PC World Komputer 1998 October A/Pcwk10a98.iso/Inprise/TRIAL/JBUILDER/JSAMPLES.Z/AppDataModule.java

Text File | 1998-05-08 | 111KB | 2,314 lines

/*
 * Copyright (c) 1997-1998 Borland International, Inc. All Rights Reserved.
 *
 * This SOURCE CODE FILE, which has been provided by Borland as part
 * of a Borland product for use ONLY by licensed users of the product,
 * includes CONFIDENTIAL and PROPRIETARY information of Borland.
 *
 * USE OF THIS SOFTWARE IS GOVERNED BY THE TERMS AND CONDITIONS
 * OF THE LICENSE STATEMENT AND LIMITED WARRANTY FURNISHED WITH
 * THE PRODUCT.
 *
 * IN PARTICULAR, YOU WILL INDEMNIFY AND HOLD BORLAND, ITS RELATED
 * COMPANIES AND ITS SUPPLIERS, HARMLESS FROM AND AGAINST ANY CLAIMS
 * OR LIABILITIES ARISING OUT OF THE USE, REPRODUCTION, OR DISTRIBUTION
 * OF YOUR PROGRAMS, INCLUDING ANY CLAIMS OR LIABILITIES ARISING OUT OF
 * OR RESULTING FROM THE USE, MODIFICATION, OR DISTRIBUTION OF PROGRAMS
 * OR FILES CREATED FROM, BASED ON, AND/OR DERIVED FROM THIS SOURCE
 * CODE FILE.
 */

package borland.samples.intl.application;

import java.awt.*;
import java.awt.event.*;
import java.io.*;
import java.sql.*;
import java.text.*;
import java.util.*;
import borland.jbcl.layout.*;
import borland.jbcl.control.*;
import borland.jbcl.model.*;
import borland.jbcl.dataset.*;
import borland.sql.dataset.*;
import borland.jbcl.util.*;
import borland.jbcl.view.*;

import com.objectspace.jgl.*;

import borland.samples.intl.beans.*;
import borland.samples.intl.beans.event.*;

import borland.samples.intl.application.resources.TextRes_en;

/**
 * The application's data module, AppDataModule, like most data
 * modules, can be conceptually divided into the following four parts:
 *<p>
 *  - JBCL data access components
 *  - public DataSet accessor methods for use by data-aware components
 *  - data module state manipulation logic
 *  - application and business logic
 *<p>
 * The first part consists of JBCL data access components (for
 * example, Database, QueryDataSet, Column, etc.) which were
 * automatically added to the code and customized using the UI
 * Designer.  These components are declared as instance variables
 * near the top of the class definition, and are customized within
 * the jbInit() method.  Some properties and custom components that
 * could not be configured using the UI Designer were done in the
 * AppDataModule constructor following the call to jbInit().
 *<p>
 * The second part of the AppDataModule consists of public DataSet
 * accessor methods, such as getCustomerDataSet(), which were
 * generated automatically by the UI Designer as we dropped datasets
 * into the data module.  Clients of the data module use these
 * accessor methods to obtain references to DataSet components
 * customized within the data module.  For example, the OrderFrame frame
 * uses a data-aware GridControl component to display line items for
 * an order.  In order to display the line item data in the grid, we
 * have to assign the OrderLineItemDataSet dataset, created in the
 * data module, to be the GridControl's dataset property.  After
 * compiling our data module and declaring an instance of it in
 * OrderFrame, we can use the UI Designer to assign datasets
 * configured in our data module to data-aware components in our
 * frame.
 *<p>
 * The third part of the AppDataModule consists of the methods by
 * which the application's GUI components manipulate the state of the
 * data module.  For example, when a user presses the "Add to Order"
 * button of the ProductFrame, the button's actionPerformed handler
 * invokes the AppDataModule component's addProductToOrderLineItem()
 * method.  In response, the data module determines the product
 * currently being viewed in the ProductFrame (the current row in the
 * ProductsDataSet), and adds a new row with the appropriate
 * information to the OrderLineItemDataSet.  Because the dataSet
 * property of the GridControl in the OrderFrame is assigned to the
 * OrderLineItemDataSet, the new row added to the OrderLineItemDataSet
 * by the data module automatically becomes visible in the GridControl
 * in the OrderFrame.  While it is possible to obtain references to
 * datasets via the data module's dataset accessor methods and
 * manipulate them directly outside the data module, maintaining a
 * separation of the application's GUI and internal logic is a good
 * programming practice.  Doing so helps to isolate bugs (because
 * datasets will only be manipulated within the data module), and
 * increases the possibility of reuse of an application's components.
 * In this sample, for example, the various GUI frames are totally
 * independent of the data module, dependent only upon the data
 * module to implement certain order entry application behaviors
 * such as moving rows from one dataset to another, or validating
 * dataset data.  Thus we are free to replace the existing UI frames
 * with any other frames or reuse the UI frames with another
 * data module with little or no modification (and usually this
 * modification can be done strictly using the UI designer).
 *<p>
 * The fourth part of the AppDataModule consists of methods which
 * define the application's logic and business rules.  In general,
 * application logic is implemented within event handlers that are
 * activated in response to DataSet events.  For example, when a new
 * row is inserted into the OrderDataSet, it should be given a unique
 * order number.  To implement this application logic, we first used
 * the UI Designer to create a row 'inserted' event handler for the
 * OrderDataSet.  (When AppDataModule.java is open in the UI Designer,
 * select OrderDataSet in the Component Tree, select the Events tab of
 * the Inspector, and enter an event handler name for the OrderDataSet
 * class's 'inserted' event property).  Inside the event handler code,
 * we assign a unique value to the order_no column of the newly
 * inserted row.
 *<p>
 * Business rules are usually defined by setting validation
 * constraints on columns of a DataSet.  For example, to specify that
 * the quantity of an item ordered be greater than 0, we set the min
 * property of the quantity column of the OrderLineItemDataSet to the
 * value '1'.  Doing so prevents a row from being posted if the
 * quantity is not at least 1.
 *<p>
 * To allow AppDataModule to use either a JDBC database
 * or a text data file as its data provider, we took advantage of the
 * fact that a QueryDataSet also has a dataFile property.  Using the
 * Designer, we defined both a TextDataFile and query for each
 * QueryDataSet, and set the executeOnOpen property of each query to
 * be false.  Doing so allows data to be provided from each
 * QueryDataSet component's TextDataFile data source by default.  In order to
 * use a JDBC database as the provider, we provide a static method
 * (setJDBCDataSource) which sets JDBC connection information.  At
 * runtime, if JDBC connection information has been set before the
 * AppDataModule is instantiated, we provide data for each
 * QueryDataSet by executing the query instead of loading data from a
 * TextDataFile.
 */
public class AppDataModule implements DataModule, LocaleChangeListener {
  /**
   * Single instance of the AppDataModule used by the application.
   * See getDataModule() for more info.
   */
  private static AppDataModule appDataModule = null;

  /**
   * Reference to the TextRes resource bundle which contains localized
   * resources for the GUI-independent side of the application.  The
   * 'resource strings' wizard automatically inserts the code required
   * to instantiate the resource bundle.  Once declared, we can
   * then assign the bundle to resourceable objects (e.g., the
   * descriptionLookupItemPainter of the orderLineItemDataSet)
   * via the UI Designer.  See
   * borland\samples\intl\application\resources\TextRes.java for more
   * information.
   */
  ResourceBundle textRes = java.util.ResourceBundle.getBundle("borland.samples.intl.application.resources.TextRes",
                                                              LocaleChangeManager.getLocale());

  /**
   * Determines whether the application's data sources will be all text file based
   * or all JDBC database based.  It is automatically set to true
   * if a JDBC data source is specified by a call to AppDataModule's
   * static setJDBCDataSource() method before is
   * instantiated.
   */
  private static boolean useQueryDataSet = false;

  /**
   * Determines whether the customerNoDataSet and orderNoDataSet
   * DataSets should be save back to their corresponding
   * TextDataFiles.  If the user doesn't open the order form,
   * these DataSets are not opened.  Saving them without opening
   * them will save an empty DataSet, erasing their files.
   */
  private boolean saveCustomerNoDataFile = false;
  private boolean saveOrderNoDataFile = false;

  /**
   * Contains the URL for a JDBC database connection.  Set via the
   * static setJDBCDataSource() method.
   */
  private static String jdbcURL;

  /**
   * Contains the user name to a JDBC database connection.  Set via
   * the static setJDBCDataSource() method.
   */
  private static String jdbcUser;

  /**
   * Contains the password to a JDBC database connection.  Set via
   * the static setJDBCDataSource() method.
   */
  private static String jdbcPassword;

  /**
   * Contains the driver name for a JDBC database connection.  Set
   * via the static setJDBCDataSource() method.
   */
  private static String jdbcDriver;

  /**
   * Public constant which may be passed as the product filtering
   * category argument of filterProducts() to signify that no products
   * should be filtered out of ProductsDataSet.
   */
  public static final int NO_PRODUCT_FILTER = -1;

  /**
   * Contains the value used to decide which rows to filter in/out of
   * the ProductsDataSet DataSet.  See the comments for
   * productDataSet_filterRow() for more information.
   */
  private int productFilteringCategory = NO_PRODUCT_FILTER;

  /**
   * Constant used to signify that no customers should be filtered
   * into customerDataSet.
   */
  private static int INVALID_CUSTOMER = -1;

  /**
   * Holds the customer number value of the customer for the current
   * order.
   */
  private static int queryCustomerNo = INVALID_CUSTOMER;

  /**
   * Indicates whether or not a new row has already been inserted into
   * OrderDataSet and CustomerDataSet in preparation for a new order
   * entry.
   */
  protected boolean enteringOrder = false;

  /**
   * Set true by localeChanged() when in the process of switching
   * to a new locale.  Since switching locales requires us to
   * save and restore the pending order, dataset event listeners
   * check this to see whether or not to ignore their events for
   * the duration of the locale change.
   */
  protected boolean localeChanging = false;

  /**
   * Custom (model-view) item editor for the 'quantity' column of the
   * orderLineItemDataSet DataSet.  See
   * borland/samples/intl/beans/IntegerSpinEditor.java for more info.
   */
  IntegerSpinItemEditor quantityItemEditor = new IntegerSpinItemEditor();

  /**
   * Custom (model-view) item painter for the calculated 'description'
   * lookup column of the orderLineItemDataSet DataSet.  See
   * borland/samples/intl/beans/ResourceableItemPainter.java for
   * more info.
   */
  ResourceableItemPainter descriptionLookupItemPainter = new ResourceableItemPainter();

  // The following AnnotatedEmptyItemPainters are custom (model-view)
  // item painters used to put the 'required' message in empty,
  // required columns in the orderDataSet and customerDataSet data sets.
  // The following item painters were dropped into the data module
  // and assigned to be item painters for columns using the UI Designer.
  // The 'required' message was set as the displayString property of
  // each painter via the designer.
  // See borland/samples/intl/beans/AnnotatedEmptyItemPainter.java for
  // more info.
  AnnotatedEmptyItemPainter lastNameRequiredPainter = new AnnotatedEmptyItemPainter();
  AnnotatedEmptyItemPainter firstNameRequiredPainter = new AnnotatedEmptyItemPainter();
  AnnotatedEmptyItemPainter address1RequiredPainter = new AnnotatedEmptyItemPainter();
  AnnotatedEmptyItemPainter cityRequiredPainter = new AnnotatedEmptyItemPainter();
  AnnotatedEmptyItemPainter provinceRequiredPainter = new AnnotatedEmptyItemPainter();
  AnnotatedEmptyItemPainter paymentMethodRequiredPainter = new AnnotatedEmptyItemPainter();
  AnnotatedEmptyItemPainter creditCardNoRequiredPainter = new AnnotatedEmptyItemPainter();
  AnnotatedEmptyItemPainter countryRequiredPainter = new AnnotatedEmptyItemPainter();

  /**
   * Custom (model-view) item editors and painters for the 'size' and 'color'
   * columns of the orderLineItemDataSet DataSet.  See
   * borland/samples/intl/beans/ResourceablePickListItemEditor.java and
   * borland/samples/intl/beans/ResourceableItemPainter.java for
   * more info.
   */
  ResourceableItemPainter orderLineItemSizeItemPainter = new ResourceableItemPainter();
  ResourceableItemPainter orderLineItemColorItemPainter = new ResourceableItemPainter();
  ResourceablePickListItemEditor orderLineItemSizeItemEditor = new ResourceablePickListItemEditor();
  ResourceablePickListItemEditor orderLineItemColorItemEditor = new ResourceablePickListItemEditor();

  /**
   * creditCardNoItemEditor is set as the ItemEditor property of the
   * creditCardNoColumn of the orderDataSet DataSet.  It is used to
   * dynamically set the edit mask for entry of a credit card number.
   * When the value of the credit card name column changes, its column
   * value change listener updates creditCardNoItemEditor's edit mask.
   */
  MaskableTextItemEditor creditCardNoItemEditor = new MaskableTextItemEditor();

  // The following components were added to the data module
  // automatically by the UI Designer when we dropped data access
  // components into the data module.
  Database database = new Database();
  TextDataFile customerDataFile = new TextDataFile();

  /**
   * DataSet used to access customer data from either customerDataFile
   * or a query on the Customers table.  It is row filtered to only
   * include the single customer row which should be visible/editable
   * at any time.
   */
  QueryDataSet customerDataSet = new QueryDataSet();
  Column lastNameColumn = new Column();
  Column middleNameColumn = new Column();
  Column firstNameColumn = new Column();
  Column address1Column = new Column();
  Column address2Column = new Column();
  Column customerNoColumn = new Column();
  Column cityColumn = new Column();
  Column provinceColumn = new Column();
  Column countryColumn = new Column();
  Column emailColumn = new Column();
  Column phoneColumn = new Column();
  Column faxColumn = new Column();
  Column passwordColumn = new Column();
  Column postalCodeColumn = new Column();

  /**
   * DataSetView which uses customerDataSet as its StorageDataSet.
   * Unlike customerDataSet, it is not restricted to viewing only a
   * single row of the customerDataSet, and therefore is used in
   * CustomerLookupDialog.java as the DataSet of a GridControl which
   * shows the entire list of customers.
   */
  DataSetView customerDataSetView = new DataSetView();

  TextDataFile exchangeRateDataFile = new TextDataFile();

  QueryDataSet exchangeRateDataSet = new QueryDataSet();
  Column exchangeRateColumn = new Column();

  TextDataFile paymentMethodDataFile = new TextDataFile();

  QueryDataSet paymentMethodDataSet = new QueryDataSet();

  TextDataFile orderDataFile = new TextDataFile();

  QueryDataSet orderDataSet = new QueryDataSet();
  Column orderDateColumn = new Column();
  Column paymentMethodColumn = new Column();
  Column creditCardNoColumn = new Column();
  Column cardExpirationDateColumn = new Column();

  TextDataFile orderLineItemDataFile = new TextDataFile();

  QueryDataSet orderLineItemDataSet = new QueryDataSet();
  Column skuColumn = new Column();
  Column quantityColumn = new Column();
  Column sizeColumn = new Column();
  Column colorColumn = new Column();
  Column descriptionLookupColumn = new Column();
  Column unitPriceLineItemColumn = new Column();
  Column extdPriceColumn = new Column();
  Column localExtdPriceColumn = new Column();
  Column subtotalColumn = new Column();
  Column localSubtotalColumn = new Column();
  Column shippingColumn = new Column();
  Column localShippingColumn = new Column();
  Column taxColumn = new Column();
  Column localTaxColumn = new Column();
  Column totalColumn = new Column();
  Column localTotalColumn = new Column();

  TextDataFile productsDataFile = new TextDataFile();

  QueryDataSet productsDataSet = new QueryDataSet();
  Column descriptionColumn = new Column();
  Column unitPriceProductsColumn = new Column();

  TextDataFile productColorsDataFile = new TextDataFile();

  QueryDataSet productColorsDataSet = new QueryDataSet();

  TextDataFile productSizesDataFile = new TextDataFile();

  QueryDataSet productSizesDataSet = new QueryDataSet();

  TextDataFile customerNoDataFile = new TextDataFile();

  QueryDataSet customerNoDataSet = new QueryDataSet();

  TextDataFile orderNoDataFile = new TextDataFile();

  QueryDataSet orderNoDataSet = new QueryDataSet();
  Column imageColumn = new Column();
  Column orderNoColumn = new Column();
  Column orderLineItemNoColumn = new Column();
  Column totalQuantityColumn = new Column();

  /**
   * Initializes data-access components of the data module.
   * Components configurable via the UI Designer are set within jbInit(),
   * all others are set in the code following the call to jbInit().
   */
  public AppDataModule() {
    try {
      jbInit();

      // The remaining code configures column properties and
      // initializes DataSets in ways which could not be done using
      // the UI Designer.

      // If setJDBCDataSource() was called prior to initial
      // instantiation of the AppDataModule, useQueryDataSet will have
      // the value 'true' and we will try to use its passed parameters
      // to load data from a JDBC source.

      if (useQueryDataSet) {
        // Explicitly load the JDBC Driver
        Class.forName(jdbcDriver);
        // Don't pass a driver to ConnectionDescriptor because it will lookup
        // the system classpath property (causing an applet security violation) to
        // locate the driver.
        database.setConnection(new borland.sql.dataset.ConnectionDescriptor(jdbcURL, jdbcUser, jdbcPassword, false, ""));
      }

      // Set aggregation descriptors for aggregated columns (columns
      // for which the calcType property is CalcType.AGGREGATE).
      // The first argument to the AggDescriptor is the list
      // of columns on which to group.  Since we want to compute the
      // sum of values for rows in the orderLineItemDataSet (the
      // line item rows for each order), we specify the linking
      // column 'order_no' as the grouping column.
      // The following AggDescriptor specifies that
      // SumAggOperator() should be applied to the 'extd_price' value
      // in all rows of the orderLineItemDataSet grouped by 'order_no', and
      // the aggregated result assigned to subtotal.
      // In JBuilder 2.0 or later, this property can be set from within the UI designer.
      subtotalColumn.setAgg(new AggDescriptor(new String [] { "order_no" }, "extd_price", new SumAggOperator()));

      // The following AggDescriptor specifies that the
      // SumAggOperator() should be applied to the 'quantity' value in
      // all rows of the orderLineItemDataSet grouped by 'order_no' and the
      // aggregated result assigned to the totalQuantityColumn.
      // In JBuilder 2.0 or later, this property can be set from within the UI designer.
      totalQuantityColumn.setAgg(new AggDescriptor(new String [] { "order_no" }, "quantity", new SumAggOperator()));

      // Set aggregation descriptors for columns whose values
      // are based on calculations performed on
      // aggregated values.  The calcType property of a 'custom' aggregated
      // column must be set to CalcType.AGGREGATE.  An AggDescriptor
      // for a calculated aggregated column differs from an
      // AggDescriptor for a regular aggregated column in that an
      // aggregate operator and aggregate value column name are both
      // set to 'null'.  When a custom aggregate value must be
      // recalculated, the CalcAggFieldsListener registered with
      // the data set is automatically invoked.
      // In JBuilder 2.0 or later, these properties can be set from within the UI designer.
      localSubtotalColumn.setAgg(new AggDescriptor(new String [] { "order_no" }, null, null));
      shippingColumn.setAgg(new AggDescriptor(new String [] { "order_no" }, null, null));
      localShippingColumn.setAgg(new AggDescriptor(new String [] { "order_no" }, null, null));
      taxColumn.setAgg(new AggDescriptor(new String [] { "order_no" }, null, null));
      localTaxColumn.setAgg(new AggDescriptor(new String [] { "order_no" }, null, null));
      totalColumn.setAgg(new AggDescriptor(new String [] { "order_no" }, null, null));
      localTotalColumn.setAgg(new AggDescriptor(new String [] { "order_no" }, null, null));

      // Set localized display masks for date and currency columns of
      // the orderDataSet for the default locale.  If a locale change
      // occurs, code within localeChanged() will reset the masks for
      // the new locale.
      orderDateColumn.setDisplayMask(((SimpleDateFormat) SimpleDateFormat.getDateInstance(DateFormat.DEFAULT, LocaleChangeManager.getLocale())).toPattern());

      // Temporary workaround for bug in JDK 1.1.6, namely that currency patterns for some
      // locales throw exceptions when analyzed by java.text.DecimalFormat().
      if (LocaleChangeManager.getLocale().equals(Locale.ITALY) ||
          LocaleChangeManager.getLocale().getCountry().equals("CH")) {
        localExtdPriceColumn.setDisplayMask(null);
        localSubtotalColumn.setDisplayMask(null);
        localShippingColumn.setDisplayMask(null);
        localTaxColumn.setDisplayMask(null);
        localTotalColumn.setDisplayMask(null);
      } else {
        localExtdPriceColumn.setDisplayMask(((DecimalFormat) DecimalFormat.getCurrencyInstance(LocaleChangeManager.getLocale())).toPattern());
        localSubtotalColumn.setDisplayMask(((DecimalFormat) DecimalFormat.getCurrencyInstance(LocaleChangeManager.getLocale())).toPattern());
        localShippingColumn.setDisplayMask(((DecimalFormat) DecimalFormat.getCurrencyInstance(LocaleChangeManager.getLocale())).toPattern());
        localTaxColumn.setDisplayMask(((DecimalFormat) DecimalFormat.getCurrencyInstance(LocaleChangeManager.getLocale())).toPattern());
        localTotalColumn.setDisplayMask(((DecimalFormat) DecimalFormat.getCurrencyInstance(LocaleChangeManager.getLocale())).toPattern());
      }

      // Provide an edit mask which allows the user to only enter the
      // month and year for a credit card's expiration date.  When
      // using such an edit mask, the day is automatically set to the
      // first of the month.  Thus we set the minimum date for the
      // credit card expiration column to be the last day of the
      // previous month.
      // Note that we could have set the minimum value via the
      // designer as a string.  However, we would have to provide
      // the string in the proper format for the runtime
      // locale (which could vary).  A variant allows us to set the
      // minimum value independently of our runtime locale.
      Variant variant = new Variant();
      Calendar calendar = new GregorianCalendar();
      variant.setTimestamp(new java.sql.Timestamp(calendar.get(Calendar.YEAR)-1900, calendar.get(Calendar.MONTH), 1, 0, 0, 0, 0));
      cardExpirationDateColumn.setMinValue(variant);

      // Adds a row filter listener to the picklist item editors used to
      // show a list of sizes and colors for a product in orderLineItemDataSet.
      // We use these filters to 'filter in' only the sizes or colors
      // appropriate for the current product line item.
      orderLineItemSizeItemEditor.addRowFilterListener(new AppDataModule_orderLineItemSizeItemEditor_rowFilterAdapter(this));
      orderLineItemColorItemEditor.addRowFilterListener(new AppDataModule_orderLineItemColorItemEditor_rowFilterAdapter(this));

      if (useQueryDataSet) {
        // The following query is used for two different purposes.
        // First, we pass it a non-existent customer_no to provide an empty set of order
        // rows into orderDataSet and orderLineItemDataSet.  We then insert new
        // rows into the data sets.  By doing the query, even though it
        // retrieves no rows, we load the metadata info into the DataSet, so that we
        // can resolve it back to the data source using DataSet.saveChanges(DataSet).
        // Second, this query is also used to select all of a customer's orders for
        // browsing.  Since we don't allow a customer to make any changes to existing
        // orders, resolving is not necessary in this case.
        ParameterRow orderDataSetQueryParameters = new ParameterRow();
        orderDataSetQueryParameters.addColumn("customer_no", Variant.INT);
        orderDataSetQueryParameters.setInt("customer_no", queryCustomerNo);
        orderDataSet.setQuery(new borland.sql.dataset.QueryDescriptor(database, "select * from orders where customer_no = :customer_no", orderDataSetQueryParameters, false, Load.ALL));
      } else {

        // When using a QueryDataSet, we simply execute a query to provide order rows
        // into the orderDataSet when browsing a customer's previous orders.
        // But for a text data file source, we always have all order rows in the
        // data set.  To restrict the user to navigating only a particular customer's
        // order data, we add a row filter and restrict navigation to order rows for
        // the current customer (stored in the queryCustomerNo variable).
        orderDataSet.addRowFilterListener(new AppDataModule_orderDataSet_rowFilterAdapter(this));
      }

      // Provide data set data from the appropriate data sources.
      if (useQueryDataSet) {
        // If we're using QueryDataSets, we first need to set the LoadOnOpen property of each
        // DataSet's corresponding TextDataFile to false, so that opening the DataSet will
        // not load data from the TextDataFile.  Then in order to provide data from the
        // JDBC data provider, we execute the query.
        customerDataFile.setLoadOnOpen(false);
        customerDataSet.executeQuery();
        customerDataSet.open();
        exchangeRateDataFile.setLoadOnOpen(false);
        exchangeRateDataSet.executeQuery();
        exchangeRateDataSet.open();
        paymentMethodDataFile.setLoadOnOpen(false);
        paymentMethodDataSet.executeQuery();
        paymentMethodDataSet.open();
        orderDataFile.setLoadOnOpen(false);
        orderDataSet.executeQuery();
        orderDataSet.open();
        orderLineItemDataFile.setLoadOnOpen(false);
        orderLineItemDataSet.executeQuery();
        orderLineItemDataSet.open();
        productsDataFile.setLoadOnOpen(false);
        productsDataSet.executeQuery();
        productsDataSet.open();
        productColorsDataFile.setLoadOnOpen(false);
        productColorsDataSet.executeQuery();
        productColorsDataSet.open();
        productSizesDataFile.setLoadOnOpen(false);
        productSizesDataSet.executeQuery();
        productSizesDataSet.open();
        customerNoDataFile.setLoadOnOpen(false);
        orderNoDataFile.setLoadOnOpen(false);
      } else {
        // Open the DataSets we plan to use in subsequent operations.
        // When using a TextDataFile, the default value for the 'loadOnOpen'
        // property is true, so opening the data set will automatically load
        // data from the text file.
        customerDataSet.open();
        exchangeRateDataSet.open();
        paymentMethodDataSet.open();
        orderDataSet.open();
        orderLineItemDataSet.open();
        productsDataSet.open();
        productColorsDataSet.open();
        productSizesDataSet.open();
      }

      customerDataSetView.open();

      // Now that the paymentMethodDataSet is open, set the default
      // credit card name and corresponding card no digit edit mask
      // from the paymentMethodDataSet.
      creditCardNoItemEditor.setEditMask(paymentMethodDataSet.getString("digit_pattern"), Variant.STRING, LocaleChangeManager.getLocale());


      // Because descriptions for products in the productsDataSet are localized,
      // we provide a value for the productDataSet's 'description' column by
      // using a product's 'sku' number as its lookup key in a resource bundle.
      // We then add that value into the 'description' column.
      // When using a TextDataFile data source, we also need to explicitly
      // fill the 'image' column with image data, since binary data cannot be
      // stored in a text file.
      int sku;
      String imageFileName;
      String localizedDescription;

      // Iterate over all rows in productsDataSet
      productsDataSet.first();
      while (productsDataSet.inBounds()) {
        sku = productsDataSet.getInt("sku");

        // Add localized description data
        localizedDescription = textRes.getString("" + sku);
        productsDataSet.setString("description", localizedDescription);

        // Since we can't save binary image data within a text data
        // file, when using a text data file as our data source we
        // need to import the image data separately.
        if (!useQueryDataSet) {
          imageFileName = "data\\" + sku + ".gif";
          BufferedInputStream bufferedInputStream =
            new BufferedInputStream(this.getClass().getResourceAsStream(imageFileName));
          bufferedInputStream.mark(40000);
          productsDataSet.setInputStream("image", bufferedInputStream);
        }
        productsDataSet.next();
      }
      // Since productsDataSet.next() will fail on the last row
      // (allowing us to exit the loop), we need to explicitly post
      // changes which would have been posted had it been successful.
      productsDataSet.post();
      productsDataSet.first();

      // Load the current US dollar exchange rate our of exchangeRateDataSet
      readExchangeRate();

      // Register ourselves as a locale change listener with the system locale change manager
      LocaleChangeManager.getLocaleChangeManager().addLocaleChangeListener(this);

      // Install a custom DataSetException error handler to display localized messages
      DataSetException.addExceptionListener(new ResourcedDataSetExceptionHandler(this));
    }
    catch (Exception e) {
      borland.jbcl.util.Diagnostic.printStackTrace(e);
    }
  }

  /**
   * Contains components customized using the UI Designer.
   */
  void jbInit() throws Exception{
    lastNameColumn.setCaption(textRes.getString("last_name"));
    lastNameColumn.setColumnName("last_name");
    lastNameColumn.setDataType(borland.jbcl.util.Variant.STRING);
    lastNameColumn.setEditMask("cccccccccccccccccccccccccccccc");
    lastNameColumn.setItemPainter(lastNameRequiredPainter);
    lastNameColumn.setRequired(true);
    middleNameColumn.setCaption(textRes.getString("middle_name"));
    middleNameColumn.setColumnName("middle_name");
    middleNameColumn.setDataType(borland.jbcl.util.Variant.STRING);
    middleNameColumn.setEditMask("cccccccccccccccccccccccccccccc");
    firstNameColumn.setCaption(textRes.getString("first_name"));
    firstNameColumn.setColumnName("first_name");
    firstNameColumn.setDataType(borland.jbcl.util.Variant.STRING);
    firstNameColumn.setEditMask("cccccccccccccccccccccccccccccc");
    firstNameColumn.setItemPainter(firstNameRequiredPainter);
    firstNameColumn.setRequired(true);
    address1Column.setCaption(textRes.getString("address1"));
    address1Column.setColumnName("address1");
    address1Column.setDataType(borland.jbcl.util.Variant.STRING);
    address1Column.setEditMask("cccccccccccccccccccccccccccccccccccccccccccccccccc");
    address1Column.setVisible(borland.jbcl.util.TriState.NO);
    address1Column.setItemPainter(address1RequiredPainter);
    address1Column.setRequired(true);
    address2Column.setCaption(textRes.getString("address2"));
    address2Column.setColumnName("address2");
    address2Column.setDataType(borland.jbcl.util.Variant.STRING);
    address2Column.setEditMask("cccccccccccccccccccccccccccccccccccccccccccccccccc");
    address2Column.setVisible(borland.jbcl.util.TriState.NO);
    customerNoColumn.setColumnName("customer_no");
    customerNoColumn.setDataType(borland.jbcl.util.Variant.INT);
    customerNoColumn.setVisible(borland.jbcl.util.TriState.NO);
    cityColumn.setCaption(textRes.getString("city"));
    cityColumn.setColumnName("city");
    cityColumn.setDataType(borland.jbcl.util.Variant.STRING);
    cityColumn.setEditMask("cccccccccccccccccccccccccccccc");
    cityColumn.setItemPainter(cityRequiredPainter);
    cityColumn.setRequired(true);
    provinceColumn.setCaption(textRes.getString("province"));
    provinceColumn.setColumnName("province");
    provinceColumn.setDataType(borland.jbcl.util.Variant.STRING);
    provinceColumn.setEditMask(textRes.getString("province_editmask"));
    provinceColumn.setItemPainter(provinceRequiredPainter);
    countryColumn.setCaption(textRes.getString("country"));
    countryColumn.setColumnName("country");
    countryColumn.setDataType(borland.jbcl.util.Variant.STRING);
    countryColumn.setEditMask("cccccccccccccccccccccccccccccc");
    countryColumn.setItemPainter(countryRequiredPainter);
    countryColumn.setRequired(true);
    emailColumn.setCaption(textRes.getString("e_mail"));
    emailColumn.setColumnName("e_mail");
    emailColumn.setDataType(borland.jbcl.util.Variant.STRING);
    emailColumn.setEditMask("cccccccccccccccccccccccccccccccccccccccccccccccccc");
    emailColumn.setVisible(borland.jbcl.util.TriState.NO);
    phoneColumn.setCaption(textRes.getString("phone"));
    phoneColumn.setColumnName("phone");
    phoneColumn.setDataType(borland.jbcl.util.Variant.STRING);
    phoneColumn.setEditMask(textRes.getString("phone_editmask"));
    phoneColumn.setVisible(borland.jbcl.util.TriState.NO);
    faxColumn.setCaption(textRes.getString("fax"));
    faxColumn.setColumnName("fax");
    faxColumn.setDataType(borland.jbcl.util.Variant.STRING);
    faxColumn.setEditMask(textRes.getString("phone_editmask"));
    faxColumn.setVisible(borland.jbcl.util.TriState.NO);
    passwordColumn.setColumnName("mangled_password");
    passwordColumn.setDataType(borland.jbcl.util.Variant.STRING);
    passwordColumn.setVisible(borland.jbcl.util.TriState.NO);
    postalCodeColumn.setCaption(textRes.getString("postal_code"));
    postalCodeColumn.setColumnName("postal_code");
    postalCodeColumn.setDataType(borland.jbcl.util.Variant.STRING);
    postalCodeColumn.setEditMask(textRes.getString("postal_code_editmask"));
    customerDataSetView.setStorageDataSet(customerDataSet);
//  In JBuilder 2.0, the following path was changed to a relative path rather than
//  an absolute one, so that it would not be necessary to replace 'JBuilder2' with
//  the actual JBuilder 2.0 installation directory in order to simply run the sample.
//  When this data module is designed in the designer however, the following text
//  file cannot be found because the relative path is incorrect relative to the
//  location of the data module.  In order to design this data module in the UI designer with all
//  columns (not only the persistent ones) from the text data files, uncomment and
//  edit, if necessary, the line with the absolute path, and comment out the
//  line with the relative path.  Repeat the process for all other similarly
//  commented out lines below.
//    exchangeRateDataFile.setFileName("\\JBuilder2\\samples\\borland\\samples\\intl\\application\\data\\ExchangeRates.txt");
    exchangeRateDataFile.setFileName("application\\data\\ExchangeRates.txt");
    exchangeRateDataSet.setDataFile(exchangeRateDataFile);
    exchangeRateDataSet.setQuery(new borland.sql.dataset.QueryDescriptor(database, "select * from exchangeRates", null, false, Load.ALL));
    exchangeRateColumn.setColumnName("exchange_rate");
    exchangeRateColumn.setDataType(borland.jbcl.util.Variant.DOUBLE);
    exchangeRateColumn.setEditMask("#####{.#####}");
    exchangeRateColumn.addColumnChangeListener(new AppDataModule_exchangeRateColumn_columnChangeAdapter(this));
//    paymentMethodDataFile.setFileName("\\JBuilder2\\samples\\borland\\samples\\intl\\application\\data\\PaymentMethods.txt");
    paymentMethodDataFile.setFileName("application\\data\\PaymentMethods.txt");
    paymentMethodDataSet.setDataFile(paymentMethodDataFile);
    paymentMethodDataSet.setQuery(new borland.sql.dataset.QueryDescriptor(database, "select * from paymentMethods", null, false, Load.ALL));
//    orderDataFile.setFileName("\\JBuilder2\\samples\\borland\\samples\\intl\\application\\data\\Orders.txt");
    orderDataFile.setFileName("application\\data\\Orders.txt");
    orderDataSet.setDataFile(orderDataFile);
    orderDataSet.setEnableInsert(false);
    orderDataSet.setEnableDelete(false);
    orderDataSet.addEditListener(new AppDataModule_orderDataSet_editAdapter(this));
    orderDateColumn.setColumnName("order_date");
    orderDateColumn.setDataType(borland.jbcl.util.Variant.TIMESTAMP);
    orderDateColumn.setEditable(false);
    orderDateColumn.setDefault("NOW");
    paymentMethodColumn.setColumnName("payment_method");
    paymentMethodColumn.setDataType(borland.jbcl.util.Variant.STRING);
    paymentMethodColumn.setItemPainter(paymentMethodRequiredPainter);
    paymentMethodColumn.setPickList(new borland.jbcl.dataset.PickListDescriptor(paymentMethodDataSet, new String[] {"CREDIT_CARD_NAME"}, new String[] {"CREDIT_CARD_NAME"}, new String[] {"PAYMENT_METHOD"}, false));
    paymentMethodColumn.setRequired(true);
    paymentMethodColumn.addColumnChangeListener(new AppDataModule_paymentMethodColumn_columnChangeAdapter(this));
    cardExpirationDateColumn.setColumnName("card_expiration_date");
    cardExpirationDateColumn.setDataType(borland.jbcl.util.Variant.TIMESTAMP);
    cardExpirationDateColumn.setEditMask(textRes.getString("month_year_editmask"));
    cardExpirationDateColumn.setDisplayMask(textRes.getString("month_year_editmask"));
    cardExpirationDateColumn.setRequired(true);
    creditCardNoColumn.setColumnName("credit_card_no");
    creditCardNoColumn.setDataType(borland.jbcl.util.Variant.STRING);
    creditCardNoColumn.setItemPainter(creditCardNoRequiredPainter);
    creditCardNoColumn.setItemEditor(creditCardNoItemEditor);
    creditCardNoColumn.setRequired(true);
//    orderLineItemDataFile.setFileName("\\JBuilder2\\samples\\borland\\samples\\intl\\application\\data\\OrderLineItems.txt");
    orderLineItemDataFile.setFileName("application\\data\\OrderLineItems.txt");
    orderLineItemDataSet.setDataFile(orderLineItemDataFile);
    orderLineItemDataSet.setMasterLink(new borland.jbcl.dataset.MasterLinkDescriptor(orderDataSet, new String[] {"order_no"}, new String[] {"order_no"}, false));
    orderLineItemDataSet.setEnableInsert(false);
    orderLineItemDataSet.setEnableDelete(false);
    orderLineItemDataSet.setQuery(new borland.sql.dataset.QueryDescriptor(database, "select * from orderLineItems", null, false, Load.ALL));
    orderLineItemDataSet.addCalcAggFieldsListener(new AppDataModule_orderLineItemDataSet_calcAggFieldsAdapter(this));
    orderLineItemDataSet.addCalcFieldsListener(new AppDataModule_orderLineItemDataSet_calcFieldsAdapter(this));
    quantityColumn.setCaption(textRes.getString("quantity"));
    quantityColumn.setColumnName("quantity");
    quantityColumn.setDataType(borland.jbcl.util.Variant.INT);
    quantityColumn.setItemEditor(quantityItemEditor);
    quantityColumn.setMin("1");
    quantityColumn.addColumnChangeListener(new AppDataModule_quantityColumn_columnChangeAdapter(this));
    sizeColumn.setCaption(textRes.getString("size"));
    sizeColumn.setColumnName("sizes");
    sizeColumn.setDataType(borland.jbcl.util.Variant.STRING);
    sizeColumn.setItemEditor(orderLineItemSizeItemEditor);
    sizeColumn.setItemPainter(orderLineItemSizeItemPainter);
    sizeColumn.setPickList(new borland.jbcl.dataset.PickListDescriptor(productSizesDataSet, new String[] {"AVAILABLE_SIZES"}, new String[] {"AVAILABLE_SIZES"}, new String[] {"SIZES"}, false));
    colorColumn.setCaption(textRes.getString("color"));
    colorColumn.setColumnName("colors");
    colorColumn.setDataType(borland.jbcl.util.Variant.STRING);
    colorColumn.setItemEditor(orderLineItemColorItemEditor);
    colorColumn.setItemPainter(orderLineItemColorItemPainter);
    colorColumn.setPickList(new borland.jbcl.dataset.PickListDescriptor(productColorsDataSet, new String[] {"AVAILABLE_COLORS"}, new String[] {"AVAILABLE_COLORS"}, new String[] {"COLORS"}, false));
    descriptionLookupColumn.setCaption(textRes.getString("description"));
    descriptionLookupColumn.setColumnName("description");
    descriptionLookupColumn.setResolvable(false);
    descriptionLookupColumn.setCalcType(borland.jbcl.dataset.CalcType.CALC);
    descriptionLookupColumn.setDataType(borland.jbcl.util.Variant.STRING);
    descriptionLookupColumn.setItemPainter(descriptionLookupItemPainter);
    descriptionLookupColumn.setEditable(false);
    unitPriceLineItemColumn.setCaption(textRes.getString("unit_price"));
    unitPriceLineItemColumn.setCurrency(true);
    unitPriceLineItemColumn.setColumnName("unit_price");
    unitPriceLineItemColumn.setDataType(borland.jbcl.util.Variant.DOUBLE);
    unitPriceLineItemColumn.setLocale(new java.util.Locale("en", "US", ""));
    unitPriceLineItemColumn.setEditable(false);
    extdPriceColumn.setCaption(textRes.getString("extd_price"));
    extdPriceColumn.setCalcType(borland.jbcl.dataset.CalcType.CALC);
    extdPriceColumn.setCurrency(true);
    extdPriceColumn.setColumnName("extd_price");
    extdPriceColumn.setResolvable(false);
    extdPriceColumn.setDataType(borland.jbcl.util.Variant.DOUBLE);
    extdPriceColumn.setLocale(new java.util.Locale("en", "US", ""));
    localExtdPriceColumn.setCaption(textRes.getString("local_price"));
    localExtdPriceColumn.setCalcType(borland.jbcl.dataset.CalcType.CALC);
    localExtdPriceColumn.setColumnName("local_extd_price");
    localExtdPriceColumn.setResolvable(false);
    localExtdPriceColumn.setDataType(borland.jbcl.util.Variant.DOUBLE);
    subtotalColumn.setCalcType(borland.jbcl.dataset.CalcType.AGGREGATE);
    subtotalColumn.setCurrency(true);
    subtotalColumn.setColumnName("subtotal");
    subtotalColumn.setResolvable(false);
    subtotalColumn.setDataType(borland.jbcl.util.Variant.DOUBLE);
    subtotalColumn.setLocale(new java.util.Locale("en", "US", ""));
    localSubtotalColumn.setCalcType(borland.jbcl.dataset.CalcType.AGGREGATE);
    localSubtotalColumn.setColumnName("local_subtotal");
    localSubtotalColumn.setResolvable(false);
    localSubtotalColumn.setDataType(borland.jbcl.util.Variant.DOUBLE);
    shippingColumn.setCalcType(borland.jbcl.dataset.CalcType.AGGREGATE);
    shippingColumn.setCurrency(true);
    shippingColumn.setColumnName("shipping");
    shippingColumn.setResolvable(false);
    shippingColumn.setDataType(borland.jbcl.util.Variant.DOUBLE);
    shippingColumn.setLocale(new java.util.Locale("en", "US", ""));
    localShippingColumn.setCalcType(borland.jbcl.dataset.CalcType.AGGREGATE);
    localShippingColumn.setColumnName("local_shipping");
    localShippingColumn.setResolvable(false);
    localShippingColumn.setDataType(borland.jbcl.util.Variant.DOUBLE);
    taxColumn.setCalcType(borland.jbcl.dataset.CalcType.AGGREGATE);
    taxColumn.setCurrency(true);
    taxColumn.setColumnName("tax");
    taxColumn.setResolvable(false);
    taxColumn.setDataType(borland.jbcl.util.Variant.DOUBLE);
    taxColumn.setLocale(new java.util.Locale("en", "US", ""));
    localTaxColumn.setCalcType(borland.jbcl.dataset.CalcType.AGGREGATE);
    localTaxColumn.setCurrency(true);
    localTaxColumn.setColumnName("local_tax");
    localTaxColumn.setResolvable(false);
    localTaxColumn.setDataType(borland.jbcl.util.Variant.DOUBLE);
    totalColumn.setCalcType(borland.jbcl.dataset.CalcType.AGGREGATE);
    totalColumn.setCurrency(true);
    totalColumn.setColumnName("total");
    totalColumn.setResolvable(false);
    totalColumn.setDataType(borland.jbcl.util.Variant.DOUBLE);
    totalColumn.setLocale(new java.util.Locale("en", "US", ""));
    localTotalColumn.setCalcType(borland.jbcl.dataset.CalcType.AGGREGATE);
    localTotalColumn.setColumnName("local_total");
    localTotalColumn.setResolvable(false);
    localTotalColumn.setDataType(borland.jbcl.util.Variant.DOUBLE);
    skuColumn.setCaption(textRes.getString("sku"));
    skuColumn.setColumnName("sku");
    skuColumn.setDataType(borland.jbcl.util.Variant.INT);
    skuColumn.setEditable(false);
//    productsDataFile.setFileName("\\JBuilder2\\samples\\borland\\samples\\intl\\application\\data\\Products.txt");
    productsDataFile.setFileName("application\\data\\Products.txt");
    unitPriceProductsColumn.setCurrency(true);
    unitPriceProductsColumn.setColumnName("unit_price");
    unitPriceProductsColumn.setDataType(borland.jbcl.util.Variant.DOUBLE);
    unitPriceProductsColumn.setLocale(new java.util.Locale("en", "US", ""));
    descriptionColumn.setColumnName("description");
    descriptionColumn.setDataType(borland.jbcl.util.Variant.STRING);
    productsDataSet.setDataFile(productsDataFile);
    productsDataSet.setQuery(new borland.sql.dataset.QueryDescriptor(database, "select * from products", null, false, Load.ALL));
    productsDataSet.addRowFilterListener(new AppDataModule_productsDataSet_rowFilterAdapter(this));
//    productColorsDataFile.setFileName("\\JBuilder2\\samples\\borland\\samples\\intl\\application\\data\\ProductColors.txt");
    productColorsDataFile.setFileName("application\\data\\ProductColors.txt");
    productColorsDataSet.setDataFile(productColorsDataFile);
    productColorsDataSet.setQuery(new borland.sql.dataset.QueryDescriptor(database, "select * from productColors", null, false, Load.ALL));
//    productSizesDataFile.setFileName("\\JBuilder2\\samples\\borland\\samples\\intl\\application\\data\\ProductSizes.txt");
    productSizesDataFile.setFileName("application\\data\\ProductSizes.txt");
    productSizesDataSet.setDataFile(productSizesDataFile);
    productSizesDataSet.setQuery(new borland.sql.dataset.QueryDescriptor(database, "select * from productSizes", null, false, Load.ALL));
    customerNoDataSet.setDataFile(customerNoDataFile);
    customerNoDataSet.setQuery(new borland.sql.dataset.QueryDescriptor(database, "select * from customerNo", null, false, Load.ALL));
//    customerNoDataFile.setFileName("\\JBuilder2\\samples\\borland\\samples\\intl\\application\\data\\CustomerNo.txt");
    customerNoDataFile.setFileName("application\\data\\CustomerNo.txt");
//    orderNoDataFile.setFileName("\\JBuilder2\\samples\\borland\\samples\\intl\\application\\data\\OrderNo.txt");
    orderNoDataFile.setFileName("application\\data\\OrderNo.txt");
    orderNoDataSet.setDataFile(orderNoDataFile);
    orderNoDataSet.setQuery(new borland.sql.dataset.QueryDescriptor(database, "select * from orderNo ", null, false, Load.ALL));
    imageColumn.setColumnName("image");
    imageColumn.setDataType(borland.jbcl.util.Variant.INPUTSTREAM);
    imageColumn.setEditable(false);
    orderNoColumn.setColumnName("order_no");
    orderNoColumn.setDataType(borland.jbcl.util.Variant.INT);
    orderLineItemNoColumn.setColumnName("order_no");
    orderLineItemNoColumn.setDataType(borland.jbcl.util.Variant.INT);
    totalQuantityColumn.setCalcType(borland.jbcl.dataset.CalcType.AGGREGATE);
    totalQuantityColumn.setColumnName("total_quantity");
    totalQuantityColumn.setDataType(borland.jbcl.util.Variant.INT);
    totalQuantityColumn.setResolvable(false);
//    customerDataFile.setFileName("\\JBuilder2\\samples\\borland\\samples\\intl\\application\\data\\Customers.txt");
    customerDataFile.setFileName("application\\data\\Customers.txt");
    customerDataSet.setDataFile(customerDataFile);
    customerDataSet.setEnableInsert(false);
    customerDataSet.setEnableDelete(false);
    customerDataSet.setQuery(new borland.sql.dataset.QueryDescriptor(database, "select * from customers", null, false, Load.ALL));
    customerDataSet.addRowFilterListener(new AppDataModule_customerDataSet_rowFilterAdapter(this));
    customerDataSet.addEditListener(new AppDataModule_customerDataSet_editAdapter(this));
    descriptionLookupItemPainter.setResourceBundle(textRes);
    orderLineItemSizeItemPainter.setResourceBundle(textRes);
    orderLineItemColorItemPainter.setResourceBundle(textRes);
    lastNameRequiredPainter.setDisplayString(textRes.getString("value_required"));
    firstNameRequiredPainter.setDisplayString(textRes.getString("value_required"));
    address1RequiredPainter.setDisplayString(textRes.getString("value_required"));
    cityRequiredPainter.setDisplayString(textRes.getString("value_required"));
    provinceRequiredPainter.setDisplayString(textRes.getString("value_required"));
    countryRequiredPainter.setDisplayString(textRes.getString("value_required"));
    paymentMethodRequiredPainter.setDisplayString(textRes.getString("value_required"));
    creditCardNoRequiredPainter.setDisplayString(textRes.getString("value_required"));
    orderLineItemSizeItemEditor.setResourceBundle(textRes);
    orderLineItemSizeItemEditor.setCachePickList(false);
    orderLineItemColorItemEditor.setResourceBundle(textRes);
    orderLineItemColorItemEditor.setCachePickList(false);
    exchangeRateDataSet.setColumns(new Column[] {exchangeRateColumn});
    orderDataSet.setColumns(new Column[] {orderNoColumn, orderDateColumn, paymentMethodColumn, creditCardNoColumn, cardExpirationDateColumn});
    productsDataSet.setColumns(new Column[] {unitPriceProductsColumn, descriptionColumn, imageColumn});
    orderLineItemDataSet.setColumns(new Column[] {orderLineItemNoColumn, skuColumn, quantityColumn, sizeColumn, colorColumn, descriptionLookupColumn, unitPriceLineItemColumn, extdPriceColumn, localExtdPriceColumn, subtotalColumn, localSubtotalColumn, shippingColumn, localShippingColumn, taxColumn, localTaxColumn, totalColumn, localTotalColumn, totalQuantityColumn});
    customerDataSet.setColumns(new Column[] {customerNoColumn, lastNameColumn, firstNameColumn, middleNameColumn, address1Column, address2Column, cityColumn, provinceColumn, countryColumn, emailColumn, phoneColumn, faxColumn, passwordColumn, postalCodeColumn});
  }

  /**
   * Return the application's single instance of AppDataModule.
   * In order to ensure that the same instance of AppDataModule is
   * used by all parts of the application, AppDataModule follows the
   * 'singleton' object creation pattern.  Clients of the data
   * module must call getDataModule() to get the single instance of
   * AppDataModule.
   *
   * @return instance of the AppDataModule
   */
  static public AppDataModule getDataModule() {
    // Create the instance of AppDataModule the first time
    // getDataModule is called (appDataModule is initially null).
    // If an instance of the data module has already been
    // created, simply return it.
    if (appDataModule == null) {
      appDataModule = new AppDataModule();
    }
    return appDataModule;
  }

  /**
   * Specifies a JDBC data source to be used as the application's data provider.
   * To use a JDBC data source instead of TextDataFile as the data
   * source, setJBCDataSource must be called with the appropriate
   * JDBC connection parameters before AppDataModule is instantiated.
   * Note that AppDataModule is instantiated the first time
   * AppDataModule.getDataModule() is called.
   *
   * @param URL Universal Resource Locator for a JDBC database connection
   * @param user user name for a JDBC database connection
   * @param password user name's password for a JDBC database connection
   * @param driver JDBC driver name (e.g. 'interbase.interclient.Driver')
   */
  static public void setJDBCDataSource(String URL, String user, String password, String driver) {
    if (appDataModule == null) {
      jdbcURL = URL;
      jdbcUser = user;
      jdbcPassword = password;
      jdbcDriver = driver;
      useQueryDataSet = true;
    }
  }

  /**
   * Returns the customerDataSet data set.
   */
  public borland.sql.dataset.QueryDataSet getCustomerDataSet() {
    return customerDataSet;
  }

  /**
   * Returns the customerDataSetView data set.
   */
  public borland.jbcl.dataset.DataSetView getCustomerDataSetView() {
    return customerDataSetView;
  }

  /**
   * Returns the exchangeRateDataSet data set.
   */
  public borland.sql.dataset.QueryDataSet getExchangeRateDataSet() {
    return exchangeRateDataSet;
  }

  /**
   * Returns the paymentMethodDataSet data set.
   */
  public borland.sql.dataset.QueryDataSet getPaymentMethodDataSet() {
    return paymentMethodDataSet;
  }

  /**
   * Returns the orderDataSet data set.
   */
  public borland.sql.dataset.QueryDataSet getOrderDataSet() {
    return orderDataSet;
  }

  /**
   * Returns the orderLineItemDataSet data set.
   */
  public borland.sql.dataset.QueryDataSet getOrderLineItemDataSet() {
    return orderLineItemDataSet;
  }

  /**
   * Returns the productsDataSet data set.
   */
  public borland.sql.dataset.QueryDataSet getProductsDataSet() {
    return productsDataSet;
  }

  /**
   * Returns the productColorsDataSet data set.
   */
  public borland.sql.dataset.QueryDataSet getProductColorsDataSet() {
    return productColorsDataSet;
  }

  /**
   * Returns the productSizesDataSet data set.
   */
  public borland.sql.dataset.QueryDataSet getProductSizesDataSet() {
    return productSizesDataSet;
  }

  /**
   * Returns the customerNoDataSet data set.
   */
  public borland.sql.dataset.QueryDataSet getCustomerNoDataSet() {
    return customerNoDataSet;
  }

  /**
   * Returns the orderNoDataSet data set.
   */
  public borland.sql.dataset.QueryDataSet getOrderNoDataSet() {
    return orderNoDataSet;
  }

  /**
   * Initializes newly inserted customerDataSet rows.
   * Assigns each newly inserted customer row a unique customer number and
   * fills in the country column with the localized country display
   * name for the current locale.
   *
   * @param DataSet DataSet into which a row has been inserted
   * @exception DataSetException upon invalid use of DataSet
   */
  void customerDataSet_inserted(DataSet dataSet) throws DataSetException{
    // Obtain a new, unique customer number.
    // queryCustomerNo is used as the row filtering criterion for customerDataSet
    // to restrict its scope to a single customer row.  When using a TextDataFile, queryCustomerNo is
    // also used to restrict the scope of orderDataSet to a single customer row.

    // During a locale change, we save the current edits, cancel them, change the locale
    // and then restore them.  Thus we don't want to set the customer_no during
    // a locale change.
    if (!localeChanging) {
      saveCustomerNoDataFile = true;
      queryCustomerNo = getNextInt(customerNoDataSet, "next_customer_no");
      customerDataSet.setInt("customer_no", queryCustomerNo);
      customerDataSet.setString("country", LocaleChangeManager.getLocale().getDisplayCountry(LocaleChangeManager.getLocale()));
    }
  }

  /**
   * Recalculates orderLineItemDataSet's calculated and aggregated value columns.
   *
   * @param DataSet DataSet containing changed column
   * @param column column which has changed
   * @param variant new column value (as a Variant)
   * @exception DataSetException upon invalid use of DataSet
   */
  void exchangeRateColumn_changed(DataSet dataSet, Column column, Variant variant) throws DataSetException{
    orderLineItemDataSet.recalc();
  }

  /**
   * Updates the edit mask of the orderDataSet's credit_card_no column
   * to the newly selected credit card's digit pattern.
   *
   * @param DataSet DataSet containing changed column
   * @param column column which has changed
   * @param variant new column value (as a Variant)
   * @exception DataSetException upon invalid use of DataSet
   */
  void paymentMethodColumn_changed(DataSet dataSet, Column column, Variant variant) throws DataSetException{
    // locate the credit card no pattern
    DataRow locateRow = new DataRow(paymentMethodDataSet, new String [] { "credit_card_name" });
    locateRow.setString("credit_card_name", orderDataSet.getString("payment_method"));
    paymentMethodDataSet.locate(locateRow, Locate.FIRST);
    creditCardNoItemEditor.setEditMask(paymentMethodDataSet.getString("digit_pattern"), Variant.STRING, LocaleChangeManager.getLocale());
  }

  /**
   * Initializes newly inserted orderDataSet rows.
   * Assigns each newly inserted order row a unique order number.
   *
   * @param DataSet DataSet into which a row has been inserted
   * @exception DataSetException upon invalid use of DataSet
   */
  void orderDataSet_inserted(DataSet dataSet) throws DataSetException{
    // During a locale change, we save the current edits, cancel them, change the locale
    // and then restore them.  Thus we don't want to set the order_no during
    // a locale change.
    if (!localeChanging) {
      saveOrderNoDataFile = true;
      dataSet.setInt("order_no", getNextInt(orderNoDataSet, "next_order_no"));
    }
  }

  /**
   * Calculates the extended and localized extended prices of posted
   * orderLineItemDataSet rows.  Also sets the resource bundle lookup
   * key for localized orderLineItemDataSet descriptions
   *
   * @param readRow row of base values for calculation
   * @param dataRow row for newly calculated row values
   * @param isPosted true if readRow is a posted row
   * @exception DataSetException upon invalid use of DataSet
   */
  void orderLineItemDataSet_calcFields(ReadRow readRow, DataRow dataRow, boolean isPosted) throws DataSetException{
    double extdPrice = readRow.getInt("quantity") * readRow.getDouble("unit_price");
    dataRow.setDouble("extd_price", extdPrice);
    dataRow.setDouble("local_extd_price", extdPrice * exchangeRateDataSet.getDouble("exchange_rate"));
    // The item painter for the description column will lookup the
    // description for the sku in a resource bundle and display the
    // localized description
    if (readRow.getInt("sku") != 0) {
      // we'll get a value of 0 when a calcFields event occurs due to a row insert.
      // since there's nothing to display in this case, don't set the value.  Setting
      // a lookup key value of 0 will cause a missing resource exception, since '0'
      // is not a valid sku.
      dataRow.setString("description", "" + readRow.getInt("sku"));
    }
  }

  /**
   * Recalculates US and localized currency subtotal, shipping, tax,
   * and total values for the current order when a row is added to
   * orderLineItemDataSet.
   *
   * @param readRow row of base values for calculation
   * @param readWriteRow row for newly calculated values
   * @exception DataSetException upon invalid use of DataSet
   */
  void orderLineItemDataSet_calcAggAdd(ReadRow readRow, ReadWriteRow readWriteRow) throws DataSetException{
    double subtotal = readRow.getDouble("subtotal");

    // Calculate shipping based on number of items
    double shipping = readRow.getInt("total_quantity") * 4.95;
    readWriteRow.setDouble("shipping", shipping);

    // Calculate 8.5% sales tax based on sum of subtotal and shipping
    double tax = .085 * (subtotal + shipping);
    readWriteRow.setDouble("tax", tax);

    double total = subtotal + shipping + tax;
    readWriteRow.setDouble("total", total);

    // Calculate local subtotal, shipping, tax, and total based on exchange rate
    double exchangeRate = exchangeRateDataSet.getDouble("exchange_rate");
    readWriteRow.setDouble("local_subtotal", subtotal * exchangeRate);
    readWriteRow.setDouble("local_shipping", shipping * exchangeRate);
    readWriteRow.setDouble("local_tax", tax * exchangeRate);
    readWriteRow.setDouble("local_total", total * exchangeRate);
  }

  /**
   * Recalculates US and localized currency subtotal, shipping, tax,
   * and total values for the current order when a row is removed from
   * orderLineItemDataSet.
   *
   * @param readRow row of base values for calculation
   * @param readWriteRow row for newly calculated values
   * @exception DataSetException upon invalid use of DataSet
   */
  void orderLineItemDataSet_calcAggDelete(ReadRow readRow, ReadWriteRow readWriteRow) throws DataSetException{
    // Delegate recalculation of values to orderLineItemDataSet_calcAggAdd()
    orderLineItemDataSet_calcAggAdd(readRow, readWriteRow);
  }

  /**
   * Refilters rows of productsDataSet according to the current
   * productFilteringCategory.
   * productsDataSet_filterRow() is called once for each row
   * in productsDataSet when productsDataSet.open() or
   * productsDataSet.refilter() is invoked.  The value of the
   * productFilteringCategory variable is used to determine which rows
   * should be filtered into (rowFilterResponse.add()) or filtered out
   * of (rowFilterResponse.ignore()) the DataSet.  By design, product
   * categories are assigned integer values.  When the user selects a
   * new product filtering category, ProductFrame calls the data
   * module's filterProducts() method, passing it a value
   * corresponding to the desired filtering category.
   * filterProducts() assigns the new filtering category to the
   * productFilteringCategory variable and invokes
   * productsDataSet.refilter(), causing productsDataSet to be
   * refiltered adding only the desired rows.  AppDataModule's public
   * constant NO_PRODUCT_FILTER can be passed to filterProducts() to
   * filter in all rows.
   *
   * @param readRow row to be filtered
   * @param rowFilterResponse indicates whether row should be filtered into or out of DataSet
   * @exception DataSetException upon invalid use of DataSet
   */
  void productsDataSet_filterRow(ReadRow readRow, RowFilterResponse rowFilterResponse) throws DataSetException{
    if ((productFilteringCategory == NO_PRODUCT_FILTER) ||
        (readRow.getInt("category") == productFilteringCategory)) {
      // add row to filtered DataSet
      rowFilterResponse.add();
    } else {
      // do not add row to filtered DataSet
      rowFilterResponse.ignore();
    }
  }

  /**
   * Sets the (single) customerDataSet filtered row to be the current
   * customerDataSetView row if the specified password is valid.
   * Also removes the unposted, new customer row from customerDataSet
   * if necessary.  Called by CustomerLookupDialog.java when user
   * presses 'OK' button to select a customer row.
   *
   * @return true if customer password is valid
   */
  public boolean isValidCustomerDataViewPassword(String password) {
    try {
      String mangledPassword = customerDataSetView.getString("mangled_password");
      if (mangledPassword.equals(PasswordMangler.manglePassword(password))) {
        // When a new order is initialized, a row is always inserted into customerDataSet
        // with a new unique customer_no value (see customerDataSet_inserted()).
        // If instead of entering a new customer, the user finds an existing customer,
        // then we first have to remove (cancel) the new customer row we added.
        customerDataSet.cancel();
        queryCustomerNo = customerDataSetView.getInt("customer_no");
        customerDataSet.refilter();
        return true;
      }
    } catch (DataSetException e) {
      DataSetException.handleException(customerDataSet, null, e, true);
    }
    return false;
  }

  // called by SoldToPanel.java after an existing customer has been retrieved,
  // in order to copy the customer's no into the pending order.
  public void syncCustomerNoWithCurrentOrder() {
    try {
      orderDataSet.setInt("customer_no", queryCustomerNo);
    } catch (DataSetException e) {
      DataSetException.handleException(orderDataSet, null, e, true);
    }
  }

  /**
   * Removes the current row from orderLineItemDataSet.
   * Called by OrderFrame.java when a user clicks the 'Remove Item'
   * button.
   */
  public void removeCurrentLineItem() {
    try {
      if (orderLineItemDataSet.getRowCount() > 0) {
        // In order to prevent users from interactively deleting rows
        // using [Ctrl][Del], we initially set setEnableDelete(false).
        // So in order to delete an existing orderLineItem row, we need to set
        // temporarily do setEnableDelete(true) so we can delete the row.
        orderLineItemDataSet.setEnableDelete(true);
        orderLineItemDataSet.deleteRow();
        orderLineItemDataSet.setEnableDelete(false);
      }
    } catch (DataSetException e) {
      DataSetException.handleException(orderLineItemDataSet, null, e, true);
    }
  }

  /**
   * Cancels the current order.
   * Called by OrderFrame.java when a user clicks the 'Cancel Order'
   * button.
   */
  public void cancelOrder() {
    StorageDataSet dataSet = null;
    if (enteringOrder) {
      try {
        // If we're using a QueryDataSet, then we can simply empty the
        // orderDataSet and orderLineItemDataSet data sets.
        if (useQueryDataSet) {
          (dataSet = orderLineItemDataSet).empty();
          // Must cancel row currently being edited before doing empty()
          (dataSet = orderDataSet).cancel();
          orderDataSet.empty();
        } else {
          // When using a TextDataFile data source, we've already loaded
          // all the orderDataSet and orderLineItemDataSet data, so we
          // have to remove the current rows we're editing in
          // orderDataSet and orderLineItemDataSet.  Delete already
          // posted line items for the current order.
          // In order to prevent users from interactively deleting rows
          // using {Ctrl-Del}, we set setEnableDelete(false).
          // So in order to delete an existing orderLineItem row, we need
          // to temporarily set setEnableDelete(true).
          (dataSet = orderLineItemDataSet).first();
          orderLineItemDataSet.setEnableDelete(true);
          while (orderLineItemDataSet.getRowCount() > 0) {
            orderLineItemDataSet.deleteRow();
          }
          orderLineItemDataSet.setEnableDelete(false);
          (dataSet = orderDataSet).cancel();
        }
        // When using either a JDBC database or TextDataFile data source,
        // we always load in all rows of the customerDataSet, so for the
        // customerDataSet, we have to cancel the row we were currently
        // editing.  cancel() on a newly inserted row will remove the
        // row.  cancel() on a modified, existing row will undo changes
        // on the row.
        (dataSet = customerDataSet).cancel();
        // Reset the enteringOrder value to indicate we are no longer
        // entering a new order.
        enteringOrder = false;
      } catch (DataSetException e) {
        DataSetException.handleException(dataSet, null, e, true);
      }
    }
  }

  /**
   * Saves the current order.
   * Called by OrderFrame.java when a user clicks on the 'Save Order'
   * button.  When using a JDBC data source, the order is immediately
   * resolved back to the database.  When using a TextDataFile data
   * source, however, changes are not resolved back to the
   * TextDataFile until resolveData() is called on application exit.
   *
   * @param password (non-mangled) password of customer submitting
   * order
   * @return false if posting any of the order rows fails (most likely due
   * to a validation error).
   */
  public boolean saveOrder(String password) {
    DataSet dataSet = null;
    try {
      // Copy summary data to master order row and post it

      // allow us to insert and update the rows
      customerDataSet.setEnableInsert(true);
      orderDataSet.setEnableInsert(true);
      orderLineItemDataSet.setEnableInsert(true);

      dataSet = orderDataSet;
      ReadRow.copyTo(new String [] { "subtotal", "tax", "shipping", "total" },
                     orderLineItemDataSet,
                     new String [] { "subtotal", "tax", "shipping_charge", "total" },
                     orderDataSet);

      orderDataSet.post();

      // If we added a new customer row or modified an existing one, post it
      if (isPasswordNeededToSaveOrder()) {
        customerDataSet.setString("mangled_password", PasswordMangler.manglePassword(password));
      }
      (dataSet = customerDataSet).post();

      // When using a query data set provider, after posting the newly
      // added order to its corresponding DataSets, we resolve it back
      // to the JDBC data source.  Note that the default query
      // resolver is smart enough to resolve only the necessary changes
      // to the database.
      if (useQueryDataSet) {
        database.saveChanges(new DataSet [] { customerDataSet, orderDataSet, orderLineItemDataSet });
      }
      // Reset the enteringOrder value to indicate we are no longer
      // entering a new order.
      enteringOrder = false;
      customerDataSet.setEnableInsert(false);
      orderDataSet.setEnableInsert(false);
      orderLineItemDataSet.setEnableInsert(false);
      return true;
    } catch (DataSetException e) {
      DataSetException.handleException(dataSet, null, e, true);
    }
    return false;
  }

  /**
   * Returns whether or not a password has already been given for the
   * current customerDataSet row.  Called by OrderFrame.java to
   * determine whether or not to prompt the user for a password when
   * saving an order.  Also called by AppDataModule.saveOrder() to check if a new
   * password needs to be saved with the current order.
   *
   * @return true if a password is needed
   */
  public boolean isPasswordNeededToSaveOrder() {
    try {
      return customerDataSet.getString("mangled_password").length() == 0;
    } catch (DataSetException e) {
      DataSetException.handleException(customerDataSet, null, e, true);
    }
    return false;
  }

  /**
   * Resolves order data back to the appropriate data source.
   * When using a JDBC database source, all changes will already have
   * been posted and resolved, so nothing has to be done.  When using
   * a TextDataFile, however, changes made to orderDataSet,
   * orderLineItemDataSet, and customerDataSet need to be saved back
   * to disk.  Called by WelcomeFrame.java when a user exits the
   * application.
   */
  public void resolveData() {
    DataSet dataSet = null;
    try {
      if (useQueryDataSet) {
        // No changes need to be saved because orders are posted on saveOrder()
        database.closeConnection();
      } else {
        // If enteringOrder is true at this point, then the user
        // exited without canceling or saving an order.  In this case,
        // we remove any posted detail rows in orderLineItemDataSet
        // and cancel changes in customerDataSet and orderDataSet.
        // Note that we have to remove the detail rows first, because
        // if we cancelled the master first, the details would no
        // longer have a master row, and we wouldn't be able to access
        // them using orderLineItemDataSet.
        if (enteringOrder) {
          (dataSet = orderLineItemDataSet).first();
          orderLineItemDataSet.setEnableDelete(true);
          // Delete already posted line items for the current order
          while (orderLineItemDataSet.getRowCount() > 0) {
            orderLineItemDataSet.deleteRow();
          }
          orderLineItemDataSet.setEnableDelete(false);
        }
        orderLineItemDataSet.close();

        if (enteringOrder) {
          // Cancel modified or newly inserted customerDataSet row
          (dataSet = customerDataSet).cancel();
        }
        customerDataSet.close();
        // Remove filter restrictions before saving.
        // TextDataFile.save() will only save rows which have been filtered
        // into the DataSet, thus in order to save back all rows we need to
        // remove filter restrictions before saving.
        customerDataSet.removeRowFilterListener(customerDataSet.getRowFilterListener());

        if (enteringOrder) {
          // Cancel newly inserted orderDataSet row
          (dataSet = orderDataSet).cancel();
        }
        // Remove filter restrictions before saving.
        // TextDataFile.save() will only saves rows which have been
        // filtered into the DataSet, thus in order to save back all
        // rows we need to remove filter restrictions before saving.
        orderDataSet.close();
        orderDataSet.removeRowFilterListener(orderDataSet.getRowFilterListener());

        // Resolve DataSet changes back to text data file sources
        customerDataFile.save(dataSet = customerDataSet);
        orderDataFile.save(dataSet = orderDataSet);
        orderLineItemDataFile.save(dataSet = orderLineItemDataSet);
        if (saveCustomerNoDataFile) {
          customerNoDataFile.save(dataSet = customerNoDataSet);
        }
        if (saveOrderNoDataFile) {
          orderNoDataFile.save(dataSet = orderNoDataSet);
        }
      }
    } catch (DataSetException e) {
      DataSetException.handleException(dataSet, null, e, true);
    } catch (Exception e) {
      borland.jbcl.util.Diagnostic.printStackTrace(e);
    }
  }

  /**
   * Initializes data entry rows for a new order.  Called by
   * addProductToOrderLineItem() when a product is inserted into an
   * order.  Checks whether the order has already been initialized,
   * and if not, inserts new rows in orderDataSet and customerDataSet.
   */
  public void initializeOrder() {
    DataSet dataSet = null;
    // enteringOrder tells us whether or not we have already
    // initialized the order.  Only initialize the order
    // if we haven't already done so.
    if (!enteringOrder) {
      try {
        if (useQueryDataSet) {
          // If we're using a JDBC database source, execute a query
          // which always returns an empty result.  This has the side
          // effect of loading database metadata into the DataSet so
          // that we can simply add new rows to orderDataSet and
          // orderLineItemDataSet and then post changes back with
          // database.saveChanges().  For customerDataSet, since we
          // always provide all customerDataSet rows, we use a
          // RowFilterListener to simply restrict the user to
          // navigating a single customer row.

          // Get the query parameters for the orderDataSet query, and
          // set them to a condition which guarantees an empty result.
          ReadWriteRow parameterRow = orderDataSet.getParameterRow();
          parameterRow.setInt("customer_no", INVALID_CUSTOMER);
          dataSet = orderDataSet;

          // Execute a query on orderDataSet which should return no
          // rows.  Because there's a MasterLinkDescriptor connecting
          // orderLineItemDataSet to orderDataSet that specifies that
          // linked detail rows should be fetched as needed, executing
          // the query on orderDataSet also executes the query on
          // orderLineItemDataSet.
          orderDataSet.executeQuery();

          // Open the DataSets for subsequent DataSet operations
          orderDataSet.open();
          orderLineItemDataSet.open();
        }
        // 'inserted' event handlers on orderDataSet and
        // customerDataSet put the proper values into the newly
        // inserted rows.

        orderDataSet.setEnableInsert(true);
        (dataSet = orderDataSet).insertRow(false);
        orderDataSet.setEnableInsert(false);
        customerDataSet.setEnableInsert(true);
        (dataSet = customerDataSet).insertRow(false);
        customerDataSet.setEnableInsert(false);
        (dataSet = orderDataSet).setInt("customer_no", customerDataSet.getInt("customer_no"));

        // Set enteringOrder to true so that the next time
        // initializeOrder() is called by addProductToOrderLineItem(),
        // we'll know to not reinitialize the order again.
        enteringOrder = true;
      } catch (Exception e) {
        DataSetException.handleException(dataSet, null, e, true);
      }
    }
  }

  /**
   * Inserts information from the current row of productsDataSet into
   * orderLineItemDataSet.  Called by ProductFrame.java when a user
   * presses the "Add product to Order" button.  When inserting the
   * new order row into the orderLineItemDataSet, we check to see if
   * an identical item already exists (same sku and detail info), and
   * if so, simply increment its quantity in the order.
   */
  public void addProductToOrderLineItem() {
    try {
      // Insert and initialize new rows in orderDataSet,
      // customerDataSet, and orderLineItemDataSet if not already
      // done.
      initializeOrder();

      // Build a scoped DataRow (on the sku and details columns) for
      // use in locating a duplicate item already in the order.
      DataRow locateRow = new DataRow(orderLineItemDataSet, new String [] { "sku", "sizes", "colors" });
      locateRow.setInt("sku", productsDataSet.getInt("sku"));
      String color = getCurrentProductDefaultColor();
      locateRow.setString("colors", color);
      String size = getCurrentProductDefaultSize();
      locateRow.setString("sizes", size);

      // See if an identical order line item (same sku and details
      // column values) already exists.
      if ((orderLineItemDataSet.getRowCount() > 0) && (orderLineItemDataSet.locate(locateRow, Locate.FIRST))) {
        // If we found the same item, just increase its quantity value
        orderLineItemDataSet.setInt("quantity", orderLineItemDataSet.getInt("quantity")+1);
      } else {
        // Otherwise, insert a row for the new item.

        orderLineItemDataSet.setEnableInsert(true);
        orderLineItemDataSet.insertRow(false);
        orderLineItemDataSet.setInt("sku", productsDataSet.getInt("sku"));
        orderLineItemDataSet.setInt("quantity", 1);
        orderLineItemDataSet.setDouble("unit_price", productsDataSet.getDouble("unit_price"));
        orderLineItemDataSet.setString("sizes", size);
        orderLineItemDataSet.setString("colors", color);
      }
      // Post new change to update calculated aggregate values
      orderLineItemDataSet.post();
      orderLineItemDataSet.setEnableInsert(false);
    } catch (DataSetException e) {
      DataSetException.handleException(orderLineItemDataSet, null, e, true);
    }
  }

  /**
   * Record new product filtering category and force refiltering to
   * occur.  Called by ProductFrame.java when a user changes the
   * current product filtering category.
   *
   * @param productFilteringCategory NO_PRODUCT_FILTER for all
   * products, 1 for software products only, 2 for deskware products
   * only, 3 for bodyware products only.
   */
  public void filterProducts(int productFilteringCategory) {
    try {
      this.productFilteringCategory = productFilteringCategory;
      // Invoke the productsDataSet's RowFilterListener to filter rows
      // based on new filter criterion
      productsDataSet.refilter();
    } catch (Exception e) {
      DataSetException.handleException(productsDataSet, null, e, true);
    }
  }

  /**
   * Returns default color for the current row of the productsDataSet.
   * Called by addProductToOrderLineItem() when inserting a new row.
   *
   * @return non-localized string containing default product color
   * or an empty string if the product has no color.
   */
  String getCurrentProductDefaultColor() {
    String color = "";
    try {
      int sku = productsDataSet.getInt("sku");

      // Create a DataRow scoped on the sku column for doing a locate
      // within productColorsDataSet.
      DataSetView colorsView = productColorsDataSet.cloneDataSetView();
      DataRow locateRow = new DataRow(colorsView, new String [] { "sku" });
      locateRow.setInt("sku", sku);
      // Locate the first color choice for the sku
      if (colorsView.locate(locateRow, Locate.FIRST)) {
        color = colorsView.getString("available_colors");
      }

    } catch (Exception e) {
      DataSetException.handleException(productColorsDataSet, null, e, true);
    }
    return color;
  }

  /**
   * Returns default size for the current row of the productsDataSet.
   * Called by addProductToOrderLineItem() when inserting a new row.
   *
   * @return non-localized string containing default product size
   * or an empty string if the product has no size.
   */
  String getCurrentProductDefaultSize() {
    String size = "";
    try {
      int sku = productsDataSet.getInt("sku");

      // Create a DataRow scoped on the sku column for doing a locate
      // within productSizesDataSet.
      DataSetView sizesView = productSizesDataSet.cloneDataSetView();
      DataRow locateRow = new DataRow(sizesView, new String [] { "sku" });
      locateRow.setInt("sku", sku);
      // Locate the first size choice for the sku
      if (sizesView.locate(locateRow, Locate.FIRST)) {
        size = sizesView.getString("available_sizes");
      }

    } catch (Exception e) {
      DataSetException.handleException(productSizesDataSet, null, e, true);
    }
    return size;
  }

  /**
   * Configures data sets for browsing previous orders of the customer
   * indicated by the customerDataSet's current row.
   * Called by WelcomeFrame.java when user clicks 'View Previous
   * Orders' button, and also OrderFrame.java when user closes frame
   * after having viewed orders.
   *
   * @param browseCustomerOrders if true, prepares data sets for
   * browsing a customer's previous orders.
   */
  public void browseCustomerOrders(boolean browseCustomerOrders) {
    StorageDataSet dataSet = null;
    try {
      if (browseCustomerOrders) {
        // queryCustomerNo (set by CustomerLookupDialog.java's call to isValidCustomerDataViewPassword())
        // should contain contain the correct customer no
        if (useQueryDataSet) {
          // If using a JDBC database, execute a query which selects
          // rows from orderDataSet for the selected customer.
          // Because orderLineItemDataSet's MasterLinkDescriptor
          // specifies linked detail rows should be fetched as needed,
          // executing the query on orderDataSet automatically fetches
          // the corresponding orderLineItemDataSet linked detail rows.
          ReadWriteRow parameterRow = orderDataSet.getParameterRow();
          parameterRow.setInt("customer_no", queryCustomerNo);
          dataSet = orderDataSet;
          orderDataSet.executeQuery();
        } else {
          // If using a TextDataFile source, force refiltering of
          // orderDataSet's rows for the selected customer.
          (dataSet = orderDataSet).refilter();
        }
        // Force updating of calculated aggregate values
        orderLineItemDataSet.recalc();
      } else {
        queryCustomerNo = INVALID_CUSTOMER;
        if (useQueryDataSet) {
          // If we're no longer browsing a customer's previous orders,
          // we can simply empty the rows from the DataSet.  Note that
          // empty() discards query resolver information so that when the
          // data set is resolved (when posting a new order), rows
          // emptied here will not be deleted from the server.
          (dataSet = orderDataSet).empty();
          (dataSet = orderLineItemDataSet).empty();
        } else {
          // If we're using a TextDataFile data source, refilter orderDataSet
          // for no order rows.
          (dataSet = orderDataSet).refilter();
        }
      }
    } catch (Exception e) {
      DataSetException.handleException(dataSet, null, e, true);
    }
  }

  /**
   * Restricts navigation of orderDataSet to rows for the current customer (stored in queryCustomerNo).
   *
   * @param readRow row to be filtered
   * @param rowFilterResponse indicates whether row should be filtered into or out of DataSet
   * @exception DataSetException upon invalid use of DataSet
   */
  void orderDataSet_filterRow(ReadRow readRow, RowFilterResponse rowFilterResponse) throws DataSetException{
    if (readRow.getInt("customer_no") == queryCustomerNo) {
      // Add row to filtered DataSet
      rowFilterResponse.add();
    } else {
      // Do not add row to filtered DataSet
      rowFilterResponse.ignore();
    }
  }

  /**
   * Sets the current row of the exchangeRateDataSet to the current locale's country.
   * If a country can't be found, the current row is set to the row for "US".
   * Localized calculations are performed based upon the conversion rate taken from the
   * current row of exchangeRateDataSet.
   */
  private void readExchangeRate() {
    try {
      // Build a scoped DataRow (on the country_code column) for
      // use in locating a country code.
      DataRow locateRow = new DataRow(exchangeRateDataSet, new String [] { "country_code" });

      locateRow.setString("country_code", LocaleChangeManager.getLocale().getCountry());
      // If the country exists in exchangeRateDataSet, the following locate() should
      // position the current row of exchangeRateDataSet to that row.
      if (!exchangeRateDataSet.locate(locateRow, Locate.FIRST)) {
        // If we couldn't find the country, set the rate to the US rate.
        locateRow.setString("country_code", "US");
        exchangeRateDataSet.locate(locateRow, Locate.FIRST);
      }
    } catch (Exception e) {
      DataSetException.handleException(exchangeRateDataSet, null, e, true);
    }
  }

  /**
   * Increments an integer value the specified column of a DataSet.
   * Called by the DataSet 'inserted' event handlers for
   * customerDataSet and orderDataSet to get unique customer and order
   * numbers, respectively.  When using a JDBC database, assumes that
   * a query has already been defined for the DataSet which provides
   * the row to be incremented.  After the value is incremented, it is
   * immediately posted back to the server.
   *
   * @param DataSet name of DataSet containing integer columnName
   * @param columnName column name of DataSet containing integer value
   * to be incremented
   * @return incremented integer value
   */
  int getNextInt(QueryDataSet dataset, String columnName) throws DataSetException{
    if (useQueryDataSet) {
      dataset.executeQuery();
    }
    dataset.open();
    int nextInt = dataset.getInt(columnName);
    dataset.setInt(columnName, nextInt + 1);
    dataset.post();
    if (useQueryDataSet) {
      dataset.saveChanges(dataset);
    }
    return nextInt;
  }

  /**
   * Updates localized resources for newly selected locale.
   * Required for implementation of LocaleChangeListener interface.
   *
   * @param e LocaleChangeEvent providing information about new locale
   */
  public void localeChanged(LocaleChangeEvent e) {
    localeChanging = true;
    try {

      // Get resource bundles for new locale
      textRes = java.util.ResourceBundle.getBundle("borland.samples.intl.application.resources.TextRes", e.getLocale());

      // Changing to a different locale requires us to close datasets
      // and reopen them for the new locale.

      DataRow [] orderLineItemRow = null;
      int currentOrderItemRow = 0;
      int orderNo = 0;
      Timestamp orderDate = null;
      String paymentMethod = null;
      String creditCardNo = null;
      Variant cardExpirationDate = null;
      int customerNo = 0;
      String lastName = null;
      String firstName = null;
      String middleName = null;
      String address1 = null;
      String address2 = null;
      String city = null;
      String province = null;
      String country = null;
      String eMail = null;
      String phone = null;
      String fax = null;
      String postalCode = null;

      if (enteringOrder) {
        // Save the rows of the current order so we can restore them later.
        // orderLineItemDataSet row storage
        orderLineItemRow = new DataRow[orderLineItemDataSet.getRowCount()];
        currentOrderItemRow = orderLineItemDataSet.getRow();
        for (int rowNo = 0; rowNo < orderLineItemRow.length; rowNo++) {
          orderLineItemRow[rowNo] = new DataRow(orderLineItemDataSet, new String [] { "sku", "quantity", "sizes", "colors", "unit_price"} );
          orderLineItemDataSet.getDataRow(rowNo, orderLineItemRow[rowNo]);
        }

        // If any of the orderDataSet's columns don't satisfy a validation
        // constraint, then saving those values in a DataRow created from
        // orderDataSet will throw a validation exception.  Thus we can't
        // use a DataRow to save the orderDataSet row data as we did with
        // orderLineItemRow above.
        orderNo = orderDataSet.getInt("order_no");
        orderDate = orderDataSet.getTimestamp("order_date");
        paymentMethod = orderDataSet.getString("payment_method");
        creditCardNo = orderDataSet.getString("credit_card_no");
        cardExpirationDate = new Variant();
        orderDataSet.getVariant("card_expiration_date", cardExpirationDate);

      // If any of the customerDataSet's columns don't satisfy a validation
      // constraint, then saving those values in a DataRow created from
      // customerDataSet will throw a validation exception.  Thus we can't
      // use a DataRow to save the customerDataSet row data as we did with
      // orderLineItemRow above.
        customerNo = customerDataSet.getInt("customer_no");
        lastName = customerDataSet.getString("last_name");
        firstName = customerDataSet.getString("first_name");
        middleName = customerDataSet.getString("middle_name");
        address1 = customerDataSet.getString("address1");
        address2 = customerDataSet.getString("address2");
        city = customerDataSet.getString("city");
        province = customerDataSet.getString("province");
        country = customerDataSet.getString("country");
        eMail = customerDataSet.getString("e_mail");
        phone = customerDataSet.getString("phone");
        fax = customerDataSet.getString("fax");
        postalCode = customerDataSet.getString("postal_code");

        // Cancel the order
        cancelOrder();
        // When we cancel the order using cancelOrder(), enteringOrder is set
        // to false.  Since we re-insert the order after the locale change,
        // we need to reset enteringOrder to be true.  (enteringOrder is the flag
        // used to determine whether to cancel the current order on exit from
        // the application.
        enteringOrder = true;
      }

      // Close the datasets so we can set new locale settings
      orderLineItemDataSet.close();
      orderDataSet.close();
      customerDataSet.close();

      // Set new localized captions
      lastNameColumn.setCaption(textRes.getString("last_name"));
      middleNameColumn.setCaption(textRes.getString("middle_name"));
      firstNameColumn.setCaption(textRes.getString("first_name"));
      address1Column.setCaption(textRes.getString("address1"));
      address2Column.setCaption(textRes.getString("address2"));
      cityColumn.setCaption(textRes.getString("city"));
      provinceColumn.setCaption(textRes.getString("province"));
      countryColumn.setCaption(textRes.getString("country"));
      emailColumn.setCaption(textRes.getString("e_mail"));
      phoneColumn.setCaption(textRes.getString("phone"));
      faxColumn.setCaption(textRes.getString("fax"));
      postalCodeColumn.setCaption(textRes.getString("postal_code"));

      // Set new localized edit masks
      postalCodeColumn.setEditMask(textRes.getString("postal_code_editmask"));
      phoneColumn.setEditMask(textRes.getString("phone_editmask"));
      faxColumn.setEditMask(textRes.getString("phone_editmask"));
      provinceColumn.setEditMask(textRes.getString("province_editmask"));

      // Set new localized captions
      quantityColumn.setCaption(textRes.getString("quantity"));
      sizeColumn.setCaption(textRes.getString("size"));
      colorColumn.setCaption(textRes.getString("color"));
      descriptionLookupColumn.setCaption(textRes.getString("description"));
      unitPriceLineItemColumn.setCaption(textRes.getString("unit_price"));
      extdPriceColumn.setCaption(textRes.getString("extd_price"));
      localExtdPriceColumn.setCaption(textRes.getString("local_price"));
      skuColumn.setCaption(textRes.getString("sku"));

      // Set new localized edit and display masks
      cardExpirationDateColumn.setEditMask(textRes.getString("month_year_editmask"));
      orderDateColumn.setDisplayMask(((SimpleDateFormat) SimpleDateFormat.getDateInstance(DateFormat.DEFAULT, e.getLocale())).toPattern());
      cardExpirationDateColumn.setDisplayMask(textRes.getString("month_year_editmask"));

      if (LocaleChangeManager.getLocale().equals(Locale.ITALY) ||
          LocaleChangeManager.getLocale().getCountry().equals("CH")) {
        localExtdPriceColumn.setDisplayMask(null);
        localSubtotalColumn.setDisplayMask(null);
        localShippingColumn.setDisplayMask(null);
        localTaxColumn.setDisplayMask(null);
        localTotalColumn.setDisplayMask(null);
      } else {
        localExtdPriceColumn.setDisplayMask(((DecimalFormat) DecimalFormat.getCurrencyInstance(LocaleChangeManager.getLocale())).toPattern());
        localSubtotalColumn.setDisplayMask(((DecimalFormat) DecimalFormat.getCurrencyInstance(LocaleChangeManager.getLocale())).toPattern());
        localShippingColumn.setDisplayMask(((DecimalFormat) DecimalFormat.getCurrencyInstance(LocaleChangeManager.getLocale())).toPattern());
        localTaxColumn.setDisplayMask(((DecimalFormat) DecimalFormat.getCurrencyInstance(LocaleChangeManager.getLocale())).toPattern());
        localTotalColumn.setDisplayMask(((DecimalFormat) DecimalFormat.getCurrencyInstance(LocaleChangeManager.getLocale())).toPattern());
      }

      // Set new localized 'value required' string
      lastNameRequiredPainter.setDisplayString(textRes.getString("value_required"));
      firstNameRequiredPainter.setDisplayString(textRes.getString("value_required"));
      address1RequiredPainter.setDisplayString(textRes.getString("value_required"));
      cityRequiredPainter.setDisplayString(textRes.getString("value_required"));
      provinceRequiredPainter.setDisplayString(textRes.getString("value_required"));
      countryRequiredPainter.setDisplayString(textRes.getString("value_required"));
      paymentMethodRequiredPainter.setDisplayString(textRes.getString("value_required"));
      creditCardNoRequiredPainter.setDisplayString(textRes.getString("value_required"));

      // Set new resource bundle for localized description lookup painter
      descriptionLookupItemPainter.setResourceBundle(textRes);


      // Set new resource bundle for order line item size and color picklist item painters and editors
      orderLineItemSizeItemPainter.setResourceBundle(textRes);
      orderLineItemColorItemPainter.setResourceBundle(textRes);
      orderLineItemSizeItemEditor.setResourceBundle(textRes);
      orderLineItemColorItemEditor.setResourceBundle(textRes);

      // Reopen datasets
      orderLineItemDataSet.open();
      orderDataSet.open();
      customerDataSet.open();

      // Restore rows to their state before the locale change.
      // Insert master before inserting linked detail rows

      if (enteringOrder) {
        // Re-insert order row data.  If any of the required columns were blank,
        // don't set the value, since doing so will cause a validation exception.
        orderDataSet.setEnableInsert(true);
        orderDataSet.insertRow(false);
        orderDataSet.setEnableInsert(false);
        orderDataSet.setInt("order_no", orderNo);
        orderDataSet.setTimestamp("order_date", orderDate);
        if (paymentMethod.length() != 0) {
          orderDataSet.setString("payment_method", paymentMethod);
        }
        if (creditCardNo.length() != 0) {
          orderDataSet.setString("credit_card_no", creditCardNo);
        }
        if (!cardExpirationDate.isNull()) {
          orderDataSet.setVariant("card_expiration_date", cardExpirationDate);
        }

        // Re-insert the order line item data.  Since the DataRow was scoped to
        // only contain editable columns, and there are no validation checks
        // on its scoped columns, we can just use updateRow() to restore the data.
        orderLineItemDataSet.setEnableInsert(true);
        for (int rowNo = 0; rowNo < orderLineItemRow.length; rowNo++) {
          orderLineItemDataSet.insertRow(false);
          orderLineItemDataSet.updateRow(orderLineItemRow[rowNo]);
          orderLineItemDataSet.post();
        }
        if (currentOrderItemRow != -1) {
          orderLineItemDataSet.goToRow(currentOrderItemRow);
        }
        orderLineItemDataSet.setEnableInsert(false);

      // Re-insert customer row data.  Since we could have been entering
      // a new row or editing an existing one, first try to see if the row
      // already exists within the dataset.  If so, then we'll update its
      // values.  If not, we'll insert a new row for the new customer data.
        DataRow locateRow = new DataRow(customerDataSet, "customer_no");
        locateRow.setInt("customer_no", customerNo);

      // Search for the customer row.  If we find it, we'll be positioned
      // on the proper row, so all we'll need to do is restore its values.
      // If we don't find the row, then we need to insert a new row for
      // this new customer.
        if (!customerDataSet.locate(locateRow, Locate.FIRST)) {
          customerDataSet.setEnableInsert(true);
          customerDataSet.insertRow(false);
          customerDataSet.setInt("customer_no", customerNo);
          customerDataSet.setEnableInsert(false);
        }
        // If any of the required columns were blank,
        // don't set the value, since doing so will cause a validation exception.
        if (lastName.length() != 0) {
          customerDataSet.setString("last_name", lastName);
        }
        if (firstName.length() != 0) {
          customerDataSet.setString("first_name", firstName);
        }
        customerDataSet.setString("middle_name", middleName);
        if (address1.length() != 0) {
          customerDataSet.setString("address1", address1);
        }
        customerDataSet.setString("address2", address2);
        if (city.length() != 0) {
          customerDataSet.setString("city", city);
        }
        if (province.length() != 0) {
          customerDataSet.setString("province", province);
        }
        if (country.length() != 0) {
          customerDataSet.setString("country", country);
        }
        customerDataSet.setString("e_mail", eMail);
        customerDataSet.setString("phone", phone);
        customerDataSet.setString("fax", fax);
        customerDataSet.setString("postal_code", postalCode);
      }

      // When the locale changes, we need to get localized description data for the new locale.
      // Note that by using productsDataSetView here instead of productsDataSet, we don't need
      // to save and restore our current cursor position within the productsDataSet, and the
      // ProductsFrame will only refresh its currently displayed row (since it's using
      // productsDataSet as its data set)
      DataSetView productsDataSetView = new DataSetView();
      productsDataSetView.setStorageDataSet(productsDataSet);
      productsDataSetView.open();
      productsDataSetView.first();

      // Add localized description data
      while (productsDataSetView.inBounds()) {
        int sku = productsDataSetView.getInt("sku");
        String localizedDescription = textRes.getString("" + sku);
        productsDataSetView.setString("description", localizedDescription);
        productsDataSetView.next();
      }
      productsDataSetView.post();
      productsDataSetView.close();

      // Update exchangeRateDataSet to point to new country's exchange rate
      readExchangeRate();

      // Force calc columns to be recalculated based on new exchange rate values
      orderLineItemDataSet.recalc();

    } catch (Exception ex) {
      borland.jbcl.util.Diagnostic.printStackTrace(ex);
    }
    localeChanging = false;
  }

  /**
   * Forces calculated aggregates to be updated immediately by posting
   * a row when its quantity value changes.  Note that aggregated
   * calculations are only performed on posted rows.  Normal
   * calculated columns, in constrast, can be updated immediately when
   * the quantity value is 'put' and do not require the row to be
   * posted.
   *
   * @param DataSet DataSet containing changed column
   * @param column column which has changed
   * @param variant new column value (as a Variant)
   * @exception DataSetException upon invalid use of DataSet
   */
  void quantityColumn_changed(DataSet dataSet, Column column, Variant variant) throws DataSetException{
    orderLineItemDataSet.post();
  }

  /**
   * Filters all but the current customer number row (stored in
   * queryCustomerNo) out of customerDataSet.
   *
   * @param readRow row to be filtered
   * @param rowFilterResponse indicates whether row should be filtered into or out of DataSet
   * @exception DataSetException upon invalid use of DataSet
   */
  void customerDataSet_filterRow(ReadRow readRow, RowFilterResponse rowFilterResponse) throws DataSetException{
    if (readRow.getInt("customer_no") == queryCustomerNo) {
      // Add row to filtered DataSet
      rowFilterResponse.add();
    } else {
      // Do not add row to filtered DataSet
      rowFilterResponse.ignore();
    }
  }

  /**
   * Filters in only those colors available for the current product.
   * Called by orderLineItemColorItemEditor when adding picklist values to its Choice.
   *
   * @param readRow row to be filtered
   * @param rowFilterResponse indicates whether row should be filtered into or out of DataSet
   * @exception DataSetException upon invalid use of DataSet
   */
  void orderLineItemColorItemEditor_filterRow(ReadRow readRow, RowFilterResponse rowFilterResponse) throws DataSetException{
    if (readRow.getInt("sku") == orderLineItemDataSet.getInt("sku")) {
      // Add row to filtered DataSet
      rowFilterResponse.add();
    } else {
      // Do not add row to filtered DataSet
      rowFilterResponse.ignore();
    }
  }

  /**
   * Filters in only those sizes available for the current product.
   * Called by orderLineItemSizeItemEditor when adding picklist values to its Choice.
   *
   * @param readRow row to be filtered
   * @param rowFilterResponse indicates whether row should be filtered into or out of DataSet
   * @exception DataSetException upon invalid use of DataSet
   */
  void orderLineItemSizeItemEditor_filterRow(ReadRow readRow, RowFilterResponse rowFilterResponse) throws DataSetException{
    if (readRow.getInt("sku") == orderLineItemDataSet.getInt("sku")) {
      // Add row to filtered DataSet
      rowFilterResponse.add();
    } else {
      // Do not add row to filtered DataSet
      rowFilterResponse.ignore();
    }
  }

}

// The following adapter classes were created by the UI Designer to hook
// up DataSet events to the appropriate methods in AppDataModule.

class AppDataModule_customerDataSet_editAdapter extends borland.jbcl.dataset.EditAdapter {
  AppDataModule adaptee;

  AppDataModule_customerDataSet_editAdapter(AppDataModule adaptee) {
    this.adaptee = adaptee;
  }

  public void inserted(DataSet dataSet) throws DataSetException{
    adaptee.customerDataSet_inserted(dataSet);
  }

}

class AppDataModule_exchangeRateColumn_columnChangeAdapter extends borland.jbcl.dataset.ColumnChangeAdapter {
  AppDataModule adaptee;

  AppDataModule_exchangeRateColumn_columnChangeAdapter(AppDataModule adaptee) {
    this.adaptee = adaptee;
  }

  public void changed(DataSet dataSet, Column column, Variant variant) throws DataSetException{
    adaptee.exchangeRateColumn_changed(dataSet, column, variant);
  }
}

class AppDataModule_paymentMethodColumn_columnChangeAdapter extends borland.jbcl.dataset.ColumnChangeAdapter {
  AppDataModule adaptee;

  AppDataModule_paymentMethodColumn_columnChangeAdapter(AppDataModule adaptee) {
    this.adaptee = adaptee;
  }

  public void changed(DataSet dataSet, Column column, Variant variant) throws DataSetException{
    adaptee.paymentMethodColumn_changed(dataSet, column, variant);
  }
}

class AppDataModule_orderDataSet_editAdapter extends borland.jbcl.dataset.EditAdapter {
  AppDataModule adaptee;

  AppDataModule_orderDataSet_editAdapter(AppDataModule adaptee) {
    this.adaptee = adaptee;
  }

  public void inserted(DataSet dataSet) throws DataSetException{
    adaptee.orderDataSet_inserted(dataSet);
  }

}

class AppDataModule_orderLineItemDataSet_calcFieldsAdapter implements borland.jbcl.dataset.CalcFieldsListener {
  AppDataModule adaptee;

  AppDataModule_orderLineItemDataSet_calcFieldsAdapter(AppDataModule adaptee) {
    this.adaptee = adaptee;
  }

  public void calcFields(ReadRow readRow, DataRow dataRow, boolean boolean1) throws DataSetException{
    adaptee.orderLineItemDataSet_calcFields(readRow, dataRow, boolean1);
  }
}

class AppDataModule_orderLineItemDataSet_calcAggFieldsAdapter extends borland.jbcl.dataset.CalcAggFieldsAdapter {
  AppDataModule adaptee;

  AppDataModule_orderLineItemDataSet_calcAggFieldsAdapter(AppDataModule adaptee) {
    this.adaptee = adaptee;
  }

  public void calcAggAdd(ReadRow readRow, ReadWriteRow readWriteRow) throws DataSetException{
    adaptee.orderLineItemDataSet_calcAggAdd(readRow, readWriteRow);
  }

  public void calcAggDelete(ReadRow readRow, ReadWriteRow readWriteRow) throws DataSetException{
    adaptee.orderLineItemDataSet_calcAggDelete(readRow, readWriteRow);
  }

}

class AppDataModule_productsDataSet_rowFilterAdapter implements borland.jbcl.dataset.RowFilterListener {
  AppDataModule adaptee;

  AppDataModule_productsDataSet_rowFilterAdapter(AppDataModule adaptee) {
    this.adaptee = adaptee;
  }

  public void filterRow(ReadRow readRow, RowFilterResponse rowFilterResponse) throws DataSetException{
    adaptee.productsDataSet_filterRow(readRow, rowFilterResponse);
  }
}

class AppDataModule_quantityColumn_columnChangeAdapter extends borland.jbcl.dataset.ColumnChangeAdapter {
  AppDataModule adaptee;

  AppDataModule_quantityColumn_columnChangeAdapter(AppDataModule adaptee) {
    this.adaptee = adaptee;
  }

  public void changed(DataSet dataSet, Column column, Variant variant) throws DataSetException{
    adaptee.quantityColumn_changed(dataSet, column, variant);
  }
}


class AppDataModule_orderDataSet_rowFilterAdapter implements borland.jbcl.dataset.RowFilterListener {
  AppDataModule adaptee;

  AppDataModule_orderDataSet_rowFilterAdapter(AppDataModule adaptee) {
    this.adaptee = adaptee;
  }

  public void filterRow(ReadRow readRow, RowFilterResponse rowFilterResponse) throws DataSetException{
    adaptee.orderDataSet_filterRow(readRow, rowFilterResponse);
  }
}


class AppDataModule_customerDataSet_rowFilterAdapter implements borland.jbcl.dataset.RowFilterListener {
  AppDataModule adaptee;

  AppDataModule_customerDataSet_rowFilterAdapter(AppDataModule adaptee) {
    this.adaptee = adaptee;
  }

  public void filterRow(ReadRow readRow, RowFilterResponse rowFilterResponse) throws DataSetException{
    adaptee.customerDataSet_filterRow(readRow, rowFilterResponse);
  }
}


class AppDataModule_orderLineItemSizeItemEditor_rowFilterAdapter implements borland.jbcl.dataset.RowFilterListener {
  AppDataModule adaptee;

  AppDataModule_orderLineItemSizeItemEditor_rowFilterAdapter(AppDataModule adaptee) {
    this.adaptee = adaptee;
  }

  public void filterRow(ReadRow readRow, RowFilterResponse rowFilterResponse) throws DataSetException{
    adaptee.orderLineItemSizeItemEditor_filterRow(readRow, rowFilterResponse);
  }
}

class AppDataModule_orderLineItemColorItemEditor_rowFilterAdapter implements borland.jbcl.dataset.RowFilterListener {
  AppDataModule adaptee;

  AppDataModule_orderLineItemColorItemEditor_rowFilterAdapter(AppDataModule adaptee) {
    this.adaptee = adaptee;
  }

  public void filterRow(ReadRow readRow, RowFilterResponse rowFilterResponse) throws DataSetException{
    adaptee.orderLineItemColorItemEditor_filterRow(readRow, rowFilterResponse);
  }
}