home *** CD-ROM | disk | FTP | other *** search
/ PC World 1998 October / PCWorld_1998-10_cd.bin / software / prehled / inprise / JSAMPLES.Z / SchemaPanel.java < prev    next >
Text File  |  1998-05-08  |  28KB  |  816 lines
  1. /*
  2.  * Copyright (c) 1997-1998 Borland International, Inc. All Rights Reserved.
  3.  * 
  4.  * This SOURCE CODE FILE, which has been provided by Borland as part
  5.  * of a Borland product for use ONLY by licensed users of the product,
  6.  * includes CONFIDENTIAL and PROPRIETARY information of Borland.  
  7.  *
  8.  * USE OF THIS SOFTWARE IS GOVERNED BY THE TERMS AND CONDITIONS 
  9.  * OF THE LICENSE STATEMENT AND LIMITED WARRANTY FURNISHED WITH
  10.  * THE PRODUCT.
  11.  *
  12.  * IN PARTICULAR, YOU WILL INDEMNIFY AND HOLD BORLAND, ITS RELATED
  13.  * COMPANIES AND ITS SUPPLIERS, HARMLESS FROM AND AGAINST ANY CLAIMS
  14.  * OR LIABILITIES ARISING OUT OF THE USE, REPRODUCTION, OR DISTRIBUTION
  15.  * OF YOUR PROGRAMS, INCLUDING ANY CLAIMS OR LIABILITIES ARISING OUT OF
  16.  * OR RESULTING FROM THE USE, MODIFICATION, OR DISTRIBUTION OF PROGRAMS
  17.  * OR FILES CREATED FROM, BASED ON, AND/OR DERIVED FROM THIS SOURCE
  18.  * CODE FILE.
  19.  */
  20. package borland.samples.apps.schemaeditor;
  21.  
  22. import java.lang.*;
  23. import java.lang.reflect.*;
  24. import java.awt.*;
  25. import java.util.*;
  26. import java.math.*;
  27. import java.io.*;
  28.      
  29. import borland.jbcl.control.*;
  30. import borland.jbcl.dataset.*;
  31. import borland.jbcl.view.*;
  32. import borland.jbcl.model.*;
  33. import borland.jbcl.util.*;
  34. import borland.jbcl.layout.*;
  35. import java.awt.event.*;
  36.  
  37. public class SchemaPanel extends BevelPanel {
  38.   //Column indices
  39.   final static int INDEX=0;
  40.   final static int NAME=1;
  41.   final static int TYPE=2;
  42.   final static int SIZE=3;
  43.   
  44.   //SQL Data Type strings
  45.   final static String BIGDECIMAL="BIGDECIMAL";
  46.   //final static String BOOLEAN="BOOLEAN";
  47.   final static String BOOLEAN="BIT";
  48.   //final static String BYTE="BYTE";        
  49.   final static String BYTE="TINYINT";        
  50.   final static String DATE="DATE";
  51.   final static String DOUBLE="DOUBLE";
  52.   final static String FLOAT="FLOAT";
  53.   //final static String INT="INT";
  54.   final static String INT="INTEGER";   
  55.   final static String LONG="LONG";
  56.   final static String SHORT="SHORT";
  57.   //final static String STRING="STRING";
  58.   final static String STRING="VARCHAR";
  59.   final static String TIME="TIME";
  60.   final static String TIMESTAMP="TIMESTAMP";
  61.  
  62.    
  63.   GridControl gridControl1 = new GridControl();
  64.   Label labelDescription = new Label();
  65.   Button addField = new Button();
  66.   Button delField = new Button();
  67.   TableDataSet schema = new TableDataSet();
  68.   private int fieldCounter=0;
  69.   
  70.   public SchemaPanel() {
  71.     try {
  72.       jbInit();
  73.     }
  74.     catch (Exception e) {
  75.       e.printStackTrace();
  76.     };
  77.   }
  78.  
  79.   private void jbInit() throws Exception {
  80.     Column columns[] = new Column[4];
  81.     
  82.     labelDescription.setText("Define table columns and column types.");
  83.     delField.setLabel("Remove Field");
  84.     delField.addActionListener(new SchemaPanel_delField_actionAdapter(this));
  85.     addField.setLabel("Insert Field");
  86.     addField.addActionListener(new SchemaPanel_addField_actionAdapter(this));
  87.     this.setLayout(gridBagLayout1);
  88.     columns[INDEX]=new Column();
  89.     columns[INDEX].setDataType(Variant.INT);
  90.     columns[INDEX].setColumnName("Index");
  91.     columns[INDEX].setCaption("Index");
  92.     columns[INDEX].setWidth(50);
  93.     //The index property is for internal use only and should not
  94.     //be seen by the user.
  95.     columns[INDEX].setVisible(TriStateProperty.FALSE);
  96.           
  97.     columns[NAME]=new Column();
  98.     columns[NAME].setDataType(Variant.STRING);
  99.     columns[NAME].setColumnName("Field_Name");
  100.     columns[NAME].setCaption("Field Name");
  101.     columns[NAME].setWidth(150);
  102.     columns[NAME].setRequired(true);
  103.  
  104.     columns[TYPE]=new Column();
  105.     columns[TYPE].setDataType(Variant.STRING);
  106.     columns[TYPE].setColumnName("Field_Type");
  107.     columns[TYPE].setCaption("Field Type");
  108.     columns[TYPE].setWidth(90);
  109.     columns[TYPE].setRequired(true);
  110.     columns[TYPE].setItemEditor(new SchemaFieldTypeEditor());
  111.  
  112.     columns[SIZE]=new Column();
  113.     columns[SIZE].setDataType(Variant.INT);
  114.     columns[SIZE].setColumnName("Size");
  115.     columns[SIZE].setCaption("Size");
  116.     columns[SIZE].setMin("0");
  117.     columns[SIZE].setWidth(50);
  118.     
  119.     schema.setColumns(columns);
  120.     schema.setSort(new SortDescriptor("INDEX"));
  121.     gridControl1.setDataSet(schema);
  122.     gridControl1.setSortOnHeaderClick(false);
  123.     addRow();  //Create the first row
  124.     
  125.     this.add(labelDescription, new GridBagConstraints2(0, 0, 3, 1, 0.0, 0.0
  126.             ,GridBagConstraints.WEST, GridBagConstraints.NONE, new Insets(10, 8, 0, 0), 75, 7));
  127.     this.add(gridControl1, new GridBagConstraints2(0, 1, 4, 1, 1.0, 1.0
  128.             ,GridBagConstraints.CENTER, GridBagConstraints.BOTH, new Insets(0, 8, 0, 9), 20, 50));
  129.     this.add(addField, new GridBagConstraints2(0, 2, 1, 1, 0.0, 0.0
  130.             ,GridBagConstraints.CENTER, GridBagConstraints.NONE, new Insets(7, 8, 26, 0), 26, 5));
  131.     this.add(delField, new GridBagConstraints2(1, 2, 1, 1, 0.0, 0.0
  132.             ,GridBagConstraints.CENTER, GridBagConstraints.NONE, new Insets(7, 17, 26, 0), 14, 5));
  133.   }
  134.  
  135.   //Inserts a new default row to the table
  136.   private void addRow() {
  137.     DataRow row;
  138.     try {
  139.      if (!schema.isOpen()) {
  140.         schema.open();
  141.       }
  142.       //Renumber index from end to current row
  143.       //Since dataset is sorted, each renumber causes a resort.
  144.       //By renumbering from the end to the cursor, we keep records
  145.       //in the correct order
  146.  
  147.       // This is an alternate way to do the renumbering by using
  148.       // a dataset view instead of moving the cursor in the current
  149.       // dataset.  A dataset view has it's own cursor and sort order
  150.       //if (schema.rowCount() > 0 ){
  151.       //  DataSetView view = schema.cloneDataSetView();
  152.       //  view.open();
  153.       //  view.goToRow(schema.getRow());
  154.       //  view.last();
  155.       //  while(view.getRow() != schema.getRow()) {
  156.       //    view.setInt(INDEX, view.getInt(INDEX)+1);
  157.       //    view.prior();
  158.       //  }
  159.       //  view.post();
  160.       //  view.close();
  161.       //}
  162.       
  163.       row=new DataRow(schema);
  164.       int currentRow=schema.getRow();
  165.       //This turns off grid painting
  166.       schema.enableDataSetEvents(false);
  167.       
  168.       schema.last();
  169.       while(schema.getRow() != currentRow) {
  170.         schema.getDataRow(row);
  171.         row.setInt(INDEX,row.getInt(INDEX)+1);
  172.         schema.updateRow(row);
  173.         schema.prior();
  174.       }
  175.                     
  176.       row.setInt(INDEX,schema.getInt(INDEX)+1);
  177.       row.setString(NAME,"Field"+fieldCounter++);
  178.       row.setString(TYPE,STRING);
  179.       row.setInt(SIZE,25);
  180.       schema.addRow(row);
  181.       
  182.       schema.next(); //Goto new row
  183.       //The add button got focus when we clicked it, return
  184.       //focus to the grid
  185.       gridControl1.requestFocus();
  186.       schema.enableDataSetEvents(true);
  187.       // In case grid doesn't repaint correctly after enabling
  188.       //gridControl1.repaintCells();
  189.     }
  190.     catch (Exception e) {e.printStackTrace();}
  191.    
  192.   }
  193.  
  194.   //Start with a clean schema
  195.   public void newDataSet() {
  196.     try {  
  197.       if (!schema.isOpen()) {
  198.         schema.open();
  199.       }
  200.       schema.deleteAllRows();
  201.       fieldCounter=0;
  202.       addRow();
  203.     }
  204.     catch (Exception e) {e.printStackTrace();}
  205.   }
  206.   
  207.   //Given an existing DataSet, display the schema for editing
  208.   public void setDataSet(StorageDataSet d) {
  209.     Column columns[];
  210.     DataRow row;
  211.     
  212.     try {  
  213.       if (!schema.isOpen()) {
  214.         schema.open();
  215.       }
  216.       schema.deleteAllRows();
  217.       //For each column in dataset, create a row in schema
  218.       columns = d.getColumns();
  219.       for (int i=0; i< columns.length ; i++) {
  220.         row = new DataRow(schema);
  221.         row.setInt(INDEX,i);
  222.         row.setString(NAME,columns[i].getColumnName());
  223.         row.setInt(SIZE,columns[i].getPrecision());
  224.  
  225.         switch (columns[i].getDataType()) {
  226.           case Variant.BIGDECIMAL:
  227.             row.setString(TYPE,BIGDECIMAL);
  228.             break;
  229.           case Variant.BOOLEAN:
  230.             row.setString(TYPE,BOOLEAN);
  231.             break;
  232.           case Variant.BYTE:
  233.             row.setString(TYPE,BYTE);
  234.             break;
  235.           case Variant.DATE:
  236.             row.setString(TYPE,DATE);
  237.             break;
  238.           case Variant.DOUBLE:
  239.             row.setString(TYPE,DOUBLE);
  240.             break;
  241.           case Variant.FLOAT:
  242.             row.setString(TYPE,FLOAT);
  243.             break;
  244.           case Variant.INT:
  245.             row.setString(TYPE,INT);
  246.             break;
  247.           case Variant.LONG:
  248.             row.setString(TYPE,LONG);
  249.             break;
  250.           case Variant.SHORT:
  251.             row.setString(TYPE,SHORT);
  252.             break;
  253.           case Variant.STRING:
  254.             row.setString(TYPE,STRING);
  255.             break;
  256.           case Variant.TIME:
  257.             row.setString(TYPE,TIME);
  258.             break;
  259.           case Variant.TIMESTAMP:
  260.             row.setString(TYPE,TIMESTAMP);
  261.             break;
  262.         }
  263.         schema.addRow(row);
  264.         schema.post();
  265.       }
  266.       gridControl1.repaintCells();
  267.     } catch (Exception e) {
  268.       e.printStackTrace();
  269.     }
  270.   }
  271.  
  272.   public StorageDataSet getDataSet(boolean sampleData) {
  273.     // Construct a temporary dataset from schema and use it to create
  274.     // the schema file by saving it.  This hides the details of the
  275.     // schema syntax in case it changes in the future.
  276.     TableDataSet ds = new TableDataSet();
  277.     Column column;
  278.     String s=null;
  279.     Variant v = new Variant();
  280.     int recordCounter=0;
  281.     String defString;
  282.     DataRow sampleRow;
  283.     int numRows;
  284.     String columnName;
  285.     String columnType;
  286.     int columnPrecision;
  287.     
  288.     // Walk through the schema and construct columns
  289.     try {
  290.       if (!schema.isOpen()) {
  291.         schema.open();
  292.       }
  293.       schema.first(); //Make sure dataset is reset to beginning
  294.       numRows=schema.getRowCount();
  295.  
  296.       for (int row=0; row < numRows; row++) {
  297.         //Is there a field that needs to be created?
  298.       
  299.         schema.getVariant(SchemaPanel.NAME,row,v);
  300.         if (!v.isNull()) {
  301.           column = new Column();
  302.           //Set the column name
  303.           columnName=v.getString();
  304.           column.setColumnName(columnName);
  305.  
  306.           //Set the size of the field
  307.           schema.getVariant(SchemaPanel.SIZE,row,v);
  308.           columnPrecision=0;
  309.           if (!v.isNull()) {
  310.             columnPrecision=v.getInt();
  311.           }
  312.           column.setPrecision(columnPrecision);
  313.        
  314.           //Set the field type
  315.           schema.getVariant(SchemaPanel.TYPE,row,v);
  316.           columnType=v.getString();
  317.           if (columnType==BIGDECIMAL) {
  318.             column.setDataType(Variant.BIGDECIMAL);
  319.           }else if (columnType==BOOLEAN) {
  320.             column.setDataType(Variant.BOOLEAN);
  321.           }else if (columnType==BYTE) {
  322.             column.setDataType(Variant.BYTE);
  323.           }else if (columnType==DATE) {
  324.             column.setDataType(Variant.DATE);
  325.           }else if (columnType==DOUBLE) {
  326.             column.setDataType(Variant.DOUBLE);
  327.           }else if (columnType==FLOAT) {
  328.             column.setDataType(Variant.FLOAT);
  329.           }else if (columnType==INT) {
  330.             column.setDataType(Variant.INT);
  331.           }else if (columnType==LONG) {
  332.             column.setDataType(Variant.LONG);
  333.           }else if (columnType==SHORT) {
  334.             column.setDataType(Variant.SHORT);
  335.           }else if (columnType==STRING) {
  336.             column.setDataType(Variant.STRING);
  337.           }else if (columnType==TIME) {
  338.             column.setDataType(Variant.TIME);
  339.           }else if (columnType==TIMESTAMP) {
  340.             column.setDataType(Variant.TIMESTAMP);
  341.           }
  342.  
  343.           //Add the column to the template
  344.           ds.addColumn(column);
  345.         } //end if (schema.getRow...)
  346.       } //end for(...)
  347.  
  348.       if (sampleData) {
  349.         // Create 10 records of sample data
  350.         ds.open();
  351.         for (int i=0; i<10;i++) {
  352.           sampleRow=new DataRow(ds);
  353.           for (int j=0; j<numRows; j++) {
  354.             columnPrecision=ds.getColumn(j).getPrecision();
  355.             switch (ds.getColumn(j).getDataType()) {
  356.               case Variant.BIGDECIMAL:
  357.                 sampleRow.setBigDecimal(j,new BigDecimal(123.45));
  358.                 break;
  359.               case Variant.BOOLEAN:
  360.               sampleRow.setBoolean(j,true);
  361.                 break;
  362.               case Variant.BYTE:
  363.                 sampleRow.setByte(j, (byte) 127);
  364.                 break;
  365.               case Variant.DATE:
  366.                 sampleRow.setDate(j,new java.sql.Date(97,7,1));
  367.                 break;
  368.               case Variant.DOUBLE:
  369.                 sampleRow.setDouble(j,123.45);
  370.                 break;
  371.               case Variant.FLOAT:
  372.                 sampleRow.setFloat(j,1234.56F);
  373.                 break;
  374.               case Variant.INT:
  375.                 sampleRow.setInt(j,10);
  376.                 break;
  377.               case Variant.LONG:
  378.                 sampleRow.setLong(j,1000000L);
  379.                 break;
  380.               case Variant.SHORT:
  381.                 sampleRow.setShort(j,(short)1000);
  382.                 break;
  383.               case Variant.STRING:
  384.                 defString=ds.getColumn(j).getColumnName()+recordCounter;
  385.                 if (defString.length() > ds.getColumn(j).getPrecision()) {
  386.                   defString=defString.substring(0,columnPrecision);
  387.                 }
  388.                 sampleRow.setString(j,defString);
  389.                 break;
  390.               case Variant.TIME:
  391.                 sampleRow.setTime(j,new java.sql.Time(12,30,30));
  392.                 break;
  393.               case Variant.TIMESTAMP:
  394.                 sampleRow.setTimestamp(j,new java.sql.Timestamp(97,7,1,12,30,30,30));
  395.                 break;
  396.             }
  397.           }
  398.           ds.addRow(sampleRow);
  399.           ds.post();
  400.           recordCounter++;
  401.         }
  402.  
  403.       }
  404.       ds.close();
  405.     }
  406.     catch (Exception x) {
  407.       x.printStackTrace();
  408.     }
  409.   return ds;
  410.   } // end getDataSet
  411.  
  412.   //Generates a sample application to view text schema
  413.   //Strings beginning with "$" in this array result in a method
  414.   //call which generates form specific code in place.
  415.   //For example, "$codeGen1", will call codeGen1(PrintWriter out)
  416.   //This is an interesting example of using reflection to call a method
  417.   //specified by a string.
  418.   private String codeBlock[] = {
  419.     "// Change package name to match actual directory where created",
  420.     "package borland.samples.apps.schemaeditor;",
  421.     "",
  422.     "import java.awt.*;",
  423.     "import java.awt.event.*;",
  424.     "import borland.jbcl.layout.*;",
  425.     "import borland.jbcl.control.*;",
  426.     "import borland.jbcl.dataset.*;",
  427.     "import borland.sql.dataset.*;",
  428.     "",
  429.     "$codeGenC0", //"public class TestSchema {",
  430.     "  // !!! These variables must be hand edited to make sample work",
  431.     "  boolean useTableDataSet = true; //false->use a query DataSet",
  432.     "  // If you are using a local data file, set the following",
  433.     "$codeGenS0",
  434.     "  // If you are using a local or remote SQL server, set the following",
  435.     "  String sqlDataBaseName=\"TestSchema\";",
  436.     "  String sqlTableName=\"TestSchema\";",
  437.     "  String sqlUserName=\"SYSDBA\";",
  438.     "  String sqlPassword=\"masterkey\";",
  439.     "",
  440.     "  StorageDataSet dataSet;",
  441.  
  442.     "  Database database1 = new Database();",
  443.     "  TextDataFile textDataFile1 = new TextDataFile();",
  444.     "",
  445.     "  BorderLayout borderLayout1 = new BorderLayout();",
  446.     "  DecoratedFrame frame = new DecoratedFrame();",
  447.     "  TestPanel panel = new TestPanel();",
  448.     "  NavigatorControl navigatorControl1 = new NavigatorControl();",
  449.     "  StatusBar statusBar1 = new StatusBar();",
  450.     "",
  451.     "  //Construct the application",
  452.     "$codeGenC1", //"  public TestSchema() {",
  453.     "    try {",
  454.     "      jbInit();",
  455.     "    }",
  456.     "    catch (Exception e) {",
  457.     "      e.printStackTrace();",
  458.     "    }",
  459.     "    frame.pack();",
  460.     "    //Center the window",
  461.     "    Dimension screenSize = Toolkit.getDefaultToolkit().getScreenSize();",
  462.     "    Dimension frameSize = frame.getPreferredSize();",
  463.     "    if (frameSize.height > screenSize.height)",
  464.     "      frameSize.height = screenSize.height;",
  465.     "    if (frameSize.width > screenSize.width)",
  466.     "      frameSize.width = screenSize.width;",
  467.     "    frame.setLocation((screenSize.width - frameSize.width) / 2, (screenSize.height - frameSize.height) / 2);",
  468.     "    frame.setVisible(true);",
  469.     "  }",
  470.     "",
  471.     "  void jbInit() throws Exception{",
  472.     "    frame.setExitOnClose(false); //Allows us to grab the window closing event",
  473.     "$codeGenC4", //"    frame.addWindowListener(new TestSchema_frame_windowAdapter(this));",
  474.     "    frame.setLayout(borderLayout1);",
  475.     "    frame.add(navigatorControl1, BorderLayout.NORTH);",
  476.     "    frame.add(panel,BorderLayout.CENTER);",
  477.     "    frame.add(statusBar1, BorderLayout.SOUTH);",
  478.     "    frame.setTitle(\"Schema Editor\");",
  479.     "    if (useTableDataSet) {",
  480.     "      textDataFile1.setFileName(tableDataSetName);",
  481.     "      dataSet=new TableDataSet();",
  482.     "      dataSet.setDataFile(textDataFile1);",
  483.     "    } else {",
  484.     "      database1.setConnection(new borland.sql.dataset.ConnectionDescriptor(\"jdbc:odbc:\" + sqlDataBaseName, sqlUserName, sqlPassword, false, \"sun.jdbc.odbc.JdbcOdbcDriver\"));",
  485.     "      QueryDataSet qds = new QueryDataSet();",
  486.     "      qds.setQuery(new borland.sql.dataset.QueryDescriptor(database1, \"select * from \"+sqlTableName, null, true, Load.ALL));",
  487.     "      dataSet=qds;",
  488.     "    }",
  489.     "    panel.setDataSet(dataSet);",
  490.     "    navigatorControl1.setDataSet(dataSet);",
  491.     "    statusBar1.setDataSet(dataSet);",
  492.     "   }",
  493.     "",
  494.     "   void frame_windowClosing(WindowEvent e) {",
  495.     "     try {",
  496.     "       //Save any changes",
  497.     "       if (useTableDataSet) {",
  498.     "         textDataFile1.save(dataSet);",
  499.     "       } else {",
  500.     "         dataSet.saveChanges(); //Save query data set",
  501.     "       }",
  502.     "     } catch (Exception x) {x.printStackTrace();}",
  503.     "     System.exit(0);",
  504.     "   }",
  505.     "",
  506.     "  //Main method",
  507.     "  static public void main(String[] args) {",
  508.     "$codeGenC2", //"    TestSchema ts = new TestSchema();",
  509.     "    System.out.println(ts.getCreateTableSQL());",
  510.     "  }",
  511.     "",
  512.     "  //Returns a SQL string that can be used to create this table",
  513.     "  //in Local Interbase",
  514.     "  String getCreateTableSQL() {",
  515.     "    String sql;",
  516.     "$codeGen0", //Create SQL string
  517.     "  }",
  518.     "}",
  519.     "",
  520.     "// This panel can be reused in other applications",
  521.     "// Note the use of a split panel to allow resizable panes",
  522.     "// You will get a warning when you compile this until you extract it to a separate file",
  523.     "public class TestPanel extends SplitPanel {",
  524.     "  BevelPanel panel1=new BevelPanel();",
  525.     "  BevelPanel panel2=new BevelPanel();",
  526.     "  GridLayout gridLayout1 = new GridLayout();",
  527.     "  DataSet dataSet;",
  528.     "",
  529.     "$codeGen1", //Create field controls
  530.     "",
  531.     "  public TestPanel() {",
  532.     "    try {",
  533.     "      jbInit();",
  534.     "    }",
  535.     "    catch (Exception e) {",
  536.     "      e.printStackTrace();",
  537.     "    }",
  538.     "  }",
  539.     "",
  540.     "  public void setDataSet (StorageDataSet s) {",
  541.     "    dataSet=s;",
  542.     "$codeGen3", //Set the dataset for all fields
  543.     "  }",
  544.     "",
  545.     "  void jbInit() throws Exception{",
  546.     "    gridLayout1.setRows(-1);",
  547.     "    gridLayout1.setColumns(1);",
  548.     "    panel1.setLayout(gridLayout1);",
  549.     "    panel2.setLayout(gridLayout1);",
  550.     "$codeGen2", //Init field controls
  551.     "    //Create the split panels",
  552.     "    this.add(panel1,new PaneConstraints(\"panel1\", \"panel1\", PaneConstraints.ROOT, 1.0f));",
  553.     "    this.add(panel2,new PaneConstraints(\"panel2\", \"panel2\", PaneConstraints.RIGHT, 0.70f));",    
  554.     "  }",
  555.     "}",
  556.     "",
  557.     "$codeGenC3",
  558.     "    this.adaptee = adaptee;",
  559.     "  }",
  560.     "",
  561.     "  public void windowClosing(WindowEvent e) {",
  562.     "    adaptee.frame_windowClosing(e);",
  563.     "  }",
  564.     "}",
  565.     ""
  566.   };
  567.   GridBagLayout gridBagLayout1 = new GridBagLayout();
  568.  
  569.   //filename specifies the name of the data table to browse    
  570.   public void generateApp(String directory, String fileName, String lastSchema) {
  571.     Method m;
  572.     Class c = this.getClass();
  573.     String methodName;
  574.     String className; //Derived from fileName, wo .java suffix
  575.     if (fileName.endsWith(".java")) {
  576.         className=(fileName.substring(0,fileName.lastIndexOf(".java")));  
  577.       }
  578.     else {
  579.       className = fileName;
  580.     }
  581.     //Replace any "\" in the string with "\\" so that we can generate legal code
  582.     String schemaName="";
  583.     for (int i=0; i<lastSchema.length(); i++) {
  584.       if (lastSchema.charAt(i) == '\\') {
  585.         schemaName=schemaName+"\\\\";
  586.       } else {
  587.         schemaName=schemaName+lastSchema.charAt(i);
  588.       }
  589.     }
  590.     try {
  591.       PrintWriter out = new PrintWriter(new FileOutputStream(directory+fileName));
  592.       schema.enableDataSetEvents(false); //Stop painting
  593.       for (int i=0; i<codeBlock.length; i++) {
  594.         if (codeBlock[i].startsWith("$")) {
  595.           //Code generating function
  596.           methodName=codeBlock[i].substring(1);
  597.           m = c.getDeclaredMethod(methodName,new Class[] {out.getClass(),String.class,String.class});
  598.           m.invoke(this,new Object[] {out,className, schemaName});
  599.         } else {
  600.           out.println(codeBlock[i]);
  601.         }
  602.       }
  603.       out.close();
  604.       schema.enableDataSetEvents(true);
  605.     } catch (Exception e) { e.printStackTrace(); }
  606.   }
  607.   private void codeGenS0(PrintWriter out, String cn, String sn) {
  608.     out.println("  String tableDataSetName=\"" + sn +"\";");
  609.   }
  610.   //Code gen for all classname specific code
  611.   private void codeGenC0(PrintWriter out, String cn, String sn) {
  612.     out.println("public class " + cn + " {");
  613.   }
  614.   private void codeGenC1(PrintWriter out, String cn, String sn) {
  615.     out.println("  public " + cn + "() {");
  616.   }
  617.   private void codeGenC2(PrintWriter out, String cn, String sn) {
  618.     out.println("    " + cn + " ts = new " + cn + "();");
  619.   }      
  620.   private void codeGenC3(PrintWriter out, String cn, String sn) {
  621.     out.println("class "+cn+"_frame_windowAdapter extends java.awt.event.WindowAdapter {");
  622.     out.println("  "+cn+" adaptee;");
  623.     out.println("  "+cn+"_frame_windowAdapter("+cn+" adaptee) {");
  624.   }       
  625.   private void codeGenC4(PrintWriter out, String cn, String sn) {
  626.     out.println("    frame.addWindowListener(new "+cn+"_frame_windowAdapter(this));");  
  627.   }  
  628.   //GenCode1 - Create Field controls
  629.   private void codeGen1(PrintWriter out, String cn, String sn) {
  630.     try { 
  631.       DataRow row=new DataRow(schema);
  632.       String fn; //Field name
  633.       schema.first();
  634.       for (int i=0; i<schema.getRowCount(); i++,schema.next()) {
  635.         schema.getDataRow(row);
  636.         fn=row.getString(NAME);
  637.         //Label
  638.         out.println("  LabelControl label"+i+" = new LabelControl();");
  639.         //Field Control
  640.         out.println("  FieldControl field"+i+" = new FieldControl(); //"+fn);
  641.       }
  642.     } catch (Exception e) {e.printStackTrace();}
  643.   }      
  644.   //GenCode2 - Init the fields
  645.   private void codeGen2(PrintWriter out, String cn, String sn) {
  646.     try {
  647.       DataRow row=new DataRow(schema);
  648.       String fn; //Field name
  649.       schema.first();
  650.       for (int i=0; i<schema.getRowCount(); i++,schema.next()) {
  651.         schema.getDataRow(row);
  652.         fn=row.getString(NAME);
  653.         //Label
  654.         out.println("    label" + i + ".setText(\"" + fn + "\");");
  655.         //Field Control
  656.         out.println("    field" + i + ".setColumnName(\"" + fn + "\");");
  657.         //Add to panel
  658.         out.println("    panel1.add(label" + i + ",null);");
  659.         out.println("    panel2.add(field" + i + ",null);");
  660.       }
  661.     } catch (Exception e) {e.printStackTrace();}
  662.   }
  663.   
  664.   //Generate the rest of the setDataSet method
  665.   private void codeGen3(PrintWriter out, String cn, String sn) {
  666.     try {
  667.       DataRow row=new DataRow(schema);
  668.       schema.first();
  669.       for (int i=0; i<schema.getRowCount(); i++,schema.next()) {
  670.         schema.getDataRow(row);
  671.         out.println("    field" + i + ".setDataSet(dataSet);");
  672.       }
  673.     } catch (Exception e) {e.printStackTrace();}
  674.   }                                                
  675.                                                   
  676.   // GenCode0 - Generate a method to return a SQL string to create table
  677.   private void codeGen0(PrintWriter out, String cn, String sn) {
  678.     try {
  679.       String sql=new String();
  680.       String type=new String();
  681.       DataRow row=new DataRow(schema);
  682.       schema.first();
  683.       for (int i=0; i<schema.getRowCount(); i++,schema.next()) {
  684.         schema.getDataRow(row);
  685.         type=row.getString(TYPE);
  686.         sql=sql + row.getString(NAME) + " " + type;
  687.         if (type != INT) { //INTEGER has no size parameter in SQL
  688.           sql=sql+ " (" + row.getInt(SIZE) + ")";
  689.         }
  690.         //First field is considered the primary key
  691.         if (i==0) {
  692.           sql=sql+" NOT NULL PRIMARY KEY";
  693.         }
  694.         if (i<schema.getRowCount()-1) {
  695.           sql=sql+","; //Last field can't have trailing comma
  696.         }
  697.       }
  698.       out.println("    sql=\"create table \"+sqlTableName+\" (" + sql + ")\";");
  699.       out.println("    return sql;");
  700.     } catch (Exception e) {e.printStackTrace();}
  701.   }
  702.   
  703.   void addField_actionPerformed(ActionEvent e) {
  704.     addRow();
  705.   }
  706.  
  707.   //Remove the current field
  708.   void delField_actionPerformed(ActionEvent e) {
  709.     try {
  710.       schema.deleteRow();
  711.     } catch (Exception x) {
  712.       x.printStackTrace();
  713.     }
  714.   }
  715.   
  716. } //end class
  717.  
  718. class SchemaFieldTypeEditor extends Choice implements ItemEditor {
  719.   SchemaFieldTypeEditor() {
  720.     super();
  721.     setBounds(0,0,0,0);
  722.     setVisible(false);
  723.     //Display all valid datatypes for a TextDataSet
  724.     addItem(SchemaPanel.BIGDECIMAL);
  725.     addItem(SchemaPanel.BOOLEAN);
  726.     addItem(SchemaPanel.BYTE);
  727.     addItem(SchemaPanel.DATE);
  728.     addItem(SchemaPanel.DOUBLE);
  729.     addItem(SchemaPanel.FLOAT);
  730.     addItem(SchemaPanel.INT);
  731.     addItem(SchemaPanel.LONG);
  732.     addItem(SchemaPanel.SHORT);
  733.     addItem(SchemaPanel.STRING);
  734.     addItem(SchemaPanel.TIME);
  735.     addItem(SchemaPanel.TIMESTAMP);
  736.  
  737.   }
  738.  
  739.   public Object getValue() {
  740.     return getSelectedItem();
  741.   }
  742.  
  743.   public Component getComponent() { return this; }
  744.  
  745.   public void startEdit(Object value, Rectangle bounds, ItemEditSite site) {
  746.     select(value.toString()); //Get whatever is in the grid and select it
  747.     changeBounds(bounds);
  748.     setVisible(true);
  749.   }
  750.  
  751.   public void changeBounds(Rectangle bounds) {
  752.     setBounds(bounds.x, bounds.y, bounds.width, bounds.height);
  753.   }
  754.  
  755.   public boolean canPost() {
  756.     return true;
  757.   }
  758.  
  759.   public void endEdit(boolean post) {}
  760. }
  761.  
  762.  
  763. class SchemaPrimaryKeyEditor extends Checkbox implements ItemEditor {
  764.   SchemaPrimaryKeyEditor() {
  765.     super();
  766.     setBounds(0,0,0,0);
  767.     setVisible(false);
  768.   }
  769.  
  770.   public Object getValue() {
  771.     return new Checkbox();
  772.   }
  773.  
  774.   public Component getComponent() { return this; }
  775.  
  776.   public void startEdit(Object value, Rectangle bounds, ItemEditSite site) {
  777.     changeBounds(bounds);
  778.     setVisible(true);
  779.   }
  780.  
  781.   public void changeBounds(Rectangle bounds) {
  782.     setBounds(bounds.x, bounds.y, bounds.width, bounds.height);
  783.   }
  784.  
  785.   public boolean canPost() {
  786.     return true;
  787.   }
  788.  
  789.   public void endEdit(boolean post) {}
  790. }
  791.  
  792. class SchemaPanel_addField_actionAdapter implements java.awt.event.ActionListener {
  793.   SchemaPanel adaptee;
  794.  
  795.   SchemaPanel_addField_actionAdapter(SchemaPanel adaptee) {
  796.     this.adaptee = adaptee;
  797.   }
  798.  
  799.   public void actionPerformed(ActionEvent e) {
  800.     adaptee.addField_actionPerformed(e);
  801.   }
  802. }
  803.  
  804. class SchemaPanel_delField_actionAdapter implements java.awt.event.ActionListener {
  805.   SchemaPanel adaptee;
  806.  
  807.   SchemaPanel_delField_actionAdapter(SchemaPanel adaptee) {
  808.     this.adaptee = adaptee;
  809.   }
  810.  
  811.   public void actionPerformed(ActionEvent e) {
  812.     adaptee.delField_actionPerformed(e);
  813.   }
  814. }
  815.  
  816.