001: package com.calipso.reportgenerator.userinterface;
002:
003: import com.calipso.reportgenerator.common.LanguageTraslator;
004: import com.calipso.reportgenerator.common.ReportSpec;
005: import com.calipso.reportgenerator.common.InfoException;
006: import com.calipso.reportgenerator.common.ShowExceptionMessageDialog;
007: import com.calipso.reportgenerator.reportdefinitions.types.ReportDataType;
008:
009: import javax.swing.*;
010: import java.awt.*;
011: import java.awt.event.ActionListener;
012: import java.awt.event.ActionEvent;
013: import java.util.*;
014: import java.text.DateFormat;
015: import java.text.SimpleDateFormat;
016: import java.text.ParseException;
017:
018: /**
019: * Genera la interfaz de usuario para el ingreso de Parametros
020: */
021:
022: public class UserParametersUI extends JDialog implements ActionListener {
023:
024: private Vector userParametersCollection;
025: private HashMap params;
026: private boolean isMapGenerated;
027: private HashMap variablesNames;
028: private JButton btAccept;
029: private JButton btCancel;
030: private int WIDTH = 90;
031: private int HEIGHT = 26;
032:
033: /**
034: * Inicializa una instancia de UserParametersUI
035: * @param userParametersCollection coleccion necesaria para la creacion de la interfaz
036: */
037: public UserParametersUI(Frame owner, Vector userParametersCollection) {
038: super (owner, true);
039: this .userParametersCollection = userParametersCollection;
040: this .variablesNames = new HashMap();
041: }
042:
043: /**
044: * Inicializa los componentes de la interfaz y los muestra
045: */
046: public void showUI() {
047: getContentPane().add(createCenterPanel(), BorderLayout.CENTER);
048: getContentPane().add(createSouthPanel(), BorderLayout.SOUTH);
049: this .pack();
050: setLocation(getDefaultLocation());
051: this .setVisible(true);
052: }
053:
054: private Point getDefaultLocation() {
055: Point ownerLocation = getOwner().getLocation();
056: Dimension ownerSize = getOwner().getSize();
057: Dimension size = getSize();
058:
059: int x = ownerLocation.x + ownerSize.width / 2 - size.width / 2;
060: int y = ownerLocation.y + ownerSize.height / 2 - size.height
061: / 2;
062: return new Point(x, y);
063: }
064:
065: /**
066: * Genera el Panel con los botones Aceptar o Cancelar
067: * @return Panel que contiene los botones Aceptar o Cancelar
068: */
069: private JPanel createSouthPanel() {
070: JPanel southPanel = new JPanel(new BorderLayout());
071: setTitle(LanguageTraslator.traslate("186"));
072: btAccept = new JButton(LanguageTraslator.traslate("112"));
073: btAccept.setSize(new Dimension(WIDTH, HEIGHT));
074: btAccept.setPreferredSize(new Dimension(WIDTH, HEIGHT));
075: btAccept.setMaximumSize(new Dimension(WIDTH, HEIGHT));
076: btAccept.setMinimumSize(new Dimension(WIDTH, HEIGHT));
077: btAccept.addActionListener(this );
078: btCancel = new JButton(LanguageTraslator.traslate("113"));
079: btCancel.addActionListener(this );
080: btCancel.setSize(new Dimension(WIDTH, HEIGHT));
081: btCancel.setPreferredSize(new Dimension(WIDTH, HEIGHT));
082: btCancel.setMaximumSize(new Dimension(WIDTH, HEIGHT));
083: btCancel.setMinimumSize(new Dimension(WIDTH, HEIGHT));
084: JPanel eastSouthPanel = new JPanel(new FlowLayout());
085: eastSouthPanel.add(btAccept);
086: eastSouthPanel.add(btCancel);
087: southPanel.add(eastSouthPanel, BorderLayout.EAST);
088: return southPanel;
089: }
090:
091: /**
092: * Panel que contiene los TextField y sus descripciones correspondientes para el
093: * ingreso de Parametros por parte del usuario
094: * @return Panel escencial para el ingreso de datos
095: */
096: private JPanel createCenterPanel() {
097: JPanel centerPanel = new JPanel(new GridLayout(
098: userParametersCollection.size(), 1));
099: for (Enumeration enumeration = userParametersCollection
100: .elements(); enumeration.hasMoreElements();) {
101: UserParameterElement paramValueElement = (UserParameterElement) enumeration
102: .nextElement();
103: JLabel label = new JLabel(paramValueElement.getName());
104: //Font font = new Font("Arial", Font.BOLD, 11);
105: //label.setFont(font);
106: centerPanel.add(label, BorderLayout.CENTER);
107: centerPanel.add(getValuesPanel(paramValueElement));
108: }
109: return centerPanel;
110: }
111:
112: /**
113: * Crea y devuelve un Panel segun la cantidad y elementos que hayan en la coleccion
114: * de parametros de usuario
115: * @param paramValueElement
116: * @return Panel con los textfields necesarios para el ingreso de datos
117: */
118: private JPanel getValuesPanel(UserParameterElement paramValueElement) {
119: JPanel pnlValues = new JPanel(new GridLayout(paramValueElement
120: .getValues().size(), paramValueElement.getValues()
121: .size()));
122: for (int i = 0; i < paramValueElement.getValues().size(); i++) {
123: String currentKey = paramValueElement.getKeyAt(i);
124: JLabel label = new JLabel(currentKey);
125: pnlValues.add(label);
126:
127: UserParameterTextField textField = null;
128: if (paramValueElement.getDimensionDataType() == ReportDataType.DATETIME_TYPE
129: || paramValueElement.getDimensionDataType() == ReportDataType.DATE_TYPE) {
130: String formatedDate = getDateFrom(paramValueElement
131: .getValues().get(currentKey).toString());
132: textField = new DateTextField(formatedDate);
133: } else if (paramValueElement.getDimensionDataType() == ReportDataType.STRING_TYPE) {
134: textField = new StringTextField(paramValueElement
135: .getValues().get(currentKey).toString());
136: }
137: pnlValues.add(textField);
138: initializeDictionary(paramValueElement
139: .getFilterDefinitionName(), currentKey, textField);
140:
141: }
142: return pnlValues;
143: }
144:
145: private String getDateFrom(String dateString) {
146: String returnVal = null;
147: try {
148: DateFormat dateFormat = new SimpleDateFormat("yyyyMMdd");
149: Date date = dateFormat.parse(dateString);
150: DateFormat second = SimpleDateFormat.getDateInstance(
151: DateFormat.SHORT, LanguageTraslator.getLocale());
152: returnVal = second.format(date);
153: } catch (ParseException e) {
154: e.printStackTrace();
155: }
156: return returnVal;
157: }
158:
159: /**
160: * Genera un Map que contiene las instancias de los TextFields creados
161: * @param name Nombre del Filtro
162: * @param paramType posibles valores FROM, TO, QUANTITY, VALUE
163: * @param textfield instancia de textfield
164: */
165: private void initializeDictionary(String name, String paramType,
166: JTextField textfield) {
167: if (paramType.equals(LanguageTraslator.traslate("146"))) {//desde
168: variablesNames.put(name + " FROM", textfield);
169: } else if (paramType.equals(LanguageTraslator.traslate("147"))) {//hasta
170: variablesNames.put(name + " TO", textfield);
171: } else if (paramType.equals(LanguageTraslator.traslate("149"))) {//cant
172: variablesNames.put(name + " QUANTITY", textfield);
173: } else if (paramType.equals(LanguageTraslator.traslate("150"))) {//value
174: variablesNames.put(name + " VALUE", textfield);
175: }
176: }
177:
178: /**
179: * Metodo que administra los eventos de la clase
180: * @param ae Evento correspondiente
181: */
182: public void actionPerformed(ActionEvent ae) {
183: isMapGenerated = false;
184: if (ae.getSource() == btAccept) {
185: Hashtable incorrectInputs = validateUserParameters();
186: if (incorrectInputs.size() > 0) {
187: showMessage(incorrectInputs);
188: return;
189: }
190: try {
191: params = getUserParameters();
192: } catch (InfoException e) {
193: ShowExceptionMessageDialog.initExceptionDialogMessage(
194: LanguageTraslator.traslate("257"), e);
195: }
196: isMapGenerated = true;
197: this .dispose();
198: } else {
199: dispose();
200: }
201: }
202:
203: /**
204: * Muestra un Dialog en caso de que se hayan cometido errores en el ingreso
205: * @param incorrectInputs Map que contiene los valores ingresados incorrectos
206: */
207: private void showMessage(Hashtable incorrectInputs) {
208: String incorrectInputsString = "";
209: for (Enumeration enumeration = incorrectInputs.keys(); enumeration
210: .hasMoreElements();) {
211: String currentKey = enumeration.nextElement().toString();
212: incorrectInputsString = incorrectInputsString + currentKey
213: + " > " + incorrectInputs.get(currentKey) + '\n';
214: }
215: JOptionPane.showMessageDialog(this , incorrectInputsString,
216: "Error", JOptionPane.ERROR_MESSAGE);
217: }
218:
219: /**
220: * Obtiene los parametros de usuario
221: * @return Hashmap que contiene los parametros de usuario
222: */
223: private HashMap getUserParameters() throws InfoException {
224: HashMap userParameters = new HashMap();
225: Set keys = variablesNames.keySet();
226: for (Iterator iterator = keys.iterator(); iterator.hasNext();) {
227: String currentKey = iterator.next().toString();
228: String[] tokens = prepareTokens(currentKey);
229: //userParameters.put(tokens[0].toUpperCase() + tokens[1], ((JTextField)variablesNames.get(currentKey)).getText());
230: userParameters.put(tokens[0].toUpperCase() + tokens[1],
231: ((UserParameterTextField) variablesNames
232: .get(currentKey)).getFieldText());
233: }
234: return userParameters;
235: }
236:
237: /**
238: * Valida los parametros ingresados por el usuario
239: * @return Map que contiene los posibles valores incorrectos
240: */
241: private Hashtable validateUserParameters() {
242: Hashtable incorrectMap = new Hashtable();
243: Set keys = variablesNames.keySet();
244: for (Iterator iterator = keys.iterator(); iterator.hasNext();) {
245: String currentKey = iterator.next().toString();
246: String[] tokens = prepareTokens(currentKey);
247: String returnedVal = validate(tokens);
248: if (!returnedVal.equals("")) {
249: String[] incorrectTokens = prepareTokens(returnedVal);
250: incorrectMap.put(incorrectTokens[0], LanguageTraslator
251: .traslate("152")
252: + incorrectTokens[1]
253: + ", "
254: + incorrectTokens[2]);
255: }
256: }
257: return incorrectMap;
258: }
259:
260: /**
261: * Valida por cada Filtro. Es decir, que el valor "TO" o "QUANTITY" sea menor al valor "FROM"
262: * @param tokens
263: * @return value
264: */
265: private String validate(String[] tokens) {
266: String from = "0", to = "0";
267: if (tokens[tokens.length - 1].equals("TO")) {
268: to = ((JTextField) variablesNames.get(tokens[0] + " "
269: + tokens[tokens.length - 1])).getText();
270: from = ((JTextField) variablesNames.get(tokens[0] + " "
271: + "FROM")).getText();
272: } else if (tokens[tokens.length - 1].equals("QUANTITY")) {
273: to = ((JTextField) variablesNames.get(tokens[0] + " "
274: + tokens[tokens.length - 1])).getText();
275: from = ((JTextField) variablesNames.get(tokens[0] + " "
276: + "FROM")).getText();
277: } else if (tokens[tokens.length - 1].equals("VALUE")) {
278: to = ((JTextField) variablesNames.get(tokens[0] + " "
279: + tokens[tokens.length - 1])).getText();
280: } else {
281: from = "-1";
282: }
283:
284: if (from.compareTo(to) > 0) {
285: return tokens[0] + " " + from + " " + to;
286: }
287: return "";
288: }
289:
290: /**
291: * A partir de un String devuelve los tokens
292: * @param currentKey
293: * @return Array que contiene los tokens
294: */
295: private String[] prepareTokens(String currentKey) {
296: StringTokenizer stringTokenizer = new StringTokenizer(
297: currentKey);
298: String[] tokens = new String[stringTokenizer.countTokens()];
299: for (int i = 0; stringTokenizer.hasMoreTokens(); i++) {
300: tokens[i] = stringTokenizer.nextToken();
301: }
302: return tokens;
303: }
304:
305: /**
306: * Devuelve los parametros de usuario
307: * @return Map que contiene los parametros de usuario
308: */
309: public HashMap getParams() {
310: return params;
311: }
312:
313: /**
314: * Devuelve un boolean que determina si se ha generado o no el Map con los parametros de usuario
315: * @return boolean que determina si se ha generado o no el Map con los
316: * parametros de usuario
317: */
318: public boolean isGenerated() {
319: return isMapGenerated;
320: }
321:
322: /**
323: * Crea la coleccion de los Filtros cuyo atributo visible = true y crea la interfaz
324: * para el ingreso de los parametros de usuario.
325: * En caso de que se haya generado el Map con dichos parametros devuelve el Map.
326: * @param reportSpec Necesario para la creacion de la coleccion
327: * @param params Map vacio que se llena luego con los nuevos parametros
328: * @return booleano que determina si se desean editar los parametros
329: */
330: public static boolean editParams(Frame owner,
331: ReportSpec reportSpec, Map params) {
332: UserParametersCollection userParametersCollection = new UserParametersCollection(
333: reportSpec);
334: UserParametersUI userParametersUI = new UserParametersUI(owner,
335: userParametersCollection.getUserParametersCollection());
336: if (userParametersCollection.getUserParametersCollection()
337: .size() > 0) {
338: userParametersUI.showUI();
339: boolean result = userParametersUI.isGenerated();
340: if (result) {
341: params.putAll(userParametersUI.getParams());
342: }
343: return result;
344: }
345: return true;
346: }
347: }
|