0001: /*
0002: * $Id: ModelForm.java,v 1.6 2004/01/17 03:57:46 byersa Exp $
0003: *
0004: * Copyright (c) 2003 The Open For Business Project - www.ofbiz.org
0005: *
0006: * Permission is hereby granted, free of charge, to any person obtaining a
0007: * copy of this software and associated documentation files (the "Software"),
0008: * to deal in the Software without restriction, including without limitation
0009: * the rights to use, copy, modify, merge, publish, distribute, sublicense,
0010: * and/or sell copies of the Software, and to permit persons to whom the
0011: * Software is furnished to do so, subject to the following conditions:
0012: *
0013: * The above copyright notice and this permission notice shall be included
0014: * in all copies or substantial portions of the Software.
0015: *
0016: * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
0017: * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
0018: * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
0019: * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
0020: * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT
0021: * OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR
0022: * THE USE OR OTHER DEALINGS IN THE SOFTWARE.
0023: */
0024: package org.ofbiz.content.widget.form;
0025:
0026: import java.util.ArrayList;
0027: import java.util.HashMap;
0028: import java.util.Iterator;
0029: import java.util.LinkedList;
0030: import java.util.List;
0031: import java.util.Map;
0032: import java.util.Set;
0033: import java.util.TreeSet;
0034:
0035: import org.ofbiz.base.util.BshUtil;
0036: import org.ofbiz.base.util.Debug;
0037: import org.ofbiz.base.util.FlexibleMapAccessor;
0038: import org.ofbiz.base.util.UtilValidate;
0039: import org.ofbiz.base.util.UtilXml;
0040: import org.ofbiz.entity.GenericDelegator;
0041: import org.ofbiz.entity.model.ModelEntity;
0042: import org.ofbiz.entity.model.ModelField;
0043: import org.ofbiz.service.GenericServiceException;
0044: import org.ofbiz.service.LocalDispatcher;
0045: import org.ofbiz.service.ModelParam;
0046: import org.ofbiz.service.ModelService;
0047: import org.w3c.dom.Element;
0048:
0049: import bsh.EvalError;
0050: import bsh.Interpreter;
0051:
0052: /**
0053: * Widget Library - Form model class
0054: *
0055: * @author <a href="mailto:jonesde@ofbiz.org">David E. Jones</a>
0056: * @author <a href="mailto:byersa@automationgroups.com">Al Byers</a>
0057: * @version $Revision: 1.6 $
0058: * @since 2.2
0059: */
0060: public class ModelForm {
0061:
0062: public static final String module = ModelForm.class.getName();
0063:
0064: protected GenericDelegator delegator;
0065: protected LocalDispatcher dispatcher;
0066:
0067: protected String name;
0068: protected String type;
0069: protected String target;
0070: protected String title;
0071: protected String tooltip;
0072: protected String listName;
0073: protected String listEntryName;
0074: protected FlexibleMapAccessor defaultMapName;
0075: protected String defaultEntityName;
0076: protected String defaultServiceName;
0077: protected String defaultTitleStyle;
0078: protected String defaultWidgetStyle;
0079: protected String defaultTooltipStyle;
0080: protected String itemIndexSeparator;
0081: protected String paginateTarget;
0082:
0083: protected List altTargets = new LinkedList();
0084: protected List autoFieldsServices = new LinkedList();
0085: protected List autoFieldsEntities = new LinkedList();
0086: protected List sortOrderFields = new LinkedList();
0087:
0088: /** This List will contain one copy of each field for each field name in the order
0089: * they were encountered in the service, entity, or form definition; field definitions
0090: * with constraints will also be in this list but may appear multiple times for the same
0091: * field name.
0092: *
0093: * When rendering the form the order in this list should be following and it should not be
0094: * necessary to use the Map. The Map is used when loading the form definition to keep the
0095: * list clean and implement the override features for field definitions.
0096: */
0097: protected List fieldList = new LinkedList();
0098:
0099: /** This Map is keyed with the field name and has a ModelFormField for the value; fields
0100: * with conditions will not be put in this Map so field definition overrides for fields
0101: * with conditions is not possible.
0102: */
0103: protected Map fieldMap = new HashMap();
0104:
0105: // ===== CONSTRUCTORS =====
0106: /** Default Constructor */
0107: public ModelForm() {
0108: }
0109:
0110: /** XML Constructor */
0111: public ModelForm(Element formElement, GenericDelegator delegator,
0112: LocalDispatcher dispatcher) {
0113: this .delegator = delegator;
0114: this .dispatcher = dispatcher;
0115:
0116: // check if there is a parent form to inherit from
0117: String parentResource = formElement
0118: .getAttribute("extends-resource");
0119: String parentForm = formElement.getAttribute("extends");
0120: //TODO: Modify this to allow for extending a form with the same name but different resource
0121: if (parentForm.length() > 0
0122: && !parentForm.equals(formElement.getAttribute("name"))) {
0123: ModelForm parent = null;
0124: // check if we have a resource name (part of the string before the ?)
0125: if (parentResource.length() > 0) {
0126: try {
0127: parent = FormFactory.getFormFromClass(
0128: parentResource, parentForm, delegator,
0129: dispatcher);
0130: } catch (Exception e) {
0131: Debug.logError(e,
0132: "Failed to load parent form definition '"
0133: + parentForm + "' at resource '"
0134: + parentResource + "'", module);
0135: }
0136: } else {
0137: // try to find a form definition in the same file
0138: Element rootElement = formElement.getOwnerDocument()
0139: .getDocumentElement();
0140: List formElements = UtilXml.childElementList(
0141: rootElement, "form");
0142: //Uncomment below to add support for abstract forms
0143: //formElements.addAll(UtilXml.childElementList(rootElement, "abstract-form"));
0144: Iterator formElementIter = formElements.iterator();
0145: while (formElementIter.hasNext()) {
0146: Element formElementEntry = (Element) formElementIter
0147: .next();
0148: if (formElementEntry.getAttribute("name").equals(
0149: parentForm)) {
0150: parent = new ModelForm(formElementEntry,
0151: delegator, dispatcher);
0152: break;
0153: }
0154: }
0155: if (parent == null) {
0156: Debug.logError(
0157: "Failed to find parent form defenition '"
0158: + parentForm
0159: + "' in same document.", module);
0160: }
0161: }
0162:
0163: if (parent != null) {
0164: this .type = parent.type;
0165: this .target = parent.target;
0166: this .title = parent.title;
0167: this .tooltip = parent.tooltip;
0168: this .listName = parent.listName;
0169: this .listEntryName = parent.listEntryName;
0170: this .tooltip = parent.tooltip;
0171: this .defaultEntityName = parent.defaultEntityName;
0172: this .defaultServiceName = parent.defaultServiceName;
0173: this .defaultTitleStyle = parent.defaultTitleStyle;
0174: this .defaultWidgetStyle = parent.defaultWidgetStyle;
0175: this .defaultTooltipStyle = parent.defaultTooltipStyle;
0176: this .itemIndexSeparator = parent.itemIndexSeparator;
0177: this .fieldList = parent.fieldList;
0178: this .fieldMap = parent.fieldMap;
0179: }
0180: }
0181:
0182: this .name = formElement.getAttribute("name");
0183: if (this .type == null || formElement.hasAttribute("type"))
0184: this .type = formElement.getAttribute("type");
0185: if (this .target == null || formElement.hasAttribute("target"))
0186: this .target = formElement.getAttribute("target");
0187: if (this .title == null || formElement.hasAttribute("title"))
0188: this .title = formElement.getAttribute("title");
0189: if (this .tooltip == null || formElement.hasAttribute("tooltip"))
0190: this .tooltip = formElement.getAttribute("tooltip");
0191: if (this .listName == null
0192: || formElement.hasAttribute("listName"))
0193: this .listName = formElement.getAttribute("list-name");
0194: if (this .listEntryName == null
0195: || formElement.hasAttribute("listEntryName"))
0196: this .listEntryName = formElement
0197: .getAttribute("list-entry-name");
0198: if (this .defaultMapName == null
0199: || formElement.hasAttribute("default-map-name"))
0200: this .setDefaultMapName(formElement
0201: .getAttribute("default-map-name"));
0202: if (this .defaultEntityName == null
0203: || formElement.hasAttribute("defaultEntityName"))
0204: this .defaultEntityName = formElement
0205: .getAttribute("default-entity-name");
0206: if (this .defaultServiceName == null
0207: || formElement.hasAttribute("defaultServiceName"))
0208: this .defaultServiceName = formElement
0209: .getAttribute("default-service-name");
0210: if (this .defaultTitleStyle == null
0211: || formElement.hasAttribute("defaultTitleStyle"))
0212: this .defaultTitleStyle = formElement
0213: .getAttribute("default-title-style");
0214: if (this .defaultWidgetStyle == null
0215: || formElement.hasAttribute("defaultWidgetStyle"))
0216: this .defaultWidgetStyle = formElement
0217: .getAttribute("default-widget-style");
0218: if (this .defaultTooltipStyle == null
0219: || formElement.hasAttribute("defaultTooltipStyle"))
0220: this .defaultTooltipStyle = formElement
0221: .getAttribute("default-tooltip-style");
0222: if (this .itemIndexSeparator == null
0223: || formElement.hasAttribute("itemIndexSeparator"))
0224: this .itemIndexSeparator = formElement
0225: .getAttribute("item-index-separator");
0226: if (this .paginateTarget == null
0227: || formElement.hasAttribute("paginateTarget"))
0228: this .paginateTarget = formElement
0229: .getAttribute("paginate-target");
0230:
0231: // alt-target
0232: List altTargetElements = UtilXml.childElementList(formElement,
0233: "alt-target");
0234: Iterator altTargetElementIter = altTargetElements.iterator();
0235: while (altTargetElementIter.hasNext()) {
0236: Element altTargetElement = (Element) altTargetElementIter
0237: .next();
0238: AltTarget altTarget = new AltTarget(altTargetElement);
0239: this .addAltTarget(altTarget);
0240: }
0241:
0242: // auto-fields-service
0243: List autoFieldsServiceElements = UtilXml.childElementList(
0244: formElement, "auto-fields-service");
0245: Iterator autoFieldsServiceElementIter = autoFieldsServiceElements
0246: .iterator();
0247: while (autoFieldsServiceElementIter.hasNext()) {
0248: Element autoFieldsServiceElement = (Element) autoFieldsServiceElementIter
0249: .next();
0250: AutoFieldsService autoFieldsService = new AutoFieldsService(
0251: autoFieldsServiceElement);
0252: this
0253: .addAutoFieldsFromService(autoFieldsService,
0254: dispatcher);
0255: }
0256:
0257: // auto-fields-entity
0258: List autoFieldsEntityElements = UtilXml.childElementList(
0259: formElement, "auto-fields-entity");
0260: Iterator autoFieldsEntityElementIter = autoFieldsEntityElements
0261: .iterator();
0262: while (autoFieldsEntityElementIter.hasNext()) {
0263: Element autoFieldsEntityElement = (Element) autoFieldsEntityElementIter
0264: .next();
0265: AutoFieldsEntity autoFieldsEntity = new AutoFieldsEntity(
0266: autoFieldsEntityElement);
0267: this .addAutoFieldsFromEntity(autoFieldsEntity, delegator);
0268: }
0269:
0270: // read in add field defs, add/override one by one using the fieldList and fieldMap
0271: List fieldElements = UtilXml.childElementList(formElement,
0272: "field");
0273: Iterator fieldElementIter = fieldElements.iterator();
0274: while (fieldElementIter.hasNext()) {
0275: Element fieldElement = (Element) fieldElementIter.next();
0276: ModelFormField modelFormField = new ModelFormField(
0277: fieldElement, this );
0278: modelFormField = this .addUpdateField(modelFormField);
0279: //Debug.logInfo("Added field " + modelFormField.getName() + " from def, mapName=" + modelFormField.getMapName(), module);
0280: }
0281:
0282: // get the sort-order
0283: Element sortOrderElement = UtilXml.firstChildElement(
0284: formElement, "sort-order");
0285: if (sortOrderElement != null) {
0286: // read in sort-field
0287: List sortFieldElements = UtilXml.childElementList(
0288: sortOrderElement, "sort-field");
0289: Iterator sortFieldElementIter = sortFieldElements
0290: .iterator();
0291: while (sortFieldElementIter.hasNext()) {
0292: Element sortFieldElement = (Element) sortFieldElementIter
0293: .next();
0294: this .sortOrderFields.add(sortFieldElement
0295: .getAttribute("name"));
0296: }
0297: }
0298:
0299: // reorder fields according to sort order
0300: if (sortOrderFields.size() > 0) {
0301: List sortedFields = new ArrayList(this .fieldList.size());
0302: Iterator sortOrderFieldIter = this .sortOrderFields
0303: .iterator();
0304: while (sortOrderFieldIter.hasNext()) {
0305: String fieldName = (String) sortOrderFieldIter.next();
0306: if (UtilValidate.isEmpty(fieldName)) {
0307: continue;
0308: }
0309:
0310: // get all fields with the given name from the existing list and put them in the sorted list
0311: Iterator fieldIter = this .fieldList.iterator();
0312: while (fieldIter.hasNext()) {
0313: ModelFormField modelFormField = (ModelFormField) fieldIter
0314: .next();
0315: if (fieldName.equals(modelFormField.getName())) {
0316: // matched the name; remove from the original last and add to the sorted list
0317: fieldIter.remove();
0318: sortedFields.add(modelFormField);
0319: }
0320: }
0321: }
0322: // now add all of the rest of the fields from fieldList, ie those that were not explicitly listed in the sort order
0323: sortedFields.addAll(this .fieldList);
0324: // sortedFields all done, set fieldList
0325: this .fieldList = sortedFields;
0326: }
0327: }
0328:
0329: /**
0330: * add/override modelFormField using the fieldList and fieldMap
0331: *
0332: * @return The same ModelFormField, or if merged with an existing field, the existing field.
0333: */
0334: public ModelFormField addUpdateField(ModelFormField modelFormField) {
0335: if (!modelFormField.isUseWhenEmpty()) {
0336: // is a conditional field, add to the List but don't worry about the Map
0337: //for adding to list, see if there is another field with that name in the list and if so, put it before that one
0338: boolean inserted = false;
0339: for (int i = 0; i < this .fieldList.size(); i++) {
0340: ModelFormField curField = (ModelFormField) this .fieldList
0341: .get(i);
0342: if (curField.getName() != null
0343: && curField.getName().equals(
0344: modelFormField.getName())) {
0345: this .fieldList.add(i, modelFormField);
0346: inserted = true;
0347: break;
0348: }
0349: }
0350: if (!inserted) {
0351: this .fieldList.add(modelFormField);
0352: }
0353: return modelFormField;
0354: } else {
0355:
0356: // not a conditional field, see if a named field exists in Map
0357: ModelFormField existingField = (ModelFormField) this .fieldMap
0358: .get(modelFormField.getName());
0359: if (existingField != null) {
0360: // does exist, update the field by doing a merge/override
0361: existingField
0362: .mergeOverrideModelFormField(modelFormField);
0363: return existingField;
0364: } else {
0365: // does not exist, add to List and Map
0366: this .fieldList.add(modelFormField);
0367: this .fieldMap.put(modelFormField.getName(),
0368: modelFormField);
0369: return modelFormField;
0370: }
0371: }
0372: }
0373:
0374: public void addAltTarget(AltTarget altTarget) {
0375: altTargets.add(altTarget);
0376: }
0377:
0378: public void addAutoFieldsFromService(
0379: AutoFieldsService autoFieldsService,
0380: LocalDispatcher dispatcher) {
0381: autoFieldsServices.add(autoFieldsService);
0382:
0383: // read service def and auto-create fields
0384: ModelService modelService = null;
0385: try {
0386: modelService = dispatcher.getDispatchContext()
0387: .getModelService(autoFieldsService.serviceName);
0388: } catch (GenericServiceException e) {
0389: String errmsg = "Error finding Service with name "
0390: + autoFieldsService.serviceName
0391: + " for auto-fields-service in a form widget";
0392: Debug.logError(e, errmsg, module);
0393: throw new IllegalArgumentException(errmsg);
0394: }
0395:
0396: List modelParams = modelService.getInModelParamList();
0397: Iterator modelParamIter = modelParams.iterator();
0398: while (modelParamIter.hasNext()) {
0399: ModelParam modelParam = (ModelParam) modelParamIter.next();
0400: // skip auto params that the service engine populates...
0401: if ("userLogin".equals(modelParam.name)
0402: || "locale".equals(modelParam.name)) {
0403: continue;
0404: }
0405: if (modelParam.formDisplay) {
0406: if (UtilValidate.isNotEmpty(modelParam.entityName)
0407: && UtilValidate
0408: .isNotEmpty(modelParam.fieldName)) {
0409: ModelEntity modelEntity = delegator
0410: .getModelEntity(modelParam.entityName);
0411: if (modelEntity != null) {
0412: ModelField modelField = modelEntity
0413: .getField(modelParam.fieldName);
0414: if (modelField != null) {
0415: // okay, populate using the entity field info...
0416: ModelFormField modelFormField = this
0417: .addFieldFromEntityField(
0418: modelEntity,
0419: modelField,
0420: autoFieldsService.defaultFieldType);
0421: if (UtilValidate
0422: .isNotEmpty(autoFieldsService.mapName)) {
0423: modelFormField
0424: .setMapName(autoFieldsService.mapName);
0425: }
0426:
0427: // continue to skip creating based on service param
0428: continue;
0429: }
0430: }
0431: }
0432:
0433: ModelFormField modelFormField = this
0434: .addFieldFromServiceParam(modelService,
0435: modelParam,
0436: autoFieldsService.defaultFieldType);
0437: if (UtilValidate.isNotEmpty(autoFieldsService.mapName)) {
0438: modelFormField
0439: .setMapName(autoFieldsService.mapName);
0440: }
0441: }
0442: }
0443: }
0444:
0445: public ModelFormField addFieldFromServiceParam(
0446: ModelService modelService, ModelParam modelParam,
0447: String defaultFieldType) {
0448: // create field def from service param def
0449: ModelFormField newFormField = new ModelFormField(this );
0450: newFormField.setName(modelParam.name);
0451: newFormField.setServiceName(modelService.name);
0452: newFormField.setAttributeName(modelParam.name);
0453: newFormField.setTitle(modelParam.formLabel);
0454: newFormField.induceFieldInfoFromServiceParam(modelService,
0455: modelParam, defaultFieldType);
0456: return this .addUpdateField(newFormField);
0457: }
0458:
0459: public void addAutoFieldsFromEntity(
0460: AutoFieldsEntity autoFieldsEntity,
0461: GenericDelegator delegator) {
0462: autoFieldsEntities.add(autoFieldsEntity);
0463: // read entity def and auto-create fields
0464: ModelEntity modelEntity = delegator
0465: .getModelEntity(autoFieldsEntity.entityName);
0466: if (modelEntity == null) {
0467: throw new IllegalArgumentException(
0468: "Error finding Entity with name "
0469: + autoFieldsEntity.entityName
0470: + " for auto-fields-entity in a form widget");
0471: }
0472:
0473: Iterator modelFieldIter = modelEntity.getFieldsIterator();
0474: while (modelFieldIter.hasNext()) {
0475: ModelField modelField = (ModelField) modelFieldIter.next();
0476: if (modelField.getIsAutoCreatedInternal()) {
0477: // don't ever auto-add these, should only be added if explicitly referenced
0478: continue;
0479: }
0480: ModelFormField modelFormField = this
0481: .addFieldFromEntityField(modelEntity, modelField,
0482: autoFieldsEntity.defaultFieldType);
0483: if (UtilValidate.isNotEmpty(autoFieldsEntity.mapName)) {
0484: modelFormField.setMapName(autoFieldsEntity.mapName);
0485: }
0486: }
0487: }
0488:
0489: public ModelFormField addFieldFromEntityField(
0490: ModelEntity modelEntity, ModelField modelField,
0491: String defaultFieldType) {
0492: // create field def from entity field def
0493: ModelFormField newFormField = new ModelFormField(this );
0494: newFormField.setName(modelField.getName());
0495: newFormField.setEntityName(modelEntity.getEntityName());
0496: newFormField.setFieldName(modelField.getName());
0497: newFormField.induceFieldInfoFromEntityField(modelEntity,
0498: modelField, defaultFieldType);
0499: return this .addUpdateField(newFormField);
0500: }
0501:
0502: /**
0503: * Renders this form to a String, i.e. in a text format, as defined with the
0504: * FormStringRenderer implementation.
0505: *
0506: * @param buffer The StringBuffer that the form text will be written to
0507: * @param context Map containing the form context; the following are
0508: * reserved words in this context: parameters (Map), isError (Boolean),
0509: * itemIndex (Integer, for lists only, otherwise null), bshInterpreter,
0510: * formName (String, optional alternate name for form, defaults to the
0511: * value of the name attribute)
0512: * @param formStringRenderer An implementation of the FormStringRenderer
0513: * interface that is responsible for the actual text generation for
0514: * different form elements; implementing you own makes it possible to
0515: * use the same form definitions for many types of form UIs
0516: */
0517: public void renderFormString(StringBuffer buffer, Map context,
0518: FormStringRenderer formStringRenderer) {
0519: // if this is a list form, don't useRequestParameters
0520: if ("list".equals(this .type) || "multi".equals(this .type)) {
0521: context.put("useRequestParameters", Boolean.FALSE);
0522: }
0523:
0524: // find the highest position number to get the max positions used
0525: int positions = 1;
0526: Iterator fieldIter = this .fieldList.iterator();
0527: while (fieldIter.hasNext()) {
0528: ModelFormField modelFormField = (ModelFormField) fieldIter
0529: .next();
0530: int curPos = modelFormField.getPosition();
0531: if (curPos > positions) {
0532: positions = curPos;
0533: }
0534: }
0535:
0536: if ("single".equals(this .type)) {
0537: this .renderSingleFormString(buffer, context,
0538: formStringRenderer, positions);
0539: } else if ("list".equals(this .type)) {
0540: this .renderListFormString(buffer, context,
0541: formStringRenderer, positions);
0542: } else if ("multi".equals(this .type)) {
0543: this .renderMultiFormString(buffer, context,
0544: formStringRenderer, positions);
0545: } else if ("upload".equals(this .type)) {
0546: this .renderSingleFormString(buffer, context,
0547: formStringRenderer, positions);
0548: } else {
0549: throw new IllegalArgumentException("The type "
0550: + this .getType()
0551: + " is not supported for form with name "
0552: + this .getName());
0553: }
0554: }
0555:
0556: public void renderSingleFormString(StringBuffer buffer,
0557: Map context, FormStringRenderer formStringRenderer,
0558: int positions) {
0559: Iterator fieldIter = null;
0560:
0561: Set alreadyRendered = new TreeSet();
0562:
0563: // render form open
0564: formStringRenderer.renderFormOpen(buffer, context, this );
0565:
0566: // render all hidden & ignored fields
0567: this .renderHiddenIgnoredFields(buffer, context,
0568: formStringRenderer, alreadyRendered);
0569:
0570: // render formatting wrapper open
0571: formStringRenderer.renderFormatSingleWrapperOpen(buffer,
0572: context, this );
0573:
0574: // render each field row, except hidden & ignored rows
0575: fieldIter = this .fieldList.iterator();
0576: ModelFormField lastFormField = null;
0577: ModelFormField currentFormField = null;
0578: ModelFormField nextFormField = null;
0579: if (fieldIter.hasNext()) {
0580: currentFormField = (ModelFormField) fieldIter.next();
0581: }
0582: if (fieldIter.hasNext()) {
0583: nextFormField = (ModelFormField) fieldIter.next();
0584: }
0585:
0586: boolean isFirstPass = true;
0587: while (currentFormField != null) {
0588: // do the check/get next stuff at the beginning so we can still use the continue stuff easily
0589: // don't do it on the first pass though...
0590: if (isFirstPass) {
0591: isFirstPass = false;
0592: } else {
0593: if (fieldIter.hasNext()) {
0594: // at least two loops left
0595: lastFormField = currentFormField;
0596: currentFormField = nextFormField;
0597: nextFormField = (ModelFormField) fieldIter.next();
0598: } else if (nextFormField != null) {
0599: // okay, just one loop left
0600: lastFormField = currentFormField;
0601: currentFormField = nextFormField;
0602: nextFormField = null;
0603: } else {
0604: // at the end...
0605: lastFormField = currentFormField;
0606: currentFormField = null;
0607: // nextFormField is already null
0608: break;
0609: }
0610: }
0611:
0612: ModelFormField.FieldInfo fieldInfo = currentFormField
0613: .getFieldInfo();
0614: if (fieldInfo.getFieldType() == ModelFormField.FieldInfo.HIDDEN
0615: || fieldInfo.getFieldType() == ModelFormField.FieldInfo.IGNORED) {
0616: continue;
0617: }
0618: if (alreadyRendered.contains(currentFormField.getName())) {
0619: continue;
0620: }
0621: //Debug.logInfo("In single form evaluating use-when for field " + currentFormField.getName() + ": " + currentFormField.getUseWhen(), module);
0622: if (!currentFormField.shouldUse(context)) {
0623: continue;
0624: }
0625: alreadyRendered.add(currentFormField.getName());
0626:
0627: boolean stayingOnRow = false;
0628: if (lastFormField != null) {
0629: if (lastFormField.getPosition() >= currentFormField
0630: .getPosition()) {
0631: // moving to next row
0632: stayingOnRow = false;
0633: } else {
0634: // staying on same row
0635: stayingOnRow = true;
0636: }
0637: }
0638:
0639: int positionSpan = 1;
0640: Integer nextPositionInRow = null;
0641: if (nextFormField != null) {
0642: if (nextFormField.getPosition() > currentFormField
0643: .getPosition()) {
0644: positionSpan = nextFormField.getPosition()
0645: - currentFormField.getPosition() - 1;
0646: nextPositionInRow = new Integer(nextFormField
0647: .getPosition());
0648: } else {
0649: positionSpan = positions
0650: - currentFormField.getPosition();
0651: if (!stayingOnRow
0652: && nextFormField.getPosition() > 1) {
0653: // TODO: here is a weird case where it is setup such
0654: //that the first position(s) in the row are skipped
0655: // not sure what to do about this right now...
0656: }
0657: }
0658: }
0659:
0660: if (stayingOnRow) {
0661: // no spacer cell, might add later though...
0662: //formStringRenderer.renderFormatFieldRowSpacerCell(buffer, context, currentFormField);
0663: } else {
0664: if (lastFormField != null) {
0665: // render row formatting close
0666: formStringRenderer.renderFormatFieldRowClose(
0667: buffer, context, this );
0668: }
0669:
0670: // render row formatting open
0671: formStringRenderer.renderFormatFieldRowOpen(buffer,
0672: context, this );
0673: }
0674:
0675: // render title formatting open
0676: formStringRenderer.renderFormatFieldRowTitleCellOpen(
0677: buffer, context, currentFormField);
0678:
0679: // render title (unless this is a submit or a reset field)
0680: if (fieldInfo.getFieldType() != ModelFormField.FieldInfo.SUBMIT
0681: && fieldInfo.getFieldType() != ModelFormField.FieldInfo.RESET) {
0682: formStringRenderer.renderFieldTitle(buffer, context,
0683: currentFormField);
0684: } else {
0685: formStringRenderer.renderFormatEmptySpace(buffer,
0686: context, this );
0687: }
0688:
0689: // render title formatting close
0690: formStringRenderer.renderFormatFieldRowTitleCellClose(
0691: buffer, context, currentFormField);
0692:
0693: // render separator
0694: formStringRenderer.renderFormatFieldRowSpacerCell(buffer,
0695: context, currentFormField);
0696:
0697: // render widget formatting open
0698: formStringRenderer.renderFormatFieldRowWidgetCellOpen(
0699: buffer, context, currentFormField, positions,
0700: positionSpan, nextPositionInRow);
0701:
0702: // render widget
0703: currentFormField.renderFieldString(buffer, context,
0704: formStringRenderer);
0705:
0706: // render widget formatting close
0707: formStringRenderer.renderFormatFieldRowWidgetCellClose(
0708: buffer, context, currentFormField, positions,
0709: positionSpan, nextPositionInRow);
0710:
0711: }
0712: // always render row formatting close after the end
0713: formStringRenderer.renderFormatFieldRowClose(buffer, context,
0714: this );
0715:
0716: // render formatting wrapper close
0717: formStringRenderer.renderFormatSingleWrapperClose(buffer,
0718: context, this );
0719:
0720: // render form close
0721: formStringRenderer.renderFormClose(buffer, context, this );
0722: }
0723:
0724: public void renderListFormString(StringBuffer buffer, Map context,
0725: FormStringRenderer formStringRenderer, int positions) {
0726: // render list/tabular type forms
0727:
0728: // render formatting wrapper open
0729: formStringRenderer.renderFormatListWrapperOpen(buffer, context,
0730: this );
0731:
0732: // ===== render header row =====
0733: this .renderHeaderRow(buffer, context, formStringRenderer);
0734:
0735: // ===== render the item rows =====
0736: this .renderItemRows(buffer, context, formStringRenderer, true);
0737:
0738: // render formatting wrapper close
0739: formStringRenderer.renderFormatListWrapperClose(buffer,
0740: context, this );
0741: }
0742:
0743: public void renderMultiFormString(StringBuffer buffer, Map context,
0744: FormStringRenderer formStringRenderer, int positions) {
0745: formStringRenderer.renderFormOpen(buffer, context, this );
0746:
0747: // render formatting wrapper open
0748: formStringRenderer.renderFormatListWrapperOpen(buffer, context,
0749: this );
0750:
0751: // ===== render header row =====
0752: this .renderHeaderRow(buffer, context, formStringRenderer);
0753:
0754: // ===== render the item rows =====
0755: this .renderItemRows(buffer, context, formStringRenderer, false);
0756:
0757: // render formatting wrapper close
0758: formStringRenderer.renderFormatListWrapperClose(buffer,
0759: context, this );
0760:
0761: formStringRenderer.renderFormClose(buffer, context, this );
0762: }
0763:
0764: public void renderHeaderRow(StringBuffer buffer, Map context,
0765: FormStringRenderer formStringRenderer) {
0766: formStringRenderer.renderFormatHeaderRowOpen(buffer, context,
0767: this );
0768:
0769: // render title for each field, except hidden & ignored, etc
0770:
0771: // start by rendering all display and hyperlink fields, until we
0772: //get to a field that should go into the form cell, then render
0773: //the form cell with all non-display and non-hyperlink fields, then
0774: //do a start after the first form input field and
0775: //render all display and hyperlink fields after the form
0776:
0777: // do the first part of display and hyperlink fields
0778: Iterator displayHyperlinkFieldIter = this .fieldList.iterator();
0779: while (displayHyperlinkFieldIter.hasNext()) {
0780: ModelFormField modelFormField = (ModelFormField) displayHyperlinkFieldIter
0781: .next();
0782: ModelFormField.FieldInfo fieldInfo = modelFormField
0783: .getFieldInfo();
0784:
0785: // don't do any header for hidden or ignored fields
0786: if (fieldInfo.getFieldType() == ModelFormField.FieldInfo.HIDDEN
0787: || fieldInfo.getFieldType() == ModelFormField.FieldInfo.IGNORED) {
0788: continue;
0789: }
0790:
0791: if (fieldInfo.getFieldType() != ModelFormField.FieldInfo.DISPLAY
0792: && fieldInfo.getFieldType() != ModelFormField.FieldInfo.HYPERLINK) {
0793: // okay, now do the form cell
0794: break;
0795: }
0796:
0797: if (!modelFormField.shouldUse(context)) {
0798: continue;
0799: }
0800:
0801: formStringRenderer.renderFormatHeaderRowCellOpen(buffer,
0802: context, this , modelFormField);
0803:
0804: formStringRenderer.renderFieldTitle(buffer, context,
0805: modelFormField);
0806:
0807: formStringRenderer.renderFormatHeaderRowCellClose(buffer,
0808: context, this , modelFormField);
0809: }
0810:
0811: List headerFormFields = new LinkedList();
0812: Iterator formFieldIter = this .fieldList.iterator();
0813: boolean isFirstFormHeader = true;
0814: while (formFieldIter.hasNext()) {
0815: ModelFormField modelFormField = (ModelFormField) formFieldIter
0816: .next();
0817: ModelFormField.FieldInfo fieldInfo = modelFormField
0818: .getFieldInfo();
0819:
0820: // don't do any header for hidden or ignored fields
0821: if (fieldInfo.getFieldType() == ModelFormField.FieldInfo.HIDDEN
0822: || fieldInfo.getFieldType() == ModelFormField.FieldInfo.IGNORED) {
0823: continue;
0824: }
0825:
0826: // skip all of the display/hyperlink fields
0827: if (fieldInfo.getFieldType() == ModelFormField.FieldInfo.DISPLAY
0828: || fieldInfo.getFieldType() == ModelFormField.FieldInfo.HYPERLINK) {
0829: continue;
0830: }
0831:
0832: // skip all of the submit/reset fields
0833: if (fieldInfo.getFieldType() == ModelFormField.FieldInfo.SUBMIT
0834: || fieldInfo.getFieldType() == ModelFormField.FieldInfo.RESET) {
0835: continue;
0836: }
0837:
0838: if (!modelFormField.shouldUse(context)) {
0839: continue;
0840: }
0841:
0842: headerFormFields.add(modelFormField);
0843: }
0844:
0845: // render the "form" cell
0846: formStringRenderer.renderFormatHeaderRowFormCellOpen(buffer,
0847: context, this );
0848:
0849: Iterator headerFormFieldIter = headerFormFields.iterator();
0850: while (headerFormFieldIter.hasNext()) {
0851: ModelFormField modelFormField = (ModelFormField) headerFormFieldIter
0852: .next();
0853: ModelFormField.FieldInfo fieldInfo = modelFormField
0854: .getFieldInfo();
0855:
0856: // render title (unless this is a submit or a reset field)
0857: formStringRenderer.renderFieldTitle(buffer, context,
0858: modelFormField);
0859:
0860: if (headerFormFieldIter.hasNext()) {
0861: // TODO: determine somehow if this is the last one... how?
0862: formStringRenderer
0863: .renderFormatHeaderRowFormCellTitleSeparator(
0864: buffer, context, this , modelFormField,
0865: false);
0866: }
0867: }
0868:
0869: formStringRenderer.renderFormatHeaderRowFormCellClose(buffer,
0870: context, this );
0871:
0872: // render the rest of the display/hyperlink fields
0873: while (displayHyperlinkFieldIter.hasNext()) {
0874: ModelFormField modelFormField = (ModelFormField) displayHyperlinkFieldIter
0875: .next();
0876: ModelFormField.FieldInfo fieldInfo = modelFormField
0877: .getFieldInfo();
0878:
0879: // don't do any header for hidden or ignored fields
0880: if (fieldInfo.getFieldType() == ModelFormField.FieldInfo.HIDDEN
0881: || fieldInfo.getFieldType() == ModelFormField.FieldInfo.IGNORED) {
0882: continue;
0883: }
0884:
0885: // skip all non-display and non-hyperlink fields
0886: if (fieldInfo.getFieldType() != ModelFormField.FieldInfo.DISPLAY
0887: && fieldInfo.getFieldType() != ModelFormField.FieldInfo.HYPERLINK) {
0888: continue;
0889: }
0890:
0891: if (!modelFormField.shouldUse(context)) {
0892: continue;
0893: }
0894:
0895: formStringRenderer.renderFormatHeaderRowCellOpen(buffer,
0896: context, this , modelFormField);
0897:
0898: formStringRenderer.renderFieldTitle(buffer, context,
0899: modelFormField);
0900:
0901: formStringRenderer.renderFormatHeaderRowCellClose(buffer,
0902: context, this , modelFormField);
0903: }
0904:
0905: formStringRenderer.renderFormatHeaderRowClose(buffer, context,
0906: this );
0907: }
0908:
0909: public void renderItemRows(StringBuffer buffer, Map context,
0910: FormStringRenderer formStringRenderer, boolean formPerItem) {
0911: // if list is empty, do not render rows
0912: List items = (List) context.get(this .getListName());
0913: if (items == null || items.size() == 0) {
0914: // do nothing; we could show an simple box with a message here
0915: } else {
0916: // render item rows
0917: Iterator itemIter = items.iterator();
0918: int itemIndex = -1;
0919: while (itemIter.hasNext()) {
0920: itemIndex++;
0921: Map localContext = new HashMap(context);
0922: Object item = itemIter.next();
0923: if (UtilValidate.isNotEmpty(this .getListEntryName())) {
0924: localContext.put(this .getListEntryName(), item);
0925: } else {
0926: Map itemMap = (Map) item;
0927: localContext.putAll(itemMap);
0928: }
0929: localContext.put("itemIndex", new Integer(itemIndex));
0930:
0931: // render row formatting open
0932: formStringRenderer.renderFormatItemRowOpen(buffer,
0933: localContext, this );
0934:
0935: // do the first part of display and hyperlink fields
0936: Iterator innerDisplayHyperlinkFieldIter = this .fieldList
0937: .iterator();
0938: while (innerDisplayHyperlinkFieldIter.hasNext()) {
0939: ModelFormField modelFormField = (ModelFormField) innerDisplayHyperlinkFieldIter
0940: .next();
0941: ModelFormField.FieldInfo fieldInfo = modelFormField
0942: .getFieldInfo();
0943:
0944: // don't do any header for hidden or ignored fields
0945: if (fieldInfo.getFieldType() == ModelFormField.FieldInfo.HIDDEN
0946: || fieldInfo.getFieldType() == ModelFormField.FieldInfo.IGNORED) {
0947: continue;
0948: }
0949:
0950: if (fieldInfo.getFieldType() != ModelFormField.FieldInfo.DISPLAY
0951: && fieldInfo.getFieldType() != ModelFormField.FieldInfo.HYPERLINK) {
0952: // okay, now do the form cell
0953: break;
0954: }
0955:
0956: if (!modelFormField.shouldUse(localContext)) {
0957: continue;
0958: }
0959:
0960: formStringRenderer.renderFormatItemRowCellOpen(
0961: buffer, localContext, this , modelFormField);
0962:
0963: modelFormField.renderFieldString(buffer,
0964: localContext, formStringRenderer);
0965:
0966: formStringRenderer.renderFormatItemRowCellClose(
0967: buffer, localContext, this , modelFormField);
0968: }
0969:
0970: // render the "form" cell
0971: formStringRenderer.renderFormatItemRowFormCellOpen(
0972: buffer, localContext, this );
0973:
0974: if (formPerItem) {
0975: formStringRenderer.renderFormOpen(buffer,
0976: localContext, this );
0977: }
0978:
0979: // do all of the hidden fields...
0980: this .renderHiddenIgnoredFields(buffer, localContext,
0981: formStringRenderer, null);
0982:
0983: Iterator innerFormFieldIter = this .fieldList.iterator();
0984: while (innerFormFieldIter.hasNext()) {
0985: ModelFormField modelFormField = (ModelFormField) innerFormFieldIter
0986: .next();
0987: ModelFormField.FieldInfo fieldInfo = modelFormField
0988: .getFieldInfo();
0989:
0990: // don't do any header for hidden or ignored fields
0991: if (fieldInfo.getFieldType() == ModelFormField.FieldInfo.HIDDEN
0992: || fieldInfo.getFieldType() == ModelFormField.FieldInfo.IGNORED) {
0993: continue;
0994: }
0995:
0996: // skip all of the display/hyperlink fields
0997: if (fieldInfo.getFieldType() == ModelFormField.FieldInfo.DISPLAY
0998: || fieldInfo.getFieldType() == ModelFormField.FieldInfo.HYPERLINK) {
0999: continue;
1000: }
1001:
1002: if (!modelFormField.shouldUse(localContext)) {
1003: continue;
1004: }
1005:
1006: // render field widget
1007: modelFormField.renderFieldString(buffer,
1008: localContext, formStringRenderer);
1009: }
1010:
1011: if (formPerItem) {
1012: formStringRenderer.renderFormClose(buffer,
1013: localContext, this );
1014: }
1015:
1016: formStringRenderer.renderFormatItemRowFormCellClose(
1017: buffer, localContext, this );
1018:
1019: // render the rest of the display/hyperlink fields
1020: while (innerDisplayHyperlinkFieldIter.hasNext()) {
1021: ModelFormField modelFormField = (ModelFormField) innerDisplayHyperlinkFieldIter
1022: .next();
1023: ModelFormField.FieldInfo fieldInfo = modelFormField
1024: .getFieldInfo();
1025:
1026: // don't do any header for hidden or ignored fields
1027: if (fieldInfo.getFieldType() == ModelFormField.FieldInfo.HIDDEN
1028: || fieldInfo.getFieldType() == ModelFormField.FieldInfo.IGNORED) {
1029: continue;
1030: }
1031:
1032: // skip all non-display and non-hyperlink fields
1033: if (fieldInfo.getFieldType() != ModelFormField.FieldInfo.DISPLAY
1034: && fieldInfo.getFieldType() != ModelFormField.FieldInfo.HYPERLINK) {
1035: continue;
1036: }
1037:
1038: if (!modelFormField.shouldUse(localContext)) {
1039: continue;
1040: }
1041:
1042: formStringRenderer.renderFormatItemRowCellOpen(
1043: buffer, localContext, this , modelFormField);
1044:
1045: modelFormField.renderFieldString(buffer,
1046: localContext, formStringRenderer);
1047:
1048: formStringRenderer.renderFormatItemRowCellClose(
1049: buffer, localContext, this , modelFormField);
1050: }
1051:
1052: // render row formatting close
1053: formStringRenderer.renderFormatItemRowClose(buffer,
1054: localContext, this );
1055: }
1056: }
1057: }
1058:
1059: public void renderHiddenIgnoredFields(StringBuffer buffer,
1060: Map context, FormStringRenderer formStringRenderer,
1061: Set alreadyRendered) {
1062: Iterator fieldIter = this .fieldList.iterator();
1063: while (fieldIter.hasNext()) {
1064: ModelFormField modelFormField = (ModelFormField) fieldIter
1065: .next();
1066: ModelFormField.FieldInfo fieldInfo = modelFormField
1067: .getFieldInfo();
1068:
1069: // render hidden/ignored field widget
1070: switch (fieldInfo.getFieldType()) {
1071: case ModelFormField.FieldInfo.HIDDEN:
1072: case ModelFormField.FieldInfo.IGNORED:
1073: if (modelFormField.shouldUse(context)) {
1074: modelFormField.renderFieldString(buffer, context,
1075: formStringRenderer);
1076: if (alreadyRendered != null)
1077: alreadyRendered.add(modelFormField.getName());
1078: }
1079: break;
1080:
1081: case ModelFormField.FieldInfo.DISPLAY:
1082: ModelFormField.DisplayField displayField = (ModelFormField.DisplayField) fieldInfo;
1083: if (displayField.getAlsoHidden()
1084: && modelFormField.shouldUse(context)) {
1085: formStringRenderer.renderHiddenField(buffer,
1086: context, modelFormField, modelFormField
1087: .getEntry(context));
1088: // don't add to already rendered here, or the display won't ger rendered: if (alreadyRendered != null) alreadyRendered.add(modelFormField.getName());
1089: }
1090: break;
1091:
1092: case ModelFormField.FieldInfo.HYPERLINK:
1093: ModelFormField.HyperlinkField hyperlinkField = (ModelFormField.HyperlinkField) fieldInfo;
1094: if (hyperlinkField.getAlsoHidden()
1095: && modelFormField.shouldUse(context)) {
1096: formStringRenderer.renderHiddenField(buffer,
1097: context, modelFormField, modelFormField
1098: .getEntry(context));
1099: // don't add to already rendered here, or the hyperlink won't ger rendered: if (alreadyRendered != null) alreadyRendered.add(modelFormField.getName());
1100: }
1101: break;
1102: }
1103: }
1104: }
1105:
1106: public LocalDispatcher getDispacher() {
1107: return this .dispatcher;
1108: }
1109:
1110: public GenericDelegator getDelegator() {
1111: return this .delegator;
1112: }
1113:
1114: /**
1115: * @return
1116: */
1117: public String getDefaultEntityName() {
1118: return this .defaultEntityName;
1119: }
1120:
1121: /**
1122: * @return
1123: */
1124: public String getDefaultMapName() {
1125: return this .defaultMapName.getOriginalName();
1126: }
1127:
1128: public Map getDefaultMap(Map context) {
1129: return (Map) this .defaultMapName.get(context);
1130: }
1131:
1132: /**
1133: * @return
1134: */
1135: public String getDefaultServiceName() {
1136: return this .defaultServiceName;
1137: }
1138:
1139: /**
1140: * @return
1141: */
1142: public String getDefaultTitleStyle() {
1143: return this .defaultTitleStyle;
1144: }
1145:
1146: /**
1147: * @return
1148: */
1149: public String getDefaultWidgetStyle() {
1150: return this .defaultWidgetStyle;
1151: }
1152:
1153: /**
1154: * @return
1155: */
1156: public String getDefaultTooltipStyle() {
1157: return this .defaultTooltipStyle;
1158: }
1159:
1160: /**
1161: * @return
1162: */
1163: public String getItemIndexSeparator() {
1164: if (UtilValidate.isNotEmpty(this .itemIndexSeparator)) {
1165: return this .itemIndexSeparator;
1166: } else {
1167: return "_o_";
1168: }
1169: }
1170:
1171: /**
1172: * @return
1173: */
1174: public String getListEntryName() {
1175: return this .listEntryName;
1176: }
1177:
1178: /**
1179: * @return
1180: */
1181: public String getListName() {
1182: return this .listName;
1183: }
1184:
1185: /**
1186: * @return
1187: */
1188: public String getName() {
1189: return this .name;
1190: }
1191:
1192: public String getCurrentFormName(Map context) {
1193: Integer itemIndex = (Integer) context.get("itemIndex");
1194: String formName = (String) context.get("formName");
1195: if (UtilValidate.isEmpty(formName)) {
1196: formName = this .getName();
1197: }
1198:
1199: if (itemIndex != null && "list".equals(this .getType())) {
1200: return formName + this .getItemIndexSeparator()
1201: + itemIndex.intValue();
1202: } else {
1203: return formName;
1204: }
1205: }
1206:
1207: /** iterate through altTargets list to see if any should be used, if not return original target
1208: * @return The target for this Form
1209: */
1210: public String getTarget(Map context) {
1211: try {
1212: // use the same Interpreter (ie with the same context setup) for all evals
1213: Interpreter bsh = this .getBshInterpreter(context);
1214: Iterator altTargetIter = this .altTargets.iterator();
1215: while (altTargetIter.hasNext()) {
1216: AltTarget altTarget = (AltTarget) altTargetIter.next();
1217: Object retVal = bsh.eval(altTarget.useWhen);
1218: boolean condTrue = false;
1219: // retVal should be a Boolean, if not something weird is up...
1220: if (retVal instanceof Boolean) {
1221: Boolean boolVal = (Boolean) retVal;
1222: condTrue = boolVal.booleanValue();
1223: } else {
1224: throw new IllegalArgumentException(
1225: "Return value from target condition eval was not a Boolean: "
1226: + retVal.getClass().getName()
1227: + " [" + retVal + "] of form "
1228: + this .name);
1229: }
1230:
1231: if (condTrue) {
1232: return altTarget.target;
1233: }
1234: }
1235: } catch (EvalError e) {
1236: String errmsg = "Error evaluating BeanShell target conditions on form "
1237: + this .name;
1238: Debug.logError(e, errmsg, module);
1239: throw new IllegalArgumentException(errmsg);
1240: }
1241:
1242: return target;
1243: }
1244:
1245: /**
1246: * @return
1247: */
1248: public String getTitle() {
1249: return this .title;
1250: }
1251:
1252: /**
1253: * @return
1254: */
1255: public String getTooltip() {
1256: return this .tooltip;
1257: }
1258:
1259: /**
1260: * @return
1261: */
1262: public String getType() {
1263: return this .type;
1264: }
1265:
1266: public Interpreter getBshInterpreter(Map context) throws EvalError {
1267: Interpreter bsh = (Interpreter) context.get("bshInterpreter");
1268: if (bsh == null) {
1269: bsh = BshUtil.makeInterpreter(context);
1270: context.put("bshInterpreter", bsh);
1271: }
1272: return bsh;
1273: }
1274:
1275: /**
1276: * @param string
1277: */
1278: public void setDefaultEntityName(String string) {
1279: this .defaultEntityName = string;
1280: }
1281:
1282: /**
1283: * @param string
1284: */
1285: public void setDefaultMapName(String string) {
1286: this .defaultMapName = new FlexibleMapAccessor(string);
1287: }
1288:
1289: /**
1290: * @param string
1291: */
1292: public void setDefaultServiceName(String string) {
1293: this .defaultServiceName = string;
1294: }
1295:
1296: /**
1297: * @param string
1298: */
1299: public void setDefaultTitleStyle(String string) {
1300: this .defaultTitleStyle = string;
1301: }
1302:
1303: /**
1304: * @param string
1305: */
1306: public void setDefaultWidgetStyle(String string) {
1307: this .defaultWidgetStyle = string;
1308: }
1309:
1310: /**
1311: * @param string
1312: */
1313: public void setDefaultTooltipStyle(String string) {
1314: this .defaultTooltipStyle = string;
1315: }
1316:
1317: /**
1318: * @param string
1319: */
1320: public void setItemIndexSeparator(String string) {
1321: this .itemIndexSeparator = string;
1322: }
1323:
1324: /**
1325: * @param string
1326: */
1327: public void setListEntryName(String string) {
1328: this .listEntryName = string;
1329: }
1330:
1331: /**
1332: * @param string
1333: */
1334: public void setListName(String string) {
1335: this .listName = string;
1336: }
1337:
1338: /**
1339: * @param string
1340: */
1341: public void setName(String string) {
1342: this .name = string;
1343: }
1344:
1345: /**
1346: * @param string
1347: */
1348: public void setTarget(String string) {
1349: this .target = string;
1350: }
1351:
1352: /**
1353: * @param string
1354: */
1355: public void setTitle(String string) {
1356: this .title = string;
1357: }
1358:
1359: /**
1360: * @param string
1361: */
1362: public void setTooltip(String string) {
1363: this .tooltip = string;
1364: }
1365:
1366: /**
1367: * @param string
1368: */
1369: public void setType(String string) {
1370: this .type = string;
1371: }
1372:
1373: /**
1374: * @return
1375: */
1376: public String getPaginateTarget() {
1377: return this .paginateTarget;
1378: }
1379:
1380: /**
1381: * @param string
1382: */
1383: public void setPaginateTarget(String string) {
1384: this .paginateTarget = string;
1385: }
1386:
1387: public static class AltTarget {
1388: public String useWhen;
1389: public String target;
1390:
1391: public AltTarget(Element altTargetElement) {
1392: this .useWhen = altTargetElement.getAttribute("use-when");
1393: this .target = altTargetElement.getAttribute("target");
1394: }
1395: }
1396:
1397: public static class AutoFieldsService {
1398: public String serviceName;
1399: public String mapName;
1400: public String defaultFieldType;
1401:
1402: public AutoFieldsService(Element element) {
1403: this .serviceName = element.getAttribute("service-name");
1404: this .mapName = element.getAttribute("map-name");
1405: this .defaultFieldType = element
1406: .getAttribute("default-field-type");
1407: }
1408: }
1409:
1410: public static class AutoFieldsEntity {
1411: public String entityName;
1412: public String mapName;
1413: public String defaultFieldType;
1414:
1415: public AutoFieldsEntity(Element element) {
1416: this .entityName = element.getAttribute("entity-name");
1417: this .mapName = element.getAttribute("map-name");
1418: this .defaultFieldType = element
1419: .getAttribute("default-field-type");
1420: }
1421: }
1422:
1423: }
|