Annotation of FM2SQL/FM2SQL.java, revision 1.7

1.1       rogo        1: import javax.swing.*;
                      2: import javax.swing.event.*;
                      3: import javax.swing.table.TableModel;
                      4: 
                      5: import Convert.DataBase;
                      6: 
                      7: import java.awt.event.*;
                      8: import java.awt.Dimension;
                      9: import java.awt.*;
                     10: import java.sql.*;
                     11: import java.util.*;
                     12: import java.io.*;
                     13: /**
                     14:  *
                     15:  * <br>
                     16:  * <h2>FileMaker Test (JDBC Database Driver Test)</h2>
                     17:  * Main class :
                     18:  * contains the main Frame, all event handlers etc
                     19:  * <br>
                     20:  * The Database access is made over DBBean class
                     21:  * all other classes are just for the visualization of the data
1.7     ! rogo       22:  *  @version 0.3( first stable release)
1.1       rogo       23:  *  @author rogo
                     24:  *
                     25:  */
                     26: public class FM2SQL extends JFrame implements ActionListener, TableModelListener
                     27: {
                     28:   /**
                     29:   * The database Bean instance.
                     30:   *
                     31:   */
                     32:   DBBean bean;
                     33:   /**
                     34:    * The database destination Bean instance.
                     35:    *
                     36:    */
                     37:   DBBean destBean;
                     38: 
                     39:   /**
                     40:    *  box - Tablenames
                     41:    */
                     42: 
                     43:   JComboBox box;
                     44:   /**
                     45:    *  tList - Tablenames to choose from
                     46:    */
                     47: 
                     48:   JList tList = new JList(new String[] { "no database", "connection", "" });
                     49:   JList tListDest = new JList(new String[] { "no database connection", "", "" });
                     50: 
                     51:   /**
                     52:    *  box2 - Layout names
                     53:    */
                     54: 
                     55:   JComboBox box2;
                     56:   /**
                     57:   *  box3 - Database URLs
                     58:   */
                     59:   JComboBox box3;
                     60:   /**
                     61:   *  box4 - Database URLs
                     62:   */
                     63:   JComboBox box4;
                     64: 
                     65:   TableComponent table, tC;
                     66:   Vector tables = new Vector();
                     67:   Vector layouts = new Vector();
                     68:   JPanel listPanel;
1.2       rogo       69:   JPanel topPanel,topPanel2, contentPanel;
                     70:   JScrollPane paneDest;
1.1       rogo       71:   FM2SQL fm = this;
                     72:   boolean noDBUpdate = false;
                     73:   boolean noUserUpdate = false;
                     74:   int id = 0;
                     75:   static boolean debug = false;
                     76:   /**
                     77:   * The result window used for query results
                     78:   */
                     79:   MultiResultWindow window;
                     80:   /**
                     81:    * The result window used for query results
                     82:    */
                     83:   MultiResultWindow windowDest;
                     84: 
                     85:   static FM2SQL fmInstance;
                     86:   static String url = "jdbc:fmpro:http://141.14.237.42";
                     87:   JButton showTables = new JButton(), showTables1 = new JButton();
                     88:   JButton convert  = new JButton();
                     89:   JButton dropTables  = new JButton();
                     90: 
                     91:   int oldWidth = 0, oldHeight = 0;
                     92:   boolean resize = true;
                     93:   static FileWriter logFile;
                     94:   Dimension screenSize = java.awt.Toolkit.getDefaultToolkit().getScreenSize();
                     95:   JFileChooser configExportFileChooser;
                     96:   JFileChooser configImportFileChooser;
                     97:  
                     98:   /**
                     99:    * tries to connect to database specified in url-Variable.
                    100:    * initializes all GUI components, then fails throws an exception
                    101:    *
                    102:    */
                    103:   public FM2SQL() throws Exception
                    104:   {
1.2       rogo      105:     
1.3       rogo      106:     initializeGUI();
1.1       rogo      107:   }
1.2       rogo      108:   public void initializeGUI() throws Exception
                    109:   {
                    110:     Image local = getToolkit().getImage(getClass().getResource("icons/fm.jpg"));
                    111:     if (local != null);
                    112:     setIconImage(local);
                    113:     bean = new DBBean();
                    114:     destBean = new DBBean();
                    115:     box2 = new JComboBox();
                    116:     box3 = new JComboBox(new String[] { "jdbc:fmpro:http://141.14.237.74:8050", "jdbc:fmpro:http://localhost", "jdbc:postgresql://foxridge/test" });
                    117:     box3.setEditable(true);
                    118:     box4 = new JComboBox(new String[] { "jdbc:postgresql://foxridge/test", "jdbc:postgresql://erebos/test1" });
                    119:     box4.setEditable(true);
                    120:     box4.addActionListener(this);
                    121:     table = new TableComponent();
                    122:     box = new JComboBox(tables);
                    123:     box.addActionListener(this);
                    124:     box2.addActionListener(this);
                    125:     box3.addActionListener(this);
                    126: 
                    127:     contentPanel = new JPanel();
                    128:     contentPanel.setLayout(new BoxLayout(contentPanel, BoxLayout.Y_AXIS));
                    129: 
                    130:     box3.setMinimumSize(new Dimension(450, 20));
                    131:     box3.setMaximumSize(new Dimension(550, 20));
                    132:     box3.setPreferredSize(new Dimension(450, 20));
                    133:     box4.setMinimumSize(new Dimension(450, 20));
                    134:     box4.setMaximumSize(new Dimension(550, 20));
                    135:     box4.setPreferredSize(new Dimension(450, 20));
                    136:     paneDest = new JScrollPane(tListDest);
1.5       rogo      137:    // tListDest.setPreferredSize(paneDest.getPreferredSize());
1.2       rogo      138:    // paneDest.setPreferredSize(new Dimension(350, 365));
                    139:     Dimension dim = paneDest.getPreferredSize();
                    140:     paneDest.setMinimumSize(dim);
                    141:     //paneDest.setMaximumSize(new Dimension(dim.width + 50, dim.height + 50));
                    142:  
                    143:     tC = new TableComponent();
                    144:     tC.sizeToFit(450, 250);
                    145:     tC.tableModel.addTableModelListener(this);
                    146:     JPanel destPanel = new JPanel();
                    147:     destPanel.setLayout(new java.awt.GridBagLayout());
                    148: 
                    149:     listPanel = new JPanel();
                    150:     listPanel.setLayout(new java.awt.GridBagLayout());
                    151:     java.awt.GridBagConstraints gbc = new java.awt.GridBagConstraints();
                    152:     JScrollPane pane = new JScrollPane(tList);
                    153:     tC.tableScroller.setPreferredSize(new Dimension(450, 365));
                    154:     //tC.table.revalidate();
                    155:     tC.tableScroller.setMinimumSize(new Dimension(450, 250));
                    156:     // tC.tableScroller.setMaximumSize(tC.tableScroller.getPreferredSize());
                    157:     topPanel = new JPanel();
                    158:     topPanel.setLayout(new GridBagLayout());
                    159:     topPanel2 = new JPanel();
                    160:     topPanel2.setLayout(new GridBagLayout());
                    161: 
                    162:     gbc.gridx = 0;
                    163:     gbc.gridy = 0;
                    164:     gbc.weightx = 0.1;
                    165:     gbc.weighty = 0.1;
                    166:     gbc.gridwidth = 1;
                    167:     gbc.gridheight = 1;
                    168:     gbc.insets = new Insets(2, 2, 5, 5);
                    169:     gbc.ipadx = 1;
                    170:     gbc.ipady = 1;
                    171: 
                    172:     gbc.anchor = GridBagConstraints.WEST;
                    173:     listPanel.add(topPanel, gbc);
                    174:     destPanel.add(topPanel2, gbc);
                    175:    
                    176:     topPanel.add(new JLabel("Choose src database: ", JLabel.CENTER), gbc);
                    177:     topPanel2.add(new JLabel("Choose dest database : ", JLabel.CENTER), gbc);
                    178: 
                    179:     gbc.anchor = GridBagConstraints.NORTHWEST;
                    180:     gbc.gridy = 1;
                    181:     topPanel.add(box3, gbc);
                    182: 
                    183:     topPanel2.add(box4, gbc);
                    184: 
                    185:     //gbc.gridx=GridBagConstraints.RELATIVE;   
                    186:     //dataBasePanel.add(new JLabel("  select Tables to Convert  ", JLabel.LEFT));
                    187:     gbc.gridy = 1;
                    188:     gbc.anchor = GridBagConstraints.SOUTHWEST;
                    189: 
                    190:     listPanel.add(new JLabel(" select Tables to Convert  ", JLabel.LEFT), gbc);
                    191:     destPanel.add(new JLabel("  Tables in database  ", JLabel.LEFT), gbc);
                    192: 
                    193:     //  gbc.anchor = GridBagConstraints.WEST;
                    194:     gbc.gridy = 2;
                    195:     gbc.gridx = 0;
                    196:     // gbc.weightx = 0.0;
                    197:     //dataBasePanel.add(tC);
                    198:     gbc.anchor = GridBagConstraints.NORTHWEST;
                    199:     gbc.gridheight = 1;
                    200:     gbc.fill = GridBagConstraints.BOTH;
                    201:     listPanel.add(tC.tableScroller, gbc);
1.4       rogo      202:    // gbc.fill = GridBagConstraints.VERTICAL;
1.2       rogo      203:     destPanel.add(paneDest, gbc);
                    204:     showTables1 = new JButton("show Tables");
                    205:     showTables1.setActionCommand("show Tables source");
                    206:     //  gbc.anchor = GridBagConstraints.NORTH;
                    207:     //  gbc.weightx = 0.0;
                    208:     gbc.fill = GridBagConstraints.NONE;
                    209:     gbc.gridheight = 1;
                    210: 
                    211:     gbc.gridx = 0;
                    212:     gbc.gridy = 2;
1.3       rogo      213:    // topPanel.add(showTables1, gbc);
1.2       rogo      214:     JPanel buttonPanel = new JPanel();
                    215:     buttonPanel.setLayout(new BoxLayout(buttonPanel, BoxLayout.X_AXIS));
1.5       rogo      216:     buttonPanel.setMinimumSize(new Dimension(380, 30));
1.2       rogo      217:     convert = new JButton("Convert Tables");
                    218:     showTables = new JButton("show Tables");
                    219:     dropTables = new JButton("drop Tables");
                    220:     //   System.out.println(convert.getPreferredSize());
                    221:     showTables.setMinimumSize(convert.getPreferredSize());
                    222:     dropTables.setMinimumSize(convert.getPreferredSize());
                    223:     showTables.setMaximumSize(convert.getPreferredSize());
                    224:     dropTables.setMaximumSize(convert.getPreferredSize());
                    225:     showTables.setPreferredSize(convert.getPreferredSize());
                    226:     dropTables.setPreferredSize(convert.getPreferredSize());
                    227: 
                    228:     showTables.addActionListener(fm);
                    229:     showTables1.addActionListener(fm);
                    230: 
                    231:     buttonPanel.add(showTables);
                    232:     buttonPanel.add(convert);
                    233:     convert.addActionListener(fm);
                    234:     dropTables.addActionListener(fm);
                    235:     buttonPanel.add(dropTables);
                    236: 
1.3       rogo      237:     JPanel buttonPanelSrc = new JPanel();
                    238:     buttonPanelSrc.setLayout(new BoxLayout(buttonPanelSrc, BoxLayout.X_AXIS));
                    239:     buttonPanelSrc.setMinimumSize(new Dimension(200, 30));
                    240:     buttonPanelSrc.add(showTables1);
                    241:     
                    242:     topPanel.add(buttonPanelSrc, gbc);
1.2       rogo      243:     topPanel2.add(buttonPanel, gbc);
1.3       rogo      244:    
1.2       rogo      245:     // gbc.anchor = GridBagConstraints.WEST;
                    246:     //   gbc.gridy = 1;
                    247:     //   gbc.gridx = 2;
                    248:     //   gbc.weightx = 0.2;
                    249: 
                    250:     // gbc.gridx = 3;
                    251:     //  gbc.anchor = GridBagConstraints.NORTHWEST;
                    252:     //  gbc.gridy = 1;
                    253:     // gbc.weightx = 1.0;
                    254:     //listPanel.add(buttonPanel, gbc);
                    255:     JSplitPane splitter = new JSplitPane();
                    256:     splitter.setTopComponent(listPanel);
                    257:     splitter.setBottomComponent(destPanel);
                    258: 
                    259:     // contentPanel.add(dataBasePanel);
                    260:     //   contentPanel.add(listPanel);
                    261:     listPanel.setMaximumSize(new Dimension(660, 750));
                    262:     listPanel.setMinimumSize(new Dimension(660, 250));
                    263:     listPanel.setPreferredSize(new Dimension(480, 500));
                    264:     paneDest.setPreferredSize(new Dimension(250, 285));
                    265: 
                    266:     getContentPane().add(splitter, "Center");
                    267:     this.addWindowListener(new WindowAdapter()
                    268:     {
                    269:       public void windowClosing(WindowEvent e)
                    270:       {
                    271:         System.exit(0);
                    272:       }
                    273:     });
                    274:     addComponentListener(new ComponentAdapter()
                    275:     {
                    276:       public void componentResized(ComponentEvent e)
                    277:       {
                    278: 
                    279:         if (oldWidth != getWidth() || oldHeight != getHeight())
                    280:         {
                    281:           table.sizeToFit(getWidth(), getHeight());
                    282: 
                    283:           Dimension dim = table.table.getPreferredSize();
                    284:           int size = contentPanel.getPreferredSize().height + new JScrollBar().getPreferredSize().height + new JMenuBar().getPreferredSize().height + 10;
                    285: 
                    286:           table.tableScroller.setPreferredSize(new Dimension(getWidth() - 15, getHeight() - size));
                    287:           Dimension d2 = table.tableScroller.getPreferredSize();
                    288: 
                    289:           oldWidth = getWidth();
                    290:           oldHeight = getHeight();
                    291: 
                    292:           table.setPreferredSize(new Dimension(d2.width + 15, d2.height + 5));
                    293:           table.table.revalidate();
                    294:           table.tableScroller.revalidate();
                    295:           table.revalidate();
                    296:           if (getHeight() > table.table.getPreferredSize().height + (2 * size))
                    297:             setSize(getWidth(), table.table.getPreferredSize().height + 2 * size);
                    298:           // System.out.println("size" + size);
                    299:         }
                    300:         //   listPanel.setMaximumSize(new Dimension(getPreferredSize().width - 5, 550));
                    301:         //   listPanel.setMinimumSize(new Dimension(getPreferredSize().width - 5, 200));
                    302:         //    listPanel.setPreferredSize(new Dimension(getPreferredSize().width - 5, 370));
                    303:         tC.tableScroller.revalidate();
                    304:         Dimension dim = getSize();
1.3       rogo      305:         tC.tableScroller.setMinimumSize(new Dimension(dim.width-400, dim.height - topPanel.getPreferredSize().height - 100));
1.2       rogo      306:         tC.tableScroller.setMaximumSize(getSize());
1.3       rogo      307:         tC.tableScroller.setPreferredSize(tC.tableScroller.getMinimumSize());
                    308:      
                    309:         paneDest.setMinimumSize(new Dimension(400, dim.height - topPanel2.getPreferredSize().height - 100));
1.2       rogo      310:         paneDest.setMaximumSize(tC.tableScroller.getMaximumSize());
1.3       rogo      311:         paneDest.setPreferredSize(new Dimension(400, dim.height - topPanel2.getPreferredSize().height - 100));
                    312:     
1.2       rogo      313:         paneDest.validate();
                    314:         // tC.tableScroller.setPreferredSize(getSize());
                    315:         tC.sizeToFit(getWidth(), getHeight());
                    316:         ((JPanel) getContentPane()).revalidate();
                    317:         repaint();
                    318:         setTitle("Filemaker 2 SQL Conversion Tool ");
                    319: 
                    320:       }
                    321:     });
                    322: 
                    323:     setMenu();
                    324:     //setSize(800, 600);
                    325:     pack();
                    326:     setLocation((screenSize.width - getWidth()) / 2, (screenSize.height - getHeight()) / 2);
                    327:     //setVisible(true);
                    328:     validate();
                    329: 
                    330:     // repaint();
                    331: 
                    332:   }
1.1       rogo      333: 
                    334:   /**
                    335:    *
                    336:    */
                    337:   public static void main(String[] args)
                    338:   {
                    339:     try
                    340:     {
                    341:       System.setErr(System.out);
                    342: //         Properties prop = System.getProperties();
                    343:   // Enumeration enum= prop.keys();
                    344: //  while(enum.hasMoreElements())
                    345: //System.out.println(enum.nextElement());
                    346:      
                    347:       if (System.getProperty("os.name").startsWith("W"))
                    348:         // javax.swing.UIManager.setLookAndFeel(
                    349:         //    new com.sun.java.swing.plaf.windows.WindowsLookAndFeel());
                    350:         javax.swing.UIManager.put("Table.focusCellHighlightBorder", new javax.swing.border.LineBorder(java.awt.Color.black));
                    351:       javax.swing.UIManager.put("Table.focusCellBackground", new java.awt.Color(227, 227, 227, 127));
                    352: 
                    353:       fmInstance = new FM2SQL();
                    354:       fmInstance.table.tableModel.addTableModelListener(fmInstance);
                    355:       fmInstance.setVisible(true);
                    356:       /*   if (!new File("./html").exists())
                    357:            new File("./html").mkdirs();
                    358:          logFile = new FileWriter("./html/index.html");
                    359:          openLog();
                    360:       */
                    361:     } catch (Exception e)
                    362:     {
                    363:       JOptionPane pane = new JOptionPane(e.getMessage() + "  \n URL: " + url, JOptionPane.ERROR_MESSAGE);
                    364: 
                    365:       JDialog dialog = pane.createDialog(null, " Exception occured while connecting");
                    366:       e.printStackTrace();
                    367:       dialog.addWindowListener(new WindowAdapter()
                    368:       {
                    369:         public void windowClosing(WindowEvent e)
                    370:         {
                    371:           System.exit(0);
                    372:         }
                    373:       });
                    374:       dialog.addComponentListener(new ComponentAdapter()
                    375:       {
                    376: 
                    377:         public void componentHidden(ComponentEvent e)
                    378:         {
                    379: 
                    380:           System.exit(0);
                    381:         }
                    382:       });
                    383:       dialog.show();
                    384:     }
                    385:   }
                    386:   public void actionPerformed(ActionEvent e)
                    387:   {
                    388:     String command = e.getActionCommand();
                    389:     if (debug)
                    390:       System.out.println("command " + command);
                    391:     if (command == "comboBoxEdited")
                    392:     {
                    393:       Object src = e.getSource();
                    394:       if (src == box3)
                    395:       {
                    396:         if (debug)
                    397:           System.out.println("hey" + box3.getSelectedItem());
                    398:         Object insObj =box3.getSelectedItem();
                    399:         ((DefaultComboBoxModel) box3.getModel()).removeElement(insObj);
                    400:    
                    401:         ((DefaultComboBoxModel) box3.getModel()).insertElementAt(insObj, 0);
                    402:         box3.setSelectedItem(insObj);
                    403:       } else if (src == box4)
                    404:       {
                    405:         if (debug)
                    406:           System.out.println("hey" + box4.getSelectedItem());
                    407:         //((DefaultComboBoxModel) box4.getModel()).insertElementAt(box4.getSelectedItem(), 0);
                    408:         try
                    409:         {
                    410:           String selected = (String) box4.getSelectedItem();
                    411:           destBean.setConnection(selected);
                    412:           Vector catalogs = destBean.getCatalogs();
                    413:           Vector urls = new Vector();
                    414:           for (int i = 0; i < catalogs.size(); ++i)
                    415:           {
                    416:             urls.add(destBean.url.substring(0, destBean.url.lastIndexOf("/") + 1) + catalogs.get(i));
                    417:           }
                    418:           box4.setModel(new DefaultComboBoxModel(urls));
                    419:           box4.setSelectedItem(selected);
                    420:         } catch (Exception e5)
                    421:         {
                    422:         }
                    423:       }
                    424:     }
                    425:     if (command == "comboBoxChanged")
                    426:     {
                    427:       try
                    428:       {
                    429:         //System.out.println("hallo " + (e.getSource() == box3));
                    430: 
                    431:         Object src = e.getSource();
                    432:         if (src == box3&&!noUserUpdate)
                    433:         {
                    434:           Thread thread = new Thread()
                    435:           {
                    436:             public void run()
                    437:             {
                    438: 
                    439:               try
                    440:               {
                    441:                 PasswordDialog dialog = new PasswordDialog(fmInstance, bean);
                    442:                 dialog.setLocationRelativeTo(box3);
                    443:                 dialog.thread = Thread.currentThread();
                    444:                 fmInstance.setCursor(Cursor.getPredefinedCursor(Cursor.WAIT_CURSOR));
                    445:                 fmInstance.setEnabled(false);
                    446:                 dialog.setVisible(true);
                    447:                 String url = box3.getSelectedItem().toString();
                    448:                 bean.url = (url != null) ? url : bean.url;
                    449:                 bean.connection = null;
                    450:                 bean.getConnection();
                    451:                 tables = bean.getTableNames();
                    452:                 fillTable();
                    453:                 fmInstance.setCursor(Cursor.getPredefinedCursor(Cursor.DEFAULT_CURSOR));
                    454:                                fmInstance.setEnabled(true);
                    455:                 //  System.out.println("hallo" + tables + " ");
                    456:               } catch (Exception e5)
                    457:               {
                    458:                 ByteArrayOutputStream b = new ByteArrayOutputStream();
                    459:                 PrintStream stream = new PrintStream(b);
                    460:                 e5.printStackTrace(stream);
                    461:                 fmInstance.setCursor(Cursor.getPredefinedCursor(Cursor.DEFAULT_CURSOR));
                    462:                                fmInstance.setEnabled(true);
                    463:                 Vector header = new Vector();
                    464:                 header.add("no database");
                    465:                 header.add("connection");
                    466:                 Vector rows = new Vector();
                    467:                 //rows.add(header);
                    468:                 noDBUpdate=true;
                    469:                 tC.tableModel.setDataVector(rows, header);
                    470:                 tC.tableModel.setRowCount(20);
                    471:                 tC.revalidate();
                    472:                 tC.tableModel.fireTableDataChanged();
                    473:                 noDBUpdate=false;
                    474:                 showErrorDialog(b.toString(), "Error occured !");
                    475:               }
                    476:             }
                    477:           };
                    478:           thread.start();
                    479:         } else if (src == box4&&!noUserUpdate)
                    480:         {
                    481:           Thread thread = new Thread()
                    482:           {
                    483:             public void run()
                    484:             {
                    485: 
                    486:               try
                    487:               {
                    488: 
                    489:                 PasswordDialog dialog = new PasswordDialog(fmInstance, destBean);
                    490:                 dialog.setLocationRelativeTo(box4);
                    491:                 dialog.thread = Thread.currentThread();
                    492:                 fmInstance.setCursor(Cursor.getPredefinedCursor(Cursor.WAIT_CURSOR));
                    493:                                fmInstance.setEnabled(false);
                    494:                 dialog.setVisible(true);
                    495:                 destBean.setConnection((String) box4.getSelectedItem());
                    496:                 DefaultListModel model = new DefaultListModel();
                    497:                 Vector tables = destBean.getTableNames();
                    498:                 for (int j = 0; j < tables.size(); ++j)
                    499:                   model.addElement(tables.get(j));
                    500:                 //  System.out.println("hallo" + tables + " ");
                    501:                 tListDest.setModel(model);
                    502:                 //  System.out.println("hallo" + tables + " ");
                    503:                 fmInstance.setCursor(Cursor.getPredefinedCursor(Cursor.DEFAULT_CURSOR));
                    504:                                fmInstance.setEnabled(true);
                    505:               } catch (Exception e5)
                    506:               {
                    507:                 ByteArrayOutputStream b = new ByteArrayOutputStream();
                    508:                 PrintStream stream = new PrintStream(b);
                    509:                 e5.printStackTrace(stream);
                    510:                                fmInstance.setEnabled(true);
                    511:                 fmInstance.setCursor(Cursor.getPredefinedCursor(Cursor.DEFAULT_CURSOR));
                    512:                 DefaultListModel model = new DefaultListModel();
                    513:                 model.addElement("no database connection");
                    514:                 tListDest.setModel(model);
                    515: 
                    516:                 showErrorDialog(b.toString(), "Error occured !");
                    517:               }
                    518:             }
                    519:           };
                    520:           thread.start();
                    521: 
                    522:         }
1.2       rogo      523:         setTitle("Filemaker 2 SQL Conversion Tool ");
1.1       rogo      524:         // pack();
                    525: 
                    526:       } catch (Exception e4)
                    527:       {
                    528:         ByteArrayOutputStream b = new ByteArrayOutputStream();
                    529:         PrintStream stream = new PrintStream(b);
                    530:         e4.printStackTrace(stream);
                    531:         showErrorDialog(b.toString(), "Open of table failed");
                    532: 
                    533:       }
                    534:     }
                    535:     if (command == "show Driver features")
                    536:     {
                    537:       ResultWindow result = new ResultWindow(this);
                    538:       try
                    539:       {
                    540:         Vector[] vecs = bean.TestDB(bean.getConnection().getMetaData());
                    541:         result.updateResult(vecs[0], vecs[1]);
                    542:         // result.pack();
                    543:         result.title = "Database features";
                    544:         result.setVisible(true);
                    545:         String name = result.writeResult();
                    546:       } catch (Exception e2)
                    547:       {
                    548:       }
                    549:     }
                    550:    //writing config
1.6       rogo      551:     if (command.equals("save XML Config"))
1.1       rogo      552:     {
                    553:       if (configExportFileChooser == null)
                    554:       {
                    555:         configExportFileChooser = new JFileChooser();
                    556:         configExportFileChooser.setFileSelectionMode(JFileChooser.FILES_AND_DIRECTORIES);
                    557:         configExportFileChooser.setFileFilter(new XMLFilter());
                    558:         configExportFileChooser.setDialogType(JFileChooser.SAVE_DIALOG);
                    559:         configExportFileChooser.addActionListener(new ActionListener()
                    560:         {
                    561:           public void actionPerformed(ActionEvent e2)
                    562:           {
                    563:             System.out.println(e2.getActionCommand());
                    564:             if (!e2.getActionCommand().toString().equals("ApproveSelection"))
                    565:               return;
                    566: 
                    567:             Thread thread = new Thread()
                    568:             {
                    569:               public void run()
                    570:               {
                    571:                 File configFile = configExportFileChooser.getSelectedFile();
                    572:                 writeConfig(configFile.toString());
                    573: 
                    574:               }
                    575:             };
                    576:             thread.start();
                    577: 
                    578:           }
                    579:         });
                    580:       }
                    581:       configExportFileChooser.rescanCurrentDirectory();
                    582:       configExportFileChooser.showDialog(fmInstance, " Save ");
                    583:    
                    584:     }
1.6       rogo      585:     if (command.equals("open XML Config"))
1.1       rogo      586:     {
                    587:       if (configImportFileChooser == null)
                    588:       {
                    589:         configImportFileChooser = new JFileChooser();
                    590:         configImportFileChooser.setFileSelectionMode(JFileChooser.FILES_AND_DIRECTORIES);
                    591:         configImportFileChooser.setFileFilter(new XMLFilter());
                    592:         configImportFileChooser.setDialogType(JFileChooser.OPEN_DIALOG);
                    593:         configImportFileChooser.addActionListener(new ActionListener()
                    594:         {
                    595:           public void actionPerformed(ActionEvent e2)
                    596:           {
                    597:             System.out.println(e2.getActionCommand());
                    598:             if (!e2.getActionCommand().toString().equals("ApproveSelection"))
                    599:               return;
                    600: 
                    601:             Thread thread = new Thread()
                    602:             {
                    603:               public void run()
                    604:               {
                    605:                 File configFile = configImportFileChooser.getSelectedFile();
                    606:                 readXMLConfig(configFile.toString());
                    607: 
                    608:               }
                    609:             };
                    610:             thread.start();
                    611: 
                    612:           }
                    613:         });
                    614:       }
                    615:       configImportFileChooser.rescanCurrentDirectory();
                    616:       configImportFileChooser.showDialog(fmInstance, " Open ");
                    617:    
                    618:     }
                    619:       
                    620:      
                    621:     if (command.equals("Convert Tables"))
                    622:     {
                    623: 
                    624:       Thread thread = new Thread()
                    625:       {
                    626:         public void run()
                    627:         {
                    628:           setEnabled(false);
                    629:           convert();
                    630:           setEnabled(true);
                    631:         }
                    632: 
                    633:       };
                    634:       thread.start();
                    635:     }
                    636:     if (command.equals("show Tables"))
                    637:     {
                    638:       Thread thread = new Thread()
                    639:       {
                    640:         public void run()
                    641:         {
                    642:                    fmInstance.setEnabled(false);
                    643:           boolean visible = showTable(1);
                    644:           window.validate();
                    645:           window.setVisible(visible);
                    646:                    fmInstance.setEnabled(true);
                    647: 
                    648:         }
                    649:       };
                    650:       thread.start();
                    651:       //  System.out.println("hello");
                    652: 
                    653:     }
                    654:     if (command.equals("show Tables source"))
                    655:     {
                    656:       Thread thread = new Thread()
                    657:       {
                    658:         public void run()
                    659:         {
                    660:                    fmInstance.setEnabled(false);
                    661:           boolean visible = showTable(0);
                    662:           window.validate();
                    663:           window.setVisible(visible);
                    664:                    fmInstance.setEnabled(true);
                    665:         }
                    666:       };
                    667:       thread.start();
                    668:       //       System.out.println("hello"+thread);
                    669: 
                    670:     }
                    671: 
                    672:     if (command.equals("drop Tables"))
                    673:     {
                    674:       Thread thread = new Thread()
                    675:       {
                    676:         public void run()
                    677:         {
                    678:           dropTable();
                    679:         }
                    680:       };
                    681:       thread.start();
                    682:     }
1.6       rogo      683:   if(command.equals("Quit"))
                    684:    {
                    685:      fmInstance.dispose();
                    686:      System.exit(0);
                    687:   
                    688:    }
                    689:    
1.1       rogo      690:   }
                    691:   /**
                    692:    * Copys the content of source to destination and makes new table if necessary
                    693:    */
                    694:   public void convert()
                    695:   {
                    696: 
                    697:     Vector vectors[] = getListFromTable();
                    698:     Convert.user = bean.user;
                    699:     Convert.passwd = bean.passwd;
                    700:     Convert.userDest = destBean.user;
                    701:     Convert.passwdDest = destBean.passwd;
                    702:     try
                    703:     {
                    704:       fmInstance.setCursor(Cursor.getPredefinedCursor(Cursor.WAIT_CURSOR));
                    705:       fmInstance.setEnabled(false);
                    706:       Convert.convert(bean.url, box4.getSelectedItem().toString(), vectors[0], vectors[1],vectors[2],vectors[3]);
                    707: 
                    708:       destBean.setConnection((String) box4.getSelectedItem());
                    709:       DefaultListModel model = new DefaultListModel();
                    710:       tables = destBean.getTableNames();
                    711:       for (int j = 0; j < tables.size(); ++j)
                    712:         model.addElement(tables.get(j));
                    713:       if (debug)
                    714:         System.out.println("hallo" + tables + " ");
                    715:       tListDest.setModel(model);
                    716:       fmInstance.setCursor(Cursor.getPredefinedCursor(Cursor.DEFAULT_CURSOR));
                    717:     } catch (Exception e4)
                    718:     {
                    719:       ByteArrayOutputStream b = new ByteArrayOutputStream();
                    720:       PrintStream stream = new PrintStream(b);
                    721:       e4.printStackTrace(stream);
                    722:       showErrorDialog(b.toString(), "Conversion of table failed");
                    723:       fmInstance.setEnabled(true);
                    724:     }
                    725:   }
                    726:   public void writeConfig(String file)
                    727:   {
                    728:     fmInstance.setCursor(Cursor.getPredefinedCursor(Cursor.WAIT_CURSOR));
                    729:     fmInstance.setEnabled(false);
                    730: 
                    731:     Vector vectors[] = getListFromTable();
                    732:     Convert.DataBase source = new Convert.DataBase(bean,vectors[0],vectors[1],vectors[2],vectors[3]);
                    733:     Convert.DataBase destination = new Convert.DataBase(destBean,new Vector(),new Vector(),new Vector(),new Vector());
                    734:    
                    735:     try
                    736:     {
                    737:       Convert.writeConfig(file,source,destination);
                    738:       fmInstance.setCursor(Cursor.getPredefinedCursor(Cursor.DEFAULT_CURSOR));
                    739:       fmInstance.setEnabled(true);
                    740: 
                    741:     } catch (Exception e)
                    742:     {
                    743:       fmInstance.setCursor(Cursor.getPredefinedCursor(Cursor.DEFAULT_CURSOR));
                    744:       fmInstance.setEnabled(true);
                    745: 
                    746:       ByteArrayOutputStream b = new ByteArrayOutputStream();
                    747:       PrintStream stream = new PrintStream(b);
                    748:       e.printStackTrace(stream);
                    749:       showErrorDialog(b.toString(), "Error while writing xml config  !");
                    750:   }
                    751:   
                    752:   }
                    753:   public void readXMLConfig(String file)
                    754:   {
                    755:      
                    756:     try
                    757:     {
                    758:       fmInstance.setCursor(Cursor.getPredefinedCursor(Cursor.WAIT_CURSOR));
                    759:       fmInstance.setEnabled(false);
                    760:       Vector databases = Convert.getXMLConfig(file);
                    761:       DataBase destBase = (DataBase) databases.lastElement();
                    762:       //destBase.bean.getConnection();
                    763:       noUserUpdate = true;
                    764:       destBean=destBase.bean;
                    765:       Object destObj =destBean.url;
                    766:       ((DefaultComboBoxModel) box4.getModel()).removeElement(destObj);
                    767:       ((DefaultComboBoxModel) box4.getModel()).insertElementAt(destObj,0);
                    768:        box4.setSelectedItem(destObj);
                    769:       databases.remove(destBase);
                    770:       for (Iterator iter = databases.iterator(); iter.hasNext();)
                    771:       {
                    772:         Convert.DataBase database = (Convert.DataBase) iter.next();
                    773:         database.bean.getConnection();
                    774:         bean = database.bean;
                    775:         Object obj =bean.url;
                    776:         ((DefaultComboBoxModel) box3.getModel()).removeElement(obj);
                    777:         ((DefaultComboBoxModel) box3.getModel()).insertElementAt(obj,0);
                    778:         box3.setSelectedItem(obj);
                    779:         fillTable();
                    780:         Vector tables=database.bean.getTableNames();
                    781:         Collections.sort(tables,String.CASE_INSENSITIVE_ORDER);
1.3       rogo      782:         int[] indices = new int[database.tables.size()];
1.1       rogo      783:         for (int i =0;i<database.tables.size();++i)
                    784:         {
                    785:           String table = (String) database.tables.get(i);
                    786:           int index=tables.indexOf(table);
                    787:           if(index<0) throw new RuntimeException("Error table \""+table+"\" does no longer exist\n at server "+bean.url +"\n or you mispelled the tablename.");
                    788:           noDBUpdate = true;
                    789:           tC.tableModel.setValueAt(new TableComponent.SQLCommand(database.selects.get(i).toString()),index,2);
                    790:           String create =database.creates.get(i).toString();
                    791:           tC.tableModel.setValueAt(new TableComponent.SQLCommand(create.equals("") ? create:"           "+create),index,3);
                    792:           Object comboBox=tC.tableModel.getValueAt(index,1);
1.3       rogo      793:           indices[i] = index;
1.1       rogo      794:           if(comboBox!=null) ((JComboBox)comboBox).setSelectedItem(database.layouts.get(i));  
                    795:           tC.tableModel.fireTableDataChanged();
                    796:           noDBUpdate = false;
                    797:           noUserUpdate = false;
                    798:         
                    799:         }
1.3       rogo      800:         // add Selections
                    801:         ListSelectionModel lm = tC.table.getSelectionModel();
                    802:         for(int i=0;i<indices.length;++i)
                    803:         lm.addSelectionInterval(indices[i],indices[i]);
                    804:          
1.1       rogo      805:        destBean.getConnection();
                    806:       
                    807:         DefaultListModel model = new DefaultListModel();
                    808:          tables = destBean.getTableNames();
                    809:         for (int j = 0; j < tables.size(); ++j)
                    810:           model.addElement(tables.get(j));
                    811:         //  System.out.println("hallo" + tables + " ");
                    812:         tListDest.setModel(model);
                    813:         fmInstance.setCursor(Cursor.getPredefinedCursor(Cursor.DEFAULT_CURSOR));
                    814:         fmInstance.setEnabled(true);
                    815:              
                    816:       }
                    817:        
                    818:     } catch (Exception e)
                    819:     {
                    820:       noUserUpdate = false;
                    821:       noDBUpdate = false;
                    822:       fmInstance.setCursor(Cursor.getPredefinedCursor(Cursor.DEFAULT_CURSOR));
                    823:       fmInstance.setEnabled(true);
                    824:    
                    825:       ByteArrayOutputStream b = new ByteArrayOutputStream();
                    826:       PrintStream stream = new PrintStream(b);
                    827:       e.printStackTrace(stream);
                    828:       showErrorDialog(b.toString(), "Error while reading xml config  !");
                    829:     }
                    830: 
                    831:   }
                    832:   public boolean showTable(int list)
                    833:   {
                    834:     ProgressDialog dialog = new ProgressDialog(fm);
                    835:     dialog.setTitle("Preparing tables to be displayed");
                    836:     dialog.thread = Thread.currentThread();
                    837:     dialog.setCursor(Cursor.getPredefinedCursor(Cursor.WAIT_CURSOR));
                    838:     fmInstance.setCursor(Cursor.getPredefinedCursor(Cursor.WAIT_CURSOR));
                    839:     String query = new String();
                    840:     Object[] objs = tListDest.getSelectedValues();
                    841:     Vector[] vectors = getListFromTable();
                    842:     Vector tables = (list == 0) ? vectors[0] : new Vector();
                    843:     if (list > 0)
                    844:       for (int i = 0; i < objs.length; ++i)
                    845:       {
                    846:         if (debug)
                    847:           System.out.println(objs[i]);
                    848:         tables.add(objs[i]);
                    849:       }
                    850:     if (window != null)
                    851:       window.dispose();
                    852:     if (windowDest != null)
                    853:       windowDest.dispose();
                    854: 
                    855:     window = new MultiResultWindow(fm);
                    856:     if (list > 0)
                    857:     {
                    858:       windowDest = new MultiResultWindow(fm);
                    859:       window = windowDest;
                    860:     }
                    861:     dialog.setLocation(FM2SQL.fmInstance.getLocationOnScreen().x + (FM2SQL.fmInstance.getWidth() - 500) / 2, FM2SQL.fmInstance.getLocationOnScreen().y + (FM2SQL.fmInstance.getHeight() - 250) / 2);
                    862:     dialog.setSize(500, 250);
                    863:     if (!tables.isEmpty())
                    864:       dialog.show();
                    865:     dialog.title.setText("Preparing tables to be diplayed");
                    866:     for (int i = 0; i < tables.size(); ++i)
                    867:     {
                    868:       dialog.table.setText("Getting table " + tables.get(i));
                    869:       dialog.status.setText("Table " + (i + 1) + " of " + tables.size());
                    870: 
                    871:        if(list==0)
                    872:        query = "select * from " + bean.getQC() +tables.get(i).toString() + bean.getQC();
                    873:     else
                    874:     query = "select * from " + destBean.getQC() +tables.get(i).toString() + destBean.getQC();
                    875:  if(list==0) query = vectors[2].get(i).toString();
                    876:       if (list == 0 && vectors[1].get(i) != null)
                    877:         if (vectors[1].get(i).toString() != "")
                    878:           {
                    879:                        String layout =" layout " + bean.getQC() + vectors[1].get(i).toString() + bean.getQC();
                    880:             String name = tables.get(i).toString();
                    881:             StringBuffer queryLayout=new StringBuffer(query);
                    882:             queryLayout.insert(queryLayout.indexOf(name)+name.length()+1," "+layout);
                    883:             query=queryLayout.toString();
                    884:           }
                    885:        if(debug)
                    886:        showErrorDialog("query in show tables is "+query,"Hello");
                    887:       window.title = " Table ;-) " + (String) tables.get(i);
                    888:       //    break;
                    889:       //  } else
                    890:       //    window.title = "Error! - No valid tablename found";
                    891: 
                    892:       try
                    893:       {
                    894:         if ((query.toLowerCase().indexOf("insert") >= 0)
                    895:           || (query.toLowerCase().indexOf("delete") >= 0)
                    896:           || (query.toLowerCase().indexOf("alter") >= 0)
                    897:           || (query.toLowerCase().indexOf("update") >= 0))
                    898:         {
                    899:           Statement stm = (list > 0) ? destBean.getConnection().createStatement() : bean.getConnection().createStatement();
                    900:           stm.executeUpdate(query);
                    901:           Vector vec = new Vector();
                    902:           Vector vec2 = new Vector();
                    903:           Vector vec3 = new Vector();
                    904:           vec2.add(query);
                    905:           vec3.add(vec2);
                    906:           vec.add("Insert, update, etc done! No results available");
                    907:           // vec.add("no Results were produced");
                    908: 
                    909:           window.updateResult(vec3, vec);
                    910:           //window.pack();
                    911:           //  window.setVisible(true);
                    912: 
                    913:         } else
                    914:         {
                    915:           Vector[] vecs = (list > 0) ? destBean.getQueryData(query, dialog, 50) : bean.getQueryData(query, dialog, 50);
                    916:           if (vecs[1].isEmpty())
                    917:             throw new Exception("Wrong columnname or Empty Layout");
                    918:           window.updateResult(vecs[0], vecs[1]);
                    919: 
                    920:           //window.pack();
                    921:           //String name = window.writeResult();
                    922:           //appendLog(window.title, name);
                    923:         }
                    924: 
                    925:         //window.setVisible(true);
                    926: 
                    927:       } catch (Exception e)
                    928:       {
                    929:         System.out.println("Exception occured");
                    930:         e.printStackTrace();
                    931:         Vector vec = new Vector();
                    932:         Vector vec2 = new Vector();
                    933:         Vector vec3 = new Vector();
                    934:         vec2.add(e.getMessage());
                    935:         vec3.add(vec2);
                    936:         vec.add("Exception occured! No results available");
                    937:         //vec.add("no Results were produced");
                    938: 
                    939:         window.updateResult(vec3, vec);
                    940:         //window.pack();
                    941:         // window.setVisible(true);
                    942:         fmInstance.setCursor(Cursor.getPredefinedCursor(Cursor.DEFAULT_CURSOR));
                    943: 
                    944:       }
                    945:     } // to for
                    946:     window.pack();
                    947:     window.setSize(700, 600);
                    948: 
                    949:     window.oldTabCount = 10000;
                    950:     dialog.dispose();
                    951:     fmInstance.setCursor(Cursor.getPredefinedCursor(Cursor.DEFAULT_CURSOR));
                    952: 
                    953:     return !tables.isEmpty();
                    954: 
                    955:   }
                    956: 
                    957:   public void dropTable()
                    958:   {
                    959:     String query = new String();
                    960:     Object[] objs = tListDest.getSelectedValues();
                    961:     Vector tables = new Vector();
                    962:     for (int i = 0; i < objs.length; ++i)
                    963:     {
                    964:       System.out.println(objs[i]);
                    965:       tables.add(objs[i]);
                    966:     }
                    967: 
                    968:     for (int i = 0; i < tables.size(); ++i)
                    969:     {
                    970: 
                    971:       query = "drop table "+destBean.getQC() + tables.get(i) + destBean.getQC();
                    972: 
                    973:       try
                    974:       {
                    975:         Statement stm = destBean.getConnection().createStatement();
                    976:         stm.executeUpdate(query);
                    977:       } catch (Exception e)
                    978:       {
                    979:         ByteArrayOutputStream b = new ByteArrayOutputStream();
                    980:         PrintStream stream = new PrintStream(b);
                    981:         e.printStackTrace(stream);
                    982:         showErrorDialog(b.toString(), "Open of table failed");
                    983: 
                    984:       }
                    985:     } // to for
                    986:     try
                    987:     {
                    988:       destBean.setConnection((String) box4.getSelectedItem());
                    989:       DefaultListModel model = new DefaultListModel();
                    990:       tables = destBean.getTableNames();
                    991:       for (int j = 0; j < tables.size(); ++j)
                    992:         model.addElement(tables.get(j));
                    993:       System.out.println("hallo" + tables + " ");
                    994:       tListDest.setModel(model);
                    995:     } catch (Exception e4)
                    996:     {
                    997:     }
                    998: 
                    999:   }
                   1000:   /**
                   1001:    * invoked then the user changes the table or the tableModel changes
                   1002:    */
                   1003:   public void tableChanged(TableModelEvent e)
                   1004:   {
                   1005:     //  if (e.getType() == e.INSERT)
                   1006:     //System.out.println("Insert done");
                   1007:     // if (e.getType() == e.UPDATE)
                   1008:     // System.out.println("Update done");
                   1009:     //if (e.getType() == e.DELETE)
                   1010:    // System.out.println("Delete done");
                   1011:     if (e.getType() == e.UPDATE && !noDBUpdate)
                   1012:     {
                   1013:       int row = e.getFirstRow(), col = e.getColumn();
                   1014:       System.out.println("Got in " + row + " " + col );
                   1015:       TableModel model =  (TableModel)e.getSource();
                   1016:       String columnName = model.getColumnName(col);
                   1017:       Object test = model.getValueAt(row, col);
                   1018:       String idVal = (test == null) ? "" : test.toString();
                   1019:       String value = (test == null) ? "" : test.toString();;
                   1020: 
                   1021:       System.out.println("Got in " + columnName +" "+idVal);
                   1022:       try
                   1023:       {
                   1024:         if(columnName.equals("select")||columnName.equals("Layouts"))
                   1025:         {
                   1026:           String table = model.getValueAt(row,0).toString();
                   1027:           String layout = (model.getValueAt(row,1)!=null) ?((JComboBox)model.getValueAt(row,1)).getSelectedItem().toString():"";
                   1028:           String query =  model.getValueAt(row,2).toString();
                   1029:           String create = model.getValueAt(row,3).toString();
                   1030:           System.out.println("table" +table+" layout "+layout+" query "+query);
                   1031:           if(!create.equals(""))
                   1032:           {
                   1033:             Object[] options = { "Yes","No"};
                   1034:             int option=showDialog("Create Statement not empty! Do you want to overwrite?","create statement",options ); 
                   1035:             if(option==0) 
                   1036:             model.setValueAt(createStatement(table,destBean,layout,query),row,3);
                   1037:           }
                   1038:        
                   1039:        
                   1040:         }
                   1041: /*        Statement stm = bean.getConnection().createStatement();
                   1042:         //  stm.executeUpdate("DELETE FROM \""+fm.tables.get(0)+"\" WHERE \"erstellt von\"='rogo') ");
                   1043: 
                   1044:         if (idVal == "")
                   1045:           stm.executeUpdate("INSERT  INTO " + DBBean.quoteChar + box.getSelectedItem() + DBBean.quoteChar + " (" + DBBean.quoteChar + columnName + DBBean.quoteChar + ")  VALUES ('" + value + "') ");
                   1046:         else
                   1047:           stm.executeUpdate(
                   1048:             "UPDATE   " + DBBean.quoteChar + box.getSelectedItem() + DBBean.quoteChar + " SET  " + DBBean.quoteChar + columnName + DBBean.quoteChar + "='" + value + "' WHERE ID='" + idVal + "' ");
                   1049:   */
                   1050:           } catch (Exception e2)
                   1051:            {
                   1052:              fmInstance.setCursor(Cursor.getPredefinedCursor(Cursor.DEFAULT_CURSOR));
                   1053:              ByteArrayOutputStream b = new ByteArrayOutputStream();
                   1054:              PrintStream stream = new PrintStream(b);
                   1055:              e2.printStackTrace(stream);
                   1056:              showErrorDialog(b.toString(), "Error while updating table  !");
                   1057:            }
                   1058:     }
                   1059:   }
                   1060: 
                   1061:   /**
                   1062:    * initialize the menubar
                   1063:    */
                   1064:   private void setMenu()
                   1065:   {
                   1066:     JMenuBar menubar = new JMenuBar();
                   1067:     JMenu menu = new JMenu("File");
1.6       rogo     1068:      menu.setMnemonic('F');
                   1069:     JMenuItem item = new JMenuItem("open XML Config");
                   1070:     item.setMnemonic('i');
                   1071:     item.setAccelerator(KeyStroke.getKeyStroke('O',InputEvent.CTRL_DOWN_MASK));
                   1072:   
                   1073:     item.addActionListener(fm);
                   1074:     menu.add(item);
                   1075:     item = new JMenuItem("save XML Config");
                   1076:     item.setAccelerator(KeyStroke.getKeyStroke('S',InputEvent.CTRL_DOWN_MASK));
                   1077:     item.setMnemonic('x');
1.1       rogo     1078:    
                   1079:     item.addActionListener(fm);
                   1080:     menu.add(item);
1.6       rogo     1081:     item = new JMenuItem("Quit");
                   1082:     item.setMnemonic('Q');
                   1083:     item.setAccelerator(KeyStroke.getKeyStroke('Q',InputEvent.CTRL_DOWN_MASK));
1.1       rogo     1084:     item.addActionListener(fm);
1.6       rogo     1085:      menu.add(item);
                   1086:  
1.1       rogo     1087:     menubar.add(menu);
                   1088:     menu = new JMenu("Options");
1.6       rogo     1089:     menu.setMnemonic('O');
                   1090:    
1.1       rogo     1091:     item = new JMenuItem("show Driver features");
                   1092:     item.addActionListener(fm);
                   1093:     menu.add(item);
                   1094:     menubar.add(menu);
                   1095:   
                   1096:     item.addActionListener(fm);
                   1097:     menu.add(item);
                   1098:   
                   1099:     menubar.add(menu);
                   1100:   
                   1101:     menu.setBackground(fm.getBackground());
                   1102:     menubar.setBackground(fm.getBackground());
                   1103:     setJMenuBar(menubar);
                   1104:   }
                   1105:   /**
                   1106:    *  open the log  file (index.html)
                   1107:    */
                   1108: 
                   1109:   public static void openLog() throws Exception
                   1110:   {
                   1111: 
                   1112:     StringBuffer buff = new StringBuffer();
                   1113:     buff.append("<html>");
                   1114:     buff.append("<head>");
                   1115:     buff.append("\n<title>");
                   1116:     buff.append("FileMaker Test");
                   1117:     buff.append("</title>\n");
                   1118:     buff.append("</head>\n");
                   1119: 
                   1120:     buff.append("<body>\n");
                   1121:     buff.append("<center>\n");
                   1122:     buff.append("\n<h3>");
                   1123:     buff.append("FileMaker Test");
                   1124:     buff.append("</h3>\n");
                   1125: 
                   1126:     logFile.write(TableComponent.convertUml(buff).toString());
                   1127:     logFile.flush();
                   1128:   }
                   1129:   /**
                   1130:    * Append one entry to the log file(index.html)
                   1131:    */
                   1132:   public static void appendLog(String entry, String name) throws Exception
                   1133:   {
                   1134:     logFile.write("<a href=\"./" + name.substring(name.lastIndexOf("/") + 1) + "\">");
                   1135:     logFile.write(entry + "</a>");
                   1136:     logFile.write("<br>\n<br>\n");
                   1137:     logFile.flush();
                   1138:   }
                   1139:   /**
                   1140:    * closes the log file invoked then the application closes
                   1141:    */
                   1142:   public static void closeLog() throws Exception
                   1143:   {
                   1144:     logFile.write("\n</body>");
                   1145:     logFile.write("\n</html>");
                   1146: 
                   1147:     logFile.close();
                   1148:   }
                   1149:   public static void showErrorDialog(String message, String title)
                   1150:   {
                   1151:     JDialog dialog = new JDialog(fmInstance);
                   1152:     dialog.setTitle(title);
                   1153:     JTextArea text = new JTextArea();
                   1154:     JScrollPane scroller = new JScrollPane(text);
                   1155:     dialog.getContentPane().add(scroller);
                   1156:     text.append(message);
                   1157:     dialog.setSize(600, 300);
                   1158:     dialog.setLocationRelativeTo(fmInstance);
                   1159:     dialog.show();
                   1160:     //JOptionPane.showMessageDialog(null, message, title, JOptionPane.ERROR_MESSAGE);
                   1161:   }
                   1162:   public static class ProgressDialog extends JDialog
                   1163:   {
                   1164:     JLabel table = new JLabel("    ");
                   1165:     JLabel status = new JLabel("    ");
                   1166:     JLabel title = new JLabel("     ");
                   1167:     JPanel content = new JPanel();
                   1168:     JPanel titlePanel = new JPanel();
                   1169:     JPanel labelPanel = new JPanel();
                   1170:     JPanel statusPanel = new JPanel();
                   1171:     JPanel buttonPanel = new JPanel();
                   1172: 
                   1173:     JProgressBar progress = new JProgressBar();
                   1174:     JButton cancel = new JButton("Cancel");
                   1175:     Thread thread;
                   1176:     public ProgressDialog(JFrame frame)
                   1177:     {
                   1178:       super(frame);
                   1179:       content = new JPanel(true);
                   1180:       //content.setBorder(BorderFactory.createRaisedBevelBorder());
                   1181:       content.setLayout(new BoxLayout(content, BoxLayout.Y_AXIS));
                   1182:       title = new JLabel("Progress of conversion");
                   1183:       title.setHorizontalTextPosition(title.CENTER);
                   1184:       titlePanel.add(title);
                   1185:       buttonPanel.add(cancel);
                   1186:       // content.add(titlePanel);
                   1187:       content.add(Box.createRigidArea(new java.awt.Dimension(0, 15)));
                   1188:       content.add(labelPanel);
                   1189:       content.add(new JLabel(""));
                   1190:       content.add(progress);
                   1191:       content.add(statusPanel);
                   1192:       content.add(buttonPanel);
                   1193:       content.add(Box.createRigidArea(new java.awt.Dimension(0, 15)));
                   1194:       labelPanel.add(table);
                   1195:       statusPanel.add(status);
                   1196:       getContentPane().add(titlePanel, "North");
                   1197:       getContentPane().add(content, "Center");
                   1198:       this.addWindowListener(new WindowAdapter()
                   1199:       {
                   1200:         public void windowClosing(WindowEvent e)
                   1201:         {
                   1202:           cancel.doClick();
                   1203:         }
                   1204:       });
                   1205: 
                   1206:       cancel.addActionListener(new ActionListener()
                   1207:       {
                   1208:         public void actionPerformed(ActionEvent e)
                   1209:         {
                   1210:           fmInstance.setCursor(Cursor.getPredefinedCursor(Cursor.DEFAULT_CURSOR));
                   1211:                    fmInstance.setEnabled(true);
                   1212:           setVisible(false);
                   1213:           thread.stop();
                   1214:         }
                   1215:       });
                   1216:       pack();
                   1217: 
                   1218:     }
                   1219: 
                   1220:   }
                   1221:   public static class PasswordDialog extends JDialog
                   1222:   {
                   1223:     JLabel table = new JLabel("    ");
                   1224:     JLabel status = new JLabel("    ");
                   1225:     JLabel title = new JLabel("     ");
                   1226:     JPanel content = new JPanel();
                   1227:     JPanel titlePanel = new JPanel();
                   1228:     JPanel userPanel = new JPanel();
                   1229:     JPanel passwordPanel = new JPanel();
                   1230:     JPanel buttonPanel = new JPanel();
                   1231:     JTextField user = new JTextField(10);
                   1232:     JTextField passwd = new JPasswordField(10);
                   1233: 
                   1234:     JButton cancel = new JButton("Cancel");
                   1235:     JButton ok = new JButton("Ok");
                   1236:     DBBean bean = null;
                   1237:     Thread thread;
                   1238:     public PasswordDialog(JFrame frame, DBBean localBean)
                   1239:     {
                   1240:       super(frame);
                   1241:       setTitle("PasswordDialog");
                   1242:       setModal(true);
                   1243:       content = new JPanel(true);
                   1244:       this.bean = localBean;
                   1245:       //content.setBorder(BorderFactory.createRaisedBevelBorder());
                   1246:       ActionListener al = new ActionListener()
                   1247:       {
                   1248:         public void actionPerformed(ActionEvent e)
                   1249:         {
                   1250:           bean.setUserAndPasswd(user.getText(), passwd.getText());
                   1251:           setVisible(false);
                   1252:         }
                   1253: 
                   1254:       };
                   1255:       this.addWindowListener(new WindowAdapter()
                   1256:       {
                   1257:         public void windowClosing(WindowEvent e)
                   1258:         {
                   1259:           cancel.doClick();
                   1260:         }
                   1261:       });
                   1262: 
                   1263:       user.setText(localBean.user);
                   1264:       passwd.setText(localBean.passwd);
                   1265:       user.addActionListener(al);
                   1266:       passwd.addActionListener(al);
                   1267:       content.setLayout(new BoxLayout(content, BoxLayout.Y_AXIS));
                   1268:       title = new JLabel("Enter user and password ");
                   1269:       title.setHorizontalTextPosition(title.CENTER);
                   1270:       titlePanel.add(title);
                   1271:       buttonPanel.add(ok);
                   1272:       buttonPanel.add(cancel);
                   1273:       content.add(titlePanel);
                   1274:       content.add(Box.createRigidArea(new java.awt.Dimension(0, 15)));
                   1275:       // content.add(labelPanel);
                   1276:       content.add(new JLabel(""));
                   1277:       content.add(userPanel);
                   1278:       content.add(passwordPanel);
                   1279:       content.add(buttonPanel);
                   1280:       content.add(Box.createRigidArea(new java.awt.Dimension(0, 15)));
                   1281:       //labelPanel.add(table);
                   1282:       userPanel.add(new JLabel("Username:  "));
                   1283:       userPanel.add(user);
                   1284:       passwordPanel.add(new JLabel("Password:  "));
                   1285:       passwordPanel.add(passwd);
                   1286:       passwd.setPreferredSize(user.getPreferredSize());
                   1287:       passwd.setMinimumSize(passwd.getPreferredSize());
                   1288:       passwd.setMaximumSize(passwd.getPreferredSize());
                   1289:       passwd.setSize(passwd.getPreferredSize());
                   1290:         getContentPane().add(titlePanel, "North");
                   1291:       getContentPane().add(content, "Center");
                   1292:       ok.addActionListener(al);
                   1293:       cancel.addActionListener(new ActionListener()
                   1294:       {
                   1295:         public void actionPerformed(ActionEvent e)
                   1296:         {
                   1297:           fmInstance.setCursor(Cursor.getPredefinedCursor(Cursor.DEFAULT_CURSOR));
                   1298:                    fmInstance.setEnabled(true);
                   1299:           setVisible(false);
                   1300:           thread.stop();
                   1301:         }
                   1302: 
                   1303:       });
                   1304:       pack();
                   1305: 
                   1306:     }
                   1307: 
                   1308:   }
                   1309:   public void fillTable()
                   1310:   {
                   1311:     noDBUpdate = true;
                   1312:     Vector tableNames = bean.getTableNames();
                   1313:     Collections.sort(tableNames, String.CASE_INSENSITIVE_ORDER);
                   1314:     Vector[] data = new Vector[2];
                   1315:     data[1] = new Vector();
                   1316:     data[1].add("Table");
                   1317:     data[1].add("Layouts");
                   1318:        data[1].add("select");
                   1319:     data[1].add("create");
                   1320:    
                   1321:     data[0] = new Vector();
                   1322: 
                   1323:     for (int i = 0; i < tableNames.size(); i++)
                   1324:     {
                   1325:       String name = tableNames.get(i).toString();
                   1326:       Vector layouts = new Vector();
                   1327:       try
                   1328:       {
                   1329:         layouts = bean.getLayoutNames(name);
                   1330:       } catch (SQLException e)
                   1331:       {
                   1332:         layouts = new Vector();
                   1333:       }
                   1334:       Vector dataRow = new Vector();
                   1335:       dataRow.add(name);
                   1336:       if (!layouts.isEmpty())
                   1337:         dataRow.add(new JComboBox(layouts));
                   1338:       else
                   1339:         dataRow.add(null);
                   1340:       dataRow.add(new TableComponent.SQLCommand("select * from "+bean.getQC()+name+bean.getQC()));
                   1341:      
                   1342:         data[0].add(dataRow);
                   1343:     dataRow.add(new TableComponent.SQLCommand(""));
                   1344:       //System.out.println(dataRow);
                   1345:     }
                   1346:     tC.tableModel.setDataVector(data[0], data[1]);
                   1347:     tC.revalidate();
                   1348:     tC.tableModel.fireTableDataChanged();
                   1349:     noDBUpdate = false;
                   1350:   
                   1351:   }
                   1352:   public Vector[] getListFromTable()
                   1353:   {
                   1354:     Vector[] vec = new Vector[4];
                   1355:     vec[0] = new Vector();
                   1356:     vec[1] = new Vector();
                   1357:        vec[2] = new Vector();
                   1358:     vec[3] = new Vector();
                   1359:     int[] rows = tC.table.getSelectedRows();
                   1360:     for (int i = 0; i < rows.length; i++)
                   1361:     {
                   1362:       //System.out.println(tC.tableModel.getValueAt(rows[i],1));
                   1363:       vec[0].add(tC.tableModel.getValueAt(rows[i], 0));
                   1364:       JComboBox box = ((JComboBox) tC.tableModel.getValueAt(rows[i], 1));
                   1365:       String layoutName = (box != null) ? box.getSelectedItem().toString() : "";
                   1366:       vec[1].add(layoutName);
                   1367:       vec[2].add(tC.tableModel.getValueAt(rows[i], 2).toString());
                   1368:       vec[3].add(tC.tableModel.getValueAt(rows[i], 3).toString());
                   1369:   
                   1370:     }
                   1371:     return vec;
                   1372:   }
                   1373:   public void setEnabled(boolean state)
                   1374:   {
                   1375:     showTables.setEnabled(state);
                   1376:     showTables1.setEnabled(state);
                   1377:     convert.setEnabled(state);
                   1378:     dropTables.setEnabled(state);
                   1379:     box3.setEnabled(state);
                   1380:     box4.setEnabled(state);
                   1381: 
                   1382:   }
                   1383:   public TableComponent.SQLCommand createStatement(String table,DBBean beanDest,String layout,String query)  throws SQLException
                   1384:   {
                   1385:     fmInstance.setCursor(Cursor.getPredefinedCursor(Cursor.WAIT_CURSOR));
                   1386:         
                   1387:     if(beanDest.url.equals("")) beanDest.url=box4.getSelectedItem().toString();
                   1388:     StringBuffer command = new StringBuffer(50);
                   1389:     command.append("\n           CREATE TABLE ");
                   1390:     command.append(beanDest.getQC());
                   1391:     command.append(Convert.convertText(table));
                   1392:     command.append(beanDest.getQC());
                   1393:     command.append("\n             ( ");
                   1394:     String type = null;
                   1395:    // String query = "select * from " + bean.getQC() +table + bean.getQC();
                   1396:    if (!layout.equals(""))
                   1397:      {
                   1398:        layout = " layout " + bean.getQC() + layout + bean.getQC();
                   1399:        StringBuffer queryLayout = new StringBuffer(query);
                   1400:        queryLayout.insert(queryLayout.indexOf(table) + table.length() + 1, " " + layout);
                   1401:        query = queryLayout.toString();
                   1402:        System.out.println("added layout  "+ query);
                   1403:         
                   1404:      }
                   1405:       Vector[] result=bean.getQueryData(query,1);
                   1406:     for (int i = 0; i < result[1].size() - 1; ++i)
                   1407:     {
                   1408:       type = bean.metaData.getColumnTypeName(i + 1);
                   1409:       //   System.out.println(i+" "+result[1].get(i)+" "+type);
                   1410:       type = (type.equals("NUMBER")) ? "INT4" : type;
                   1411:       type = (type.equals("CONTAINER")) ? "TEXT" : type;
                   1412:       type = type.toUpperCase(); 
                   1413:       if(i==0)
                   1414:       command.append(beanDest.getQC() + Convert.convertText((String) result[1].get(i)) + beanDest.getQC() + " " + type + ", ");
                   1415:       else
                   1416:       command.append("               "+beanDest.getQC() + Convert.convertText((String) result[1].get(i)) + beanDest.getQC() + " " + type + ", ");
                   1417:       command.append("\n");
                   1418:     }
                   1419:     type = bean.metaData.getColumnTypeName(result[1].size());
                   1420:     type = (type.equals("NUMBER")) ? "INT4" : type;
                   1421:     type = (type.equals("CONTAINER")) ? "TEXT" : type;
                   1422:     type = type.toUpperCase(); 
                   1423:     command.append("               "+beanDest.getQC() + Convert.convertText((String) result[1].get(result[1].size() - 1)) + beanDest.getQC() + " " + type);
                   1424:     command.append("\n             )\n");
                   1425:     fmInstance.setCursor(Cursor.getPredefinedCursor(Cursor.DEFAULT_CURSOR));
                   1426:    
                   1427:    return new TableComponent.SQLCommand(command.toString());
                   1428:   }
                   1429:   static class XMLFilter extends javax.swing.filechooser.FileFilter
                   1430:   {
                   1431:     public boolean accept(java.io.File file)
                   1432:     {
                   1433:       if (file.getName().toLowerCase().endsWith(".xml") || file.isDirectory())
                   1434:         return true;
                   1435:       else
                   1436:         return false;
                   1437:     }
                   1438:     public String getDescription()
                   1439:     {
                   1440:       return "Batch Convert XML File";
                   1441:     }
                   1442: 
                   1443:   }
                   1444:   public static int showDialog(String message, String title, Object[] options)
                   1445:   {
                   1446:     int option = JOptionPane.showOptionDialog(null, message, title, JOptionPane.DEFAULT_OPTION, JOptionPane.WARNING_MESSAGE, null, options, options[0]);
                   1447:     return option;
                   1448:   
                   1449:   }
                   1450: 
                   1451: }

FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>