public abstract class AbstractGriffonArtifact extends Object implements GriffonArtifact
| Modifier and Type | Field and Description |
|---|---|
protected GriffonApplication |
application |
| Constructor and Description |
|---|
AbstractGriffonArtifact() |
AbstractGriffonArtifact(GriffonApplication application)
Deprecated.
Griffon prefers field injection over constructor injector for artifacts as of 2.1.0
|
| Modifier and Type | Method and Description |
|---|---|
ClassLoader |
classloader()
Returns the classloader used to resolve resources.
|
<MVC extends TypedMVCGroup> |
createMVC(Class<? extends MVC> mvcType)
Instantiates an MVC group of the specified type returning only the MVC parts.
|
<MVC extends TypedMVCGroup> |
createMVC(Class<? extends MVC> mvcType,
Map<String,Object> args)
Instantiates an MVC group of the specified type with additional variables.
|
<MVC extends TypedMVCGroup> |
createMVC(Class<? extends MVC> mvcType,
String mvcId)
Instantiates an MVC group of the specified type with a particular name.
|
<MVC extends TypedMVCGroup> |
createMVC(Class<? extends MVC> mvcType,
String mvcId,
Map<String,Object> args)
Instantiates an MVC group of the specified type with a particular name.
|
<MVC extends TypedMVCGroup> |
createMVC(Map<String,Object> args,
Class<? extends MVC> mvcType)
Instantiates an MVC group of the specified type with additional variables.
|
<MVC extends TypedMVCGroup> |
createMVC(Map<String,Object> args,
Class<? extends MVC> mvcType,
String mvcId)
Instantiates an MVC group of the specified type with a particular name.
|
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.
|
<MVC extends TypedMVCGroup> |
createMVCGroup(Class<? extends MVC> mvcType)
Instantiates an MVC group of the specified type.
|
<MVC extends TypedMVCGroup> |
createMVCGroup(Class<? extends MVC> mvcType,
Map<String,Object> args)
Instantiates an MVC group of the specified type with additional variables.
|
<MVC extends TypedMVCGroup> |
createMVCGroup(Class<? extends MVC> mvcType,
String mvcId)
Instantiates an MVC group of the specified type with a particular name.
|
<MVC extends TypedMVCGroup> |
createMVCGroup(Class<? extends MVC> mvcType,
String mvcId,
Map<String,Object> args)
Instantiates an MVC group of the specified type with a particular name.
|
<MVC extends TypedMVCGroup> |
createMVCGroup(Map<String,Object> args,
Class<? extends MVC> mvcType)
Instantiates an MVC group of the specified type with additional variables.
|
<MVC extends TypedMVCGroup> |
createMVCGroup(Map<String,Object> args,
Class<? extends MVC> mvcType,
String mvcId)
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.
|
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.
|
Class<? extends GriffonArtifact> |
getTypeClass()
Returns the
Class of this artifact. |
boolean |
isUIThread()
True if the current thread is the UI thread.
|
protected String |
msg(String key)
Try to resolve the message.
|
protected String |
msg(String key,
List<?> args)
Try to resolve the message.
|
protected String |
msg(String key,
Map<String,Object> args)
Try to resolve the message.
|
protected String |
msg(String key,
Object[] args)
Try to resolve the message.
|
<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.
|
<R> R |
runInsideUISync(Callable<R> callable)
Executes a code block synchronously 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.
|
void |
runOutsideUIAsync(Runnable runnable)
Executes a code block on a background thread, always.
|
<MVC extends TypedMVCGroup,M extends GriffonModel,V extends GriffonView,C extends GriffonController> |
withMVC(Class<? extends MVC> 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.
|
<MVC extends TypedMVCGroup,M extends GriffonModel,V extends GriffonView,C extends GriffonController> |
withMVC(Class<? extends MVC> mvcType,
MVCFunction<M,V,C> handler)
Instantiates an MVC group of the specified type then destroys it after it has been handled.
|
<MVC extends TypedMVCGroup,M extends GriffonModel,V extends GriffonView,C extends GriffonController> |
withMVC(Class<? extends MVC> 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.
|
<MVC extends TypedMVCGroup,M extends GriffonModel,V extends GriffonView,C extends GriffonController> |
withMVC(Class<? extends MVC> mvcType,
String mvcId,
MVCFunction<M,V,C> handler)
Instantiates an MVC group of the specified type then destroys it after it has been handled.
|
<MVC extends TypedMVCGroup,M extends GriffonModel,V extends GriffonView,C extends GriffonController> |
withMVC(Map<String,Object> args,
Class<? extends MVC> mvcType,
MVCFunction<M,V,C> handler)
Instantiates an MVC group of the specified type then destroys it after it has been handled.
|
<MVC extends TypedMVCGroup,M extends GriffonModel,V extends GriffonView,C extends GriffonController> |
withMVC(Map<String,Object> args,
Class<? extends MVC> 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> |
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> |
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> |
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> |
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> |
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> |
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.
|
<MVC extends TypedMVCGroup> |
withMVCGroup(Class<? extends MVC> mvcType,
Map<String,Object> args,
TypedMVCGroupFunction<MVC> handler)
Instantiates an MVC group of the specified type then destroys it after it has been handled.
|
<MVC extends TypedMVCGroup> |
withMVCGroup(Class<? extends MVC> mvcType,
String mvcId,
Map<String,Object> args,
TypedMVCGroupFunction<MVC> handler)
Instantiates an MVC group of the specified type then destroys it after it has been handled.
|
<MVC extends TypedMVCGroup> |
withMVCGroup(Class<? extends MVC> mvcType,
String mvcId,
TypedMVCGroupFunction<MVC> handler)
Instantiates an MVC group of the specified type then destroys it after it has been handled.
|
<MVC extends TypedMVCGroup> |
withMVCGroup(Class<? extends MVC> mvcType,
TypedMVCGroupFunction<MVC> handler)
Instantiates an MVC group of the specified type then destroys it after it has been handled.
|
<MVC extends TypedMVCGroup> |
withMVCGroup(Map<String,Object> args,
Class<? extends MVC> mvcType,
String mvcId,
TypedMVCGroupFunction<MVC> handler)
Instantiates an MVC group of the specified type then destroys it after it has been handled.
|
<MVC extends TypedMVCGroup> |
withMVCGroup(Map<String,Object> args,
Class<? extends MVC> mvcType,
TypedMVCGroupFunction<MVC> 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.
|
@Inject protected GriffonApplication application
public AbstractGriffonArtifact()
@Inject @Deprecated public AbstractGriffonArtifact(@Nonnull GriffonApplication application)
application - the GriffonApplication that holds this artifact.@Nonnull public Class<? extends GriffonArtifact> getTypeClass()
GriffonArtifactClass of this artifact.getTypeClass in interface GriffonArtifactClass of this artifact.@Nonnull public GriffonApplication getApplication()
GriffonArtifactGriffonApplicationgetApplication in interface GriffonArtifact@Nonnull public GriffonClass getGriffonClass()
GriffonArtifactgetGriffonClass in interface GriffonArtifact@Nonnull public Logger getLog()
GriffonArtifactThe 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'.
getLog in interface GriffonArtifactpublic boolean isUIThread()
ThreadingHandlerisUIThread in interface ThreadingHandler@Nonnull public <R> Future<R> runFuture(@Nonnull ExecutorService executorService, @Nonnull Callable<R> callable)
ThreadingHandlerrunFuture in interface ThreadingHandler@Nonnull public <R> Future<R> runFuture(@Nonnull Callable<R> callable)
ThreadingHandlerrunFuture in interface ThreadingHandlerpublic void runInsideUISync(@Nonnull Runnable runnable)
ThreadingHandlerrunInsideUISync in interface ThreadingHandlerpublic void runOutsideUI(@Nonnull Runnable runnable)
ThreadingHandlerrunOutsideUI in interface ThreadingHandlerpublic void runOutsideUIAsync(@Nonnull Runnable runnable)
ThreadingHandlerrunOutsideUIAsync in interface ThreadingHandlerpublic void runInsideUIAsync(@Nonnull Runnable runnable)
ThreadingHandlerrunInsideUIAsync in interface ThreadingHandler@Nullable public <R> R runInsideUISync(@Nonnull Callable<R> callable)
ThreadingHandlerrunInsideUISync in interface ThreadingHandler@Nonnull public ClassLoader classloader()
ResourceHandlerclassloader in interface ResourceHandler@Nullable public URL getResourceAsURL(@Nonnull String name)
ResourceHandlerThe name of a resource is a '/'-separated path name that identifies the resource.
getResourceAsURL in interface ResourceHandlername - The resource name@Nullable public List<URL> getResources(@Nonnull String name)
ResourceHandlerThe name of a resource is a /-separated path name that identifies the resource.
getResources in interface ResourceHandlername - The resource nameURL 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.@Nullable public InputStream getResourceAsStream(@Nonnull String name)
ResourceHandlergetResourceAsStream in interface ResourceHandlername - The resource name@Nonnull public MVCGroup createMVCGroup(@Nonnull String mvcType)
MVCHandlerMVC 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 Config.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')
assert (fooGroup.controller instanceof FooController)
createMVCGroup in interface MVCHandlermvcType - the type of group to build.@Nonnull public MVCGroup createMVCGroup(@Nonnull String mvcType, @Nonnull String mvcId)
MVCHandlerMVC 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 Config.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.createMVCGroup in interface MVCHandlermvcType - the type of group to build.mvcId - the name to assign to the built group.@Nonnull public MVCGroup createMVCGroup(@Nonnull Map<String,Object> args, @Nonnull String mvcType)
MVCHandlerMVC 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
Config.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
createMVCGroup in interface MVCHandlerargs - 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.@Nonnull public MVCGroup createMVCGroup(@Nonnull String mvcType, @Nonnull Map<String,Object> args)
MVCHandlerMVC 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
Config.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
createMVCGroup in interface MVCHandlermvcType - 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.@Nonnull public MVCGroup createMVCGroup(@Nonnull Map<String,Object> args, @Nonnull String mvcType, @Nonnull String mvcId)
MVCHandlerMVC 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
Config.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('foo', 'foo2', model: fooGroup1.model)
assert fooGroup1.model == fooGroup2.model
MVC groups must have an unique name.createMVCGroup in interface MVCHandlerargs - 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.@Nonnull public MVCGroup createMVCGroup(@Nonnull String mvcType, @Nonnull String mvcId, @Nonnull Map<String,Object> args)
MVCHandlerMVC 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
Config.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('foo', 'foo2', model: fooGroup1.model)
assert fooGroup1.model == fooGroup2.model
MVC groups must have an unique name.createMVCGroup in interface MVCHandlermvcType - 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.@Nonnull public <MVC extends TypedMVCGroup> MVC createMVCGroup(@Nonnull Class<? extends MVC> mvcType)
MVCHandlerMVC 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 Config.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
FooMVCGroup fooGroup = createMVCGroup(FooMVCGroup) assert (fooGroup.controller instanceof FooController)
createMVCGroup in interface MVCHandlermvcType - the type of group to build.@Nonnull public <MVC extends TypedMVCGroup> MVC createMVCGroup(@Nonnull Class<? extends MVC> mvcType, @Nonnull String mvcId)
MVCHandlerMVC 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 Config.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
FooMVCGroup fooGroup = createMVCGroup(FooMVCGroup, 'foo' + System.currentTimeMillis()) assert (fooGroup.controller instanceof FooController)MVC groups must have an unique name.
createMVCGroup in interface MVCHandlermvcType - the type of group to build.mvcId - the name to assign to the built group.@Nonnull public <MVC extends TypedMVCGroup> MVC createMVCGroup(@Nonnull Map<String,Object> args, @Nonnull Class<? extends MVC> mvcType)
MVCHandlerMVC 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
Config.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:
FooMVCGroup fooGroup = createMVCGroup(FooMVCGroup) BarMVCGroup barGroup = createMVCGroup(BarMVCGroup, model: fooGroup.model) assert fooGroup.model == barGroup.model
createMVCGroup in interface MVCHandlerargs - 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.@Nonnull public <MVC extends TypedMVCGroup> MVC createMVCGroup(@Nonnull Class<? extends MVC> mvcType, @Nonnull Map<String,Object> args)
MVCHandlerMVC 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
Config.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:
FooMVCGroup fooGroup = createMVCGroup(FooMVCGroup) BarMVCGroup barGroup = createMVCGroup(BarMVCGroup, model: fooGroup.model) assert fooGroup.model == barGroup.model
createMVCGroup in interface MVCHandlermvcType - 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.@Nonnull public <MVC extends TypedMVCGroup> MVC createMVCGroup(@Nonnull Map<String,Object> args, @Nonnull Class<? extends MVC> mvcType, @Nonnull String mvcId)
MVCHandlerMVC 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
Config.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:
FooMVCGroup fooGroup1 = createMVCGroup(FooMVCGroup, 'foo1') FooMVCGroup fooGroup2 = createMVCGroup(FooMVCGroup, 'foo2', model: fooGroup1.model) assert fooGroup1.model == fooGroup2.modelMVC groups must have an unique name.
createMVCGroup in interface MVCHandlerargs - 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.@Nonnull public <MVC extends TypedMVCGroup> MVC createMVCGroup(@Nonnull Class<? extends MVC> mvcType, @Nonnull String mvcId, @Nonnull Map<String,Object> args)
MVCHandlerMVC 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
Config.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:
FooMVCGroup fooGroup1 = createMVCGroup(FooMVCGroup, 'foo1') FooMVCGroup fooGroup2 = createMVCGroup(FooMVCGroup, 'foo2', model: fooGroup1.model) assert fooGroup1.model == fooGroup2.modelMVC groups must have an unique name.
createMVCGroup in interface MVCHandlermvcType - 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.@Nonnull public List<? extends GriffonMvcArtifact> createMVC(@Nonnull String mvcType)
MVCHandlerMVC 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 Config.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)
createMVC in interface MVCHandlermvcType - the type of group to build.@Nonnull public List<? extends GriffonMvcArtifact> createMVC(@Nonnull Map<String,Object> args, @Nonnull String mvcType)
MVCHandlerMVC 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
Config.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
createMVC in interface MVCHandlerargs - 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.@Nonnull public List<? extends GriffonMvcArtifact> createMVC(@Nonnull String mvcType, @Nonnull Map<String,Object> args)
MVCHandlerMVC 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
Config.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
createMVC in interface MVCHandlermvcType - 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.@Nonnull public List<? extends GriffonMvcArtifact> createMVC(@Nonnull String mvcType, @Nonnull String mvcId)
MVCHandlerMVC 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 Config.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.createMVC in interface MVCHandlermvcType - the type of group to build.mvcId - the name to assign to the built group.@Nonnull public List<? extends GriffonMvcArtifact> createMVC(@Nonnull Map<String,Object> args, @Nonnull String mvcType, @Nonnull String mvcId)
MVCHandlerMVC 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
Config.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.createMVC in interface MVCHandlerargs - 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.@Nonnull public List<? extends GriffonMvcArtifact> createMVC(@Nonnull String mvcType, @Nonnull String mvcId, @Nonnull Map<String,Object> args)
MVCHandlerMVC 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
Config.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.createMVC in interface MVCHandlermvcType - 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.@Nonnull public <MVC extends TypedMVCGroup> List<? extends GriffonMvcArtifact> createMVC(@Nonnull Class<? extends MVC> mvcType)
MVCHandlerMVC 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 Config.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(FooMVCGroup) assert (c instanceof FooController)
createMVC in interface MVCHandlermvcType - the type of group to build.@Nonnull public <MVC extends TypedMVCGroup> List<? extends GriffonMvcArtifact> createMVC(@Nonnull Map<String,Object> args, @Nonnull Class<? extends MVC> mvcType)
MVCHandlerMVC 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
Config.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(FooMVCGroup) def (m2, v2, c2) = createMVC(BarMVCGroup, model: m1) assert fm1 == m2
createMVC in interface MVCHandlerargs - 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.@Nonnull public <MVC extends TypedMVCGroup> List<? extends GriffonMvcArtifact> createMVC(@Nonnull Class<? extends MVC> mvcType, @Nonnull Map<String,Object> args)
MVCHandlerMVC 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
Config.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(FooMVCGroup) def (m2, v2, c2) = createMVC(BarMVCGroup, model: m1) assert fm1 == m2
createMVC in interface MVCHandlermvcType - 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.@Nonnull public <MVC extends TypedMVCGroup> List<? extends GriffonMvcArtifact> createMVC(@Nonnull Class<? extends MVC> mvcType, @Nonnull String mvcId)
MVCHandlerMVC 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 Config.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(FooMVCGroup, 'foo' + System.currentTimeMillis()) assert (c instanceof FooController)MVC groups must have an unique name.
createMVC in interface MVCHandlermvcType - the type of group to build.mvcId - the name to assign to the built group.@Nonnull public <MVC extends TypedMVCGroup> List<? extends GriffonMvcArtifact> createMVC(@Nonnull Map<String,Object> args, @Nonnull Class<? extends MVC> mvcType, @Nonnull String mvcId)
MVCHandlerMVC 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
Config.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(FooMVCGroup, 'foo1') def (m2, v2, c2) = createMVC(FooMVCGroup, 'foo2', model: m1) assert fm1 == m2MVC groups must have an unique name.
createMVC in interface MVCHandlerargs - 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.@Nonnull public <MVC extends TypedMVCGroup> List<? extends GriffonMvcArtifact> createMVC(@Nonnull Class<? extends MVC> mvcType, @Nonnull String mvcId, @Nonnull Map<String,Object> args)
MVCHandlerMVC 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
Config.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(FooMVCGroup, 'foo1') def (m2, v2, c2) = createMVC(FooMVCGroup, 'foo2', model: m1) assert fm1 == m2MVC groups must have an unique name.
createMVC in interface MVCHandlermvcType - 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.public void destroyMVCGroup(@Nonnull String mvcId)
MVCHandlerATTENTION: make sure to call the super implementation if you override this method otherwise group references will not be kept up to date.
destroyMVCGroup in interface MVCHandlermvcId - the name of the group to destroy and dispose.public <M extends GriffonModel,V extends GriffonView,C extends GriffonController> void withMVC(@Nonnull String mvcType, @Nonnull MVCFunction<M,V,C> handler)
MVCHandler
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 inConfig.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 MVCFunction<FooModel, FooView, FooController>() {
public void call(FooModel m, FooView v, FooController c) {
m.setSomeProperty(someValue);
c.invokeAnAction();
}
});
withMVC in interface MVCHandlermvcType - the type of group to build.handler - a code block used to configure and manage the instantiated grouppublic <M extends GriffonModel,V extends GriffonView,C extends GriffonController> void withMVC(@Nonnull String mvcType, @Nonnull String mvcId, @Nonnull MVCFunction<M,V,C> handler)
MVCHandler
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 inConfig.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 MVCFunction<FooModel, FooView, FooController>() {
public void call(FooModel m, FooView v, FooController c) {
m.setSomeProperty(someValue);
c.invokeAnAction();
}
});
MVC groups must have an unique name.withMVC in interface MVCHandlermvcType - 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 grouppublic <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)
MVCHandler
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 scenariosConfig.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