Attachment #226268 for bug #399380

Some Eclipse Foundation services are deprecated, or will be soon. Please ensure you've read this important communication.

View | Details | Raw Unified | Return to bug 399380
Collapse All | Expand All

Lines 20-28 Link Here

(-)src/org/eclipse/scout/rt/extension/client/Replace.java (+3 lines)
20	* the first object is removed which type is the annotated class's super class.	20	* the first object is removed which type is the annotated class's super class.
21	*	21	*
22	* @since 3.9.0	22	* @since 3.9.0
		23	* @deprecated Do not use this class any more. It has been replaced by
		24	* {@link org.eclipse.scout.commons.annotations.Replace}.
23	*/	25	*/
24	@Retention(RetentionPolicy.RUNTIME)	26	@Retention(RetentionPolicy.RUNTIME)
25	@Target(ElementType.TYPE)	27	@Target(ElementType.TYPE)
		28	@Deprecated
26	public @interface Replace {	29	public @interface Replace {
27		30
28	/**	31	/**

Lines 23-28 Link Here

(-)src/org/eclipse/scout/rt/extension/client/ExtensionUtility.java (+9 lines)
23	import org.eclipse.scout.commons.BeanUtility;	23	import org.eclipse.scout.commons.BeanUtility;
24	import org.eclipse.scout.commons.CompareUtility;	24	import org.eclipse.scout.commons.CompareUtility;
25	import org.eclipse.scout.commons.CompositeObject;	25	import org.eclipse.scout.commons.CompositeObject;
		26	import org.eclipse.scout.commons.ConfigurationUtility;
26	import org.eclipse.scout.commons.TypeCastUtility;	27	import org.eclipse.scout.commons.TypeCastUtility;
27	import org.eclipse.scout.commons.logger.IScoutLogger;	28	import org.eclipse.scout.commons.logger.IScoutLogger;
28	import org.eclipse.scout.commons.logger.ScoutLogManager;	29	import org.eclipse.scout.commons.logger.ScoutLogManager;
Lines 63-69 Link Here
63	/**	64	/**
64	* Removes those objects of the given list that match any {@link Replace} annotation on other elements being part of	65	* Removes those objects of the given list that match any {@link Replace} annotation on other elements being part of
65	* the same list.	66	* the same list.
		67	*
		68	* @deprecated The {@link Replace} annotation this method works for has been replaced by
		69	* {@link org.eclipse.scout.commons.annotations.Replace}. The corresponding methods for this one are
		70	* {@link ConfigurationUtility#removeReplacedClasses(Class[])},
		71	* {@link ConfigurationUtility#getReplacementMapping(Class[])} and
		72	* {@link ConfigurationUtility#getReplacingLeafClasses(Class[])}.
66	*/	73	*/
		74	@Deprecated
		75	@SuppressWarnings("deprecation")
67	public static <T> Map<T, T> processReplaceAnnotations(List<T> list) {	76	public static <T> Map<T, T> processReplaceAnnotations(List<T> list) {
68	if (list == null \|\| list.isEmpty()) {	77	if (list == null \|\| list.isEmpty()) {
69	return Collections.emptyMap();	78	return Collections.emptyMap();

Lines 34-39 Link Here

(-)src/org/eclipse/scout/rt/extension/client/ui/basic/table/AbstractExtensibleTable.java (+1 lines)
34	*	34	*
35	* @since 3.9.0	35	* @since 3.9.0
36	*/	36	*/
		37	@SuppressWarnings("deprecation")
37	public abstract class AbstractExtensibleTable extends AbstractTable implements IExtensibleScoutObject {	38	public abstract class AbstractExtensibleTable extends AbstractTable implements IExtensibleScoutObject {
38	private static final IScoutLogger LOG = ScoutLogManager.getLogger(AbstractExtensibleTable.class);	39	private static final IScoutLogger LOG = ScoutLogManager.getLogger(AbstractExtensibleTable.class);
39		40

Lines 15-25 Link Here

(-)src/org/eclipse/scout/commons/ConfigurationUtility.java (-8 / +189 lines)
15	import java.lang.reflect.Modifier;	15	import java.lang.reflect.Modifier;
16	import java.util.ArrayList;	16	import java.util.ArrayList;
17	import java.util.Collection;	17	import java.util.Collection;
		18	import java.util.Collections;
		19	import java.util.HashMap;
		20	import java.util.HashSet;
		21	import java.util.List;
		22	import java.util.Map;
		23	import java.util.Set;
18	import java.util.TreeMap;	24	import java.util.TreeMap;
19		25
20	import org.eclipse.scout.commons.annotations.IOrdered;	26	import org.eclipse.scout.commons.annotations.IOrdered;
21	import org.eclipse.scout.commons.annotations.InjectFieldTo;	27	import org.eclipse.scout.commons.annotations.InjectFieldTo;
22	import org.eclipse.scout.commons.annotations.Order;	28	import org.eclipse.scout.commons.annotations.Order;
		29	import org.eclipse.scout.commons.annotations.Replace;
23	import org.eclipse.scout.commons.logger.IScoutLogger;	30	import org.eclipse.scout.commons.logger.IScoutLogger;
24	import org.eclipse.scout.commons.logger.ScoutLogManager;	31	import org.eclipse.scout.commons.logger.ScoutLogManager;
25		32
Lines 55-61 Link Here
55	orderedClassesMap.put(new CompositeObject(order.value(), i), classes[i]);	62	orderedClassesMap.put(new CompositeObject(order.value(), i), classes[i]);
56	}	63	}
57	else {	64	else {
58	LOG.error("missing @Order annotation: " + classes[i].getName());	65	if (!classes[i].isAnnotationPresent(Replace.class)) {
		66	LOG.error("missing @Order annotation: " + classes[i].getName());
		67	}
59	orderedClassesMap.put(new CompositeObject(Double.MAX_VALUE, i), classes[i]);	68	orderedClassesMap.put(new CompositeObject(Double.MAX_VALUE, i), classes[i]);
60	}	69	}
61	}	70	}
Lines 111-117 Link Here
111	*	120	*
112	* @param classes	121	* @param classes
113	* @param filter	122	* @param filter
114	* @return first occurrence of filter, might be annotated with {@link InjectFieldTo}	123	* @return first occurrence of filter, might be annotated with {@link InjectFieldTo} or {@link Replace}
115	*/	124	*/
116	@SuppressWarnings("unchecked")	125	@SuppressWarnings("unchecked")
117	public static <T> Class<T> filterClass(Class[] classes, Class<T> filter) {	126	public static <T> Class<T> filterClass(Class[] classes, Class<T> filter) {
Lines 124-130 Link Here
124	}	133	}
125		134
126	/**	135	/**
127	* same as {@link #filterClass(Class[], Class)} but ignoring classes with {@link InjectFieldTo} annotation	136	* same as {@link #filterClass(Class[], Class)} but ignoring classes with {@link InjectFieldTo} and {@link Replace}
		137	* annotations
128	*	138	*
129	* @since 3.8.1	139	* @since 3.8.1
130	*/	140	*/
Lines 132-138 Link Here
132	public static <T> Class<T> filterClassIgnoringInjectFieldAnnotation(Class[] classes, Class<T> filter) {	142	public static <T> Class<T> filterClassIgnoringInjectFieldAnnotation(Class[] classes, Class<T> filter) {
133	for (Class c : classes) {	143	for (Class c : classes) {
134	if (filter.isAssignableFrom(c) && !Modifier.isAbstract(c.getModifiers())) {	144	if (filter.isAssignableFrom(c) && !Modifier.isAbstract(c.getModifiers())) {
135	if (!c.isAnnotationPresent(InjectFieldTo.class)) {	145	if (!isInjectFieldAnnotationPresent(c)) {
136	return c;	146	return c;
137	}	147	}
138	}	148	}
Lines 161-167 Link Here
161	}	171	}
162		172
163	/**	173	/**
164	* same as {@link #filterClasses(Class[], Class)} but ignoring classes with {@link InjectFieldTo} annotation	174	* same as {@link #filterClasses(Class[], Class)} but ignoring classes with {@link InjectFieldTo} and {@link Replace}
		175	* annotations
165	*	176	*
166	* @since 3.8.1	177	* @since 3.8.1
167	*/	178	*/
Lines 170-176 Link Here
170	ArrayList<Class<T>> list = new ArrayList<Class<T>>();	181	ArrayList<Class<T>> list = new ArrayList<Class<T>>();
171	for (Class c : classes) {	182	for (Class c : classes) {
172	if (filter.isAssignableFrom(c) && !Modifier.isAbstract(c.getModifiers())) {	183	if (filter.isAssignableFrom(c) && !Modifier.isAbstract(c.getModifiers())) {
173	if (!c.isAnnotationPresent(InjectFieldTo.class)) {	184	if (!isInjectFieldAnnotationPresent(c)) {
174	list.add(c);	185	list.add(c);
175	}	186	}
176	}	187	}
Lines 179-185 Link Here
179	}	190	}
180		191
181	/**	192	/**
182	* same as {@link #filterClasses(Class[], Class)} but only accepting classes with {@link InjectFieldTo} annotation	193	* same as {@link #filterClasses(Class[], Class)} but only accepting classes with {@link InjectFieldTo} and
		194	* {@link Replace} annotations
183	*	195	*
184	* @since 3.8.1	196	* @since 3.8.1
185	*/	197	*/
Lines 188-194 Link Here
188	ArrayList<Class<T>> list = new ArrayList<Class<T>>();	200	ArrayList<Class<T>> list = new ArrayList<Class<T>>();
189	for (Class c : classes) {	201	for (Class c : classes) {
190	if (filter.isAssignableFrom(c) && !Modifier.isAbstract(c.getModifiers())) {	202	if (filter.isAssignableFrom(c) && !Modifier.isAbstract(c.getModifiers())) {
191	if (c.isAnnotationPresent(InjectFieldTo.class)) {	203	if (isInjectFieldAnnotationPresent(c)) {
192	list.add(c);	204	list.add(c);
193	}	205	}
194	}	206	}
Lines 197-202 Link Here
197	}	209	}
198		210
199	/**	211	/**
		212	* @return Returns <code>true</code> if the given class is annotated by {@link InjectFieldTo} or {@link Replace}.
		213	* Otherwise <code>false</code>.
		214	* <p/>
		215	* <b>Note:</b> This method throws a {@link NullPointerException} if the given class is null.
		216	*/
		217	public static boolean isInjectFieldAnnotationPresent(Class<?> c) {
		218	return c.isAnnotationPresent(InjectFieldTo.class) \|\| c.isAnnotationPresent(Replace.class);
		219	}
		220
		221	/**
200	* get all declared classes (inner types) of the specified class and all its	222	* get all declared classes (inner types) of the specified class and all its
201	* super classes	223	* super classes
202	*/	224	*/
Lines 261-264 Link Here
261	}	283	}
262	return c;	284	return c;
263	}	285	}
		286
		287	/**
		288	* Returns a new array without those classes, that are replaced by another class. The returned array is a new
		289	* instance, except there are no replacing classes. Replacing classes are annotated with {@link Replace}. Replacing
		290	* classes are reordered according to their nearest {@link Order} annotation that is found up the type hierarchy.
		291	*
		292	* @param classes
		293	* @return
		294	* @since 3.8.2
		295	*/
		296	@SuppressWarnings("unchecked")
		297	public static <T> Class<? extends T>[] removeReplacedClasses(Class<? extends T>[] classes) {
		298	Set<Class<? extends T>> replacingClasses = getReplacingLeafClasses(classes);
		299	if (replacingClasses.isEmpty()) {
		300	// there are no replacing classes -> return original array
		301	return classes;
		302	}
		303
		304	// compute resulting list of ordered classes
		305	List<Class<? extends T>> list = new ArrayList<Class<? extends T>>();
		306	for (Class<? extends T> c : classes) {
		307	list.add(c);
		308	}
		309
		310	for (Class<? extends T> replacingClass : replacingClasses) {
		311	boolean reorder = !replacingClass.isAnnotationPresent(Order.class);
		312	boolean reordered = false;
		313
		314	// handle transitive replacements
		315	Class<?> classToBeReplaced = replacingClass.getSuperclass();
		316	while (classToBeReplaced.isAnnotationPresent(Replace.class)) {
		317	// reorder replacement if necessary
		318	if (reorder && !reordered && classToBeReplaced.isAnnotationPresent(Order.class)) {
		319	reordered = moveBefore(list, replacingClass, (Class<? extends T>) classToBeReplaced);
		320	}
		321	list.remove(classToBeReplaced);
		322	classToBeReplaced = classToBeReplaced.getSuperclass();
		323	}
		324
		325	// reorder replacement if necessary
		326	if (reorder && !reordered) {
		327	moveBefore(list, replacingClass, (Class<? extends T>) classToBeReplaced);
		328	}
		329	list.remove(classToBeReplaced);
		330	}
		331
		332	return list.toArray(new Class[list.size()]);
		333	}
		334
		335	/**
		336	* Computes a map based on the given classes that contains replaced classes pointing to their replacing classes. This
		337	* method never returns <code>null</code>.
		338	* <p/>
		339	* <b>Example:</b> Given the following two classes
		340	*
		341	* <pre>
		342	* public class A {
		343	* }
		344	*
		345	* @Replace
		346	* public class B extends A {
		347	* }
		348	* </pre>
		349	*
350	* The invocation of <code>getReplacementMapping(new Class[] {B.class, String.class})</code> returns a map containing
351	* <code><A.class, B.class></code>.
352	*
353	* @param classes
354	* @return
355	* @since 3.8.2
356	*/
357	public static <T> Map<Class<?>, Class<? extends T>> getReplacementMapping(Class<? extends T>[] classes) {
358	Set<Class<? extends T>> replacingClasses = getReplacingLeafClasses(classes);
359	if (replacingClasses.isEmpty()) {
360	// there are no replacing classes -> return original array
361	return Collections.emptyMap();
362	}
363
364	// compute resulting replacement mapping
365	Map<Class<?>, Class<? extends T>> mappings = new HashMap<Class<?>, Class<? extends T>>();
366	for (Class<? extends T> c : replacingClasses) {
367	Class<?> tmpClass = c;
368	do {
369	tmpClass = tmpClass.getSuperclass();
370	mappings.put(tmpClass, c);
371	}
372	while (tmpClass.isAnnotationPresent(Replace.class));
373	}
374	return mappings;
375	}
376
377	/**
378	* Computes the set of classes that are annotated with {@link Replace} and removes transitive dependencies, so that
379	* the most specific classes are returned.
380	* <p/>
381	* <b>Example:</b> Given the following two classes
382	*
383	* <pre>
384	* public class A {
385	* }
386	*
387	* @Replace
388	* public class B extends A {
389	* }
390	* </pre>
391	*
392	* The invocation of <code>getReplacingLeafClasses(new Class[] {A.class, B.class, String.class})</code> returns a set
393	* that contains <code>B.class</code> only. <code>String.class</code> is not annotated with {@link Replace} and
394	* <code>A.class</code> is not a leaf replacement, but further replaced by <code>B.class</code>.
395	*
396	* @param classes
397	* @return Returns the set of replacing leaf classes or an empty set.
398	* @since 3.8.2
399	*/
400	public static <T> Set<Class<? extends T>> getReplacingLeafClasses(Class<? extends T>[] classes) {
401	// gather all replacing and replaced classes (i.e. those annotated with @Replace and their super classes)
402	Set<Class<? extends T>> replacingClasses = new HashSet<Class<? extends T>>();
403	Set<Class<?>> replacedClasses = new HashSet<Class<?>>();
404	for (Class<? extends T> c : classes) {
405	if (c.isAnnotationPresent(Replace.class)) {
406	replacingClasses.add(c);
407	Class<?> tmpClass = c;
408	do {
409	tmpClass = tmpClass.getSuperclass();
410	replacedClasses.add(tmpClass);
411	}
412	while (tmpClass.isAnnotationPresent(Replace.class));
413	}
414	}
415
416	if (replacingClasses.isEmpty()) {
417	return Collections.emptySet();
418	}
419
420	// remove transitive replacements (e.g. if A replaces B and B replaces C, A and B are replacing classes but we are interested in A only)
421	replacingClasses.removeAll(replacedClasses);
422	return replacingClasses;
423	}
424
425	/**
426	* Moves the given element before the reference element. Both are expected to be part of the given list. If the
427	* reference element is not in the list, the list remains untouched. If the element to move is not part of the list,
428	* it is added before the reference element.
429	*
430	* @param list
431	* @param element
432	* @param referenceElement
433	* @return Returns <code>true</code> if the element has been moved or inserted. Otherwise <code>false</code>.
434	* @since 3.8.2
435	*/
436	private static <T> boolean moveBefore(List<T> list, T element, T referenceElement) {
437	int index = list.indexOf(referenceElement);
438	if (index != -1) {
439	list.remove(element);
440	list.add(index, element);
441	return true;
442	}
443	return false;
444	}
264	}	445	}




package org.eclipse.scout.commons.annotations;

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

import org.eclipse.scout.commons.annotations.FormData.SdkCommand;

/**
 * Annotation on a class used to replace the first occurrence of its super class. The Annotation can be applied to
 * several scout objects types like columns, menus, form fields. Further, the annotation can be applied recursively
 * (i.e. replaced objects can be replaced as well).
 * <p/>
 * <h3>Usage on form fields</h3> If this annotation is added to a form field in an extended form, it works like the
 * {@link InjectFieldTo} annotation except that the original field is removed. The replaced field's container is used by
 * the replacing field as well. If the {@link Order} annotation is missing on the replacing class, the order of the
 * extended class is used. Finally, the {@link FormData} annotation is inherited form the replaced field. If the
 * replaced field does not have a form field data, the replacing field may crate on using {@link SdkCommand#CREATE} or
 * {@link SdkCommand#USE}.
 * <p/>
 * <b>Example:</b> The NameExField replaces the NameField in the original BaseForm without changing its order within the
 * FirstGroupBox. <b>Note:</b> the weird looking super constructor call is required for initializing the extended
 * <em>inner class</em>.
 * 
 * <pre>
 * public class BaseForm extends AbstractForm {
 *   &#064;Order(10)
 *   public class MainBox extends AbstractGroupBox {
 *     &#064;Order(10)
 *     public class FirstGroupBox extends AbstractGroupBox {
 *       &#064;Order(10)
 *       public class NameField extends AbstractStringField {
 *       }
 *     }
 *   }
 * }
 * 
 * public class ExtendedForm extends BaseForm {
 *   &#064;Replace
 *   public class NameExField extends NameField {
 *     public NameExField(BaseForm.MainBox.FirstGroupBox container) {
 *       container.super();
 *     }
 *   }
 * }
 * </pre>
 * 
 * <h3>Usage on table columns</h3> The annotation can be used to modify or move columns within a table. By default, the
 * replaced column uses the same {@link Order} of the replaced column.
 * <p/>
 * <b>Example 1:</b> The FirstExColumn replaces the FirstColumn in the original Table without changing its order.
 * 
 * <pre>
 * public class Table extends AbstractTable {
 *   &#064;Order(10)
 *   public class FirstColumn extends AbstractStringColumn {
 *   }
 * 
 *   &#064;Order(20)
 *   public class SecondColumn extends AbstractStringColumn {
 *   }
 * }
 * 
 * public class ExtendedTable extends Table {
 *   &#064;Replace
 *   public class FirstExColumn extends FirstColumn {
 *   }
 * }
 * </pre>
 * 
 * <b>Example 2:</b> Modifying the table of a table field requires to replace the table field as well:
 * 
 * <pre>
 * public class BaseForm extends AbstractForm {
 *   &#064;Order(10)
 *   public class MainBox extends AbstractGroupBox {
 *     &#064;Order(10)
 *     public class FirstGroupBox extends AbstractGroupBox {
 *       &#064;Order(10)
 *       public class TableField extends AbstractTableField {
 *         public class Table extends AbstractTable {
 *           &#064;Order(10)
 *           public class FirstColumn extends AbstractStringColumn {
 *           }
 *         }
 *       }
 *     }
 *   }
 * }
 * 
 * public class ExtendedForm extends BaseForm {
 *   &#064;Replace
 *   public class TableExField extends NameField {
 *     public TableExField(BaseForm.MainBox.FirstGroupBox container) {
 *       container.super();
 *     }
 * 
 *     public class TableEx extends Table {
 *       &#064;Replace
 *       public class FirstExColumn extends FirstColumn {
 *       }
 *     }
 *   }
 * }
 * </pre>
 * 
 * <h3>Usage on action containers</h3> The annotation can be used to change the behavior of an action. Menus, key
 * strokes, tool buttons and view buttons are actions as well.
 * <p/>
 * <b>Example:</b> Modify the behavior of a menu defined on a smart field:
 * 
 * <pre>
 * public class BaseForm extends AbstractForm {
 *   &#064;Order(10)
 *   public class MainBox extends AbstractGroupBox {
 *     &#064;Order(10)
 *     public class MySmartField extends AbstractSmartField&lt;Long&gt; {
 *       &#064;Order(10)
 *       public class MyMenu extends AbstractMenu {
 *       }
 *     }
 *   }
 * }
 * 
 * public class ExtendedForm extends BaseForm {
 *   &#064;Replace
 *   public class MyExSmartField extends MySmartField {
 *     public MyExSmartField(BaseForm.MainBox container) {
 *       container.super();
 *     }
 * 
 *     &#064;Replace
 *     public class MyExMenu extends MyMenu {
 *     }
 *   }
 * }
 * </pre>
 * 
 * @since 3.8.2
 */
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.TYPE)
public @interface Replace {

}

Lines 128-133 Link Here

(-)src/org/eclipse/scout/sdk/RuntimeClasses.java (+1 lines)
128	public static final String BasicHierarchyPermission = "org.eclipse.scout.rt.shared.security.BasicHierarchyPermission"; // NO_UCD	128	public static final String BasicHierarchyPermission = "org.eclipse.scout.rt.shared.security.BasicHierarchyPermission"; // NO_UCD
129	public static final String BasicPermission = "java.security.BasicPermission"; // NO_UCD	129	public static final String BasicPermission = "java.security.BasicPermission"; // NO_UCD
130	public static final String FormData = "org.eclipse.scout.commons.annotations.FormData"; // NO_UCD	130	public static final String FormData = "org.eclipse.scout.commons.annotations.FormData"; // NO_UCD
		131	public static final String Replace = "org.eclipse.scout.commons.annotations.Replace"; // NO_UCD
131	public static final String FormData_UpdateOperation = "org.eclipse.scout.commons.annotations.FormData.UpdateOperation"; // NO_UCD	132	public static final String FormData_UpdateOperation = "org.eclipse.scout.commons.annotations.FormData.UpdateOperation"; // NO_UCD
132	public static final String ClientProxyServiceFactory = "org.eclipse.scout.rt.client.services.ClientProxyServiceFactory"; // NO_UCD	133	public static final String ClientProxyServiceFactory = "org.eclipse.scout.rt.client.services.ClientProxyServiceFactory"; // NO_UCD
133	public static final String ClientServiceFactory = "org.eclipse.scout.rt.client.services.ClientServiceFactory"; // NO_UCD	134	public static final String ClientServiceFactory = "org.eclipse.scout.rt.client.services.ClientServiceFactory"; // NO_UCD




import org.eclipse.scout.sdk.icon.IIconProvider;
import org.eclipse.scout.sdk.internal.ScoutSdk;
import org.eclipse.scout.sdk.operation.form.formdata.FormDataAnnotation;
import org.eclipse.scout.sdk.operation.form.formdata.FormDataUtility;
import org.eclipse.scout.sdk.util.Regex;
import org.eclipse.scout.sdk.util.ScoutMethodUtility;
import org.eclipse.scout.sdk.util.ScoutUtility;

    return null;
  }

  /**
   * @return Returns <code>true</code> if the given type exists and if it is annotated with an
   *         {@link RuntimeClasses#Replace} annotation.
   * @since 3.8.2
   */
  public static boolean isReplaceAnnotationPresent(IType type) {
    IAnnotation annotation = JdtUtility.getAnnotation(type, RuntimeClasses.Replace);
    return TypeUtility.exists(annotation);
  }

  /**
   * @return Returns the form field data for the given form field or <code>null</code> if it does not have one.
   * @since 3.8.2
   */
  public static IType getFormDataType(IType formField, ITypeHierarchy hierarchy) throws JavaModelException {
    IType primaryType = getFormFieldDataPrimaryTypeRec(formField, hierarchy);
    if (!TypeUtility.exists(primaryType)) {
      return null;
    }
    IType formDataType = primaryType.getType(FormDataUtility.getBeanName(FormDataUtility.getFieldNameWithoutSuffix(formField.getElementName()), true));
    if (TypeUtility.exists(formDataType)) {
      return formDataType;
    }
    return null;
  }

  /**
   * @return Returns the form field data for the given form field or <code>null</code> if it does not have one. The
   *         method walks recursively through the list of declaring classes until it has reached a primary type.
   * @since 3.8.2
   */
  private static IType getFormFieldDataPrimaryTypeRec(IType recursiveDeclaringType, ITypeHierarchy hierarchy) throws JavaModelException {
    if (!TypeUtility.exists(recursiveDeclaringType)) {
      return null;
    }
    FormDataAnnotation formDataAnnotation = findFormDataAnnotation(recursiveDeclaringType, hierarchy);
    if (formDataAnnotation == null) {
      return null;
    }
    if (FormDataAnnotation.isIgnore(formDataAnnotation)) {
      return null;
    }

    IType declaringType = recursiveDeclaringType.getDeclaringType();
    if (declaringType == null) {
      // primary type
      if (FormDataAnnotation.isSdkCommandCreate(formDataAnnotation) || FormDataAnnotation.isSdkCommandUse(formDataAnnotation)) {
        return getTypeBySignature(formDataAnnotation.getFormDataTypeSignature());
      }
      return null;
    }

    return getFormFieldDataPrimaryTypeRec(declaringType, hierarchy);
  }

  public static FormDataAnnotation findFormDataAnnotation(IType type, ITypeHierarchy hierarchy) throws JavaModelException {
    return findFormDataAnnnotationImpl(type, hierarchy);
  }


  private static void parseFormDataAnnotationReq(FormDataAnnotation annotation, IType type, ITypeHierarchy hierarchy, boolean isOwner) {
    if (TypeUtility.exists(type)) {
      boolean replaceAnnotationPresent = isReplaceAnnotationPresent(type);
      IType superType = hierarchy.getSuperclass(type);
      parseFormDataAnnotationReq(annotation, superType, hierarchy, replaceAnnotationPresent);

      if (replaceAnnotationPresent) {
        if (!isReplaceAnnotationPresent(superType)) {
          // super type is the original field that is going to be replaced by the given type
          // check whether the super type is embedded into a form field that is annotated by @FormData with SdkCommand.IGNORE.
          try {
            IType declaringType = superType.getDeclaringType();
            while (TypeUtility.exists(declaringType)) {
              FormDataAnnotation declaringTypeformDataAnnotation = findFormDataAnnotation(declaringType, hierarchy);
              if (FormDataAnnotation.isIgnore(declaringTypeformDataAnnotation)) {
                // super type is embedded into a ignored form field. Hence this field is ignored as well. Adjust parsed annotation.
                annotation.setSdkCommand(SdkCommand.IGNORE);
                break;
              }
              declaringType = declaringType.getDeclaringType();
            }
          }
          catch (JavaModelException e) {
            ScoutSdk.logWarning("could not determine enclosing class's @FormData annotation", e);
          }
        }

        if (!FormDataAnnotation.isIgnore(annotation)) {
          // a form field data must always be created for a replacing fields if its parent has one and it must extend the parent field's field data class
          return;
        }
      }

      try {
        fillFormDataAnnotation(type, annotation, isOwner);
      }

  }

  /**
   * @see #getValidationRuleMethods(IType, ITypeHierarchy)
   */
  public static List<ValidationRuleMethod> getValidationRuleMethods(IType declaringType) throws JavaModelException {
    return getValidationRuleMethods(declaringType, null);
  }

  /**
   * @return a map with all validation rule names mapped to the method on the most specific declaring type
   * @throws JavaModelException
   */
  public static List<ValidationRuleMethod> getValidationRuleMethods(IType declaringType, org.eclipse.jdt.core.ITypeHierarchy superTypeHierarchy) throws JavaModelException {
    TreeMap<String, ValidationRuleMethod> ruleMap = new TreeMap<String, ValidationRuleMethod>();
    if (superTypeHierarchy == null) {
      try {
        superTypeHierarchy = declaringType.newSupertypeHierarchy(null);
      }
      catch (JavaModelException e) {
        ScoutSdk.logWarning("could not build super type hierarchy for '" + declaringType.getFullyQualifiedName() + "'", e);
        return Collections.emptyList();
      }
    }

    ArrayList<IType> targetTypeList = new ArrayList<IType>(5);
    targetTypeList.add(0, declaringType);
    IType[] superClasses = superTypeHierarchy.getAllSuperclasses(declaringType);

          continue;
        }
        //found new rule annotation, now find most specific method in subclasses to generate source code
        if (ruleSkip.booleanValue()) {
          ruleMap.put(hashKey, null);
          continue;
        }
        if (ruleGeneratedSourceCode != null && ruleGeneratedSourceCode.length() == 0) {
          ruleGeneratedSourceCode = null;
        }

          implementedMethod = annotatedMethod;
        }
        //new rule is sufficiently parsed
        ValidationRuleMethod vm = new ValidationRuleMethod(validationRuleAnnotation, ruleField, ruleString, ruleGeneratedSourceCode, annotatedMethod, implementedMethod, superTypeHierarchy, ruleSkip);
        ruleMap.put(hashKey, vm);
      }
    }




  private final IMethod m_annotatedMethod;
  private final IMethod m_implementedMethod;
  private final ITypeHierarchy m_superTypeHierarchy;
  private final boolean m_skipRule;

  public ValidationRuleMethod(IAnnotation annotation, IField ruleField, String ruleName, String ruleGeneratedSourceCode, IMethod annotatedMethod, IMethod implementedMethod, ITypeHierarchy superTypeHierarchy, boolean skipRule) {
    m_annotation = annotation;
    m_ruleField = ruleField;
    m_ruleName = ruleName;

    m_annotatedMethod = annotatedMethod;
    m_implementedMethod = implementedMethod;
    m_superTypeHierarchy = superTypeHierarchy;
    m_skipRule = skipRule;
  }

  /**

    return m_superTypeHierarchy;
  }

  /**
   * @return Returns <code>true</code> if this rule should be skipped.
   */
  public boolean isSkipRule() {
    return m_skipRule;
  }
}

Lines 33-38 Link Here

(-)src/org/eclipse/scout/sdk/operation/form/formdata/FormDataUtility.java (-5 / +15 lines)
33	import org.eclipse.scout.sdk.util.signature.SignatureUtility;	33	import org.eclipse.scout.sdk.util.signature.SignatureUtility;
34	import org.eclipse.scout.sdk.util.type.TypeUtility;	34	import org.eclipse.scout.sdk.util.type.TypeUtility;
35	import org.eclipse.scout.sdk.util.typecache.ITypeHierarchy;	35	import org.eclipse.scout.sdk.util.typecache.ITypeHierarchy;
		36	import org.eclipse.scout.sdk.workspace.type.ScoutTypeUtility;
36	import org.eclipse.text.edits.InsertEdit;	37	import org.eclipse.text.edits.InsertEdit;
37	import org.eclipse.text.edits.MultiTextEdit;	38	import org.eclipse.text.edits.MultiTextEdit;
38		39
Lines 104-111 Link Here
104	public static ITypeSourceBuilder getPrimaryTypeFormDataSourceBuilder(String superTypeSignature, IType formField, ITypeHierarchy hierarchy) {	105	public static ITypeSourceBuilder getPrimaryTypeFormDataSourceBuilder(String superTypeSignature, IType formField, ITypeHierarchy hierarchy) {
105	ITypeSourceBuilder builder = null;	106	ITypeSourceBuilder builder = null;
106	try {	107	try {
107	String typeErasure = Signature.getTypeErasure(superTypeSignature);	108	IType superType = ScoutTypeUtility.getTypeBySignature(superTypeSignature);
108	if (Signature.getSignatureSimpleName(typeErasure).equals(Signature.getSimpleName(RuntimeClasses.AbstractTableFieldData))) {	109	ITypeHierarchy superTypeHierarchy = null;
		110	if (TypeUtility.exists(superType)) {
		111	superTypeHierarchy = TypeUtility.getSuperTypeHierarchy(superType);
		112	}
		113
		114	if (superTypeHierarchy != null && superTypeHierarchy.contains(TypeUtility.getType(RuntimeClasses.AbstractTableFieldData))) {
109	builder = new TableFieldSourceBuilder(formField, hierarchy);	115	builder = new TableFieldSourceBuilder(formField, hierarchy);
110	}	116	}
111	else {	117	else {
Lines 119-128 Link Here
119	return builder;	125	return builder;
120	}	126	}
121		127
122	public static ITypeSourceBuilder getInnerTypeFormDataSourceBuilder(String superTypeSignature, IType formField, ITypeHierarchy hierarchy) {	128	public static ITypeSourceBuilder getInnerTypeFormDataSourceBuilder(IType superType, String superTypeSignature, IType formField, ITypeHierarchy hierarchy) {
123	ITypeSourceBuilder builder = null;	129	ITypeSourceBuilder builder = null;
124	String typeErasure = Signature.getTypeErasure(superTypeSignature);	130	ITypeHierarchy superTypeHierarchy = null;
125	if (Signature.toString(typeErasure).equals(RuntimeClasses.AbstractTableFieldData)) {	131	if (TypeUtility.exists(superType)) {
		132	superTypeHierarchy = TypeUtility.getSuperTypeHierarchy(superType);
		133	}
		134
		135	if (superTypeHierarchy != null && superTypeHierarchy.contains(TypeUtility.getType(RuntimeClasses.AbstractTableFieldData))) {
126	builder = new TableFieldSourceBuilder(formField, hierarchy);	136	builder = new TableFieldSourceBuilder(formField, hierarchy);
127	}	137	}
128	else {	138	else {




  protected void addValidationRules(IType type) {
    // validation rules
    try {
      boolean replaceAnnotationPresent = ScoutTypeUtility.isReplaceAnnotationPresent(type);

      ITypeHierarchy hierarchy = TypeUtility.getSuperTypeHierarchy(type);
      if (hierarchy == null) {
        return;
      }

      // If the replace annotation is available, we have to check whether the replaced field
      // is not associated to a form field data
      boolean superTypeHasNoFormFieldData = false;
      if (replaceAnnotationPresent) {
        IType superType = hierarchy.getSuperclass(type);
        superTypeHasNoFormFieldData = ScoutTypeUtility.getFormDataType(superType, hierarchy) == null;
      }

      List<ValidationRuleMethod> list = ScoutTypeUtility.getValidationRuleMethods(type, hierarchy.getJdtHierarchy());
      if (list.size() > 0) {
        for (Iterator<ValidationRuleMethod> it = list.iterator(); it.hasNext();) {
          ValidationRuleMethod vm = it.next();
          if (replaceAnnotationPresent) {
            if (superTypeHasNoFormFieldData && vm.isSkipRule()) {
              it.remove();
              continue;
            }
            else if (!superTypeHasNoFormFieldData && !type.equals(vm.getImplementedMethod().getDeclaringType())) {
              // remove all validation rules that are not overridden by the replacement class
              it.remove();
              continue;
            }
          }
          else if (vm.isSkipRule()) {
            // class does not replace its super class. Hence remove all skipped validation rules
            it.remove();
            continue;
          }

          String generatedSourceCode = vm.getRuleGeneratedSourceCode();
          if (generatedSourceCode != null) {
            if (generatedSourceCode.equals("null")) {

          String generatedSourceCode = vm.getRuleGeneratedSourceCode();
          //filter
          generatedSourceCode = filterGeneratedSourceCode(vm.getImplementedMethod(), generatedSourceCode, validator);
          if (!vm.isSkipRule() && (generatedSourceCode == null || containsBrackets(generatedSourceCode))) {
            //add javadoc warning
            String fqn = vm.getImplementedMethod().getDeclaringType().getFullyQualifiedName('.') + " # " + vm.getImplementedMethod().getElementName();
            buf.append("/**");

          }
          //
          buf.append(NL);
          if (vm.isSkipRule()) {
            buf.append("ruleMap.remove(");
            buf.append(ruleDecl);
            buf.append(");");
          }
          else {
            buf.append("ruleMap.put(");
            buf.append(ruleDecl);
            buf.append(", ");
            buf.append(generatedSourceCode);
            buf.append(");");
          }
        }
        catch (Exception e) {
          String fqn = vm.getImplementedMethod().getDeclaringType().getFullyQualifiedName() + "#" + vm.getImplementedMethod().getElementName();




    if (formDataAnnotation != null) {
      if (FormDataAnnotation.isCreate(formDataAnnotation)) {
        String formDataElementName = FormDataUtility.getBeanName(FormDataUtility.getFieldNameWithoutSuffix(formField.getElementName()), true);
        String superTypeSignature = null;
        IType superType = null;

        boolean replaceAnnotationPresent = ScoutTypeUtility.isReplaceAnnotationPresent(formField);
        if (replaceAnnotationPresent) {
          IType replacedType = formFieldHierarchy.getSuperclass(formField);
          IType replacedFormFieldDataType = ScoutTypeUtility.getFormDataType(replacedType, formFieldHierarchy);
          if (replacedFormFieldDataType != null) {
            superTypeSignature = Signature.createTypeSignature(replacedFormFieldDataType.getTypeQualifiedName(), false);
            superType = replacedFormFieldDataType;
          }
        }

        if (superTypeSignature == null) {
          superTypeSignature = formDataAnnotation.getSuperTypeSignature();
          superType = TypeUtility.getTypeBySignature(superTypeSignature);
          if (formDataAnnotation.getGenericOrdinal() >= 0) {
            if (TypeUtility.isGenericType(superType)) {
              String genericTypeSig = org.eclipse.scout.sdk.operation.form.formdata.FormDataUtility.computeFormFieldGenericType(formField, formFieldHierarchy);
              if (genericTypeSig != null) {
                superTypeSignature = superTypeSignature.replaceAll("\\;$", "<" + genericTypeSig + ">;");
              }
            }
          }
        }

        ITypeSourceBuilder builder = FormDataUtility.getInnerTypeFormDataSourceBuilder(superType, superTypeSignature, formField, formFieldHierarchy);
        builder.setElementName(formDataElementName);
        builder.setSuperTypeSignature(superTypeSignature);
        builder.setFlags(Flags.AccPublic | Flags.AccStatic);
        if (replaceAnnotationPresent) {
          builder.addAnnotation(new AnnotationSourceBuilder(Signature.createTypeSignature(RuntimeClasses.Replace, true)));
        }
        addBuilder(builder, CATEGORY_TYPE_FIELD);
        MethodSourceBuilder getterBuilder = new MethodSourceBuilder(NL);
        getterBuilder.setElementName("get" + formDataElementName);

Lines 38-44 Link Here

(-)src/org/eclipse/scout/rt/client/ui/action/tree/AbstractActionNode.java (-2 / +2 lines)
38	*/	38	*/
39	private Class<? extends IActionNode>[] getConfiguredChildActions() {	39	private Class<? extends IActionNode>[] getConfiguredChildActions() {
40	Class[] dca = ConfigurationUtility.getDeclaredPublicClasses(getClass());	40	Class[] dca = ConfigurationUtility.getDeclaredPublicClasses(getClass());
41	return ConfigurationUtility.sortFilteredClassesByOrderAnnotation(dca, IActionNode.class);	41	Class<IActionNode>[] foca = ConfigurationUtility.sortFilteredClassesByOrderAnnotation(dca, IActionNode.class);
		42	return ConfigurationUtility.removeReplacedClasses(foca);
42	}	43	}
43		44
44	@Override	45	@Override
Lines 65-71 Link Here
65	catch (Exception e) {	66	catch (Exception e) {
66	LOG.error("error occured while dynamically contribute action nodes.", e);	67	LOG.error("error occured while dynamically contribute action nodes.", e);
67	}	68	}
68
69	setChildActions(nodeList);	69	setChildActions(nodeList);
70	}	70	}
71		71

Lines 18-23 Link Here

(-)src/org/eclipse/scout/rt/client/ui/action/AbstractAction.java (-1 / +6 lines)
18	import org.eclipse.scout.commons.annotations.ConfigProperty;	18	import org.eclipse.scout.commons.annotations.ConfigProperty;
19	import org.eclipse.scout.commons.annotations.ConfigPropertyValue;	19	import org.eclipse.scout.commons.annotations.ConfigPropertyValue;
20	import org.eclipse.scout.commons.annotations.Order;	20	import org.eclipse.scout.commons.annotations.Order;
		21	import org.eclipse.scout.commons.annotations.Replace;
21	import org.eclipse.scout.commons.beans.AbstractPropertyObserver;	22	import org.eclipse.scout.commons.beans.AbstractPropertyObserver;
22	import org.eclipse.scout.commons.exception.ProcessingException;	23	import org.eclipse.scout.commons.exception.ProcessingException;
23	import org.eclipse.scout.commons.logger.IScoutLogger;	24	import org.eclipse.scout.commons.logger.IScoutLogger;
Lines 272-278 Link Here
272		273
273	@Override	274	@Override
274	public String getActionId() {	275	public String getActionId() {
275	String s = getClass().getName();	276	Class<?> c = getClass();
		277	while (c.isAnnotationPresent(Replace.class)) {
		278	c = c.getSuperclass();
		279	}
		280	String s = c.getName();
276	int i = Math.max(s.lastIndexOf('$'), s.lastIndexOf('.'));	281	int i = Math.max(s.lastIndexOf('$'), s.lastIndexOf('.'));
277	s = s.substring(i + 1);	282	s = s.substring(i + 1);
278	return s;	283	return s;

Lines 89-95 Link Here

(-)src/org/eclipse/scout/rt/client/ui/basic/calendar/provider/AbstractCalendarItemProvider.java (-1 / +2 lines)
89		89
90	private Class<? extends IMenu>[] getConfiguredMenus() {	90	private Class<? extends IMenu>[] getConfiguredMenus() {
91	Class[] dca = ConfigurationUtility.getDeclaredPublicClasses(getClass());	91	Class[] dca = ConfigurationUtility.getDeclaredPublicClasses(getClass());
92	return ConfigurationUtility.sortFilteredClassesByOrderAnnotation(dca, IMenu.class);	92	Class<IMenu>[] foca = ConfigurationUtility.sortFilteredClassesByOrderAnnotation(dca, IMenu.class);
		93	return ConfigurationUtility.removeReplacedClasses(foca);
93	}	94	}
94		95
95	/**	96	/**





  private Class<? extends ICalendarItemProvider>[] getConfiguredProducers() {
    Class[] dca = ConfigurationUtility.getDeclaredPublicClasses(getClass());
    Class<ICalendarItemProvider>[] foca = ConfigurationUtility.sortFilteredClassesByOrderAnnotation(dca, ICalendarItemProvider.class);
    return ConfigurationUtility.removeReplacedClasses(foca);
  }

  private Class<? extends IMenu>[] getConfiguredMenus() {
    Class[] dca = ConfigurationUtility.getDeclaredPublicClasses(getClass());
    Class<IMenu>[] foca = ConfigurationUtility.sortFilteredClassesByOrderAnnotation(dca, IMenu.class);
    return ConfigurationUtility.removeReplacedClasses(foca);
  }

  @ConfigOperation

  }

  /**
   * do not use this internal method unless you are implementing a container that holds and controls an
   * {@link ICalendar}
   */
  public void setContainerInternal(Object container) {
    propertySupport.setProperty(PROP_CONTAINER, container);

Lines 144-150 Link Here

(-)src/org/eclipse/scout/rt/client/ui/basic/tree/AbstractTreeNode.java (-1 / +3 lines)
144		144
145	private Class<? extends IMenu>[] getConfiguredMenus() {	145	private Class<? extends IMenu>[] getConfiguredMenus() {
146	Class<?>[] dca = ConfigurationUtility.getDeclaredPublicClasses(getClass());	146	Class<?>[] dca = ConfigurationUtility.getDeclaredPublicClasses(getClass());
147	return ConfigurationUtility.sortFilteredClassesByOrderAnnotation(dca, IMenu.class);	147	Class<IMenu>[] foca = ConfigurationUtility.sortFilteredClassesByOrderAnnotation(dca, IMenu.class);
		148	return ConfigurationUtility.removeReplacedClasses(foca);
148	}	149	}
149		150
150	protected void initConfig() {	151	protected void initConfig() {
Lines 607-612 Link Here
607		608
608	@Override	609	@Override
609	public <T extends IMenu> T getMenu(Class<T> menuType) throws ProcessingException {	610	public <T extends IMenu> T getMenu(Class<T> menuType) throws ProcessingException {
		611	// ActionFinder performs instance-of checks. Hence the menu replacement mapping is not required
610	return new ActionFinder().findAction(getMenus(), menuType);	612	return new ActionFinder().findAction(getMenus(), menuType);
611	}	613	}
612		614





  private Class<? extends IKeyStroke>[] getConfiguredKeyStrokes() {
    Class<?>[] dca = ConfigurationUtility.getDeclaredPublicClasses(getClass());
    Class<IKeyStroke>[] fca = ConfigurationUtility.filterClasses(dca, IKeyStroke.class);
    return ConfigurationUtility.removeReplacedClasses(fca);
  }

  private Class<? extends IMenu>[] getConfiguredMenus() {
    Class<?>[] dca = ConfigurationUtility.getDeclaredPublicClasses(getClass());
    Class<IMenu>[] foca = ConfigurationUtility.sortFilteredClassesByOrderAnnotation(dca, IMenu.class);
    return ConfigurationUtility.removeReplacedClasses(foca);
  }

  @ConfigOperation


  @Override
  public <T extends IMenu> T getMenu(Class<T> menuType) throws ProcessingException {
    // ActionFinder performs instance-of checks. Hence the menu replacement mapping is not required
    return new ActionFinder().findAction(getMenus(), menuType);
  }


Lines 137-143 Link Here

(-)src/org/eclipse/scout/rt/client/ui/basic/activitymap/AbstractActivityMap.java (-1 / +2 lines)
137		137
138	private Class<? extends IMenu>[] getConfiguredMenus() {	138	private Class<? extends IMenu>[] getConfiguredMenus() {
139	Class[] dca = ConfigurationUtility.getDeclaredPublicClasses(getClass());	139	Class[] dca = ConfigurationUtility.getDeclaredPublicClasses(getClass());
140	return ConfigurationUtility.sortFilteredClassesByOrderAnnotation(dca, IMenu.class);	140	Class<IMenu>[] foca = ConfigurationUtility.sortFilteredClassesByOrderAnnotation(dca, IMenu.class);
		141	return ConfigurationUtility.removeReplacedClasses(foca);
141	}	142	}
142		143
143	/**	144	/**




import org.eclipse.scout.commons.annotations.ConfigProperty;
import org.eclipse.scout.commons.annotations.ConfigPropertyValue;
import org.eclipse.scout.commons.annotations.Order;
import org.eclipse.scout.commons.annotations.Replace;
import org.eclipse.scout.commons.beans.AbstractPropertyObserver;
import org.eclipse.scout.commons.dnd.TextTransferObject;
import org.eclipse.scout.commons.dnd.TransferObject;

  private final HashMap<CompositeObject, ITableRow> m_deletedRows;
  private TreeSet<ITableRow/* ordered by rowIndex */> m_selectedRows = new TreeSet<ITableRow>(new RowIndexComparator());
  private IMenu[] m_menus;
  private Map<Class<?>, Class<? extends IMenu>> m_menuReplacementMapping;
  private ITableUIFacade m_uiFacade;
  private final ArrayList<ITableRowFilter> m_rowFilters;
  private String m_userPreferenceContext;


  private Class<? extends IMenu>[] getConfiguredMenus() {
    Class[] dca = ConfigurationUtility.getDeclaredPublicClasses(getClass());
    Class<IMenu>[] foca = ConfigurationUtility.sortFilteredClassesByOrderAnnotation(dca, IMenu.class);
    return ConfigurationUtility.removeReplacedClasses(foca);
  }

  private Class<? extends IColumn>[] getConfiguredColumns() {
    Class[] dca = ConfigurationUtility.getDeclaredPublicClasses(getClass());
    Class<IColumn>[] foca = ConfigurationUtility.sortFilteredClassesByOrderAnnotation(dca, IColumn.class);
    return ConfigurationUtility.removeReplacedClasses(foca);
  }

  private Class<? extends IKeyStroke>[] getConfiguredKeyStrokes() {
    Class[] dca = ConfigurationUtility.getDeclaredPublicClasses(getClass());
    Class<IKeyStroke>[] fca = ConfigurationUtility.filterClasses(dca, IKeyStroke.class);
    return ConfigurationUtility.removeReplacedClasses(fca);
  }

  protected void initConfig() {

    // menus
    ArrayList<IMenu> menuList = new ArrayList<IMenu>();
    Class<? extends IMenu>[] ma = getConfiguredMenus();
    Map<Class<?>, Class<? extends IMenu>> replacements = ConfigurationUtility.getReplacementMapping(ma);
    if (!replacements.isEmpty()) {
      m_menuReplacementMapping = replacements;
    }
    for (int i = 0; i < ma.length; i++) {
      try {
        IMenu menu = ConfigurationUtility.newInnerInstance(this, ma[i]);


  @Override
  public <T extends IMenu> T getMenu(Class<T> menuType) throws ProcessingException {
    // ActionFinder performs instance-of checks. Hence the menu replacement mapping is not required
    return new ActionFinder().findAction(getMenus(), menuType);
  }

  @Override
  public boolean runMenu(Class<? extends IMenu> menuType) throws ProcessingException {
    Class<? extends IMenu> c = getReplacingMenuClass(menuType);
    for (IMenu m : getMenus()) {
      if (m.getClass() == c) {
        if (!m.isEnabledProcessingAction()) {
          return false;
        }

  }

  /**
   * Checks whether the menu with the given class has been replaced by another menu. If so, the replacing
   * menu's class is returned. Otherwise the given class itself.
   * 
   * @param c
   * @return Returns the possibly available replacing menu class for the given class.
   * @see Replace
   * @since 3.8.2
   */
  private <T extends IMenu> Class<? extends T> getReplacingMenuClass(Class<T> c) {
    if (m_menuReplacementMapping != null) {
      @SuppressWarnings("unchecked")
      Class<? extends T> replacingMenuClass = (Class<? extends T>) m_menuReplacementMapping.get(c);
      if (replacingMenuClass != null) {
        return replacingMenuClass;
      }
    }
    return c;
  }

  /**
   * factory to manage table column filters
   * <p>
   * default creates a {@link DefaultTableColumnFilterManager}

Lines 22-27 Link Here

(-)src/org/eclipse/scout/rt/client/ui/basic/table/ColumnSet.java (-1 / +39 lines)
22	import org.eclipse.scout.commons.CompareUtility;	22	import org.eclipse.scout.commons.CompareUtility;
23	import org.eclipse.scout.commons.CompositeObject;	23	import org.eclipse.scout.commons.CompositeObject;
24	import org.eclipse.scout.commons.ConfigurationUtility;	24	import org.eclipse.scout.commons.ConfigurationUtility;
		25	import org.eclipse.scout.commons.annotations.Replace;
25	import org.eclipse.scout.commons.logger.IScoutLogger;	26	import org.eclipse.scout.commons.logger.IScoutLogger;
26	import org.eclipse.scout.commons.logger.ScoutLogManager;	27	import org.eclipse.scout.commons.logger.ScoutLogManager;
27	import org.eclipse.scout.rt.client.ui.ClientUIPreferences;	28	import org.eclipse.scout.rt.client.ui.ClientUIPreferences;
Lines 60-66 Link Here
60	*/	61	*/
61	private final HashMap<String, IColumn> m_idIndexes = new HashMap<String, IColumn>();	62	private final HashMap<String, IColumn> m_idIndexes = new HashMap<String, IColumn>();
62		63
		64	private final Map<Class<?>, Class<? extends IColumn>> m_columnReplacements;
		65
63	public ColumnSet(AbstractTable table, Collection<IColumn> columns) {	66	public ColumnSet(AbstractTable table, Collection<IColumn> columns) {
		67	// process @Replace annotations
		68	@SuppressWarnings("unchecked")
		69	Class<? extends IColumn>[] columnArray = new Class[columns.size()];
		70	int i = 0;
		71	for (IColumn c : columns) {
		72	columnArray[i] = c.getClass();
		73	i++;
		74	}
		75	Map<Class<?>, Class<? extends IColumn>> replacements = ConfigurationUtility.getReplacementMapping(columnArray);
		76	if (replacements.isEmpty()) {
		77	replacements = null;
		78	}
		79	m_columnReplacements = replacements;
		80	//
64	m_table = table;	81	m_table = table;
65	m_columns = new IColumn[columns.size()];	82	m_columns = new IColumn[columns.size()];
66	m_userSortColumns = new ArrayList<IColumn>();	83	m_userSortColumns = new ArrayList<IColumn>();
Lines 282-288 Link Here
282		299
283	@SuppressWarnings("unchecked")	300	@SuppressWarnings("unchecked")
284	public <T extends IColumn> T getColumnByClass(Class<T> c) {	301	public <T extends IColumn> T getColumnByClass(Class<T> c) {
285	T col = (T) m_classIndexes.get(c);	302	Class<? extends T> columnClass = getReplacingColumnClass(c);
		303	T col = (T) m_classIndexes.get(columnClass);
286	return col;	304	return col;
287	}	305	}
288		306
Lines 291-296 Link Here
291	return (T) m_idIndexes.get(id);	309	return (T) m_idIndexes.get(id);
292	}	310	}
293		311
		312	/**
		313	* Checks whether the column with the given class has been replaced by another column. If so, the replacing
		314	* column's class is returned. Otherwise the given class itself.
		315	*
		316	* @param c
		317	* @return Returns the possibly available replacing column class for the given class.
		318	* @see Replace
		319	* @since 3.8.2
		320	*/
		321	private <T extends IColumn> Class<? extends T> getReplacingColumnClass(Class<T> c) {
		322	if (m_columnReplacements != null) {
		323	@SuppressWarnings("unchecked")
		324	Class<? extends T> replacingColumnClass = (Class<? extends T>) m_columnReplacements.get(c);
		325	if (replacingColumnClass != null) {
		326	return replacingColumnClass;
		327	}
		328	}
		329	return c;
		330	}
		331
294	public IColumn getDisplayableColumn(int index) {	332	public IColumn getDisplayableColumn(int index) {
295	if (index >= 0 && index < m_displayableIndexes.length) {	333	if (index >= 0 && index < m_displayableIndexes.length) {
296	return m_columns[m_displayableIndexes[index]];	334	return m_columns[m_displayableIndexes[index]];

Lines 25-30 Link Here

(-)src/org/eclipse/scout/rt/client/ui/basic/table/columns/AbstractColumn.java (-1 / +6 lines)
25	import org.eclipse.scout.commons.annotations.ConfigProperty;	25	import org.eclipse.scout.commons.annotations.ConfigProperty;
26	import org.eclipse.scout.commons.annotations.ConfigPropertyValue;	26	import org.eclipse.scout.commons.annotations.ConfigPropertyValue;
27	import org.eclipse.scout.commons.annotations.Order;	27	import org.eclipse.scout.commons.annotations.Order;
		28	import org.eclipse.scout.commons.annotations.Replace;
28	import org.eclipse.scout.commons.beans.AbstractPropertyObserver;	29	import org.eclipse.scout.commons.beans.AbstractPropertyObserver;
29	import org.eclipse.scout.commons.exception.ProcessingException;	30	import org.eclipse.scout.commons.exception.ProcessingException;
30	import org.eclipse.scout.commons.logger.IScoutLogger;	31	import org.eclipse.scout.commons.logger.IScoutLogger;
Lines 828-834 Link Here
828		829
829	@Override	830	@Override
830	public String getColumnId() {	831	public String getColumnId() {
831	String s = getClass().getSimpleName();	832	Class<?> c = getClass();
		833	while (c.isAnnotationPresent(Replace.class)) {
		834	c = c.getSuperclass();
		835	}
		836	String s = c.getSimpleName();
832	if (s.endsWith("Column")) {	837	if (s.endsWith("Column")) {
833	s = s.replaceAll("Column$", "");	838	s = s.replaceAll("Column$", "");
834	}	839	}

Lines 199-205 Link Here

(-)src/org/eclipse/scout/rt/client/ui/desktop/AbstractDesktop.java (-2 / +7 lines)
199		199
200	private Class<? extends IAction>[] getConfiguredActions() {	200	private Class<? extends IAction>[] getConfiguredActions() {
201	Class[] dca = ConfigurationUtility.getDeclaredPublicClasses(getClass());	201	Class[] dca = ConfigurationUtility.getDeclaredPublicClasses(getClass());
202	return ConfigurationUtility.filterClasses(dca, IAction.class);	202	Class<IAction>[] fca = ConfigurationUtility.filterClasses(dca, IAction.class);
		203	return ConfigurationUtility.removeReplacedClasses(fca);
203	}	204	}
204		205
205	/**	206	/**
Lines 619-624 Link Here
619		620
620	@Override	621	@Override
621	public <T extends IMenu> T getMenu(Class<? extends T> searchType) {	622	public <T extends IMenu> T getMenu(Class<? extends T> searchType) {
		623	// ActionFinder performs instance-of checks. Hence the menu replacement mapping is not required
622	return new ActionFinder().findAction(getMenus(), searchType);	624	return new ActionFinder().findAction(getMenus(), searchType);
623	}	625	}
624		626
Lines 921-928 Link Here
921		923
922	@Override	924	@Override
923	public void setOutline(Class<? extends IOutline> outlineType) {	925	public void setOutline(Class<? extends IOutline> outlineType) {
		926	if (outlineType == null) {
		927	return;
		928	}
924	for (IOutline o : getAvailableOutlines()) {	929	for (IOutline o : getAvailableOutlines()) {
925	if (o.getClass() == outlineType) {	930	if (outlineType.isInstance(o)) {
926	setOutline(o);	931	setOutline(o);
927	return;	932	return;
928	}	933	}

Lines 373-379 Link Here

(-)src/org/eclipse/scout/rt/client/ui/desktop/AbstractDesktopExtension.java (-1 / +2 lines)
373		373
374	private Class<? extends IAction>[] getConfiguredActions() {	374	private Class<? extends IAction>[] getConfiguredActions() {
375	Class<?>[] dca = ConfigurationUtility.getDeclaredPublicClasses(getClass());	375	Class<?>[] dca = ConfigurationUtility.getDeclaredPublicClasses(getClass());
376	return ConfigurationUtility.filterClasses(dca, IAction.class);	376	Class<IAction>[] fca = ConfigurationUtility.filterClasses(dca, IAction.class);
		377	return ConfigurationUtility.removeReplacedClasses(fca);
377	}	378	}
378		379
379	}	380	}




/*******************************************************************************
 * Copyright (c) 2010 BSI Business Systems Integration AG.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *     BSI Business Systems Integration AG - initial API and implementation
 ******************************************************************************/
package org.eclipse.scout.rt.client.ui.form;

import java.util.ArrayList;
import java.util.List;

import org.eclipse.scout.commons.annotations.InjectFieldTo;
import org.eclipse.scout.commons.annotations.Order;
import org.eclipse.scout.rt.client.ui.form.fields.IFormField;

/**
 * Default implementation that inserts the fields at the right place based on their {@link Order} annotation.
 * 
 * @since 3.8.1
 */
public class DefaultFormFieldInjection implements IFormFieldInjection {
  private final ArrayList<IFormField> m_list = new ArrayList<IFormField>();

  public void addField(IFormField f) {
    m_list.add(f);
  }

  @Override
  public void injectFields(IFormField container, List<IFormField> fieldList) {
    if (container == null || fieldList == null || m_list.isEmpty()) {
      return;
    }
    Class<?> containerClazz = container.getClass();
    for (IFormField f : m_list) {
      InjectFieldTo ann = f.getClass().getAnnotation(InjectFieldTo.class);
      if (ann == null) {
        continue;
      }
      if (ann.value() != containerClazz) {
        continue;
      }
      insertField(fieldList, f);
    }
  }

  /**
   * add the field f to the list at the right place regarding the {@link Order} annotation
   */
  protected void insertField(List<IFormField> list, IFormField f) {
    //check if list already contains f
    if (list.contains(f)) {
      return;
    }
    Class<?> c = f.getClass();
    if (!c.isAnnotationPresent(Order.class)) {
      list.add(f);
      return;
    }
    double newOrder = c.getAnnotation(Order.class).value();
    for (int i = 0, n = list.size(); i < n; i++) {
      Class<?> existingClazz = list.get(i).getClass();
      if (existingClazz.isAnnotationPresent(Order.class)) {
        double existingOrder = existingClazz.getAnnotation(Order.class).value();
        if (newOrder < existingOrder) {
          list.add(i, f);
          return;
        }
      }
    }
    //default at end
    list.add(f);
  }
}




import java.util.List;

import org.eclipse.scout.commons.annotations.InjectFieldTo;
import org.eclipse.scout.commons.annotations.Replace;
import org.eclipse.scout.rt.client.ui.form.fields.AbstractFormField;
import org.eclipse.scout.rt.client.ui.form.fields.IFormField;

/**
 * Thread local used to inject form fields using the {@link InjectFieldTo} and {@link Replace} annotations.
 * <p>
 * This thread local is used by {@link AbstractForm} and {@link AbstractFormField} to put its contributions.
 * <p>


  /**
   * @param container
   *          is the container field the given field classes are created for
   * @param fieldList
   *          live and mutable list of configured field classes (i.e. yet not instantiated)
   * @since 3.8.2
   */
  public static void filterFields(IFormField container, List<Class<? extends IFormField>> fieldList) {
    THREAD_LOCAL.get().filterFieldsInternal(container, fieldList);
  }

  /**
   * @param container
   *          is the container field that is being added potential injected fields
   * @param fieldList
   *          live and mutable list of currently (configured) fields, not yet initialized

      i.injectFields(container, fieldList);
    }
  }

  private void filterFieldsInternal(IFormField container, List<Class<? extends IFormField>> fieldList) {
    if (m_stack.isEmpty()) {
      return;
    }
    for (IFormFieldInjection i : m_stack) {
      if (i instanceof IFormFieldInjection2) {
        ((IFormFieldInjection2) i).filterFields(container, fieldList);
      }
    }
  }
}

Lines 21-28 Link Here

(-)src/org/eclipse/scout/rt/client/ui/form/AbstractForm.java (-40 / +35 lines)
21	import java.nio.charset.Charset;	21	import java.nio.charset.Charset;
22	import java.security.Permission;	22	import java.security.Permission;
23	import java.util.ArrayList;	23	import java.util.ArrayList;
24	import java.util.Arrays;
25	import java.util.Comparator;
26	import java.util.EventListener;	24	import java.util.EventListener;
27	import java.util.HashMap;	25	import java.util.HashMap;
28	import java.util.HashSet;	26	import java.util.HashSet;
Lines 139-144 Link Here
139	private DataChangeListener m_internalDataChangeListener;	137	private DataChangeListener m_internalDataChangeListener;
140	private IEventHistory<FormEvent> m_eventHistory;	138	private IEventHistory<FormEvent> m_eventHistory;
141		139
		140	// field replacement support
		141	private Map<Class<?>, Class<? extends IFormField>> m_fieldReplacements;
		142
142	public AbstractForm() throws ProcessingException {	143	public AbstractForm() throws ProcessingException {
143	this(true);	144	this(true);
144	}	145	}
Lines 452-478 Link Here
452		453
453	private Class<? extends IFormField>[] getConfiguredInjectedFields() {	454	private Class<? extends IFormField>[] getConfiguredInjectedFields() {
454	Class[] dca = ConfigurationUtility.getDeclaredPublicClasses(getClass());	455	Class[] dca = ConfigurationUtility.getDeclaredPublicClasses(getClass());
455	Class<IFormField>[] filteredClasses = ConfigurationUtility.filterClassesWithInjectFieldAnnotation(dca, IFormField.class);	456	return ConfigurationUtility.filterClassesWithInjectFieldAnnotation(dca, IFormField.class);
456	// sort injected fields by enclosing class so that sub classes are before parent classes
457	// this order is required so that sub classes may inject fields to other injected fields defined in a super class
458	// see https://bugs.eclipse.org/bugs/show_bug.cgi?id=392972
459	Comparator<Class<?>> comparator = new Comparator<Class<?>>() {
460	@Override
461	public int compare(Class<?> c1, Class<?> c2) {
462	Class<?> ec1 = c1.getEnclosingClass();
463	Class<?> ec2 = c2.getEnclosingClass();
464
465	if (ec1 == ec2) {
466	return 0;
467	}
468	if (ec2 != null && ec2.getSuperclass() == ec1) {
469	return 1;
470	}
471	return -1;
472	}
473	};
474	Arrays.sort(filteredClasses, comparator);
475	return filteredClasses;
476	}	457	}
477		458
478	protected void initConfig() throws ProcessingException {	459	protected void initConfig() throws ProcessingException {
Lines 482-506 Link Here
482	// prepare injected fields	463	// prepare injected fields
483	Class<? extends IFormField>[] fieldArray = getConfiguredInjectedFields();	464	Class<? extends IFormField>[] fieldArray = getConfiguredInjectedFields();
484	DefaultFormFieldInjection injectedFields = null;	465	DefaultFormFieldInjection injectedFields = null;
485	if (fieldArray.length > 0) {
486	injectedFields = new DefaultFormFieldInjection();
487	}
488	IGroupBox rootBox = getRootGroupBox();	466	IGroupBox rootBox = getRootGroupBox();
489	try {	467	try {
490	if (injectedFields != null) {	468	if (fieldArray.length > 0) {
		469	injectedFields = new DefaultFormFieldInjection(this);
		470	injectedFields.addFields(fieldArray);
491	FormFieldInjectionThreadLocal.push(injectedFields);	471	FormFieldInjectionThreadLocal.push(injectedFields);
492	// create instances of injected fields
493	for (Class<? extends IFormField> clazz : fieldArray) {
494	try {
495	IFormField f = ConfigurationUtility.newInnerInstance(this, clazz);
496	if (f != null) {
497	injectedFields.addField(f);
498	}
499	}// end try
500	catch (Throwable t) {
501	SERVICES.getService(IExceptionHandlerService.class).handleException(new ProcessingException("field: " + clazz.getName(), t));
502	}
503	}
504	}	472	}
505	//	473	//
506	// add mainbox if getter returns null	474	// add mainbox if getter returns null
Lines 517-522 Link Here
517	}	485	}
518	finally {	486	finally {
519	if (injectedFields != null) {	487	if (injectedFields != null) {
		488	m_fieldReplacements = injectedFields.getReplacementMapping();
520	FormFieldInjectionThreadLocal.pop(injectedFields);	489	FormFieldInjectionThreadLocal.pop(injectedFields);
521	}	490	}
522	}	491	}
Lines 2117-2123 Link Here
2117	}	2086	}
2118		2087
2119	/**	2088	/**
2120	* Model Observer .	2089	* @return Returns a map having old field classes as keys and replacement field classes as values. <code>null</code> is
		2090	* returned if no form fields are replaced. Do not use this internal method.
		2091	* @since 3.8.2
		2092	*/
		2093	public Map<Class<?>, Class<? extends IFormField>> getFormFieldReplacementsInternal() {
		2094	return m_fieldReplacements;
		2095	}
		2096
		2097	/**
		2098	* Registers the given form field replacements on this form. Do not use this internal method.
		2099	*
		2100	* @param replacements
		2101	* Map having old field classes as key and replacing field classes as values.
		2102	* @since 3.8.2
		2103	*/
		2104	public void registerFormFieldReplacementsInternal(Map<Class<?>, Class<? extends IFormField>> replacements) {
		2105	if (replacements == null \|\| replacements.isEmpty()) {
		2106	return;
		2107	}
		2108	if (m_fieldReplacements == null) {
		2109	m_fieldReplacements = new HashMap<Class<?>, Class<? extends IFormField>>();
		2110	}
		2111	m_fieldReplacements.putAll(replacements);
		2112	}
		2113
		2114	/**
		2115	* Model Observer.
2121	*/	2116	*/
2122	@Override	2117	@Override
2123	public void addFormListener(FormListener listener) {	2118	public void addFormListener(FormListener listener) {

Lines 347-353 Link Here

(-)src/org/eclipse/scout/rt/client/ui/form/fields/smartfield/AbstractSmartField.java (-1 / +2 lines)
347		347
348	private Class<? extends IMenu>[] getConfiguredMenus() {	348	private Class<? extends IMenu>[] getConfiguredMenus() {
349	Class[] dca = ConfigurationUtility.getDeclaredPublicClasses(getClass());	349	Class[] dca = ConfigurationUtility.getDeclaredPublicClasses(getClass());
350	return ConfigurationUtility.sortFilteredClassesByOrderAnnotation(dca, IMenu.class);	350	Class<IMenu>[] foca = ConfigurationUtility.sortFilteredClassesByOrderAnnotation(dca, IMenu.class);
		351	return ConfigurationUtility.removeReplacedClasses(foca);
351	}	352	}
352		353
353	// override to freeze	354	// override to freeze

Lines 128-134 Link Here

(-)src/org/eclipse/scout/rt/client/ui/form/fields/filechooserfield/AbstractFileChooserField.java (-1 / +2 lines)
128		128
129	private Class<? extends IMenu>[] getConfiguredMenus() {	129	private Class<? extends IMenu>[] getConfiguredMenus() {
130	Class<?>[] dca = ConfigurationUtility.getDeclaredPublicClasses(getClass());	130	Class<?>[] dca = ConfigurationUtility.getDeclaredPublicClasses(getClass());
131	return ConfigurationUtility.sortFilteredClassesByOrderAnnotation(dca, IMenu.class);	131	Class<IMenu>[] foca = ConfigurationUtility.sortFilteredClassesByOrderAnnotation(dca, IMenu.class);
		132	return ConfigurationUtility.removeReplacedClasses(foca);
132	}	133	}
133		134
134	@Override	135	@Override

Lines 138-144 Link Here

(-)src/org/eclipse/scout/rt/client/ui/form/fields/imagebox/AbstractImageField.java (-1 / +2 lines)
138		138
139	private Class<? extends IMenu>[] getConfiguredMenus() {	139	private Class<? extends IMenu>[] getConfiguredMenus() {
140	Class[] dca = ConfigurationUtility.getDeclaredPublicClasses(getClass());	140	Class[] dca = ConfigurationUtility.getDeclaredPublicClasses(getClass());
141	return ConfigurationUtility.sortFilteredClassesByOrderAnnotation(dca, IMenu.class);	141	Class<IMenu>[] foca = ConfigurationUtility.sortFilteredClassesByOrderAnnotation(dca, IMenu.class);
		142	return ConfigurationUtility.removeReplacedClasses(foca);
142	}	143	}
143		144
144	@Override	145	@Override




import java.beans.PropertyChangeListener;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;

import org.eclipse.scout.commons.ConfigurationUtility;
import org.eclipse.scout.commons.annotations.InjectFieldTo;
import org.eclipse.scout.commons.annotations.Replace;
import org.eclipse.scout.commons.exception.ProcessingException;
import org.eclipse.scout.commons.holders.Holder;
import org.eclipse.scout.rt.client.ui.form.AbstractForm;
import org.eclipse.scout.rt.client.ui.form.DefaultFormFieldInjection;
import org.eclipse.scout.rt.client.ui.form.FormFieldInjectionThreadLocal;
import org.eclipse.scout.rt.client.ui.form.IForm;

public abstract class AbstractCompositeField extends AbstractFormField implements ICompositeField {

  private IFormField[] m_fields;
  private Map<Class<?>, Class<? extends IFormField>> m_formFieldReplacements;

  public AbstractCompositeField() {
    this(true);

    Class<? extends IFormField>[] fieldArray = getConfiguredFields();
    // prepare injected fields
    DefaultFormFieldInjection injectedFields = null;
    List<Class<? extends IFormField>> configuredFields = new ArrayList<Class<? extends IFormField>>();
    for (Class<? extends IFormField> clazz : fieldArray) {
      if (ConfigurationUtility.isInjectFieldAnnotationPresent(clazz)) {
        if (injectedFields == null) {
          injectedFields = new DefaultFormFieldInjection(this);
      try {
        IFormField f = ConfigurationUtility.newInnerInstance(this, clazz);
        if (f != null) {
          if (injectedFields == null) {
            injectedFields = new DefaultFormFieldInjection();
          }
          injectedFields.addField(f);
        }
        injectedFields.addField(clazz);
      }
      else {
        configuredFields.add(clazz);
      }
    }
    ArrayList<IFormField> fieldList = new ArrayList<IFormField>();

        FormFieldInjectionThreadLocal.push(injectedFields);
      }
      //
      filterFieldsInternal(configuredFields);
      for (Class<? extends IFormField> clazz : configuredFields) {
          continue;
        }
        try {
          IFormField f = ConfigurationUtility.newInnerInstance(this, clazz);
          fieldList.add(f);

    }
    finally {
      if (injectedFields != null) {
        m_formFieldReplacements = injectedFields.getReplacementMapping();
        FormFieldInjectionThreadLocal.pop(injectedFields);
      }
    }

  }

  /**
   * Filter list of configured fields before they are instantiated.
   * <p/>
   * The default implementation removes fields replaced by another field annotated with {@link Replace}.
   * 
   * @param fieldList
   *          live and mutable list of configured field classes (i.e. yet not instantiated)
   * @since 3.8.2
   */
  protected void filterFieldsInternal(List<Class<? extends IFormField>> fieldList) {
    FormFieldInjectionThreadLocal.filterFields(this, fieldList);
  }

  /**
   * Override this internal method only in order to make use of dynamic fields<br>
   * Used to manage field list and add/remove fields (see {@link AbstractGroupBox} with wizard buttons)
   * <p>

  @Override
  public void setFormInternal(IForm form) {
    super.setFormInternal(form);
    if (form instanceof AbstractForm) {
      ((AbstractForm) form).registerFormFieldReplacementsInternal(m_formFieldReplacements);
    }
    IFormField[] a = m_fields;
    for (int i = 0; i < a.length; i++) {
      IFormField f = a[i];

  }

  @Override
  public <T extends IFormField> T getFieldByClass(Class<T> c) {
    final Class<? extends T> formFieldClass = getReplacingFieldClass(c);
    final Holder<T> found = new Holder<T>(c);
    IFormFieldVisitor v = new IFormFieldVisitor() {
      @Override
      @SuppressWarnings("unchecked")
      public boolean visitField(IFormField field, int level, int fieldIndex) {
        if (field.getClass() == formFieldClass) {
          found.setValue((T) field);
        }
        return found.getValue() == null;

    return found.getValue();
  }

  /**
   * Checks whether the form field with the given class has been replaced by another form field. If so, the replacing
   * form field's class is returned. Otherwise the given class itself.
   * 
   * @param c
   * @return Returns the possibly available replacing field class for the given class.
   * @see Replace
   * @since 3.8.2
   */
  private <T extends IFormField> Class<? extends T> getReplacingFieldClass(Class<T> c) {
    IForm form = getForm();
    if (form instanceof AbstractForm) {
      Map<Class<?>, Class<? extends IFormField>> mapping = ((AbstractForm) form).getFormFieldReplacementsInternal();
      if (mapping != null) {
        @SuppressWarnings("unchecked")
        Class<? extends T> replacementFieldClass = (Class<? extends T>) mapping.get(c);
        if (replacementFieldClass != null) {
          return replacementFieldClass;
        }
      }
    }
    return c;
  }

  @Override
  public IFormField[] getFields() {
    IFormField[] a = new IFormField[m_fields.length];




import org.eclipse.scout.commons.annotations.FormData;
import org.eclipse.scout.commons.annotations.FormData.SdkCommand;
import org.eclipse.scout.commons.annotations.Order;
import org.eclipse.scout.commons.annotations.Replace;
import org.eclipse.scout.commons.beans.AbstractPropertyObserver;
import org.eclipse.scout.commons.beans.BasicPropertySupport;
import org.eclipse.scout.commons.exception.IProcessingStatus;
import org.eclipse.scout.commons.exception.ProcessingException;
import org.eclipse.scout.commons.exception.ProcessingStatus;
import org.eclipse.scout.commons.holders.Holder;
import org.eclipse.scout.commons.logger.IScoutLogger;
import org.eclipse.scout.commons.logger.ScoutLogManager;
import org.eclipse.scout.commons.xmlparser.SimpleXmlElement;

import org.eclipse.scout.rt.client.ui.action.keystroke.IKeyStroke;
import org.eclipse.scout.rt.client.ui.desktop.IDesktop;
import org.eclipse.scout.rt.client.ui.form.IForm;
import org.eclipse.scout.rt.client.ui.form.IFormFieldVisitor;
import org.eclipse.scout.rt.client.ui.form.PrintDevice;
import org.eclipse.scout.rt.client.ui.form.fields.button.IButton;
import org.eclipse.scout.rt.client.ui.form.fields.groupbox.AbstractGroupBox;


  private Class<? extends IKeyStroke>[] getConfiguredKeyStrokes() {
    Class[] dca = ConfigurationUtility.getDeclaredPublicClasses(getClass());
    Class<IKeyStroke>[] fca = ConfigurationUtility.filterClasses(dca, IKeyStroke.class);
    return ConfigurationUtility.removeReplacedClasses(fca);
  }

  @ConfigOperation

      return getForm().getFieldByClass(c);
    }

    final Holder<T> found = new Holder<T>(c);
    IFormFieldVisitor v = new IFormFieldVisitor() {
      @Override
      @SuppressWarnings("unchecked")
      public boolean visitField(IFormField field, int level, int fieldIndex) {
        if (field.getClass() == c) {
          found.setValue((T) field);
        }
        return found.getValue() == null;
      }
    };

    // search requested field within critical parent field
    Collections.reverse(enclosingFields);
    for (ICompositeField parentField : enclosingFields) {
      T field = parentField.getFieldByClass(c);
      if (field != null) {
        return field;
      }
    }



  @Override
  public String getFieldId() {
    Class<?> c = getClass();
    while (c.isAnnotationPresent(Replace.class)) {
      c = c.getSuperclass();
    }
    return c.getSimpleName();
  }

  /*

        SERVICES.getService(IExceptionHandlerService.class).handleException(new ProcessingException("keyStroke: " + shortcutArray[i].getName(), t));
      }
    }
    List<IKeyStroke> ksList = new ArrayList<IKeyStroke>(ksMap.values());
    return ksList.toArray(new IKeyStroke[ksList.size()]);
  }

  @Override

Lines 210-216 Link Here

(-)src/org/eclipse/scout/rt/client/ui/form/fields/button/AbstractButton.java (-1 / +2 lines)
210		210
211	private Class<? extends IMenu>[] getConfiguredMenus() {	211	private Class<? extends IMenu>[] getConfiguredMenus() {
212	Class[] dca = ConfigurationUtility.getDeclaredPublicClasses(getClass());	212	Class[] dca = ConfigurationUtility.getDeclaredPublicClasses(getClass());
213	return ConfigurationUtility.sortFilteredClassesByOrderAnnotation(dca, IMenu.class);	213	Class<IMenu>[] foca = ConfigurationUtility.sortFilteredClassesByOrderAnnotation(dca, IMenu.class);
		214	return ConfigurationUtility.removeReplacedClasses(foca);
214	}	215	}
215		216
216	@Override	217	@Override




/*******************************************************************************
 * Copyright (c) 2010 BSI Business Systems Integration AG.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *     BSI Business Systems Integration AG - initial API and implementation
 ******************************************************************************/
package org.eclipse.scout.rt.client.ui.form;

import java.util.List;

import org.eclipse.scout.rt.client.ui.form.fields.IFormField;

/**
 * Interface extension to {@link IFormFieldInjection} that provides additional methods for filtering form fields before
 * they are initialized.
 * 
 * @since 3.8.2
 */
public interface IFormFieldInjection2 extends IFormFieldInjection {

  /**
   * @param container
   *          is the container field the given field classes are created for
   * @param fieldList
   *          live and mutable list of configured field classes (i.e. yet not instantiated)
   * @since 3.8.2
   */
  void filterFields(IFormField container, List<Class<? extends IFormField>> fieldList);
}

Lines 34-39 Link Here

(-)src/org/eclipse/scout/rt/extension/client/ExtensionUtilityTest.java (+1 lines)
34	/**	34	/**
35	* @since 3.9.0	35	* @since 3.9.0
36	*/	36	*/
		37	@SuppressWarnings("deprecation")
37	public class ExtensionUtilityTest {	38	public class ExtensionUtilityTest {
38		39
39	private List<Object> m_instanceList;	40	private List<Object> m_instanceList;

Lines 22-27 Link Here

(-)src/org/eclipse/scout/rt/extension/client/ui/basic/table/ExtensibleTableTest.java (+1 lines)
22	/**	22	/**
23	* @since 3.9.0	23	* @since 3.9.0
24	*/	24	*/
		25	@SuppressWarnings("deprecation")
25	public class ExtensibleTableTest {	26	public class ExtensibleTableTest {
26		27
27	@Test	28	@Test




package formdata.shared.services.process.replace;

import org.eclipse.scout.rt.shared.data.form.ValidationRule;
import org.eclipse.scout.rt.shared.data.form.fields.AbstractValueFieldData;
import org.eclipse.scout.rt.shared.data.form.AbstractFormData;

public class BaseFormData extends AbstractFormData {
  private static final long serialVersionUID = 1L;

  public BaseFormData() {
  }

  public Lookup getLookup() {
    return getFieldByClass(Lookup.class);
  }

  public Name getName() {
    return getFieldByClass(Name.class);
  }

  public SdkCommandCreate getSdkCommandCreate() {
    return getFieldByClass(SdkCommandCreate.class);
  }

  public SdkCommandNone getSdkCommandNone() {
    return getFieldByClass(SdkCommandNone.class);
  }

  public SdkCommandUse getSdkCommandUse() {
    return getFieldByClass(SdkCommandUse.class);
  }

  public Smart getSmart() {
    return getFieldByClass(Smart.class);
  }

  public static class Lookup extends AbstractValueFieldData<Long> {
    private static final long serialVersionUID = 1L;

    public Lookup() {
    }

    /**
     * list of derived validation rules.
     */
    @Override
    protected void initValidationRules(java.util.Map<String, Object> ruleMap) {
      super.initValidationRules(ruleMap);
      ruleMap.put(ValidationRule.LOOKUP_CALL, TestingLookupCall.class);
      ruleMap.put(ValidationRule.ZERO_NULL_EQUALITY, true);
    }
  }

  public static class Name extends AbstractValueFieldData<String> {
    private static final long serialVersionUID = 1L;

    public Name() {
    }

    /**
     * list of derived validation rules.
     */
    @Override
    protected void initValidationRules(java.util.Map<String, Object> ruleMap) {
      super.initValidationRules(ruleMap);
      ruleMap.put(ValidationRule.MANDATORY, true);
      ruleMap.put(ValidationRule.MAX_LENGTH, 60);
    }
  }

  public static class SdkCommandCreate extends AbstractValueFieldData<String> {
    private static final long serialVersionUID = 1L;

    public SdkCommandCreate() {
    }

    /**
     * list of derived validation rules.
     */
    @Override
    protected void initValidationRules(java.util.Map<String, Object> ruleMap) {
      super.initValidationRules(ruleMap);
      ruleMap.put(ValidationRule.MAX_LENGTH, 4000);
    }
  }

  public static class SdkCommandNone extends AbstractValueFieldData<String> {
    private static final long serialVersionUID = 1L;

    public SdkCommandNone() {
    }

    /**
     * list of derived validation rules.
     */
    @Override
    protected void initValidationRules(java.util.Map<String, Object> ruleMap) {
      super.initValidationRules(ruleMap);
      ruleMap.put(ValidationRule.MAX_LENGTH, 4000);
    }
  }

  public static class SdkCommandUse extends UsingFormFieldData {
    private static final long serialVersionUID = 1L;

    public SdkCommandUse() {
    }

    /**
     * list of derived validation rules.
     */
    @Override
    protected void initValidationRules(java.util.Map<String, Object> ruleMap) {
      super.initValidationRules(ruleMap);
      ruleMap.put(ValidationRule.MAX_LENGTH, 4000);
    }
  }

  public static class Smart extends AbstractValueFieldData<Long> {
    private static final long serialVersionUID = 1L;

    public Smart() {
    }

    /**
     * list of derived validation rules.
     */
    @Override
    protected void initValidationRules(java.util.Map<String, Object> ruleMap) {
      super.initValidationRules(ruleMap);
      ruleMap.put(ValidationRule.CODE_TYPE, TestingCodeType.class);
      ruleMap.put(ValidationRule.ZERO_NULL_EQUALITY, true);
    }
  }
}




package formdata.shared.services.process.replace;

import org.eclipse.scout.commons.annotations.Replace;
import org.eclipse.scout.rt.shared.data.form.ValidationRule;
import org.eclipse.scout.rt.shared.data.form.fields.AbstractValueFieldData;
import org.eclipse.scout.rt.shared.data.form.properties.AbstractPropertyData;

public class ExtendedExtendedFormData extends ExtendedFormData {
  private static final long serialVersionUID = 1L;

  public ExtendedExtendedFormData() {
  }

  public IgnoringGroupBoxExCreateNone getIgnoringGroupBoxExCreateNone() {
    return getFieldByClass(IgnoringGroupBoxExCreateNone.class);
  }

  public IgnoringGroupBoxExNoneCreate getIgnoringGroupBoxExNoneCreate() {
    return getFieldByClass(IgnoringGroupBoxExNoneCreate.class);
  }

  public NameExEx getNameExEx() {
    return getFieldByClass(NameExEx.class);
  }

  public SdkCommandCreateCreateCreate getSdkCommandCreateCreateCreate() {
    return getFieldByClass(SdkCommandCreateCreateCreate.class);
  }

  public SdkCommandCreateCreateIgnore getSdkCommandCreateCreateIgnore() {
    return getFieldByClass(SdkCommandCreateCreateIgnore.class);
  }

  public SdkCommandCreateCreateNone getSdkCommandCreateCreateNone() {
    return getFieldByClass(SdkCommandCreateCreateNone.class);
  }

  public SdkCommandCreateCreateUse getSdkCommandCreateCreateUse() {
    return getFieldByClass(SdkCommandCreateCreateUse.class);
  }

  public SdkCommandCreateIgnoreCreate getSdkCommandCreateIgnoreCreate() {
    return getFieldByClass(SdkCommandCreateIgnoreCreate.class);
  }

  public SdkCommandCreateIgnoreIgnore getSdkCommandCreateIgnoreIgnore() {
    return getFieldByClass(SdkCommandCreateIgnoreIgnore.class);
  }

  public SdkCommandCreateIgnoreNone getSdkCommandCreateIgnoreNone() {
    return getFieldByClass(SdkCommandCreateIgnoreNone.class);
  }

  public SdkCommandCreateIgnoreUse getSdkCommandCreateIgnoreUse() {
    return getFieldByClass(SdkCommandCreateIgnoreUse.class);
  }

  public SdkCommandCreateNoneCreate getSdkCommandCreateNoneCreate() {
    return getFieldByClass(SdkCommandCreateNoneCreate.class);
  }

  public SdkCommandCreateNoneIgnore getSdkCommandCreateNoneIgnore() {
    return getFieldByClass(SdkCommandCreateNoneIgnore.class);
  }

  public SdkCommandCreateNoneNone getSdkCommandCreateNoneNone() {
    return getFieldByClass(SdkCommandCreateNoneNone.class);
  }

  public SdkCommandCreateNoneUse getSdkCommandCreateNoneUse() {
    return getFieldByClass(SdkCommandCreateNoneUse.class);
  }

  public SdkCommandCreateUseCreate getSdkCommandCreateUseCreate() {
    return getFieldByClass(SdkCommandCreateUseCreate.class);
  }

  public SdkCommandCreateUseIgnore getSdkCommandCreateUseIgnore() {
    return getFieldByClass(SdkCommandCreateUseIgnore.class);
  }

  public SdkCommandCreateUseNone getSdkCommandCreateUseNone() {
    return getFieldByClass(SdkCommandCreateUseNone.class);
  }

  public SdkCommandCreateUseUse getSdkCommandCreateUseUse() {
    return getFieldByClass(SdkCommandCreateUseUse.class);
  }

  public SdkCommandIgnoreCreateCreate getSdkCommandIgnoreCreateCreate() {
    return getFieldByClass(SdkCommandIgnoreCreateCreate.class);
  }

  public SdkCommandIgnoreCreateIgnore getSdkCommandIgnoreCreateIgnore() {
    return getFieldByClass(SdkCommandIgnoreCreateIgnore.class);
  }

  public SdkCommandIgnoreCreateNone getSdkCommandIgnoreCreateNone() {
    return getFieldByClass(SdkCommandIgnoreCreateNone.class);
  }

  public SdkCommandIgnoreCreateUse getSdkCommandIgnoreCreateUse() {
    return getFieldByClass(SdkCommandIgnoreCreateUse.class);
  }

  public SdkCommandIgnoreIgnoreCreate getSdkCommandIgnoreIgnoreCreate() {
    return getFieldByClass(SdkCommandIgnoreIgnoreCreate.class);
  }

  public SdkCommandIgnoreIgnoreUse getSdkCommandIgnoreIgnoreUse() {
    return getFieldByClass(SdkCommandIgnoreIgnoreUse.class);
  }

  public SdkCommandIgnoreNoneCreate getSdkCommandIgnoreNoneCreate() {
    return getFieldByClass(SdkCommandIgnoreNoneCreate.class);
  }

  public SdkCommandIgnoreNoneUse getSdkCommandIgnoreNoneUse() {
    return getFieldByClass(SdkCommandIgnoreNoneUse.class);
  }

  public SdkCommandIgnoreUseCreate getSdkCommandIgnoreUseCreate() {
    return getFieldByClass(SdkCommandIgnoreUseCreate.class);
  }

  public SdkCommandIgnoreUseIgnore getSdkCommandIgnoreUseIgnore() {
    return getFieldByClass(SdkCommandIgnoreUseIgnore.class);
  }

  public SdkCommandIgnoreUseNone getSdkCommandIgnoreUseNone() {
    return getFieldByClass(SdkCommandIgnoreUseNone.class);
  }

  public SdkCommandIgnoreUseUse getSdkCommandIgnoreUseUse() {
    return getFieldByClass(SdkCommandIgnoreUseUse.class);
  }

  public SdkCommandNoneCreateCreate getSdkCommandNoneCreateCreate() {
    return getFieldByClass(SdkCommandNoneCreateCreate.class);
  }

  public SdkCommandNoneCreateIgnore getSdkCommandNoneCreateIgnore() {
    return getFieldByClass(SdkCommandNoneCreateIgnore.class);
  }

  public SdkCommandNoneCreateNone getSdkCommandNoneCreateNone() {
    return getFieldByClass(SdkCommandNoneCreateNone.class);
  }

  public SdkCommandNoneCreateUse getSdkCommandNoneCreateUse() {
    return getFieldByClass(SdkCommandNoneCreateUse.class);
  }

  public SdkCommandNoneIgnoreCreate getSdkCommandNoneIgnoreCreate() {
    return getFieldByClass(SdkCommandNoneIgnoreCreate.class);
  }

  public SdkCommandNoneIgnoreIgnore getSdkCommandNoneIgnoreIgnore() {
    return getFieldByClass(SdkCommandNoneIgnoreIgnore.class);
  }

  public SdkCommandNoneIgnoreNone getSdkCommandNoneIgnoreNone() {
    return getFieldByClass(SdkCommandNoneIgnoreNone.class);
  }

  public SdkCommandNoneIgnoreUse getSdkCommandNoneIgnoreUse() {
    return getFieldByClass(SdkCommandNoneIgnoreUse.class);
  }

  public SdkCommandNoneNoneCreate getSdkCommandNoneNoneCreate() {
    return getFieldByClass(SdkCommandNoneNoneCreate.class);
  }

  public SdkCommandNoneNoneIgnore getSdkCommandNoneNoneIgnore() {
    return getFieldByClass(SdkCommandNoneNoneIgnore.class);
  }

  public SdkCommandNoneNoneNone getSdkCommandNoneNoneNone() {
    return getFieldByClass(SdkCommandNoneNoneNone.class);
  }

  public SdkCommandNoneNoneUse getSdkCommandNoneNoneUse() {
    return getFieldByClass(SdkCommandNoneNoneUse.class);
  }

  public SdkCommandNoneUseCreate getSdkCommandNoneUseCreate() {
    return getFieldByClass(SdkCommandNoneUseCreate.class);
  }

  public SdkCommandNoneUseIgnore getSdkCommandNoneUseIgnore() {
    return getFieldByClass(SdkCommandNoneUseIgnore.class);
  }

  public SdkCommandNoneUseNone getSdkCommandNoneUseNone() {
    return getFieldByClass(SdkCommandNoneUseNone.class);
  }

  public SdkCommandNoneUseUse getSdkCommandNoneUseUse() {
    return getFieldByClass(SdkCommandNoneUseUse.class);
  }

  public SdkCommandUseCreateCreate getSdkCommandUseCreateCreate() {
    return getFieldByClass(SdkCommandUseCreateCreate.class);
  }

  public SdkCommandUseCreateIgnore getSdkCommandUseCreateIgnore() {
    return getFieldByClass(SdkCommandUseCreateIgnore.class);
  }

  public SdkCommandUseCreateNone getSdkCommandUseCreateNone() {
    return getFieldByClass(SdkCommandUseCreateNone.class);
  }

  public SdkCommandUseCreateUse getSdkCommandUseCreateUse() {
    return getFieldByClass(SdkCommandUseCreateUse.class);
  }

  public SdkCommandUseIgnoreCreate getSdkCommandUseIgnoreCreate() {
    return getFieldByClass(SdkCommandUseIgnoreCreate.class);
  }

  public SdkCommandUseIgnoreIgnore getSdkCommandUseIgnoreIgnore() {
    return getFieldByClass(SdkCommandUseIgnoreIgnore.class);
  }

  public SdkCommandUseIgnoreNone getSdkCommandUseIgnoreNone() {
    return getFieldByClass(SdkCommandUseIgnoreNone.class);
  }

  public SdkCommandUseIgnoreUse getSdkCommandUseIgnoreUse() {
    return getFieldByClass(SdkCommandUseIgnoreUse.class);
  }

  public SdkCommandUseNoneCreate getSdkCommandUseNoneCreate() {
    return getFieldByClass(SdkCommandUseNoneCreate.class);
  }

  public SdkCommandUseNoneIgnore getSdkCommandUseNoneIgnore() {
    return getFieldByClass(SdkCommandUseNoneIgnore.class);
  }

  public SdkCommandUseNoneNone getSdkCommandUseNoneNone() {
    return getFieldByClass(SdkCommandUseNoneNone.class);
  }

  public SdkCommandUseNoneUse getSdkCommandUseNoneUse() {
    return getFieldByClass(SdkCommandUseNoneUse.class);
  }

  public SdkCommandUseUseCreate getSdkCommandUseUseCreate() {
    return getFieldByClass(SdkCommandUseUseCreate.class);
  }

  public SdkCommandUseUseIgnore getSdkCommandUseUseIgnore() {
    return getFieldByClass(SdkCommandUseUseIgnore.class);
  }

  public SdkCommandUseUseNone getSdkCommandUseUseNone() {
    return getFieldByClass(SdkCommandUseUseNone.class);
  }

  public SdkCommandUseUseUse getSdkCommandUseUseUse() {
    return getFieldByClass(SdkCommandUseUseUse.class);
  }

  @Replace
  public static class IgnoringGroupBoxExCreateNone extends ExtendedFormData.IgnoringGroupBoxExCreate {
    private static final long serialVersionUID = 1L;

    public IgnoringGroupBoxExCreateNone() {
    }
  }

  @Replace
  public static class IgnoringGroupBoxExNoneCreate extends AbstractValueFieldData<String> {
    private static final long serialVersionUID = 1L;

    public IgnoringGroupBoxExNoneCreate() {
    }

    /**
     * list of derived validation rules.
     */
    @Override
    protected void initValidationRules(java.util.Map<String, Object> ruleMap) {
      super.initValidationRules(ruleMap);
      ruleMap.put(ValidationRule.MAX_LENGTH, 4000);
    }
  }

  @Replace
  public static class NameExEx extends ExtendedFormData.NameEx {
    private static final long serialVersionUID = 1L;

    public NameExEx() {
    }

    public StringPropertyProperty getStringPropertyProperty() {
      return getPropertyByClass(StringPropertyProperty.class);
    }

    /**
     * access method for property StringProperty.
     */
    public String getStringProperty() {
      return getStringPropertyProperty().getValue();
    }

    /**
     * access method for property StringProperty.
     */
    public void setStringProperty(String stringProperty) {
      getStringPropertyProperty().setValue(stringProperty);
    }

    public class StringPropertyProperty extends AbstractPropertyData<String> {
      private static final long serialVersionUID = 1L;

      public StringPropertyProperty() {
      }
    }

    /**
     * list of derived validation rules.
     */
    @Override
    protected void initValidationRules(java.util.Map<String, Object> ruleMap) {
      super.initValidationRules(ruleMap);
      ruleMap.put(ValidationRule.MAX_LENGTH, 15);
    }
  }

  @Replace
  public static class SdkCommandCreateCreateCreate extends ExtendedFormData.SdkCommandCreateCreate {
    private static final long serialVersionUID = 1L;

    public SdkCommandCreateCreateCreate() {
    }
  }

  @Replace
  public static class SdkCommandCreateCreateIgnore extends ExtendedFormData.SdkCommandCreateCreate {
    private static final long serialVersionUID = 1L;

    public SdkCommandCreateCreateIgnore() {
    }
  }

  @Replace
  public static class SdkCommandCreateCreateNone extends ExtendedFormData.SdkCommandCreateCreate {
    private static final long serialVersionUID = 1L;

    public SdkCommandCreateCreateNone() {
    }
  }

  @Replace
  public static class SdkCommandCreateCreateUse extends ExtendedFormData.SdkCommandCreateCreate {
    private static final long serialVersionUID = 1L;

    public SdkCommandCreateCreateUse() {
    }
  }

  @Replace
  public static class SdkCommandCreateIgnoreCreate extends ExtendedFormData.SdkCommandCreateIgnore {
    private static final long serialVersionUID = 1L;

    public SdkCommandCreateIgnoreCreate() {
    }
  }

  @Replace
  public static class SdkCommandCreateIgnoreIgnore extends ExtendedFormData.SdkCommandCreateIgnore {
    private static final long serialVersionUID = 1L;

    public SdkCommandCreateIgnoreIgnore() {
    }
  }

  @Replace
  public static class SdkCommandCreateIgnoreNone extends ExtendedFormData.SdkCommandCreateIgnore {
    private static final long serialVersionUID = 1L;

    public SdkCommandCreateIgnoreNone() {
    }
  }

  @Replace
  public static class SdkCommandCreateIgnoreUse extends ExtendedFormData.SdkCommandCreateIgnore {
    private static final long serialVersionUID = 1L;

    public SdkCommandCreateIgnoreUse() {
    }
  }

  @Replace
  public static class SdkCommandCreateNoneCreate extends ExtendedFormData.SdkCommandCreateNone {
    private static final long serialVersionUID = 1L;

    public SdkCommandCreateNoneCreate() {
    }
  }

  @Replace
  public static class SdkCommandCreateNoneIgnore extends ExtendedFormData.SdkCommandCreateNone {
    private static final long serialVersionUID = 1L;

    public SdkCommandCreateNoneIgnore() {
    }
  }

  @Replace
  public static class SdkCommandCreateNoneNone extends ExtendedFormData.SdkCommandCreateNone {
    private static final long serialVersionUID = 1L;

    public SdkCommandCreateNoneNone() {
    }
  }

  @Replace
  public static class SdkCommandCreateNoneUse extends ExtendedFormData.SdkCommandCreateNone {
    private static final long serialVersionUID = 1L;

    public SdkCommandCreateNoneUse() {
    }
  }

  @Replace
  public static class SdkCommandCreateUseCreate extends ExtendedFormData.SdkCommandCreateUse {
    private static final long serialVersionUID = 1L;

    public SdkCommandCreateUseCreate() {
    }
  }

  @Replace
  public static class SdkCommandCreateUseIgnore extends ExtendedFormData.SdkCommandCreateUse {
    private static final long serialVersionUID = 1L;

    public SdkCommandCreateUseIgnore() {
    }
  }

  @Replace
  public static class SdkCommandCreateUseNone extends ExtendedFormData.SdkCommandCreateUse {
    private static final long serialVersionUID = 1L;

    public SdkCommandCreateUseNone() {
    }
  }

  @Replace
  public static class SdkCommandCreateUseUse extends ExtendedFormData.SdkCommandCreateUse {
    private static final long serialVersionUID = 1L;

    public SdkCommandCreateUseUse() {
    }
  }

  @Replace
  public static class SdkCommandIgnoreCreateCreate extends ExtendedFormData.SdkCommandIgnoreCreate {
    private static final long serialVersionUID = 1L;

    public SdkCommandIgnoreCreateCreate() {
    }
  }

  @Replace
  public static class SdkCommandIgnoreCreateIgnore extends ExtendedFormData.SdkCommandIgnoreCreate {
    private static final long serialVersionUID = 1L;

    public SdkCommandIgnoreCreateIgnore() {
    }
  }

  @Replace
  public static class SdkCommandIgnoreCreateNone extends ExtendedFormData.SdkCommandIgnoreCreate {
    private static final long serialVersionUID = 1L;

    public SdkCommandIgnoreCreateNone() {
    }
  }

  @Replace
  public static class SdkCommandIgnoreCreateUse extends ExtendedFormData.SdkCommandIgnoreCreate {
    private static final long serialVersionUID = 1L;

    public SdkCommandIgnoreCreateUse() {
    }
  }

  @Replace
  public static class SdkCommandIgnoreIgnoreCreate extends AbstractValueFieldData<String> {
    private static final long serialVersionUID = 1L;

    public SdkCommandIgnoreIgnoreCreate() {
    }

    /**
     * list of derived validation rules.
     */
    @Override
    protected void initValidationRules(java.util.Map<String, Object> ruleMap) {
      super.initValidationRules(ruleMap);
      ruleMap.put(ValidationRule.MAX_LENGTH, 4000);
    }
  }

  @Replace
  public static class SdkCommandIgnoreIgnoreUse extends UsingFormFieldData {
    private static final long serialVersionUID = 1L;

    public SdkCommandIgnoreIgnoreUse() {
    }

    /**
     * list of derived validation rules.
     */
    @Override
    protected void initValidationRules(java.util.Map<String, Object> ruleMap) {
      super.initValidationRules(ruleMap);
      ruleMap.put(ValidationRule.MAX_LENGTH, 4000);
    }
  }

  @Replace
  public static class SdkCommandIgnoreNoneCreate extends AbstractValueFieldData<String> {
    private static final long serialVersionUID = 1L;

    public SdkCommandIgnoreNoneCreate() {
    }

    /**
     * list of derived validation rules.
     */
    @Override
    protected void initValidationRules(java.util.Map<String, Object> ruleMap) {
      super.initValidationRules(ruleMap);
      ruleMap.put(ValidationRule.MAX_LENGTH, 4000);
    }
  }

  @Replace
  public static class SdkCommandIgnoreNoneUse extends UsingFormFieldData {
    private static final long serialVersionUID = 1L;

    public SdkCommandIgnoreNoneUse() {
    }

    /**
     * list of derived validation rules.
     */
    @Override
    protected void initValidationRules(java.util.Map<String, Object> ruleMap) {
      super.initValidationRules(ruleMap);
      ruleMap.put(ValidationRule.MAX_LENGTH, 4000);
    }
  }

  @Replace
  public static class SdkCommandIgnoreUseCreate extends ExtendedFormData.SdkCommandIgnoreUse {
    private static final long serialVersionUID = 1L;

    public SdkCommandIgnoreUseCreate() {
    }
  }

  @Replace
  public static class SdkCommandIgnoreUseIgnore extends ExtendedFormData.SdkCommandIgnoreUse {
    private static final long serialVersionUID = 1L;

    public SdkCommandIgnoreUseIgnore() {
    }
  }

  @Replace
  public static class SdkCommandIgnoreUseNone extends ExtendedFormData.SdkCommandIgnoreUse {
    private static final long serialVersionUID = 1L;

    public SdkCommandIgnoreUseNone() {
    }
  }

  @Replace
  public static class SdkCommandIgnoreUseUse extends ExtendedFormData.SdkCommandIgnoreUse {
    private static final long serialVersionUID = 1L;

    public SdkCommandIgnoreUseUse() {
    }
  }

  @Replace
  public static class SdkCommandNoneCreateCreate extends ExtendedFormData.SdkCommandNoneCreate {
    private static final long serialVersionUID = 1L;

    public SdkCommandNoneCreateCreate() {
    }
  }

  @Replace
  public static class SdkCommandNoneCreateIgnore extends ExtendedFormData.SdkCommandNoneCreate {
    private static final long serialVersionUID = 1L;

    public SdkCommandNoneCreateIgnore() {
    }
  }

  @Replace
  public static class SdkCommandNoneCreateNone extends ExtendedFormData.SdkCommandNoneCreate {
    private static final long serialVersionUID = 1L;

    public SdkCommandNoneCreateNone() {
    }
  }

  @Replace
  public static class SdkCommandNoneCreateUse extends ExtendedFormData.SdkCommandNoneCreate {
    private static final long serialVersionUID = 1L;

    public SdkCommandNoneCreateUse() {
    }
  }

  @Replace
  public static class SdkCommandNoneIgnoreCreate extends ExtendedFormData.SdkCommandNoneIgnore {
    private static final long serialVersionUID = 1L;

    public SdkCommandNoneIgnoreCreate() {
    }
  }

  @Replace
  public static class SdkCommandNoneIgnoreIgnore extends ExtendedFormData.SdkCommandNoneIgnore {
    private static final long serialVersionUID = 1L;

    public SdkCommandNoneIgnoreIgnore() {
    }
  }

  @Replace
  public static class SdkCommandNoneIgnoreNone extends ExtendedFormData.SdkCommandNoneIgnore {
    private static final long serialVersionUID = 1L;

    public SdkCommandNoneIgnoreNone() {
    }
  }

  @Replace
  public static class SdkCommandNoneIgnoreUse extends ExtendedFormData.SdkCommandNoneIgnore {
    private static final long serialVersionUID = 1L;

    public SdkCommandNoneIgnoreUse() {
    }
  }

  @Replace
  public static class SdkCommandNoneNoneCreate extends ExtendedFormData.SdkCommandNoneNone {
    private static final long serialVersionUID = 1L;

    public SdkCommandNoneNoneCreate() {
    }
  }

  @Replace
  public static class SdkCommandNoneNoneIgnore extends ExtendedFormData.SdkCommandNoneNone {
    private static final long serialVersionUID = 1L;

    public SdkCommandNoneNoneIgnore() {
    }
  }

  @Replace
  public static class SdkCommandNoneNoneNone extends ExtendedFormData.SdkCommandNoneNone {
    private static final long serialVersionUID = 1L;

    public SdkCommandNoneNoneNone() {
    }
  }

  @Replace
  public static class SdkCommandNoneNoneUse extends ExtendedFormData.SdkCommandNoneNone {
    private static final long serialVersionUID = 1L;

    public SdkCommandNoneNoneUse() {
    }
  }

  @Replace
  public static class SdkCommandNoneUseCreate extends ExtendedFormData.SdkCommandNoneUse {
    private static final long serialVersionUID = 1L;

    public SdkCommandNoneUseCreate() {
    }
  }

  @Replace
  public static class SdkCommandNoneUseIgnore extends ExtendedFormData.SdkCommandNoneUse {
    private static final long serialVersionUID = 1L;

    public SdkCommandNoneUseIgnore() {
    }
  }

  @Replace
  public static class SdkCommandNoneUseNone extends ExtendedFormData.SdkCommandNoneUse {
    private static final long serialVersionUID = 1L;

    public SdkCommandNoneUseNone() {
    }
  }

  @Replace
  public static class SdkCommandNoneUseUse extends ExtendedFormData.SdkCommandNoneUse {
    private static final long serialVersionUID = 1L;

    public SdkCommandNoneUseUse() {
    }
  }

  @Replace
  public static class SdkCommandUseCreateCreate extends ExtendedFormData.SdkCommandUseCreate {
    private static final long serialVersionUID = 1L;

    public SdkCommandUseCreateCreate() {
    }
  }

  @Replace
  public static class SdkCommandUseCreateIgnore extends ExtendedFormData.SdkCommandUseCreate {
    private static final long serialVersionUID = 1L;

    public SdkCommandUseCreateIgnore() {
    }
  }

  @Replace
  public static class SdkCommandUseCreateNone extends ExtendedFormData.SdkCommandUseCreate {
    private static final long serialVersionUID = 1L;

    public SdkCommandUseCreateNone() {
    }
  }

  @Replace
  public static class SdkCommandUseCreateUse extends ExtendedFormData.SdkCommandUseCreate {
    private static final long serialVersionUID = 1L;

    public SdkCommandUseCreateUse() {
    }
  }

  @Replace
  public static class SdkCommandUseIgnoreCreate extends ExtendedFormData.SdkCommandUseIgnore {
    private static final long serialVersionUID = 1L;

    public SdkCommandUseIgnoreCreate() {
    }
  }

  @Replace
  public static class SdkCommandUseIgnoreIgnore extends ExtendedFormData.SdkCommandUseIgnore {
    private static final long serialVersionUID = 1L;

    public SdkCommandUseIgnoreIgnore() {
    }
  }

  @Replace
  public static class SdkCommandUseIgnoreNone extends ExtendedFormData.SdkCommandUseIgnore {
    private static final long serialVersionUID = 1L;

    public SdkCommandUseIgnoreNone() {
    }
  }

  @Replace
  public static class SdkCommandUseIgnoreUse extends ExtendedFormData.SdkCommandUseIgnore {
    private static final long serialVersionUID = 1L;

    public SdkCommandUseIgnoreUse() {
    }
  }

  @Replace
  public static class SdkCommandUseNoneCreate extends ExtendedFormData.SdkCommandUseNone {
    private static final long serialVersionUID = 1L;

    public SdkCommandUseNoneCreate() {
    }
  }

  @Replace
  public static class SdkCommandUseNoneIgnore extends ExtendedFormData.SdkCommandUseNone {
    private static final long serialVersionUID = 1L;

    public SdkCommandUseNoneIgnore() {
    }
  }

  @Replace
  public static class SdkCommandUseNoneNone extends ExtendedFormData.SdkCommandUseNone {
    private static final long serialVersionUID = 1L;

    public SdkCommandUseNoneNone() {
    }
  }

  @Replace
  public static class SdkCommandUseNoneUse extends ExtendedFormData.SdkCommandUseNone {
    private static final long serialVersionUID = 1L;

    public SdkCommandUseNoneUse() {
    }
  }

  @Replace
  public static class SdkCommandUseUseCreate extends ExtendedFormData.SdkCommandUseUse {
    private static final long serialVersionUID = 1L;

    public SdkCommandUseUseCreate() {
    }
  }

  @Replace
  public static class SdkCommandUseUseIgnore extends ExtendedFormData.SdkCommandUseUse {
    private static final long serialVersionUID = 1L;

    public SdkCommandUseUseIgnore() {
    }
  }

  @Replace
  public static class SdkCommandUseUseNone extends ExtendedFormData.SdkCommandUseUse {
    private static final long serialVersionUID = 1L;

    public SdkCommandUseUseNone() {
    }
  }

  @Replace
  public static class SdkCommandUseUseUse extends ExtendedFormData.SdkCommandUseUse {
    private static final long serialVersionUID = 1L;

    public SdkCommandUseUseUse() {
    }
  }
}




package formdata.shared.services.process.replace;

import org.eclipse.scout.commons.annotations.Replace;
import org.eclipse.scout.rt.shared.data.form.ValidationRule;
import org.eclipse.scout.rt.shared.data.form.fields.AbstractValueFieldData;

public class ExtendedFormData extends BaseFormData {
  private static final long serialVersionUID = 1L;

  public ExtendedFormData() {
  }

  public FirstName getFirstName() {
    return getFieldByClass(FirstName.class);
  }

  public IgnoringGroupBoxExCreate getIgnoringGroupBoxExCreate() {
    return getFieldByClass(IgnoringGroupBoxExCreate.class);
  }

  public IgnoringGroupBoxExUse getIgnoringGroupBoxExUse() {
    return getFieldByClass(IgnoringGroupBoxExUse.class);
  }

  public NameEx getNameEx() {
    return getFieldByClass(NameEx.class);
  }

  public SdkCommandCreateCreate getSdkCommandCreateCreate() {
    return getFieldByClass(SdkCommandCreateCreate.class);
  }

  public SdkCommandCreateIgnore getSdkCommandCreateIgnore() {
    return getFieldByClass(SdkCommandCreateIgnore.class);
  }

  public SdkCommandCreateNone getSdkCommandCreateNone() {
    return getFieldByClass(SdkCommandCreateNone.class);
  }

  public SdkCommandCreateUse getSdkCommandCreateUse() {
    return getFieldByClass(SdkCommandCreateUse.class);
  }

  public SdkCommandIgnoreCreate getSdkCommandIgnoreCreate() {
    return getFieldByClass(SdkCommandIgnoreCreate.class);
  }

  public SdkCommandIgnoreUse getSdkCommandIgnoreUse() {
    return getFieldByClass(SdkCommandIgnoreUse.class);
  }

  public SdkCommandNoneCreate getSdkCommandNoneCreate() {
    return getFieldByClass(SdkCommandNoneCreate.class);
  }

  public SdkCommandNoneIgnore getSdkCommandNoneIgnore() {
    return getFieldByClass(SdkCommandNoneIgnore.class);
  }

  public SdkCommandNoneNone getSdkCommandNoneNone() {
    return getFieldByClass(SdkCommandNoneNone.class);
  }

  public SdkCommandNoneUse getSdkCommandNoneUse() {
    return getFieldByClass(SdkCommandNoneUse.class);
  }

  public SdkCommandUseCreate getSdkCommandUseCreate() {
    return getFieldByClass(SdkCommandUseCreate.class);
  }

  public SdkCommandUseIgnore getSdkCommandUseIgnore() {
    return getFieldByClass(SdkCommandUseIgnore.class);
  }

  public SdkCommandUseNone getSdkCommandUseNone() {
    return getFieldByClass(SdkCommandUseNone.class);
  }

  public SdkCommandUseUse getSdkCommandUseUse() {
    return getFieldByClass(SdkCommandUseUse.class);
  }

  public SmartEx getSmartEx() {
    return getFieldByClass(SmartEx.class);
  }

  public static class FirstName extends AbstractValueFieldData<String> {
    private static final long serialVersionUID = 1L;

    public FirstName() {
    }

    /**
     * list of derived validation rules.
     */
    @Override
    protected void initValidationRules(java.util.Map<String, Object> ruleMap) {
      super.initValidationRules(ruleMap);
      ruleMap.put(ValidationRule.MAX_LENGTH, 4000);
    }
  }

  @Replace
  public static class IgnoringGroupBoxExCreate extends AbstractValueFieldData<String> {
    private static final long serialVersionUID = 1L;

    public IgnoringGroupBoxExCreate() {
    }

    /**
     * list of derived validation rules.
     */
    @Override
    protected void initValidationRules(java.util.Map<String, Object> ruleMap) {
      super.initValidationRules(ruleMap);
      ruleMap.put(ValidationRule.MAX_LENGTH, 4000);
    }
  }

  @Replace
  public static class IgnoringGroupBoxExUse extends UsingFormFieldData {
    private static final long serialVersionUID = 1L;

    public IgnoringGroupBoxExUse() {
    }

    /**
     * list of derived validation rules.
     */
    @Override
    protected void initValidationRules(java.util.Map<String, Object> ruleMap) {
      super.initValidationRules(ruleMap);
      ruleMap.put(ValidationRule.MAX_LENGTH, 4000);
    }
  }

  @Replace
  public static class NameEx extends BaseFormData.Name {
    private static final long serialVersionUID = 1L;

    public NameEx() {
    }

    /**
     * list of derived validation rules.
     */
    @Override
    protected void initValidationRules(java.util.Map<String, Object> ruleMap) {
      super.initValidationRules(ruleMap);
      ruleMap.put(ValidationRule.MAX_LENGTH, 100);
    }
  }

  @Replace
  public static class SdkCommandCreateCreate extends BaseFormData.SdkCommandCreate {
    private static final long serialVersionUID = 1L;

    public SdkCommandCreateCreate() {
    }
  }

  @Replace
  public static class SdkCommandCreateIgnore extends BaseFormData.SdkCommandCreate {
    private static final long serialVersionUID = 1L;

    public SdkCommandCreateIgnore() {
    }
  }

  @Replace
  public static class SdkCommandCreateNone extends BaseFormData.SdkCommandCreate {
    private static final long serialVersionUID = 1L;

    public SdkCommandCreateNone() {
    }
  }

  @Replace
  public static class SdkCommandCreateUse extends BaseFormData.SdkCommandCreate {
    private static final long serialVersionUID = 1L;

    public SdkCommandCreateUse() {
    }
  }

  @Replace
  public static class SdkCommandIgnoreCreate extends AbstractValueFieldData<String> {
    private static final long serialVersionUID = 1L;

    public SdkCommandIgnoreCreate() {
    }

    /**
     * list of derived validation rules.
     */
    @Override
    protected void initValidationRules(java.util.Map<String, Object> ruleMap) {
      super.initValidationRules(ruleMap);
      ruleMap.put(ValidationRule.MAX_LENGTH, 4000);
    }
  }

  @Replace
  public static class SdkCommandIgnoreUse extends UsingFormFieldData {
    private static final long serialVersionUID = 1L;

    public SdkCommandIgnoreUse() {
    }

    /**
     * list of derived validation rules.
     */
    @Override
    protected void initValidationRules(java.util.Map<String, Object> ruleMap) {
      super.initValidationRules(ruleMap);
      ruleMap.put(ValidationRule.MAX_LENGTH, 4000);
    }
  }

  @Replace
  public static class SdkCommandNoneCreate extends BaseFormData.SdkCommandNone {
    private static final long serialVersionUID = 1L;

    public SdkCommandNoneCreate() {
    }
  }

  @Replace
  public static class SdkCommandNoneIgnore extends BaseFormData.SdkCommandNone {
    private static final long serialVersionUID = 1L;

    public SdkCommandNoneIgnore() {
    }
  }

  @Replace
  public static class SdkCommandNoneNone extends BaseFormData.SdkCommandNone {
    private static final long serialVersionUID = 1L;

    public SdkCommandNoneNone() {
    }
  }

  @Replace
  public static class SdkCommandNoneUse extends BaseFormData.SdkCommandNone {
    private static final long serialVersionUID = 1L;

    public SdkCommandNoneUse() {
    }
  }

  @Replace
  public static class SdkCommandUseCreate extends BaseFormData.SdkCommandUse {
    private static final long serialVersionUID = 1L;

    public SdkCommandUseCreate() {
    }
  }

  @Replace
  public static class SdkCommandUseIgnore extends BaseFormData.SdkCommandUse {
    private static final long serialVersionUID = 1L;

    public SdkCommandUseIgnore() {
    }
  }

  @Replace
  public static class SdkCommandUseNone extends BaseFormData.SdkCommandUse {
    private static final long serialVersionUID = 1L;

    public SdkCommandUseNone() {
    }
  }

  @Replace
  public static class SdkCommandUseUse extends BaseFormData.SdkCommandUse {
    private static final long serialVersionUID = 1L;

    public SdkCommandUseUse() {
    }
  }

  @Replace
  public static class SmartEx extends BaseFormData.Smart {
    private static final long serialVersionUID = 1L;

    public SmartEx() {
    }

    /**
     * list of derived validation rules.
     */
    @Override
    protected void initValidationRules(java.util.Map<String, Object> ruleMap) {
      super.initValidationRules(ruleMap);
      ruleMap.remove(ValidationRule.CODE_TYPE);
    }
  }
}




package formdata.shared.services.process.replace;

import org.eclipse.scout.rt.shared.data.basic.table.AbstractTableRowData;
import org.eclipse.scout.rt.shared.data.form.AbstractFormData;
import org.eclipse.scout.rt.shared.data.form.fields.tablefield.AbstractTableFieldBeanData;

public class TableFieldBaseFormData extends AbstractFormData {
  private static final long serialVersionUID = 1L;

  public TableFieldBaseFormData() {
  }

  public EmptyTable getEmptyTable() {
    return getFieldByClass(EmptyTable.class);
  }

  public NoTable getNoTable() {
    return getFieldByClass(NoTable.class);
  }

  public Table getTable() {
    return getFieldByClass(Table.class);
  }

  public static class EmptyTable extends AbstractTableFieldBeanData {
    private static final long serialVersionUID = 1L;

    public EmptyTable() {
    }

    @Override
    public EmptyTableRowData addRow(int rowState) {
      return (EmptyTableRowData) super.addRow(rowState);
    }

    @Override
    public EmptyTableRowData addRow() {
      return (EmptyTableRowData) super.addRow();
    }

    @Override
    public EmptyTableRowData createRow() {
      return new EmptyTableRowData();
    }

    @Override
    public Class<? extends AbstractTableRowData> getRowType() {
      return EmptyTableRowData.class;
    }

    @Override
    public EmptyTableRowData[] getRows() {
      return (EmptyTableRowData[]) super.getRows();
    }

    @Override
    public EmptyTableRowData rowAt(int idx) {
      return (EmptyTableRowData) super.rowAt(idx);
    }

    public void setRows(EmptyTableRowData[] rows) {
      super.setRows(rows);
    }

    public static class EmptyTableRowData extends AbstractTableRowData {
      private static final long serialVersionUID = 1L;

      public EmptyTableRowData() {
      }
    }
  }

  public static class NoTable extends AbstractTableFieldBeanData {
    private static final long serialVersionUID = 1L;

    public NoTable() {
    }

    @Override
    public AbstractTableRowData createRow() {
      return new AbstractTableRowData() {
        private static final long serialVersionUID = 1L;
      };
    }

    @Override
    public Class<? extends AbstractTableRowData> getRowType() {
      return AbstractTableRowData.class;
    }
  }

  public static class Table extends AbstractTableFieldBeanData {
    private static final long serialVersionUID = 1L;

    public Table() {
    }

    @Override
    public TableRowData addRow() {
      return (TableRowData) super.addRow();
    }

    @Override
    public TableRowData addRow(int rowState) {
      return (TableRowData) super.addRow(rowState);
    }

    @Override
    public TableRowData createRow() {
      return new TableRowData();
    }

    @Override
    public Class<? extends AbstractTableRowData> getRowType() {
      return TableRowData.class;
    }

    @Override
    public TableRowData[] getRows() {
      return (TableRowData[]) super.getRows();
    }

    @Override
    public TableRowData rowAt(int idx) {
      return (TableRowData) super.rowAt(idx);
    }

    public void setRows(TableRowData[] rows) {
      super.setRows(rows);
    }

    public static class TableRowData extends AbstractTableRowData {
      private static final long serialVersionUID = 1L;

      public TableRowData() {
      }

      private String m_first;
      private String m_second;

      public String getFirst() {
        return m_first;
      }

      public void setFirst(String first) {
        m_first = first;
      }

      public String getSecond() {
        return m_second;
      }

      public void setSecond(String second) {
        m_second = second;
      }
    }
  }
}




package formdata.shared.services.process.replace;

import org.eclipse.scout.commons.annotations.Replace;
import org.eclipse.scout.rt.shared.data.basic.table.AbstractTableRowData;

public class TableFieldExFormData extends TableFieldBaseFormData {
  private static final long serialVersionUID = 1L;

  public TableFieldExFormData() {
  }

  public EmptyTableExtended getEmptyTableExtended() {
    return getFieldByClass(EmptyTableExtended.class);
  }

  public NoTableExtended getNoTableExtended() {
    return getFieldByClass(NoTableExtended.class);
  }

  public TableExtended getTableExtended() {
    return getFieldByClass(TableExtended.class);
  }

  @Replace
  public static class EmptyTableExtended extends TableFieldBaseFormData.EmptyTable {
    private static final long serialVersionUID = 1L;

    public EmptyTableExtended() {
    }

    @Override
    public TableExRowData addRow() {
      return (TableExRowData) super.addRow();
    }

    @Override
    public TableExRowData addRow(int rowState) {
      return (TableExRowData) super.addRow(rowState);
    }

    @Override
    public TableExRowData createRow() {
      return new TableExRowData();
    }

    @Override
    public Class<? extends AbstractTableRowData> getRowType() {
      return TableExRowData.class;
    }

    @Override
    public TableExRowData[] getRows() {
      return (TableExRowData[]) super.getRows();
    }

    @Override
    public TableExRowData rowAt(int idx) {
      return (TableExRowData) super.rowAt(idx);
    }

    public void setRows(TableExRowData[] rows) {
      super.setRows(rows);
    }

    public static class TableExRowData extends TableFieldBaseFormData.EmptyTable.EmptyTableRowData {
      private static final long serialVersionUID = 1L;

      public TableExRowData() {
      }

      private String m_single;

      public void setSingle(String single) {
        m_single = single;
      }

      public String getSingle() {
        return m_single;
      }
    }
  }

  @Replace
  public static class NoTableExtended extends TableFieldBaseFormData.NoTable {
    private static final long serialVersionUID = 1L;

    public NoTableExtended() {
    }

    @Override
    public NoTableExtendedRowData addRow() {
      return (NoTableExtendedRowData) super.addRow();
    }

    @Override
    public NoTableExtendedRowData addRow(int rowState) {
      return (NoTableExtendedRowData) super.addRow(rowState);
    }

    @Override
    public NoTableExtendedRowData createRow() {
      return new NoTableExtendedRowData();
    }

    @Override
    public Class<? extends AbstractTableRowData> getRowType() {
      return NoTableExtendedRowData.class;
    }

    @Override
    public NoTableExtendedRowData[] getRows() {
      return (NoTableExtendedRowData[]) super.getRows();
    }

    @Override
    public NoTableExtendedRowData rowAt(int idx) {
      return (NoTableExtendedRowData) super.rowAt(idx);
    }

    public void setRows(NoTableExtendedRowData[] rows) {
      super.setRows(rows);
    }

    public static class NoTableExtendedRowData extends AbstractTableRowData {
      private static final long serialVersionUID = 1L;

      public NoTableExtendedRowData() {
      }

      private String m_newValue;

      public void setNew(String newValue) {
        m_newValue = newValue;
      }

      public String getNew() {
        return m_newValue;
      }
    }
  }

  @Replace
  public static class TableExtended extends TableFieldBaseFormData.Table {
    private static final long serialVersionUID = 1L;

    public TableExtended() {
    }

    @Override
    public TableExRowData addRow(int rowState) {
      return (TableExRowData) super.addRow(rowState);
    }

    @Override
    public TableExRowData addRow() {
      return (TableExRowData) super.addRow();
    }

    @Override
    public TableExRowData createRow() {
      return new TableExRowData();
    }

    @Override
    public Class<? extends AbstractTableRowData> getRowType() {
      return TableExRowData.class;
    }

    @Override
    public TableExRowData[] getRows() {
      return (TableExRowData[]) super.getRows();
    }

    @Override
    public TableExRowData rowAt(int idx) {
      return (TableExRowData) super.rowAt(idx);
    }

    public void setRows(TableExRowData[] rows) {
      super.setRows(rows);
    }

    public static class TableExRowData extends TableFieldBaseFormData.Table.TableRowData {
      private static final long serialVersionUID = 1L;

      public TableExRowData() {
      }

      private Boolean m_booleanValue;

      public void setBoolean(Boolean booleanValue) {
        m_booleanValue = booleanValue;
      }

      public Boolean getBoolean() {
        return m_booleanValue;
      }
    }
  }
}




/*******************************************************************************
 * Copyright (c) 2010 BSI Business Systems Integration AG.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *     BSI Business Systems Integration AG - initial API and implementation
 ******************************************************************************/
package formdata.shared.services.process.replace;

import org.eclipse.scout.rt.shared.services.common.code.AbstractCodeType;

public class TestingCodeType extends AbstractCodeType<Long> {

  private static final long serialVersionUID = 1L;

  @Override
  public Long getId() {
    return 42L;
  }
}




/*******************************************************************************
 * Copyright (c) 2010 BSI Business Systems Integration AG.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *     BSI Business Systems Integration AG - initial API and implementation
 ******************************************************************************/
package formdata.shared.services.process.replace;

import org.eclipse.scout.rt.shared.services.lookup.LookupCall;

public class TestingLookupCall extends LookupCall {

  private static final long serialVersionUID = 1L;

}




/*******************************************************************************
 * Copyright (c) 2010 BSI Business Systems Integration AG.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *     BSI Business Systems Integration AG - initial API and implementation
 ******************************************************************************/
package formdata.shared.services.process.replace;

import org.eclipse.scout.rt.shared.data.form.fields.AbstractValueFieldData;

public class UsingFormFieldData extends AbstractValueFieldData<String> {

  private static final long serialVersionUID = 1L;

}

Lines 10-14 Link Here

(-)resources/operation/formData/formdata.shared/META-INF/MANIFEST.MF (+1 lines)
10	org.eclipse.scout.rt.shared;visibility:=reexport	10	org.eclipse.scout.rt.shared;visibility:=reexport
11	Export-Package: formdata.shared,	11	Export-Package: formdata.shared,
12	formdata.shared.services.process,	12	formdata.shared.services.process,
		13	formdata.shared.services.process.replace,
13	formdata.shared.security,	14	formdata.shared.security,
14	formdata.shared.services.common.text	15	formdata.shared.services.common.text




/*******************************************************************************
 * Copyright (c) 2010 BSI Business Systems Integration AG.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *     BSI Business Systems Integration AG - initial API and implementation
 ******************************************************************************/
package formdata.client.ui.forms.replace;

import org.eclipse.scout.rt.client.ui.form.fields.smartfield.AbstractSmartField;
import org.eclipse.scout.rt.shared.services.lookup.LookupCall;

import formdata.shared.services.process.replace.TestingLookupCall;

public abstract class AbstractLookupField extends AbstractSmartField<Long> {

  @Override
  protected Class<? extends LookupCall> getConfiguredLookupCall() {
    return TestingLookupCall.class;
  }
}




package formdata.client.ui.forms.replace;

import org.eclipse.scout.commons.annotations.FormData;
import org.eclipse.scout.commons.annotations.FormData.SdkCommand;
import org.eclipse.scout.commons.annotations.Order;
import org.eclipse.scout.commons.exception.ProcessingException;
import org.eclipse.scout.rt.client.ui.form.AbstractForm;
import org.eclipse.scout.rt.client.ui.form.fields.button.AbstractCloseButton;
import org.eclipse.scout.rt.client.ui.form.fields.groupbox.AbstractGroupBox;
import org.eclipse.scout.rt.client.ui.form.fields.smartfield.AbstractSmartField;
import org.eclipse.scout.rt.client.ui.form.fields.stringfield.AbstractStringField;
import org.eclipse.scout.rt.shared.services.common.code.ICodeType;

import formdata.client.ui.forms.replace.BaseForm.MainBox.CloseButton;
import formdata.client.ui.forms.replace.BaseForm.MainBox.GroupBox;
import formdata.client.ui.forms.replace.BaseForm.MainBox.GroupBox.NameField;
import formdata.client.ui.forms.replace.BaseForm.MainBox.GroupBox.SmartField;
import formdata.client.ui.forms.replace.BaseForm.MainBox.IgnoringGroupBox;
import formdata.client.ui.forms.replace.BaseForm.MainBox.IgnoringGroupBox.IgnoringGroupBoxField;
import formdata.shared.services.process.replace.BaseFormData;
import formdata.shared.services.process.replace.TestingCodeType;
import formdata.shared.services.process.replace.UsingFormFieldData;

@FormData(value = BaseFormData.class, sdkCommand = SdkCommand.CREATE)
public class BaseForm extends AbstractForm {

  public BaseForm() throws ProcessingException {
    super();
  }

  public MainBox getMainBox() {
    return getFieldByClass(MainBox.class);
  }

  public GroupBox getGroupBox() {
    return getFieldByClass(GroupBox.class);
  }

  public NameField getNameField() {
    return getFieldByClass(NameField.class);
  }

  public SmartField getSmartField() {
    return getFieldByClass(SmartField.class);
  }

  public IgnoringGroupBox getIgnoringGroupBox() {
    return getFieldByClass(IgnoringGroupBox.class);
  }

  public IgnoringGroupBoxField getIgnoringGroupBoxField() {
    return getFieldByClass(IgnoringGroupBoxField.class);
  }

  public CloseButton getCloseButton() {
    return getFieldByClass(CloseButton.class);
  }

  @Order(10.0)
  public class MainBox extends AbstractGroupBox {

    @Order(10)
    public class NoneFormDataFieldsGroupBox extends AbstractGroupBox {
      @Order(10)
      public class SdkCommandNoneField extends AbstractStringField {
      }
    }

    @Order(20)
    public class CreatingFormDataFieldsGroupBox extends AbstractGroupBox {
      @Order(10)
      @FormData(sdkCommand = SdkCommand.CREATE)
      public class SdkCommandCreateField extends AbstractStringField {
      }
    }

    @Order(30)
    public class UsingFormDataFieldsGroupBox extends AbstractGroupBox {
      @Order(10)
      @FormData(sdkCommand = SdkCommand.USE, value = UsingFormFieldData.class)
      public class SdkCommandUseField extends AbstractStringField {
      }
    }

    @Order(40)
    public class IgnoringFormDataFieldsGroupBox extends AbstractGroupBox {
      @Order(10)
      @FormData(sdkCommand = SdkCommand.IGNORE)
      public class SdkCommandIgnoreField extends AbstractStringField {
      }
    }

    @Order(50.0)
    public class GroupBox extends AbstractGroupBox {

      @Order(10.0)
      public class NameField extends AbstractStringField {

        @Override
        protected boolean getConfiguredMandatory() {
          return true;
        }

        @Override
        protected int getConfiguredMaxLength() {
          return 60;
        }
      }

      @Order(20.0)
      public class SmartField extends AbstractSmartField<Long> {
        @Override
        protected Class<? extends ICodeType<?>> getConfiguredCodeType() {
          return TestingCodeType.class;
        }
      }

      @Order(30.0)
      public class LookupField extends AbstractLookupField {
      }
    }

    @Order(20.0)
    @FormData(sdkCommand = SdkCommand.IGNORE)
    public class IgnoringGroupBox extends AbstractGroupBox {

      @Order(10.0)
      public class IgnoringGroupBoxField extends AbstractStringField {
      }
    }

    @Order(100.0)
    public class CloseButton extends AbstractCloseButton {
    }
  }
}




/*******************************************************************************
 * Copyright (c) 2010 BSI Business Systems Integration AG.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *     BSI Business Systems Integration AG - initial API and implementation
 ******************************************************************************/
package formdata.client.ui.forms.replace;

import org.eclipse.scout.commons.annotations.FormData;
import org.eclipse.scout.commons.annotations.FormData.SdkCommand;
import org.eclipse.scout.commons.annotations.Replace;
import org.eclipse.scout.commons.exception.ProcessingException;

import formdata.client.ui.forms.replace.BaseForm.MainBox.GroupBox;
import formdata.shared.services.process.replace.ExtendedExtendedFormData;
import formdata.shared.services.process.replace.UsingFormFieldData;

@FormData(value = ExtendedExtendedFormData.class, sdkCommand = SdkCommand.CREATE)
public class ExtendedExtendedForm extends ExtendedForm {

  public ExtendedExtendedForm() throws ProcessingException {
    super();
  }

  /* ##########################################################################
   * replacing fields that are creating a form data (without explicitly
   * defining a @FormData annotation)
   * expectation: replacing form field data must be created and it must be a
   *              subclass of the parent field's form field data. Hence any
   *              @FormData annotation available on the field replacements are
   *              ignored.
   * ##########################################################################
   */
  @Replace
  public class SdkCommandNoneNoneNoneField extends ExtendedForm.SdkCommandNoneNoneField {
    public SdkCommandNoneNoneNoneField(BaseForm.MainBox.NoneFormDataFieldsGroupBox container) {
      super(container);
    }
  }

  @Replace
  @FormData(sdkCommand = SdkCommand.CREATE)
  public class SdkCommandNoneNoneCreateField extends ExtendedForm.SdkCommandNoneNoneField {
    public SdkCommandNoneNoneCreateField(BaseForm.MainBox.NoneFormDataFieldsGroupBox container) {
      super(container);
    }
  }

  @Replace
  @FormData(sdkCommand = SdkCommand.USE, value = UsingFormFieldData.class)
  public class SdkCommandNoneNoneUseField extends ExtendedForm.SdkCommandNoneNoneField {
    public SdkCommandNoneNoneUseField(BaseForm.MainBox.NoneFormDataFieldsGroupBox container) {
      super(container);
    }
  }

  @Replace
  @FormData(sdkCommand = SdkCommand.IGNORE)
  public class SdkCommandNoneNoneIgnoreField extends ExtendedForm.SdkCommandNoneNoneField {
    public SdkCommandNoneNoneIgnoreField(BaseForm.MainBox.NoneFormDataFieldsGroupBox container) {
      super(container);
    }
  }

  @Replace
  public class SdkCommandNoneCreateNoneField extends ExtendedForm.SdkCommandNoneCreateField {
    public SdkCommandNoneCreateNoneField(BaseForm.MainBox.NoneFormDataFieldsGroupBox container) {
      super(container);
    }
  }

  @Replace
  @FormData(sdkCommand = SdkCommand.CREATE)
  public class SdkCommandNoneCreateCreateField extends ExtendedForm.SdkCommandNoneCreateField {
    public SdkCommandNoneCreateCreateField(BaseForm.MainBox.NoneFormDataFieldsGroupBox container) {
      super(container);
    }
  }

  @Replace
  @FormData(sdkCommand = SdkCommand.USE, value = UsingFormFieldData.class)
  public class SdkCommandNoneCreateUseField extends ExtendedForm.SdkCommandNoneCreateField {
    public SdkCommandNoneCreateUseField(BaseForm.MainBox.NoneFormDataFieldsGroupBox container) {
      super(container);
    }
  }

  @Replace
  @FormData(sdkCommand = SdkCommand.IGNORE)
  public class SdkCommandNoneCreateIgnoreField extends ExtendedForm.SdkCommandNoneCreateField {
    public SdkCommandNoneCreateIgnoreField(BaseForm.MainBox.NoneFormDataFieldsGroupBox container) {
      super(container);
    }
  }

  @Replace
  public class SdkCommandNoneUseNoneField extends ExtendedForm.SdkCommandNoneUseField {
    public SdkCommandNoneUseNoneField(BaseForm.MainBox.NoneFormDataFieldsGroupBox container) {
      super(container);
    }
  }

  @Replace
  @FormData(sdkCommand = SdkCommand.CREATE)
  public class SdkCommandNoneUseCreateField extends ExtendedForm.SdkCommandNoneUseField {
    public SdkCommandNoneUseCreateField(BaseForm.MainBox.NoneFormDataFieldsGroupBox container) {
      super(container);
    }
  }

  @Replace
  @FormData(sdkCommand = SdkCommand.USE, value = UsingFormFieldData.class)
  public class SdkCommandNoneUseUseField extends ExtendedForm.SdkCommandNoneUseField {
    public SdkCommandNoneUseUseField(BaseForm.MainBox.NoneFormDataFieldsGroupBox container) {
      super(container);
    }
  }

  @Replace
  @FormData(sdkCommand = SdkCommand.IGNORE)
  public class SdkCommandNoneUseIgnoreField extends ExtendedForm.SdkCommandNoneUseField {
    public SdkCommandNoneUseIgnoreField(BaseForm.MainBox.NoneFormDataFieldsGroupBox container) {
      super(container);
    }
  }

  @Replace
  public class SdkCommandNoneIgnoreNoneField extends ExtendedForm.SdkCommandNoneIgnoreField {
    public SdkCommandNoneIgnoreNoneField(BaseForm.MainBox.NoneFormDataFieldsGroupBox container) {
      super(container);
    }
  }

  @Replace
  @FormData(sdkCommand = SdkCommand.CREATE)
  public class SdkCommandNoneIgnoreCreateField extends ExtendedForm.SdkCommandNoneIgnoreField {
    public SdkCommandNoneIgnoreCreateField(BaseForm.MainBox.NoneFormDataFieldsGroupBox container) {
      super(container);
    }
  }

  @Replace
  @FormData(sdkCommand = SdkCommand.USE, value = UsingFormFieldData.class)
  public class SdkCommandNoneIgnoreUseField extends ExtendedForm.SdkCommandNoneIgnoreField {
    public SdkCommandNoneIgnoreUseField(BaseForm.MainBox.NoneFormDataFieldsGroupBox container) {
      super(container);
    }
  }

  @Replace
  @FormData(sdkCommand = SdkCommand.IGNORE)
  public class SdkCommandNoneIgnoreIgnoreField extends ExtendedForm.SdkCommandNoneIgnoreField {
    public SdkCommandNoneIgnoreIgnoreField(BaseForm.MainBox.NoneFormDataFieldsGroupBox container) {
      super(container);
    }
  }

  /* ##########################################################################
   * replacing fields that are creating a form data (SdkCommand CREATE)
   * expectation: replacing form field data must be created and it must be a
   *              subclass of the parent field's form field data. Hence any
   *              @FormData annotation available on the field replacements are
   *              ignored.
   * ##########################################################################
   */
  @Replace
  public class SdkCommandCreateNoneNoneField extends ExtendedForm.SdkCommandCreateNoneField {
    public SdkCommandCreateNoneNoneField(BaseForm.MainBox.CreatingFormDataFieldsGroupBox container) {
      super(container);
    }
  }

  @Replace
  @FormData(sdkCommand = SdkCommand.CREATE)
  public class SdkCommandCreateNoneCreateField extends ExtendedForm.SdkCommandCreateNoneField {
    public SdkCommandCreateNoneCreateField(BaseForm.MainBox.CreatingFormDataFieldsGroupBox container) {
      super(container);
    }
  }

  @Replace
  @FormData(sdkCommand = SdkCommand.USE, value = UsingFormFieldData.class)
  public class SdkCommandCreateNoneUseField extends ExtendedForm.SdkCommandCreateNoneField {
    public SdkCommandCreateNoneUseField(BaseForm.MainBox.CreatingFormDataFieldsGroupBox container) {
      super(container);
    }
  }

  @Replace
  @FormData(sdkCommand = SdkCommand.IGNORE)
  public class SdkCommandCreateNoneIgnoreField extends ExtendedForm.SdkCommandCreateNoneField {
    public SdkCommandCreateNoneIgnoreField(BaseForm.MainBox.CreatingFormDataFieldsGroupBox container) {
      super(container);
    }
  }

  @Replace
  public class SdkCommandCreateCreateNoneField extends ExtendedForm.SdkCommandCreateCreateField {
    public SdkCommandCreateCreateNoneField(BaseForm.MainBox.CreatingFormDataFieldsGroupBox container) {
      super(container);
    }
  }

  @Replace
  @FormData(sdkCommand = SdkCommand.CREATE)
  public class SdkCommandCreateCreateCreateField extends ExtendedForm.SdkCommandCreateCreateField {
    public SdkCommandCreateCreateCreateField(BaseForm.MainBox.CreatingFormDataFieldsGroupBox container) {
      super(container);
    }
  }

  @Replace
  @FormData(sdkCommand = SdkCommand.USE, value = UsingFormFieldData.class)
  public class SdkCommandCreateCreateUseField extends ExtendedForm.SdkCommandCreateCreateField {
    public SdkCommandCreateCreateUseField(BaseForm.MainBox.CreatingFormDataFieldsGroupBox container) {
      super(container);
    }
  }

  @Replace
  @FormData(sdkCommand = SdkCommand.IGNORE)
  public class SdkCommandCreateCreateIgnoreField extends ExtendedForm.SdkCommandCreateCreateField {
    public SdkCommandCreateCreateIgnoreField(BaseForm.MainBox.CreatingFormDataFieldsGroupBox container) {
      super(container);
    }
  }

  @Replace
  public class SdkCommandCreateUseNoneField extends ExtendedForm.SdkCommandCreateUseField {
    public SdkCommandCreateUseNoneField(BaseForm.MainBox.CreatingFormDataFieldsGroupBox container) {
      super(container);
    }
  }

  @Replace
  @FormData(sdkCommand = SdkCommand.CREATE)
  public class SdkCommandCreateUseCreateField extends ExtendedForm.SdkCommandCreateUseField {
    public SdkCommandCreateUseCreateField(BaseForm.MainBox.CreatingFormDataFieldsGroupBox container) {
      super(container);
    }
  }

  @Replace
  @FormData(sdkCommand = SdkCommand.USE, value = UsingFormFieldData.class)
  public class SdkCommandCreateUseUseField extends ExtendedForm.SdkCommandCreateUseField {
    public SdkCommandCreateUseUseField(BaseForm.MainBox.CreatingFormDataFieldsGroupBox container) {
      super(container);
    }
  }

  @Replace
  @FormData(sdkCommand = SdkCommand.IGNORE)
  public class SdkCommandCreateUseIgnoreField extends ExtendedForm.SdkCommandCreateUseField {
    public SdkCommandCreateUseIgnoreField(BaseForm.MainBox.CreatingFormDataFieldsGroupBox container) {
      super(container);
    }
  }

  @Replace
  public class SdkCommandCreateIgnoreNoneField extends ExtendedForm.SdkCommandCreateIgnoreField {
    public SdkCommandCreateIgnoreNoneField(BaseForm.MainBox.CreatingFormDataFieldsGroupBox container) {
      super(container);
    }
  }

  @Replace
  @FormData(sdkCommand = SdkCommand.CREATE)
  public class SdkCommandCreateIgnoreCreateField extends ExtendedForm.SdkCommandCreateIgnoreField {
    public SdkCommandCreateIgnoreCreateField(BaseForm.MainBox.CreatingFormDataFieldsGroupBox container) {
      super(container);
    }
  }

  @Replace
  @FormData(sdkCommand = SdkCommand.USE, value = UsingFormFieldData.class)
  public class SdkCommandCreateIgnoreUseField extends ExtendedForm.SdkCommandCreateIgnoreField {
    public SdkCommandCreateIgnoreUseField(BaseForm.MainBox.CreatingFormDataFieldsGroupBox container) {
      super(container);
    }
  }

  @Replace
  @FormData(sdkCommand = SdkCommand.IGNORE)
  public class SdkCommandCreateIgnoreIgnoreField extends ExtendedForm.SdkCommandCreateIgnoreField {
    public SdkCommandCreateIgnoreIgnoreField(BaseForm.MainBox.CreatingFormDataFieldsGroupBox container) {
      super(container);
    }
  }

  /* ##########################################################################
   * replacing fields that are using a form data (SdkCommand USE)
   * expectation: replacing form field data must be created and it must be a
   *              subclass of the parent field's form field data. Hence any
   *              @FormData annotation available on the field replacements are
   *              ignored.
   * ##########################################################################
   */
  @Replace
  public class SdkCommandUseNoneNoneField extends ExtendedForm.SdkCommandUseNoneField {
    public SdkCommandUseNoneNoneField(BaseForm.MainBox.UsingFormDataFieldsGroupBox container) {
      super(container);
    }
  }

  @Replace
  @FormData(sdkCommand = SdkCommand.CREATE)
  public class SdkCommandUseNoneCreateField extends ExtendedForm.SdkCommandUseNoneField {
    public SdkCommandUseNoneCreateField(BaseForm.MainBox.UsingFormDataFieldsGroupBox container) {
      super(container);
    }
  }

  @Replace
  @FormData(sdkCommand = SdkCommand.USE, value = UsingFormFieldData.class)
  public class SdkCommandUseNoneUseField extends ExtendedForm.SdkCommandUseNoneField {
    public SdkCommandUseNoneUseField(BaseForm.MainBox.UsingFormDataFieldsGroupBox container) {
      super(container);
    }
  }

  @Replace
  @FormData(sdkCommand = SdkCommand.IGNORE)
  public class SdkCommandUseNoneIgnoreField extends ExtendedForm.SdkCommandUseNoneField {
    public SdkCommandUseNoneIgnoreField(BaseForm.MainBox.UsingFormDataFieldsGroupBox container) {
      super(container);
    }
  }

  @Replace
  public class SdkCommandUseCreateNoneField extends ExtendedForm.SdkCommandUseCreateField {
    public SdkCommandUseCreateNoneField(BaseForm.MainBox.UsingFormDataFieldsGroupBox container) {
      super(container);
    }
  }

  @Replace
  @FormData(sdkCommand = SdkCommand.CREATE)
  public class SdkCommandUseCreateCreateField extends ExtendedForm.SdkCommandUseCreateField {
    public SdkCommandUseCreateCreateField(BaseForm.MainBox.UsingFormDataFieldsGroupBox container) {
      super(container);
    }
  }

  @Replace
  @FormData(sdkCommand = SdkCommand.USE, value = UsingFormFieldData.class)
  public class SdkCommandUseCreateUseField extends ExtendedForm.SdkCommandUseCreateField {
    public SdkCommandUseCreateUseField(BaseForm.MainBox.UsingFormDataFieldsGroupBox container) {
      super(container);
    }
  }

  @Replace
  @FormData(sdkCommand = SdkCommand.IGNORE)
  public class SdkCommandUseCreateIgnoreField extends ExtendedForm.SdkCommandUseCreateField {
    public SdkCommandUseCreateIgnoreField(BaseForm.MainBox.UsingFormDataFieldsGroupBox container) {
      super(container);
    }
  }

  @Replace
  public class SdkCommandUseUseNoneField extends ExtendedForm.SdkCommandUseUseField {
    public SdkCommandUseUseNoneField(BaseForm.MainBox.UsingFormDataFieldsGroupBox container) {
      super(container);
    }
  }

  @Replace
  @FormData(sdkCommand = SdkCommand.CREATE)
  public class SdkCommandUseUseCreateField extends ExtendedForm.SdkCommandUseUseField {
    public SdkCommandUseUseCreateField(BaseForm.MainBox.UsingFormDataFieldsGroupBox container) {
      super(container);
    }
  }

  @Replace
  @FormData(sdkCommand = SdkCommand.USE, value = UsingFormFieldData.class)
  public class SdkCommandUseUseUseField extends ExtendedForm.SdkCommandUseUseField {
    public SdkCommandUseUseUseField(BaseForm.MainBox.UsingFormDataFieldsGroupBox container) {
      super(container);
    }
  }

  @Replace
  @FormData(sdkCommand = SdkCommand.IGNORE)
  public class SdkCommandUseUseIgnoreField extends ExtendedForm.SdkCommandUseUseField {
    public SdkCommandUseUseIgnoreField(BaseForm.MainBox.UsingFormDataFieldsGroupBox container) {
      super(container);
    }
  }

  @Replace
  public class SdkCommandUseIgnoreNoneField extends ExtendedForm.SdkCommandUseIgnoreField {
    public SdkCommandUseIgnoreNoneField(BaseForm.MainBox.UsingFormDataFieldsGroupBox container) {
      super(container);
    }
  }

  @Replace
  @FormData(sdkCommand = SdkCommand.CREATE)
  public class SdkCommandUseIgnoreCreateField extends ExtendedForm.SdkCommandUseIgnoreField {
    public SdkCommandUseIgnoreCreateField(BaseForm.MainBox.UsingFormDataFieldsGroupBox container) {
      super(container);
    }
  }

  @Replace
  @FormData(sdkCommand = SdkCommand.USE, value = UsingFormFieldData.class)
  public class SdkCommandUseIgnoreUseField extends ExtendedForm.SdkCommandUseIgnoreField {
    public SdkCommandUseIgnoreUseField(BaseForm.MainBox.UsingFormDataFieldsGroupBox container) {
      super(container);
    }
  }

  @Replace
  @FormData(sdkCommand = SdkCommand.IGNORE)
  public class SdkCommandUseIgnoreIgnoreField extends ExtendedForm.SdkCommandUseIgnoreField {
    public SdkCommandUseIgnoreIgnoreField(BaseForm.MainBox.UsingFormDataFieldsGroupBox container) {
      super(container);
    }
  }

  /* ########################################################################
   * replacing fields that are ignoring a form data (SdkCommand IGNORE)
   * expectation: replacing form field data must be created if the replacement
   *              field is not annotated with SdkCommand.IGNORE. There is no
   *              special parent field data handling required.
   * ########################################################################
   */
  @Replace
  public class SdkCommandIgnoreNoneNoneField extends ExtendedForm.SdkCommandIgnoreNoneField {
    public SdkCommandIgnoreNoneNoneField(BaseForm.MainBox.IgnoringFormDataFieldsGroupBox container) {
      super(container);
    }
  }

  @Replace
  @FormData(sdkCommand = SdkCommand.CREATE)
  public class SdkCommandIgnoreNoneCreateField extends ExtendedForm.SdkCommandIgnoreNoneField {
    public SdkCommandIgnoreNoneCreateField(BaseForm.MainBox.IgnoringFormDataFieldsGroupBox container) {
      super(container);
    }
  }

  @Replace
  @FormData(sdkCommand = SdkCommand.USE, value = UsingFormFieldData.class)
  public class SdkCommandIgnoreNoneUseField extends ExtendedForm.SdkCommandIgnoreNoneField {
    public SdkCommandIgnoreNoneUseField(BaseForm.MainBox.IgnoringFormDataFieldsGroupBox container) {
      super(container);
    }
  }

  @Replace
  @FormData(sdkCommand = SdkCommand.IGNORE)
  public class SdkCommandIgnoreNoneIgnoreField extends ExtendedForm.SdkCommandIgnoreNoneField {
    public SdkCommandIgnoreNoneIgnoreField(BaseForm.MainBox.IgnoringFormDataFieldsGroupBox container) {
      super(container);
    }
  }

  @Replace
  public class SdkCommandIgnoreCreateNoneField extends ExtendedForm.SdkCommandIgnoreCreateField {
    public SdkCommandIgnoreCreateNoneField(BaseForm.MainBox.IgnoringFormDataFieldsGroupBox container) {
      super(container);
    }
  }

  @Replace
  @FormData(sdkCommand = SdkCommand.CREATE)
  public class SdkCommandIgnoreCreateCreateField extends ExtendedForm.SdkCommandIgnoreCreateField {
    public SdkCommandIgnoreCreateCreateField(BaseForm.MainBox.IgnoringFormDataFieldsGroupBox container) {
      super(container);
    }
  }

  @Replace
  @FormData(sdkCommand = SdkCommand.USE, value = UsingFormFieldData.class)
  public class SdkCommandIgnoreCreateUseField extends ExtendedForm.SdkCommandIgnoreCreateField {
    public SdkCommandIgnoreCreateUseField(BaseForm.MainBox.IgnoringFormDataFieldsGroupBox container) {
      super(container);
    }
  }

  @Replace
  @FormData(sdkCommand = SdkCommand.IGNORE)
  public class SdkCommandIgnoreCreateIgnoreField extends ExtendedForm.SdkCommandIgnoreCreateField {
    public SdkCommandIgnoreCreateIgnoreField(BaseForm.MainBox.IgnoringFormDataFieldsGroupBox container) {
      super(container);
    }
  }

  @Replace
  public class SdkCommandIgnoreUseNoneField extends ExtendedForm.SdkCommandIgnoreUseField {
    public SdkCommandIgnoreUseNoneField(BaseForm.MainBox.IgnoringFormDataFieldsGroupBox container) {
      super(container);
    }
  }

  @Replace
  @FormData(sdkCommand = SdkCommand.CREATE)
  public class SdkCommandIgnoreUseCreateField extends ExtendedForm.SdkCommandIgnoreUseField {
    public SdkCommandIgnoreUseCreateField(BaseForm.MainBox.IgnoringFormDataFieldsGroupBox container) {
      super(container);
    }
  }

  @Replace
  @FormData(sdkCommand = SdkCommand.USE, value = UsingFormFieldData.class)
  public class SdkCommandIgnoreUseUseField extends ExtendedForm.SdkCommandIgnoreUseField {
    public SdkCommandIgnoreUseUseField(BaseForm.MainBox.IgnoringFormDataFieldsGroupBox container) {
      super(container);
    }
  }

  @Replace
  @FormData(sdkCommand = SdkCommand.IGNORE)
  public class SdkCommandIgnoreUseIgnoreField extends ExtendedForm.SdkCommandIgnoreUseField {
    public SdkCommandIgnoreUseIgnoreField(BaseForm.MainBox.IgnoringFormDataFieldsGroupBox container) {
      super(container);
    }
  }

  @Replace
  public class SdkCommandIgnoreIgnoreNoneField extends ExtendedForm.SdkCommandIgnoreIgnoreField {
    public SdkCommandIgnoreIgnoreNoneField(BaseForm.MainBox.IgnoringFormDataFieldsGroupBox container) {
      super(container);
    }
  }

  @Replace
  @FormData(sdkCommand = SdkCommand.CREATE)
  public class SdkCommandIgnoreIgnoreCreateField extends ExtendedForm.SdkCommandIgnoreIgnoreField {
    public SdkCommandIgnoreIgnoreCreateField(BaseForm.MainBox.IgnoringFormDataFieldsGroupBox container) {
      super(container);
    }
  }

  @Replace
  @FormData(sdkCommand = SdkCommand.USE, value = UsingFormFieldData.class)
  public class SdkCommandIgnoreIgnoreUseField extends ExtendedForm.SdkCommandIgnoreIgnoreField {
    public SdkCommandIgnoreIgnoreUseField(BaseForm.MainBox.IgnoringFormDataFieldsGroupBox container) {
      super(container);
    }
  }

  @Replace
  @FormData(sdkCommand = SdkCommand.IGNORE)
  public class SdkCommandIgnoreIgnoreIgnoreField extends ExtendedForm.SdkCommandIgnoreIgnoreField {
    public SdkCommandIgnoreIgnoreIgnoreField(BaseForm.MainBox.IgnoringFormDataFieldsGroupBox container) {
      super(container);
    }
  }

  /* ########################################################################
   * additional tests
   * ########################################################################
   */
  @Replace
  public class NameExExField extends NameExField {

    private String m_stringProperty;

    public NameExExField(GroupBox container) {
      super(container);
    }

    @FormData
    public String getStringProperty() {
      return m_stringProperty;
    }

    @FormData
    public void setStringProperty(String stringProperty) {
      m_stringProperty = stringProperty;
    }

    @Override
    protected int getConfiguredMaxLength() {
      return 15;
    }
  }

  @Replace
  public class IgnoringGroupBoxExNoneNoneField extends ExtendedForm.IgnoringGroupBoxExNoneField {

    public IgnoringGroupBoxExNoneNoneField(BaseForm.MainBox.IgnoringGroupBox container) {
      super(container);
    }
  }

  @Replace
  @FormData(sdkCommand = SdkCommand.CREATE)
  public class IgnoringGroupBoxExNoneCreateField extends ExtendedForm.IgnoringGroupBoxExNoneField {

    public IgnoringGroupBoxExNoneCreateField(BaseForm.MainBox.IgnoringGroupBox container) {
      super(container);
    }
  }

  @Replace
  public class IgnoringGroupBoxExCreateNoneField extends ExtendedForm.IgnoringGroupBoxExCreateField {

    public IgnoringGroupBoxExCreateNoneField(BaseForm.MainBox.IgnoringGroupBox container) {
      super(container);
    }
  }
}




/*******************************************************************************
 * Copyright (c) 2010 BSI Business Systems Integration AG.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *     BSI Business Systems Integration AG - initial API and implementation
 ******************************************************************************/
package formdata.client.ui.forms.replace;

import org.eclipse.scout.commons.annotations.FormData;
import org.eclipse.scout.commons.annotations.FormData.SdkCommand;
import org.eclipse.scout.commons.annotations.InjectFieldTo;
import org.eclipse.scout.commons.annotations.Order;
import org.eclipse.scout.commons.annotations.Replace;
import org.eclipse.scout.commons.exception.ProcessingException;
import org.eclipse.scout.rt.client.ui.form.fields.stringfield.AbstractStringField;
import org.eclipse.scout.rt.shared.data.form.ValidationRule;
import org.eclipse.scout.rt.shared.services.common.code.ICodeType;

import formdata.shared.services.process.replace.ExtendedFormData;
import formdata.shared.services.process.replace.UsingFormFieldData;

@FormData(value = ExtendedFormData.class, sdkCommand = SdkCommand.CREATE)
public class ExtendedForm extends BaseForm {

  public ExtendedForm() throws ProcessingException {
    super();
  }

  /* ##########################################################################
   * injecting additional field
   * ##########################################################################
   */
  @Order(20)
  @InjectFieldTo(BaseForm.MainBox.class)
  public class FirstNameField extends AbstractStringField {
  }

  /* ##########################################################################
   * replacing fields that are creating a form data (without explicitly
   * defining a @FormData annotation)
   * expectation: replacing form field data must be created and it must be a
   *              subclass of the parent field's form field data. Hence any
   *              @FormData annotation available on the field replacements are
   *              ignored.
   * ##########################################################################
   */
  @Replace
  public class SdkCommandNoneNoneField extends BaseForm.MainBox.NoneFormDataFieldsGroupBox.SdkCommandNoneField {
    public SdkCommandNoneNoneField(BaseForm.MainBox.NoneFormDataFieldsGroupBox container) {
      container.super();
    }
  }

  @Replace
  @FormData(sdkCommand = SdkCommand.CREATE)
  public class SdkCommandNoneCreateField extends BaseForm.MainBox.NoneFormDataFieldsGroupBox.SdkCommandNoneField {
    public SdkCommandNoneCreateField(BaseForm.MainBox.NoneFormDataFieldsGroupBox container) {
      container.super();
    }
  }

  @Replace
  @FormData(sdkCommand = SdkCommand.USE, value = UsingFormFieldData.class)
  public class SdkCommandNoneUseField extends BaseForm.MainBox.NoneFormDataFieldsGroupBox.SdkCommandNoneField {
    public SdkCommandNoneUseField(BaseForm.MainBox.NoneFormDataFieldsGroupBox container) {
      container.super();
    }
  }

  @Replace
  @FormData(sdkCommand = SdkCommand.IGNORE)
  public class SdkCommandNoneIgnoreField extends BaseForm.MainBox.NoneFormDataFieldsGroupBox.SdkCommandNoneField {
    public SdkCommandNoneIgnoreField(BaseForm.MainBox.NoneFormDataFieldsGroupBox container) {
      container.super();
    }
  }

  /* ##########################################################################
   * replacing fields that are creating a form data (SdkCommand CREATE)
   * expectation: replacing form field data must be created and it must be a
   *              subclass of the parent field's form field data. Hence any
   *              @FormData annotation available on the field replacements are
   *              ignored.
   * ##########################################################################
   */
  @Replace
  public class SdkCommandCreateNoneField extends BaseForm.MainBox.CreatingFormDataFieldsGroupBox.SdkCommandCreateField {
    public SdkCommandCreateNoneField(BaseForm.MainBox.CreatingFormDataFieldsGroupBox container) {
      container.super();
    }
  }

  @Replace
  @FormData(sdkCommand = SdkCommand.CREATE)
  public class SdkCommandCreateCreateField extends BaseForm.MainBox.CreatingFormDataFieldsGroupBox.SdkCommandCreateField {
    public SdkCommandCreateCreateField(BaseForm.MainBox.CreatingFormDataFieldsGroupBox container) {
      container.super();
    }
  }

  @Replace
  @FormData(sdkCommand = SdkCommand.USE, value = UsingFormFieldData.class)
  public class SdkCommandCreateUseField extends BaseForm.MainBox.CreatingFormDataFieldsGroupBox.SdkCommandCreateField {
    public SdkCommandCreateUseField(BaseForm.MainBox.CreatingFormDataFieldsGroupBox container) {
      container.super();
    }
  }

  @Replace
  @FormData(sdkCommand = SdkCommand.IGNORE)
  public class SdkCommandCreateIgnoreField extends BaseForm.MainBox.CreatingFormDataFieldsGroupBox.SdkCommandCreateField {
    public SdkCommandCreateIgnoreField(BaseForm.MainBox.CreatingFormDataFieldsGroupBox container) {
      container.super();
    }
  }

  /* ##########################################################################
   * replacing fields that are using a form data (SdkCommand USE)
   * expectation: replacing form field data must be created and it must be a
   *              subclass of the parent field's form field data. Hence any
   *              @FormData annotation available on the field replacements are
   *              ignored.
   * ##########################################################################
   */
  @Replace
  public class SdkCommandUseNoneField extends BaseForm.MainBox.UsingFormDataFieldsGroupBox.SdkCommandUseField {
    public SdkCommandUseNoneField(BaseForm.MainBox.UsingFormDataFieldsGroupBox container) {
      container.super();
    }
  }

  @Replace
  @FormData(sdkCommand = SdkCommand.CREATE)
  public class SdkCommandUseCreateField extends BaseForm.MainBox.UsingFormDataFieldsGroupBox.SdkCommandUseField {
    public SdkCommandUseCreateField(BaseForm.MainBox.UsingFormDataFieldsGroupBox container) {
      container.super();
    }
  }

  @Replace
  @FormData(sdkCommand = SdkCommand.USE, value = UsingFormFieldData.class)
  public class SdkCommandUseUseField extends BaseForm.MainBox.UsingFormDataFieldsGroupBox.SdkCommandUseField {
    public SdkCommandUseUseField(BaseForm.MainBox.UsingFormDataFieldsGroupBox container) {
      container.super();
    }
  }

  @Replace
  @FormData(sdkCommand = SdkCommand.IGNORE)
  public class SdkCommandUseIgnoreField extends BaseForm.MainBox.UsingFormDataFieldsGroupBox.SdkCommandUseField {
    public SdkCommandUseIgnoreField(BaseForm.MainBox.UsingFormDataFieldsGroupBox container) {
      container.super();
    }
  }

  /* ########################################################################
   * replacing fields that are ignoring a form data (SdkCommand IGNORE)
   * expectation: replacing form field data must be created if the replacement
   *              field is not annotated with SdkCommand.IGNORE. There is no
   *              special parent field data handling required.
   * ########################################################################
   */
  @Replace
  public class SdkCommandIgnoreNoneField extends BaseForm.MainBox.IgnoringFormDataFieldsGroupBox.SdkCommandIgnoreField {
    public SdkCommandIgnoreNoneField(BaseForm.MainBox.IgnoringFormDataFieldsGroupBox container) {
      container.super();
    }
  }

  @Replace
  @FormData(sdkCommand = SdkCommand.CREATE)
  public class SdkCommandIgnoreCreateField extends BaseForm.MainBox.IgnoringFormDataFieldsGroupBox.SdkCommandIgnoreField {
    public SdkCommandIgnoreCreateField(BaseForm.MainBox.IgnoringFormDataFieldsGroupBox container) {
      container.super();
    }
  }

  @Replace
  @FormData(sdkCommand = SdkCommand.USE, value = UsingFormFieldData.class)
  public class SdkCommandIgnoreUseField extends BaseForm.MainBox.IgnoringFormDataFieldsGroupBox.SdkCommandIgnoreField {
    public SdkCommandIgnoreUseField(BaseForm.MainBox.IgnoringFormDataFieldsGroupBox container) {
      container.super();
    }
  }

  @Replace
  @FormData(sdkCommand = SdkCommand.IGNORE)
  public class SdkCommandIgnoreIgnoreField extends BaseForm.MainBox.IgnoringFormDataFieldsGroupBox.SdkCommandIgnoreField {
    public SdkCommandIgnoreIgnoreField(BaseForm.MainBox.IgnoringFormDataFieldsGroupBox container) {
      container.super();
    }
  }

  /* ########################################################################
   * additional tests
   * ########################################################################
   */
  @Replace
  public class NameExField extends BaseForm.MainBox.GroupBox.NameField {

    public NameExField(BaseForm.MainBox.GroupBox container) {
      container.super();
    }

    @Override
    protected boolean getConfiguredMandatory() {
      return false;
    }

    @Override
    protected int getConfiguredMaxLength() {
      return 100;
    }
  }

  @Replace
  public class SmartExField extends BaseForm.MainBox.GroupBox.SmartField {

    public SmartExField(BaseForm.MainBox.GroupBox container) {
      container.super();
    }

    @Override
    @ValidationRule(value = ValidationRule.CODE_TYPE, skip = true)
    protected Class<? extends ICodeType<?>> getConfiguredCodeType() {
      return super.getConfiguredCodeType();
    }
  }

  @Replace
  public class IgnoringGroupBoxExNoneField extends BaseForm.MainBox.IgnoringGroupBox.IgnoringGroupBoxField {

    public IgnoringGroupBoxExNoneField(BaseForm.MainBox.IgnoringGroupBox container) {
      container.super();
    }
  }

  @Replace
  @FormData(sdkCommand = SdkCommand.CREATE)
  public class IgnoringGroupBoxExCreateField extends BaseForm.MainBox.IgnoringGroupBox.IgnoringGroupBoxField {

    public IgnoringGroupBoxExCreateField(BaseForm.MainBox.IgnoringGroupBox container) {
      container.super();
    }
  }

  @Replace
  @FormData(sdkCommand = SdkCommand.USE, value = UsingFormFieldData.class)
  public class IgnoringGroupBoxExUseField extends BaseForm.MainBox.IgnoringGroupBox.IgnoringGroupBoxField {

    public IgnoringGroupBoxExUseField(BaseForm.MainBox.IgnoringGroupBox container) {
      container.super();
    }
  }

  @Replace
  @FormData(sdkCommand = SdkCommand.IGNORE)
  public class IgnoringGroupBoxExIgnoreField extends BaseForm.MainBox.IgnoringGroupBox.IgnoringGroupBoxField {

    public IgnoringGroupBoxExIgnoreField(BaseForm.MainBox.IgnoringGroupBox container) {
      container.super();
    }
  }

  @Replace
  public class CloseExButton extends BaseForm.MainBox.CloseButton {

    public CloseExButton(BaseForm.MainBox container) {
      container.super();
    }
  }
}




/*******************************************************************************
 * Copyright (c) 2010 BSI Business Systems Integration AG.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *     BSI Business Systems Integration AG - initial API and implementation
 ******************************************************************************/
package formdata.client.ui.forms.replace;

import org.eclipse.scout.commons.annotations.FormData;
import org.eclipse.scout.commons.annotations.FormData.SdkCommand;
import org.eclipse.scout.commons.annotations.Order;
import org.eclipse.scout.commons.exception.ProcessingException;
import org.eclipse.scout.rt.client.ui.basic.table.AbstractTable;
import org.eclipse.scout.rt.client.ui.basic.table.ITable;
import org.eclipse.scout.rt.client.ui.basic.table.columns.AbstractStringColumn;
import org.eclipse.scout.rt.client.ui.form.AbstractForm;
import org.eclipse.scout.rt.client.ui.form.fields.groupbox.AbstractGroupBox;
import org.eclipse.scout.rt.client.ui.form.fields.tablefield.AbstractTableField;
import org.eclipse.scout.rt.shared.data.form.fields.tablefield.AbstractTableFieldBeanData;

import formdata.shared.services.process.replace.TableFieldBaseFormData;

@FormData(value = TableFieldBaseFormData.class, sdkCommand = SdkCommand.CREATE)
public class TableFieldBaseForm extends AbstractForm {

  /**
   * @throws ProcessingException
   */
  public TableFieldBaseForm() throws ProcessingException {
    super();
  }

  @Order(10.0)
  public class MainBox extends AbstractGroupBox {

    @Order(10.0)
    @FormData(sdkCommand = SdkCommand.USE, value = AbstractTableFieldBeanData.class)
    public class TableField extends AbstractTableField<TableField.Table> {

      public class Table extends AbstractTable {

        @Order(10.0)
        public class FirstColumn extends AbstractStringColumn {

        }

        @Order(20.0)
        public class SecondColumn extends AbstractStringColumn {

        }
      }
    }

    @Order(20.0)
    @FormData(sdkCommand = SdkCommand.USE, value = AbstractTableFieldBeanData.class)
    public class EmptyTableField extends AbstractTableField<EmptyTableField.Table> {

      public class Table extends AbstractTable {
      }
    }

    @Order(30.0)
    @FormData(sdkCommand = SdkCommand.USE, value = AbstractTableFieldBeanData.class)
    public class NoTableField extends AbstractTableField<ITable> {
    }
  }
}




/*******************************************************************************
 * Copyright (c) 2010 BSI Business Systems Integration AG.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *     BSI Business Systems Integration AG - initial API and implementation
 ******************************************************************************/
package formdata.client.ui.forms.replace;

import org.eclipse.scout.commons.annotations.FormData;
import org.eclipse.scout.commons.annotations.FormData.SdkCommand;
import org.eclipse.scout.commons.annotations.Order;
import org.eclipse.scout.commons.annotations.Replace;
import org.eclipse.scout.commons.exception.ProcessingException;
import org.eclipse.scout.rt.client.ui.basic.table.AbstractTable;
import org.eclipse.scout.rt.client.ui.basic.table.columns.AbstractBooleanColumn;
import org.eclipse.scout.rt.client.ui.basic.table.columns.AbstractStringColumn;

import formdata.shared.services.process.replace.TableFieldExFormData;

/**
 *
 */
@FormData(value = TableFieldExFormData.class, sdkCommand = SdkCommand.CREATE)
public class TableFieldExForm extends TableFieldBaseForm {

  public TableFieldExForm() throws ProcessingException {
    super();
  }

  @Replace
  public class TableExtendedField extends TableFieldBaseForm.MainBox.TableField {

    public TableExtendedField(TableFieldBaseForm.MainBox container) {
      container.super();
    }

    public class TableEx extends Table {

      @Order(30)
      @Replace
      public class FirstExtendedColumn extends FirstColumn {

      }

      @Order(40)
      public class BooleanColumn extends AbstractBooleanColumn {

      }
    }
  }

  @Replace
  public class EmptyTableExtendedField extends TableFieldBaseForm.MainBox.EmptyTableField {

    public EmptyTableExtendedField(TableFieldBaseForm.MainBox container) {
      container.super();
    }

    public class TableEx extends Table {

      public class SingleColumn extends AbstractStringColumn {

      }
    }
  }

  @Replace
  public class NoTableExtendedField extends TableFieldBaseForm.MainBox.NoTableField {

    public NoTableExtendedField(TableFieldBaseForm.MainBox container) {
      container.super();
    }

    public class Table extends AbstractTable {

      public class NewColumn extends AbstractStringColumn {

      }
    }
  }
}




//@SuiteClasses({FormWithTemplateTest.class, TemplateFormDataTest.class})
@SuiteClasses({
    ExternalCheckboxFieldTest.class,
    ExternalGroupboxTest.class,
    ExternalTableFieldTest.class,
    FormPropertiesTest.class,
    FormWithGroupboxesTest.class,
    FormWithTemplateTest.class,
    IgnoredFieldsFormTest.class,
    ListBoxFormTest.class,
    ReplaceFormFiledTest.class,
    SimpleFormTest.class,
    TableFieldFormTest.class})
    ExternalGroupboxTest.class})
public class _SuiteFormData {

}




/*******************************************************************************
 * Copyright (c) 2010 BSI Business Systems Integration AG.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *     BSI Business Systems Integration AG - initial API and implementation
 ******************************************************************************/
package org.eclipse.scout.sdk.internal.test.operation.formdata;

import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertTrue;

import java.util.HashMap;
import java.util.Map;

import javax.annotation.Generated;

import org.eclipse.core.resources.IProject;
import org.eclipse.jdt.core.IMethod;
import org.eclipse.jdt.core.ISourceRange;
import org.eclipse.jdt.core.IType;
import org.eclipse.scout.sdk.jobs.OperationJob;
import org.eclipse.scout.sdk.operation.form.formdata.FormDataUpdateOperation;
import org.eclipse.scout.sdk.test.AbstractScoutSdkTest;
import org.eclipse.scout.sdk.util.type.TypeUtility;
import org.junit.BeforeClass;
import org.junit.Test;

public class ReplaceFormFiledTest extends AbstractScoutSdkTest {

  private static IType s_baseFormData;
  private static IType s_extendedFormData;
  private static IType s_extendedExtendedFormData;
  private static Map<String, String> s_validationRules;

  @BeforeClass
  public static void setUpWorkspace() throws Exception {
    setupWorkspace("operation/formData", "formdata.shared", "formdata.client");

    IProject sharedProject = getProject("formdata.shared");
    assertNotNull(sharedProject);

    s_baseFormData = updateFormData(sharedProject, "formdata.client.ui.forms.replace.BaseForm", "formdata.shared.services.process.replace.BaseFormData", "AbstractFormData");
    s_extendedFormData = updateFormData(sharedProject, "formdata.client.ui.forms.replace.ExtendedForm", "formdata.shared.services.process.replace.ExtendedFormData", "BaseFormData");
    s_extendedExtendedFormData = updateFormData(sharedProject, "formdata.client.ui.forms.replace.ExtendedExtendedForm", "formdata.shared.services.process.replace.ExtendedExtendedFormData", "ExtendedFormData");

    s_validationRules = new HashMap<String, String>();
    s_validationRules.put("ValidationRule.MANDATORY", "\"mandatory\"");
    s_validationRules.put("ValidationRule.MIN_VALUE", "\"minValue\"");
    s_validationRules.put("ValidationRule.MAX_VALUE", "\"maxValue\"");
    s_validationRules.put("ValidationRule.MIN_LENGTH", "\"minLength\"");
    s_validationRules.put("ValidationRule.MAX_LENGTH", "\"maxLength\"");
    s_validationRules.put("ValidationRule.CODE_TYPE", "\"codeType\"");
    s_validationRules.put("ValidationRule.LOOKUP_CALL", "\"lookupCall\"");
    s_validationRules.put("ValidationRule.REGEX", "\"regex\"");
    s_validationRules.put("ValidationRule.MASTER_VALUE_FIELD", "\"masterValueField\"");
    s_validationRules.put("ValidationRule.MASTER_VALUE_REQUIRED", "\"masterValueRequired\"");
    s_validationRules.put("ValidationRule.ZERO_NULL_EQUALITY", "\"zeroNullEquality\"");
  }

  private static IType updateFormData(IProject sharedProject, String formFqcn, String formDataFqcn, String formDataSuperClassName) throws Exception {
    IType form = TypeUtility.getType(formFqcn);
    assertTrue(TypeUtility.exists(form));

    FormDataUpdateOperation op = new FormDataUpdateOperation(form);
    OperationJob job = new OperationJob(op);
    job.schedule();
    job.join();
    buildWorkspace();
    IType formData = op.getFormDataType();
    assertTrue(TypeUtility.exists(formData));
    assertEquals(formDataFqcn, formData.getFullyQualifiedName());
    assertEquals(formDataSuperClassName, formData.getSuperclassName());
    return formData;
  }

  private static void assertValidationRules(IType type, String... expectedLines) throws Exception {
    IMethod initValidationRulesMethod = TypeUtility.getMethod(type, "initValidationRules");

    if (expectedLines == null || expectedLines.length == 0) {
      assertFalse(TypeUtility.exists(initValidationRulesMethod));
      return;
    }

    // validation rules are expected. Check contents.
    assertTrue(TypeUtility.exists(initValidationRulesMethod));

    String source = initValidationRulesMethod.getSource();
    ISourceRange range = TypeUtility.getContentRange(initValidationRulesMethod);
    source = initValidationRulesMethod.getOpenable().getBuffer().getText(range.getOffset(), range.getLength());

    assertNotNull(source);

    source = source.replace("super.initValidationRules(ruleMap);", "");
    for (String line : expectedLines) {
      source = source.replace(line, "");

      // inline constants
      for (Map.Entry<String, String> rule : s_validationRules.entrySet()) {
        line = line.replace(rule.getKey(), rule.getValue());
      }
      source = source.replace(line, "");
    }

    source = source.trim();
    assertEquals("", source);
  }

  /* ##########################################################################
   * BaseForm tests
   * ##########################################################################
   */
  @Test
  public void testBaseFormName() throws Exception {
    IType type = s_baseFormData.getType("Name");
    assertTrue(TypeUtility.exists(type));
    assertEquals("AbstractValueFieldData<String>", type.getSuperclassName());
    assertValidationRules(type,
        "ruleMap.put(ValidationRule.MANDATORY, true);",
        "ruleMap.put(ValidationRule.MAX_LENGTH, 60);");
  }

  @Test
  public void testBaseFormSmart() throws Exception {
    IType type = s_baseFormData.getType("Smart");
    assertTrue(TypeUtility.exists(type));
    assertEquals("AbstractValueFieldData<Long>", type.getSuperclassName());
    assertValidationRules(type,
        "ruleMap.put(ValidationRule.CODE_TYPE, TestingCodeType.class);",
        "ruleMap.put(ValidationRule.ZERO_NULL_EQUALITY, true);");
  }

  @Test
  public void testBaseFormLookup() throws Exception {
    IType type = s_baseFormData.getType("Lookup");
    assertTrue(TypeUtility.exists(type));
    assertEquals("AbstractValueFieldData<Long>", type.getSuperclassName());
    assertValidationRules(type,
        "ruleMap.put(ValidationRule.LOOKUP_CALL, TestingLookupCall.class);",
        "ruleMap.put(ValidationRule.ZERO_NULL_EQUALITY, true);");
  }

  @Test
  public void testBaseFormDataIgnoringGroupBox() throws Exception {
    IType type = s_baseFormData.getType("IgnoringGroupBox");
    assertFalse(TypeUtility.exists(type));
  }

  @Test
  public void testBaseFormDataClose() throws Exception {
    IType type = s_baseFormData.getType("Close");
    assertFalse(TypeUtility.exists(type));
  }

  @Test
  @Generated("Replace Field Test Generator")
  public void testBaseFormDataSdkCommandNone() throws Exception {
    IType type = s_baseFormData.getType("SdkCommandNone");
    assertTrue(TypeUtility.exists(type));
    assertEquals("AbstractValueFieldData<String>", type.getSuperclassName());
    assertValidationRules(type,
        "ruleMap.put(ValidationRule.MAX_LENGTH, 4000);");
  }

  @Test
  @Generated("Replace Field Test Generator")
  public void testBaseFormDataSdkCommandCreate() throws Exception {
    IType type = s_baseFormData.getType("SdkCommandCreate");
    assertTrue(TypeUtility.exists(type));
    assertEquals("AbstractValueFieldData<String>", type.getSuperclassName());
    assertValidationRules(type,
        "ruleMap.put(ValidationRule.MAX_LENGTH, 4000);");
  }

  @Test
  @Generated("Replace Field Test Generator")
  public void testBaseFormDataSdkCommandUse() throws Exception {
    IType type = s_baseFormData.getType("SdkCommandUse");
    assertTrue(TypeUtility.exists(type));
    assertEquals("UsingFormFieldData", type.getSuperclassName());
    assertValidationRules(type,
        "ruleMap.put(ValidationRule.MAX_LENGTH, 4000);");
  }

  @Test
  @Generated("Replace Field Test Generator")
  public void testBaseFormDataSdkCommandIgnore() throws Exception {
    IType type = s_baseFormData.getType("SdkCommandIgnore");
    assertFalse(TypeUtility.exists(type));
  }

  /* ##########################################################################
   * ExtendedForm tests
   * ##########################################################################
   */
  @Test
  public void testExtendedFormFirstname() throws Exception {
    IType type = s_extendedFormData.getType("FirstName");
    assertTrue(TypeUtility.exists(type));
    assertEquals("AbstractValueFieldData<String>", type.getSuperclassName());
    assertValidationRules(type,
        "ruleMap.put(ValidationRule.MAX_LENGTH, 4000);");
  }

  @Test
  public void testExtendedFormNameEx() throws Exception {
    IType type = s_extendedFormData.getType("NameEx");
    assertTrue(TypeUtility.exists(type));
    assertEquals("BaseFormData.Name", type.getSuperclassName());
    assertValidationRules(type,
        "ruleMap.put(ValidationRule.MANDATORY, false);",
        "ruleMap.put(ValidationRule.MAX_LENGTH, 100);");
  }

  @Test
  public void testExtendedFormSmartEx() throws Exception {
    IType type = s_extendedFormData.getType("SmartEx");
    assertTrue(TypeUtility.exists(type));
    assertEquals("BaseFormData.Smart", type.getSuperclassName());
    assertValidationRules(type,
        "ruleMap.remove(ValidationRule.CODE_TYPE);");
  }

  @Test
  public void testExtendedFormDataIgnoringGroupBoxExNone() throws Exception {
    IType type = s_extendedFormData.getType("IgnoringGroupBoxExNone");
    assertFalse(TypeUtility.exists(type));
  }

  @Test
  public void testExtendedFormDataIgnoringGroupBoxExWithCreate() throws Exception {
    IType type = s_extendedFormData.getType("IgnoringGroupBoxExCreate");
    assertTrue(TypeUtility.exists(type));
    assertEquals("AbstractValueFieldData<String>", type.getSuperclassName());
    assertValidationRules(type,
        "ruleMap.put(ValidationRule.MAX_LENGTH, 4000);");
  }

  @Test
  public void testExtendedFormDataIgnoringGroupBoxExUse() throws Exception {
    IType type = s_extendedFormData.getType("IgnoringGroupBoxExUse");
    assertTrue(TypeUtility.exists(type));
    assertEquals("UsingFormFieldData", type.getSuperclassName());
    assertValidationRules(type,
        "ruleMap.put(ValidationRule.MAX_LENGTH, 4000);");
  }

  @Test
  public void testExtendedFormDataIgnoringGroupBoxExIgnore() throws Exception {
    IType type = s_extendedFormData.getType("IgnoringGroupBoxExIgnore");
    assertFalse(TypeUtility.exists(type));
  }

  @Test
  public void testExtendedFormDataCloseEx() throws Exception {
    IType type = s_extendedFormData.getType("CloseEx");
    assertFalse(TypeUtility.exists(type));
  }

  @Test
  public void testExtendedFormIgnoringGroupBoxExNone() throws Exception {
    IType type = s_extendedFormData.getType("IgnoringGroupBoxExNone");
    assertFalse(TypeUtility.exists(type));
  }

  @Test
  @Generated("Replace Field Test Generator")
  public void testExtendedFormDataSdkCommandNoneNone() throws Exception {
    IType type = s_extendedFormData.getType("SdkCommandNoneNone");
    assertTrue(TypeUtility.exists(type));
    assertEquals("BaseFormData.SdkCommandNone", type.getSuperclassName());
    assertValidationRules(type);
  }

  @Test
  @Generated("Replace Field Test Generator")
  public void testExtendedFormDataSdkCommandNoneCreate() throws Exception {
    IType type = s_extendedFormData.getType("SdkCommandNoneCreate");
    assertTrue(TypeUtility.exists(type));
    assertEquals("BaseFormData.SdkCommandNone", type.getSuperclassName());
    assertValidationRules(type);
  }

  @Test
  @Generated("Replace Field Test Generator")
  public void testExtendedFormDataSdkCommandNoneUse() throws Exception {
    IType type = s_extendedFormData.getType("SdkCommandNoneUse");
    assertTrue(TypeUtility.exists(type));
    assertEquals("BaseFormData.SdkCommandNone", type.getSuperclassName());
    assertValidationRules(type);
  }

  @Test
  @Generated("Replace Field Test Generator")
  public void testExtendedFormDataSdkCommandNoneIgnore() throws Exception {
    IType type = s_extendedFormData.getType("SdkCommandNoneIgnore");
    assertTrue(TypeUtility.exists(type));
    assertEquals("BaseFormData.SdkCommandNone", type.getSuperclassName());
    assertValidationRules(type);
  }

  @Test
  @Generated("Replace Field Test Generator")
  public void testExtendedFormDataSdkCommandCreateNone() throws Exception {
    IType type = s_extendedFormData.getType("SdkCommandCreateNone");
    assertTrue(TypeUtility.exists(type));
    assertEquals("BaseFormData.SdkCommandCreate", type.getSuperclassName());
    assertValidationRules(type);
  }

  @Test
  @Generated("Replace Field Test Generator")
  public void testExtendedFormDataSdkCommandCreateCreate() throws Exception {
    IType type = s_extendedFormData.getType("SdkCommandCreateCreate");
    assertTrue(TypeUtility.exists(type));
    assertEquals("BaseFormData.SdkCommandCreate", type.getSuperclassName());
    assertValidationRules(type);
  }

  @Test
  @Generated("Replace Field Test Generator")
  public void testExtendedFormDataSdkCommandCreateUse() throws Exception {
    IType type = s_extendedFormData.getType("SdkCommandCreateUse");
    assertTrue(TypeUtility.exists(type));
    assertEquals("BaseFormData.SdkCommandCreate", type.getSuperclassName());
    assertValidationRules(type);
  }

  @Test
  @Generated("Replace Field Test Generator")
  public void testExtendedFormDataSdkCommandCreateIgnore() throws Exception {
    IType type = s_extendedFormData.getType("SdkCommandCreateIgnore");
    assertTrue(TypeUtility.exists(type));
    assertEquals("BaseFormData.SdkCommandCreate", type.getSuperclassName());
    assertValidationRules(type);
  }

  @Test
  @Generated("Replace Field Test Generator")
  public void testExtendedFormDataSdkCommandUseNone() throws Exception {
    IType type = s_extendedFormData.getType("SdkCommandUseNone");
    assertTrue(TypeUtility.exists(type));
    assertEquals("BaseFormData.SdkCommandUse", type.getSuperclassName());
    assertValidationRules(type);
  }

  @Test
  @Generated("Replace Field Test Generator")
  public void testExtendedFormDataSdkCommandUseCreate() throws Exception {
    IType type = s_extendedFormData.getType("SdkCommandUseCreate");
    assertTrue(TypeUtility.exists(type));
    assertEquals("BaseFormData.SdkCommandUse", type.getSuperclassName());
    assertValidationRules(type);
  }

  @Test
  @Generated("Replace Field Test Generator")
  public void testExtendedFormDataSdkCommandUseUse() throws Exception {
    IType type = s_extendedFormData.getType("SdkCommandUseUse");
    assertTrue(TypeUtility.exists(type));
    assertEquals("BaseFormData.SdkCommandUse", type.getSuperclassName());
    assertValidationRules(type);
  }

  @Test
  @Generated("Replace Field Test Generator")
  public void testExtendedFormDataSdkCommandUseIgnore() throws Exception {
    IType type = s_extendedFormData.getType("SdkCommandUseIgnore");
    assertTrue(TypeUtility.exists(type));
    assertEquals("BaseFormData.SdkCommandUse", type.getSuperclassName());
    assertValidationRules(type);
  }

  @Test
  @Generated("Replace Field Test Generator")
  public void testExtendedFormDataSdkCommandIgnoreNone() throws Exception {
    IType type = s_extendedFormData.getType("SdkCommandIgnoreNone");
    assertFalse(TypeUtility.exists(type));
  }

  @Test
  @Generated("Replace Field Test Generator")
  public void testExtendedFormDataSdkCommandIgnoreCreate() throws Exception {
    IType type = s_extendedFormData.getType("SdkCommandIgnoreCreate");
    assertTrue(TypeUtility.exists(type));
    assertEquals("AbstractValueFieldData<String>", type.getSuperclassName());
    assertValidationRules(type,
        "ruleMap.put(ValidationRule.MAX_LENGTH, 4000);");
  }

  @Test
  @Generated("Replace Field Test Generator")
  public void testExtendedFormDataSdkCommandIgnoreUse() throws Exception {
    IType type = s_extendedFormData.getType("SdkCommandIgnoreUse");
    assertTrue(TypeUtility.exists(type));
    assertEquals("UsingFormFieldData", type.getSuperclassName());
    assertValidationRules(type,
        "ruleMap.put(ValidationRule.MAX_LENGTH, 4000);");
  }

  @Test
  @Generated("Replace Field Test Generator")
  public void testExtendedFormDataSdkCommandIgnoreIgnore() throws Exception {
    IType type = s_extendedFormData.getType("SdkCommandIgnoreIgnore");
    assertFalse(TypeUtility.exists(type));
  }

  /* ##########################################################################
   * ExtendedExtendedForm tests
   * ##########################################################################
   */
  @Test
  public void testExtendedExtendedFormNameExEx() throws Exception {
    IType type = s_extendedExtendedFormData.getType("NameExEx");
    assertTrue(TypeUtility.exists(type));
    assertEquals("ExtendedFormData.NameEx", type.getSuperclassName());
    assertValidationRules(type,
        "ruleMap.put(ValidationRule.MAX_LENGTH, 15);");
  }

  @Test
  @Generated("Replace Field Test Generator")
  public void testExtendedExtendedFormDataSdkCommandNoneNoneNone() throws Exception {
    IType type = s_extendedExtendedFormData.getType("SdkCommandNoneNoneNone");
    assertTrue(TypeUtility.exists(type));
    assertEquals("ExtendedFormData.SdkCommandNoneNone", type.getSuperclassName());
    assertValidationRules(type);
  }

  @Test
  @Generated("Replace Field Test Generator")
  public void testExtendedExtendedFormDataSdkCommandNoneNoneCreate() throws Exception {
    IType type = s_extendedExtendedFormData.getType("SdkCommandNoneNoneCreate");
    assertTrue(TypeUtility.exists(type));
    assertEquals("ExtendedFormData.SdkCommandNoneNone", type.getSuperclassName());
    assertValidationRules(type);
  }

  @Test
  @Generated("Replace Field Test Generator")
  public void testExtendedExtendedFormDataSdkCommandNoneNoneUse() throws Exception {
    IType type = s_extendedExtendedFormData.getType("SdkCommandNoneNoneUse");
    assertTrue(TypeUtility.exists(type));
    assertEquals("ExtendedFormData.SdkCommandNoneNone", type.getSuperclassName());
    assertValidationRules(type);
  }

  @Test
  @Generated("Replace Field Test Generator")
  public void testExtendedExtendedFormDataSdkCommandNoneNoneIgnore() throws Exception {
    IType type = s_extendedExtendedFormData.getType("SdkCommandNoneNoneIgnore");
    assertTrue(TypeUtility.exists(type));
    assertEquals("ExtendedFormData.SdkCommandNoneNone", type.getSuperclassName());
    assertValidationRules(type);
  }

  @Test
  @Generated("Replace Field Test Generator")
  public void testExtendedExtendedFormDataSdkCommandNoneCreateNone() throws Exception {
    IType type = s_extendedExtendedFormData.getType("SdkCommandNoneCreateNone");
    assertTrue(TypeUtility.exists(type));
    assertEquals("ExtendedFormData.SdkCommandNoneCreate", type.getSuperclassName());
    assertValidationRules(type);
  }

  @Test
  @Generated("Replace Field Test Generator")
  public void testExtendedExtendedFormDataSdkCommandNoneCreateCreate() throws Exception {
    IType type = s_extendedExtendedFormData.getType("SdkCommandNoneCreateCreate");
    assertTrue(TypeUtility.exists(type));
    assertEquals("ExtendedFormData.SdkCommandNoneCreate", type.getSuperclassName());
    assertValidationRules(type);
  }

  @Test
  @Generated("Replace Field Test Generator")
  public void testExtendedExtendedFormDataSdkCommandNoneCreateUse() throws Exception {
    IType type = s_extendedExtendedFormData.getType("SdkCommandNoneCreateUse");
    assertTrue(TypeUtility.exists(type));
    assertEquals("ExtendedFormData.SdkCommandNoneCreate", type.getSuperclassName());
    assertValidationRules(type);
  }

  @Test
  @Generated("Replace Field Test Generator")
  public void testExtendedExtendedFormDataSdkCommandNoneCreateIgnore() throws Exception {
    IType type = s_extendedExtendedFormData.getType("SdkCommandNoneCreateIgnore");
    assertTrue(TypeUtility.exists(type));
    assertEquals("ExtendedFormData.SdkCommandNoneCreate", type.getSuperclassName());
    assertValidationRules(type);
  }

  @Test
  @Generated("Replace Field Test Generator")
  public void testExtendedExtendedFormDataSdkCommandNoneUseNone() throws Exception {
    IType type = s_extendedExtendedFormData.getType("SdkCommandNoneUseNone");
    assertTrue(TypeUtility.exists(type));
    assertEquals("ExtendedFormData.SdkCommandNoneUse", type.getSuperclassName());
    assertValidationRules(type);
  }

  @Test
  @Generated("Replace Field Test Generator")
  public void testExtendedExtendedFormDataSdkCommandNoneUseCreate() throws Exception {
    IType type = s_extendedExtendedFormData.getType("SdkCommandNoneUseCreate");
    assertTrue(TypeUtility.exists(type));
    assertEquals("ExtendedFormData.SdkCommandNoneUse", type.getSuperclassName());
    assertValidationRules(type);
  }

  @Test
  @Generated("Replace Field Test Generator")
  public void testExtendedExtendedFormDataSdkCommandNoneUseUse() throws Exception {
    IType type = s_extendedExtendedFormData.getType("SdkCommandNoneUseUse");
    assertTrue(TypeUtility.exists(type));
    assertEquals("ExtendedFormData.SdkCommandNoneUse", type.getSuperclassName());
    assertValidationRules(type);
  }

  @Test
  @Generated("Replace Field Test Generator")
  public void testExtendedExtendedFormDataSdkCommandNoneUseIgnore() throws Exception {
    IType type = s_extendedExtendedFormData.getType("SdkCommandNoneUseIgnore");
    assertTrue(TypeUtility.exists(type));
    assertEquals("ExtendedFormData.SdkCommandNoneUse", type.getSuperclassName());
    assertValidationRules(type);
  }

  @Test
  @Generated("Replace Field Test Generator")
  public void testExtendedExtendedFormDataSdkCommandNoneIgnoreNone() throws Exception {
    IType type = s_extendedExtendedFormData.getType("SdkCommandNoneIgnoreNone");
    assertTrue(TypeUtility.exists(type));
    assertEquals("ExtendedFormData.SdkCommandNoneIgnore", type.getSuperclassName());
    assertValidationRules(type);
  }

  @Test
  @Generated("Replace Field Test Generator")
  public void testExtendedExtendedFormDataSdkCommandNoneIgnoreCreate() throws Exception {
    IType type = s_extendedExtendedFormData.getType("SdkCommandNoneIgnoreCreate");
    assertTrue(TypeUtility.exists(type));
    assertEquals("ExtendedFormData.SdkCommandNoneIgnore", type.getSuperclassName());
    assertValidationRules(type);
  }

  @Test
  @Generated("Replace Field Test Generator")
  public void testExtendedExtendedFormDataSdkCommandNoneIgnoreUse() throws Exception {
    IType type = s_extendedExtendedFormData.getType("SdkCommandNoneIgnoreUse");
    assertTrue(TypeUtility.exists(type));
    assertEquals("ExtendedFormData.SdkCommandNoneIgnore", type.getSuperclassName());
    assertValidationRules(type);
  }

  @Test
  @Generated("Replace Field Test Generator")
  public void testExtendedExtendedFormDataSdkCommandNoneIgnoreIgnore() throws Exception {
    IType type = s_extendedExtendedFormData.getType("SdkCommandNoneIgnoreIgnore");
    assertTrue(TypeUtility.exists(type));
    assertEquals("ExtendedFormData.SdkCommandNoneIgnore", type.getSuperclassName());
    assertValidationRules(type);
  }

  @Test
  @Generated("Replace Field Test Generator")
  public void testExtendedExtendedFormDataSdkCommandCreateNoneNone() throws Exception {
    IType type = s_extendedExtendedFormData.getType("SdkCommandCreateNoneNone");
    assertTrue(TypeUtility.exists(type));
    assertEquals("ExtendedFormData.SdkCommandCreateNone", type.getSuperclassName());
    assertValidationRules(type);
  }

  @Test
  @Generated("Replace Field Test Generator")
  public void testExtendedExtendedFormDataSdkCommandCreateNoneCreate() throws Exception {
    IType type = s_extendedExtendedFormData.getType("SdkCommandCreateNoneCreate");
    assertTrue(TypeUtility.exists(type));
    assertEquals("ExtendedFormData.SdkCommandCreateNone", type.getSuperclassName());
    assertValidationRules(type);
  }

  @Test
  @Generated("Replace Field Test Generator")
  public void testExtendedExtendedFormDataSdkCommandCreateNoneUse() throws Exception {
    IType type = s_extendedExtendedFormData.getType("SdkCommandCreateNoneUse");
    assertTrue(TypeUtility.exists(type));
    assertEquals("ExtendedFormData.SdkCommandCreateNone", type.getSuperclassName());
    assertValidationRules(type);
  }

  @Test
  @Generated("Replace Field Test Generator")
  public void testExtendedExtendedFormDataSdkCommandCreateNoneIgnore() throws Exception {
    IType type = s_extendedExtendedFormData.getType("SdkCommandCreateNoneIgnore");
    assertTrue(TypeUtility.exists(type));
    assertEquals("ExtendedFormData.SdkCommandCreateNone", type.getSuperclassName());
    assertValidationRules(type);
  }

  @Test
  @Generated("Replace Field Test Generator")
  public void testExtendedExtendedFormDataSdkCommandCreateCreateNone() throws Exception {
    IType type = s_extendedExtendedFormData.getType("SdkCommandCreateCreateNone");
    assertTrue(TypeUtility.exists(type));
    assertEquals("ExtendedFormData.SdkCommandCreateCreate", type.getSuperclassName());
    assertValidationRules(type);
  }

  @Test
  @Generated("Replace Field Test Generator")
  public void testExtendedExtendedFormDataSdkCommandCreateCreateCreate() throws Exception {
    IType type = s_extendedExtendedFormData.getType("SdkCommandCreateCreateCreate");
    assertTrue(TypeUtility.exists(type));
    assertEquals("ExtendedFormData.SdkCommandCreateCreate", type.getSuperclassName());
    assertValidationRules(type);
  }

  @Test
  @Generated("Replace Field Test Generator")
  public void testExtendedExtendedFormDataSdkCommandCreateCreateUse() throws Exception {
    IType type = s_extendedExtendedFormData.getType("SdkCommandCreateCreateUse");
    assertTrue(TypeUtility.exists(type));
    assertEquals("ExtendedFormData.SdkCommandCreateCreate", type.getSuperclassName());
    assertValidationRules(type);
  }

  @Test
  @Generated("Replace Field Test Generator")
  public void testExtendedExtendedFormDataSdkCommandCreateCreateIgnore() throws Exception {
    IType type = s_extendedExtendedFormData.getType("SdkCommandCreateCreateIgnore");
    assertTrue(TypeUtility.exists(type));
    assertEquals("ExtendedFormData.SdkCommandCreateCreate", type.getSuperclassName());
    assertValidationRules(type);
  }

  @Test
  @Generated("Replace Field Test Generator")
  public void testExtendedExtendedFormDataSdkCommandCreateUseNone() throws Exception {
    IType type = s_extendedExtendedFormData.getType("SdkCommandCreateUseNone");
    assertTrue(TypeUtility.exists(type));
    assertEquals("ExtendedFormData.SdkCommandCreateUse", type.getSuperclassName());
    assertValidationRules(type);
  }

  @Test
  @Generated("Replace Field Test Generator")
  public void testExtendedExtendedFormDataSdkCommandCreateUseCreate() throws Exception {
    IType type = s_extendedExtendedFormData.getType("SdkCommandCreateUseCreate");
    assertTrue(TypeUtility.exists(type));
    assertEquals("ExtendedFormData.SdkCommandCreateUse", type.getSuperclassName());
    assertValidationRules(type);
  }

  @Test
  @Generated("Replace Field Test Generator")
  public void testExtendedExtendedFormDataSdkCommandCreateUseUse() throws Exception {
    IType type = s_extendedExtendedFormData.getType("SdkCommandCreateUseUse");
    assertTrue(TypeUtility.exists(type));
    assertEquals("ExtendedFormData.SdkCommandCreateUse", type.getSuperclassName());
    assertValidationRules(type);
  }

  @Test
  @Generated("Replace Field Test Generator")
  public void testExtendedExtendedFormDataSdkCommandCreateUseIgnore() throws Exception {
    IType type = s_extendedExtendedFormData.getType("SdkCommandCreateUseIgnore");
    assertTrue(TypeUtility.exists(type));
    assertEquals("ExtendedFormData.SdkCommandCreateUse", type.getSuperclassName());
    assertValidationRules(type);
  }

  @Test
  @Generated("Replace Field Test Generator")
  public void testExtendedExtendedFormDataSdkCommandCreateIgnoreNone() throws Exception {
    IType type = s_extendedExtendedFormData.getType("SdkCommandCreateIgnoreNone");
    assertTrue(TypeUtility.exists(type));
    assertEquals("ExtendedFormData.SdkCommandCreateIgnore", type.getSuperclassName());
    assertValidationRules(type);
  }

  @Test
  @Generated("Replace Field Test Generator")
  public void testExtendedExtendedFormDataSdkCommandCreateIgnoreCreate() throws Exception {
    IType type = s_extendedExtendedFormData.getType("SdkCommandCreateIgnoreCreate");
    assertTrue(TypeUtility.exists(type));
    assertEquals("ExtendedFormData.SdkCommandCreateIgnore", type.getSuperclassName());
    assertValidationRules(type);
  }

  @Test
  @Generated("Replace Field Test Generator")
  public void testExtendedExtendedFormDataSdkCommandCreateIgnoreUse() throws Exception {
    IType type = s_extendedExtendedFormData.getType("SdkCommandCreateIgnoreUse");
    assertTrue(TypeUtility.exists(type));
    assertEquals("ExtendedFormData.SdkCommandCreateIgnore", type.getSuperclassName());
    assertValidationRules(type);
  }

  @Test
  @Generated("Replace Field Test Generator")
  public void testExtendedExtendedFormDataSdkCommandCreateIgnoreIgnore() throws Exception {
    IType type = s_extendedExtendedFormData.getType("SdkCommandCreateIgnoreIgnore");
    assertTrue(TypeUtility.exists(type));
    assertEquals("ExtendedFormData.SdkCommandCreateIgnore", type.getSuperclassName());
    assertValidationRules(type);
  }

  @Test
  @Generated("Replace Field Test Generator")
  public void testExtendedExtendedFormDataSdkCommandUseNoneNone() throws Exception {
    IType type = s_extendedExtendedFormData.getType("SdkCommandUseNoneNone");
    assertTrue(TypeUtility.exists(type));
    assertEquals("ExtendedFormData.SdkCommandUseNone", type.getSuperclassName());
    assertValidationRules(type);
  }

  @Test
  @Generated("Replace Field Test Generator")
  public void testExtendedExtendedFormDataSdkCommandUseNoneCreate() throws Exception {
    IType type = s_extendedExtendedFormData.getType("SdkCommandUseNoneCreate");
    assertTrue(TypeUtility.exists(type));
    assertEquals("ExtendedFormData.SdkCommandUseNone", type.getSuperclassName());
    assertValidationRules(type);
  }

  @Test
  @Generated("Replace Field Test Generator")
  public void testExtendedExtendedFormDataSdkCommandUseNoneUse() throws Exception {
    IType type = s_extendedExtendedFormData.getType("SdkCommandUseNoneUse");
    assertTrue(TypeUtility.exists(type));
    assertEquals("ExtendedFormData.SdkCommandUseNone", type.getSuperclassName());
    assertValidationRules(type);
  }

  @Test
  @Generated("Replace Field Test Generator")
  public void testExtendedExtendedFormDataSdkCommandUseNoneIgnore() throws Exception {
    IType type = s_extendedExtendedFormData.getType("SdkCommandUseNoneIgnore");
    assertTrue(TypeUtility.exists(type));
    assertEquals("ExtendedFormData.SdkCommandUseNone", type.getSuperclassName());
    assertValidationRules(type);
  }

  @Test
  @Generated("Replace Field Test Generator")
  public void testExtendedExtendedFormDataSdkCommandUseCreateNone() throws Exception {
    IType type = s_extendedExtendedFormData.getType("SdkCommandUseCreateNone");
    assertTrue(TypeUtility.exists(type));
    assertEquals("ExtendedFormData.SdkCommandUseCreate", type.getSuperclassName());
    assertValidationRules(type);
  }

  @Test
  @Generated("Replace Field Test Generator")
  public void testExtendedExtendedFormDataSdkCommandUseCreateCreate() throws Exception {
    IType type = s_extendedExtendedFormData.getType("SdkCommandUseCreateCreate");
    assertTrue(TypeUtility.exists(type));
    assertEquals("ExtendedFormData.SdkCommandUseCreate", type.getSuperclassName());
    assertValidationRules(type);
  }

  @Test
  @Generated("Replace Field Test Generator")
  public void testExtendedExtendedFormDataSdkCommandUseCreateUse() throws Exception {
    IType type = s_extendedExtendedFormData.getType("SdkCommandUseCreateUse");
    assertTrue(TypeUtility.exists(type));
    assertEquals("ExtendedFormData.SdkCommandUseCreate", type.getSuperclassName());
    assertValidationRules(type);
  }

  @Test
  @Generated("Replace Field Test Generator")
  public void testExtendedExtendedFormDataSdkCommandUseCreateIgnore() throws Exception {
    IType type = s_extendedExtendedFormData.getType("SdkCommandUseCreateIgnore");
    assertTrue(TypeUtility.exists(type));
    assertEquals("ExtendedFormData.SdkCommandUseCreate", type.getSuperclassName());
    assertValidationRules(type);
  }

  @Test
  @Generated("Replace Field Test Generator")
  public void testExtendedExtendedFormDataSdkCommandUseUseNone() throws Exception {
    IType type = s_extendedExtendedFormData.getType("SdkCommandUseUseNone");
    assertTrue(TypeUtility.exists(type));
    assertEquals("ExtendedFormData.SdkCommandUseUse", type.getSuperclassName());
    assertValidationRules(type);
  }

  @Test
  @Generated("Replace Field Test Generator")
  public void testExtendedExtendedFormDataSdkCommandUseUseCreate() throws Exception {
    IType type = s_extendedExtendedFormData.getType("SdkCommandUseUseCreate");
    assertTrue(TypeUtility.exists(type));
    assertEquals("ExtendedFormData.SdkCommandUseUse", type.getSuperclassName());
    assertValidationRules(type);
  }

  @Test
  @Generated("Replace Field Test Generator")
  public void testExtendedExtendedFormDataSdkCommandUseUseUse() throws Exception {
    IType type = s_extendedExtendedFormData.getType("SdkCommandUseUseUse");
    assertTrue(TypeUtility.exists(type));
    assertEquals("ExtendedFormData.SdkCommandUseUse", type.getSuperclassName());
    assertValidationRules(type);
  }

  @Test
  @Generated("Replace Field Test Generator")
  public void testExtendedExtendedFormDataSdkCommandUseUseIgnore() throws Exception {
    IType type = s_extendedExtendedFormData.getType("SdkCommandUseUseIgnore");
    assertTrue(TypeUtility.exists(type));
    assertEquals("ExtendedFormData.SdkCommandUseUse", type.getSuperclassName());
    assertValidationRules(type);
  }

  @Test
  @Generated("Replace Field Test Generator")
  public void testExtendedExtendedFormDataSdkCommandUseIgnoreNone() throws Exception {
    IType type = s_extendedExtendedFormData.getType("SdkCommandUseIgnoreNone");
    assertTrue(TypeUtility.exists(type));
    assertEquals("ExtendedFormData.SdkCommandUseIgnore", type.getSuperclassName());
    assertValidationRules(type);
  }

  @Test
  @Generated("Replace Field Test Generator")
  public void testExtendedExtendedFormDataSdkCommandUseIgnoreCreate() throws Exception {
    IType type = s_extendedExtendedFormData.getType("SdkCommandUseIgnoreCreate");
    assertTrue(TypeUtility.exists(type));
    assertEquals("ExtendedFormData.SdkCommandUseIgnore", type.getSuperclassName());
    assertValidationRules(type);
  }

  @Test
  @Generated("Replace Field Test Generator")
  public void testExtendedExtendedFormDataSdkCommandUseIgnoreUse() throws Exception {
    IType type = s_extendedExtendedFormData.getType("SdkCommandUseIgnoreUse");
    assertTrue(TypeUtility.exists(type));
    assertEquals("ExtendedFormData.SdkCommandUseIgnore", type.getSuperclassName());
    assertValidationRules(type);
  }

  @Test
  @Generated("Replace Field Test Generator")
  public void testExtendedExtendedFormDataSdkCommandUseIgnoreIgnore() throws Exception {
    IType type = s_extendedExtendedFormData.getType("SdkCommandUseIgnoreIgnore");
    assertTrue(TypeUtility.exists(type));
    assertEquals("ExtendedFormData.SdkCommandUseIgnore", type.getSuperclassName());
    assertValidationRules(type);
  }

  @Test
  @Generated("Replace Field Test Generator")
  public void testExtendedExtendedFormDataSdkCommandIgnoreNoneNone() throws Exception {
    IType type = s_extendedExtendedFormData.getType("SdkCommandIgnoreNoneNone");
    assertFalse(TypeUtility.exists(type));
  }

  @Test
  @Generated("Replace Field Test Generator")
  public void testExtendedExtendedFormDataSdkCommandIgnoreNoneCreate() throws Exception {
    IType type = s_extendedExtendedFormData.getType("SdkCommandIgnoreNoneCreate");
    assertTrue(TypeUtility.exists(type));
    assertEquals("AbstractValueFieldData<String>", type.getSuperclassName());
    assertValidationRules(type,
        "ruleMap.put(ValidationRule.MAX_LENGTH, 4000);");
  }

  @Test
  @Generated("Replace Field Test Generator")
  public void testExtendedExtendedFormDataSdkCommandIgnoreNoneUse() throws Exception {
    IType type = s_extendedExtendedFormData.getType("SdkCommandIgnoreNoneUse");
    assertTrue(TypeUtility.exists(type));
    assertEquals("UsingFormFieldData", type.getSuperclassName());
    assertValidationRules(type,
        "ruleMap.put(ValidationRule.MAX_LENGTH, 4000);");
  }

  @Test
  @Generated("Replace Field Test Generator")
  public void testExtendedExtendedFormDataSdkCommandIgnoreNoneIgnore() throws Exception {
    IType type = s_extendedExtendedFormData.getType("SdkCommandIgnoreNoneIgnore");
    assertFalse(TypeUtility.exists(type));
  }

  @Test
  @Generated("Replace Field Test Generator")
  public void testExtendedExtendedFormDataSdkCommandIgnoreCreateNone() throws Exception {
    IType type = s_extendedExtendedFormData.getType("SdkCommandIgnoreCreateNone");
    assertTrue(TypeUtility.exists(type));
    assertEquals("ExtendedFormData.SdkCommandIgnoreCreate", type.getSuperclassName());
    assertValidationRules(type);
  }

  @Test
  @Generated("Replace Field Test Generator")
  public void testExtendedExtendedFormDataSdkCommandIgnoreCreateCreate() throws Exception {
    IType type = s_extendedExtendedFormData.getType("SdkCommandIgnoreCreateCreate");
    assertTrue(TypeUtility.exists(type));
    assertEquals("ExtendedFormData.SdkCommandIgnoreCreate", type.getSuperclassName());
    assertValidationRules(type);
  }

  @Test
  @Generated("Replace Field Test Generator")
  public void testExtendedExtendedFormDataSdkCommandIgnoreCreateUse() throws Exception {
    IType type = s_extendedExtendedFormData.getType("SdkCommandIgnoreCreateUse");
    assertTrue(TypeUtility.exists(type));
    assertEquals("ExtendedFormData.SdkCommandIgnoreCreate", type.getSuperclassName());
    assertValidationRules(type);
  }

  @Test
  @Generated("Replace Field Test Generator")
  public void testExtendedExtendedFormDataSdkCommandIgnoreCreateIgnore() throws Exception {
    IType type = s_extendedExtendedFormData.getType("SdkCommandIgnoreCreateIgnore");
    assertTrue(TypeUtility.exists(type));
    assertEquals("ExtendedFormData.SdkCommandIgnoreCreate", type.getSuperclassName());
    assertValidationRules(type);
  }

  @Test
  @Generated("Replace Field Test Generator")
  public void testExtendedExtendedFormDataSdkCommandIgnoreUseNone() throws Exception {
    IType type = s_extendedExtendedFormData.getType("SdkCommandIgnoreUseNone");
    assertTrue(TypeUtility.exists(type));
    assertEquals("ExtendedFormData.SdkCommandIgnoreUse", type.getSuperclassName());
    assertValidationRules(type);
  }

  @Test
  @Generated("Replace Field Test Generator")
  public void testExtendedExtendedFormDataSdkCommandIgnoreUseCreate() throws Exception {
    IType type = s_extendedExtendedFormData.getType("SdkCommandIgnoreUseCreate");
    assertTrue(TypeUtility.exists(type));
    assertEquals("ExtendedFormData.SdkCommandIgnoreUse", type.getSuperclassName());
    assertValidationRules(type);
  }

  @Test
  @Generated("Replace Field Test Generator")
  public void testExtendedExtendedFormDataSdkCommandIgnoreUseUse() throws Exception {
    IType type = s_extendedExtendedFormData.getType("SdkCommandIgnoreUseUse");
    assertTrue(TypeUtility.exists(type));
    assertEquals("ExtendedFormData.SdkCommandIgnoreUse", type.getSuperclassName());
    assertValidationRules(type);
  }

  @Test
  @Generated("Replace Field Test Generator")
  public void testExtendedExtendedFormDataSdkCommandIgnoreUseIgnore() throws Exception {
    IType type = s_extendedExtendedFormData.getType("SdkCommandIgnoreUseIgnore");
    assertTrue(TypeUtility.exists(type));
    assertEquals("ExtendedFormData.SdkCommandIgnoreUse", type.getSuperclassName());
    assertValidationRules(type);
  }

  @Test
  @Generated("Replace Field Test Generator")
  public void testExtendedExtendedFormDataSdkCommandIgnoreIgnoreNone() throws Exception {
    IType type = s_extendedExtendedFormData.getType("SdkCommandIgnoreIgnoreNone");
    assertFalse(TypeUtility.exists(type));
  }

  @Test
  @Generated("Replace Field Test Generator")
  public void testExtendedExtendedFormDataSdkCommandIgnoreIgnoreCreate() throws Exception {
    IType type = s_extendedExtendedFormData.getType("SdkCommandIgnoreIgnoreCreate");
    assertTrue(TypeUtility.exists(type));
    assertEquals("AbstractValueFieldData<String>", type.getSuperclassName());
    assertValidationRules(type,
        "ruleMap.put(ValidationRule.MAX_LENGTH, 4000);");
  }

  @Test
  @Generated("Replace Field Test Generator")
  public void testExtendedExtendedFormDataSdkCommandIgnoreIgnoreUse() throws Exception {
    IType type = s_extendedExtendedFormData.getType("SdkCommandIgnoreIgnoreUse");
    assertTrue(TypeUtility.exists(type));
    assertEquals("UsingFormFieldData", type.getSuperclassName());
    assertValidationRules(type,
        "ruleMap.put(ValidationRule.MAX_LENGTH, 4000);");
  }

  @Test
  @Generated("Replace Field Test Generator")
  public void testExtendedExtendedFormDataSdkCommandIgnoreIgnoreIgnore() throws Exception {
    IType type = s_extendedExtendedFormData.getType("SdkCommandIgnoreIgnoreIgnore");
    assertFalse(TypeUtility.exists(type));
  }

}




import java.util.Map;

import org.eclipse.scout.commons.ConfigurationUtility;
import org.eclipse.scout.commons.annotations.Replace;
import org.eclipse.scout.commons.logger.IScoutLogger;
import org.eclipse.scout.commons.logger.ScoutLogManager;
import org.eclipse.scout.rt.shared.data.form.FormDataUtility;

  private static final IScoutLogger LOG = ScoutLogManager.getLogger(AbstractFormFieldData.class);
  private static final long serialVersionUID = 1L;

  private Map<Class<?>, Class<? extends AbstractFormFieldData>> m_fieldDataReplacements;
  private Map<Class<? extends AbstractPropertyData>, AbstractPropertyData> m_propertyMap;
  private Map<Class<? extends AbstractFormFieldData>, AbstractFormFieldData> m_fieldMap;
  private boolean m_valueSet;


  private Class<? extends AbstractFormFieldData>[] getConfiguredFieldDatas() {
    Class[] dca = ConfigurationUtility.getDeclaredPublicClasses(getClass());
    Class<AbstractFormFieldData>[] fca = ConfigurationUtility.filterClasses(dca, AbstractFormFieldData.class);
    return ConfigurationUtility.removeReplacedClasses(fca);
  }

  protected void initConfig() {

    }// end for
    if (map.size() > 0) {
      m_fieldMap = map;
      Map<Class<?>, Class<? extends AbstractFormFieldData>> replacements = ConfigurationUtility.getReplacementMapping(fieldArray);
      if (!replacements.isEmpty()) {
        m_fieldDataReplacements = replacements;
      }
    }
  }


  }

  public String getFieldId() {
    Class<?> c = getClass();
    while (c.isAnnotationPresent(Replace.class)) {
      c = c.getSuperclass();
    }
    String s = c.getName();
    int i = Math.max(s.lastIndexOf('$'), s.lastIndexOf('.'));
    s = s.substring(i + 1);
    return s;

  }

  public AbstractFormFieldData getFieldById(String id) {
    String fieldDataId = FormDataUtility.getFieldDataId(id);
    if (m_fieldMap == null) {
      return null;
    }
    String fieldDataId = FormDataUtility.getFieldDataId(id);
    for (AbstractFormFieldData f : m_fieldMap.values()) {
      if (f.getFieldId().equals(fieldDataId)) {
        return f;

    if (m_fieldMap == null) {
      return null;
    }
    Class<? extends T> clazz = getReplacingFieldDataClass(c);
    return (T) m_fieldMap.get(clazz);
  }

  public <T extends AbstractFormFieldData> void setFieldByClass(Class<T> c, T v) {
    Class<? extends T> clazz = getReplacingFieldDataClass(c);
    if (v == null) {
      if (m_fieldMap != null) {
        m_fieldMap.remove(clazz);
      }
    }
    else {
      if (m_fieldMap == null) {
        m_fieldMap = new HashMap<Class<? extends AbstractFormFieldData>, AbstractFormFieldData>();
      }
      m_fieldMap.put(clazz, v);
    }
  }

  /**
   * Checks whether the form field data with the given class has been replaced by another field. If so, the replacing
   * form field data's class is returned. Otherwise the given class itself.
   * 
   * @param c
   * @return Returns the possibly available replacing field data class for the given class.
   * @see Replace
   * @since 3.8.2
   */
  private <T> Class<? extends T> getReplacingFieldDataClass(Class<T> c) {
    if (m_fieldDataReplacements != null) {
      @SuppressWarnings("unchecked")
      Class<? extends T> replacingFieldClass = (Class<? extends T>) m_fieldDataReplacements.get(c);
      if (replacingFieldClass != null) {
        return replacingFieldClass;
      }
    }
    return c;
  }

  public AbstractFormFieldData[] getFields() {




import org.eclipse.scout.commons.ClassIdentifier;
import org.eclipse.scout.commons.CloneUtility;
import org.eclipse.scout.commons.ConfigurationUtility;
import org.eclipse.scout.commons.annotations.Replace;
import org.eclipse.scout.commons.exception.ProcessingException;
import org.eclipse.scout.commons.logger.IScoutLogger;
import org.eclipse.scout.commons.logger.ScoutLogManager;

  private static final IScoutLogger LOG = ScoutLogManager.getLogger(AbstractFormData.class);
  private static final long serialVersionUID = 1L;

  private Map<Class<?>, Class<? extends AbstractFormFieldData>> m_fieldDataReplacements;
  private Map<Class<? extends AbstractPropertyData>, AbstractPropertyData> m_propertyMap;
  private Map<Class<? extends AbstractFormFieldData>, AbstractFormFieldData> m_fieldMap;



  private Class<? extends AbstractFormFieldData>[] getConfiguredFieldDatas() {
    Class[] dca = ConfigurationUtility.getDeclaredPublicClasses(getClass());
    Class<AbstractFormFieldData>[] fca = ConfigurationUtility.filterClasses(dca, AbstractFormFieldData.class);
    return ConfigurationUtility.removeReplacedClasses(fca);
  }

  protected void initConfig() {

     // add fields
    m_fieldMap = new HashMap<Class<? extends AbstractFormFieldData>, AbstractFormFieldData>();
    Class<? extends AbstractFormFieldData>[] fieldArray = getConfiguredFieldDatas();
    Map<Class<?>, Class<? extends AbstractFormFieldData>> replacements = ConfigurationUtility.getReplacementMapping(fieldArray);
    if (!replacements.isEmpty()) {
      m_fieldDataReplacements = replacements;
    }
    for (int i = 0; i < fieldArray.length; i++) {
      AbstractFormFieldData f;
      try {


  @SuppressWarnings("unchecked")
  public <T extends AbstractFormFieldData> T getFieldByClass(Class<T> c) {
    Class<? extends T> clazz = getReplacingFieldDataClass(c);
    return (T) m_fieldMap.get(clazz);
  }

  public <T extends AbstractFormFieldData> void setFieldByClass(Class<T> c, T v) {
    Class<? extends T> clazz = getReplacingFieldDataClass(c);
    if (v == null) {
      m_fieldMap.remove(clazz);
    }
    else {
      m_fieldMap.put(clazz, v);
    }
  }

  /**
   * Checks whether the form field data with the given class has been replaced by another field. If so, the replacing
   * form field data's class is returned. Otherwise the given class itself.
   * 
   * @param c
   * @return Returns the possibly available replacing field data class for the given class.
   * @see Replace
   * @since 3.8.2
   */
  private <T extends AbstractFormFieldData> Class<? extends T> getReplacingFieldDataClass(Class<T> c) {
    if (m_fieldDataReplacements != null) {
      @SuppressWarnings("unchecked")
      Class<T> replacingFieldDataClass = (Class<T>) m_fieldDataReplacements.get(c);
      if (replacingFieldDataClass != null) {
        return replacingFieldDataClass;
      }
    }
    return c;
  }

  /**

Return to bug 399380

Line 0 Link Here

(-)src/org/eclipse/scout/commons/annotations/Replace.java (+146 lines)
		1	package org.eclipse.scout.commons.annotations;
		2
		3	import java.lang.annotation.ElementType;
		4	import java.lang.annotation.Retention;
		5	import java.lang.annotation.RetentionPolicy;
		6	import java.lang.annotation.Target;
		7
		8	import org.eclipse.scout.commons.annotations.FormData.SdkCommand;
		9
		10	/**
		11	* Annotation on a class used to replace the first occurrence of its super class. The Annotation can be applied to
		12	* several scout objects types like columns, menus, form fields. Further, the annotation can be applied recursively
		13	* (i.e. replaced objects can be replaced as well).
		14	* <p/>
		15	* <h3>Usage on form fields</h3> If this annotation is added to a form field in an extended form, it works like the
		16	* {@link InjectFieldTo} annotation except that the original field is removed. The replaced field's container is used by
		17	* the replacing field as well. If the {@link Order} annotation is missing on the replacing class, the order of the
		18	* extended class is used. Finally, the {@link FormData} annotation is inherited form the replaced field. If the
		19	* replaced field does not have a form field data, the replacing field may crate on using {@link SdkCommand#CREATE} or
		20	* {@link SdkCommand#USE}.
		21	* <p/>
		22	* <b>Example:</b> The NameExField replaces the NameField in the original BaseForm without changing its order within the
		23	* FirstGroupBox. <b>Note:</b> the weird looking super constructor call is required for initializing the extended
		24	* <em>inner class</em>.
		25	*
		26	* <pre>
		27	* public class BaseForm extends AbstractForm {
		28	* @Order(10)
		29	* public class MainBox extends AbstractGroupBox {
		30	* @Order(10)
		31	* public class FirstGroupBox extends AbstractGroupBox {
		32	* @Order(10)
		33	* public class NameField extends AbstractStringField {
		34	* }
		35	* }
		36	* }
		37	* }
		38	*
		39	* public class ExtendedForm extends BaseForm {
		40	* @Replace
		41	* public class NameExField extends NameField {
		42	* public NameExField(BaseForm.MainBox.FirstGroupBox container) {
		43	* container.super();
		44	* }
		45	* }
		46	* }
		47	* </pre>
		48	*
		49	* <h3>Usage on table columns</h3> The annotation can be used to modify or move columns within a table. By default, the
		50	* replaced column uses the same {@link Order} of the replaced column.
		51	* <p/>
		52	* <b>Example 1:</b> The FirstExColumn replaces the FirstColumn in the original Table without changing its order.
		53	*
		54	* <pre>
		55	* public class Table extends AbstractTable {
		56	* @Order(10)
		57	* public class FirstColumn extends AbstractStringColumn {
		58	* }
		59	*
		60	* @Order(20)
		61	* public class SecondColumn extends AbstractStringColumn {
		62	* }
		63	* }
		64	*
65	* public class ExtendedTable extends Table {
66	* @Replace
67	* public class FirstExColumn extends FirstColumn {
68	* }
69	* }
70	* </pre>
71	*
72	* <b>Example 2:</b> Modifying the table of a table field requires to replace the table field as well:
73	*
74	* <pre>
75	* public class BaseForm extends AbstractForm {
76	* @Order(10)
77	* public class MainBox extends AbstractGroupBox {
78	* @Order(10)
79	* public class FirstGroupBox extends AbstractGroupBox {
80	* @Order(10)
81	* public class TableField extends AbstractTableField {
82	* public class Table extends AbstractTable {
83	* @Order(10)
84	* public class FirstColumn extends AbstractStringColumn {
85	* }
86	* }
87	* }
88	* }
89	* }
90	* }
91	*
92	* public class ExtendedForm extends BaseForm {
93	* @Replace
94	* public class TableExField extends NameField {
95	* public TableExField(BaseForm.MainBox.FirstGroupBox container) {
96	* container.super();
97	* }
98	*
99	* public class TableEx extends Table {
100	* @Replace
101	* public class FirstExColumn extends FirstColumn {
102	* }
103	* }
104	* }
105	* }
106	* </pre>
107	*
108	* <h3>Usage on action containers</h3> The annotation can be used to change the behavior of an action. Menus, key
109	* strokes, tool buttons and view buttons are actions as well.
110	* <p/>
111	* <b>Example:</b> Modify the behavior of a menu defined on a smart field:
112	*
113	* <pre>
114	* public class BaseForm extends AbstractForm {
115	* @Order(10)
116	* public class MainBox extends AbstractGroupBox {
117	* @Order(10)
118	* public class MySmartField extends AbstractSmartField<Long> {
119	* @Order(10)
120	* public class MyMenu extends AbstractMenu {
121	* }
122	* }
123	* }
124	* }
125	*
126	* public class ExtendedForm extends BaseForm {
127	* @Replace
128	* public class MyExSmartField extends MySmartField {
129	* public MyExSmartField(BaseForm.MainBox container) {
130	* container.super();
131	* }
132	*
133	* @Replace
134	* public class MyExMenu extends MyMenu {
135	* }
136	* }
137	* }
138	* </pre>
139	*
140	* @since 3.8.2
141	*/
142	@Retention(RetentionPolicy.RUNTIME)
143	@Target(ElementType.TYPE)
144	public @interface Replace {
145
146	}

Lines 47-52 Link Here

(-)src/org/eclipse/scout/sdk/workspace/type/ScoutTypeUtility.java (-14 / +104 lines)
47	import org.eclipse.scout.sdk.icon.IIconProvider;	47	import org.eclipse.scout.sdk.icon.IIconProvider;
48	import org.eclipse.scout.sdk.internal.ScoutSdk;	48	import org.eclipse.scout.sdk.internal.ScoutSdk;
49	import org.eclipse.scout.sdk.operation.form.formdata.FormDataAnnotation;	49	import org.eclipse.scout.sdk.operation.form.formdata.FormDataAnnotation;
		50	import org.eclipse.scout.sdk.operation.form.formdata.FormDataUtility;
50	import org.eclipse.scout.sdk.util.Regex;	51	import org.eclipse.scout.sdk.util.Regex;
51	import org.eclipse.scout.sdk.util.ScoutMethodUtility;	52	import org.eclipse.scout.sdk.util.ScoutMethodUtility;
52	import org.eclipse.scout.sdk.util.ScoutUtility;	53	import org.eclipse.scout.sdk.util.ScoutUtility;
Lines 182-187 Link Here
182	return null;	183	return null;
183	}	184	}
184		185
		186	/**
		187	* @return Returns <code>true</code> if the given type exists and if it is annotated with an
		188	* {@link RuntimeClasses#Replace} annotation.
		189	* @since 3.8.2
		190	*/
		191	public static boolean isReplaceAnnotationPresent(IType type) {
		192	IAnnotation annotation = JdtUtility.getAnnotation(type, RuntimeClasses.Replace);
		193	return TypeUtility.exists(annotation);
		194	}
		195
		196	/**
		197	* @return Returns the form field data for the given form field or <code>null</code> if it does not have one.
		198	* @since 3.8.2
		199	*/
		200	public static IType getFormDataType(IType formField, ITypeHierarchy hierarchy) throws JavaModelException {
		201	IType primaryType = getFormFieldDataPrimaryTypeRec(formField, hierarchy);
		202	if (!TypeUtility.exists(primaryType)) {
		203	return null;
		204	}
		205	IType formDataType = primaryType.getType(FormDataUtility.getBeanName(FormDataUtility.getFieldNameWithoutSuffix(formField.getElementName()), true));
		206	if (TypeUtility.exists(formDataType)) {
		207	return formDataType;
		208	}
		209	return null;
		210	}
		211
		212	/**
		213	* @return Returns the form field data for the given form field or <code>null</code> if it does not have one. The
		214	* method walks recursively through the list of declaring classes until it has reached a primary type.
		215	* @since 3.8.2
		216	*/
		217	private static IType getFormFieldDataPrimaryTypeRec(IType recursiveDeclaringType, ITypeHierarchy hierarchy) throws JavaModelException {
		218	if (!TypeUtility.exists(recursiveDeclaringType)) {
		219	return null;
		220	}
		221	FormDataAnnotation formDataAnnotation = findFormDataAnnotation(recursiveDeclaringType, hierarchy);
		222	if (formDataAnnotation == null) {
		223	return null;
		224	}
		225	if (FormDataAnnotation.isIgnore(formDataAnnotation)) {
		226	return null;
		227	}
		228
		229	IType declaringType = recursiveDeclaringType.getDeclaringType();
		230	if (declaringType == null) {
		231	// primary type
		232	if (FormDataAnnotation.isSdkCommandCreate(formDataAnnotation) \|\| FormDataAnnotation.isSdkCommandUse(formDataAnnotation)) {
		233	return getTypeBySignature(formDataAnnotation.getFormDataTypeSignature());
		234	}
		235	return null;
		236	}
		237
		238	return getFormFieldDataPrimaryTypeRec(declaringType, hierarchy);
		239	}
		240
185	public static FormDataAnnotation findFormDataAnnotation(IType type, ITypeHierarchy hierarchy) throws JavaModelException {	241	public static FormDataAnnotation findFormDataAnnotation(IType type, ITypeHierarchy hierarchy) throws JavaModelException {
186	return findFormDataAnnnotationImpl(type, hierarchy);	242	return findFormDataAnnnotationImpl(type, hierarchy);
187	}	243	}
Lines 212-219 Link Here
212		268
213	private static void parseFormDataAnnotationReq(FormDataAnnotation annotation, IType type, ITypeHierarchy hierarchy, boolean isOwner) {	269	private static void parseFormDataAnnotationReq(FormDataAnnotation annotation, IType type, ITypeHierarchy hierarchy, boolean isOwner) {
214	if (TypeUtility.exists(type)) {	270	if (TypeUtility.exists(type)) {
		271	boolean replaceAnnotationPresent = isReplaceAnnotationPresent(type);
215	IType superType = hierarchy.getSuperclass(type);	272	IType superType = hierarchy.getSuperclass(type);
216	parseFormDataAnnotationReq(annotation, superType, hierarchy, false);	273	parseFormDataAnnotationReq(annotation, superType, hierarchy, replaceAnnotationPresent);
		274
		275	if (replaceAnnotationPresent) {
		276	if (!isReplaceAnnotationPresent(superType)) {
		277	// super type is the original field that is going to be replaced by the given type
		278	// check whether the super type is embedded into a form field that is annotated by @FormData with SdkCommand.IGNORE.
		279	try {
		280	IType declaringType = superType.getDeclaringType();
		281	while (TypeUtility.exists(declaringType)) {
		282	FormDataAnnotation declaringTypeformDataAnnotation = findFormDataAnnotation(declaringType, hierarchy);
		283	if (FormDataAnnotation.isIgnore(declaringTypeformDataAnnotation)) {
		284	// super type is embedded into a ignored form field. Hence this field is ignored as well. Adjust parsed annotation.
		285	annotation.setSdkCommand(SdkCommand.IGNORE);
		286	break;
		287	}
		288	declaringType = declaringType.getDeclaringType();
		289	}
		290	}
		291	catch (JavaModelException e) {
		292	ScoutSdk.logWarning("could not determine enclosing class's @FormData annotation", e);
		293	}
		294	}
		295
		296	if (!FormDataAnnotation.isIgnore(annotation)) {
		297	// a form field data must always be created for a replacing fields if its parent has one and it must extend the parent field's field data class
		298	return;
		299	}
		300	}
		301
217	try {	302	try {
218	fillFormDataAnnotation(type, annotation, isOwner);	303	fillFormDataAnnotation(type, annotation, isOwner);
219	}	304	}
Lines 704-722 Link Here
704	}	789	}
705		790
706	/**	791	/**
		792	* @see #getValidationRuleMethods(IType, ITypeHierarchy)
		793	*/
		794	public static List<ValidationRuleMethod> getValidationRuleMethods(IType declaringType) throws JavaModelException {
		795	return getValidationRuleMethods(declaringType, null);
		796	}
		797
		798	/**
707	* @return a map with all validation rule names mapped to the method on the most specific declaring type	799	* @return a map with all validation rule names mapped to the method on the most specific declaring type
708	* @throws JavaModelException	800	* @throws JavaModelException
709	*/	801	*/
710	public static List<ValidationRuleMethod> getValidationRuleMethods(IType declaringType) throws JavaModelException {	802	public static List<ValidationRuleMethod> getValidationRuleMethods(IType declaringType, org.eclipse.jdt.core.ITypeHierarchy superTypeHierarchy) throws JavaModelException {
711	TreeMap<String, ValidationRuleMethod> ruleMap = new TreeMap<String, ValidationRuleMethod>();	803	TreeMap<String, ValidationRuleMethod> ruleMap = new TreeMap<String, ValidationRuleMethod>();
712	org.eclipse.jdt.core.ITypeHierarchy superTypeHierarchy = null;	804	if (superTypeHierarchy == null) {
713	try {	805	try {
714	superTypeHierarchy = declaringType.newSupertypeHierarchy(null);	806	superTypeHierarchy = declaringType.newSupertypeHierarchy(null);
715	}	807	}
716	catch (JavaModelException e) {	808	catch (JavaModelException e) {
717	ScoutSdk.logWarning("could not build super type hierarchy for '" + declaringType.getFullyQualifiedName() + "'", e);	809	ScoutSdk.logWarning("could not build super type hierarchy for '" + declaringType.getFullyQualifiedName() + "'", e);
718	return Collections.emptyList();	810	return Collections.emptyList();
		811	}
719	}	812	}
		813
720	ArrayList<IType> targetTypeList = new ArrayList<IType>(5);	814	ArrayList<IType> targetTypeList = new ArrayList<IType>(5);
721	targetTypeList.add(0, declaringType);	815	targetTypeList.add(0, declaringType);
722	IType[] superClasses = superTypeHierarchy.getAllSuperclasses(declaringType);	816	IType[] superClasses = superTypeHierarchy.getAllSuperclasses(declaringType);
Lines 807-816 Link Here
807	continue;	901	continue;
808	}	902	}
809	//found new rule annotation, now find most specific method in subclasses to generate source code	903	//found new rule annotation, now find most specific method in subclasses to generate source code
810	if (ruleSkip.booleanValue()) {
811	ruleMap.put(hashKey, null);
812	continue;
813	}
814	if (ruleGeneratedSourceCode != null && ruleGeneratedSourceCode.length() == 0) {	904	if (ruleGeneratedSourceCode != null && ruleGeneratedSourceCode.length() == 0) {
815	ruleGeneratedSourceCode = null;	905	ruleGeneratedSourceCode = null;
816	}	906	}
Lines 840-846 Link Here
840	implementedMethod = annotatedMethod;	930	implementedMethod = annotatedMethod;
841	}	931	}
842	//new rule is sufficiently parsed	932	//new rule is sufficiently parsed
843	ValidationRuleMethod vm = new ValidationRuleMethod(validationRuleAnnotation, ruleField, ruleString, ruleGeneratedSourceCode, annotatedMethod, implementedMethod, superTypeHierarchy);	933	ValidationRuleMethod vm = new ValidationRuleMethod(validationRuleAnnotation, ruleField, ruleString, ruleGeneratedSourceCode, annotatedMethod, implementedMethod, superTypeHierarchy, ruleSkip);
844	ruleMap.put(hashKey, vm);	934	ruleMap.put(hashKey, vm);
845	}	935	}
846	}	936	}

Lines 26-33 Link Here

(-)src/org/eclipse/scout/sdk/workspace/type/validationrule/ValidationRuleMethod.java (-1 / +9 lines)
26	private final IMethod m_annotatedMethod;	26	private final IMethod m_annotatedMethod;
27	private final IMethod m_implementedMethod;	27	private final IMethod m_implementedMethod;
28	private final ITypeHierarchy m_superTypeHierarchy;	28	private final ITypeHierarchy m_superTypeHierarchy;
		29	private final boolean m_skipRule;
29		30
30	public ValidationRuleMethod(IAnnotation annotation, IField ruleField, String ruleName, String ruleGeneratedSourceCode, IMethod annotatedMethod, IMethod implementedMethod, ITypeHierarchy superTypeHierarchy) {	31	public ValidationRuleMethod(IAnnotation annotation, IField ruleField, String ruleName, String ruleGeneratedSourceCode, IMethod annotatedMethod, IMethod implementedMethod, ITypeHierarchy superTypeHierarchy, boolean skipRule) {
31	m_annotation = annotation;	32	m_annotation = annotation;
32	m_ruleField = ruleField;	33	m_ruleField = ruleField;
33	m_ruleName = ruleName;	34	m_ruleName = ruleName;
Lines 35-40 Link Here
35	m_annotatedMethod = annotatedMethod;	36	m_annotatedMethod = annotatedMethod;
36	m_implementedMethod = implementedMethod;	37	m_implementedMethod = implementedMethod;
37	m_superTypeHierarchy = superTypeHierarchy;	38	m_superTypeHierarchy = superTypeHierarchy;
		39	m_skipRule = skipRule;
38	}	40	}
39		41
40	/**	42	/**
Lines 86-89 Link Here
86	return m_superTypeHierarchy;	88	return m_superTypeHierarchy;
87	}	89	}
88		90
		91	/**
		92	* @return Returns <code>true</code> if this rule should be skipped.
		93	*/
		94	public boolean isSkipRule() {
		95	return m_skipRule;
		96	}
89	}	97	}

Lines 143-152 Link Here

(-)src/org/eclipse/scout/sdk/operation/form/formdata/SourceBuilderWithProperties.java (-7 / +46 lines)
143	protected void addValidationRules(IType type) {	143	protected void addValidationRules(IType type) {
144	// validation rules	144	// validation rules
145	try {	145	try {
146	List<ValidationRuleMethod> list = ScoutTypeUtility.getValidationRuleMethods(type);	146	boolean replaceAnnotationPresent = ScoutTypeUtility.isReplaceAnnotationPresent(type);
		147
		148	ITypeHierarchy hierarchy = TypeUtility.getSuperTypeHierarchy(type);
		149	if (hierarchy == null) {
		150	return;
		151	}
		152
		153	// If the replace annotation is available, we have to check whether the replaced field
		154	// is not associated to a form field data
		155	boolean superTypeHasNoFormFieldData = false;
		156	if (replaceAnnotationPresent) {
		157	IType superType = hierarchy.getSuperclass(type);
		158	superTypeHasNoFormFieldData = ScoutTypeUtility.getFormDataType(superType, hierarchy) == null;
		159	}
		160
		161	List<ValidationRuleMethod> list = ScoutTypeUtility.getValidationRuleMethods(type, hierarchy.getJdtHierarchy());
147	if (list.size() > 0) {	162	if (list.size() > 0) {
148	for (Iterator<ValidationRuleMethod> it = list.iterator(); it.hasNext();) {	163	for (Iterator<ValidationRuleMethod> it = list.iterator(); it.hasNext();) {
149	ValidationRuleMethod vm = it.next();	164	ValidationRuleMethod vm = it.next();
		165	if (replaceAnnotationPresent) {
		166	if (superTypeHasNoFormFieldData && vm.isSkipRule()) {
		167	it.remove();
		168	continue;
		169	}
		170	else if (!superTypeHasNoFormFieldData && !type.equals(vm.getImplementedMethod().getDeclaringType())) {
		171	// remove all validation rules that are not overridden by the replacement class
		172	it.remove();
		173	continue;
		174	}
		175	}
		176	else if (vm.isSkipRule()) {
		177	// class does not replace its super class. Hence remove all skipped validation rules
		178	it.remove();
		179	continue;
		180	}
		181
150	String generatedSourceCode = vm.getRuleGeneratedSourceCode();	182	String generatedSourceCode = vm.getRuleGeneratedSourceCode();
151	if (generatedSourceCode != null) {	183	if (generatedSourceCode != null) {
152	if (generatedSourceCode.equals("null")) {	184	if (generatedSourceCode.equals("null")) {
Lines 198-204 Link Here
198	String generatedSourceCode = vm.getRuleGeneratedSourceCode();	230	String generatedSourceCode = vm.getRuleGeneratedSourceCode();
199	//filter	231	//filter
200	generatedSourceCode = filterGeneratedSourceCode(vm.getImplementedMethod(), generatedSourceCode, validator);	232	generatedSourceCode = filterGeneratedSourceCode(vm.getImplementedMethod(), generatedSourceCode, validator);
201	if (generatedSourceCode == null \|\| containsBrackets(generatedSourceCode)) {	233	if (!vm.isSkipRule() && (generatedSourceCode == null \|\| containsBrackets(generatedSourceCode))) {
202	//add javadoc warning	234	//add javadoc warning
203	String fqn = vm.getImplementedMethod().getDeclaringType().getFullyQualifiedName('.') + " # " + vm.getImplementedMethod().getElementName();	235	String fqn = vm.getImplementedMethod().getDeclaringType().getFullyQualifiedName('.') + " # " + vm.getImplementedMethod().getElementName();
204	buf.append("/**");	236	buf.append("/**");
Lines 224-234 Link Here
224	}	256	}
225	//	257	//
226	buf.append(NL);	258	buf.append(NL);
227	buf.append("ruleMap.put(");	259	if (vm.isSkipRule()) {
228	buf.append(ruleDecl);	260	buf.append("ruleMap.remove(");
229	buf.append(", ");	261	buf.append(ruleDecl);
230	buf.append(generatedSourceCode);	262	buf.append(");");
231	buf.append(");");	263	}
		264	else {
		265	buf.append("ruleMap.put(");
		266	buf.append(ruleDecl);
		267	buf.append(", ");
		268	buf.append(generatedSourceCode);
		269	buf.append(");");
		270	}
232	}	271	}
233	catch (Exception e) {	272	catch (Exception e) {
234	String fqn = vm.getImplementedMethod().getDeclaringType().getFullyQualifiedName() + "#" + vm.getImplementedMethod().getElementName();	273	String fqn = vm.getImplementedMethod().getDeclaringType().getFullyQualifiedName() + "#" + vm.getImplementedMethod().getElementName();

Lines 66-85 Link Here

(-)src/org/eclipse/scout/sdk/operation/form/formdata/CompositePrimaryTypeSourceBuilder.java (-8 / +27 lines)
66	if (formDataAnnotation != null) {	66	if (formDataAnnotation != null) {
67	if (FormDataAnnotation.isCreate(formDataAnnotation)) {	67	if (FormDataAnnotation.isCreate(formDataAnnotation)) {
68	String formDataElementName = FormDataUtility.getBeanName(FormDataUtility.getFieldNameWithoutSuffix(formField.getElementName()), true);	68	String formDataElementName = FormDataUtility.getBeanName(FormDataUtility.getFieldNameWithoutSuffix(formField.getElementName()), true);
69	String superTypeSignature = formDataAnnotation.getSuperTypeSignature();	69	String superTypeSignature = null;
70	if (formDataAnnotation.getGenericOrdinal() >= 0) {	70	IType superType = null;
71	IType superType = TypeUtility.getTypeBySignature(superTypeSignature);	71
72	if (TypeUtility.isGenericType(superType)) {	72	boolean replaceAnnotationPresent = ScoutTypeUtility.isReplaceAnnotationPresent(formField);
73	String genericTypeSig = org.eclipse.scout.sdk.operation.form.formdata.FormDataUtility.computeFormFieldGenericType(formField, formFieldHierarchy);	73	if (replaceAnnotationPresent) {
74	if (genericTypeSig != null) {	74	IType replacedType = formFieldHierarchy.getSuperclass(formField);
75	superTypeSignature = superTypeSignature.replaceAll("\\;$", "<" + genericTypeSig + ">;");	75	IType replacedFormFieldDataType = ScoutTypeUtility.getFormDataType(replacedType, formFieldHierarchy);
		76	if (replacedFormFieldDataType != null) {
		77	superTypeSignature = Signature.createTypeSignature(replacedFormFieldDataType.getTypeQualifiedName(), false);
		78	superType = replacedFormFieldDataType;
		79	}
		80	}
		81
		82	if (superTypeSignature == null) {
		83	superTypeSignature = formDataAnnotation.getSuperTypeSignature();
		84	superType = TypeUtility.getTypeBySignature(superTypeSignature);
		85	if (formDataAnnotation.getGenericOrdinal() >= 0) {
		86	if (TypeUtility.isGenericType(superType)) {
		87	String genericTypeSig = org.eclipse.scout.sdk.operation.form.formdata.FormDataUtility.computeFormFieldGenericType(formField, formFieldHierarchy);
		88	if (genericTypeSig != null) {
		89	superTypeSignature = superTypeSignature.replaceAll("\\;$", "<" + genericTypeSig + ">;");
		90	}
76	}	91	}
77	}	92	}
78	}	93	}
79	ITypeSourceBuilder builder = FormDataUtility.getInnerTypeFormDataSourceBuilder(superTypeSignature, formField, formFieldHierarchy);	94
		95	ITypeSourceBuilder builder = FormDataUtility.getInnerTypeFormDataSourceBuilder(superType, superTypeSignature, formField, formFieldHierarchy);
80	builder.setElementName(formDataElementName);	96	builder.setElementName(formDataElementName);
81	builder.setSuperTypeSignature(superTypeSignature);	97	builder.setSuperTypeSignature(superTypeSignature);
82	builder.setFlags(Flags.AccPublic \| Flags.AccStatic);	98	builder.setFlags(Flags.AccPublic \| Flags.AccStatic);
		99	if (replaceAnnotationPresent) {
		100	builder.addAnnotation(new AnnotationSourceBuilder(Signature.createTypeSignature(RuntimeClasses.Replace, true)));
		101	}
83	addBuilder(builder, CATEGORY_TYPE_FIELD);	102	addBuilder(builder, CATEGORY_TYPE_FIELD);
84	MethodSourceBuilder getterBuilder = new MethodSourceBuilder(NL);	103	MethodSourceBuilder getterBuilder = new MethodSourceBuilder(NL);
85	getterBuilder.setElementName("get" + formDataElementName);	104	getterBuilder.setElementName("get" + formDataElementName);

Lines 94-105 Link Here

(-)src/org/eclipse/scout/rt/client/ui/basic/calendar/AbstractCalendar.java (-3 / +6 lines)
94		94
95	private Class<? extends ICalendarItemProvider>[] getConfiguredProducers() {	95	private Class<? extends ICalendarItemProvider>[] getConfiguredProducers() {
96	Class[] dca = ConfigurationUtility.getDeclaredPublicClasses(getClass());	96	Class[] dca = ConfigurationUtility.getDeclaredPublicClasses(getClass());
97	return ConfigurationUtility.sortFilteredClassesByOrderAnnotation(dca, ICalendarItemProvider.class);	97	Class<ICalendarItemProvider>[] foca = ConfigurationUtility.sortFilteredClassesByOrderAnnotation(dca, ICalendarItemProvider.class);
		98	return ConfigurationUtility.removeReplacedClasses(foca);
98	}	99	}
99		100
100	private Class<? extends IMenu>[] getConfiguredMenus() {	101	private Class<? extends IMenu>[] getConfiguredMenus() {
101	Class[] dca = ConfigurationUtility.getDeclaredPublicClasses(getClass());	102	Class[] dca = ConfigurationUtility.getDeclaredPublicClasses(getClass());
102	return ConfigurationUtility.sortFilteredClassesByOrderAnnotation(dca, IMenu.class);	103	Class<IMenu>[] foca = ConfigurationUtility.sortFilteredClassesByOrderAnnotation(dca, IMenu.class);
		104	return ConfigurationUtility.removeReplacedClasses(foca);
103	}	105	}
104		106
105	@ConfigOperation	107	@ConfigOperation
Lines 452-458 Link Here
452	}	454	}
453		455
454	/**	456	/**
455	* do not use this internal method unless you are implementing a container that holds and controls an {@link ICalendar}	457	* do not use this internal method unless you are implementing a container that holds and controls an
		458	* {@link ICalendar}
456	*/	459	*/
457	public void setContainerInternal(Object container) {	460	public void setContainerInternal(Object container) {
458	propertySupport.setProperty(PROP_CONTAINER, container);	461	propertySupport.setProperty(PROP_CONTAINER, container);

Lines 235-246 Link Here

(-)src/org/eclipse/scout/rt/client/ui/basic/tree/AbstractTree.java (-2 / +5 lines)
235		235
236	private Class<? extends IKeyStroke>[] getConfiguredKeyStrokes() {	236	private Class<? extends IKeyStroke>[] getConfiguredKeyStrokes() {
237	Class<?>[] dca = ConfigurationUtility.getDeclaredPublicClasses(getClass());	237	Class<?>[] dca = ConfigurationUtility.getDeclaredPublicClasses(getClass());
238	return ConfigurationUtility.filterClasses(dca, IKeyStroke.class);	238	Class<IKeyStroke>[] fca = ConfigurationUtility.filterClasses(dca, IKeyStroke.class);
		239	return ConfigurationUtility.removeReplacedClasses(fca);
239	}	240	}
240		241
241	private Class<? extends IMenu>[] getConfiguredMenus() {	242	private Class<? extends IMenu>[] getConfiguredMenus() {
242	Class<?>[] dca = ConfigurationUtility.getDeclaredPublicClasses(getClass());	243	Class<?>[] dca = ConfigurationUtility.getDeclaredPublicClasses(getClass());
243	return ConfigurationUtility.sortFilteredClassesByOrderAnnotation(dca, IMenu.class);	244	Class<IMenu>[] foca = ConfigurationUtility.sortFilteredClassesByOrderAnnotation(dca, IMenu.class);
		245	return ConfigurationUtility.removeReplacedClasses(foca);
244	}	246	}
245		247
246	@ConfigOperation	248	@ConfigOperation
Lines 491-496 Link Here
491		493
492	@Override	494	@Override
493	public <T extends IMenu> T getMenu(Class<T> menuType) throws ProcessingException {	495	public <T extends IMenu> T getMenu(Class<T> menuType) throws ProcessingException {
		496	// ActionFinder performs instance-of checks. Hence the menu replacement mapping is not required
494	return new ActionFinder().findAction(getMenus(), menuType);	497	return new ActionFinder().findAction(getMenus(), menuType);
495	}	498	}
496		499

Lines 1-77 Link Here

(-)src/org/eclipse/scout/rt/client/ui/form/DefaultFormFieldInjection.java (-77 lines)
1	/*******************************************************************************
2	* Copyright (c) 2010 BSI Business Systems Integration AG.
3	* All rights reserved. This program and the accompanying materials
4	* are made available under the terms of the Eclipse Public License v1.0
5	* which accompanies this distribution, and is available at
6	* http://www.eclipse.org/legal/epl-v10.html
7	*
8	* Contributors:
9	* BSI Business Systems Integration AG - initial API and implementation
10	******************************************************************************/
11	package org.eclipse.scout.rt.client.ui.form;
12
13	import java.util.ArrayList;
14	import java.util.List;
15
16	import org.eclipse.scout.commons.annotations.InjectFieldTo;
17	import org.eclipse.scout.commons.annotations.Order;
18	import org.eclipse.scout.rt.client.ui.form.fields.IFormField;
19
20	/**
21	* Default implementation that inserts the fields at the right place based on their {@link Order} annotation.
22	*
23	* @since 3.8.1
24	*/
25	public class DefaultFormFieldInjection implements IFormFieldInjection {
26	private final ArrayList<IFormField> m_list = new ArrayList<IFormField>();
27
28	public void addField(IFormField f) {
29	m_list.add(f);
30	}
31
32	@Override
33	public void injectFields(IFormField container, List<IFormField> fieldList) {
34	if (container == null \|\| fieldList == null \|\| m_list.isEmpty()) {
35	return;
36	}
37	Class<?> containerClazz = container.getClass();
38	for (IFormField f : m_list) {
39	InjectFieldTo ann = f.getClass().getAnnotation(InjectFieldTo.class);
40	if (ann == null) {
41	continue;
42	}
43	if (ann.value() != containerClazz) {
44	continue;
45	}
46	insertField(fieldList, f);
47	}
48	}
49
50	/**
51	* add the field f to the list at the right place regarding the {@link Order} annotation
52	*/
53	protected void insertField(List<IFormField> list, IFormField f) {
54	//check if list already contains f
55	if (list.contains(f)) {
56	return;
57	}
58	Class<?> c = f.getClass();
59	if (!c.isAnnotationPresent(Order.class)) {
60	list.add(f);
61	return;
62	}
63	double newOrder = c.getAnnotation(Order.class).value();
64	for (int i = 0, n = list.size(); i < n; i++) {
65	Class<?> existingClazz = list.get(i).getClass();
66	if (existingClazz.isAnnotationPresent(Order.class)) {
67	double existingOrder = existingClazz.getAnnotation(Order.class).value();
68	if (newOrder < existingOrder) {
69	list.add(i, f);
70	return;
71	}
72	}
73	}
74	//default at end
75	list.add(f);
76	}
77	}

Lines 14-24 Link Here

(-)src/org/eclipse/scout/rt/client/ui/form/fields/AbstractCompositeField.java (-19 / +58 lines)
14	import java.beans.PropertyChangeListener;	14	import java.beans.PropertyChangeListener;
15	import java.util.ArrayList;	15	import java.util.ArrayList;
16	import java.util.List;	16	import java.util.List;
		17	import java.util.Map;
17		18
18	import org.eclipse.scout.commons.ConfigurationUtility;	19	import org.eclipse.scout.commons.ConfigurationUtility;
19	import org.eclipse.scout.commons.annotations.InjectFieldTo;	20	import org.eclipse.scout.commons.annotations.InjectFieldTo;
		21	import org.eclipse.scout.commons.annotations.Replace;
20	import org.eclipse.scout.commons.exception.ProcessingException;	22	import org.eclipse.scout.commons.exception.ProcessingException;
21	import org.eclipse.scout.commons.holders.Holder;	23	import org.eclipse.scout.commons.holders.Holder;
		24	import org.eclipse.scout.rt.client.ui.form.AbstractForm;
22	import org.eclipse.scout.rt.client.ui.form.DefaultFormFieldInjection;	25	import org.eclipse.scout.rt.client.ui.form.DefaultFormFieldInjection;
23	import org.eclipse.scout.rt.client.ui.form.FormFieldInjectionThreadLocal;	26	import org.eclipse.scout.rt.client.ui.form.FormFieldInjectionThreadLocal;
24	import org.eclipse.scout.rt.client.ui.form.IForm;	27	import org.eclipse.scout.rt.client.ui.form.IForm;
Lines 31-36 Link Here
31	public abstract class AbstractCompositeField extends AbstractFormField implements ICompositeField {	34	public abstract class AbstractCompositeField extends AbstractFormField implements ICompositeField {
32		35
33	private IFormField[] m_fields;	36	private IFormField[] m_fields;
		37	private Map<Class<?>, Class<? extends IFormField>> m_formFieldReplacements;
34		38
35	public AbstractCompositeField() {	39	public AbstractCompositeField() {
36	this(true);	40	this(true);
Lines 66-86 Link Here
66	Class<? extends IFormField>[] fieldArray = getConfiguredFields();	70	Class<? extends IFormField>[] fieldArray = getConfiguredFields();
67	// prepare injected fields	71	// prepare injected fields
68	DefaultFormFieldInjection injectedFields = null;	72	DefaultFormFieldInjection injectedFields = null;
		73	List<Class<? extends IFormField>> configuredFields = new ArrayList<Class<? extends IFormField>>();
69	for (Class<? extends IFormField> clazz : fieldArray) {	74	for (Class<? extends IFormField> clazz : fieldArray) {
70	if (!clazz.isAnnotationPresent(InjectFieldTo.class)) {	75	if (ConfigurationUtility.isInjectFieldAnnotationPresent(clazz)) {
71	continue;	76	if (injectedFields == null) {
72	}	77	injectedFields = new DefaultFormFieldInjection(this);
73	try {
74	IFormField f = ConfigurationUtility.newInnerInstance(this, clazz);
75	if (f != null) {
76	if (injectedFields == null) {
77	injectedFields = new DefaultFormFieldInjection();
78	}
79	injectedFields.addField(f);
80	}	78	}
81	}// end try	79	injectedFields.addField(clazz);
82	catch (Throwable t) {	80	}
83	SERVICES.getService(IExceptionHandlerService.class).handleException(new ProcessingException("field: " + clazz.getName(), t));	81	else {
		82	configuredFields.add(clazz);
84	}	83	}
85	}	84	}
86	ArrayList<IFormField> fieldList = new ArrayList<IFormField>();	85	ArrayList<IFormField> fieldList = new ArrayList<IFormField>();
Lines 89-98 Link Here
89	FormFieldInjectionThreadLocal.push(injectedFields);	88	FormFieldInjectionThreadLocal.push(injectedFields);
90	}	89	}
91	//	90	//
92	for (Class<? extends IFormField> clazz : fieldArray) {	91	filterFieldsInternal(configuredFields);
93	if (clazz.isAnnotationPresent(InjectFieldTo.class)) {	92	for (Class<? extends IFormField> clazz : configuredFields) {
94	continue;
95	}
96	try {	93	try {
97	IFormField f = ConfigurationUtility.newInnerInstance(this, clazz);	94	IFormField f = ConfigurationUtility.newInnerInstance(this, clazz);
98	fieldList.add(f);	95	fieldList.add(f);
Lines 105-110 Link Here
105	}	102	}
106	finally {	103	finally {
107	if (injectedFields != null) {	104	if (injectedFields != null) {
		105	m_formFieldReplacements = injectedFields.getReplacementMapping();
108	FormFieldInjectionThreadLocal.pop(injectedFields);	106	FormFieldInjectionThreadLocal.pop(injectedFields);
109	}	107	}
110	}	108	}
Lines 120-125 Link Here
120	}	118	}
121		119
122	/**	120	/**
		121	* Filter list of configured fields before they are instantiated.
		122	* <p/>
		123	* The default implementation removes fields replaced by another field annotated with {@link Replace}.
		124	*
		125	* @param fieldList
		126	* live and mutable list of configured field classes (i.e. yet not instantiated)
		127	* @since 3.8.2
		128	*/
		129	protected void filterFieldsInternal(List<Class<? extends IFormField>> fieldList) {
		130	FormFieldInjectionThreadLocal.filterFields(this, fieldList);
		131	}
		132
		133	/**
123	* Override this internal method only in order to make use of dynamic fields<br>	134	* Override this internal method only in order to make use of dynamic fields<br>
124	* Used to manage field list and add/remove fields (see {@link AbstractGroupBox} with wizard buttons)	135	* Used to manage field list and add/remove fields (see {@link AbstractGroupBox} with wizard buttons)
125	* <p>	136	* <p>
Lines 136-141 Link Here
136	@Override	147	@Override
137	public void setFormInternal(IForm form) {	148	public void setFormInternal(IForm form) {
138	super.setFormInternal(form);	149	super.setFormInternal(form);
		150	if (form instanceof AbstractForm) {
		151	((AbstractForm) form).registerFormFieldReplacementsInternal(m_formFieldReplacements);
		152	}
139	IFormField[] a = m_fields;	153	IFormField[] a = m_fields;
140	for (int i = 0; i < a.length; i++) {	154	for (int i = 0; i < a.length; i++) {
141	IFormField f = a[i];	155	IFormField f = a[i];
Lines 192-204 Link Here
192	}	206	}
193		207
194	@Override	208	@Override
195	public <T extends IFormField> T getFieldByClass(final Class<T> c) {	209	public <T extends IFormField> T getFieldByClass(Class<T> c) {
		210	final Class<? extends T> formFieldClass = getReplacingFieldClass(c);
196	final Holder<T> found = new Holder<T>(c);	211	final Holder<T> found = new Holder<T>(c);
197	IFormFieldVisitor v = new IFormFieldVisitor() {	212	IFormFieldVisitor v = new IFormFieldVisitor() {
198	@Override	213	@Override
199	@SuppressWarnings("unchecked")	214	@SuppressWarnings("unchecked")
200	public boolean visitField(IFormField field, int level, int fieldIndex) {	215	public boolean visitField(IFormField field, int level, int fieldIndex) {
201	if (field.getClass() == c) {	216	if (field.getClass() == formFieldClass) {
202	found.setValue((T) field);	217	found.setValue((T) field);
203	}	218	}
204	return found.getValue() == null;	219	return found.getValue() == null;
Lines 208-213 Link Here
208	return found.getValue();	223	return found.getValue();
209	}	224	}
210		225
		226	/**
		227	* Checks whether the form field with the given class has been replaced by another form field. If so, the replacing
		228	* form field's class is returned. Otherwise the given class itself.
		229	*
		230	* @param c
		231	* @return Returns the possibly available replacing field class for the given class.
		232	* @see Replace
		233	* @since 3.8.2
		234	*/
		235	private <T extends IFormField> Class<? extends T> getReplacingFieldClass(Class<T> c) {
		236	IForm form = getForm();
		237	if (form instanceof AbstractForm) {
		238	Map<Class<?>, Class<? extends IFormField>> mapping = ((AbstractForm) form).getFormFieldReplacementsInternal();
		239	if (mapping != null) {
		240	@SuppressWarnings("unchecked")
		241	Class<? extends T> replacementFieldClass = (Class<? extends T>) mapping.get(c);
		242	if (replacementFieldClass != null) {
		243	return replacementFieldClass;
		244	}
		245	}
		246	}
		247	return c;
		248	}
		249
211	@Override	250	@Override
212	public IFormField[] getFields() {	251	public IFormField[] getFields() {
213	IFormField[] a = new IFormField[m_fields.length];	252	IFormField[] a = new IFormField[m_fields.length];

Line 0 Link Here

(-)resources/operation/formData/formdata.shared/src/formdata/shared/services/process/replace/BaseFormData.java (+135 lines)
		1	package formdata.shared.services.process.replace;
		2
		3	import org.eclipse.scout.rt.shared.data.form.ValidationRule;
		4	import org.eclipse.scout.rt.shared.data.form.fields.AbstractValueFieldData;
		5	import org.eclipse.scout.rt.shared.data.form.AbstractFormData;
		6
		7	public class BaseFormData extends AbstractFormData {
		8	private static final long serialVersionUID = 1L;
		9
		10	public BaseFormData() {
		11	}
		12
		13	public Lookup getLookup() {
		14	return getFieldByClass(Lookup.class);
		15	}
		16
		17	public Name getName() {
		18	return getFieldByClass(Name.class);
		19	}
		20
		21	public SdkCommandCreate getSdkCommandCreate() {
		22	return getFieldByClass(SdkCommandCreate.class);
		23	}
		24
		25	public SdkCommandNone getSdkCommandNone() {
		26	return getFieldByClass(SdkCommandNone.class);
		27	}
		28
		29	public SdkCommandUse getSdkCommandUse() {
		30	return getFieldByClass(SdkCommandUse.class);
		31	}
		32
		33	public Smart getSmart() {
		34	return getFieldByClass(Smart.class);
		35	}
		36
		37	public static class Lookup extends AbstractValueFieldData<Long> {
		38	private static final long serialVersionUID = 1L;
		39
		40	public Lookup() {
		41	}
		42
		43	/**
		44	* list of derived validation rules.
		45	*/
		46	@Override
		47	protected void initValidationRules(java.util.Map<String, Object> ruleMap) {
		48	super.initValidationRules(ruleMap);
		49	ruleMap.put(ValidationRule.LOOKUP_CALL, TestingLookupCall.class);
		50	ruleMap.put(ValidationRule.ZERO_NULL_EQUALITY, true);
		51	}
		52	}
		53
		54	public static class Name extends AbstractValueFieldData<String> {
		55	private static final long serialVersionUID = 1L;
		56
		57	public Name() {
		58	}
		59
		60	/**
		61	* list of derived validation rules.
		62	*/
		63	@Override
		64	protected void initValidationRules(java.util.Map<String, Object> ruleMap) {
65	super.initValidationRules(ruleMap);
66	ruleMap.put(ValidationRule.MANDATORY, true);
67	ruleMap.put(ValidationRule.MAX_LENGTH, 60);
68	}
69	}
70
71	public static class SdkCommandCreate extends AbstractValueFieldData<String> {
72	private static final long serialVersionUID = 1L;
73
74	public SdkCommandCreate() {
75	}
76
77	/**
78	* list of derived validation rules.
79	*/
80	@Override
81	protected void initValidationRules(java.util.Map<String, Object> ruleMap) {
82	super.initValidationRules(ruleMap);
83	ruleMap.put(ValidationRule.MAX_LENGTH, 4000);
84	}
85	}
86
87	public static class SdkCommandNone extends AbstractValueFieldData<String> {
88	private static final long serialVersionUID = 1L;
89
90	public SdkCommandNone() {
91	}
92
93	/**
94	* list of derived validation rules.
95	*/
96	@Override
97	protected void initValidationRules(java.util.Map<String, Object> ruleMap) {
98	super.initValidationRules(ruleMap);
99	ruleMap.put(ValidationRule.MAX_LENGTH, 4000);
100	}
101	}
102
103	public static class SdkCommandUse extends UsingFormFieldData {
104	private static final long serialVersionUID = 1L;
105
106	public SdkCommandUse() {
107	}
108
109	/**
110	* list of derived validation rules.
111	*/
112	@Override
113	protected void initValidationRules(java.util.Map<String, Object> ruleMap) {
114	super.initValidationRules(ruleMap);
115	ruleMap.put(ValidationRule.MAX_LENGTH, 4000);
116	}
117	}
118
119	public static class Smart extends AbstractValueFieldData<Long> {
120	private static final long serialVersionUID = 1L;
121
122	public Smart() {
123	}
124
125	/**
126	* list of derived validation rules.
127	*/
128	@Override
129	protected void initValidationRules(java.util.Map<String, Object> ruleMap) {
130	super.initValidationRules(ruleMap);
131	ruleMap.put(ValidationRule.CODE_TYPE, TestingCodeType.class);
132	ruleMap.put(ValidationRule.ZERO_NULL_EQUALITY, true);
133	}
134	}
135	}

Line 0 Link Here

(-)resources/operation/formData/formdata.client/src/formdata/client/ui/forms/replace/BaseForm.java (+136 lines)
		1	package formdata.client.ui.forms.replace;
		2
		3	import org.eclipse.scout.commons.annotations.FormData;
		4	import org.eclipse.scout.commons.annotations.FormData.SdkCommand;
		5	import org.eclipse.scout.commons.annotations.Order;
		6	import org.eclipse.scout.commons.exception.ProcessingException;
		7	import org.eclipse.scout.rt.client.ui.form.AbstractForm;
		8	import org.eclipse.scout.rt.client.ui.form.fields.button.AbstractCloseButton;
		9	import org.eclipse.scout.rt.client.ui.form.fields.groupbox.AbstractGroupBox;
		10	import org.eclipse.scout.rt.client.ui.form.fields.smartfield.AbstractSmartField;
		11	import org.eclipse.scout.rt.client.ui.form.fields.stringfield.AbstractStringField;
		12	import org.eclipse.scout.rt.shared.services.common.code.ICodeType;
		13
		14	import formdata.client.ui.forms.replace.BaseForm.MainBox.CloseButton;
		15	import formdata.client.ui.forms.replace.BaseForm.MainBox.GroupBox;
		16	import formdata.client.ui.forms.replace.BaseForm.MainBox.GroupBox.NameField;
		17	import formdata.client.ui.forms.replace.BaseForm.MainBox.GroupBox.SmartField;
		18	import formdata.client.ui.forms.replace.BaseForm.MainBox.IgnoringGroupBox;
		19	import formdata.client.ui.forms.replace.BaseForm.MainBox.IgnoringGroupBox.IgnoringGroupBoxField;
		20	import formdata.shared.services.process.replace.BaseFormData;
		21	import formdata.shared.services.process.replace.TestingCodeType;
		22	import formdata.shared.services.process.replace.UsingFormFieldData;
		23
		24	@FormData(value = BaseFormData.class, sdkCommand = SdkCommand.CREATE)
		25	public class BaseForm extends AbstractForm {
		26
		27	public BaseForm() throws ProcessingException {
		28	super();
		29	}
		30
		31	public MainBox getMainBox() {
		32	return getFieldByClass(MainBox.class);
		33	}
		34
		35	public GroupBox getGroupBox() {
		36	return getFieldByClass(GroupBox.class);
		37	}
		38
		39	public NameField getNameField() {
		40	return getFieldByClass(NameField.class);
		41	}
		42
		43	public SmartField getSmartField() {
		44	return getFieldByClass(SmartField.class);
		45	}
		46
		47	public IgnoringGroupBox getIgnoringGroupBox() {
		48	return getFieldByClass(IgnoringGroupBox.class);
		49	}
		50
		51	public IgnoringGroupBoxField getIgnoringGroupBoxField() {
		52	return getFieldByClass(IgnoringGroupBoxField.class);
		53	}
		54
		55	public CloseButton getCloseButton() {
		56	return getFieldByClass(CloseButton.class);
		57	}
		58
		59	@Order(10.0)
		60	public class MainBox extends AbstractGroupBox {
		61
		62	@Order(10)
		63	public class NoneFormDataFieldsGroupBox extends AbstractGroupBox {
		64	@Order(10)
65	public class SdkCommandNoneField extends AbstractStringField {
66	}
67	}
68
69	@Order(20)
70	public class CreatingFormDataFieldsGroupBox extends AbstractGroupBox {
71	@Order(10)
72	@FormData(sdkCommand = SdkCommand.CREATE)
73	public class SdkCommandCreateField extends AbstractStringField {
74	}
75	}
76
77	@Order(30)
78	public class UsingFormDataFieldsGroupBox extends AbstractGroupBox {
79	@Order(10)
80	@FormData(sdkCommand = SdkCommand.USE, value = UsingFormFieldData.class)
81	public class SdkCommandUseField extends AbstractStringField {
82	}
83	}
84
85	@Order(40)
86	public class IgnoringFormDataFieldsGroupBox extends AbstractGroupBox {
87	@Order(10)
88	@FormData(sdkCommand = SdkCommand.IGNORE)
89	public class SdkCommandIgnoreField extends AbstractStringField {
90	}
91	}
92
93	@Order(50.0)
94	public class GroupBox extends AbstractGroupBox {
95
96	@Order(10.0)
97	public class NameField extends AbstractStringField {
98
99	@Override
100	protected boolean getConfiguredMandatory() {
101	return true;
102	}
103
104	@Override
105	protected int getConfiguredMaxLength() {
106	return 60;
107	}
108	}
109
110	@Order(20.0)
111	public class SmartField extends AbstractSmartField<Long> {
112	@Override
113	protected Class<? extends ICodeType<?>> getConfiguredCodeType() {
114	return TestingCodeType.class;
115	}
116	}
117
118	@Order(30.0)
119	public class LookupField extends AbstractLookupField {
120	}
121	}
122
123	@Order(20.0)
124	@FormData(sdkCommand = SdkCommand.IGNORE)
125	public class IgnoringGroupBox extends AbstractGroupBox {
126
127	@Order(10.0)
128	public class IgnoringGroupBoxField extends AbstractStringField {
129	}
130	}
131
132	@Order(100.0)
133	public class CloseButton extends AbstractCloseButton {
134	}
135	}
136	}

Lines 17-31 Link Here

(-)src/org/eclipse/scout/sdk/internal/test/operation/formdata/_SuiteFormData.java (-2 / +3 lines)
17	//@SuiteClasses({FormWithTemplateTest.class, TemplateFormDataTest.class})	17	//@SuiteClasses({FormWithTemplateTest.class, TemplateFormDataTest.class})
18	@SuiteClasses({	18	@SuiteClasses({
19	ExternalCheckboxFieldTest.class,	19	ExternalCheckboxFieldTest.class,
		20	ExternalGroupboxTest.class,
20	ExternalTableFieldTest.class,	21	ExternalTableFieldTest.class,
21	FormPropertiesTest.class,	22	FormPropertiesTest.class,
22	FormWithGroupboxesTest.class,	23	FormWithGroupboxesTest.class,
23	FormWithTemplateTest.class,	24	FormWithTemplateTest.class,
24	IgnoredFieldsFormTest.class,	25	IgnoredFieldsFormTest.class,
25	ListBoxFormTest.class,	26	ListBoxFormTest.class,
		27	ReplaceFormFiledTest.class,
26	SimpleFormTest.class,	28	SimpleFormTest.class,
27	TableFieldFormTest.class,	29	TableFieldFormTest.class})
28	ExternalGroupboxTest.class})
29	public class _SuiteFormData {	30	public class _SuiteFormData {
30		31
31	}	32	}

Lines 15-20 Link Here

(-)src/org/eclipse/scout/rt/shared/data/form/fields/AbstractFormFieldData.java (-6 / +39 lines)
15	import java.util.Map;	15	import java.util.Map;
16		16
17	import org.eclipse.scout.commons.ConfigurationUtility;	17	import org.eclipse.scout.commons.ConfigurationUtility;
		18	import org.eclipse.scout.commons.annotations.Replace;
18	import org.eclipse.scout.commons.logger.IScoutLogger;	19	import org.eclipse.scout.commons.logger.IScoutLogger;
19	import org.eclipse.scout.commons.logger.ScoutLogManager;	20	import org.eclipse.scout.commons.logger.ScoutLogManager;
20	import org.eclipse.scout.rt.shared.data.form.FormDataUtility;	21	import org.eclipse.scout.rt.shared.data.form.FormDataUtility;
Lines 24-29 Link Here
24	private static final IScoutLogger LOG = ScoutLogManager.getLogger(AbstractFormFieldData.class);	25	private static final IScoutLogger LOG = ScoutLogManager.getLogger(AbstractFormFieldData.class);
25	private static final long serialVersionUID = 1L;	26	private static final long serialVersionUID = 1L;
26		27
		28	private Map<Class<?>, Class<? extends AbstractFormFieldData>> m_fieldDataReplacements;
27	private Map<Class<? extends AbstractPropertyData>, AbstractPropertyData> m_propertyMap;	29	private Map<Class<? extends AbstractPropertyData>, AbstractPropertyData> m_propertyMap;
28	private Map<Class<? extends AbstractFormFieldData>, AbstractFormFieldData> m_fieldMap;	30	private Map<Class<? extends AbstractFormFieldData>, AbstractFormFieldData> m_fieldMap;
29	private boolean m_valueSet;	31	private boolean m_valueSet;
Lines 39-45 Link Here
39		41
40	private Class<? extends AbstractFormFieldData>[] getConfiguredFieldDatas() {	42	private Class<? extends AbstractFormFieldData>[] getConfiguredFieldDatas() {
41	Class[] dca = ConfigurationUtility.getDeclaredPublicClasses(getClass());	43	Class[] dca = ConfigurationUtility.getDeclaredPublicClasses(getClass());
42	return ConfigurationUtility.filterClasses(dca, AbstractFormFieldData.class);	44	Class<AbstractFormFieldData>[] fca = ConfigurationUtility.filterClasses(dca, AbstractFormFieldData.class);
		45	return ConfigurationUtility.removeReplacedClasses(fca);
43	}	46	}
44		47
45	protected void initConfig() {	48	protected void initConfig() {
Lines 71-76 Link Here
71	}// end for	74	}// end for
72	if (map.size() > 0) {	75	if (map.size() > 0) {
73	m_fieldMap = map;	76	m_fieldMap = map;
		77	Map<Class<?>, Class<? extends AbstractFormFieldData>> replacements = ConfigurationUtility.getReplacementMapping(fieldArray);
		78	if (!replacements.isEmpty()) {
		79	m_fieldDataReplacements = replacements;
		80	}
74	}	81	}
75	}	82	}
76		83
Lines 84-90 Link Here
84	}	91	}
85		92
86	public String getFieldId() {	93	public String getFieldId() {
87	String s = getClass().getName();	94	Class<?> c = getClass();
		95	while (c.isAnnotationPresent(Replace.class)) {
		96	c = c.getSuperclass();
		97	}
		98	String s = c.getName();
88	int i = Math.max(s.lastIndexOf('$'), s.lastIndexOf('.'));	99	int i = Math.max(s.lastIndexOf('$'), s.lastIndexOf('.'));
89	s = s.substring(i + 1);	100	s = s.substring(i + 1);
90	return s;	101	return s;
Lines 126-135 Link Here
126	}	137	}
127		138
128	public AbstractFormFieldData getFieldById(String id) {	139	public AbstractFormFieldData getFieldById(String id) {
129	String fieldDataId = FormDataUtility.getFieldDataId(id);
130	if (m_fieldMap == null) {	140	if (m_fieldMap == null) {
131	return null;	141	return null;
132	}	142	}
		143	String fieldDataId = FormDataUtility.getFieldDataId(id);
133	for (AbstractFormFieldData f : m_fieldMap.values()) {	144	for (AbstractFormFieldData f : m_fieldMap.values()) {
134	if (f.getFieldId().equals(fieldDataId)) {	145	if (f.getFieldId().equals(fieldDataId)) {
135	return f;	146	return f;
Lines 143-163 Link Here
143	if (m_fieldMap == null) {	154	if (m_fieldMap == null) {
144	return null;	155	return null;
145	}	156	}
146	return (T) m_fieldMap.get(c);	157	Class<? extends T> clazz = getReplacingFieldDataClass(c);
		158	return (T) m_fieldMap.get(clazz);
147	}	159	}
148		160
149	public <T extends AbstractFormFieldData> void setFieldByClass(Class<T> c, T v) {	161	public <T extends AbstractFormFieldData> void setFieldByClass(Class<T> c, T v) {
		162	Class<? extends T> clazz = getReplacingFieldDataClass(c);
150	if (v == null) {	163	if (v == null) {
151	if (m_fieldMap != null) {	164	if (m_fieldMap != null) {
152	m_fieldMap.remove(c);	165	m_fieldMap.remove(clazz);
153	}	166	}
154	}	167	}
155	else {	168	else {
156	if (m_fieldMap == null) {	169	if (m_fieldMap == null) {
157	m_fieldMap = new HashMap<Class<? extends AbstractFormFieldData>, AbstractFormFieldData>();	170	m_fieldMap = new HashMap<Class<? extends AbstractFormFieldData>, AbstractFormFieldData>();
158	}	171	}
159	m_fieldMap.put(c, v);	172	m_fieldMap.put(clazz, v);
		173	}
		174	}
		175
		176	/**
		177	* Checks whether the form field data with the given class has been replaced by another field. If so, the replacing
		178	* form field data's class is returned. Otherwise the given class itself.
		179	*
		180	* @param c
		181	* @return Returns the possibly available replacing field data class for the given class.
		182	* @see Replace
		183	* @since 3.8.2
		184	*/
		185	private <T> Class<? extends T> getReplacingFieldDataClass(Class<T> c) {
		186	if (m_fieldDataReplacements != null) {
		187	@SuppressWarnings("unchecked")
		188	Class<? extends T> replacingFieldClass = (Class<? extends T>) m_fieldDataReplacements.get(c);
		189	if (replacingFieldClass != null) {
		190	return replacingFieldClass;
		191	}
160	}	192	}
		193	return c;
161	}	194	}
162		195
163	public AbstractFormFieldData[] getFields() {	196	public AbstractFormFieldData[] getFields() {

Lines 19-24 Link Here

(-)src/org/eclipse/scout/rt/shared/data/form/AbstractFormData.java (-4 / +33 lines)
19	import org.eclipse.scout.commons.ClassIdentifier;	19	import org.eclipse.scout.commons.ClassIdentifier;
20	import org.eclipse.scout.commons.CloneUtility;	20	import org.eclipse.scout.commons.CloneUtility;
21	import org.eclipse.scout.commons.ConfigurationUtility;	21	import org.eclipse.scout.commons.ConfigurationUtility;
		22	import org.eclipse.scout.commons.annotations.Replace;
22	import org.eclipse.scout.commons.exception.ProcessingException;	23	import org.eclipse.scout.commons.exception.ProcessingException;
23	import org.eclipse.scout.commons.logger.IScoutLogger;	24	import org.eclipse.scout.commons.logger.IScoutLogger;
24	import org.eclipse.scout.commons.logger.ScoutLogManager;	25	import org.eclipse.scout.commons.logger.ScoutLogManager;
Lines 29-34 Link Here
29	private static final IScoutLogger LOG = ScoutLogManager.getLogger(AbstractFormData.class);	30	private static final IScoutLogger LOG = ScoutLogManager.getLogger(AbstractFormData.class);
30	private static final long serialVersionUID = 1L;	31	private static final long serialVersionUID = 1L;
31		32
		33	private Map<Class<?>, Class<? extends AbstractFormFieldData>> m_fieldDataReplacements;
32	private Map<Class<? extends AbstractPropertyData>, AbstractPropertyData> m_propertyMap;	34	private Map<Class<? extends AbstractPropertyData>, AbstractPropertyData> m_propertyMap;
33	private Map<Class<? extends AbstractFormFieldData>, AbstractFormFieldData> m_fieldMap;	35	private Map<Class<? extends AbstractFormFieldData>, AbstractFormFieldData> m_fieldMap;
34		36
Lines 43-49 Link Here
43		45
44	private Class<? extends AbstractFormFieldData>[] getConfiguredFieldDatas() {	46	private Class<? extends AbstractFormFieldData>[] getConfiguredFieldDatas() {
45	Class[] dca = ConfigurationUtility.getDeclaredPublicClasses(getClass());	47	Class[] dca = ConfigurationUtility.getDeclaredPublicClasses(getClass());
46	return ConfigurationUtility.filterClasses(dca, AbstractFormFieldData.class);	48	Class<AbstractFormFieldData>[] fca = ConfigurationUtility.filterClasses(dca, AbstractFormFieldData.class);
		49	return ConfigurationUtility.removeReplacedClasses(fca);
47	}	50	}
48		51
49	protected void initConfig() {	52	protected void initConfig() {
Lines 63-68 Link Here
63	// add fields	66	// add fields
64	m_fieldMap = new HashMap<Class<? extends AbstractFormFieldData>, AbstractFormFieldData>();	67	m_fieldMap = new HashMap<Class<? extends AbstractFormFieldData>, AbstractFormFieldData>();
65	Class<? extends AbstractFormFieldData>[] fieldArray = getConfiguredFieldDatas();	68	Class<? extends AbstractFormFieldData>[] fieldArray = getConfiguredFieldDatas();
		69	Map<Class<?>, Class<? extends AbstractFormFieldData>> replacements = ConfigurationUtility.getReplacementMapping(fieldArray);
		70	if (!replacements.isEmpty()) {
		71	m_fieldDataReplacements = replacements;
		72	}
66	for (int i = 0; i < fieldArray.length; i++) {	73	for (int i = 0; i < fieldArray.length; i++) {
67	AbstractFormFieldData f;	74	AbstractFormFieldData f;
68	try {	75	try {
Lines 114-129 Link Here
114		121
115	@SuppressWarnings("unchecked")	122	@SuppressWarnings("unchecked")
116	public <T extends AbstractFormFieldData> T getFieldByClass(Class<T> c) {	123	public <T extends AbstractFormFieldData> T getFieldByClass(Class<T> c) {
117	return (T) m_fieldMap.get(c);	124	Class<? extends T> clazz = getReplacingFieldDataClass(c);
		125	return (T) m_fieldMap.get(clazz);
118	}	126	}
119		127
120	public <T extends AbstractFormFieldData> void setFieldByClass(Class<T> c, T v) {	128	public <T extends AbstractFormFieldData> void setFieldByClass(Class<T> c, T v) {
		129	Class<? extends T> clazz = getReplacingFieldDataClass(c);
121	if (v == null) {	130	if (v == null) {
122	m_fieldMap.remove(c);	131	m_fieldMap.remove(clazz);
123	}	132	}
124	else {	133	else {
125	m_fieldMap.put(c, v);	134	m_fieldMap.put(clazz, v);
		135	}
		136	}
		137
		138	/**
		139	* Checks whether the form field data with the given class has been replaced by another field. If so, the replacing
		140	* form field data's class is returned. Otherwise the given class itself.
		141	*
		142	* @param c
		143	* @return Returns the possibly available replacing field data class for the given class.
		144	* @see Replace
		145	* @since 3.8.2
		146	*/
		147	private <T extends AbstractFormFieldData> Class<? extends T> getReplacingFieldDataClass(Class<T> c) {
		148	if (m_fieldDataReplacements != null) {
		149	@SuppressWarnings("unchecked")
		150	Class<T> replacingFieldDataClass = (Class<T>) m_fieldDataReplacements.get(c);
		151	if (replacingFieldDataClass != null) {
		152	return replacingFieldDataClass;
		153	}
126	}	154	}
		155	return c;
127	}	156	}
128		157
129	/**	158	/**