BUG 15/BUGCD1998_06.ISO/aplic/jbuilder/jsamples.z/AppDataModule.java

Java Source | 1997-07-28 | 104.0 KB | 2,264 lines

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.jbcl.util.*;
import borland.jbcl.view.*;

import COM.objectspace.jgl.*;

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

/**
 * The application's data module, AppDataModule, can be conceptually
 * divided into the following four parts:
 *  - JBCL data access components
 *  - public DataSet accessor methods that are automatically generated
 *  - event handler logic
 *  - application and business logic
 *
 * 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
 * automatically generated by the UI Designer for each DataSet in
 * the data module.  Clients of the data module use these accessor
 * methods to obtain references to DataSet components provided by the data
 * module.  For example, the OrderFrame frame uses a data-aware
 * GridControl component to display line items for an order.
 * The GridControl component's dataSet property is set to the
 * OrderLineItemDataSet returned using the getOrderLineItemDataSet() method
 * of the AppDataModule.
 *<p>
 * The third part of the AppDataModule consists of the methods by which the
 * application's GUI components manipulate the state of the
 * application.  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 .
 *<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 an 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.  See
   * borland\samples\intl\application\resources\TextRes.java for more
   * information.
   */
  ResourceBundle textRes = java.util.ResourceBundle.getBundle("borland.samples.intl.application.resources.TextRes");

  /**
   * 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;

  /**
   * 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;

  /**
   * Determines whether or not an 'inserting' event should be allowed
   * to succeed on a DataSet.  By throwing a VetoException from within
   * a DataSet's 'inserting' event handler, if vetoInsertingEvent is
   * 'true', we can prevent users from inserting a new row by pressing
   * {Ctrl-Ins} from within a GridControl or FieldControl.
   */
  protected boolean vetoInsertingEvent = true;

  /**
   * Determines whether or not a 'deleting' event should be allowed to
   * succeed on a data set.  By throwing a VetoException from within a
   * DataSet's 'deleting' event handler, if vetoDeletingEvent is
   * 'true', we can prevent users from deleting existing rows by
   * pressing {Ctrl-Del} from within a GridControl or FieldControl.
   */
  protected boolean vetoDeletingEvent = true;

  /**
   * Determines whether or not an 'adding' or 'updating' event should
   * be allowed to succeed on a data set.  By throwing a VetoException
   * from within a DataSet's 'adding' or 'updating' event handler, if
   * vetoAddingOrUpdatingEvent is 'true', we can prevent users from
   * posting existing rows by pressing {PgDn} or {PgUp} from within a
   * FieldControl.
   */
  protected boolean vetoAddingOrUpdatingEvent = true;

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

  /**
   * The custom (model-view) item editor for the 'details' column of
   * orderLineItemDataSet.  See
   * borland/samples/intl/application/ResourceableLineItemDetailEditor.java
   * for more info.
   */
  ResourceableLineItemDetailEditor orderLineItemDetailEditor = new ResourceableLineItemDetailEditor();

  /**
   * The custom (model-view) item painter for the 'details' column of
   * orderLineItemDataSet.  See
   * borland/samples/intl/application/ResourceableLineItemDetailPainter.java
   * for more info.
   */
  ResourceableLineItemDetailPainter orderLineItemDetailPainter = new ResourceableLineItemDetailPainter();

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

  // The following AnnotatedEmptyItemPainters are custom (model-view)
  // item painters used to put the 'required' message in empty,
  // required fields 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.
  // See borland/samples/intl/util/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 cardExpirationDateRequiredPainter = new AnnotatedEmptyItemPainter();
  AnnotatedEmptyItemPainter creditCardNoRequiredPainter = new AnnotatedEmptyItemPainter();
  AnnotatedEmptyItemPainter countryRequiredPainter = new AnnotatedEmptyItemPainter();

  // 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 detailsColumn = 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.

      // NOTE: Columns of a data set are cloned by
      // DataSet.setColumns().  Thus maintaining a reference to the
      // column object and updating its properties will have no effect
      // on the column's DataSet once setColumns() has been called.
      // In order to update column properties after setColumns() has
      // been called, you must either call setColumns() again, or use
      // DataSet.getColumn() to get the column and call
      // DataSet.enableDataSetEvents(true) to force the DataSet to
      // update its column properties.

      // 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.jbcl.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.
      orderLineItemDataSet.getColumn("subtotal").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.
      orderLineItemDataSet.getColumn("total_quantity").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.
      orderLineItemDataSet.getColumn("local_subtotal").setAgg(new AggDescriptor(new String [] { "order_no" }, null, null));
      orderLineItemDataSet.getColumn("shipping").setAgg(new AggDescriptor(new String [] { "order_no" }, null, null));
      orderLineItemDataSet.getColumn("local_shipping").setAgg(new AggDescriptor(new String [] { "order_no" }, null, null));
      orderLineItemDataSet.getColumn("tax").setAgg(new AggDescriptor(new String [] { "order_no" }, null, null));
      orderLineItemDataSet.getColumn("local_tax").setAgg(new AggDescriptor(new String [] { "order_no" }, null, null));
      orderLineItemDataSet.getColumn("total").setAgg(new AggDescriptor(new String [] { "order_no" }, null, null));
      orderLineItemDataSet.getColumn("local_total").setAgg(new AggDescriptor(new String [] { "order_no" }, null, null));

      // Set the string to be displayed by the AnnotatedEmptyItemPainter for
      // required columns when empty.  Also, replace the default item painter
      // used by an AnnotatedEmptyItemPainter (TextItemPainter) with a
      // focusable, selectable text item painter.
      String requiredString = textRes.getString("value_required");
      lastNameRequiredPainter.setDisplayString(requiredString);
      lastNameRequiredPainter.setItemPainter(new FocusableItemPainter(new SelectableTextItemPainter()));
      firstNameRequiredPainter.setDisplayString(requiredString);
      firstNameRequiredPainter.setItemPainter(new FocusableItemPainter(new SelectableTextItemPainter()));
      address1RequiredPainter.setDisplayString(requiredString);
      address1RequiredPainter.setItemPainter(new FocusableItemPainter(new SelectableTextItemPainter()));
      cityRequiredPainter.setDisplayString(requiredString);
      cityRequiredPainter.setItemPainter(new FocusableItemPainter(new SelectableTextItemPainter()));
      provinceRequiredPainter.setDisplayString(requiredString);
      provinceRequiredPainter.setItemPainter(new FocusableItemPainter(new SelectableTextItemPainter()));
      countryRequiredPainter.setDisplayString(requiredString);
      countryRequiredPainter.setItemPainter(new FocusableItemPainter(new SelectableTextItemPainter()));
      paymentMethodRequiredPainter.setDisplayString(requiredString);
      paymentMethodRequiredPainter.setItemPainter(new FocusableItemPainter(new SelectableTextItemPainter()));
      creditCardNoRequiredPainter.setDisplayString(requiredString);
      creditCardNoRequiredPainter.setItemPainter(new FocusableItemPainter(new SelectableTextItemPainter()));
      cardExpirationDateRequiredPainter.setDisplayString(requiredString);
      cardExpirationDateRequiredPainter.setItemPainter(new FocusableItemPainter(new SelectableTextItemPainter()));

      // Set the resource bundle used by descriptionLookupItemPainter,
      // the item painter used to display localized product
      // descriptions in the 'description' column of the
      // orderLineItemDataSet DataSet.  Also, replace
      // descriptionLookupItemPainter's default TextItemPainter with a
      // selectable one, and assign it as the item painter for the
      // descriptionLookupColumn (wrapped within a focusable item
      // painter).
      descriptionLookupItemPainter.setResourceBundle(textRes);
      descriptionLookupItemPainter.setTextItemPainter(new SelectableTextItemPainter());
      orderLineItemDataSet.getColumn("description").setItemPainter(new FocusableItemPainter(descriptionLookupItemPainter));

      // The orderLineItemDetailEditor and orderLineItemDetailPainter classes
      // are responsible for managing the editing and display of localized
      // data from the details column of orderLineItemDataSet.  More
      // specifically, orderLineItemDetailEditor reads non-localized
      // product color and size values from the column, and presents
      // the user with one or more ChoiceControls to edit the values.
      // Similarly, the orderLineItemDetailPainter reads non-localized
      // product color and size values from the column, and displays
      // their localized translations.  Because this functionality
      // requires intimate knowledge of the application's format for
      // storing details data, orderLineItemDetailEditor and
      // orderLineItemDetailPainter are located within the
      // borland.samples.intl.application package rather than the
      // general borland.samples.intl.util package.
      orderLineItemDetailEditor.setAppDataModule(this);
      orderLineItemDetailEditor.setResourceBundle(textRes);
      orderLineItemDetailPainter.setResourceBundle(textRes);

      // 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.
      orderDataSet.getColumn("order_date").setDisplayMask(((SimpleDateFormat) SimpleDateFormat.getDateInstance(DateFormat.DEFAULT, Locale.getDefault())).toPattern());
      orderLineItemDataSet.getColumn("local_extd_price").setDisplayMask(((DecimalFormat) DecimalFormat.getCurrencyInstance(Locale.getDefault())).toPattern());
      orderLineItemDataSet.getColumn("local_subtotal").setDisplayMask(((DecimalFormat) DecimalFormat.getCurrencyInstance(Locale.getDefault())).toPattern());
      orderLineItemDataSet.getColumn("local_shipping").setDisplayMask(((DecimalFormat) DecimalFormat.getCurrencyInstance(Locale.getDefault())).toPattern());
      orderLineItemDataSet.getColumn("local_tax").setDisplayMask(((DecimalFormat) DecimalFormat.getCurrencyInstance(Locale.getDefault())).toPattern());
      orderLineItemDataSet.getColumn("local_total").setDisplayMask(((DecimalFormat) DecimalFormat.getCurrencyInstance(Locale.getDefault())).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.
      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));
      orderDataSet.getColumn("card_expiration_date").setMinValue(variant);

      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.jbcl.dataset.QueryDescriptor(database, "select * from orders where customer_no = :customer_no", orderDataSetQueryParameters, false, false));
      } 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.
      orderLineItemDataSet.enableDataSetEvents(false);
      orderDataSet.enableDataSetEvents(false);
      orderDataSet.close();
      orderDataSet.getColumn("credit_card_no").setEditMask(paymentMethodDataSet.getString("digit_pattern"));
      orderDataSet.getColumn("payment_method").setDefault(paymentMethodDataSet.getString("credit_card_name"));
      orderDataSet.open();
      orderLineItemDataSet.enableDataSetEvents(true);
      orderDataSet.enableDataSetEvents(true);

      // 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.setBinaryStream("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);
    provinceColumn.setRequired(true);
    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);
    exchangeRateDataFile.setFileName("\\JBuilder\\samples\\borland\\samples\\intl\\application\\data\\ExchangeRates.txt");
    exchangeRateDataSet.setDataFile(exchangeRateDataFile);
    exchangeRateDataSet.setQuery(new borland.jbcl.dataset.QueryDescriptor(database, "select * from exchangeRates", null, false, false));
    exchangeRateColumn.setColumnName("exchange_rate");
    exchangeRateColumn.setDataType(borland.jbcl.util.Variant.DOUBLE);
    exchangeRateColumn.setEditMask("#####{.#####}");
    exchangeRateColumn.addColumnChangeListener(new AppDataModule_exchangeRateColumn_columnChangeAdapter(this));
    paymentMethodDataFile.setFileName("\\JBuilder\\samples\\borland\\samples\\intl\\application\\data\\PaymentMethods.txt");
    paymentMethodDataSet.setDataFile(paymentMethodDataFile);
    paymentMethodDataSet.setQuery(new borland.jbcl.dataset.QueryDescriptor(database, "select * from paymentMethods", null, false, false));
    orderDataFile.setFileName("\\JBuilder\\samples\\borland\\samples\\intl\\application\\data\\Orders.txt");
    orderDataSet.setDataFile(orderDataFile);
    orderDataSet.addEditListener(new AppDataModule_orderDataSet_editAdapter(this));
    orderDateColumn.setColumnName("order_date");
    orderDateColumn.setDataType(borland.jbcl.util.Variant.TIMESTAMP);
    orderDateColumn.setDefault("now");
    paymentMethodColumn.setColumnName("payment_method");
    paymentMethodColumn.setDataType(borland.jbcl.util.Variant.STRING);
    paymentMethodColumn.setItemPainter(paymentMethodRequiredPainter);
    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.setItemPainter(cardExpirationDateRequiredPainter);
    cardExpirationDateColumn.setRequired(true);
    creditCardNoColumn.setColumnName("credit_card_no");
    creditCardNoColumn.setDataType(borland.jbcl.util.Variant.STRING);
    creditCardNoColumn.setItemPainter(creditCardNoRequiredPainter);
    creditCardNoColumn.setRequired(true);
    orderLineItemDataFile.setFileName("\\JBuilder\\samples\\borland\\samples\\intl\\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.setQuery(new borland.jbcl.dataset.QueryDescriptor(database, "select * from orderLineItems", null, false, false));
    orderLineItemDataSet.addEditListener(new AppDataModule_orderLineItemDataSet_editAdapter(this));
    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));
    detailsColumn.setCaption(textRes.getString("details"));
    detailsColumn.setColumnName("details");
    detailsColumn.setDataType(borland.jbcl.util.Variant.STRING);
    detailsColumn.setItemEditor(orderLineItemDetailEditor);
    detailsColumn.setItemPainter(orderLineItemDetailPainter);
    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.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("\\JBuilder\\samples\\borland\\samples\\intl\\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.jbcl.dataset.QueryDescriptor(database, "select * from products", null, false, false));
    productsDataSet.addRowFilterListener(new AppDataModule_productsDataSet_rowFilterAdapter(this));
    productColorsDataFile.setFileName("\\JBuilder\\samples\\borland\\samples\\intl\\application\\data\\ProductColors.txt");
    productColorsDataSet.setDataFile(productColorsDataFile);
    productColorsDataSet.setQuery(new borland.jbcl.dataset.QueryDescriptor(database, "select * from productColors", null, false, false));
    productSizesDataFile.setFileName("\\JBuilder\\samples\\borland\\samples\\intl\\application\\data\\ProductSizes.txt");
    productSizesDataSet.setDataFile(productSizesDataFile);
    productSizesDataSet.setQuery(new borland.jbcl.dataset.QueryDescriptor(database, "select * from productSizes", null, false, false));
    customerNoDataSet.setDataFile(customerNoDataFile);
    customerNoDataSet.setQuery(new borland.jbcl.dataset.QueryDescriptor(database, "select * from customerNo", null, false, false));
    customerNoDataFile.setFileName("\\JBuilder\\samples\\borland\\samples\\intl\\application\\data\\CustomerNo.txt");
    orderNoDataFile.setFileName("\\JBuilder\\samples\\borland\\samples\\intl\\application\\data\\OrderNo.txt");
    orderNoDataSet.setDataFile(orderNoDataFile);
    orderNoDataSet.setQuery(new borland.jbcl.dataset.QueryDescriptor(database, "select * from orderNo ", null, false, false));
    imageColumn.setColumnName("image");
    imageColumn.setDataType(borland.jbcl.util.Variant.BINARY_STREAM);
    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("\\JBuilder\\samples\\borland\\samples\\intl\\application\\data\\Customers.txt");
    customerDataSet.setDataFile(customerDataFile);
    customerDataSet.setQuery(new borland.jbcl.dataset.QueryDescriptor(database, "select * from customers", null, false, false));
    customerDataSet.addRowFilterListener(new AppDataModule_customerDataSet_rowFilterAdapter(this));
    customerDataSet.addEditListener(new AppDataModule_customerDataSet_editAdapter(this));
    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, detailsColumn, 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.jbcl.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.jbcl.dataset.QueryDataSet getExchangeRateDataSet() {
    return exchangeRateDataSet;
  }

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

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

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

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

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

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

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

  /**
   * Returns the orderNoDataSet data set.
   */
  public borland.jbcl.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 field 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.
    queryCustomerNo = getNextInt(customerNoDataSet, "next_customer_no");
    customerDataSet.setInt("customer_no", queryCustomerNo);
    customerDataSet.setString("country", Locale.getDefault().getDisplayCountry(Locale.getDefault()));
  }

  /**
   * 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);
    orderDataSet.enableDataSetEvents(false);
    // set the credit card no edit mask pattern
    orderDataSet.getColumn("credit_card_no").setEditMask(paymentMethodDataSet.getString("digit_pattern"));
    // activate the new edit mask
    orderDataSet.enableDataSetEvents(true);
  }

  /**
   * 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{
    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{
    if (isPosted) {
      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
      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 have defined a DataSet 'deleting'
    // event handler which vetoes 'deleting' events if
    // vetoDeletingEvent is true (the default value).  So in
    // order to delete an existing orderLineItem row, we need to set
    // vetoDeletingEvent false.
    vetoDeletingEvent = false;
    orderLineItemDataSet.deleteRow();
    vetoDeletingEvent = true;
      }
    } 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;
    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 have defined a DataSet 'deleting'
    // event handler which vetoes 'deleting' events if
    // vetoDeletingEvent is true (the default value).  So in
    // order to delete an existing orderLineItem row, we need to set
    // vetoDeletingEvent false.
    (DataSet = orderLineItemDataSet).first();
    vetoDeletingEvent = false;
    while (orderLineItemDataSet.getRowCount() > 0) {
      orderLineItemDataSet.deleteRow();
    }
    vetoDeletingEvent = true;
    (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
      DataSet = orderDataSet;
      ReadRow.copyTo(new String [] { "subtotal", "tax", "shipping", "total" },
                     orderLineItemDataSet,
             new String [] { "subtotal", "tax", "shipping_charge", "total" },
             orderDataSet);
      // In order to post a new orderDataSet row, we need to tell
      // orderDataSet's 'adding' event handler that it should not veto
      // the event.  We do that by setting vetoAddingOrUpdating false
      // when posting.
      vetoAddingOrUpdatingEvent = false;
      orderDataSet.post();
      vetoAddingOrUpdatingEvent = true;

      // If we added a new customer row or modified an existing one, post it
      if (isPasswordNeededToSaveOrder()) {
    customerDataSet.setString("mangled_password", PasswordMangler.manglePassword(password));
      }
      // In order to post a new or modified, existing customerDataSet
      // row, we need to tell customerDataSet's 'adding', 'updating',
      // and 'inserting' event handlers that they should not veto the
      // event.  We do that by setting vetoAddingOrUpdating and
      // vetoInsertingEvent false when posting.
      vetoAddingOrUpdatingEvent = false;
      vetoInsertingEvent = false;
      (DataSet = customerDataSet).post();
      vetoAddingOrUpdatingEvent = true;
      vetoInsertingEvent = true;

      // 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;
      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.
    // In order to prevent users from interactively deleting rows
    // using {Ctrl-Del}, we have defined a DataSet 'deleting'
    // event handler which vetoes 'deleting' events if
    // vetoDeletingEvent is true (the default value).  So in
    // order to delete an existing orderLineItem row, we need to set
    // vetoDeletingEvent false.
    if (enteringOrder) {
      (DataSet = orderLineItemDataSet).first();
      vetoDeletingEvent = false;
      // Delete already posted line items for the current order
      while (orderLineItemDataSet.getRowCount() > 0) {
        orderLineItemDataSet.deleteRow();
      }
      vetoDeletingEvent = true;
    }
    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);
    orderNoDataFile.save(DataSet = orderNoDataSet);
    customerNoDataFile.save(DataSet = customerNoDataSet);
      }
    } 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.
      ParameterRow 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.

    // To prevent a user from interactively inserting (by
    // {Ctrl-Ins}), deleting (by {Ctrl-Del}), or posting (by {PgDn}
    // or {PgUp}) our newly inserted rows, we have attached
    // 'inserting', 'adding', and 'deleting' event handlers which
    // will veto such events unless we explicitly disable them.
    // Thus in order to insert a new customer row, we need
    // to set vetoInsertingEvent false to tell our
    // customerDataSet 'inserting' event handler to allow
    // us to do an insertRow().
    (DataSet = orderDataSet).insertRow(false);
    vetoInsertingEvent = false;
    (DataSet = customerDataSet).insertRow(false);
    vetoInsertingEvent = true;
    (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 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", "details" });
      locateRow.setInt("sku", productsDataSet.getInt("sku"));
      String details = getCurrentProductDefaultDetails();
      if (details.length() == 0) {
    details = "N/A";
      }
      locateRow.setString("details", details);

      // 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.

    // In order to prevent users from interactively adding rows
    // using {Ctrl-Ins}, we have defined a DataSet 'inserting'
    // event handler which vetoes 'inserting' events if
    // vetoInsertingEvent is true (the default value).  So in
    // order to insert a new orderLineItem row, we need to set
    // vetoInsertingEvent to false.
    vetoInsertingEvent = false;
    orderLineItemDataSet.insertRow(false);
    vetoInsertingEvent = true;
    orderLineItemDataSet.setInt("sku", productsDataSet.getInt("sku"));
    orderLineItemDataSet.setInt("quantity", 1);
    orderLineItemDataSet.setDouble("unit_price", productsDataSet.getDouble("unit_price"));
    orderLineItemDataSet.setString("details", details);
      }
      // Post new change to update calculated aggregate values
      orderLineItemDataSet.post();
    } 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 detail info (product color/size) for the current
   * row of the productsDataSet.
   * Called by addProductToOrderLineItem() when inserting a new row.
   *
   * @return non-localized string containing comma separated list of
   * color and size info (e.g., "white,L") or an empty string if the
   * product requires no detail information.
   */
  String getCurrentProductDefaultDetails() {
    String details = "";
    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)) {
    details = colorsView.getString("available_colors");
      }

      // Create a DataRow scoped on the sku column for doing a locate
      // within productSizesDataSet.
      DataSetView sizesView = productSizesDataSet.cloneDataSetView();
      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)) {
    if (details.length() == 0) {
      details = sizesView.getString("available_sizes");
    } else {
      details += "," + sizesView.getString("available_sizes");
    }
      }
    } catch (Exception e) {
      DataSetException.handleException(productsDataSet, null, e, true);
    }
    return details;
  }

  /**
   * 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.
      ParameterRow 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 records from the DataSet.  Note that
      // empty() discards query resolver information so that when the
      // data set is resolved (when posting a new order), records
      // 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", Locale.getDefault().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);
    }
  }

  /**
   * Returns an array of strings containing detail choices (sizes or
   * colors) for a product.  Called by
   * ResourceableLineItemDetailEditor.java to get a list of sizes or
   * colors to present as details for a product item.  The value in
   * the keyColumnName column of the current row of keyDataSet should
   * contain a string value which can be used as the lookup key for
   * rows in lookupDataSet.  For example, if the sku (keyColumnName)
   * column of the current row of productsDataSet (keyDataSet)
   * contains the value '1000', all values from the color
   * (lookupColumnName) column for rows whose sku (keyColumnName)
   * column value in productColorsDataSet (lookupDataSet) are '1000'
   * will be returned.
   *
   * @param keyDataSet DataSet whose current row's keyColumnName
   * column value contains a lookup key
   * @param keyColumnName name of column in keyDataSet containing
   * lookup key value
   * @param lookupDataSet DataSet which may contain rows matching a
   * lookup key
   * @param lookupColumnName name of column in lookupDataSet from
   * which to extract string values
   * @return array of strings with matched lookup values from
   * lookupColumnName
   */
  String [] getLookupChoices(DataSet keyDataSet, String keyColumnName, DataSet lookupDataSet, String lookupColumnName) {
    String [] choices = new String[0];
    try {
      Array array = new Array();
      DataRow locateRow = new DataRow(lookupDataSet, new String [] { keyColumnName });
      Variant locateVariant = new Variant();
      keyDataSet.getVariant(keyColumnName, locateVariant);
      locateRow.setVariant(keyColumnName, locateVariant);
      if (lookupDataSet.locate(locateRow, Locate.FIRST)) {
    Variant foundVariant = new Variant();
    do {
      lookupDataSet.getVariant(lookupColumnName, foundVariant);
      array.add(foundVariant.toString());
    } while (lookupDataSet.locate(locateRow, Locate.NEXT));
      }
      choices = new String[array.size()];
      array.copyTo(choices);
    } catch (Exception e) {
      DataSetException.handleException(lookupDataSet, null, e, true);
    }
    return choices;
  }

  /**
   * 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.
   * Note that DataSet.enableDataSetEvents() must be called in order
   * for newly set column properties to take effect.
   *
   * @param e LocaleChangeEvent providing information about new locale
   */
  public void localeChanged(LocaleChangeEvent e) {
    try {
      // Get resource bundles for new locale
      textRes = ResourceBundle.getBundle("borland.samples.intl.application.resources.textRes", e.getLocale());

      // Set new localized captions
      customerDataSet.enableDataSetEvents(false);
      customerDataSet.getColumn("last_name").setCaption(textRes.getString("last_name"));
      customerDataSet.getColumn("middle_name").setCaption(textRes.getString("middle_name"));
      customerDataSet.getColumn("first_name").setCaption(textRes.getString("first_name"));
      customerDataSet.getColumn("address1").setCaption(textRes.getString("address1"));
      customerDataSet.getColumn("address2").setCaption(textRes.getString("address2"));
      customerDataSet.getColumn("city").setCaption(textRes.getString("city"));
      customerDataSet.getColumn("province").setCaption(textRes.getString("province"));
      customerDataSet.getColumn("country").setCaption(textRes.getString("country"));
      customerDataSet.getColumn("e_mail").setCaption(textRes.getString("e_mail"));
      customerDataSet.getColumn("phone").setCaption(textRes.getString("phone"));
      customerDataSet.getColumn("fax").setCaption(textRes.getString("fax"));
      customerDataSet.getColumn("postal_code").setCaption(textRes.getString("postal_code"));

      // Set new localized edit masks
      customerDataSet.getColumn("postal_code").setEditMask(textRes.getString("postal_code_editmask"));
      customerDataSet.getColumn("phone").setEditMask(textRes.getString("phone_editmask"));
      customerDataSet.getColumn("fax").setEditMask(textRes.getString("phone_editmask"));
      customerDataSet.getColumn("province").setEditMask(textRes.getString("province_editmask"));
      customerDataSet.enableDataSetEvents(true);

      // Set new localized captions
      orderLineItemDataSet.getColumn("quantity").setCaption(textRes.getString("quantity"));
      orderLineItemDataSet.getColumn("details").setCaption(textRes.getString("details"));
      orderLineItemDataSet.getColumn("description").setCaption(textRes.getString("description"));
      orderLineItemDataSet.getColumn("unit_price").setCaption(textRes.getString("unit_price"));
      orderLineItemDataSet.getColumn("extd_price").setCaption(textRes.getString("extd_price"));
      orderLineItemDataSet.getColumn("local_extd_price").setCaption(textRes.getString("local_price"));
      orderLineItemDataSet.getColumn("sku").setCaption(textRes.getString("sku"));

      // Set new localized edit and display masks
      orderDataSet.enableDataSetEvents(false);
      orderDataSet.getColumn("card_expiration_date").setEditMask(textRes.getString("month_year_editmask"));
      orderDataSet.getColumn("order_date").setDisplayMask(((SimpleDateFormat) SimpleDateFormat.getDateInstance(DateFormat.DEFAULT, e.getLocale())).toPattern());
      orderDataSet.getColumn("card_expiration_date").setDisplayMask(textRes.getString("month_year_editmask"));
      orderDataSet.enableDataSetEvents(true);

      orderLineItemDataSet.enableDataSetEvents(false);
      orderLineItemDataSet.getColumn("local_extd_price").setDisplayMask(((DecimalFormat) DecimalFormat.getCurrencyInstance(e.getLocale())).toPattern());
      orderLineItemDataSet.getColumn("local_subtotal").setDisplayMask(((DecimalFormat) DecimalFormat.getCurrencyInstance(e.getLocale())).toPattern());
      orderLineItemDataSet.getColumn("local_shipping").setDisplayMask(((DecimalFormat) DecimalFormat.getCurrencyInstance(e.getLocale())).toPattern());
      orderLineItemDataSet.getColumn("local_tax").setDisplayMask(((DecimalFormat) DecimalFormat.getCurrencyInstance(e.getLocale())).toPattern());
      orderLineItemDataSet.getColumn("local_total").setDisplayMask(((DecimalFormat) DecimalFormat.getCurrencyInstance(e.getLocale())).toPattern());
      orderLineItemDataSet.enableDataSetEvents(true);

      // Set new localized 'value required' string
      String requiredString = textRes.getString("value_required");
      lastNameRequiredPainter.setDisplayString(requiredString);
      lastNameRequiredPainter.setItemPainter(new FocusableItemPainter(new SelectableTextItemPainter()));
      firstNameRequiredPainter.setDisplayString(requiredString);
      firstNameRequiredPainter.setItemPainter(new FocusableItemPainter(new SelectableTextItemPainter()));
      address1RequiredPainter.setDisplayString(requiredString);
      address1RequiredPainter.setItemPainter(new FocusableItemPainter(new SelectableTextItemPainter()));
      cityRequiredPainter.setDisplayString(requiredString);
      cityRequiredPainter.setItemPainter(new FocusableItemPainter(new SelectableTextItemPainter()));
      provinceRequiredPainter.setDisplayString(requiredString);
      provinceRequiredPainter.setItemPainter(new FocusableItemPainter(new SelectableTextItemPainter()));
      countryRequiredPainter.setDisplayString(requiredString);
      countryRequiredPainter.setItemPainter(new FocusableItemPainter(new SelectableTextItemPainter()));
      paymentMethodRequiredPainter.setDisplayString(requiredString);
      paymentMethodRequiredPainter.setItemPainter(new FocusableItemPainter(new SelectableTextItemPainter()));
      creditCardNoRequiredPainter.setDisplayString(requiredString);
      creditCardNoRequiredPainter.setItemPainter(new FocusableItemPainter(new SelectableTextItemPainter()));
      cardExpirationDateRequiredPainter.setDisplayString(requiredString);
      cardExpirationDateColumn.setItemPainter(new FocusableItemPainter(new SelectableTextItemPainter()));

      // Set new resource bundle for localized description lookup painter
      descriptionLookupItemPainter.setResourceBundle(textRes);
      descriptionLookupItemPainter.setTextItemPainter(new SelectableTextItemPainter());
      orderLineItemDataSet.getColumn("description").setItemPainter(new FocusableItemPainter(descriptionLookupItemPainter));

      // Set new resource bundle for detail item editor and painter
      orderLineItemDetailEditor.setResourceBundle(textRes);
      orderLineItemDetailPainter.setResourceBundle(textRes);

      // 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 = productsDataSet.cloneDataSetView();
      productsDataSetView.open();
      productsDataSetView.first();

      // Add image and 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 fields to be recalculated based on new exchange rate values
      orderLineItemDataSet.recalc();

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

  /**
   * 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 records.  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();
    }
  }

  /**
   * Prevents a user from interactively deleting customer rows, by
   * throwing a VetoException() if the event occurs and
   * vetoDeletingEvent is 'true'.  Called if the user presses
   * {Ctrl-Del} from within a FieldControl attached to
   * customerDataSet.
   *
   * @param DataSet DataSet from which a row is being deleted
   * @exception Exception (VetoException) to prevent the row from being deleted
   */
  void customerDataSet_deleting(DataSet DataSet) throws Exception{
    if (vetoDeletingEvent) {
      throw new VetoException("<ignore>");
    }
  }

  /**
   * Prevents a user from interactively moving off a customer row and
   * thereby posting it by throwing a VetoException() if the event
   * occurs and vetoAddingOrUpdatingEvent is 'true'.
   *
   * Called if the user moves off a newly inserted customerDataSet
   * row by pressing [PgUp] or [PgDn] from within a FieldControl
   * attached to customerDataSet.
   *
   * @param DataSet DataSet into which a row is being added
   * @param readWriteRow new row being added
   * @exception Exception (VetoException) to prevent the row from being added
   */
  void customerDataSet_adding(DataSet DataSet, ReadWriteRow readWriteRow) throws Exception{
    if (vetoAddingOrUpdatingEvent) {
      throw new VetoException("<ignore>");
    }
  }

  /**
   * Prevents a user from interactively moving off a customer row and
   * thereby posting it by throwing a VetoException() if the event
   * occurs and vetoAddingOrUpdatingEvent is 'true'.
   * Called if the user moves off a modified, existing
   * customerDataSet row by pressing [PgUp] or [PgDn] from within a
   * FieldControl attached to customerDataSet.
   *
   * @param DataSet DataSet in which a row is being updated
   * @param readWriteRow modified row after update
   * @param readRow original row before update
   * @exception Exception (VetoException) to prevent the row from being updated
   */
  void customerDataSet_updating(DataSet DataSet, ReadWriteRow readWriteRow, ReadRow readRow) throws Exception{
    if (vetoAddingOrUpdatingEvent) {
      throw new VetoException("<ignore>");
    }
  }

  /**
   * Prevents a user from interactively inserting any new order line
   * item rows by throwing a VetoException() if the event occurs and
   * vetoInsertingEvent is 'true'.  Called if the user presses
   * [Ctrl][Ins] before editing an existing customer row from within
   * OrderFrame.java.
   *
   * @param DataSet DataSet into which a row is being inserted
   * @param readWriteRow new row being inserted
   * @exception Exception (VetoException) to prevent the row from being inserted
   */
  void customerDataSet_inserting(DataSet DataSet) throws Exception{
    if (vetoInsertingEvent) {
      throw new VetoException("<ignore>");
    }
  }

  /**
   * Prevents a user from interactively deleting any order rows by
   * throwing a VetoException() if the event occurs and vetoDeletingEvent
   * is 'true'.
   * Called if the user presses {Ctrl-Del} from within
   * a FieldControl attached to orderDataSet.
   *
   * @param DataSet DataSet from which a row is being deleted
   * @exception Exception (VetoException) to prevent the row from being deleted
   */
  void orderDataSet_deleting(DataSet DataSet) throws Exception{
    if (vetoDeletingEvent) {
      throw new VetoException("<ignore>");
    }
  }

  /**
   * Prevents a user from interactively moving off a customer row and
   * thereby posting it by throwing a VetoException() if the event
   * occurs and vetoAddingOrUpdatingEvent is 'true'.  Called if the
   * user moves off a newly inserted orderDataSet row by pressing
   * [PgUp] or [PgDn] from within a FieldControl attached to
   * orderDataSet.
   *
   * @param DataSet DataSet into which a row is being added
   * @param readWriteRow new row being added
   * @exception Exception (VetoException) to prevent the row from being added
   */
  void orderDataSet_adding(DataSet DataSet, ReadWriteRow readWriteRow) throws Exception{
    if (vetoAddingOrUpdatingEvent) {
      throw new VetoException("<ignore>");
    }
  }

  /**
   * Prevents a user from interactively deleting any order line item
   * rows by throwing a VetoException() if the event occurs and
   * vetoDeletingEvent is 'true'.
   * Called if the user presses {Ctrl-Del} from within a GridControl
   * attached to orderLineItemDataSet.
   *
   * @param DataSet DataSet from which a row is being deleted
   * @exception Exception (VetoException) to prevent the row from being deleted
   */
  void orderLineItemDataSet_deleting(DataSet DataSet) throws Exception{
    if (vetoDeletingEvent) {
      throw new VetoException("<ignore>");
    }
  }

  /**
   * Prevents a user from interactively inserting any new order line
   * item rows by throwing a VetoException() if the event occurs and
   * vetoInsertingEvent is 'true'.  Called if the user presses
   * [Ctrl][Ins] from within the GridControl attached to
   * orderLineItemDataSet.
   *
   * @param DataSet DataSet into which a row is being inserted
   * @param readWriteRow new row being inserted
   * @exception Exception (VetoException) to prevent the row from being inserted
   */
  void orderLineItemDataSet_inserting(DataSet DataSet) throws Exception{
    if (vetoInsertingEvent) {
      throw new VetoException("<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);
  }

  public void deleting(DataSet DataSet) throws Exception{
    adaptee.customerDataSet_deleting(DataSet);
  }

  public void adding(DataSet DataSet, ReadWriteRow readWriteRow) throws Exception{
    adaptee.customerDataSet_adding(DataSet, readWriteRow);
  }

  public void inserting(DataSet DataSet) throws Exception{
    adaptee.customerDataSet_inserting(DataSet);
  }

  public void updating(DataSet DataSet, ReadWriteRow readWriteRow, ReadRow readRow) throws Exception{
    adaptee.customerDataSet_updating(DataSet, readWriteRow, readRow);
  }

}

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);
  }

  public void deleting(DataSet DataSet) throws Exception{
    adaptee.orderDataSet_deleting(DataSet);
  }

  public void adding(DataSet DataSet, ReadWriteRow readWriteRow) throws Exception{
    adaptee.orderDataSet_adding(DataSet, readWriteRow);
  }

}

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_orderLineItemDataSet_editAdapter extends borland.jbcl.dataset.EditAdapter {
  AppDataModule adaptee;

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

  public void deleting(DataSet DataSet) throws Exception{
    adaptee.orderLineItemDataSet_deleting(DataSet);
  }

  public void inserting(DataSet DataSet) throws Exception{
    adaptee.orderLineItemDataSet_inserting(DataSet);
  }

}