001: // /////////////////////////////
002: // Makumba, Makumba tag library
003: // Copyright (C) 2000-2003 http://www.makumba.org
004: //
005: // This library is free software; you can redistribute it and/or
006: // modify it under the terms of the GNU Lesser General Public
007: // License as published by the Free Software Foundation; either
008: // version 2.1 of the License, or (at your option) any later version.
009: //
010: // This library is distributed in the hope that it will be useful,
011: // but WITHOUT ANY WARRANTY; without even the implied warranty of
012: // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
013: // Lesser General Public License for more details.
014: //
015: // You should have received a copy of the GNU Lesser General Public
016: // License along with this library; if not, write to the Free Software
017: // Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
018: //
019: // -------------
020: // $Id: FieldEditor.java 1749 2007-10-03 15:56:11Z manuel_gay $
021: // $Name$
022: /////////////////////////////////////
023:
024: package org.makumba.forms.html;
025:
026: import java.util.Dictionary;
027:
028: import org.makumba.ProgrammerError;
029: import org.makumba.commons.formatters.FieldFormatter;
030: import org.makumba.commons.formatters.InvalidValueException;
031: import org.makumba.commons.formatters.RecordFormatter;
032:
033: public class FieldEditor extends
034: org.makumba.commons.formatters.FieldFormatter {
035:
036: public static final String ERROR_NO_INT = "invalid integer";
037:
038: public static final String ERROR_NO_REAL = "invalid real";
039:
040: /* see http://c2.com/cgi/wiki?JavaSingleton */
041: private static final class SingletonHolder {
042: static final FieldEditor singleton = new FieldEditor();
043: }
044:
045: /** Don't use this, use getInstance() */
046: protected FieldEditor() {
047: }
048:
049: public static FieldFormatter getInstance() {
050: return SingletonHolder.singleton;
051: }
052:
053: static String[] params = { "default", "empty", "type" };
054:
055: static String[][] paramValues = { null, null, { "hidden" } };
056:
057: public String[] getAcceptedParams() {
058: return params;
059: }
060:
061: public String[][] getAcceptedValue() {
062: return paramValues;
063: }
064:
065: static final String suffixName = "org.makumba.editorSuffix";
066:
067: public static String getSuffix(RecordFormatter rf, int fieldIndex,
068: Dictionary formatParams) {
069: return (String) formatParams.get(suffixName);
070: }
071:
072: public static void setSuffix(Dictionary formatParams, String suffix) {
073: formatParams.put(suffixName, suffix);
074: }
075:
076: public void checkParam(RecordFormatter rf, int fieldIndex,
077: String name, String val) {
078: if (name.equals(extraFormattingParam))
079: return;
080: if (name.equals("type") && val.equals("hidden"))
081: return;
082: super .checkParam(rf, fieldIndex, name, val);
083: }
084:
085: public String format(RecordFormatter rf, int fieldIndex, Object o,
086: Dictionary formatParams) {
087: String s = (String) formatParams.get("type");
088: if (s != null && s.equals("hidden"))
089: return formatHidden(rf, fieldIndex, o, formatParams);
090: return formatShow(rf, fieldIndex, o, formatParams);
091: }
092:
093: public String formatShow(RecordFormatter rf, int fieldIndex,
094: Object o, Dictionary formatParams) {
095: // this will call formatNull and formatNotNull which should be redefined
096: // or, the entire formatShow should be redefined
097: return super .format(rf, fieldIndex, o, formatParams);
098: }
099:
100: public String formatHidden(RecordFormatter rf, int fieldIndex,
101: Object o, Dictionary formatParams) {
102: return "<input type=\"hidden\" name=\""
103: + getInputName(rf, fieldIndex, formatParams)
104: + "\" value=\""
105: + formatHiddenValue(rf, fieldIndex, o, formatParams)
106: + "\" "
107: + getExtraFormatting(rf, fieldIndex, formatParams)
108: + ">";
109: }
110:
111: /** Formats the value to appear in hidden input statement. */
112: public String formatHiddenValue(RecordFormatter rf, int fieldIndex,
113: Object o, Dictionary formatParams) {
114: // default : same treatment as formatting for normal input.
115: return formatValue(rf, fieldIndex, o, formatParams);
116: }
117:
118: /** Formats the value to appear in an input statement. */
119: public String formatValue(RecordFormatter rf, int fieldIndex,
120: Object o, Dictionary formatParams) {
121: // return super.format(o, formatParams);
122: throw new ProgrammerError(
123: "If this method is needed, overload it in the inheriting class");
124: }
125:
126: public void onStartup(RecordFormatter rf, int fieldIndex) {
127: }
128:
129: public String getInputName(RecordFormatter rf, int fieldIndex,
130: Dictionary formatParams) {
131: return getInputName(rf, fieldIndex, getSuffix(rf, fieldIndex,
132: formatParams));
133: }
134:
135: public String getInputName(RecordFormatter rf, int fieldIndex,
136: String suffix) {
137: return rf.expr[fieldIndex] + suffix;
138: }
139:
140: public static final String extraFormattingParam = "makumba.extraFormatting";
141:
142: public static String getExtraFormatting(RecordFormatter rf,
143: int fieldIndex, Dictionary formatParams) {
144: return (String) formatParams.get(extraFormattingParam);
145: }
146:
147: public static void setExtraFormatting(Dictionary formatParams,
148: String extraFormatting) {
149: formatParams.put(extraFormattingParam, extraFormatting);
150: }
151:
152: public Object readFrom(RecordFormatter rf, int fieldIndex,
153: org.makumba.commons.attributes.HttpParameters p,
154: String suffix) {
155: return p.getParameter(getInputName(rf, fieldIndex, suffix));
156: }
157:
158: protected Integer toInt(RecordFormatter rf, int fieldIndex, Object o) {
159: if (o == null)
160: return null;
161: String s = ("" + o).trim();
162: if (s.length() == 0)
163: return null;
164: try {
165: return new Integer(Integer.parseInt(s));
166: } catch (NumberFormatException e) {
167: throw new InvalidValueException(rf.expr[fieldIndex],
168: ERROR_NO_INT + ": " + o);
169: }
170: }
171:
172: protected Double toReal(RecordFormatter rf, int fieldIndex, Object o) {
173: if (o == null)
174: return null;
175: String s = ("" + o).trim();
176: if (s.length() == 0)
177: return null;
178: try {
179: return new Double(Double.parseDouble(s));
180: } catch (NumberFormatException e) {
181: try {
182: return new Double(Double.parseDouble(s
183: .replace(',', '.')));
184: } catch (NumberFormatException e2) {
185: try {
186: return new Double(Double.parseDouble(s.replace('.',
187: ',')));
188: } catch (NumberFormatException e3) {
189: throw new InvalidValueException(
190: rf.expr[fieldIndex], ERROR_NO_REAL + ": "
191: + o);
192: }
193: }
194: }
195: }
196:
197: }
|