0001: /*
0002: * Copyright 2006-2007 Luca Garulli (luca.garulli@assetdata.it)
0003: *
0004: * Licensed under the Apache License, Version 2.0 (the "License"); you may not
0005: * use this file except in compliance with the License. You may obtain a copy of
0006: * the License at
0007: *
0008: * http://www.apache.org/licenses/LICENSE-2.0
0009: *
0010: * Unless required by applicable law or agreed to in writing, software
0011: * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
0012: * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
0013: * License for the specific language governing permissions and limitations under
0014: * the License.
0015: */
0016: package org.romaframework.aspect.view.echo2.form;
0017:
0018: import java.util.Calendar;
0019: import java.util.Collection;
0020: import java.util.Date;
0021: import java.util.Map;
0022: import java.util.Set;
0023: import java.util.Map.Entry;
0024:
0025: import nextapp.echo2.app.Button;
0026: import nextapp.echo2.app.CheckBox;
0027: import nextapp.echo2.app.Component;
0028: import nextapp.echo2.app.ImageReference;
0029: import nextapp.echo2.app.Label;
0030: import nextapp.echo2.app.ListBox;
0031: import nextapp.echo2.app.WindowPane;
0032: import nextapp.echo2.app.list.DefaultListModel;
0033: import nextapp.echo2.app.text.TextComponent;
0034:
0035: import org.apache.commons.logging.Log;
0036: import org.apache.commons.logging.LogFactory;
0037: import org.romaframework.aspect.authentication.AuthenticationAspect;
0038: import org.romaframework.aspect.core.CoreAspect;
0039: import org.romaframework.aspect.core.feature.CoreFieldFeatures;
0040: import org.romaframework.aspect.i18n.I18NAspect;
0041: import org.romaframework.aspect.session.SessionAccount;
0042: import org.romaframework.aspect.session.SessionAspect;
0043: import org.romaframework.aspect.session.SessionInfo;
0044: import org.romaframework.aspect.view.ViewAspect;
0045: import org.romaframework.aspect.view.ViewCallback;
0046: import org.romaframework.aspect.view.ViewConstants;
0047: import org.romaframework.aspect.view.echo2.component.ComposedComponent;
0048: import org.romaframework.aspect.view.echo2.component.DynaComponentSet;
0049: import org.romaframework.aspect.view.echo2.component.DynaDate;
0050: import org.romaframework.aspect.view.echo2.component.DynaHtml;
0051: import org.romaframework.aspect.view.echo2.component.DynaListBox;
0052: import org.romaframework.aspect.view.echo2.component.DynaRadio;
0053: import org.romaframework.aspect.view.echo2.component.DynaTabbedPane;
0054: import org.romaframework.aspect.view.echo2.component.DynaTree;
0055: import org.romaframework.aspect.view.echo2.component.PopupForm;
0056: import org.romaframework.aspect.view.echo2.component.SelectComponent;
0057: import org.romaframework.aspect.view.echo2.component.SelectFieldComponent;
0058: import org.romaframework.aspect.view.echo2.component.resolver.RenderingResolver;
0059: import org.romaframework.aspect.view.echo2.component.table.DynaTable;
0060: import org.romaframework.aspect.view.echo2.look.LookAndFeelManager;
0061: import org.romaframework.aspect.view.echo2.screen.Echo2Screen;
0062: import org.romaframework.aspect.view.feature.ViewBaseFeatures;
0063: import org.romaframework.aspect.view.feature.ViewElementFeatures;
0064: import org.romaframework.aspect.view.feature.ViewFieldFeatures;
0065: import org.romaframework.aspect.view.form.ContentComponent;
0066: import org.romaframework.aspect.view.form.ContentForm;
0067: import org.romaframework.aspect.view.form.FormPool;
0068: import org.romaframework.aspect.view.form.FormViewer;
0069: import org.romaframework.aspect.view.layout.LayoutMode;
0070: import org.romaframework.aspect.view.layout.LayoutModeManager;
0071: import org.romaframework.aspect.view.rendering.InvalidRenderingMode;
0072: import org.romaframework.aspect.view.rendering.RenderingMode;
0073: import org.romaframework.aspect.view.rendering.RenderingModeManager;
0074: import org.romaframework.aspect.view.screen.Screen;
0075: import org.romaframework.core.Utility;
0076: import org.romaframework.core.config.RomaApplicationContext;
0077: import org.romaframework.core.domain.type.TreeNode;
0078: import org.romaframework.core.exception.ConfigurationException;
0079: import org.romaframework.core.flow.Controller;
0080: import org.romaframework.core.flow.ObjectContext;
0081: import org.romaframework.core.schema.SchemaAction;
0082: import org.romaframework.core.schema.SchemaClassDefinition;
0083: import org.romaframework.core.schema.SchemaElement;
0084: import org.romaframework.core.schema.SchemaEvent;
0085: import org.romaframework.core.schema.SchemaField;
0086: import org.romaframework.core.schema.SchemaHelper;
0087: import org.romaframework.core.schema.SchemaManager;
0088: import org.romaframework.core.schema.SchemaObject;
0089:
0090: import echopointng.CheckBoxEx;
0091: import echopointng.ImageIcon;
0092: import echopointng.ProgressBar;
0093: import echopointng.Tree;
0094: import echopointng.tree.DefaultMutableTreeNode;
0095: import echopointng.tree.DefaultTreeModel;
0096: import echopointng.tree.TreePath;
0097:
0098: public class FormUtil {
0099:
0100: public static final String METADATA_COMPONENT_OWNER = "component";
0101: public static final String METADATA_ALLOW_NULL = "allowNull";
0102: private static final Boolean[] BOOLEAN_VALUES = { Boolean.TRUE,
0103: Boolean.FALSE };
0104: private static final String METADATA_FORM_NAME = "form";
0105: private static final String METADATA_SCHEMA_NAME = "metadata";
0106: private static final String LABEL_POSTFIX = ".label";
0107: private static final String CLASS_LABEL_POSTFIX = "label";
0108: private static final String HINT_POSTFIX = ".hint";
0109: private static final String ENABLED_SUFFIX = ".enabled";
0110: private static final String START_IMG_PATH = "$";
0111: private static final String SHOW_EVENT_NAME = "show";
0112: private static Log log = LogFactory.getLog(FormUtil.class);
0113:
0114: public static void showLinkedEntity(ContentComponent iCallerForm,
0115: EntityForm iForm, boolean iEditMode) {
0116: WindowPane window = new PopupForm(iCallerForm, iForm, iEditMode);
0117: FormViewer.getInstance().display(
0118: Echo2Screen.POPUP + ":" + iForm, window);
0119: }
0120:
0121: public static String getLabel(Class<?> iClass, String iText) {
0122: return RomaApplicationContext.getInstance().getBean(
0123: I18NAspect.class).resolveString(iClass, iText);
0124: }
0125:
0126: public static String getLabel(SchemaClassDefinition iClass) {
0127: String label = (String) iClass.getFeature(
0128: ViewAspect.ASPECT_NAME, ViewBaseFeatures.LABEL);
0129: if (label == null)
0130: label = I18NAspect.VARNAME_PREFIX + CLASS_LABEL_POSTFIX;
0131: else if (!label.startsWith(I18NAspect.VARNAME_PREFIX))
0132: // RETURN FIXED LABEL
0133: return label;
0134: label = RomaApplicationContext.getInstance().getBean(
0135: I18NAspect.class).resolveString(
0136: iClass.getSchemaClass().getClazz(), label);
0137: if (label == null)
0138: label = Utility.getClearName(iClass.getSchemaClass()
0139: .getName());
0140: return label;
0141: }
0142:
0143: public static String getLabel(SchemaElement iElement) {
0144: String label = (String) (iElement).getFeature(
0145: ViewAspect.ASPECT_NAME, ViewBaseFeatures.LABEL);
0146: if (label == null)
0147: label = I18NAspect.VARNAME_PREFIX + iElement.getName();
0148: else if (!label.startsWith(I18NAspect.VARNAME_PREFIX))
0149: // RETURN FIXED LABEL
0150: return label;
0151: label += LABEL_POSTFIX;
0152: label = RomaApplicationContext.getInstance().getBean(
0153: I18NAspect.class)
0154: .resolveString(
0155: iElement.getEntity().getSchemaClass()
0156: .getClazz(), label);
0157: if (label == null)
0158: label = Utility.getClearName(iElement.getName());
0159: return label;
0160: }
0161:
0162: public static void assignLabel(Component iComponent, String iText) {
0163: if (iComponent instanceof Button)
0164: ((Button) iComponent).setText(iText);
0165: else if (iComponent instanceof Label)
0166: ((Label) iComponent).setText(iText);
0167: }
0168:
0169: public static String getHint(Class<?> iClass, String iText) {
0170: return RomaApplicationContext.getInstance().getBean(
0171: I18NAspect.class).resolveString(iClass, iText);
0172: }
0173:
0174: public static String getHint(SchemaElement iElement) {
0175: String hint = (String) iElement.getFeature(
0176: ViewAspect.ASPECT_NAME, ViewBaseFeatures.DESCRIPTION);
0177: if (hint == null)
0178: hint = I18NAspect.VARNAME_PREFIX + iElement.getName()
0179: + HINT_POSTFIX;
0180: hint = RomaApplicationContext.getInstance().getBean(
0181: I18NAspect.class).resolveString(
0182: iElement.getEntity().getSchemaClass().getClazz(), hint);
0183: if (hint == null)
0184: hint = Utility.getClearName(iElement.getName());
0185: return hint;
0186: }
0187:
0188: public static void assignHint(Component iComponent, String iText) {
0189: if (iComponent instanceof Button)
0190: ((Button) iComponent).setToolTipText(iText);
0191: else if (iComponent instanceof TextComponent)
0192: ((TextComponent) iComponent).setToolTipText(iText);
0193: else if (iComponent instanceof ComposedComponent)
0194: ((ComposedComponent) iComponent).getTextComponent()
0195: .setToolTipText(iText);
0196: else if (iComponent instanceof Label)
0197: ((Label) iComponent).setToolTipText(iText);
0198: }
0199:
0200: /**
0201: * Render a form's field.
0202: *
0203: * @param iForm
0204: * @param iField
0205: * @return
0206: */
0207: public static Component renderField(ContentComponent iForm,
0208: SchemaField iField, ContentComponent iFormToRender) {
0209: if (iField != null
0210: && !(Boolean) iField.getFeature(ViewAspect.ASPECT_NAME,
0211: ViewElementFeatures.VISIBLE))
0212: return null;
0213:
0214: String renderName = iField != null ? (String) iField
0215: .getFeature(ViewAspect.ASPECT_NAME,
0216: ViewBaseFeatures.RENDER) : null;
0217: RenderingMode<Component> rendering = ObjectContext
0218: .getInstance().getComponent(RenderingResolver.class)
0219: .getRenderingMode(iField, renderName);
0220:
0221: if (rendering == null)
0222: throw new InvalidRenderingMode("field: "
0223: + iField.getName()
0224: + " render: "
0225: + iField.getFeature(ViewAspect.ASPECT_NAME,
0226: ViewBaseFeatures.RENDER));
0227:
0228: Component component = rendering.renderField(iForm, iField,
0229: iFormToRender);
0230: setMetadata(component, iFormToRender, iField);
0231:
0232: if (iField != null)
0233: // ASSIGN STYLE
0234: RomaApplicationContext.getInstance().getBean(
0235: LookAndFeelManager.class).assignStyle(
0236: component,
0237: iForm.getSchemaInstance().getSchemaClass()
0238: .getClazz(),
0239: iField.getName(),
0240: (String) iField.getFeature(ViewAspect.ASPECT_NAME,
0241: ViewBaseFeatures.STYLE));
0242: else
0243: // ASSIGN STYLE
0244: RomaApplicationContext.getInstance().getBean(
0245: LookAndFeelManager.class).assignStyle(
0246: component,
0247: iForm.getSchemaInstance().getSchemaClass()
0248: .getClazz());
0249: return component;
0250: }
0251:
0252: /**
0253: * Render and form's action.
0254: *
0255: * @param iForm
0256: * @param iAction
0257: * @return
0258: */
0259: public static Component renderAction(EntityForm iForm,
0260: SchemaAction iAction) {
0261: if (!(Boolean) iAction.getFeature(ViewAspect.ASPECT_NAME,
0262: ViewElementFeatures.VISIBLE))
0263: return null;
0264: String renderName = (String) iAction.getFeature(
0265: ViewAspect.ASPECT_NAME, ViewBaseFeatures.RENDER);
0266: RenderingMode<Component> rendering = ObjectContext
0267: .getInstance().getComponent(RenderingResolver.class)
0268: .getRenderingMode(iAction, renderName);
0269: if (rendering == null)
0270: throw new InvalidRenderingMode("action: "
0271: + iAction.getName()
0272: + " render: "
0273: + iAction.getFeature(ViewAspect.ASPECT_NAME,
0274: ViewBaseFeatures.RENDER));
0275: Component component = rendering.renderAction(iForm, iAction);
0276: if (component != null)
0277: // ASSIGN STYLE
0278: RomaApplicationContext.getInstance().getBean(
0279: LookAndFeelManager.class).assignStyle(
0280: component,
0281: iForm.getSchemaInstance().getSchemaClass()
0282: .getClazz(),
0283: iAction.getName(),
0284: (String) iAction.getFeature(ViewAspect.ASPECT_NAME,
0285: ViewBaseFeatures.STYLE));
0286: return component;
0287: }
0288:
0289: public static Component renderForm(ContentComponent iForm,
0290: ContentComponent iFormToRender) {
0291: String renderName = (String) iForm.getSchemaInstance()
0292: .getFeature(ViewAspect.ASPECT_NAME,
0293: ViewBaseFeatures.RENDER);
0294: if (renderName == null)
0295: renderName = ViewConstants.RENDER_DEFAULT;
0296: RenderingMode<Component> rendering = RomaApplicationContext
0297: .getInstance().getBean(RenderingModeManager.class)
0298: .getComponent(renderName);
0299: if (rendering == null)
0300: throw new InvalidRenderingMode("entity: "
0301: + iForm.getSchemaInstance().getSchemaClass()
0302: .getName()
0303: + " render: "
0304: + iForm.getSchemaInstance().getFeature(
0305: ViewAspect.ASPECT_NAME,
0306: ViewBaseFeatures.RENDER));
0307: Component component = rendering.renderClass(iForm,
0308: iFormToRender);
0309: // ASSIGN STYLE
0310: RomaApplicationContext.getInstance().getBean(
0311: LookAndFeelManager.class)
0312: .assignStyle(
0313: component,
0314: iForm.getSchemaInstance().getSchemaClass()
0315: .getClazz(),
0316: (String) iForm.getSchemaInstance().getFeature(
0317: ViewAspect.ASPECT_NAME,
0318: ViewBaseFeatures.STYLE));
0319: return component;
0320: }
0321:
0322: public static String layoutForm(EntityForm iForm,
0323: EntityForm iFormToRender, String iWhere, Screen iDesktop) {
0324: Component component = renderForm(iForm, iFormToRender);
0325: String layoutName = (String) iForm.getSchemaInstance()
0326: .getFeature(ViewAspect.ASPECT_NAME,
0327: ViewBaseFeatures.LAYOUT);
0328: if (layoutName == null) {
0329: if (iWhere == null)
0330: layoutName = ViewConstants.LAYOUT_DEFAULT;
0331: else
0332: layoutName = iWhere;
0333: }
0334: // EXTRACT COMPOSED NAME IF ANY
0335: String tokens[] = extractTokens(layoutName, ":");
0336: String mode = tokens.length > 1 ? tokens[1] : null;
0337: // RENDER THE FIELD IN THE LAYOUT-STRETEGY DEFINED FORM
0338: LayoutMode<Component> layout = RomaApplicationContext
0339: .getInstance().getBean(LayoutModeManager.class)
0340: .getComponent(tokens[0]);
0341: if (layout == null) {
0342: // LAYOUT NOT FOUND: USE DYNAMIC LAYOUT
0343: layout = RomaApplicationContext.getInstance().getBean(
0344: LayoutModeManager.class).getComponent(
0345: ViewConstants.LAYOUT_SCREEN);
0346: // POSITION NOT VALUED: USE LAYOUT NAME
0347: mode = layoutName;
0348: }
0349: return layout.layoutClass(iForm, component, mode, iDesktop);
0350: }
0351:
0352: /**
0353: * Render and place a form's field.
0354: *
0355: * @param iForm
0356: * @param iField
0357: * @return
0358: */
0359: public static Component layoutField(EntityForm iForm,
0360: SchemaField iField, ContentComponent iFormToRender) {
0361: Component component = renderField(iForm, iField, iFormToRender);
0362: if (component == null)
0363: return null;
0364: // PLACE THE COMPONENT
0365: String layoutName = (String) iField.getFeature(
0366: ViewAspect.ASPECT_NAME, ViewBaseFeatures.LAYOUT);
0367: String mode = null;
0368: if (layoutName != null) {
0369: // EXTRACT COMPOSED NAME IF ANY
0370: String tokens[] = extractTokens(layoutName, ":");
0371: if (tokens.length > 1)
0372: mode = tokens[1];
0373: layoutName = tokens[0];
0374: } else
0375: // LAYOUT NOT FOUND: USE DEFAULT LAYOUT
0376: layoutName = ViewConstants.LAYOUT_DEFAULT;
0377: // RENDER THE FIELD IN THE LAYOUT-STRETEGY DEFINED FORM
0378: LayoutMode<Component> layout = RomaApplicationContext
0379: .getInstance().getBean(LayoutModeManager.class)
0380: .getComponent(layoutName);
0381: if (component instanceof ContentComponent) {
0382: ContentComponent embeddedForm = ((ContentComponent) component);
0383: // EMBEDDED COMPONENT: RENDER IT NOW FOLLOWING LAYOUT STRATEGY
0384: layout.getContainerForm(embeddedForm).render(embeddedForm);
0385: }
0386: if (layout.renderOwnerField()) {
0387: String area = layout.layoutField(iField, iForm, component,
0388: mode);
0389: if (component instanceof ContentForm)
0390: // UPDATE AREA POSITION
0391: ((ContentForm) component).setScreenArea(area);
0392: }
0393: return component;
0394: }
0395:
0396: public static void layoutAction(EntityForm iForm,
0397: SchemaAction iAction, Component iComponent) {
0398: String layoutName = (String) iAction.getFeature(
0399: ViewAspect.ASPECT_NAME, ViewBaseFeatures.LAYOUT);
0400: String mode = null;
0401: if (layoutName != null) {
0402: // EXTRACT COMPOSED NAME IF ANY
0403: String tokens[] = extractTokens(layoutName, ":");
0404: if (tokens.length > 1)
0405: mode = tokens[1];
0406: layoutName = tokens[0];
0407: } else
0408: // LAYOUT NOT FOUND: USE DEFAULT LAYOUT
0409: layoutName = ViewConstants.LAYOUT_DEFAULT;
0410: LayoutMode<Component> layout = RomaApplicationContext
0411: .getInstance().getBean(LayoutModeManager.class)
0412: .getComponent(layoutName);
0413: layout.layoutAction(iAction, iForm, iComponent, mode);
0414: }
0415:
0416: public static String[] extractTokens(String iText, String iSeparator) {
0417: int pos = iText.indexOf(iSeparator);
0418: if (pos == -1)
0419: return new String[] { iText };
0420: return new String[] { iText.substring(0, pos),
0421: iText.substring(pos + 1) };
0422: }
0423:
0424: public static Object setContentField(Component iComponent,
0425: Object iContent) {
0426: if (iComponent == null || iContent == null)
0427: return null;
0428: SchemaField field = (SchemaField) getComponentSchema(iComponent);
0429: Object value = SchemaHelper.getFieldValue(field, iContent);
0430:
0431: if (iComponent instanceof ContentComponent) {
0432: ObjectContext.getInstance().createObjectFormAssociation(
0433: value, null, (ContentComponent) iComponent);
0434: FormUtil.invokeOnShow(value);
0435: }
0436:
0437: setComponentValue(iComponent, value);
0438: return value;
0439: }
0440:
0441: public static void setComponentValue(Component iComponent,
0442: Object iValue) {
0443: if (iComponent == null)
0444: return;
0445: SchemaField field = (SchemaField) getComponentSchema(iComponent);
0446: String textValue;
0447: String renderName = null;
0448: if (field != null)
0449: renderName = (String) field.getFeature(
0450: ViewAspect.ASPECT_NAME, ViewBaseFeatures.RENDER);
0451: if (renderName == null)
0452: renderName = ViewConstants.RENDER_DEFAULT;
0453: if (iValue instanceof Date) {
0454: I18NAspect i18n = RomaApplicationContext.getInstance()
0455: .getBean(I18NAspect.class);
0456: if (renderName.equals(ViewConstants.RENDER_DATE))
0457: textValue = i18n.getDateFormat().format((Date) iValue);
0458: else if (renderName.equals(ViewConstants.RENDER_TIME))
0459: textValue = i18n.getTimeFormat().format((Date) iValue);
0460: else
0461: textValue = i18n.getDateTimeFormat().format(
0462: (Date) iValue);
0463: } else
0464: textValue = iValue != null ? iValue.toString() : "";
0465: if (iComponent instanceof TextComponent) {
0466: ((TextComponent) iComponent).setText(textValue);
0467: } else if (iComponent instanceof Label) {
0468: ((Label) iComponent).setText(textValue);
0469: } else if (iComponent instanceof CheckBoxEx) {
0470: if (iValue != null)
0471: ((CheckBoxEx) iComponent).setSelected((Boolean) iValue);
0472: } else if (iComponent instanceof DynaHtml) {
0473: ((DynaHtml) iComponent).setText(textValue);
0474: } else if (iComponent instanceof ImageIcon) {
0475: if (iValue != null) {
0476: ImageReference img = ObjectContext.getInstance()
0477: .getComponent(LookAndFeelManager.class)
0478: .getImage(iValue.toString());
0479: if (img != null) {
0480: ((ImageIcon) iComponent).setIcon(img);
0481: ((ImageIcon) iComponent).setWidth(img.getWidth());
0482: ((ImageIcon) iComponent).setHeight(img.getHeight());
0483: }
0484: }
0485: } else if (iComponent instanceof DynaDate) {
0486: Date date = (Date) iValue;
0487: Calendar cal = Calendar.getInstance(ObjectContext
0488: .getInstance().getComponent(SessionAspect.class)
0489: .getActiveLocale());
0490: if (date != null) {
0491: cal.setTime(date);
0492: ((DynaDate) iComponent).getComponent().setSelectedDate(
0493: cal);
0494: } else
0495: ((DynaDate) iComponent).getComponent().getTextField()
0496: .setText("");
0497: } else if (iComponent instanceof DynaTable) {
0498: DynaTable table = (DynaTable) iComponent;
0499: enableComponent(table, field);
0500: table.setContent(iValue);
0501: // SET THE VALUE CONTAINED IN THE SELECTION-FIELD (IF ANY)
0502: String selectionField = (String) field.getFeature(
0503: ViewAspect.ASPECT_NAME,
0504: ViewFieldFeatures.SELECTION_FIELD);
0505: if (selectionField != null) {
0506: Object selectionFieldValue = SchemaHelper
0507: .getFieldValue(field.getEntity(),
0508: selectionField, FormUtil
0509: .getComponentForm(iComponent)
0510: .getContent());
0511: if (selectionFieldValue != null
0512: && !(selectionFieldValue instanceof Object[]))
0513: // NO ARRAY FOUND: CREATE ON THE FLY
0514: selectionFieldValue = new Object[] { selectionFieldValue };
0515: table.setSelectedValues((Object[]) selectionFieldValue);
0516: }
0517: } else if (iComponent instanceof SelectFieldComponent) {
0518: setValueForSelect((SelectFieldComponent) iComponent,
0519: iValue, field);
0520: } else if (iComponent instanceof DynaListBox) {
0521: if (iComponent instanceof DynaListBox)
0522: ((DynaListBox) iComponent).setContent(iValue);
0523: fillListBox((ListBox) ((DynaListBox) iComponent)
0524: .getUnderlyingComponent(), iValue, field);
0525: } else if (iComponent instanceof DynaRadio) {
0526: fillRadio((DynaRadio) iComponent, iValue, field);
0527: } else if (iComponent instanceof ListBox) {
0528: fillListBox((ListBox) iComponent, iValue, field);
0529: } else if (iComponent instanceof DynaComponentSet) {
0530: ((DynaComponentSet) iComponent).addElements(iValue);
0531: } else if (iComponent instanceof DynaTabbedPane) {
0532: DynaTabbedPane tab = (DynaTabbedPane) iComponent;
0533: if (iValue instanceof Map) {
0534: Map map = (Map) iValue;
0535: Component childForm;
0536: SchemaObject schemaObject;
0537: tab.clear();
0538: for (Entry entry : (Set<Entry>) map.entrySet()) {
0539: if (entry.getValue() instanceof Component)
0540: childForm = (Component) entry.getValue();
0541: else {
0542: schemaObject = new SchemaObject(ObjectContext
0543: .getInstance().getComponent(
0544: SchemaManager.class)
0545: .getClassInfo(
0546: entry.getValue().getClass()
0547: .getSimpleName()),
0548: entry.getValue());
0549: childForm = (EntityForm) ObjectContext
0550: .getInstance().getComponent(
0551: FormPool.class).getForm(
0552: schemaObject, field,
0553: entry.getValue());
0554: }
0555: tab.addTab(entry.getKey().toString(), childForm);
0556: }
0557:
0558: String selectionField = (String) field.getFeature(
0559: ViewAspect.ASPECT_NAME,
0560: ViewFieldFeatures.SELECTION_FIELD);
0561: if (selectionField != null) {
0562: Object selectionFieldValue = SchemaHelper
0563: .getFieldValue(field.getEntity(),
0564: selectionField, FormUtil
0565: .getComponentForm(
0566: iComponent)
0567: .getContent());
0568: if (selectionFieldValue != null) {
0569: // SEARCH THE COMPONENT TO BE THE SELECTED ONE
0570: int i = 0;
0571: for (Entry entry : (Set<Entry>) map.entrySet()) {
0572: if (entry.getValue().equals(
0573: selectionFieldValue)) {
0574: tab.setSelectedIndex(i);
0575: break;
0576: }
0577: ++i;
0578: }
0579: }
0580: }
0581: }
0582: } else if (iComponent instanceof DynaTree) {
0583: Tree tree = (Tree) ((DynaTree) iComponent)
0584: .getUnderlyingComponent();
0585: if (iValue instanceof TreeNode) {
0586: TreeNode userObj = (TreeNode) iValue;
0587: DefaultMutableTreeNode rootNode = generateTreeNode(userObj);
0588: DefaultTreeModel model = new DefaultTreeModel(rootNode);
0589: tree.setModel(model);
0590: // SET THE VALUE CONTAINED IN THE SELECTION-FIELD (IF ANY)
0591: String selectionField = (String) field.getFeature(
0592: ViewAspect.ASPECT_NAME,
0593: ViewFieldFeatures.SELECTION_FIELD);
0594: if (selectionField != null) {
0595: Object selectionFieldValue = SchemaHelper
0596: .getFieldValue(field.getEntity(),
0597: selectionField, FormUtil
0598: .getComponentForm(
0599: iComponent)
0600: .getContent());
0601: if (selectionFieldValue != null
0602: && selectionFieldValue instanceof TreeNode) {
0603: TreePath[] paths = null;
0604: tree.setSelectionPaths(paths);
0605: }
0606: }
0607: }
0608: } else if (iComponent instanceof ContentComponent) {
0609: ContentComponent embedded = (ContentComponent) iComponent;
0610: // EMBEDDED ENTITY: RENDER CONTENT
0611: if (embedded.getContent() != null
0612: && iValue != null
0613: && !embedded.getContent().getClass().equals(
0614: iValue.getClass())) {
0615: embedded.setMetaDataSchema(new SchemaObject(
0616: ObjectContext.getInstance().getComponent(
0617: SchemaManager.class).getClassInfo(
0618: iValue.getClass().getSimpleName())));
0619: embedded.render();
0620: }
0621: if ((Boolean) field.getFeature(CoreAspect.ASPECT_NAME,
0622: CoreFieldFeatures.USE_RUNTIME_TYPE)) {
0623: SchemaObject schema = new SchemaObject(
0624: ObjectContext.getInstance().getComponent(
0625: SchemaManager.class).getClassInfo(
0626: iValue.getClass().getSimpleName()));
0627: embedded.setMetaDataSchema(schema);
0628: embedded.render();
0629: }
0630: embedded.setContent(iValue);
0631: embedded.renderContent();
0632: } else if (iComponent instanceof Button) {
0633: if (iValue != null) {
0634: String value = iValue.toString();
0635: if (value.startsWith(START_IMG_PATH)) {
0636: ImageReference img = ObjectContext.getInstance()
0637: .getComponent(LookAndFeelManager.class)
0638: .getImage(
0639: value.substring(START_IMG_PATH
0640: .length()));
0641: if (img != null) {
0642: ((Button) iComponent).setIcon(img);
0643: ((Button) iComponent).setText("");
0644: } else
0645: iComponent.setVisible(false);
0646: } else {
0647: String renderMode = (String) field.getFeature(
0648: ViewAspect.ASPECT_NAME,
0649: ViewBaseFeatures.RENDER);
0650: if (renderMode
0651: .equals(ViewConstants.RENDER_IMAGEBUTTON)) {
0652: } else if (renderMode
0653: .equals(ViewConstants.RENDER_LINK)) {
0654: ((Button) iComponent).setText(textValue);
0655: } else {
0656: String iValueToRender = (String) field
0657: .getFeature(ViewAspect.ASPECT_NAME,
0658: ViewBaseFeatures.LABEL);
0659: // BUTTON: SET THE TO-STRING VALUE AS TEXT
0660: ((Button) iComponent).setText(iValueToRender);
0661: }
0662: }
0663: }
0664: } else if (iComponent instanceof ProgressBar) {
0665: ((ProgressBar) iComponent).setValue((Integer) iValue);
0666: }
0667: }
0668:
0669: private static void setValueForSelect(SelectFieldComponent select,
0670: Object iValue, SchemaField field) {
0671: Object[] contentObjects = getObjectArray(select, iValue, field);
0672: // CREATE THE MODEL BASED ON ARRAY VALUES BUT AS FIRST ITEM NULL TO ALLOW
0673: // NULL SELECTION (ONLY FOR NON-PRIMITIVE-TYPES!)
0674: DefaultListModel model;
0675: model = new DefaultListModel(contentObjects);
0676: select.setModel(model);
0677: String selectionField = (String) field.getFeature(
0678: ViewAspect.ASPECT_NAME,
0679: ViewFieldFeatures.SELECTION_FIELD);
0680: // SET THE VALUE CONTAINED IN THE SELECTION-FIELD (IF ANY)
0681: if (selectionField != null) {
0682: // SchemaField selectionSchemaField =
0683: // SchemaHelper.getFieldName(field.getEntity(), selectionField);
0684: Boolean allowNulls = (Boolean) select
0685: .getProperty(METADATA_ALLOW_NULL);
0686: Object selectionFieldValue = SchemaHelper.getFieldValue(
0687: field.getEntity(), selectionField, FormUtil
0688: .getComponentForm(select).getContent());
0689: if (selectionFieldValue != null) {
0690: byte selectionMode = (Byte) field.getFeature(
0691: ViewAspect.ASPECT_NAME,
0692: ViewFieldFeatures.SELECTION_MODE);
0693: int index = -1;
0694: if (selectionMode == ViewFieldFeatures.SELECTION_MODE_INDEX) {
0695: if (selectionFieldValue instanceof Integer)
0696: index = (Integer) selectionFieldValue;
0697: else if (selectionFieldValue instanceof Short)
0698: index = (Short) selectionFieldValue;
0699: else if (selectionFieldValue instanceof Byte)
0700: index = (Byte) selectionFieldValue;
0701: if (allowNulls != null && allowNulls)
0702: index += 1;
0703: } else
0704: index = ((DefaultListModel) select.getModel())
0705: .indexOf(selectionFieldValue);
0706: select.setSelectedIndex(index);
0707: } else {
0708: // SET FIRST VALUE AS NULL
0709: if (allowNulls != null && allowNulls)
0710: select.setSelectedIndex(0);
0711: }
0712: }
0713: }
0714:
0715: /**
0716: * Method to generate Tree node recursively.
0717: *
0718: * @param userObj
0719: * @return
0720: */
0721: private static DefaultMutableTreeNode generateTreeNode(
0722: TreeNode userObj) {
0723: DefaultMutableTreeNode rootNode = new DefaultMutableTreeNode(
0724: userObj);
0725: DefaultMutableTreeNode childNode;
0726: if (userObj.getChildren() != null)
0727: for (Object child : userObj.getChildren()) {
0728: if (child instanceof TreeNode) {
0729: childNode = generateTreeNode((TreeNode) child);
0730: rootNode.add(childNode);
0731: }
0732: }
0733: return rootNode;
0734: }
0735:
0736: private static void fillRadio(DynaRadio iComponent,
0737: Object iContent, SchemaField iField) {
0738: Object[] contentObjects = getObjectArray(iComponent, iContent,
0739: iField);
0740: iComponent.addElements(contentObjects);
0741: // SET THE VALUE CONTAINED IN THE SELECTION-FIELD (IF ANY)
0742: String selectionField = (String) iField.getFeature(
0743: ViewAspect.ASPECT_NAME,
0744: ViewFieldFeatures.SELECTION_FIELD);
0745: if (selectionField != null && contentObjects.length > 0) {
0746: try {
0747: Object selectionFieldValue = SchemaHelper
0748: .getFieldValue(iField.getEntity(),
0749: selectionField, FormUtil
0750: .getComponentForm(iComponent)
0751: .getContent());
0752: if (selectionFieldValue != null) {
0753: byte selectionMode = (Byte) iField.getFeature(
0754: ViewAspect.ASPECT_NAME,
0755: ViewFieldFeatures.SELECTION_MODE);
0756: int index = -1;
0757: if (selectionMode == ViewFieldFeatures.SELECTION_MODE_INDEX) {
0758: if (selectionFieldValue instanceof Integer)
0759: index = (Integer) selectionFieldValue;
0760: else if (selectionFieldValue instanceof Short)
0761: index = (Short) selectionFieldValue;
0762: else if (selectionFieldValue instanceof Byte)
0763: index = (Byte) selectionFieldValue;
0764: } else {
0765: for (int i = 0; i < contentObjects.length; ++i)
0766: if (contentObjects[i]
0767: .equals(selectionFieldValue)) {
0768: index = i;
0769: break;
0770: }
0771: }
0772: if (index != -1) {
0773: iComponent.setSelected(index);
0774: }
0775: }
0776: } catch (Exception e) {
0777: throw new ConfigurationException("Selection field "
0778: + selectionField + " not accessible", e);
0779: }
0780: }
0781: }
0782:
0783: private static void fillListBox(ListBox iComponent,
0784: Object iContent, SchemaField iField) {
0785: Object[] contentObjects = getObjectArray(iComponent, iContent,
0786: iField);
0787: iComponent.setModel(new DefaultListModel(contentObjects));
0788: // SET THE VALUE CONTAINED IN THE SELECTION-FIELD (IF ANY)
0789: String selectionField = (String) iField.getFeature(
0790: ViewAspect.ASPECT_NAME,
0791: ViewFieldFeatures.SELECTION_FIELD);
0792: if (selectionField != null && contentObjects.length > 0) {
0793: try {
0794: Object selectionFieldValue = null;
0795: Object content = FormUtil.getComponentForm(iComponent)
0796: .getContent();
0797: if (content != null)
0798: selectionFieldValue = SchemaHelper
0799: .getFieldValue(iField.getEntity(),
0800: selectionField, content);
0801: if (selectionFieldValue != null) {
0802: byte selectionMode = (Byte) iField.getFeature(
0803: ViewAspect.ASPECT_NAME,
0804: ViewFieldFeatures.SELECTION_MODE);
0805: int index = -1;
0806: if (selectionMode == ViewFieldFeatures.SELECTION_MODE_INDEX) {
0807: if (selectionFieldValue instanceof Integer)
0808: index = (Integer) selectionFieldValue;
0809: else if (selectionFieldValue instanceof Short)
0810: index = (Short) selectionFieldValue;
0811: else if (selectionFieldValue instanceof Byte)
0812: index = (Byte) selectionFieldValue;
0813: } else {
0814: for (int i = 0; i < contentObjects.length; ++i)
0815: if (contentObjects[i]
0816: .equals(selectionFieldValue)) {
0817: index = i;
0818: break;
0819: }
0820: }
0821: if (index != -1)
0822: iComponent.setSelectedIndex(index);
0823: } else {
0824: iComponent.getSelectionModel().clearSelection();
0825: }
0826: } catch (Exception e) {
0827: throw new ConfigurationException(
0828: "Selection field "
0829: + selectionField
0830: + " not accessible. It was defined for binding of field: "
0831: + iField.getField());
0832: }
0833: }
0834: }
0835:
0836: private static Object[] getObjectArray(Component iComponent,
0837: Object iContent, SchemaField iField) {
0838: Object[] objects = null;
0839: if (iField.getTypeClass().equals(Boolean.class)) {
0840: objects = BOOLEAN_VALUES;
0841: } else {
0842: if (iField.getTypeClass().isArray())
0843: objects = (Object[]) iContent;
0844: else if (iContent instanceof Collection)
0845: objects = ((Collection) iContent).toArray();
0846: else if (iContent instanceof Map)
0847: objects = ((Map) iContent).values().toArray();
0848: }
0849: if (objects != null) {
0850: if (iField != null && !iField.getTypeClass().isPrimitive()
0851: && iComponent instanceof SelectFieldComponent) {
0852: Object[] tempObjects = new Object[objects.length + 1];
0853: tempObjects[0] = null;
0854: for (int i = 0; i < objects.length; ++i) {
0855: tempObjects[i + 1] = objects[i];
0856: }
0857: // NULLABLE FIELD: SET NULL AS FIRST ELEMENT
0858: iComponent.setProperty(METADATA_ALLOW_NULL, true);
0859: objects = tempObjects;
0860: }
0861: // REPLACE NULL OBJECT WITH THE NULL STRING TO AVOID ERROR ON ECHO2
0862: // RENDERING
0863: objects = getNotNullElementArray(objects);
0864: } else
0865: objects = new Object[0];
0866: return objects;
0867: }
0868:
0869: private static Object[] getNotNullElementArray(Object[] contentList) {
0870: Object[] elementsToInsert = new Object[contentList.length];
0871: Object current;
0872: for (int i = 0; i < contentList.length; ++i) {
0873: current = contentList[i];
0874: if (current == null || current.toString() == null)
0875: current = "";
0876: elementsToInsert[i] = current;
0877: }
0878: return elementsToInsert;
0879: }
0880:
0881: public static Object getContentField(Component iComponent) {
0882: if (iComponent == null)
0883: return null;
0884: Object value = null;
0885: try {
0886: if (iComponent instanceof TextComponent)
0887: value = ((TextComponent) iComponent).getText();
0888: else if (iComponent instanceof Label)
0889: value = ((Label) iComponent).getText();
0890: else if (iComponent instanceof DynaHtml)
0891: value = ((DynaHtml) iComponent).getText();
0892: else if (iComponent instanceof DynaHtml)
0893: value = ((ImageIcon) iComponent).getIcon();
0894: else if (iComponent instanceof CheckBox)
0895: value = ((CheckBox) iComponent).isSelected();
0896: else if (iComponent instanceof ComposedComponent)
0897: value = ((ComposedComponent) iComponent)
0898: .getTextComponent().getText();
0899: else if (iComponent instanceof SelectComponent) {
0900: SelectComponent select = (SelectComponent) iComponent;
0901: int index = select.getSelectedIndex();
0902: if (index < 0)
0903: value = null;
0904: else {
0905: Object selection = ((DefaultListModel) select
0906: .getModel()).get(index);
0907: Object allowNull = iComponent
0908: .getProperty(METADATA_ALLOW_NULL);
0909: if (allowNull != null && ((Boolean) allowNull)
0910: && index <= 0)
0911: // FIRST ONE NULL ELEMENT SELECTED
0912: value = null;
0913: else
0914: value = selection;
0915: }
0916: } else if (iComponent instanceof DynaRadio) {
0917: DynaRadio radio = (DynaRadio) iComponent;
0918: int index = radio.getSelectedIndex();
0919: if (index < 0)
0920: value = null;
0921: else {
0922: value = radio.getElement(index);
0923: }
0924: } else if (iComponent instanceof DynaDate)
0925: value = ((DynaDate) iComponent).getComponent()
0926: .getSelectedDate().getTime();
0927: else if (iComponent instanceof DynaTable)
0928: value = ((DynaTable) iComponent).getContent();
0929: else if (iComponent instanceof ProgressBar)
0930: value = ((ProgressBar) iComponent).getValue();
0931: else if (iComponent instanceof Tree) {
0932: Tree tree = (Tree) iComponent;
0933: if (!tree.isSelectionEmpty())
0934: value = ((DefaultMutableTreeNode) tree
0935: .getSelectionPath().getLastPathComponent())
0936: .getUserObject();
0937: }
0938: } catch (Throwable e) {
0939: log.error("[FormUtil.getContentField] Error", e);
0940: }
0941: return value;
0942: }
0943:
0944: public static void setMetadata(Component iComponent,
0945: ContentComponent iForm, SchemaElement iElement) {
0946: if (iComponent != null) {
0947: iComponent.setProperty(METADATA_FORM_NAME, iForm);
0948: iComponent.setProperty(METADATA_SCHEMA_NAME, iElement);
0949: if (iComponent.getProperty(METADATA_COMPONENT_OWNER) == null)
0950: // COMPONENT OWNER NOT SETTED, SET TO CURRENT COMPONENT
0951: iComponent.setProperty(METADATA_COMPONENT_OWNER,
0952: iComponent);
0953: }
0954: }
0955:
0956: public static ContentForm getComponentForm(Component iComponent) {
0957: return (ContentForm) iComponent.getProperty(METADATA_FORM_NAME);
0958: }
0959:
0960: public static SchemaElement getComponentSchema(Component iComponent) {
0961: return (SchemaElement) iComponent
0962: .getProperty(METADATA_SCHEMA_NAME);
0963: }
0964:
0965: public static Component getComponentOwner(Component iComponent) {
0966: return (Component) iComponent
0967: .getProperty(METADATA_COMPONENT_OWNER);
0968: }
0969:
0970: public static void enableComponent(Component iComponent,
0971: SchemaElement iElement) {
0972: if (iComponent == null)
0973: return;
0974: SessionInfo sessInfo = ObjectContext.getInstance()
0975: .getComponent(SessionAspect.class)
0976: .getActiveSessionInfo();
0977: SessionAccount account = sessInfo != null ? sessInfo
0978: .getAccount() : null;
0979: Boolean enabled;
0980: if (account != null) {
0981: String elementName = iElement.getEntity().getSchemaClass()
0982: .getName()
0983: + "." + iElement.getName() + ENABLED_SUFFIX;
0984: enabled = ObjectContext.getInstance().getComponent(
0985: AuthenticationAspect.class).allow(
0986: account.getProfile(), elementName);
0987: // FOUND ENABLING MODE IN PROFILE: SET IT
0988: iComponent.setEnabled(enabled);
0989: }
0990: enabled = iElement != null ? (Boolean) iElement.getFeature(
0991: ViewAspect.ASPECT_NAME, ViewElementFeatures.ENABLED)
0992: : null;
0993: if (enabled != null)
0994: iComponent.setEnabled(enabled);
0995: }
0996:
0997: /**
0998: * Invoke the onShow() event assuring to invoke listeners.
0999: *
1000: * @param content
1001: * POJO where to invoke the onShow() method
1002: */
1003: public static void invokeOnShow(Object content) {
1004: if (content == null)
1005: return;
1006:
1007: if (content instanceof ViewCallback) {
1008: ((ViewCallback) content).onShow();
1009: }
1010: }
1011: }
|