1: /*
2: * FM2SQL.java -- Main program Filemaker to SQL Converter
3: * Copyright (C) 2003 Robert Gordesch (rogo@mpiwg-berlin.mpg.de)
4: * This program is free software; you can redistribute it and/or modify it
5: * under the terms of the GNU General Public License as published by the Free
6: * Software Foundation; either version 2 of the License, or (at your option)
7: * any later version. Please read license.txt for the full details. A copy of
8: * the GPL may be found at http://www.gnu.org/copyleft/lgpl.html You should
9: * have received a copy of the GNU General Public License along with this
10: * program; if not, write to the Free Software Foundation, Inc., 59 Temple
11: * Place, Suite 330, Boston, MA 02111-1307 USA Created on 15.09.2003 by
12: * rogo
13: */
14:
15: import java.awt.Cursor;
16: import java.awt.Dimension;
17: import java.awt.Font;
18: import java.awt.GridBagConstraints;
19: import java.awt.GridBagLayout;
20: import java.awt.Image;
21: import java.awt.Insets;
22: import java.awt.event.ActionEvent;
23: import java.awt.event.ActionListener;
24: import java.awt.event.ComponentAdapter;
25: import java.awt.event.ComponentEvent;
26: import java.awt.event.InputEvent;
27: import java.awt.event.WindowAdapter;
28: import java.awt.event.WindowEvent;
29: import java.io.ByteArrayOutputStream;
30: import java.io.File;
31: import java.io.FileWriter;
32: import java.io.PrintStream;
33: import java.sql.SQLException;
34: import java.sql.Statement;
35: import java.util.Collections;
36: import java.util.Iterator;
37: import java.util.Vector;
38:
39: import javax.swing.Box;
40: import javax.swing.BoxLayout;
41: import javax.swing.ButtonGroup;
42: import javax.swing.DefaultComboBoxModel;
43: import javax.swing.DefaultListModel;
44: import javax.swing.JButton;
45: import javax.swing.JCheckBoxMenuItem;
46: import javax.swing.JComboBox;
47: import javax.swing.JDialog;
48: import javax.swing.JFileChooser;
49: import javax.swing.JFrame;
50: import javax.swing.JLabel;
51: import javax.swing.JList;
52: import javax.swing.JMenu;
53: import javax.swing.JMenuBar;
54: import javax.swing.JMenuItem;
55: import javax.swing.JOptionPane;
56: import javax.swing.JPanel;
57: import javax.swing.JPasswordField;
58: import javax.swing.JProgressBar;
59: import javax.swing.JScrollBar;
60: import javax.swing.JScrollPane;
61: import javax.swing.JSplitPane;
62: import javax.swing.JTextArea;
63: import javax.swing.JTextField;
64: import javax.swing.KeyStroke;
65: import javax.swing.ListSelectionModel;
66: import javax.swing.event.TableModelEvent;
67: import javax.swing.event.TableModelListener;
68: import javax.swing.table.TableModel;
69: /**
70: *
71: * <br>
72: * <h2>FileMaker Test (JDBC Database Driver Test)</h2>
73: * Main class :
74: * contains the main Frame, all event handlers etc
75: * <br>
76: * The Database access is made over DBBean class
77: * all other classes are just for the visualization of the data
78: * @version 0.3( first stable release)
79: * @author rogo
80: *
81: */
82: public class FM2SQL extends JFrame implements ActionListener, TableModelListener
83: {
84: private JMenuItem delimiterItem;
85: private JCheckBoxMenuItem convertItem;
86: private JCheckBoxMenuItem appendItem;
87: private JCheckBoxMenuItem updateItem;
88: private JCheckBoxMenuItem deleteItem;
89:
90: int mode = -1;
91: final static int STATUS_INDEX = 0;
92: final static int NAME_INDEX = 1;
93: final static int ID_INDEX = 2;
94: final static int SELECT_INDEX = 3;
95: final static int CREATE_INDEX = 4;
96: final static int LAYOUT_INDEX = 5;
97:
98:
99:
100: /**
101: * The database Bean instance.
102: *
103: */
104: DBBean bean;
105: /**
106: * The database destination Bean instance.
107: *
108: */
109: DBBean destBean;
110:
111: /**
112: * tList - Tablenames to choose from
113: */
114:
115: JList tList = new JList(new String[] { "no database", "connection", "" });
116: JList tListDest = new JList(new String[] { "no database connection", "", "" });
117:
118: /**
119: * sourceUrl - Database URL ComboBox
120: */
121: JComboBox sourceURLBox;
122: /**
123: * destUrlBox - Database URL ComboBox
124: */
125: JComboBox destURLBox;
126:
127: TableComponent table, tC;
128: Vector tables = new Vector();
129: Vector layouts = new Vector();
130: JPanel listPanel;
131: JPanel topPanel,topPanel2, contentPanel;
132: JScrollPane paneDest;
133: FM2SQL fm = this;
134: boolean noDBUpdate = false;
135: boolean noUserUpdate = false;
136: int id = 0;
137: static boolean debug = false;
138: /**
139: * The result window used for query results
140: */
141: MultiResultWindow window;
142: /**
143: * The result window used for query results
144: */
145: MultiResultWindow windowDest;
146:
147: static FM2SQL fmInstance;
148: static String url = "jdbc:fmpro:http://141.14.237.42";
149: JButton showTables = new JButton(), showTables1 = new JButton();
150: JButton convert = new JButton();
151: JButton dropTables = new JButton();
152:
153: int oldWidth = 0, oldHeight = 0;
154: boolean resize = true;
155: static FileWriter logFile;
156: String delimiter = "";
157:
158: Dimension screenSize = java.awt.Toolkit.getDefaultToolkit().getScreenSize();
159: JFileChooser configExportFileChooser;
160: JFileChooser configImportFileChooser;
161:
162: /**
163: * tries to connect to database specified in url-Variable.
164: * initializes all GUI components, then fails throws an exception
165: *
166: */
167: public FM2SQL() throws Exception
168: {
169:
170: initializeGUI();
171: }
172: public void initializeGUI() throws Exception
173: {
174: Image local = getToolkit().getImage(FM2SQL.class.getResource("icons/fm.jpg"));
175: if (local != null);
176: setIconImage(local);
177: bean = new DBBean();
178: destBean = new DBBean();
179: sourceURLBox = new JComboBox(new String[] { "jdbc:fmpro:http://141.14.237.74:8050", "jdbc:fmpro:http://localhost", "jdbc:postgresql://foxridge/test" });
180: sourceURLBox.setEditable(true);
181: sourceURLBox.setFont(new Font("Times New Roman",Font.PLAIN,14));
182: destURLBox = new JComboBox(new String[] { "jdbc:postgresql://foxridge/test", "jdbc:postgresql://erebos/test1" });
183: destURLBox.setEditable(true);
184: destURLBox.addActionListener(this);
185: destURLBox.setFont(new Font("Times New Roman",Font.PLAIN,14));
186: table = new TableComponent();
187: //box = new JComboBox(tables);
188: // box.addActionListener(this);
189: // box2.addActionListener(this);
190: sourceURLBox.addActionListener(this);
191:
192: contentPanel = new JPanel();
193: contentPanel.setLayout(new BoxLayout(contentPanel, BoxLayout.Y_AXIS));
194:
195: sourceURLBox.setMinimumSize(new Dimension(450, 25));
196: sourceURLBox.setMaximumSize(new Dimension(550, 25));
197: sourceURLBox.setPreferredSize(new Dimension(450, 25));
198: destURLBox.setMinimumSize(new Dimension(450, 25));
199: destURLBox.setMaximumSize(new Dimension(550, 25));
200: destURLBox.setPreferredSize(new Dimension(450, 25));
201: paneDest = new JScrollPane(tListDest);
202: // tListDest.setPreferredSize(paneDest.getPreferredSize());
203: // paneDest.setPreferredSize(new Dimension(350, 365));
204: Dimension dim = paneDest.getPreferredSize();
205: paneDest.setMinimumSize(dim);
206: //paneDest.setMaximumSize(new Dimension(dim.width + 50, dim.height + 50));
207:
208: tC = new TableComponent();
209: tC.sizeToFit(450, 250);
210: tC.tableModel.addTableModelListener(this);
211: JPanel destPanel = new JPanel();
212: destPanel.setLayout(new java.awt.GridBagLayout());
213:
214: listPanel = new JPanel();
215: listPanel.setLayout(new java.awt.GridBagLayout());
216: java.awt.GridBagConstraints gbc = new java.awt.GridBagConstraints();
217: JScrollPane pane = new JScrollPane(tList);
218: tC.tableScroller.setPreferredSize(new Dimension(450, 365));
219: //tC.table.revalidate();
220: tC.tableScroller.setMinimumSize(new Dimension(450, 250));
221: // tC.tableScroller.setMaximumSize(tC.tableScroller.getPreferredSize());
222: topPanel = new JPanel();
223: topPanel.setLayout(new GridBagLayout());
224: topPanel2 = new JPanel();
225: topPanel2.setLayout(new GridBagLayout());
226:
227: gbc.gridx = 0;
228: gbc.gridy = 0;
229: gbc.weightx = 0.1;
230: gbc.weighty = 0.1;
231: gbc.gridwidth = 1;
232: gbc.gridheight = 1;
233: gbc.insets = new Insets(2, 2, 5, 5);
234: gbc.ipadx = 1;
235: gbc.ipady = 1;
236:
237: gbc.anchor = GridBagConstraints.WEST;
238: listPanel.add(topPanel, gbc);
239: destPanel.add(topPanel2, gbc);
240:
241: topPanel.add(new JLabel("Choose src database: ", JLabel.CENTER), gbc);
242: topPanel2.add(new JLabel("Choose dest database : ", JLabel.CENTER), gbc);
243:
244: gbc.anchor = GridBagConstraints.NORTHWEST;
245: gbc.gridy = 1;
246: topPanel.add(sourceURLBox, gbc);
247:
248: topPanel2.add(destURLBox, gbc);
249:
250: //gbc.gridx=GridBagConstraints.RELATIVE;
251: //dataBasePanel.add(new JLabel(" select Tables to Convert ", JLabel.LEFT));
252: gbc.gridy = 1;
253: gbc.anchor = GridBagConstraints.SOUTHWEST;
254:
255: listPanel.add(new JLabel(" select Tables to Convert ", JLabel.LEFT), gbc);
256: destPanel.add(new JLabel(" Tables in database ", JLabel.LEFT), gbc);
257:
258: // gbc.anchor = GridBagConstraints.WEST;
259: gbc.gridy = 2;
260: gbc.gridx = 0;
261: // gbc.weightx = 0.0;
262: //dataBasePanel.add(tC);
263: gbc.anchor = GridBagConstraints.NORTHWEST;
264: gbc.gridheight = 1;
265: gbc.fill = GridBagConstraints.BOTH;
266: listPanel.add(tC.tableScroller, gbc);
267: // gbc.fill = GridBagConstraints.VERTICAL;
268: destPanel.add(paneDest, gbc);
269: showTables1 = new JButton("show Tables");
270: showTables1.setActionCommand("show Tables source");
271: // gbc.anchor = GridBagConstraints.NORTH;
272: // gbc.weightx = 0.0;
273: gbc.fill = GridBagConstraints.NONE;
274: gbc.gridheight = 1;
275:
276: gbc.gridx = 0;
277: gbc.gridy = 2;
278: // topPanel.add(showTables1, gbc);
279: JPanel buttonPanel = new JPanel();
280: buttonPanel.setLayout(new BoxLayout(buttonPanel, BoxLayout.X_AXIS));
281: buttonPanel.setMinimumSize(new Dimension(380, 30));
282: convert = new JButton("Convert Tables");
283: showTables = new JButton("show Tables");
284: dropTables = new JButton("drop Tables");
285: // System.out.println(convert.getPreferredSize());
286: showTables.setMinimumSize(convert.getPreferredSize());
287: dropTables.setMinimumSize(convert.getPreferredSize());
288: showTables.setMaximumSize(convert.getPreferredSize());
289: dropTables.setMaximumSize(convert.getPreferredSize());
290: showTables.setPreferredSize(convert.getPreferredSize());
291: dropTables.setPreferredSize(convert.getPreferredSize());
292:
293: showTables.addActionListener(fm);
294: showTables1.addActionListener(fm);
295:
296: buttonPanel.add(showTables);
297: buttonPanel.add(convert);
298: convert.addActionListener(fm);
299: dropTables.addActionListener(fm);
300: buttonPanel.add(dropTables);
301:
302: JPanel buttonPanelSrc = new JPanel();
303: buttonPanelSrc.setLayout(new BoxLayout(buttonPanelSrc, BoxLayout.X_AXIS));
304: buttonPanelSrc.setMinimumSize(new Dimension(200, 30));
305: buttonPanelSrc.add(showTables1);
306:
307: topPanel.add(buttonPanelSrc, gbc);
308: topPanel2.add(buttonPanel, gbc);
309:
310: // gbc.anchor = GridBagConstraints.WEST;
311: // gbc.gridy = 1;
312: // gbc.gridx = 2;
313: // gbc.weightx = 0.2;
314:
315: // gbc.gridx = 3;
316: // gbc.anchor = GridBagConstraints.NORTHWEST;
317: // gbc.gridy = 1;
318: // gbc.weightx = 1.0;
319: //listPanel.add(buttonPanel, gbc);
320: JSplitPane splitter = new JSplitPane();
321: splitter.setTopComponent(listPanel);
322: splitter.setBottomComponent(destPanel);
323:
324: // contentPanel.add(dataBasePanel);
325: // contentPanel.add(listPanel);
326: listPanel.setMaximumSize(new Dimension(660, 750));
327: listPanel.setMinimumSize(new Dimension(660, 250));
328: listPanel.setPreferredSize(new Dimension(480, 500));
329: paneDest.setPreferredSize(new Dimension(250, 285));
330:
331: getContentPane().add(splitter, "Center");
332: this.addWindowListener(new WindowAdapter()
333: {
334: public void windowClosing(WindowEvent e)
335: {
336: System.exit(0);
337: }
338: });
339: addComponentListener(new ComponentAdapter()
340: {
341: public void componentResized(ComponentEvent e)
342: {
343:
344: if (oldWidth != getWidth() || oldHeight != getHeight())
345: {
346: //table.sizeToFit(getWidth(), getHeight());
347:
348: Dimension dim = table.table.getPreferredSize();
349: int size = contentPanel.getPreferredSize().height + new JScrollBar().getPreferredSize().height + new JMenuBar().getPreferredSize().height + 10;
350:
351: table.tableScroller.setPreferredSize(new Dimension(getWidth() - 15, getHeight() - size));
352: Dimension d2 = table.tableScroller.getPreferredSize();
353:
354: oldWidth = getWidth();
355: oldHeight = getHeight();
356:
357: table.setPreferredSize(new Dimension(d2.width + 15, d2.height + 5));
358: table.table.revalidate();
359: table.tableScroller.revalidate();
360: table.revalidate();
361: if (getHeight() > table.table.getPreferredSize().height + (2 * size))
362: setSize(getWidth(), table.table.getPreferredSize().height + 2 * size);
363: // System.out.println("size" + size);
364: }
365: // listPanel.setMaximumSize(new Dimension(getPreferredSize().width - 5, 550));
366: // listPanel.setMinimumSize(new Dimension(getPreferredSize().width - 5, 200));
367: // listPanel.setPreferredSize(new Dimension(getPreferredSize().width - 5, 370));
368: tC.tableScroller.revalidate();
369: Dimension dim = getSize();
370: tC.tableScroller.setMinimumSize(new Dimension(dim.width-400, dim.height - topPanel.getPreferredSize().height - 100));
371: tC.tableScroller.setMaximumSize(getSize());
372: tC.tableScroller.setPreferredSize(tC.tableScroller.getMinimumSize());
373:
374: paneDest.setMinimumSize(new Dimension(400, dim.height - topPanel2.getPreferredSize().height - 100));
375: paneDest.setMaximumSize(tC.tableScroller.getMaximumSize());
376: paneDest.setPreferredSize(new Dimension(400, dim.height - topPanel2.getPreferredSize().height - 100));
377:
378: paneDest.validate();
379: // tC.tableScroller.setPreferredSize(getSize());
380: // @TODO new sizeToFit method for listPanel table!!!
381: tC.sizeToFit(getWidth(), getHeight());
382: ((JPanel) getContentPane()).revalidate();
383: repaint();
384: setTitle("Filemaker 2 SQL Conversion Tool ");
385:
386: }
387: });
388:
389: setMenu();
390: //setSize(800, 600);
391: pack();
392: setLocation((screenSize.width - getWidth()) / 2, (screenSize.height - getHeight()) / 2);
393: //setVisible(true);
394: validate();
395:
396: // repaint();
397:
398: }
399:
400: /**
401: *
402: */
403: public static void main(String[] args)
404: {
405: try
406: {
407: System.setErr(System.out);
408: // Properties prop = System.getProperties();
409: // Enumeration enum= prop.keys();
410: // while(enum.hasMoreElements())
411: //System.out.println(enum.nextElement());
412:
413: if (System.getProperty("os.name").startsWith("W"))
414: // javax.swing.UIManager.setLookAndFeel(
415: // new com.sun.java.swing.plaf.windows.WindowsLookAndFeel());
416: javax.swing.UIManager.put("Table.focusCellHighlightBorder", new javax.swing.border.LineBorder(java.awt.Color.black));
417: javax.swing.UIManager.put("Table.focusCellBackground", new java.awt.Color(227, 227, 227, 127));
418:
419: fmInstance = new FM2SQL();
420: fmInstance.table.tableModel.addTableModelListener(fmInstance);
421: fmInstance.setVisible(true);
422: /* if (!new File("./html").exists())
423: new File("./html").mkdirs();
424: logFile = new FileWriter("./html/index.html");
425: openLog();
426: */
427: } catch (Exception e)
428: {
429: JOptionPane pane = new JOptionPane(e.getMessage() + " \n URL: " + url, JOptionPane.ERROR_MESSAGE);
430:
431: JDialog dialog = pane.createDialog(null, " Exception occured while connecting");
432: e.printStackTrace();
433: dialog.addWindowListener(new WindowAdapter()
434: {
435: public void windowClosing(WindowEvent e)
436: {
437: System.exit(0);
438: }
439: });
440: dialog.addComponentListener(new ComponentAdapter()
441: {
442:
443: public void componentHidden(ComponentEvent e)
444: {
445:
446: System.exit(0);
447: }
448: });
449: dialog.show();
450: }
451: }
452: public void actionPerformed(ActionEvent e)
453: {
454: String command = e.getActionCommand();
455: if (debug)
456: System.out.println("command " + command);
457: if (command == "comboBoxEdited")
458: {
459: Object src = e.getSource();
460: if (src == sourceURLBox)
461: {
462: if (debug)
463: System.out.println("hey" + sourceURLBox.getSelectedItem());
464: Object insObj =sourceURLBox.getSelectedItem();
465: ((DefaultComboBoxModel) sourceURLBox.getModel()).removeElement(insObj);
466:
467: ((DefaultComboBoxModel) sourceURLBox.getModel()).insertElementAt(insObj, 0);
468: sourceURLBox.setSelectedItem(insObj);
469: } else if (src == destURLBox)
470: {
471: if (debug)
472: System.out.println("hey" + destURLBox.getSelectedItem());
473: //((DefaultComboBoxModel) box4.getModel()).insertElementAt(box4.getSelectedItem(), 0);
474: try
475: {
476: String selected = (String) destURLBox.getSelectedItem();
477: destBean.setConnection(selected);
478: Vector catalogs = destBean.getCatalogs();
479: Vector urls = new Vector();
480: for (int i = 0; i < catalogs.size(); ++i)
481: {
482: urls.add(destBean.url.substring(0, destBean.url.lastIndexOf("/") + 1) + catalogs.get(i));
483: }
484: destURLBox.setModel(new DefaultComboBoxModel(urls));
485: destURLBox.setSelectedItem(selected);
486: } catch (Exception e5)
487: {
488: }
489: }
490: }
491: if (command == "comboBoxChanged")
492: {
493: try
494: {
495: //System.out.println("hallo " + (e.getSource() == box3));
496:
497: Object src = e.getSource();
498: if (src == sourceURLBox&&!noUserUpdate)
499: {
500: Thread thread = new Thread()
501: {
502: public void run()
503: {
504:
505: try
506: {
507: PasswordDialog dialog = new PasswordDialog(fmInstance, bean);
508: dialog.setLocationRelativeTo(sourceURLBox);
509: dialog.thread = Thread.currentThread();
510: fmInstance.setCursor(Cursor.getPredefinedCursor(Cursor.WAIT_CURSOR));
511: fmInstance.setEnabled(false);
512: dialog.setVisible(true);
513: String url = sourceURLBox.getSelectedItem().toString();
514: bean.url = (url != null) ? url : bean.url;
515: bean.connection = null;
516: bean.getConnection();
517: tables = bean.getTableNames();
518: fillTable();
519: fmInstance.setCursor(Cursor.getPredefinedCursor(Cursor.DEFAULT_CURSOR));
520: fmInstance.setEnabled(true);
521: // System.out.println("hallo" + tables + " ");
522: } catch (Exception e5)
523: {
524: ByteArrayOutputStream b = new ByteArrayOutputStream();
525: PrintStream stream = new PrintStream(b);
526: e5.printStackTrace(stream);
527: fmInstance.setCursor(Cursor.getPredefinedCursor(Cursor.DEFAULT_CURSOR));
528: fmInstance.setEnabled(true);
529: Vector header = new Vector();
530: header.add("no database");
531: header.add("connection");
532: Vector rows = new Vector();
533: //rows.add(header);
534: noDBUpdate=true;
535: tC.tableModel.setDataVector(rows, header);
536: tC.tableModel.setRowCount(20);
537: tC.revalidate();
538: tC.tableModel.fireTableDataChanged();
539: noDBUpdate=false;
540: showErrorDialog(b.toString(), "Error occured !");
541: }
542: }
543: };
544: thread.start();
545: } else if (src == destURLBox&&!noUserUpdate)
546: {
547: Thread thread = new Thread()
548: {
549: public void run()
550: {
551:
552: try
553: {
554:
555: PasswordDialog dialog = new PasswordDialog(fmInstance, destBean);
556: dialog.setLocationRelativeTo(destURLBox);
557: dialog.thread = Thread.currentThread();
558: fmInstance.setCursor(Cursor.getPredefinedCursor(Cursor.WAIT_CURSOR));
559: fmInstance.setEnabled(false);
560: dialog.setVisible(true);
561: destBean.setConnection((String) destURLBox.getSelectedItem());
562: DefaultListModel model = new DefaultListModel();
563: Vector tables = destBean.getTableNames();
564: for (int j = 0; j < tables.size(); ++j)
565: model.addElement(tables.get(j));
566: // System.out.println("hallo" + tables + " ");
567: tListDest.setModel(model);
568: // System.out.println("hallo" + tables + " ");
569: fmInstance.setCursor(Cursor.getPredefinedCursor(Cursor.DEFAULT_CURSOR));
570: fmInstance.setEnabled(true);
571: } catch (Exception e5)
572: {
573: ByteArrayOutputStream b = new ByteArrayOutputStream();
574: PrintStream stream = new PrintStream(b);
575: e5.printStackTrace(stream);
576: fmInstance.setEnabled(true);
577: fmInstance.setCursor(Cursor.getPredefinedCursor(Cursor.DEFAULT_CURSOR));
578: DefaultListModel model = new DefaultListModel();
579: model.addElement("no database connection");
580: tListDest.setModel(model);
581:
582: showErrorDialog(b.toString(), "Error occured !");
583: }
584: }
585: };
586: thread.start();
587:
588: }
589: setTitle("Filemaker 2 SQL Conversion Tool ");
590: // pack();
591:
592: } catch (Exception e4)
593: {
594: ByteArrayOutputStream b = new ByteArrayOutputStream();
595: PrintStream stream = new PrintStream(b);
596: e4.printStackTrace(stream);
597: showErrorDialog(b.toString(), "Open of table failed");
598:
599: }
600: }
601: if (command == "show Driver features")
602: {
603: ResultWindow result = new ResultWindow(this);
604: try
605: {
606: Vector[] vecs = bean.TestDB(bean.getConnection().getMetaData());
607: result.updateResult(vecs[0], vecs[1]);
608: // result.pack();
609: result.title = "Database features";
610: result.setVisible(true);
611: String name = result.writeResult();
612: } catch (Exception e2)
613: {
614: }
615: }
616: if (command.equals("Delimiter"))
617: {
618: new DelimiterDialog(fmInstance).setVisible(true);
619: //delimiter = JOptionPane.showInputDialog(fmInstance,"Enter delimiter String",delimiter);
620:
621: }
622:
623: if (command == "Convert Mode")
624: {
625: System.out.println("Convert Mode selected");
626: convert.setText("Convert Tables");
627: convert.setActionCommand("Convert Tables");
628: convert.setToolTipText("Normal table conversion existing table will be deleted");
629: mode = Convert.DataBase.CONVERT_MODE;
630: }
631: if (command == "Append Mode")
632: {
633: System.out.println("Append Mode selected");
634: convert.setText("Append Tables");
635: convert.setActionCommand("Append Tables");
636: convert.setToolTipText("Appends data to an existing table");
637:
638: mode = Convert.DataBase.APPEND_MODE;
639: }
640: if (command == "Update Mode")
641: {
642: System.out.println("Update Mode selected");
643: convert.setText("Update Tables");
644: convert.setActionCommand("Update Tables");
645: convert.setToolTipText("Updates data that has been changed in source");
646: mode = Convert.DataBase.UPDATE_MODE;
647: }
648: if (command == "Delete Mode")
649: {
650: System.out.println("Delete Mode selected");
651: convert.setText("Delete Tables");
652: convert.setActionCommand("Delete Tables");
653: convert.setToolTipText("Deletes data that has been deleted in source");
654: mode = Convert.DataBase.DELETE_MODE;
655: }
656:
657: //writing config
658: if (command.equals("save XML Config"))
659: {
660: if (configExportFileChooser == null)
661: {
662: configExportFileChooser = new JFileChooser();
663: configExportFileChooser.setFileSelectionMode(JFileChooser.FILES_AND_DIRECTORIES);
664: configExportFileChooser.setFileFilter(new XMLFilter());
665: configExportFileChooser.setDialogType(JFileChooser.SAVE_DIALOG);
666: configExportFileChooser.addActionListener(new ActionListener()
667: {
668: public void actionPerformed(ActionEvent e2)
669: {
670: System.out.println(e2.getActionCommand());
671: if (!e2.getActionCommand().toString().equals("ApproveSelection"))
672: return;
673:
674: Thread thread = new Thread()
675: {
676: public void run()
677: {
678: File configFile = configExportFileChooser.getSelectedFile();
679: writeConfig(configFile.toString());
680:
681: }
682: };
683: thread.start();
684:
685: }
686: });
687: }
688: configExportFileChooser.rescanCurrentDirectory();
689: configExportFileChooser.showDialog(fmInstance, " Save ");
690:
691: }
692: if (command.equals("open XML Config"))
693: {
694: if (configImportFileChooser == null)
695: {
696: configImportFileChooser = new JFileChooser();
697: configImportFileChooser.setFileSelectionMode(JFileChooser.FILES_AND_DIRECTORIES);
698: configImportFileChooser.setFileFilter(new XMLFilter());
699: configImportFileChooser.setDialogType(JFileChooser.OPEN_DIALOG);
700: configImportFileChooser.addActionListener(new ActionListener()
701: {
702: public void actionPerformed(ActionEvent e2)
703: {
704: System.out.println(e2.getActionCommand());
705: if (!e2.getActionCommand().toString().equals("ApproveSelection"))
706: return;
707:
708: Thread thread = new Thread()
709: {
710: public void run()
711: {
712: File configFile = configImportFileChooser.getSelectedFile();
713: readXMLConfig(configFile.toString());
714:
715: }
716: };
717: thread.start();
718:
719: }
720: });
721: }
722: configImportFileChooser.rescanCurrentDirectory();
723: configImportFileChooser.showDialog(fmInstance, " Open ");
724:
725: }
726:
727:
728: if (command.equals("Convert Tables")||command.equals("Append Tables"))
729: {
730:
731: Thread thread = new Thread()
732: {
733: public void run()
734: {
735: setEnabled(false);
736: convert();
737: setEnabled(true);
738: }
739:
740: };
741: thread.start();
742: }
743: if (command.equals("Update Tables"))
744: {
745:
746: Thread thread = new Thread()
747: {
748: public void run()
749: {
750: setEnabled(false);
751: update();
752: setEnabled(true);
753: }
754:
755: };
756: thread.start();
757: }
758: if (command.equals("Delete Tables"))
759: {
760:
761: Thread thread = new Thread()
762: {
763: public void run()
764: {
765: setEnabled(false);
766: delete();
767: setEnabled(true);
768: }
769:
770: };
771: thread.start();
772: }
773:
774: if (command.equals("show Tables"))
775: {
776: Thread thread = new Thread()
777: {
778: public void run()
779: {
780: fmInstance.setEnabled(false);
781: boolean visible = showTable(1);
782: window.validate();
783: window.setVisible(visible);
784: fmInstance.setEnabled(true);
785:
786: }
787: };
788: thread.start();
789: // System.out.println("hello");
790:
791: }
792: if (command.equals("show Tables source"))
793: {
794: Thread thread = new Thread()
795: {
796: public void run()
797: {
798: fmInstance.setEnabled(false);
799: boolean visible = showTable(0);
800: window.validate();
801: window.setVisible(visible);
802: fmInstance.setEnabled(true);
803: }
804: };
805: thread.start();
806: // System.out.println("hello"+thread);
807:
808: }
809:
810: if (command.equals("drop Tables"))
811: {
812: Thread thread = new Thread()
813: {
814: public void run()
815: {
816: dropTable();
817: }
818: };
819: thread.start();
820: }
821: if(command.equals("Quit"))
822: {
823: fmInstance.dispose();
824: System.exit(0);
825:
826: }
827:
828: }
829: /**
830: * Updates the content of source to destination and makes new table if necessary
831: */
832:
833: public void update()
834: {
835: Vector vectors[] = getListFromTable();
836: Convert.user = bean.user;
837: Convert.passwd = bean.passwd;
838: Convert.userDest = destBean.user;
839: Convert.passwdDest = destBean.passwd;
840: try
841: {
842:
843: fmInstance.setCursor(Cursor.getPredefinedCursor(Cursor.WAIT_CURSOR));
844: fmInstance.setEnabled(false);
845: Convert.update(bean.url, destURLBox.getSelectedItem().toString(), vectors[0], vectors[1], vectors[2], vectors[3],vectors[4], mode);
846:
847: destBean.setConnection((String) destURLBox.getSelectedItem());
848: DefaultListModel model = new DefaultListModel();
849: tables = destBean.getTableNames();
850: for (int j = 0; j < tables.size(); ++j)
851: model.addElement(tables.get(j));
852: if (debug)
853: System.out.println("hallo" + tables + " ");
854: tListDest.setModel(model);
855: fmInstance.setCursor(Cursor.getPredefinedCursor(Cursor.DEFAULT_CURSOR));
856: } catch (Exception e4)
857: {
858: ByteArrayOutputStream b = new ByteArrayOutputStream();
859: PrintStream stream = new PrintStream(b);
860: e4.printStackTrace(stream);
861: showErrorDialog(b.toString(), "Update of table failed");
862: fmInstance.setEnabled(true);
863: }
864:
865: }
866: public void delete()
867: {
868: Vector vectors[] = getListFromTable();
869: Convert.user = bean.user;
870: Convert.passwd = bean.passwd;
871: Convert.userDest = destBean.user;
872: Convert.passwdDest = destBean.passwd;
873: try
874: {
875:
876: fmInstance.setCursor(Cursor.getPredefinedCursor(Cursor.WAIT_CURSOR));
877: fmInstance.setEnabled(false);
878: Convert.delete(bean.url, destURLBox.getSelectedItem().toString(), vectors[0], vectors[1], vectors[2], vectors[3],vectors[4], mode);
879:
880: destBean.setConnection((String) destURLBox.getSelectedItem());
881: DefaultListModel model = new DefaultListModel();
882: tables = destBean.getTableNames();
883: for (int j = 0; j < tables.size(); ++j)
884: model.addElement(tables.get(j));
885: if (debug)
886: System.out.println("hallo" + tables + " ");
887: tListDest.setModel(model);
888: fmInstance.setCursor(Cursor.getPredefinedCursor(Cursor.DEFAULT_CURSOR));
889: } catch (Exception e4)
890: {
891: ByteArrayOutputStream b = new ByteArrayOutputStream();
892: PrintStream stream = new PrintStream(b);
893: e4.printStackTrace(stream);
894: showErrorDialog(b.toString(), "Delete of table failed");
895: fmInstance.setEnabled(true);
896: }
897:
898: }
899:
900: /**
901: * Copys the content of source to destination and makes new table if necessary
902: */
903: public void convert()
904: {
905:
906: Vector vectors[] = getListFromTable();
907: Convert.user = bean.user;
908: Convert.passwd = bean.passwd;
909: Convert.userDest = destBean.user;
910: Convert.passwdDest = destBean.passwd;
911: try
912: {
913: fmInstance.setCursor(Cursor.getPredefinedCursor(Cursor.WAIT_CURSOR));
914: fmInstance.setEnabled(false);
915: Convert.convert(bean.url, destURLBox.getSelectedItem().toString(), vectors[0], vectors[1],vectors[2],vectors[3],vectors[4],mode,delimiter);
916: destBean.setConnection((String) destURLBox.getSelectedItem());
917: DefaultListModel model = new DefaultListModel();
918: tables = destBean.getTableNames();
919: for (int j = 0; j < tables.size(); ++j)
920: model.addElement(tables.get(j));
921: if (debug)
922: System.out.println("hallo" + tables + " ");
923: tListDest.setModel(model);
924: fmInstance.setCursor(Cursor.getPredefinedCursor(Cursor.DEFAULT_CURSOR));
925: } catch (Exception e4)
926: {
927: ByteArrayOutputStream b = new ByteArrayOutputStream();
928: PrintStream stream = new PrintStream(b);
929: e4.printStackTrace(stream);
930: showErrorDialog(b.toString(), "Conversion of table failed");
931: fmInstance.setEnabled(true);
932: }
933: }
934: public void writeConfig(String file)
935: {
936: fmInstance.setCursor(Cursor.getPredefinedCursor(Cursor.WAIT_CURSOR));
937: fmInstance.setEnabled(false);
938:
939: Vector vectors[] = getListFromTable();
940: if(convertItem.isSelected()) mode = Convert.DataBase.CONVERT_MODE;
941: else
942: if(appendItem.isSelected()) mode = Convert.DataBase.APPEND_MODE;
943: else
944: if(updateItem.isSelected()) mode = Convert.DataBase.UPDATE_MODE;
945: else
946: if(deleteItem.isSelected()) mode = Convert.DataBase.DELETE_MODE;
947:
948: // TODO add id vector in table and write it out
949: Convert.DataBase source = new Convert.DataBase(bean,vectors[0],vectors[1],vectors[2],vectors[3],vectors[4],mode);
950: Convert.DataBase destination = new Convert.DataBase(destBean,new Vector(),new Vector(),new Vector(),new Vector(),new Vector(),-1);
951: source.delimiter =delimiter;
952: try
953: {
954: Convert.writeConfig(file,source,destination);
955: fmInstance.setCursor(Cursor.getPredefinedCursor(Cursor.DEFAULT_CURSOR));
956: fmInstance.setEnabled(true);
957:
958: } catch (Exception e)
959: {
960: fmInstance.setCursor(Cursor.getPredefinedCursor(Cursor.DEFAULT_CURSOR));
961: fmInstance.setEnabled(true);
962:
963: ByteArrayOutputStream b = new ByteArrayOutputStream();
964: PrintStream stream = new PrintStream(b);
965: e.printStackTrace(stream);
966: showErrorDialog(b.toString(), "Error while writing xml config !");
967: }
968:
969: }
970: public void readXMLConfig(String file)
971: {
972:
973: try
974: {
975: fmInstance.setCursor(Cursor.getPredefinedCursor(Cursor.WAIT_CURSOR));
976: fmInstance.setEnabled(false);
977: Vector databases = Convert.getXMLConfig(file);
978: Convert.DataBase destBase = (Convert.DataBase) databases.lastElement();
979: //destBase.bean.getConnection();
980: noUserUpdate = true;
981: destBean=destBase.bean;
982: Object destObj =destBean.url;
983: ((DefaultComboBoxModel) destURLBox.getModel()).removeElement(destObj);
984: ((DefaultComboBoxModel) destURLBox.getModel()).insertElementAt(destObj,0);
985: destURLBox.setSelectedItem(destObj);
986: databases.remove(destBase);
987: for (Iterator iter = databases.iterator(); iter.hasNext();)
988: {
989: Convert.DataBase database = (Convert.DataBase) iter.next();
990:
991: if (database.mode == Convert.DataBase.CONVERT_MODE)
992: {
993: convertItem.doClick();
994: } else if (database.mode == Convert.DataBase.APPEND_MODE)
995: {
996: appendItem.doClick();
997: } else if (database.mode == Convert.DataBase.UPDATE_MODE)
998: {
999: updateItem.doClick();
1000: } else if (database.mode == Convert.DataBase.DELETE_MODE)
1001: {
1002: deleteItem.doClick();
1003: }
1004: delimiter=database.delimiter;
1005: database.bean.getConnection();
1006:
1007: bean = database.bean;
1008: Object obj =bean.url;
1009: ((DefaultComboBoxModel) sourceURLBox.getModel()).removeElement(obj);
1010: ((DefaultComboBoxModel) sourceURLBox.getModel()).insertElementAt(obj,0);
1011: sourceURLBox.setSelectedItem(obj);
1012: fillTable();
1013: Vector tables=database.bean.getTableNames();
1014: Collections.sort(tables,String.CASE_INSENSITIVE_ORDER);
1015: int[] indices = new int[database.tables.size()];
1016: for (int i =0;i<database.tables.size();++i)
1017: {
1018: String table = (String) database.tables.get(i);
1019: int index=tables.indexOf(table);
1020: if(index<0) throw new RuntimeException("Error table \""+table+"\" does no longer exist\n at server "+bean.url +"\n or you mispelled the tablename.");
1021: noDBUpdate = true;
1022: tC.tableModel.setValueAt(new TableComponent.SQLCommand(database.selects.get(i).toString()),index,SELECT_INDEX);
1023:
1024: String create =database.creates.get(i).toString();
1025: tC.tableModel.setValueAt(new TableComponent.SQLCommand(create.equals("") ? create:" "+create),index,CREATE_INDEX);
1026: // tC.tableModel.setValueAt(new TableComponent.SQLCommand(bean.ids.get(i).toString()),index,ID_INDEX);
1027:
1028: Object comboBox=tC.tableModel.getValueAt(index,LAYOUT_INDEX);
1029: Object idcomboBox=tC.tableModel.getValueAt(index,ID_INDEX);
1030:
1031: indices[i] = index;
1032: if (comboBox != null)
1033: {
1034: String layout = database.layouts.get(i).toString();
1035: ((JComboBox) comboBox).setSelectedItem(layout);
1036: if (layout != "")
1037: {
1038: bean.makeQuery("select * from" + bean.getQC() + table + bean.getQC() + " layout " + bean.getQC() + layout + bean.getQC(), 1);
1039:
1040: Vector idVec = bean.getColumnNames();
1041: if (idVec == null)
1042: idVec = new Vector();
1043: idVec.add(0, "");
1044: ((JComboBox) idcomboBox).setModel(new DefaultComboBoxModel(idVec));
1045: }
1046:
1047: }
1048: if(idcomboBox!=null)((JComboBox)idcomboBox).setSelectedItem(bean.ids.get(i));
1049: tC.tableModel.fireTableDataChanged();
1050: noDBUpdate = false;
1051: noUserUpdate = false;
1052:
1053: }
1054: // add Selections
1055: ListSelectionModel lm = tC.table.getSelectionModel();
1056: for(int i=0;i<indices.length;++i)
1057: {
1058: lm.addSelectionInterval(indices[i],indices[i]);
1059: tC.tableModel.setValueAt(Boolean.TRUE,indices[i],STATUS_INDEX);
1060: }
1061: destBean.getConnection();
1062:
1063: DefaultListModel model = new DefaultListModel();
1064: tables = destBean.getTableNames();
1065: for (int j = 0; j < tables.size(); ++j)
1066: model.addElement(tables.get(j));
1067: // System.out.println("hallo" + tables + " ");
1068: tListDest.setModel(model);
1069: fmInstance.setCursor(Cursor.getPredefinedCursor(Cursor.DEFAULT_CURSOR));
1070: fmInstance.setEnabled(true);
1071:
1072: }
1073:
1074: } catch (Exception e)
1075: {
1076: noUserUpdate = false;
1077: noDBUpdate = false;
1078: fmInstance.setCursor(Cursor.getPredefinedCursor(Cursor.DEFAULT_CURSOR));
1079: fmInstance.setEnabled(true);
1080:
1081: ByteArrayOutputStream b = new ByteArrayOutputStream();
1082: PrintStream stream = new PrintStream(b);
1083: e.printStackTrace(stream);
1084: showErrorDialog(b.toString(), "Error while reading xml config !");
1085: }
1086:
1087: }
1088: public boolean showTable(int list)
1089: {
1090: ProgressDialog dialog = new ProgressDialog(fm,bean);
1091: dialog.setTitle("Preparing tables to be displayed");
1092: dialog.thread = Thread.currentThread();
1093: dialog.setCursor(Cursor.getPredefinedCursor(Cursor.WAIT_CURSOR));
1094: fmInstance.setCursor(Cursor.getPredefinedCursor(Cursor.WAIT_CURSOR));
1095: String query = new String();
1096: Object[] objs = tListDest.getSelectedValues();
1097: Vector[] vectors = getListFromTable();
1098: Vector tables = (list == 0) ? vectors[0] : new Vector();
1099: if (list > 0)
1100: for (int i = 0; i < objs.length; ++i)
1101: {
1102: if (debug)
1103: System.out.println(objs[i]);
1104: tables.add(objs[i]);
1105: }
1106: if (window != null)
1107: window.dispose();
1108: if (windowDest != null)
1109: windowDest.dispose();
1110:
1111: window = new MultiResultWindow(fm);
1112: if (list > 0)
1113: {
1114: windowDest = new MultiResultWindow(fm);
1115: window = windowDest;
1116: }
1117: dialog.setLocation(FM2SQL.fmInstance.getLocationOnScreen().x + (FM2SQL.fmInstance.getWidth() - 500) / 2, FM2SQL.fmInstance.getLocationOnScreen().y + (FM2SQL.fmInstance.getHeight() - 250) / 2);
1118: dialog.setSize(500, 250);
1119: if (!tables.isEmpty())
1120: dialog.show();
1121: dialog.title.setText("Preparing tables to be diplayed");
1122: for (int i = 0; i < tables.size(); ++i)
1123: {
1124: dialog.table.setText("Getting table " + tables.get(i));
1125: dialog.status.setText("Table " + (i + 1) + " of " + tables.size());
1126:
1127: if(list==0)
1128: query = "select * from " + bean.getQC() +tables.get(i).toString() + bean.getQC();
1129: else
1130: query = "select * from " + destBean.getQC() +tables.get(i).toString() + destBean.getQC();
1131: if(list==0) query = vectors[2].get(i).toString();
1132: if (list == 0 && vectors[1].get(i) != null)
1133: if (vectors[1].get(i).toString() != "")
1134: {
1135: String layout =" layout " + bean.getQC() + vectors[1].get(i).toString() + bean.getQC();
1136: String name = tables.get(i).toString();
1137: StringBuffer queryLayout=new StringBuffer(query);
1138: queryLayout.insert(queryLayout.indexOf(name)+name.length()+1," "+layout);
1139: query=queryLayout.toString();
1140: }
1141: if(debug)
1142: showErrorDialog("query in show tables is "+query,"Hello");
1143: window.title = " Table ;-) " + (String) tables.get(i);
1144: // break;
1145: // } else
1146: // window.title = "Error! - No valid tablename found";
1147:
1148: try
1149: {
1150: if ((query.toLowerCase().indexOf("insert") >= 0)
1151: || (query.toLowerCase().indexOf("delete") >= 0)
1152: || (query.toLowerCase().indexOf("alter") >= 0)
1153: || (query.toLowerCase().indexOf("update") >= 0))
1154: {
1155: Statement stm = (list > 0) ? destBean.getConnection().createStatement() : bean.getConnection().createStatement();
1156: stm.executeUpdate(query);
1157: Vector vec = new Vector();
1158: Vector vec2 = new Vector();
1159: Vector vec3 = new Vector();
1160: vec2.add(query);
1161: vec3.add(vec2);
1162: vec.add("Insert, update, etc done! No results available");
1163: // vec.add("no Results were produced");
1164:
1165: window.updateResult(vec3, vec);
1166: //window.pack();
1167: // window.setVisible(true);
1168:
1169: } else
1170: {
1171: Vector[] vecs = (list > 0) ? destBean.getQueryData(query, dialog, 50) : bean.getQueryData(query, dialog, 50);
1172: if (vecs[1].isEmpty())
1173: throw new Exception("Wrong columnname or Empty Layout");
1174: window.updateResult(vecs[0], vecs[1]);
1175:
1176: //window.pack();
1177: //String name = window.writeResult();
1178: //appendLog(window.title, name);
1179: }
1180:
1181: //window.setVisible(true);
1182:
1183: } catch (Exception e)
1184: {
1185: System.out.println("Exception occured");
1186: e.printStackTrace();
1187: Vector vec = new Vector();
1188: Vector vec2 = new Vector();
1189: Vector vec3 = new Vector();
1190: vec2.add(e.getMessage());
1191: vec3.add(vec2);
1192: vec.add("Exception occured! No results available");
1193: //vec.add("no Results were produced");
1194:
1195: window.updateResult(vec3, vec);
1196: //window.pack();
1197: // window.setVisible(true);
1198: fmInstance.setCursor(Cursor.getPredefinedCursor(Cursor.DEFAULT_CURSOR));
1199:
1200: }
1201: } // to for
1202: window.pack();
1203: window.setSize(700, 600);
1204:
1205: window.oldTabCount = 10000;
1206: dialog.dispose();
1207: fmInstance.setCursor(Cursor.getPredefinedCursor(Cursor.DEFAULT_CURSOR));
1208:
1209: return !tables.isEmpty();
1210:
1211: }
1212:
1213: public void dropTable()
1214: {
1215: String query = new String();
1216: Object[] objs = tListDest.getSelectedValues();
1217: Vector tables = new Vector();
1218: for (int i = 0; i < objs.length; ++i)
1219: {
1220: System.out.println(objs[i]);
1221: tables.add(objs[i]);
1222: }
1223:
1224: for (int i = 0; i < tables.size(); ++i)
1225: {
1226:
1227: query = "drop table "+destBean.getQC() + tables.get(i) + destBean.getQC();
1228:
1229: try
1230: {
1231: Statement stm = destBean.getConnection().createStatement();
1232: stm.executeUpdate(query);
1233: } catch (Exception e)
1234: {
1235: ByteArrayOutputStream b = new ByteArrayOutputStream();
1236: PrintStream stream = new PrintStream(b);
1237: e.printStackTrace(stream);
1238: showErrorDialog(b.toString(), "Open of table failed");
1239:
1240: }
1241: } // to for
1242: try
1243: {
1244: destBean.setConnection((String) destURLBox.getSelectedItem());
1245: DefaultListModel model = new DefaultListModel();
1246: tables = destBean.getTableNames();
1247: for (int j = 0; j < tables.size(); ++j)
1248: model.addElement(tables.get(j));
1249: System.out.println("hallo" + tables + " ");
1250: tListDest.setModel(model);
1251: } catch (Exception e4)
1252: {
1253: }
1254:
1255: }
1256: /**
1257: * invoked then the user changes the table or the tableModel changes
1258: */
1259: public void tableChanged(TableModelEvent e)
1260: {
1261: // if (e.getType() == e.INSERT)
1262: //System.out.println("Insert done");
1263: // if (e.getType() == e.UPDATE)
1264: // System.out.println("Update done");
1265: //if (e.getType() == e.DELETE)
1266: // System.out.println("Delete done");
1267: if (e.getType() == e.UPDATE && !noDBUpdate)
1268: {
1269: int row = e.getFirstRow(), col = e.getColumn();
1270: System.out.println("Got in " + row + " " + col );
1271: TableModel model = (TableModel)e.getSource();
1272: String columnName = model.getColumnName(col);
1273: Object test = model.getValueAt(row, col);
1274: String idVal = (test == null) ? "" : test.toString();
1275: String value = (test == null) ? "" : test.toString();;
1276:
1277: System.out.println("Got in " + columnName +" "+idVal);
1278: try
1279: {
1280: if(columnName.equals("select")||columnName.equals("Layouts"))
1281: {
1282: String table = model.getValueAt(row,NAME_INDEX).toString();
1283: String layout = (model.getValueAt(row,LAYOUT_INDEX)!=null) ?((JComboBox)model.getValueAt(row,LAYOUT_INDEX)).getSelectedItem().toString():"";
1284: String query = model.getValueAt(row,SELECT_INDEX).toString();
1285: String create = model.getValueAt(row,CREATE_INDEX).toString();
1286: String id = (model.getValueAt(row,ID_INDEX)!=null) ?((JComboBox)model.getValueAt(row,ID_INDEX)).getSelectedItem().toString():"";
1287:
1288: System.out.println("table" +table+" layout "+layout+" query "+query);
1289: if(!create.equals(""))
1290: {
1291: Object[] options = { "Yes","No"};
1292: int option=showDialog("Create Statement not empty! Do you want to overwrite?","create statement",options );
1293: if(option==0)
1294: model.setValueAt(createStatement(table,destBean,layout,query),row,CREATE_INDEX);
1295: }
1296: if (columnName.equals("Layouts"))
1297: {
1298:
1299: bean.makeQuery("select * from"+bean.getQC()+table+bean.getQC()+" layout "+bean.getQC()+layout+bean.getQC(),1);
1300:
1301: Vector idVec = bean.getColumnNames();
1302: if (idVec == null)
1303: idVec = new Vector();
1304: idVec.add(0, "");
1305: JComboBox box = ((JComboBox) model.getValueAt(row, ID_INDEX));
1306: box.setModel(new DefaultComboBoxModel(idVec));
1307: box.setSelectedItem(id);
1308:
1309: tC.tableModel.fireTableCellUpdated(row,ID_INDEX);
1310: }
1311:
1312: }
1313: /* Statement stm = bean.getConnection().createStatement();
1314: // stm.executeUpdate("DELETE FROM \""+fm.tables.get(0)+"\" WHERE \"erstellt von\"='rogo') ");
1315:
1316: if (idVal == "")
1317: stm.executeUpdate("INSERT INTO " + DBBean.quoteChar + box.getSelectedItem() + DBBean.quoteChar + " (" + DBBean.quoteChar + columnName + DBBean.quoteChar + ") VALUES ('" + value + "') ");
1318: else
1319: stm.executeUpdate(
1320: "UPDATE " + DBBean.quoteChar + box.getSelectedItem() + DBBean.quoteChar + " SET " + DBBean.quoteChar + columnName + DBBean.quoteChar + "='" + value + "' WHERE ID='" + idVal + "' ");
1321: */
1322: } catch (Exception e2)
1323: {
1324: fmInstance.setCursor(Cursor.getPredefinedCursor(Cursor.DEFAULT_CURSOR));
1325: ByteArrayOutputStream b = new ByteArrayOutputStream();
1326: PrintStream stream = new PrintStream(b);
1327: e2.printStackTrace(stream);
1328: showErrorDialog(b.toString(), "Error while updating table !");
1329: }
1330: }
1331: }
1332:
1333: /**
1334: * initialize the menubar
1335: */
1336: private void setMenu()
1337: {
1338: JMenuBar menubar = new JMenuBar();
1339: JMenu menu = new JMenu("File");
1340: menu.setMnemonic('F');
1341: JMenuItem item = new JMenuItem("open XML Config");
1342: item.setToolTipText("opens a XML config file for batch conversion");
1343: item.setMnemonic('i');
1344: item.setAccelerator(KeyStroke.getKeyStroke('O',InputEvent.CTRL_DOWN_MASK));
1345:
1346: item.addActionListener(fm);
1347: menu.add(item);
1348: item = new JMenuItem("save XML Config");
1349: item.setToolTipText("saves the current selections in an XML config file for batch conversion");
1350: item.setAccelerator(KeyStroke.getKeyStroke('S',InputEvent.CTRL_DOWN_MASK));
1351: item.setMnemonic('x');
1352:
1353: item.addActionListener(fm);
1354: menu.add(item);
1355: item = new JMenuItem("Quit");
1356: item.setMnemonic('Q');
1357: item.setToolTipText("Quits the application");
1358: item.setAccelerator(KeyStroke.getKeyStroke('Q',InputEvent.CTRL_DOWN_MASK));
1359: item.addActionListener(fm);
1360: menu.add(item);
1361:
1362: menubar.add(menu);
1363: menu = new JMenu("Options");
1364: menu.setMnemonic('O');
1365:
1366: ButtonGroup bgrp = new ButtonGroup();
1367: convertItem = new JCheckBoxMenuItem("Convert Mode");
1368: convertItem.setToolTipText("Normal table conversion existing table will be deleted");
1369: convertItem.addActionListener(fm);
1370:
1371: bgrp.add(convertItem);
1372:
1373: menu.add(convertItem);
1374: menubar.add(menu);
1375:
1376: appendItem = new JCheckBoxMenuItem("Append Mode");
1377: appendItem.setToolTipText("Appends data to an existing table");
1378: appendItem.addActionListener(fm);
1379:
1380: bgrp.add(appendItem);
1381:
1382: menu.add(appendItem);
1383: menubar.add(menu);
1384:
1385: updateItem = new JCheckBoxMenuItem("Update Mode");
1386: updateItem.setToolTipText("Updates data in an existing table");
1387: updateItem.addActionListener(fm);
1388:
1389: bgrp.add(updateItem);
1390:
1391: menu.add(updateItem);
1392: deleteItem = new JCheckBoxMenuItem("Delete Mode");
1393: deleteItem.setToolTipText("Deletes data in an existing table \n that has been deleted in source table");
1394: deleteItem.addActionListener(fm);
1395:
1396: bgrp.add(deleteItem);
1397:
1398: menu.add(deleteItem);
1399:
1400: menubar.add(menu);
1401: item = new JMenuItem("show Driver features");
1402: item.setToolTipText("shows the features of the selected driver");
1403: item.addActionListener(fm);
1404: menu.add(item);
1405: menubar.add(menu);
1406: delimiterItem = new JMenuItem("Delimiter");
1407: delimiterItem.setToolTipText("Delimiter for FM Arrayfields");
1408: delimiterItem.addActionListener(fm);
1409: menu.add(delimiterItem);
1410: menubar.add(menu);
1411:
1412: // item.addActionListener(fm);
1413: // menu.add(item);
1414:
1415: menubar.add(menu);
1416:
1417: menu.setBackground(fm.getBackground());
1418: menubar.setBackground(fm.getBackground());
1419: convertItem.doClick();
1420: setJMenuBar(menubar);
1421: }
1422: /**
1423: * open the log file (index.html)
1424: */
1425:
1426: public static void openLog() throws Exception
1427: {
1428:
1429: StringBuffer buff = new StringBuffer();
1430: buff.append("<html>");
1431: buff.append("<head>");
1432: buff.append("\n<title>");
1433: buff.append("FileMaker Test");
1434: buff.append("</title>\n");
1435: buff.append("</head>\n");
1436:
1437: buff.append("<body>\n");
1438: buff.append("<center>\n");
1439: buff.append("\n<h3>");
1440: buff.append("FileMaker Test");
1441: buff.append("</h3>\n");
1442:
1443: logFile.write(TableComponent.convertUml(buff).toString());
1444: logFile.flush();
1445: }
1446: /**
1447: * Append one entry to the log file(index.html)
1448: */
1449: public static void appendLog(String entry, String name) throws Exception
1450: {
1451: logFile.write("<a href=\"./" + name.substring(name.lastIndexOf("/") + 1) + "\">");
1452: logFile.write(entry + "</a>");
1453: logFile.write("<br>\n<br>\n");
1454: logFile.flush();
1455: }
1456: /**
1457: * closes the log file invoked then the application closes
1458: */
1459: public static void closeLog() throws Exception
1460: {
1461: logFile.write("\n</body>");
1462: logFile.write("\n</html>");
1463:
1464: logFile.close();
1465: }
1466: public static void showErrorDialog(String message, String title)
1467: {
1468: JDialog dialog = new JDialog(fmInstance);
1469: dialog.setTitle(title);
1470: JTextArea text = new JTextArea();
1471: JScrollPane scroller = new JScrollPane(text);
1472: dialog.getContentPane().add(scroller);
1473: text.append(message);
1474: dialog.setSize(600, 300);
1475: dialog.setLocationRelativeTo(fmInstance);
1476: dialog.show();
1477: //JOptionPane.showMessageDialog(null, message, title, JOptionPane.ERROR_MESSAGE);
1478: }
1479: public static class ProgressDialog extends JDialog
1480: {
1481: JLabel table = new JLabel(" ");
1482: JLabel status = new JLabel(" ");
1483: JLabel title = new JLabel(" ");
1484: JPanel content = new JPanel();
1485: JPanel titlePanel = new JPanel();
1486: JPanel labelPanel = new JPanel();
1487: JPanel statusPanel = new JPanel();
1488: JPanel buttonPanel = new JPanel();
1489:
1490: JProgressBar progress = new JProgressBar();
1491: JButton cancel = new JButton("Cancel");
1492: Thread thread;
1493: DBBean bean;
1494: public ProgressDialog(JFrame frame,DBBean bean)
1495: {
1496: super(frame);
1497: this.bean = bean;
1498:
1499: content = new JPanel(true);
1500: //content.setBorder(BorderFactory.createRaisedBevelBorder());
1501: content.setLayout(new BoxLayout(content, BoxLayout.Y_AXIS));
1502: title = new JLabel("Progress of conversion");
1503: title.setHorizontalTextPosition(title.CENTER);
1504: titlePanel.add(title);
1505: buttonPanel.add(cancel);
1506: // content.add(titlePanel);
1507: content.add(Box.createRigidArea(new java.awt.Dimension(0, 15)));
1508: content.add(labelPanel);
1509: content.add(new JLabel(""));
1510: content.add(progress);
1511: content.add(statusPanel);
1512: content.add(buttonPanel);
1513: content.add(Box.createRigidArea(new java.awt.Dimension(0, 15)));
1514: labelPanel.add(table);
1515: statusPanel.add(status);
1516: getContentPane().add(titlePanel, "North");
1517: getContentPane().add(content, "Center");
1518: this.addWindowListener(new WindowAdapter()
1519: {
1520: public void windowClosing(WindowEvent e)
1521: {
1522: cancel.doClick();
1523: }
1524: });
1525:
1526: cancel.addActionListener(new ActionListener()
1527: {
1528: public void actionPerformed(ActionEvent e)
1529: {
1530: fmInstance.setCursor(Cursor.getPredefinedCursor(Cursor.DEFAULT_CURSOR));
1531: fmInstance.setEnabled(true);
1532: setVisible(false);
1533: try
1534: {
1535: ProgressDialog.this.bean.getConnection().close();
1536: } catch (SQLException e1)
1537: {
1538: // TODO Auto-generated catch block
1539: e1.printStackTrace();
1540: } catch (Exception e1)
1541: {
1542: // TODO Auto-generated catch block
1543: e1.printStackTrace();
1544: }
1545: thread.stop();
1546: }
1547: });
1548: pack();
1549:
1550: }
1551:
1552: }
1553: public static class DelimiterDialog extends JDialog
1554: {
1555: JLabel table = new JLabel(" ");
1556: JLabel status = new JLabel(" ");
1557: JLabel title = new JLabel(" ");
1558: JPanel content = new JPanel();
1559: JPanel titlePanel = new JPanel();
1560: JPanel delimiterPanel = new JPanel();
1561: JPanel buttonPanel = new JPanel();
1562: JTextField delimiter = new JTextField(10);
1563:
1564: JButton cancel = new JButton("Cancel");
1565: JButton ok = new JButton("Ok");
1566: Thread thread;
1567: public DelimiterDialog(JFrame frame)
1568: {
1569: super(frame);
1570: setTitle("Delimiter Editor");
1571: setModal(true);
1572: content = new JPanel(true);
1573: delimiter.setText(fmInstance.delimiter);
1574: ActionListener al = new ActionListener()
1575: {
1576: public void actionPerformed(ActionEvent e)
1577: {
1578: fmInstance.delimiter=parseDelimiter(delimiter.getText());
1579: setVisible(false);
1580: }
1581:
1582: };
1583: this.addWindowListener(new WindowAdapter()
1584: {
1585: public void windowClosing(WindowEvent e)
1586: {
1587: cancel.doClick();
1588: }
1589: });
1590:
1591: //delimiter.setText(fmInstance.delimiter);
1592: delimiter.addActionListener(al);
1593: content.setLayout(new BoxLayout(content, BoxLayout.Y_AXIS));
1594: title = new JLabel("Enter Delimiter ");
1595: title.setHorizontalTextPosition(title.CENTER);
1596: titlePanel.add(title);
1597: buttonPanel.add(ok);
1598: buttonPanel.add(cancel);
1599: content.add(titlePanel);
1600: content.add(Box.createRigidArea(new java.awt.Dimension(0, 15)));
1601:
1602: content.add(new JLabel(""));
1603: content.add(delimiterPanel);
1604: content.add(buttonPanel);
1605: content.add(Box.createRigidArea(new java.awt.Dimension(0, 15)));
1606:
1607: delimiterPanel.add(new JLabel("Delimiter: "));
1608: delimiterPanel.add(delimiter);
1609: getContentPane().add(titlePanel, "North");
1610: getContentPane().add(content, "Center");
1611: ok.addActionListener(al);
1612: cancel.addActionListener(new ActionListener()
1613: {
1614: public void actionPerformed(ActionEvent e)
1615: {
1616: fmInstance.setCursor(Cursor.getPredefinedCursor(Cursor.DEFAULT_CURSOR));
1617: fmInstance.setEnabled(true);
1618: setVisible(false);
1619: // thread.stop();
1620: }
1621:
1622: });
1623: pack();
1624: setLocationRelativeTo(fmInstance);
1625: }
1626: public String parseDelimiter(Object o)
1627: {
1628: String str = o.toString();
1629: StringBuffer sbuff = new StringBuffer();
1630: int length = str.length();
1631: for(int i = 0;i<length;++i)
1632: {
1633:
1634: if(str.charAt(i)=='\\')
1635: {
1636: System.out.println(str.charAt(i));
1637: if (str.charAt(i + 1) == 'r')
1638: {
1639: sbuff.append("\r");
1640: }
1641: if (str.charAt(i + 1) == 't')
1642: {
1643: sbuff.append("\t");
1644: }
1645: if (str.charAt(i + 1) == 'n')
1646: {
1647: sbuff.append("\n");
1648: }
1649: if (str.charAt(i + 1) == '\\')
1650: {
1651: sbuff.append("\\");
1652: }
1653:
1654: if(i<length-1) ++i;
1655:
1656: } else sbuff.append(str.charAt(i));
1657: }
1658:
1659: return sbuff.toString();
1660: }
1661: }
1662:
1663:
1664: public static class PasswordDialog extends JDialog
1665: {
1666: JLabel table = new JLabel(" ");
1667: JLabel status = new JLabel(" ");
1668: JLabel title = new JLabel(" ");
1669: JPanel content = new JPanel();
1670: JPanel titlePanel = new JPanel();
1671: JPanel userPanel = new JPanel();
1672: JPanel passwordPanel = new JPanel();
1673: JPanel buttonPanel = new JPanel();
1674: JTextField user = new JTextField(10);
1675: JTextField passwd = new JPasswordField(10);
1676:
1677: JButton cancel = new JButton("Cancel");
1678: JButton ok = new JButton("Ok");
1679: DBBean bean = null;
1680: Thread thread;
1681: public PasswordDialog(JFrame frame, DBBean localBean)
1682: {
1683: super(frame);
1684: setTitle("PasswordDialog");
1685: setModal(true);
1686: content = new JPanel(true);
1687: this.bean = localBean;
1688: //content.setBorder(BorderFactory.createRaisedBevelBorder());
1689: ActionListener al = new ActionListener()
1690: {
1691: public void actionPerformed(ActionEvent e)
1692: {
1693: bean.setUserAndPasswd(user.getText(), passwd.getText());
1694: setVisible(false);
1695: }
1696:
1697: };
1698: this.addWindowListener(new WindowAdapter()
1699: {
1700: public void windowClosing(WindowEvent e)
1701: {
1702: cancel.doClick();
1703: }
1704: });
1705:
1706: user.setText(localBean.user);
1707: passwd.setText(localBean.passwd);
1708: user.addActionListener(al);
1709: passwd.addActionListener(al);
1710: content.setLayout(new BoxLayout(content, BoxLayout.Y_AXIS));
1711: title = new JLabel("Enter user and password ");
1712: title.setHorizontalTextPosition(title.CENTER);
1713: titlePanel.add(title);
1714: buttonPanel.add(ok);
1715: buttonPanel.add(cancel);
1716: content.add(titlePanel);
1717: content.add(Box.createRigidArea(new java.awt.Dimension(0, 15)));
1718: // content.add(labelPanel);
1719: content.add(new JLabel(""));
1720: content.add(userPanel);
1721: content.add(passwordPanel);
1722: content.add(buttonPanel);
1723: content.add(Box.createRigidArea(new java.awt.Dimension(0, 15)));
1724: //labelPanel.add(table);
1725: userPanel.add(new JLabel("Username: "));
1726: userPanel.add(user);
1727: passwordPanel.add(new JLabel("Password: "));
1728: passwordPanel.add(passwd);
1729: passwd.setPreferredSize(user.getPreferredSize());
1730: passwd.setMinimumSize(passwd.getPreferredSize());
1731: passwd.setMaximumSize(passwd.getPreferredSize());
1732: passwd.setSize(passwd.getPreferredSize());
1733: getContentPane().add(titlePanel, "North");
1734: getContentPane().add(content, "Center");
1735: ok.addActionListener(al);
1736: cancel.addActionListener(new ActionListener()
1737: {
1738: public void actionPerformed(ActionEvent e)
1739: {
1740: fmInstance.setCursor(Cursor.getPredefinedCursor(Cursor.DEFAULT_CURSOR));
1741: fmInstance.setEnabled(true);
1742: setVisible(false);
1743: thread.stop();
1744: }
1745:
1746: });
1747: pack();
1748:
1749: }
1750:
1751: }
1752: public void fillTable()
1753: {
1754: noDBUpdate = true;
1755: Vector tableNames = bean.getTableNames();
1756: Collections.sort(tableNames, String.CASE_INSENSITIVE_ORDER);
1757: Vector[] data = new Vector[2];
1758: data[1] = new Vector(6);
1759: data[1].setSize(6);
1760: data[1].set(STATUS_INDEX," ");
1761: data[1].set(NAME_INDEX," source Tablename ");
1762: data[1].set(LAYOUT_INDEX,"Layouts");
1763: data[1].set(SELECT_INDEX,"select");
1764: data[1].set(CREATE_INDEX,"create");
1765: data[1].set(ID_INDEX," id ");
1766: data[0] = new Vector();
1767: for (int i = 0; i < tableNames.size(); i++)
1768: {
1769: String name = tableNames.get(i).toString();
1770: Vector layouts = new Vector();
1771: Vector idVec = new Vector();
1772:
1773: try
1774: {
1775: bean.makeQuery("select * from"+bean.getQC()+name+bean.getQC(),1);
1776: layouts = bean.getLayoutNames(name);
1777: } catch (SQLException e)
1778: {
1779: layouts = new Vector();
1780: }
1781:
1782: idVec = bean.getColumnNames();
1783: if(idVec==null) idVec=new Vector();
1784: idVec.add(0,"");
1785: Vector dataRow = new Vector(6);
1786:
1787: dataRow.setSize(6);
1788: dataRow.set(STATUS_INDEX,Boolean.FALSE);
1789: dataRow.set(NAME_INDEX,name);
1790:
1791: dataRow.set(SELECT_INDEX,new TableComponent.SQLCommand("select * from " + bean.getQC() + name + bean.getQC()));
1792: if (!layouts.isEmpty())
1793: dataRow.set(LAYOUT_INDEX,new JComboBox(layouts));
1794: else
1795: dataRow.set(LAYOUT_INDEX,null);
1796:
1797:
1798: // create row
1799: dataRow.set(CREATE_INDEX,new TableComponent.SQLCommand(""));
1800: // id row
1801: dataRow.set(ID_INDEX,new TableComponent.IDComboBox(idVec));//new TableComponent.SQLCommand(""));
1802: bean.ids.add("");
1803: data[0].add(dataRow);
1804:
1805: //System.out.println(dataRow);
1806: }
1807:
1808: tC.booleanRenderer.renderFalseEmpty=true;
1809: tC.tableModel.setDataVector(data[0], data[1]);
1810: //@TODO new sizeToFit method needed
1811: //tC.sizeToFit(450, 250);
1812: Dimension dim=listPanel.getPreferredSize();
1813: tC.sizeToFit(dim.width,dim.height);
1814: tC.revalidate();
1815: tC.tableModel.fireTableDataChanged();
1816: noDBUpdate = false;
1817:
1818: }
1819: public Vector[] getListFromTable()
1820: {
1821: Vector[] vec = new Vector[5];
1822: vec[0] = new Vector();
1823: vec[1] = new Vector();
1824: vec[2] = new Vector();
1825: vec[3] = new Vector();
1826: vec[4] = new Vector();
1827: for(int i=0;i<tC.tableModel.getRowCount();++i)
1828: {
1829: }
1830: int[] rows = tC.table.getSelectedRows();
1831: for (int i = 0; i < tC.tableModel.getRowCount(); i++)
1832: {
1833: if(((Boolean)tC.tableModel.getValueAt(i,STATUS_INDEX))==Boolean.FALSE)
1834: {
1835: System.out.println("skipped row "+i);
1836: continue;
1837: }
1838:
1839: //System.out.println(tC.tableModel.getValueAt(rows[i],1));
1840: vec[0].add(tC.tableModel.getValueAt(i, NAME_INDEX));
1841: JComboBox box = ((JComboBox) tC.tableModel.getValueAt(i, LAYOUT_INDEX));
1842: String layoutName = (box != null) ? box.getSelectedItem().toString() : "";
1843:
1844: String idName = ((JComboBox)tC.tableModel.getValueAt(i, ID_INDEX)).getSelectedItem().toString();
1845: vec[1].add(layoutName);
1846: vec[2].add(tC.tableModel.getValueAt(i,SELECT_INDEX ).toString());
1847: vec[3].add(tC.tableModel.getValueAt(i, CREATE_INDEX).toString());
1848: vec[4].add(idName);
1849:
1850: }
1851: return vec;
1852: }
1853: public void setEnabled(boolean state)
1854: {
1855: showTables.setEnabled(state);
1856: showTables1.setEnabled(state);
1857: convert.setEnabled(state);
1858: dropTables.setEnabled(state);
1859: sourceURLBox.setEnabled(state);
1860: destURLBox.setEnabled(state);
1861:
1862: }
1863: public TableComponent.SQLCommand createStatement(String table,DBBean beanDest,String layout,String query) throws SQLException
1864: {
1865: fmInstance.setCursor(Cursor.getPredefinedCursor(Cursor.WAIT_CURSOR));
1866:
1867: if(beanDest.url.equals("")) beanDest.url=destURLBox.getSelectedItem().toString();
1868: StringBuffer command = new StringBuffer(50);
1869: command.append("\n CREATE TABLE ");
1870: command.append(beanDest.getQC());
1871: command.append(Convert.convertText(table));
1872: command.append(beanDest.getQC());
1873: command.append("\n ( ");
1874: String type = null;
1875: // String query = "select * from " + bean.getQC() +table + bean.getQC();
1876: if (!layout.equals(""))
1877: {
1878: layout = " layout " + bean.getQC() + layout + bean.getQC();
1879: StringBuffer queryLayout = new StringBuffer(query);
1880: queryLayout.insert(queryLayout.indexOf(table) + table.length() + 1, " " + layout);
1881: query = queryLayout.toString();
1882: System.out.println("added layout "+ query);
1883:
1884: }
1885: Vector[] result=bean.getQueryData(query,1);
1886: for (int i = 0; i < result[1].size() - 1; ++i)
1887: {
1888: type = bean.metaData.getColumnTypeName(i + 1);
1889: // System.out.println(i+" "+result[1].get(i)+" "+type);
1890: type = (type.equals("NUMBER")) ? "INT4" : type;
1891: type = (type.equals("CONTAINER")) ? "TEXT" : type;
1892: type = type.toUpperCase();
1893: if(i==0)
1894: command.append(beanDest.getQC() + Convert.convertText((String) result[1].get(i)) + beanDest.getQC() + " " + type + ", ");
1895: else
1896: command.append(" "+beanDest.getQC() + Convert.convertText((String) result[1].get(i)) + beanDest.getQC() + " " + type + ", ");
1897: command.append("\n");
1898: }
1899: type = bean.metaData.getColumnTypeName(result[1].size());
1900: type = (type.equals("NUMBER")) ? "INT4" : type;
1901: type = (type.equals("CONTAINER")) ? "TEXT" : type;
1902: type = type.toUpperCase();
1903: command.append(" "+beanDest.getQC() + Convert.convertText((String) result[1].get(result[1].size() - 1)) + beanDest.getQC() + " " + type);
1904: command.append("\n )\n");
1905: fmInstance.setCursor(Cursor.getPredefinedCursor(Cursor.DEFAULT_CURSOR));
1906:
1907: return new TableComponent.SQLCommand(command.toString());
1908: }
1909: static class XMLFilter extends javax.swing.filechooser.FileFilter
1910: {
1911: public boolean accept(java.io.File file)
1912: {
1913: if (file.getName().toLowerCase().endsWith(".xml") || file.isDirectory())
1914: return true;
1915: else
1916: return false;
1917: }
1918: public String getDescription()
1919: {
1920: return "Batch Convert XML File";
1921: }
1922:
1923: }
1924: public static int showDialog(String message, String title, Object[] options)
1925: {
1926: int option = JOptionPane.showOptionDialog(null, message, title, JOptionPane.DEFAULT_OPTION, JOptionPane.WARNING_MESSAGE, null, options, options[0]);
1927: return option;
1928:
1929: }
1930:
1931: }
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/cvs/cvsweb/icons/back.gif){kind=icon}
Return to FM2SQL.java CVS log ![[TXT]](/cvs/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvs/cvsweb/icons/dir.gif){kind=icon}
Up to [Repository] / FM2SQL