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