This is an automated email from the ASF dual-hosted git repository.
ntimofeev pushed a commit to branch STABLE-4.1
in repository https://gitbox.apache.org/repos/asf/cayenne.git
commit 3ad81a8f0fe77b64b95029fe77942f8d50e9dc9c
Author: Nikita Timofeev <stari...@gmail.com>
AuthorDate: Wed Feb 24 13:24:42 2021 +0300
CAY-2677 Custom Class Generation Templates for Embeddables and DataMaps
applying patch from Stefan S, see JIRA issue
---
.../org/apache/cayenne/gen/CgenConfiguration.java | 6 ++
.../apache/cayenne/gen/xml/CgenConfigHandler.java | 43 ++++++++++
.../cayenne/modeler/CodeTemplateManager.java | 92 +++++++++++++--------
.../modeler/editor/cgen/CustomModeController.java | 75 +++++++++++++++++
.../modeler/editor/cgen/CustomModePanel.java | 93 +++++++++++++++++++++-
5 files changed, 274 insertions(+), 35 deletions(-)
diff --git
a/cayenne-cgen/src/main/java/org/apache/cayenne/gen/CgenConfiguration.java
b/cayenne-cgen/src/main/java/org/apache/cayenne/gen/CgenConfiguration.java
index 2f6e2e4..eb2c822 100644
--- a/cayenne-cgen/src/main/java/org/apache/cayenne/gen/CgenConfiguration.java
+++ b/cayenne-cgen/src/main/java/org/apache/cayenne/gen/CgenConfiguration.java
@@ -396,6 +396,12 @@ public class CgenConfiguration implements Serializable,
XMLSerializable {
.simpleTag("mode", this.artifactsGenerationMode.getLabel())
.simpleTag("template", this.template)
.simpleTag("superTemplate", this.superTemplate)
+ .simpleTag("template", this.template)
+ .simpleTag("superTemplate", this.superTemplate)
+ .simpleTag("embeddableTemplate", this.embeddableTemplate)
+ .simpleTag("embeddableSuperTemplate",
this.embeddableSuperTemplate)
+ .simpleTag("queryTemplate", this.queryTemplate)
+ .simpleTag("querySuperTemplate", this.querySuperTemplate)
.simpleTag("outputPattern", this.outputPattern)
.simpleTag("makePairs", Boolean.toString(this.makePairs))
.simpleTag("usePkgPath", Boolean.toString(this.usePkgPath))
diff --git
a/cayenne-cgen/src/main/java/org/apache/cayenne/gen/xml/CgenConfigHandler.java
b/cayenne-cgen/src/main/java/org/apache/cayenne/gen/xml/CgenConfigHandler.java
index 6a80f91..0a41a04 100644
---
a/cayenne-cgen/src/main/java/org/apache/cayenne/gen/xml/CgenConfigHandler.java
+++
b/cayenne-cgen/src/main/java/org/apache/cayenne/gen/xml/CgenConfigHandler.java
@@ -43,6 +43,10 @@ public class CgenConfigHandler extends
NamespaceAwareNestedTagHandler{
private static final String GENERATION_MODE_TAG = "mode";
private static final String SUBCLASS_TEMPLATE_TAG = "template";
private static final String SUPERCLASS_TEMPLATE_TAG = "superTemplate";
+ private static final String EMBEDDABLE_TEMPLATE_TAG = "embeddableTemplate";
+ private static final String EMBEDDABLE_SUPER_TEMPLATE_TAG =
"embeddableSuperTemplate";
+ private static final String QUERY_TEMPLATE_TAG = "queryTemplate";
+ private static final String QUERY_SUPER_TEMPLATE_TAG =
"querySuperTemplate";
private static final String OUTPUT_PATTERN_TAG = "outputPattern";
private static final String MAKE_PAIRS_TAG = "makePairs";
private static final String USE_PKG_PATH_TAG = "usePkgPath";
@@ -97,6 +101,17 @@ public class CgenConfigHandler extends
NamespaceAwareNestedTagHandler{
case SUPERCLASS_TEMPLATE_TAG:
createSuperclassTemplate(data);
break;
+ case EMBEDDABLE_TEMPLATE_TAG:
+ createEmbeddableTemplate(data);
+ break;
+ case EMBEDDABLE_SUPER_TEMPLATE_TAG:
+ createEmbeddableSuperTemplate(data);
+ case QUERY_TEMPLATE_TAG:
+ createQueryTemplate(data);
+ break;
+ case QUERY_SUPER_TEMPLATE_TAG:
+ createQuerySuperTemplate(data);
+ break;
case OUTPUT_PATTERN_TAG:
createOutputPattern(data);
break;
@@ -165,6 +180,34 @@ public class CgenConfigHandler extends
NamespaceAwareNestedTagHandler{
}
configuration.setSuperTemplate(template);
}
+
+ private void createEmbeddableTemplate(String template) {
+ if(template.trim().length() == 0) {
+ return;
+ }
+ configuration.setEmbeddableTemplate(template);
+ }
+
+ private void createEmbeddableSuperTemplate(String template) {
+ if(template.trim().length() == 0) {
+ return;
+ }
+ configuration.setEmbeddableSuperTemplate(template);
+ }
+
+ private void createQueryTemplate(String template) {
+ if(template.trim().length() == 0) {
+ return;
+ }
+ configuration.setQueryTemplate(template);
+ }
+
+ private void createQuerySuperTemplate(String template) {
+ if(template.trim().length() == 0) {
+ return;
+ }
+ configuration.setQuerySuperTemplate(template);
+ }
private void createOutputPattern(String pattern) {
if(pattern.trim().length() == 0) {
diff --git
a/modeler/cayenne-modeler/src/main/java/org/apache/cayenne/modeler/CodeTemplateManager.java
b/modeler/cayenne-modeler/src/main/java/org/apache/cayenne/modeler/CodeTemplateManager.java
index f9f6108..09ea39a 100644
---
a/modeler/cayenne-modeler/src/main/java/org/apache/cayenne/modeler/CodeTemplateManager.java
+++
b/modeler/cayenne-modeler/src/main/java/org/apache/cayenne/modeler/CodeTemplateManager.java
@@ -43,17 +43,19 @@ public class CodeTemplateManager {
public static final String STANDARD_SERVER_SUPERCLASS = "Standard
Server Superclass";
public static final String STANDARD_SERVER_SUBCLASS = "Standard Server
Subclass";
- public static final String SINGLE_SERVER_CLASS = "Single Server class";
+ public static final String SINGLE_SERVER_CLASS = "Single Server Class";
static final String STANDARD_CLIENT_SUPERCLASS = "Standard Client
Superclass";
static final String STANDARD_CLIENT_SUBCLASS = "Standard Client
Subclass";
- private static final String STANDART_EMBEDDABLE_SUPERCLASS = "Standart
Embeddable Superclass";
- private static final String STANDART_EMBEDDABLE_SUBCLASS = "Standart
Embeddable Subclass";
- private static final String SINGLE_EMBEDDABLE_CLASS = "Single
Embeddable class";
+ private static final String STANDARD_EMBEDDABLE_SUPERCLASS = "Standard
Embeddable Superclass";
+ private static final String STANDARD_EMBEDDABLE_SUBCLASS = "Standard
Embeddable Subclass";
+ private static final String SINGLE_EMBEDDABLE_CLASS = "Single
Embeddable Class";
- private static final String STANDART_DATAMAP_SUPERCLASS = "Standart
DataMap Superclass";
- private static final String STANDART_DATAMAP_SUBCLASS = "Standart
DataMap Subclass";
- private static final String SINGLE_DATAMAP_CLASS = "Single DataMap
class";
+ private static final String STANDARD_SERVER_DATAMAP_SUPERCLASS =
"Standard Server DataMap Superclass";
+ private static final String STANDARD_SERVER_DATAMAP_SUBCLASS =
"Standard Server DataMap Subclass";
+ private static final String STANDARD_CLIENT_DATAMAP_SUPERCLASS =
"Standard Client DataMap Superclass";
+ private static final String STANDARD_CLIENT_DATAMAP_SUBCLASS =
"Standard Client DataMap Subclass";
+ private static final String SINGLE_DATAMAP_CLASS = "Single DataMap
Class";
public static final String NODE_NAME = "codeTemplateManager";
@@ -65,11 +67,13 @@ public class CodeTemplateManager {
private Map<String, String> reverseCustomTemplate;
private Map<String, String> standardTemplates;
- private List<String> standartEmbeddableTemplates;
- private List<String> standartEmbeddableSuperclassTemplates;
+ private List<String> standardEmbeddableTemplates;
+ private List<String> standardEmbeddableSuperclassTemplates;
- private List<String> standartDataMapTemplates;
- private List<String> standartDataMapSuperclassTemplates;
+ private List<String> standardServerDataMapTemplates;
+ private List<String> standardServerDataMapSuperclassTemplates;
+ private List<String> standardClientDataMapTemplates;
+ private List<String> standardClientDataMapSuperclassTemplates;
private Map<String, String> reverseStandartTemplates;
@@ -93,19 +97,25 @@ public class CodeTemplateManager {
standardClientSubclassTemplates = new ArrayList<>();
standardClientSubclassTemplates.add(STANDARD_CLIENT_SUBCLASS);
- standartEmbeddableTemplates = new ArrayList<>();
- standartEmbeddableTemplates.add(SINGLE_EMBEDDABLE_CLASS);
- standartEmbeddableTemplates.add(STANDART_EMBEDDABLE_SUBCLASS);
+ standardEmbeddableTemplates = new ArrayList<>();
+ standardEmbeddableTemplates.add(STANDARD_EMBEDDABLE_SUBCLASS);
+ standardEmbeddableTemplates.add(SINGLE_EMBEDDABLE_CLASS);
- standartEmbeddableSuperclassTemplates = new ArrayList<>();
-
standartEmbeddableSuperclassTemplates.add(STANDART_EMBEDDABLE_SUPERCLASS);
+ standardEmbeddableSuperclassTemplates = new ArrayList<>();
+
standardEmbeddableSuperclassTemplates.add(STANDARD_EMBEDDABLE_SUPERCLASS);
- standartDataMapTemplates = new ArrayList<>();
- standartDataMapTemplates.add(STANDART_DATAMAP_SUBCLASS);
- standartDataMapTemplates.add(SINGLE_DATAMAP_CLASS);
+ standardServerDataMapTemplates = new ArrayList<>();
+
standardServerDataMapTemplates.add(STANDARD_SERVER_DATAMAP_SUBCLASS);
+ standardServerDataMapTemplates.add(SINGLE_DATAMAP_CLASS);
- standartDataMapSuperclassTemplates = new ArrayList<>();
-
standartDataMapSuperclassTemplates.add(STANDART_DATAMAP_SUPERCLASS);
+ standardServerDataMapSuperclassTemplates = new ArrayList<>();
+
standardServerDataMapSuperclassTemplates.add(STANDARD_SERVER_DATAMAP_SUPERCLASS);
+
+ standardClientDataMapTemplates = new ArrayList<>();
+
standardClientDataMapTemplates.add(STANDARD_CLIENT_DATAMAP_SUBCLASS);
+
+ standardClientDataMapSuperclassTemplates = new ArrayList<>();
+
standardClientDataMapSuperclassTemplates.add(STANDARD_CLIENT_DATAMAP_SUPERCLASS);
updateCustomTemplates(getTemplatePreferences(application));
reverseCustomTemplate = new HashMap<>();
@@ -120,13 +130,15 @@ public class CodeTemplateManager {
standardTemplates.put(STANDARD_CLIENT_SUBCLASS,
ClientClassGenerationAction.SUBCLASS_TEMPLATE);
standardTemplates.put(SINGLE_SERVER_CLASS,
ClassGenerationAction.SINGLE_CLASS_TEMPLATE);
- standardTemplates.put(STANDART_EMBEDDABLE_SUPERCLASS,
ClassGenerationAction.EMBEDDABLE_SUPERCLASS_TEMPLATE);
- standardTemplates.put(STANDART_EMBEDDABLE_SUBCLASS,
ClassGenerationAction.EMBEDDABLE_SUBCLASS_TEMPLATE);
+ standardTemplates.put(STANDARD_EMBEDDABLE_SUPERCLASS,
ClassGenerationAction.EMBEDDABLE_SUPERCLASS_TEMPLATE);
+ standardTemplates.put(STANDARD_EMBEDDABLE_SUBCLASS,
ClassGenerationAction.EMBEDDABLE_SUBCLASS_TEMPLATE);
standardTemplates.put(SINGLE_EMBEDDABLE_CLASS,
ClassGenerationAction.EMBEDDABLE_SINGLE_CLASS_TEMPLATE);
- standardTemplates.put(STANDART_DATAMAP_SUBCLASS,
ClassGenerationAction.DATAMAP_SUBCLASS_TEMPLATE);
+ standardTemplates.put(STANDARD_SERVER_DATAMAP_SUBCLASS,
ClassGenerationAction.DATAMAP_SUBCLASS_TEMPLATE);
+ standardTemplates.put(STANDARD_CLIENT_DATAMAP_SUBCLASS,
ClientClassGenerationAction.DMAP_SUBCLASS_TEMPLATE);
standardTemplates.put(SINGLE_DATAMAP_CLASS,
ClassGenerationAction.DATAMAP_SINGLE_CLASS_TEMPLATE);
- standardTemplates.put(STANDART_DATAMAP_SUPERCLASS,
ClassGenerationAction.DATAMAP_SUPERCLASS_TEMPLATE);
+ standardTemplates.put(STANDARD_SERVER_DATAMAP_SUPERCLASS,
ClassGenerationAction.DATAMAP_SUPERCLASS_TEMPLATE);
+ standardTemplates.put(STANDARD_CLIENT_DATAMAP_SUPERCLASS,
ClientClassGenerationAction.DMAP_SUPERCLASS_TEMPLATE);
reverseStandartTemplates = new HashMap<>();
reverseStandartTemplates.put(ClassGenerationAction.SUBCLASS_TEMPLATE,
STANDARD_SERVER_SUBCLASS);
@@ -135,13 +147,15 @@ public class CodeTemplateManager {
reverseStandartTemplates.put(ClientClassGenerationAction.SUPERCLASS_TEMPLATE,
STANDARD_CLIENT_SUPERCLASS);
reverseStandartTemplates.put(ClassGenerationAction.SUPERCLASS_TEMPLATE,
STANDARD_SERVER_SUPERCLASS);
-
reverseStandartTemplates.put(ClassGenerationAction.EMBEDDABLE_SUPERCLASS_TEMPLATE,
STANDART_EMBEDDABLE_SUPERCLASS);
-
reverseStandartTemplates.put(ClassGenerationAction.EMBEDDABLE_SUBCLASS_TEMPLATE,
STANDART_EMBEDDABLE_SUBCLASS);
+
reverseStandartTemplates.put(ClassGenerationAction.EMBEDDABLE_SUPERCLASS_TEMPLATE,
STANDARD_EMBEDDABLE_SUPERCLASS);
+
reverseStandartTemplates.put(ClassGenerationAction.EMBEDDABLE_SUBCLASS_TEMPLATE,
STANDARD_EMBEDDABLE_SUBCLASS);
reverseStandartTemplates.put(ClassGenerationAction.EMBEDDABLE_SINGLE_CLASS_TEMPLATE,
SINGLE_EMBEDDABLE_CLASS);
-
reverseStandartTemplates.put(ClassGenerationAction.DATAMAP_SUBCLASS_TEMPLATE,
STANDART_DATAMAP_SUBCLASS);
+
reverseStandartTemplates.put(ClassGenerationAction.DATAMAP_SUBCLASS_TEMPLATE,
STANDARD_SERVER_DATAMAP_SUBCLASS);
+
reverseStandartTemplates.put(ClientClassGenerationAction.DMAP_SUBCLASS_TEMPLATE,
STANDARD_CLIENT_DATAMAP_SUBCLASS);
reverseStandartTemplates.put(ClassGenerationAction.DATAMAP_SINGLE_CLASS_TEMPLATE,
SINGLE_DATAMAP_CLASS);
-
reverseStandartTemplates.put(ClassGenerationAction.DATAMAP_SUPERCLASS_TEMPLATE,
STANDART_DATAMAP_SUPERCLASS);
+
reverseStandartTemplates.put(ClassGenerationAction.DATAMAP_SUPERCLASS_TEMPLATE,
STANDARD_SERVER_DATAMAP_SUPERCLASS);
+
reverseStandartTemplates.put(ClientClassGenerationAction.DMAP_SUPERCLASS_TEMPLATE,
STANDARD_CLIENT_DATAMAP_SUPERCLASS);
}
/**
@@ -212,14 +226,26 @@ public class CodeTemplateManager {
}
public List<String> getStandartEmbeddableTemplates() {
- return standartEmbeddableTemplates;
+ return standardEmbeddableTemplates;
}
public List<String> getStandartEmbeddableSuperclassTemplates() {
- return standartEmbeddableSuperclassTemplates;
+ return standardEmbeddableSuperclassTemplates;
}
- public List<String> getStandartDataMapTemplates() { return
standartDataMapTemplates; }
+ public List<String> getStandartDataMapTemplates() {
+ return standardServerDataMapTemplates;
+ }
- public List<String> getStandartDataMapSuperclassTemplates() { return
standartDataMapSuperclassTemplates; }
+ public List<String> getStandartDataMapSuperclassTemplates() {
+ return standardServerDataMapSuperclassTemplates;
+ }
+
+ public List<String> getStandardClientDataMapTemplates() {
+ return standardClientDataMapTemplates;
+ }
+
+ public List<String> getStandardClientDataMapSuperclassTemplates() {
+ return standardClientDataMapSuperclassTemplates;
+ }
}
diff --git
a/modeler/cayenne-modeler/src/main/java/org/apache/cayenne/modeler/editor/cgen/CustomModeController.java
b/modeler/cayenne-modeler/src/main/java/org/apache/cayenne/modeler/editor/cgen/CustomModeController.java
index 46f8f33..7dfc013 100644
---
a/modeler/cayenne-modeler/src/main/java/org/apache/cayenne/modeler/editor/cgen/CustomModeController.java
+++
b/modeler/cayenne-modeler/src/main/java/org/apache/cayenne/modeler/editor/cgen/CustomModeController.java
@@ -79,8 +79,32 @@ public class CustomModeController extends
GeneratorController {
Collections.sort(subTemplates);
subTemplates.addAll(customTemplates);
+ List<String> querySuperTemplates = isClient ?
+ new
ArrayList<>(templateManager.getStandardClientDataMapSuperclassTemplates()) :
+ new
ArrayList<>(templateManager.getStandartDataMapSuperclassTemplates());
+ Collections.sort(querySuperTemplates);
+ querySuperTemplates.addAll(customTemplates);
+
+ List<String> queryTemplates = isClient ?
+ new
ArrayList<>(templateManager.getStandardClientDataMapTemplates()) :
+ new ArrayList<>(templateManager.getStandartDataMapTemplates());
+ Collections.sort(queryTemplates);
+ queryTemplates.addAll(customTemplates);
+
+ List<String> embeddableSuperTemplates = new
ArrayList<>(templateManager.getStandartEmbeddableSuperclassTemplates());
+ Collections.sort(embeddableSuperTemplates);
+ embeddableSuperTemplates.addAll(customTemplates);
+
+ List<String> embeddableTemplates = new
ArrayList<>(templateManager.getStandartEmbeddableTemplates());
+ Collections.sort(embeddableTemplates);
+ embeddableTemplates.addAll(customTemplates);
+
this.view.getSubclassTemplate().getComboBox().setModel(new
DefaultComboBoxModel<>(subTemplates.toArray(new String[0])));
this.view.getSuperclassTemplate().getComboBox().setModel(new
DefaultComboBoxModel<>(superTemplates.toArray(new String[0])));
+ this.view.getQueryTemplate().getComboBox().setModel(new
DefaultComboBoxModel<>(queryTemplates.toArray(new String[0])));
+ this.view.getQuerySuperTemplate().getComboBox().setModel(new
DefaultComboBoxModel<>(querySuperTemplates.toArray(new String[0])));
+ this.view.getEmbeddableTemplate().getComboBox().setModel(new
DefaultComboBoxModel<>(embeddableTemplates.toArray(new String[0])));
+ this.view.getEmbeddableSuperTemplate().getComboBox().setModel(new
DefaultComboBoxModel<>(embeddableSuperTemplates.toArray(new String[0])));
}
public Component getView() {
@@ -108,8 +132,22 @@ public class CustomModeController extends
GeneratorController {
cgenConfiguration.getTemplate(),
cgenConfiguration.getRootPath());
String superTemplateName =
getApplication().getCodeTemplateManager().getNameByPath(
cgenConfiguration.getSuperTemplate(),
cgenConfiguration.getRootPath());
+ String embeddableTemplateName =
getApplication().getCodeTemplateManager().getNameByPath(
+ cgenConfiguration.getEmbeddableTemplate(),
cgenConfiguration.getRootPath());
+ String embeddableSuperTemplateName =
getApplication().getCodeTemplateManager().getNameByPath(
+ cgenConfiguration.getEmbeddableSuperTemplate(),
cgenConfiguration.getRootPath());
+ String queryTemplateName =
getApplication().getCodeTemplateManager().getNameByPath(
+ cgenConfiguration.getQueryTemplate(),
cgenConfiguration.getRootPath());
+ String querySuperTemplateName =
getApplication().getCodeTemplateManager().getNameByPath(
+ cgenConfiguration.getQuerySuperTemplate(),
cgenConfiguration.getRootPath());
+
String path =
cgenConfiguration.getRootPath().resolve(Paths.get(cgenConfiguration.getTemplate())).normalize().toString();
String superPath =
cgenConfiguration.getRootPath().resolve(Paths.get(cgenConfiguration.getSuperTemplate())).normalize().toString();
+ String embeddableTemplatePath =
cgenConfiguration.getRootPath().resolve(Paths.get(cgenConfiguration.getEmbeddableTemplate())).normalize().toString();
+ String embeddableSuperTemplatePath =
cgenConfiguration.getRootPath().resolve(Paths.get(cgenConfiguration.getEmbeddableSuperTemplate())).normalize().toString();
+ String queryTemplatePath =
cgenConfiguration.getRootPath().resolve(Paths.get(cgenConfiguration.getQueryTemplate())).normalize().toString();
+ String querySuperTemplatePath =
cgenConfiguration.getRootPath().resolve(Paths.get(cgenConfiguration.getQuerySuperTemplate())).normalize().toString();
+
if(templateName == null && superTemplateName == null) {
view.getSubclassTemplate().setItem(null);
view.getSuperclassTemplate().setItem(null);
@@ -124,6 +162,27 @@ public class CustomModeController extends
GeneratorController {
view.getSubclassTemplate().setItem(templateName);
view.getSuperclassTemplate().setItem(superTemplateName);
}
+
+ if(embeddableTemplateName == null && embeddableSuperTemplateName ==
null) {
+ missTemplateDialog(cgenConfiguration, embeddableTemplatePath,
embeddableSuperTemplatePath);
+ } else if(embeddableTemplateName == null) {
+ missTemplateDialog(cgenConfiguration, embeddableTemplatePath,
null);
+ } else if(embeddableSuperTemplateName == null) {
+ missTemplateDialog(cgenConfiguration, null,
embeddableSuperTemplatePath);
+ }
+ view.getEmbeddableTemplate().setItem(embeddableTemplateName);
+ view.getEmbeddableSuperTemplate().setItem(embeddableSuperTemplateName);
+
+ if(queryTemplateName == null && querySuperTemplateName == null) {
+ missTemplateDialog(cgenConfiguration, queryTemplatePath,
querySuperTemplatePath);
+ } else if(queryTemplateName == null) {
+ missTemplateDialog(cgenConfiguration, queryTemplatePath, null);
+ } else if(querySuperTemplateName == null) {
+ missTemplateDialog(cgenConfiguration, null,
querySuperTemplatePath);
+ }
+ view.getQueryTemplate().setItem(queryTemplateName);
+ view.getQuerySuperTemplate().setItem(querySuperTemplateName);
+
view.setDisableSuperComboBoxes(view.getPairs().isSelected());
}
@@ -179,9 +238,13 @@ public class CustomModeController extends
GeneratorController {
if(isSelected) {
cgenConfiguration.setTemplate(ClientClassGenerationAction.SUBCLASS_TEMPLATE);
cgenConfiguration.setSuperTemplate(ClientClassGenerationAction.SUPERCLASS_TEMPLATE);
+
cgenConfiguration.setQueryTemplate(ClientClassGenerationAction.DMAP_SUBCLASS_TEMPLATE);
+
cgenConfiguration.setQuerySuperTemplate(ClientClassGenerationAction.DMAP_SUPERCLASS_TEMPLATE);
} else {
cgenConfiguration.setTemplate(ClassGenerationAction.SUBCLASS_TEMPLATE);
cgenConfiguration.setSuperTemplate(ClassGenerationAction.SUPERCLASS_TEMPLATE);
+
cgenConfiguration.setQueryTemplate(ClassGenerationAction.DATAMAP_SUBCLASS_TEMPLATE);
+
cgenConfiguration.setQuerySuperTemplate(ClassGenerationAction.DATAMAP_SUPERCLASS_TEMPLATE);
}
updateTemplates();
String templateName =
getApplication().getCodeTemplateManager().getNameByPath(
@@ -194,8 +257,20 @@ public class CustomModeController extends
GeneratorController {
ClientClassGenerationAction.SUBCLASS_TEMPLATE :
ClassGenerationAction.SUBCLASS_TEMPLATE,
cgenConfiguration.getRootPath());
+ String queryTemplateName =
getApplication().getCodeTemplateManager().getNameByPath(
+ isSelected ?
+
ClientClassGenerationAction.DMAP_SUBCLASS_TEMPLATE :
+
ClassGenerationAction.DATAMAP_SUBCLASS_TEMPLATE,
+
cgenConfiguration.getRootPath());
+ String querySuperTemplateName =
getApplication().getCodeTemplateManager().getNameByPath(
+ isSelected ?
+
ClientClassGenerationAction.DMAP_SUPERCLASS_TEMPLATE :
+
ClassGenerationAction.DATAMAP_SUPERCLASS_TEMPLATE,
+
cgenConfiguration.getRootPath());
view.getSubclassTemplate().setItem(templateName);
view.getSuperclassTemplate().setItem(superTemplateName);
+ view.getQueryTemplate().setItem(queryTemplateName);
+ view.getQuerySuperTemplate().setItem(querySuperTemplateName);
if(!getParentController().isInitFromModel()) {
getParentController().getProjectController().setDirty(true);
}
diff --git
a/modeler/cayenne-modeler/src/main/java/org/apache/cayenne/modeler/editor/cgen/CustomModePanel.java
b/modeler/cayenne-modeler/src/main/java/org/apache/cayenne/modeler/editor/cgen/CustomModePanel.java
index 7bb7912..cada7f9 100644
---
a/modeler/cayenne-modeler/src/main/java/org/apache/cayenne/modeler/editor/cgen/CustomModePanel.java
+++
b/modeler/cayenne-modeler/src/main/java/org/apache/cayenne/modeler/editor/cgen/CustomModePanel.java
@@ -44,6 +44,10 @@ public class CustomModePanel extends
GeneratorControllerPanel {
private ComboBoxAdapter<String> subclassTemplate;
private ComboBoxAdapter<String> superclassTemplate;
+ private ComboBoxAdapter<String> embeddableTemplate;
+ private ComboBoxAdapter<String> embeddableSuperTemplate;
+ private ComboBoxAdapter<String> queryTemplate;
+ private ComboBoxAdapter<String> querySuperTemplate;
private JCheckBox pairs;
private JCheckBox overwrite;
private JCheckBox usePackagePath;
@@ -57,6 +61,7 @@ public class CustomModePanel extends GeneratorControllerPanel
{
CustomModePanel(ProjectController projectController,
CodeGeneratorControllerBase codeGeneratorControllerBase) {
super(projectController, codeGeneratorControllerBase);
+
JComboBox<String> superclassField = new JComboBox<>();
this.superclassTemplate = new ComboBoxAdapter<String>(superclassField)
{
@Override
@@ -82,6 +87,58 @@ public class CustomModePanel extends
GeneratorControllerPanel {
}
}
};
+
+ JComboBox<String> embeddableField = new JComboBox<>();
+ this.embeddableTemplate = new ComboBoxAdapter<String>(embeddableField)
{
+ @Override
+ protected void updateModel(String item) throws
ValidationException {
+ CgenConfiguration cgenConfiguration =
getCgenByDataMap();
+
cgenConfiguration.setEmbeddableTemplate(Application.getInstance().getCodeTemplateManager().getTemplatePath(item,
+
cgenConfiguration.getDataMap().getConfigurationSource()));
+ if(!codeGeneratorControllerBase.isInitFromModel()) {
+ projectController.setDirty(true);
+ }
+ }
+ };
+
+ JComboBox<String> embeddableSuperField = new JComboBox<>();
+ this.embeddableSuperTemplate = new
ComboBoxAdapter<String>(embeddableSuperField) {
+ @Override
+ protected void updateModel(String item) throws
ValidationException {
+ CgenConfiguration cgenConfiguration =
getCgenByDataMap();
+
cgenConfiguration.setEmbeddableSuperTemplate(Application.getInstance().getCodeTemplateManager().getTemplatePath(item,
+
cgenConfiguration.getDataMap().getConfigurationSource()));
+ if(!codeGeneratorControllerBase.isInitFromModel()) {
+ projectController.setDirty(true);
+ }
+ }
+ };
+
+ JComboBox<String> queryField = new JComboBox<>();
+ this.queryTemplate = new ComboBoxAdapter<String>(queryField) {
+ @Override
+ protected void updateModel(String item) throws
ValidationException {
+ CgenConfiguration cgenConfiguration =
getCgenByDataMap();
+
cgenConfiguration.setQueryTemplate(Application.getInstance().getCodeTemplateManager().getTemplatePath(item,
+
cgenConfiguration.getDataMap().getConfigurationSource()));
+ if(!codeGeneratorControllerBase.isInitFromModel()) {
+ projectController.setDirty(true);
+ }
+ }
+ };
+
+ JComboBox<String> querySuperField = new JComboBox<>();
+ this.querySuperTemplate = new ComboBoxAdapter<String>(querySuperField)
{
+ @Override
+ protected void updateModel(String item) throws
ValidationException {
+ CgenConfiguration cgenConfiguration =
getCgenByDataMap();
+
cgenConfiguration.setQuerySuperTemplate(Application.getInstance().getCodeTemplateManager().getTemplatePath(item,
+
cgenConfiguration.getDataMap().getConfigurationSource()));
+ if(!codeGeneratorControllerBase.isInitFromModel()) {
+ projectController.setDirty(true);
+ }
+ }
+ };
this.pairs = new JCayenneCheckBox();
this.overwrite = new JCayenneCheckBox();
@@ -121,7 +178,7 @@ public class CustomModePanel extends
GeneratorControllerPanel {
// assemble
FormLayout layout = new FormLayout(
- "right:74dlu, 1dlu, fill:240:grow, 1dlu, left:100dlu, 100dlu",
"");
+ "right:105dlu, 1dlu, fill:240:grow, 1dlu, left:100dlu,
100dlu", "");
DefaultFormBuilder builder = new DefaultFormBuilder(layout);
builder.setDefaultDialogBorder();
@@ -133,6 +190,18 @@ public class CustomModePanel extends
GeneratorControllerPanel {
builder.append("Superclass Template:",
superclassTemplate.getComboBox());
builder.nextLine();
+
+ builder.append("Embeddable Template:",
embeddableTemplate.getComboBox());
+ builder.nextLine();
+
+ builder.append("Embeddable Superclass Template:",
embeddableSuperTemplate.getComboBox());
+ builder.nextLine();
+
+ builder.append("DataMap Template:", queryTemplate.getComboBox());
+ builder.nextLine();
+
+ builder.append("DataMap Superclass Template:",
querySuperTemplate.getComboBox());
+ builder.nextLine();
builder.append("Output Pattern:", outputPattern.getComponent());
builder.nextLine();
@@ -167,17 +236,37 @@ public class CustomModePanel extends
GeneratorControllerPanel {
public void setDisableSuperComboBoxes(boolean val){
superclassTemplate.getComboBox().setEnabled(val);
+ embeddableSuperTemplate.getComboBox().setEnabled(val);
+ querySuperTemplate.getComboBox().setEnabled(val);
}
public JButton getManageTemplatesLink() {
return manageTemplatesLink;
}
- public ComboBoxAdapter<String> getSubclassTemplate() { return
subclassTemplate; }
+ public ComboBoxAdapter<String> getSubclassTemplate() {
+ return subclassTemplate;
+ }
public ComboBoxAdapter<String> getSuperclassTemplate() {
return superclassTemplate;
}
+
+ public ComboBoxAdapter<String> getEmbeddableTemplate() {
+ return embeddableTemplate;
+ }
+
+ public ComboBoxAdapter<String> getEmbeddableSuperTemplate() {
+ return embeddableSuperTemplate;
+ }
+
+ public ComboBoxAdapter<String> getQueryTemplate() {
+ return queryTemplate;
+ }
+
+ public ComboBoxAdapter<String> getQuerySuperTemplate() {
+ return querySuperTemplate;
+ }
public JCheckBox getOverwrite() {
return overwrite;
