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