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