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