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