Removed some of the code from the generated files. For example the code that actually builds the layout of the screen is now in its own class file. This is written the first time you generate an application. From then on it is not overwritten. This allows you to manually set up the screen the way you want and if you regenerate the application these changes are not lost.

Enhanced the Find routine.

Added a Duplicate current row, NEXT and PREVIOUS button to the pop-up menu.

When you save changes, these changes are reflected immediately in the JTable that displays the rows. This was done without re-reading all of the data and rebuilding the JTable.

Added an EXTRA button to each application. This button activates a separate class. The first time the application is generated this class is written out with dummy code. You can add functionality to this class and it will not be overwritten if the application is regenerated. You can change the name from "eXtra" using the I18N table edit described above.

Added another demo application to the sample application. This is an inventory edit screen that uses the extra button to merge table information into an HTML template. This template creates an ad for eBay. The Extra button also has an option that writes the necessary data out to a CSV formatted text file for import into eBay's Turbo Lister program. Using this system you can keep track of inventory, build ads to auction the inventory and automatically send the ads to Turbo Lister. Turbo Lister allows you to double check your work and upload the ads to eBay when you are ready for the auctions to start.

 ;; 10/7/2003 - Removed JGuiGenIni.xml, JGuiGen.Java, com/halepringle/src/UserLogData.Java, com/jguigen/standard/Model.java and com/jguigen/standard/DBMaster.java from the CVS repository and renamed them to *.javatemplate. ; These three files were added to the CVS repository. ; A setup.bat and a setup.sh file were also created.  The batch/script files copy the template files into their proper place.  The net result is that changes to the xml file, UserLogData.java,  JGuiGen.java, Model.java and DBMaster.java are not updated into the CVS repository.  Since these files are edited by each project in a unique way, this is desirable behavior. ; In order to commit a change to the repository so that every new project will have the change, the javatemplate files must be updated.

 ; 10/10/2003 - automated some steps that required cut and paste.  The steps automatically insert code into the XML file and the Model.java file as needed now.

Java Web Start - When I reactivate it you will be able to download an sample executable JGuiGen using Java Web Start (JAWS) on the SourceForge web site. Right now this is not functioning

The classes downloaded via JAWS will automatically unjar a copy of the necessary data base using Hypersonic SQL (hsqlhd on SourceForge.net).
It will also automatically unjar a copy of the XML file that contains setup information JGuiGen uses when an application starts up (JGuiGenIni.XML).

The XML file contains references to the JDBC Driver, the data base URL, the account to use to open the data base, etc.

There are currently URLS, Driver setups, etc. for six different backend SQL databases in the XML setup file (JGuiGenIni.xml). The set pointing to the 1) HSQL database is live. The xml properties pointing to the 2) MS Access, 3) PostgreSQL, 4) MS SQL-SERVER, 5) OracleXE, and 6) MySQL databases are commented out. You can edit the XML file and run the application against the other database types. See the sections below for information about running against PostgreSQL, SQL-SERVER, Oracle, mySQL and MS Access databases.

Full Copy -  You can copy down a full copy of JGuiGen from the HalePringle.com web site.  You will need to unzip the three files  ; There are more instructions below. 

SVN Repository on SourceForge-  You can obtain the most recent code from the SVN repository.  If you have installed subversion you can download a working copy of everything with the following command
svn checkout https://svn.sourceforge.net/svnroot/jguigen/JGuiGen/trunk jguigen
In this case the last word is the name of the folder that svn will create with this project installed. You can look at a video that walks through the steps at http://vernon.is-a-geek.org/mediawiki/index.php/JGuiGen_Demo_with_Hale%27s_notes
Note: the PostgreSQL data base on my web site are not currently active. I will reactivate it upon request.

B. WHAT TO DO FIRST

Java Web Start (JAWS) - When you launch JGuiGen with JAWS the sample program runs automatically. (You will be asked to okay a certificate from Hale Pringle that is not verified. You will need to say it is okay for the system to download and run.)

Full Copy and SVN versions-  After you download and unzip the full copy run build.bat or ./build.sh   This sets up a classpath and compiles the code. Then run run.bat JGuiGen or ./run.sh JGuiGen to run the main application. You can run run.bat com\halepringle\src\JGuiGenDemo or ./run.sh com/halepringle/src/JGuiGenDemo to run a demonstration of what JGuiGen generates. There is more information below. I use the Eclipse IDE and there is a section below that describes running JGuiGen from this IDE. Other IDE are similar.

Edit JGuiGenIni.xml file - After you start you may want to use a text editor and edit the JGuiGenIni.xml file.  There is a list of users in this (you will see Hale, Vernon, and Tester already there.)  You may want to add your name to this list. ; If you don't modify the file, you can use any of the three names that are already there and the system will run using the HSQL tiny database system.

WHEN YOU FIRST RUN the JGuiGen.class- you will be asked to point to the path to the executable file that runs your browser of choice and your word processor/editor of choice. When one of the applications needs to show you something in HTML format it will invoke the file you point to. You will only need to do this once per machine.  Typical paths are shown in the prompt when you are asked to pick the path to your browser of choice.

Running the sample JGuiGen Application - The Main JGuiGen screen will come up. If you want to see what a generated screen looks like click on USERS --> View JGuiGenDemo. This will bring up a sample screen that has been generated by JGuiGen. This screen demonstrates virtually all of the special features that JGuiGen can generate. These are covered in some detail on the web site.

Creating a JGuiGen generated application You can run the DataDictionary portion of JGuiGen under the DataDictionary -->Execute menu option. The options available to you are described in some detail on the web site and in the HELP screen that comes up when you press the Help button on the DataDictionary Edit Screen. The Internationalization edit screen is also available under the DataDictionary menu option.

• MARK TABLES - See a list of tables in your SQL database and indicate which ones you are interested in working with.

• CHECK - In your JGuiGenIni.XML file you point to a database and indicate the user name and password (if required) used to access the database. (See the LDAP section for instructions on encrypting the user name and password used to access the SQL database.) The CHECK option will compare the contents of the current data_dict table with the actual contents of tables in your database. This data_dict table is a "data dictionary" that describes your tables. There is one row in data_dict for each column in each table your are interested in. The CHECK option will fill the data_dict table with information about the columns in each SQL table of interest in your database and will generate a detailed documentation printout that describes these tables. Additions, deletions and changes in the tables are noted in this documentation. ;
  
  JGuiGen comes with an edit screen for the data_dict table. You can use this screen edit the fields that describe each column in the tables in this database. When you rerun the CHECK option, the printout will include the descriptions and notes that you add here. This is described in more detail later.
  
  
• EDIT Class Description - At the top of the Edit Screen there is a combo box. You can choose the table you wish to edit from this list. It will restrict the JTable at the bottom of the screen to classes being generated for one table. This is where you indicate things about the entire class you will generate. Click the HELP button for more information about the options available here.
  
  
• EDIT Column Descriptions - At the top of the Edit Screen there is a combo box. You can choose the table you wish to edit from this list. It will restrict the JTable at the bottom of the screen to just the columns contained in that table. You can click on different rows in the JTable at the bottom of the screen and edit to add comments, notes, indicate which type of java class to use when editing this field (i.e. combobox), how the data should be validated, etc. Click the Help button for more instructions about the options available here.
  
• Generate Code - This menu option brings up a screen that lets you do three things.
  
  • MODEL - This button creates an abstractTableModel for one table. One of the typical ways java programmers use to access SQL tables involves creating an abstract table model class. This class contains the SQL query, insert, and delete code used by other classes to access a SQL table. NOTE: Use the USERLOGDATA table for your testing. (There are snippets in the generated file that will be automatically merged into the com.jguigen.standard.Model.java file.  These are already commented out.  You can delete them if you want.)  If you create the abstractTableModel for UserLogData, it will be in com.halepringle.src.UserLogDataTableModel.java.
    
  • ORDER - This button presents a screen that allows you to sort the columns in a table into an order that will be used in the generated GUI Edit screen.
    
  • CREATE - This writes out the java files necessary to have a GUI view/add/edit/delete screen for one table. It also writes out a resource bundle for internationalization, and two files needed to run a JUnit (jfcUnit) testCase against the generated GUI file. If you create a GUI for UserLogData, the generated code will be in com.halepringle.src.UserLogData.java, com.halepringle.src.UserLogDataTest.java, com.halepringle.src.UserLogDataAbstractTestCase.java and (root folder) UserLogDataRb.properties.
    

• Internationalization - This screen lets you modify the screen prompts for the application you just created.

• Codes Bank - Some fields in the generated code will be edited using Visual components such as JLists, JComboboxes or radio buttons. The components need a place to find their data. The codes bank is where JGuiGen stores these values.

Windows - Step by Step

I. First we need to download a fairly current version of Java.
Navigate to javasoft.com
You need to have a later version of 1.4_8 (or so) or Java 1.5. If you decide on 1.4.2_10 (the last version of 1.4, you will need to search for the download using the search area in the upper right corner of the screen.

• Download the SDK (System Developer Kit) or JDK (Java Development Kit as they are calling it now) not the Java Runtime Environment (JRE).
• Accept Certificates (twice)
  
• Click on Accept
  
• Download Java Development Kit 1.4.2_10 or Java Development Kit 1.5.?
  
• The last time I pulled down a version it was the SDK 1.4.2_10 and NetBeans bundle. This gave a very nice Installshield install
  
• Editing your path: You may need to go to Control Panel --> System --> Advanced --> Environment variables and change the PATH to point to your new version of Java.
• We will need to set some places in Eclipse in order to use this version.

II. If you want an Integrated Development Environment (DE) you will need to download Eclipse

• Download eclipse from eclipse.org
• The version you download will be a zip file that you can unzip where ever you want eclipse to reside. There is nothing more to the install.
• I usually right click the windows start button --> Explore and navigate to where I unzipped Eclipse. I find Eclipse.exe and right click on it. When I choose the "Send to --> Desktop (Shortcut button)" the system places a shortcut on my desktop.

  
  

III. Now we download the source code

• Best is to get the newest from sourceforge.net. You will need to download a subversion client I used Tortisesvn from http://tortoisesvn.tigris.org/
  Tortisesvn merged into your windows explorer. Open the windows explorer and create a folder. Highlight the folder and right click. You should see a Tortisesvn Checkout option. Click on that and fill in the information. The "URL of Repository" is https://svn.sourceforge.net/svnroot/jguigen/JGuiGen/trunk Then "Checkout Directory" should already be filled in. The only other things that should be checked is the "HEAD Revision" checkbox. If you download a command line client the command will be
  svn checkout https://svn.sourceforge.net/svnroot/jguigen/JGuiGen/trunk jguigen
  This creates a folder called jguigen under your home (or wherever you were when you ran the file.) If you download using subversion you only need to unzip JGuiGenMisc.zip
• Alternatively you can Go to www.halepringle.com --> JGuiGen (tab on left side) at the bottom of the screen download JGuiGenCode.zip, JGuiGenJars.zip and JGuiGenMisc.zip 5, 11 and 1 meg or thereabouts
  
• Put these where you want them. I created a folder called JGuiGen under my JProjects folder and put them there.
• Unzip them.

III Running Eclipse

• Start up Eclipse 3.1
  
  I kill the Welcome Screen (red x on its tab)
  Click on Window --> Open Perspective --> Debug
  Now you will see two tabs in the upper right. You can switch back and forth.
  The Java Perspective has the nice tree for opening files
  The Debug Perspective allows you to "Terminate and Remove Threads" (Right click on a thread in the upper left and click on Terminate and Remove.
  You will need this because HSQL (the sample database in use) is truly single-user. If a thread hangs you can't open it again until that "user" goes away.
  
• Click on File --> New -- Jave Project --> Next and enter JGuiGen change the "Open new project in Workspace" to "Create project from existing source" and browse for the folder you placed JGuiGen in.
• You may need to add the Java Run Time that we down loaded
  Click on Window Tab --> Preferences --> Installed JRE's I had to add c:\j2sdk1.4.2_10 and put a check mark by it to make it live
• If I have forgotten to remove the ojdbc14.jar from the Build Path (again) You will see an error at the bottom of the screen that tells you that the jar is missing in the Build Path.
  Right click on the JGuiGen in the upper left of the Java Perspective. Click on Properties and Java Build Path
  Click the Libraries tab and remove the ojdbc14.jar. This is Oracle JDBC file and they won't let me send it unless I agree that I won't let people from foreign countries that the US doesn't like download it. I can't possibly stop them so there we are.

  You will also have to change the folder where Eclipse finds the /jre/lib/ext/jce.jar and the Note: You will need to change the JRE and add these two external jar
  files every time you download a complete copy of the source. If you do not unzip the JGuiGenMisc.zip file you will not need to update the classpath.
  

• click on the little arrow beside the Yellow Arrow Pointing down Uncheck the "Warnings" now clicking on the Yellow Down Arrow takes you to the next error in the file.

• Click on the plus beside the JGuiGen Package (upper left corner of Java Perspective
  
  
• Click on the plus be Default Package
  
  
• Double Click on JGuiGen.java
  
• Click on arrow beside the green circle --> run --> as Java Application
  
• One of the first steps should be run the JGuiGenDemo under the Users mens option.
  You can then generate UserLogData using the options under Data Dictionary.
  
• After the UserLogData files (model java code and main class java code) have been generated, you will need to right click on the JGuiGen Project in the upper left corner of the Eclipse Java Perspective. Choose "Refresh" and Eclipse will find the new java files in the com.halepringle.src folder. User projects choose "Build Project" or "Clear" to compile all of the new files. You can then run UserLogData on the Users menu option.

V. Running from the command line

We have created two batch files build.bat and run.bat.

• build.bat will compile the complete JGuiGen application.
• run.bat JGuiGen will run the JGuiGen application
• run.bat com/halepringle/src/JGuiGenDemo will run a Java Class generated by JGuiGen

• Open a Command Window (Start button --> All Programs --> Accessories --> Command )
• runUtil.bat DatabaseManager
• fill in JGuiGen on second line
• change from "In Memory" to "Standalone"
• change the <> to JGuiGenDB
  note the DB on the last line The next time you can get JGuiGen from the list at the top of the screen and you won't have to reenter the Standalone and the database name
• You can run SQL statements in the window and click on Execute

In normal development, I use the Eclipse (from eclipse.org) and run the DataDictionary application in com.jguigen.standard directly from the IDE and run the applications generated directly.

Finally there is a text file generated while JGuiGen is running. Developers or administrators can use these files to look for errors or to see who made certain changes. The files are called JGuiGen.txt.x where the "x" is replaced with 1, 2, 3, etc. They are written to the /Logs folder under the root folder for JGuiGen.

IX. Databases supported  

• PostgreSQL - most of the development work was done with this full featured and very powerful open source SQL database engine. In addition to being able to link to the PostgreSQL server on my system, there are four small java files that (after you configure the XML file) will create and fill the two tables required to run the samples in JGuiGen. This allows you to install PostgreSQL and run the samples on your own system.
  
  
• HSQL - the hsqldb project at SourceForge has created a very nice "small" SQL database. This database and its JDBC driver can be unzipped into a folder and at that point it is fully installed the JDBC driver can access it. For small systems and demonstration systems, this is ideal. HSQL scales up into multi- user and server versions as well.
  
  
• MySQL - this is also a high end open source database package.
  
  
• MS SQL SERVER - Microsoft's SQL Server is one of the large commercial databases heavily used in MS Shops. You can download a free (small) version called MSDE.
  
  
• Oracle - the Oracle database system is one of the largest commercial databases available in the market. Testing was done using the OracleXE version which is a light version for developers and small businesses.
  
  
• MS Access - Access is a well known and easy to use database system on Windows PCs. The database can be shipped to a PC, unzipped and it is ready to go. Unlike the HSQL database it requires the java ODBC-JDBC Bridge. This means that it cannot be used inside Java Web Start and we have not configured an ODBC driver for Linux yet. (There are commercial JDBC drivers for MS Access, but we haven't found an open source version yet.)

1. In a folder called C:\JGuiGen or /usr/home//jguigen.  You can change this by editing your copy of Model.java class used by all JGuiGen applications,
   
2. In the folder the JGuiGen class is currently running from.
   
3. Failing this, it looks for a jar called RMDatabases.jar. If this is found JGuiGen
   
4. unjars the database and the XML file from the jar.
   
5. If the RMDatabases.jar is not present it unjars one from the main JGuiGen.jar.  This one runs against the PostgreSQL database at my web site.
   

XII JGuiGen Security and LDAP Support

Authentication - who can log in

• Your call - first, you instantiate the Model class, then call
  Connection conn = Model.getConnection(username, password);,
  then call Model.setConnection(conn);
  You can optionally call Model.setUser("name of a user to record in tables"). If you don't make this call the user making changes will be recorded as "unknown".
  You get the database username and password and the username from your own code.
• Trusted environment - don't worry about it. Place the user name and password required to access your database in the JGuiGenINI.xml file. Anyone can see it. After you instantiate Model, make a call to Model.getUser(). This will make a connection and pop up a Dialog screen with user names to select from. They are taken from a list in the JGuiGenIni.xml file. There are no passwords. A connection will be made using the information in the JGuiGenIni.xml file.
• Stronger -In this case you do not put the database user name and password in the JGuiGenIni.xml file. You instantiate Model and make a call to model.getUser(). When the system notes that it can find the database, but doesn't have a user name and password to login with, it prompts your user with a fairly standard username/password screen. The password is hashed and that hash is compared with a hash stored in an LDAP system (a local file system is used if you do not have LDAP installed.) If the hashes match, the users password is used to decrypt a file containing the database user name and password. Local encrypted files are also decrypted to gain access to the LDAP in the first place and to determine the password used to encrypt selected fields in the table. See the Manual for more information about this system.

Note: At the time of this writing, the author does not actually have an LDAP system running. I am using JNDI which is Java's system for accessing multiple directory services with a standard set of calls. These calls should access Novel's NDS, Microsoft's Active Directory Service, various versions of LDAP - such as Open LDAP, etc. In this can I am using FSCONTEXT.jar which is a reference system provided by Sun to emulate LDAP. The information is being saved in a file called .bindings in the root directory where JGuiGen resides. While the user names are visible, the password information stored there is in hash form and it is VERY difficult to go from the exposed hash to the password that created that hash. These calls should work on a real LDAP or they may need some modification. I believe that they are close.

Note: The JGuiGenIni.xml file contains an entry for a shared path. This is a location where the encrypted text files are stored. This can be a shared network directory where IT can remove and add files at will or a local directory. If the shared path is "DEFAULT", the files will be in a System directory under the root location where JGuiGen resides.

Files: You will see the following files in the shared directory:

• <username>-keystore.bin - this is a special encrypted value used with the person's password to encrypt the other files. This is part of Password Generated Encryption.
• <username>-<databasetype>-DBUserPwd.encrypt - for example Hale-hsql-DBUserPwd.encrypt. This is the database user name and password used to access the HSQL database. The encryption is unique to the user Hale and is encrypted with Hale's keystore and his password.
• <username>-<databasetype>-DBEncrypt-encrypt - for example Hale-hsql-DBEncrypt.encrypt. This is an encrypted version of the password used to encrypt individual fields in the hsql database.
• <username>-fullRights-LDAP.encrypt - this is the name and password used to access the LDAP store. It indicates that the user Hale has the right to create new users. When the add-new-users screen is activated in JGuiGen all of the fields will be active. Of course - you must actually know an LDAP username and password to actually update the LDAP.
• <username>-ChangePwOnly-LDAP.encrypt - If the user does not have a "fullRights" file, they should have the "ChangePwOnly" file. In the case they will be able to change their own password, but will not be able to change anything else. This encrypted file should contain a user name and password that gives just enough rights for a person to access their own password and (optionally) change it.

Authorization

Encryption

General

HTTP Tunneling

NOTE: I have not worked on these files at this time and hence don't know if they will work for us, but they should.

XIII The JGuiGen Code Generator

First I take a working java program and mark it up. This becomes my template. The template always compiles and runs. This allows me to use an IDE to syntax check while I add features. It also allows me to compile and run the template until I get the results that I am looking for.

There are a few simple definitions and rules.

1. Definition - Constant code - this is code that (with a few small substitutions) will be the same from one version of a given application to the next. Things in JGuiGen like buttons and their listeners are constant code. I have broken my application down into some 17 main sections.
2. Variable Code - this is code that will differ dramatically based upon what type of SQL table columns we are dealing with. Dates will have pop-up calendars, while text fields will have very little "extra" code. There are some 20 Variable sections of code in JGuiGen.
3. Line Markers - Lines that should be included in the generation process will have a comment at the end. When we call the merge process we tell it which line markers to look for.
4. Merge Start and Stop codes - JGuiGen looks for certain codes in a line that tell it there are variables that should be merged. At present I use "_JGG_" to start and stop merge fields. This results in lines that javac understands even if they look a little odd to us. For example

   "public class _JGG_classname_JGG_ () { //MAINSOURCE"

   results in a line that compiles cleanly. JGuiGen would include this line if it is looking for the Line Marker "//MAINSOURCE" and could substitute the classname for _JGG_classname_JGG_.

5. Special comments - JGuiGen looks for lines that start with "//+" these lines are ignored by the javac compiler, but are included in the final generated output. In the few cases where I cannot use a line in my template that needs to be in the generated output, I start it with //+.

//Example code for the JGuiGen Code Generator
package com.halepringle.src;
#import java.swing.utils;
public class Sample() {
System.out.println("Generated Sample.java");
System.out.println("Hello World")
)


Part of what I am working toward is to merge two types of templates as part of the generation process.

Type one - Constant code I have a large class (5000 plus) lines that will edit a SQL table. You have seen an example on the web site. This is what I call constant code even though there are elements in it (such as classname) that are variables.

TYPE 2 Variable code- Code that is specific to one type of Visual Component.

The current JGuiGen application has 20 different places in it that need java code to be generated that is specific to one SQL table and the columns that it contains. Most of these places involve Visual Components. For example: If I have a SQL table with the column lastname char(30) I would have the following places that this appears in my code:

DECLARE JBoundedTextFeild txtLastName = new JBoundedTextField(30);

INCLUDE IN AN ARRAY OF TABLE HEADERS ,"lastname"

INCLUDE ITS WIDTH IN AN ARRAY OF COLUMN WIDTHS ,75

CREATE A LOCAL INT THAT ACCESSES THE FIELD IN A JTABLE CLASSNAME_LASTNAME = 2;

INSTANTIATE txtLastName.setToolTip("_JGG_description_JGG_");
txtLastName.getAccessibility......
txtLastName.setName("last name");
etc.
LISTENER FOR VALIDATAION

CODE TO CHECK FOR ERRORS

CODE TO GET THIS FIELD OUT OF A SQL RESULTSET AND PUTS IT INTO A BEAN

tmpString = (String) rs.getString(tablename.LASTNAME);
if (tmpString = null) {tmpString = "";}
origDataBean.setLastName(tmpString);


CODE THAT TAKES IT FROM A BEAN AND PUTS IT INTO THE VISUAL COMPONENT
txtLastName.setText(origDataBeam.getLastName());


CODE THAT TAKES IT OUT OF THE VISUAL COMPONENT AND PUTS IT INTO A NEW BEAN
revisedDataBean.setLastName(txtLastName.value);


CODE THAT COMPARES THE TWO BEANS AND CREATES SQL STATEMENTS


classname_UPDATE_VARLIST += "lastname, ";
classname UPDATE_VALUELIST +=
"'"+revisedDataBean.getLastName()+"', ";
if (!{origBean.getLastName().equals(
revisedBean.get:astLastName())){
msg =+ "LastName changed":
classname_INSERLIST += "lastname = '"+
revisedBean.getLastName()+"', ";
changes++
}


Code is also needed to update a row in the JTABLE, special renders that might be needed for the JTable, etc. etc.

The bottom line is that all of this code is specific to a JBoundedTextField and will be extracted from a Java class file that is running code, but only has a couple of fields - one of which is a JBoundedTextField. The column name is this code will be _JGG_colname_JGG_ This will compile and run, but will be easy to find and substitute when I use the code in the merge. I'll have another class that contains all of the same code for a date, an integer, a regex field, etc.

Putting it together:

The final generated application will take all of the constant code and bits and pieces of the Variable definition files. If you have 30 char fields in your SQL table, it will have the same code 30 times, but with different column names substituted in the appropriate places. I haven't been really scoping this out as a generic tool, but I know that when I finish I will have enough pieces to fit into almost any running java code that I have worked with and turn it into a template.

XIV - Files and Jars used by JGuiGen

There are a number of special files and jars used by JGuiGen.  Here is a listing of some of the critical ones for developers.  The special classes provided for your use and used by JGuiGen applications are listed on the web site.  These are both provided through Java Web Start so that they are available to run the application and they are needed in your CLASSPATH when you develop using the JGuiGen system.  I use the Eclipse IDE and I need to Right Click on the Project name, choose Properties and choose BUILDPATH.  I then "add external libraries" and add all of these.

•  hsqldb.jar - HSQL system.  This jar has the JDBC driver for the HSQL database, the Database Manager application for HSQL and other classes required to access and use an HSQL database.  
• jaccess.jar - Accessibility (A11y) - This jar is required for use with   assistive technology extensions. These extensions are used to help handicapped users.


• jakarta-regexp-1.2.jar - This regular expression system from the Jakarta project is used by jfcUnit.
  
• jdom.jar - This is used to access the JGuiGenIni.xml file.
  
• jh.jar - The JavaHelp jar is from Sun Microsystems (r) and contains the classes to access the JGuiGenHelp.jar
  
• junit.jar - The classes required for JUnit testing.
  
• jfcunit.jar- This is an extension of JUnit and is used for testing GUI code.
  
• pgjdbc2.jar - The drivers to access PostgreSQL databases.
  
• xerces.jar - The XML parser used to parse the JGuiGenIni.xml file.
• mysql-connector-java-3.0.11-stable-bin.jar - JDBC driver for MySQL
  
• bsh-1.2b6.jar - part of JFreeReports
• gnujaxp.jar - part of JFreeReports
• itext-1.00.jar - part of JFreeReports
• jcommon-0.9.1a.jar - part of JFreeReports
• jfreereport-0.8.4_8-all.jar - part of JFreeReports
• pixie-0.8.1.jar - part of JFreeReports
• poi-2.0-RC1-20031102.jar - part of JFreeReports
  
• jts-1.2.jar - JDBC Driver for SQL-SERVER
• ojdbc14.jar - JDBC Driver for Oracle
• wraplf.jar - a jar that allows anti-aliased fonts to be accessed
• l2fprod-common-fontchooser.jar - a jar that contains the screen to choose fonts with
• /jre/lib/ext/jce.jar - a security jar from Sun
• /jre/lib/ext/jsse.jar - a security jar from Sun
• fscontext.jar - a reference application for creating an local LDAP
• providerutil.jar - a reference application for creating an local LDAP

• jscroll-1.0.2.jar - is needed for one of the com/halepringle/standard source files. It is not actually used by JGuiGen at this point.
  

In addition there are three jar files and some other files created by JGuiGen.  When these are downloaded by Java Web Start they will have the letters "RM" added to the front of each file.

• Database.jar - The HSQL database and the MS Access database are shipped in this jar.  The files in the jar are unjarred on the target PC.
  
•  JGuiGenHelp.jar - The help file is accessed directly from this jar.
  
• JGuiGen.jar - The main application is shipped in this jar.
  
• cd2JGuiGen.bat and cd2JGuiGen.sh - these batch and shell files are placed in your $HOMEDIR.  They will changed directories into the folder where Java Web Start installed JGuiGen.
  
• jawsUnjar.bat and jawsUnjar.sh - These batch and shell files are placed in the folder where Java Web Start installed JGuiGen.  When it is run, the com\halepringle\standard\*.class files will be extracted from the JGuiGen jar.  A couple of properties files are also unjarred.   Once this has happened you should be able to compile java files that you create with the JGuiGen DataDictionary application.
  
• JGuiGen.bat and JGuiGen.sh - These batch and shell files are placed in your $HOMEDIR.  In order to run JGuiGen with the MS Access database you must run with a regular java runtime engine.  These files call    java -jar <path >JGuiGen.jar.   If you edit the JGuiGenIni.xml file so that the JDBC Driver points at the MS Access database and run JGuiGen you will be using the MS Access database.  (Linux users - I haven't figured out the ODBC substitution to access the MS Access database yet so this will not work for you.) In either case the default database is Hypersonic (HSQL). This small SQL database is contained in a single jar file and is downloaded with JGuiGen.

JGuiGen Files

Property files (I18N) - in the /conf folder

•   JGuiGenModelRb.properties - the MODEL properties file
  
•   JguigenmodelRb_en.properties - MODEL - English
  
•   UserlogdataRb.properties - Userlogdata properties
  
•   UsersLogDataRb_en.properties - Userlogdata - English
  
•   UserlogdataRb_es.properties - UserLogdata - Spanish
  
•  JGuigen_I18N.properties - JGuiGen_I18N - English
  

Once the system has been downloaded, several files will be created and taken out of the jars.  If you use the DataDictionary --> Edit menu option and generate new files, they will exist on your system but you cannot run them from inside the JGuiGen application that Java Web Start downloads.  This application is compressed into a jar and the files you have created are not part of this jar.  Here are the steps to try out the files you create.

1. CD to your $HOMEDIR and run cd2JGuigen.  This will put you into the folder where Java Web Start installed JGuiGen.  
   
2. type unjar   - this will run a batch or shell file that removes the com\halepringle\standard\ classes from the jar.  On Linux use ./unjar.sh - you will need to run chmod a+x unjar.sh to make the script executable.
   
3. cd to com/halepringle/src and edit the abstractTableModel file you created.  It will need to have several lines deleted from the top.  These lines are instructions about modifying the Model class.  This has already been done for the userlogdata class.
   
4. cd back to the folder where JGuiGen.jar is and compile the abstractTableModel file - i.e. type javac com\halepringle\src\UserlogdataTableModel.java
   
5. Compile the Userlogdata.java file - type javac com\halepringle\src\Userlogdata.java
   
6. Run the Userlogdata class - type java com\halepringle\src\Userlogdata
       

Obviously if you changed the name of the UserLogData.java file, you will need to make the changes to com\halepringle\standard\Model.java, recompile it and use your file name in steps 3, 4 and 5 in place of UserLogData.

• Shell Scripts - Each of the batch files mentioned above have corresponding shell scripts.  You will probably have to do a "chmod a+x   xxx.sh" on each of them to make them executable.
  
• Special Directory - For the Java Web Start examples, the JGuiGen.Ini.xml file resides in the same folder with the jar files that Java Web Start downloads.   The more normal placement is in a special folder.  On Linux PC's this is a /usr/local/JGuiGen folder instead of a C:\JGuiGen folder used for windozs PC's.
  
• Java and Java Web Start.   When you download the newest versions of java for Linux, there is no real install so they are not accessible when you type "java" or "javaws."  One way to make java accessible to your whole system is to create a   java.sh file in /etc/profile.d directory.  Do this work as super-user and make sure the version number of Java that you are installing is used in place of the 1.1.1_02 used in the sample below..  Here is an example

           Warning: Be careful when editing /etc/profile.d/java.sh. 
             You may not be able to run   Linux afterwards.
             In this case, use the Red Hat Linux CD-ROM with boot: Linux rescue

	[root]# vi /etc/profile.d/java.sh

	export NPX_PLUGIN_PATH=/usr/java/j2sdk1.4.1_10/jre/plugin/i386/ns4/
	export PATH=$PATH:/usr/java/j2sdk1.4.1_10/bin/:/usr/java/j2skd1.r.1_02/jre/javaws

• Java Web Start - Note that the Howto's on the internet do not usually include the path to Java Web Start.  Also note that the version number is part of the path.  If you download a different version, you will need to adjust the path accordingly.   After you run ./java.sh, you should be able to type echo $PATH and see that java and java web start are in the path.  Typing java - version from any folder should run java and give you the version number of the jre being executed.
  
• Eclipse - I use Eclipse as an IDE.  Two things I noticed about the Linux version and your mileage may definitely vary here.  First the motif version of Eclipse seemed to work better on RedHat 9 than the GTK version.  Second, the default setting for my windoze version compiled java files when I saved them.  The default on my Linux box did not.  Go to the Widows Menu --> preferences --> Workbench and make sure the "Perform build automatically on resource modification" checkbox is checked.  The way I noticed this was that errors would not go away after I saved a file.  Even lines that were now comments continued to be listed as errors.  See the Getting Started section for jars that need to included in the Java Build Path.
  
• Test Directory - In order to use the toJar.sh and runJar.sh scripts you will need to create a "test" folder under your home folder.  I also used cvs to put the JGuiGen folder under my home folder.  These scripts expect to find it there.  Adjust them to suit your tastes.
  

• Numeric columns return a column width of -1.
  
• When you use a SQL CREATE statement to create a new table, the auto-increment field should just be called "serial."   For example CREATE table junk (junk_id serial, counter int4).   If you need to drop the table and create it again, you will either need to drop the automatically created sequence_id or change the word serial to something like dict_id int4 DEFAULT nextval('"data_dict_dict_id_seq"'::text) NOT NULL,      In the nextval function the "data_dict" portion is the table name, the "_dict_id" portion is the name of the auto-increment column and the "_seq" portion is a constant.
  
• The "nextval" is a function that you can use to capture the next available auto- increment number. You can then insert this number in the table manually and know that it will be unique. Since you know the number it can be returned to calling application.  This is done automatically in JGuiGen generated applications.
  
• Since you can insert any id number that is not already present, the JUnit TestCase can use a "testing id."  The default is ID = 1.  This can be changed in the JGuiGenIni.xml file.
  
• When editing the data in the data_dict table that describes another table, a "lastChangedDate" column must be created and identified if you want JGuiGen generated code to avoid multi-user conflicts.
  

1. Ccreate the three tables (data_dict, userlogdata and JGuiGen_I18N) using the mysql_data_dict.sql, mysql_userlogdata.sql and mysql_jguigen_i18n.sql files.  You should run something like the MySQL Command Center, open the SQL window and paste the CREATE statements into the window and execute.
   
   
2. Fill the tables with the three java files with the same names (plus the word "fill").   This means you will type    javac mysql_filldata_dict      and then      java mysql_filldata_dict  
   
   
3. Edit the JGuiGenIni.xml file and uncomment the section that describes accessing mySQL tables.  You will need to point to the location of your database engine and put the username and password for your system into this file.    You will also need to comment out whatever driver that XML is currently using..
   

• MySQL SQL commands default to case insensitive (unless variable is char BINARY)
  
• On-Line Reference - http://www.mysql.com/doc/en/Column_types.html
  
• List of MySQL gotchas - http://sql-info.de/mysql/gotchas.html#1_1
  
• Tablenames and paths default to the case sensitivity of your operating system. Windows = NO, *nix = YES
  
• In order to obtain the last inserted ID, the following function was used:
  int newId = (int) ((com.mysql.jdbc.Statement) stmt).getLastInsertID();
  
• Autoincrementing fiields are marked with the key word "auto-increment" in the SQL CREATE statement
  
• MySQL does not have a type BOOLEAN. It does, but the field is a tinyint and takes 1's and 0's as true and false. This required a lot of rewriting. It is interesting that in SQL CREATE statements the default values for the TINYINT columns are given in quotes e.g. active tinyint(1) NOT NULL default '0' Most other database system give integer default values without quotes.
  
• The SQL command like "Hale %" does not work on a char or var char since they are trimmed and hence there is never a space at the end of a column.
  
• The SQL command upper ('hale') does not work because of the space after the key word upper.

• MS Access has an auto-increment feature for an INTEGER column. It is called a COUNTER during CREATE and an AutoNumber column in query designer.
  
• MS Access does NOT allow us to force an insert even if the number you are trying to insert does not exist. This means that JGuiGen cannot use a "Testing id" when it inserts a row during the TestCase run.
  
• MS Access is case-INsensitive during queries and doesn't recognize upper() lower() and trim().
  
• JGuiGen has to read back the last record written after an INSERT to determine the id number that was auto-incremented. If the developer as included a "lastchangedate" field this is used to guarantee that the correct row is returned.
  
  Try bookmark code bookmark = rs.absolutePosition rs.Requery rs.absolutePosition = bookmark
• Text columns return a width of 1,000,000 plus.
  
• Column defaults are hard to add during CREATE statements. I had to go to the query designer and finish a lot of the conversion.
  
• Numeric fields must use the type DECIMAL if there are to be decimals in the database. Several other data types (numeric, float, double) have a decimal value, but this is just for reporting purposes. The DECIMAL data type has property called SCALE which save how many decimals should be saved in the table.
  
• Dates, Times and DateTimes all return SQL data types of 93 (TimeStamp). This required a change so that you could manually indicate that a column was to be a date only or a time only using the JGuiGen mask characteristic.
  
• Logical fields are bit   and return 1 or 0..  Must be loaded as "true" or "false"
  
• INTEGER return English SQL type of INTEGER (not int4 like PostgreSQL)
  
• CHAR and TEXT columns default to "Cannot have zero length".  I changed this.
  

XXIV. A few notes on JGuiGen as Demo Swing Application Code

One of the major reasons for building JGuiGen is to demonstrate and document one way to put Java code together into a full application. The help screens and documentation inside the code do a lot of this. In addition, one of the options when you generate code is to generate the code as an HTML file. When you do there are a series of links build that allow you to look at a list of areas inside the code and click on a link and jump straight to that section of the code. To demonstrate this, here are the 24 sections that JGuiGen has been divided into. There is a lot more to the code than these 24 sections, but they do separate the code into most of the major pieces that are requires to have a data entry screen with a JTable.

SECTION markers are placed in every class that JGuiGen generates. They mark the various sections in the code where various Swing activities take place.

• /** SECTION 1 - SETUP CONSTANTS and DECLARE VISUAL COMPONANTS */
  Example: Private String strVar;

• /** SECTION 2 - START APPLICATION - ADD ATTRIBUTES TO INSTANTIAED VARIABLE & VISUAL COMPONANTS*/
  The main constructor. This is where the program starts running. The MODEL class is instantiated and things like looking up codes obtained from the XML file by the model class or obtaining internationalized strings and assigning labels, hot keys, etc. This cannot be done until the code is running because we get internationalized data with a method instead of the java default which crashes the program if a prompt is missing from the properties files. Example: lblScreen_Title.setText(model.getRbString(UserlogdataRb,"SCREEN_TITLE","userlogdata") Note: This method also adds the prompt to the JGuiGen_I18N table if it is missing from the userlogdata.properties file.

• /** SECTION 3 - MORE SETUP OF COLUMN VARS - INCLUDING BUTTONS and LISTENERS */
  Set up listeners and add internationalized labels to buttons.

• /** SECTION 4 - SETUP POPUP MENU */
  

• /** SECTION 5 - MAIN DRIVER SECTION - DO THE WORK */
  Small section of code that actually calls for the BuildLayout, Get Data from a table, call for a JTable which uses the data and sets the screen visible.

• /** SECTION 6 - CHECKS ALL FIELDS FOR ERRORS */
  When anything happens that will exit the current record, the currently visible data is checked first for errors. This includes 1) Changing rows in the JTable, 2) Starting a Find, 3) Closing the Window, 4) Executing an ADD, 5) Duplicating the current record, 6) Going to the next record, 7) Going to the Previous Record, or 8) Executing a Save

• /** SECTION 7 - LIST Columns to call BuildLayout */
  Building the layout is done in its down class so that manually made changes will not be lost when the class is regenerated. It does mean that you must make additions or deletions manually. This requires that all of the fields to be used are passed into the BuildLayout() class.

• /** SECTION 8 - Commented Column for BuildLayout */
  This set of fields is commented out and goes into the BuildLayout class. It is used see what has changed in order to make manual changes to the BuildLayout class.

• /** SECTION 9 - ROWLAYOUT MANAGER - Build Rows */
  Java uses layout managers to determine where components go on a screen and how they handle screen resizing. JGuiGen uses a layout managers that deals one row at a time. All of the work takes place in a separate class (for example: UserLogDataBuildLayout()).

• /** SECTION 10- CHECK FOR CHANGED FIELDS - SETUP UPDATE and INSERT STRINGS */
  Just like the routine that checks for errors, this routine is fired off anytime a screen of data would be left without saving changes. It builds the SQL strings needed to insert a new record or to update an existing record. It notifies the user that changes will be lost if a SAVE is not done and tells the user which fields changed.
  
  Example:
           tmpVarName is a String.
           tmpString is a String
           Model.QuoteReplacer() is a method
             that makes single quotes into two single quotes for SQL
           newRowObj is a java bean with changed data
           vars_UserLogData is a String that contains a comma delimited list of variables to be
           ;    inserted in a SQL statement
           Values_UserLogData is a String that contains a comma delimited list of values to be used
           ;    in a SQL insert.
           rowObj is a Java Bean with the original data (before changes)
           change = in Integer which counts the number of changed records
           changeMsg is a String with a list of changed fields that a user can read
           update_UserLogData is a String containing Field=Value pairs for an SQL update call
      tmpVarName = "MiddleName";
  
      tmpString = model.QuoteReplacer(newRowObj.getMiddleName());
      vars_UserLogData = vars_UserLogData + "middleName, ";
    values_UserLogData = values_UserLogData + "'"+tmpString.trim()+"', ";>
      if (!(tmpString.trim().equals(model.QuoteReplacer(rowObj.getMiddleName()).trim()))){;
         changes++;
         changeMsg = changeMsg + "\n"+model.getRbString(UserLogDataRb,"change_description_MiddleName","UserLogData") + model.getRbString(UserLogDataRb," -Changed","UserLogData");
         update_UserLogData = update_UserLogData + "middleName = '"+tmpString.trim()+"', ";
      }
  

• /** SECTION 11- GET CHANGED DATA FROM VISUAL COMPONANTS & BUILD NEWROWOBJ */
  JGuiGen uses tow Java Beans. Once contains the data before changes and the other contains the data after changes. This routine pulls the data from all visual components and builds a bean after changes are made.
  

• /** SECTION 12- GETS DATA FROM DATABASE TABLE, FILLS VISUAL COMPONANTS and SETS UP JTABLE */
  main call to build the Java Bean before changes are made.

• /** SECTION 13- GET RESULT SET FROM DATABASE and SETUP JTABLE RENDERERS, SORTER, ETC */
  Actually fire off the SQL Query and set up the JTable that will hold the resultset.

• /** SECTION 14- GET DATA IN RESULTSET AND PUTS DATA INTO ROWOBJ */
  Routines that accessing one row of the result set and builds the Java Bean that holds the data as it looked before any changes are made.
  Example: utm = the instantiated tableModel class.
           idx_ is the row number
           utm.MIDDLENAME is a constant in the TableModel class with the column number
  

  tmpString = (String)(utm.getValueAt(idx_,utm.MIDDLENAME));
      if (tmpString == null) {tmpString = "";};
         tmpString = tmpString.trim();
      if (idx_ == 0){
         rowObj.setMiddleName(tmpString);
      }
  

• /** SECTION 15- TAKE DATA FROM ROWOBJ AND PLACE IN VISUAL COMPONANTS */
  Fill the visual components with new data.
  Example: txtMiddleName.setText(rowObj.getMiddleName());

• /** SECTION 16- UPDATE ONE ROW IN THE JTABLE WITH SAVED EDIT CHANGES */
  Change the values in the scrolling JTable to reflect saved changes in one row without having to re-query the whole results set. (Does not work with HSQL backend).
  Example: myModel = an Abstract Table model describing the JTable
           idx_ = index of the row in the JTable to update.
           UTM_MIDDLEWARE a constant in the UserLogData.Class that contains the column number that holds middlename in the JTable
           rowObj = a JavaBean containing the data.           myModel.setValueAt(rowObj.getMiddleName(),idx_,UTM_MIDDLENAME);

• /** SECTION 17- CLEAR VISUAL COMPONANTS - PREPARE FOR ADD NEW ROW TO TABLE */
  Example: txtMiddleName.setText(" ");

• /** SECTION 18- MISCELLANEOUS METHODS EG JTABLE MODEL & RENDERS, SCROLL SETTINS, SAVE SETTINS, PAINT VIUALS COMPONANTS TO PRINTER */
  Example: class MyTableModel extends AbstractTableModel {...
  

• /** SECTION 19- BTNSAVE - DO INSERT or CHECK THAT ROW HASN'T CHANGED DURING EDIT AND IF OKAY DO UPDATE */
  This section calls to see if any variables have bad values (Errors)
  It then checks for any fields that have changed
  The routines that checks for changes also builds the strings needed for both a SQL Insert and a SQL update
  If the ID number is currently zero the utm.insertTable() method is called to insert a new row in the database table.
  If the ID number is not zero the system checks to see if the row in the database table still has the same date/time stamp in it that it had when the edit started. If not the update is aborted and the user is notified that a multiuser error occurred
  If the date/time is the same then a utm.updateTable() call is made to update the data is the database table.
  

• /** SECTION 20- MAIN METHOD - USED TO RUN CLASS STANDALONE - RESTORES SCREEN SIZE & PLAF TO USER PREFERENCE */
  Almost all of the classes created by JGuiGen can be run in a standalone environment. This means that they need to have a MAIN() method in them.

• /** SECTION 21- HANDLE CLOSING THE WINDOW (Calling program then sets to NULL) */
  Closes SQL resultset and SQL statement in the tablemodel, hides the frame and disposes of the frame. The calling program then sets the instantiated frame to null which frees up all of the memory it used.
• /** SECTION 22- ABSTRACT TABLE MODEL IN A SEPARATE CLASS. */
  Each application JGuiGen Builds has a TableModel class that contains the calls that update and insert rows into the SQL backend.

• /** SECTION 23- JUNIT TESTS IN TWO SEPARATE CLASSES */
  JGuiGen generates JUnit test files. These will 1) open the application (2) clear the fields 3) insert unique data into each field 4) save the data to the SQL table 5) close the application 6) Reopen the application 7) Query the SQL table for the row just inserted 8) Test every field to see if the data obtained from the query matches the data inserted in step 4.

• /** SECTION 24- EXTRA CLASS TO RUN WHEN THE "EXTRA" BUTTON IS CLICKED. */
  Each application that JGuiGen generates has a button called EXTRA. (You change its name using the internationalization table). This comes with a dummy program that just pops up a message. You can replace this with your own code to do something real with your data.

  Example that shows the various places a single JTextField (bounded) appears in the code

• Bounded Text Field Example - declare the field
  
• Bounded Text Field Example - set ToolTips and Assistive Technology
  
• Bounded Text Field Example - add to layout manager
  
• Bounded Text Field Example - Test if data changed, set up update & insert strings
  
• Bounded Text Field Example - Fill component from resultSet
  
• Bounded Text Field Example - Reset hld value to value in component after save
  

  Example that show the various things done to the JFrame that holds this screen.

• JxFrame Example - Includes for borders
  
• JxFrame Example - JxFrame Declaration & Setting Title
  
• JxFrame Example - Declaration of border variables
  
• JxFrame Example - JxFrame Declaration for inside class
  
• JxFrame Example - Pass JxFrame into class
  
• JxFrame Example - Set Passed in JxFrame to a local field in class
  
• JxFrame Example - Replace coffee cup icon on frame
  
• JxFrame Example - setting the JxFrame border
  
• JxFrame Example - Let user close the frame
  
• JxFrame Example - JxFrame Windows Listener in Class - check if leaving class is okay
  
• JxFrame Example - Example of passing frame into a JDialog
  
• JxFrame Example - JxFrame Setup - size and location on screen
  
• JxFrame Example - JxFrame Window Listener in main (set to null when done)
  

XXV. A list of Tasks that programmers need to do in a Swing Application

There are literally hundreds of things that a modern application is expected to do and Look and Feels that users expect from modern application. Here a some of those items and where you can see an example in JGuiGen generated code.

-more to come-