home *** CD-ROM | disk | FTP | other *** search
/ PC World 1998 October / PCWorld_1998-10_cd.bin / software / prehled / inprise / JSAMPLES.Z / ResourceablePickListItemEditor.java < prev    next >
Encoding:
Java Source  |  1998-05-08  |  11.6 KB  |  366 lines
  1. /*
  2.  * Copyright (c) 1997-1998 Borland International, Inc. All Rights Reserved.
  3.  * 
  4.  * This SOURCE CODE FILE, which has been provided by Borland as part
  5.  * of a Borland product for use ONLY by licensed users of the product,
  6.  * includes CONFIDENTIAL and PROPRIETARY information of Borland.  
  7.  *
  8.  * USE OF THIS SOFTWARE IS GOVERNED BY THE TERMS AND CONDITIONS 
  9.  * OF THE LICENSE STATEMENT AND LIMITED WARRANTY FURNISHED WITH
  10.  * THE PRODUCT.
  11.  *
  12.  * IN PARTICULAR, YOU WILL INDEMNIFY AND HOLD BORLAND, ITS RELATED
  13.  * COMPANIES AND ITS SUPPLIERS, HARMLESS FROM AND AGAINST ANY CLAIMS
  14.  * OR LIABILITIES ARISING OUT OF THE USE, REPRODUCTION, OR DISTRIBUTION
  15.  * OF YOUR PROGRAMS, INCLUDING ANY CLAIMS OR LIABILITIES ARISING OUT OF
  16.  * OR RESULTING FROM THE USE, MODIFICATION, OR DISTRIBUTION OF PROGRAMS
  17.  * OR FILES CREATED FROM, BASED ON, AND/OR DERIVED FROM THIS SOURCE
  18.  * CODE FILE.
  19.  */
  20. package borland.samples.intl.beans;
  21.  
  22. import java.awt.*;
  23. import java.awt.event.*;
  24. import java.util.*;
  25.  
  26. import borland.jbcl.util.*;
  27. import borland.jbcl.model.*;
  28. import borland.jbcl.view.*;
  29. import borland.jbcl.dataset.*;
  30.  
  31. /**
  32.  * ResourceablePickListItemEditor is a modified version of the JBCL
  33.  * PickListItemEditor which optionally treats items from the picklist
  34.  * dataset as keys which can be looked up in a specified resource
  35.  * bundle.  See borland.jbcl.control.PickListItemEditor for more
  36.  * info about picklists.
  37.  */
  38. public class ResourceablePickListItemEditor extends java.awt.Panel implements borland.jbcl.model.ItemEditor, ItemListener, KeyListener, BlackBox
  39. {
  40.   public ResourceablePickListItemEditor() {
  41.     super();
  42.     this.setVisible(false);
  43.     this.setLayout(new BorderLayout());
  44.     cache = true;
  45.     value = new Variant();
  46.     resourceBundle = null;
  47.     choice.addItemListener(this);
  48.     choice.addKeyListener(this);
  49.   }
  50.  
  51.   /**
  52.    * The CachePickList property determines whether or not values from the
  53.    * display ("picklist") DataSet are cached.  If the column of
  54.    * display choices from which to choose is subject to frequent change, setting
  55.    * this property false will ensure that the most recent list of choices
  56.    * will be displayed when the PickListItemEditor is invoked.  For performance, 
  57.    * this property is true by default.
  58.    */
  59.   public final void setCachePickList(boolean cache) {
  60.     this.cache  = cache;
  61.   }
  62.  
  63.   public final boolean isCachePickList() {
  64.     return cache;
  65.   }
  66.  
  67.   /**
  68.    * Sets a RowFilterListener on the picklist dataset.
  69.    * By specifying a RowFilterListener and setting Cache false,
  70.    * you can dynamically change the list of values displayed
  71.    * by PickListItemEditor through the row filter.
  72.    */
  73.   public final void addRowFilterListener(RowFilterListener listener)
  74.     throws TooManyListenersException
  75.   {
  76.     if (listener == null) {
  77.       throw new IllegalArgumentException();
  78.     }
  79.  
  80.     if (this.listener != null) {
  81.       throw new TooManyListenersException();
  82.     }
  83.  
  84.     this.listener = listener;
  85.     if (pickListDataSet != null) {
  86.       pickListDataSet.addRowFilterListener(listener);
  87.     }
  88.   }
  89.  
  90.   public final void removeRowFilterListener(RowFilterListener listener) {
  91.     this.listener = null;
  92.     if (pickListDataSet != null) {
  93.       pickListDataSet.removeRowFilterListener(listener);
  94.     }
  95.   }
  96.  
  97.  
  98.   /**
  99.    * Sets the resource bundle in which to look up items to display.
  100.    *
  101.    * @param resourceBundle resourceBundle to use for key lookups
  102.    */
  103.   public void setResourceBundle(ResourceBundle resourceBundle) {
  104.     this.resourceBundle = resourceBundle;
  105.   }
  106.  
  107.   /**
  108.    * Returns the resource bundle used to look up resource keys.
  109.    *
  110.    * @return resource bundle for key lookups.
  111.    */
  112.   public ResourceBundle getResourceBundle() {
  113.     return resourceBundle;
  114.   }
  115.  
  116.   // loadPickList() is called by startEdit() when a user begins
  117.   // editing the control.  It has the side effect of extracting the
  118.   // pickListDescriptor info into class variables.
  119.   protected void loadPickList(PickListDescriptor pickList) {
  120.     if (pickListDataSet == null || !cache) {
  121.       setVisible(true);
  122.       setCursor(Cursor.getPredefinedCursor(Cursor.WAIT_CURSOR));
  123.       try {
  124.         if (pickListDataSet == null) {
  125.           pickListDataSet = new DataSetView();
  126.           if (listener != null) {
  127.             pickListDataSet.addRowFilterListener(listener);
  128.           }
  129.           // if pickList.getPickListDataSet() returns null, we'll catch
  130.           // the NPE below and set pickListDataSet to be null.  startEdit()
  131.           // checks if this is the case and if so, immediately cancels
  132.           // the edit.
  133.           pickListDataSet.setStorageDataSet(pickList.getPickListDataSet().getStorageDataSet());
  134.           sourceColumns = pickList.getPickListColumns();
  135.           targetColumns = pickList.getDestinationColumns();
  136.           displayColumns = pickList.getPickListDisplayColumns();
  137.           // if any of the columns are null or don't have at least one
  138.           // column specified, then setting pickListDataSet null and
  139.           // returning will cause startEdit() to immediately cancel
  140.           // the edit.
  141.           if ((sourceColumns == null) || (sourceColumns.length == 0) ||
  142.               (targetColumns == null) || (targetColumns.length == 0) ||
  143.               (displayColumns == null) || (displayColumns.length == 0)) {
  144.             pickListDataSet = null;
  145.             return;
  146.           }
  147.         }
  148.         pickListDataSet.open();
  149. //        locateRow = new DataRow(pickListDataSet, sourceColumns[0]);
  150.  
  151.         if (!cache) {
  152.           choice.removeAll();
  153.         }
  154.         int ordinal = pickListDataSet.getColumn(displayColumns[0]).getOrdinal();
  155.         if (listener != null) {
  156.           pickListDataSet.refilter();
  157.         }
  158.         pickListDataSet.first();
  159.         while(pickListDataSet.inBounds()) {
  160.           if (resourceBundle == null) {
  161.             choice.add(pickListDataSet.format(ordinal));
  162.           } else {
  163.             choice.add(resourceBundle.getString(pickListDataSet.format(ordinal)));
  164.           }
  165.           pickListDataSet.next();
  166.         }
  167.         // in case cache is false (and loadPickList is called more than
  168.         // once), don't add the choice again to the panel
  169.         if (getComponentCount() == 0) {
  170.           add(choice, BorderLayout.CENTER);
  171.         }
  172.  
  173.       }
  174.       catch(Exception ex) {
  175.         pickListDataSet = null;
  176.         DataSetException.handleException(ex);
  177.       }
  178.       setCursor(Cursor.getPredefinedCursor(Cursor.DEFAULT_CURSOR));
  179.     }
  180.   }
  181.  
  182.   public Object getValue() {
  183.  
  184.     if (pickListDataSet != null) {
  185.       try {
  186.         // Go to the row in the PickListDataSet corresponding to
  187.         // the row selected by the user.
  188.         pickListDataSet.goToRow(choice.getSelectedIndex());
  189.  
  190.         // Copy the PickList columns to the corresponding destination columns.
  191.         ReadRow.copyTo(sourceColumns, pickListDataSet, targetColumns, targetDataSet);
  192.  
  193.         // If the current column is one of the picklist target columns,
  194.         // then return that value, otherwise simply return the original
  195.         // value.
  196.         for (int index = 0; index < targetColumns.length; index++) {
  197.           if (targetColumns[index].equalsIgnoreCase(currentColumnName)) {
  198.             pickListDataSet.getVariant(sourceColumns[0], value);
  199.             break;
  200.           }
  201.         }
  202.         return value;
  203.       }
  204.       catch(DataSetException ex) {
  205.         value.setUnassignedNull();
  206.         DataSetException.handleException(ex);
  207.       }
  208.     }
  209.     return value;
  210.   }
  211.  
  212.   public Component getComponent() {
  213.     return this;
  214.   }
  215.  
  216.   public void startEdit(Object data, Rectangle bounds, ItemEditSite editSite) {
  217.     Column currentColumn = null;
  218.     ColumnVariant currentColumnVariant = null;
  219.  
  220.     setBounds(bounds.x, bounds.y, bounds.width, bounds.height);
  221.     this.editSite = editSite;
  222.  
  223.     if (data instanceof ColumnVariant) {
  224.       currentColumnVariant = (ColumnVariant)data;
  225.       value.setVariant(currentColumnVariant);
  226.       currentColumn  = currentColumnVariant.getColumn();
  227.       currentColumnName = currentColumn.getColumnName();
  228.       targetDataSet = currentColumnVariant.getDataSet();
  229.       loadPickList(currentColumn.getPickList());
  230.       // if there was a problem with information in the PickListDescriptor,
  231.       // then quietly cancel the edit.
  232.       if (pickListDataSet == null) {
  233.         editSite.safeEndEdit(false);
  234.       }
  235.     }
  236.  
  237.     if (pickListDataSet != null && locateRow != null) {
  238.       try {
  239.         locateRow = new DataRow(pickListDataSet, sourceColumns[0]);
  240.         locateRow.setVariant(sourceColumns[0], currentColumnVariant);
  241.         // Doing a locate() on the pickListDataSet should move the
  242.         // current row to the target row if it exists.
  243.         // We need to select() the corresponding row as an
  244.         // index into the choices in the Choice (only if the locate
  245.         // succeeds, i.e., the value exists in the dataset).
  246.         if (pickListDataSet.locate(locateRow, Locate.FIRST)) {
  247.           choice.select(pickListDataSet.getRow());
  248.         }
  249.       } catch (DataSetException ex) {
  250.         DataSetException.handleException(ex);
  251.       }
  252.     }
  253.  
  254.     choice.invalidate();
  255.  
  256.     if (editSite != null) {
  257.       choice.setBackground(editSite.getBackground());
  258.       choice.setForeground(editSite.getForeground());
  259.       choice.setFont(editSite.getFont());
  260.     }
  261.  
  262.     validate();
  263.     setVisible(true);
  264.  
  265.     choice.requestFocus();
  266.  
  267.   }
  268.  
  269.  
  270.   public void changeBounds(Rectangle bounds) {
  271.     choice.invalidate();
  272.     setBounds(bounds.x, bounds.y, bounds.width, bounds.height);
  273.     validate();
  274.   }
  275.  
  276.  
  277.   public boolean canPost() {
  278.     return true;
  279.   }
  280.  
  281.   public void endEdit(boolean post) {
  282.     setBounds(0,0,0,0);
  283.     setVisible(false);
  284.   }
  285.  
  286.   public void keyTyped(KeyEvent e) {
  287.   }
  288.  
  289.   public void keyPressed(KeyEvent e) {
  290.     int code = e.getKeyCode();
  291.     int sel = choice.getSelectedIndex();
  292.     switch (code) {
  293.       case e.VK_DOWN:
  294.       case e.VK_RIGHT:
  295.         if (sel < (choice.getItemCount() - 1)) {
  296.           choice.select(sel + 1);
  297.         }
  298.         e.consume();
  299.         break;
  300.       case e.VK_LEFT:
  301.       case e.VK_UP:
  302.         if (sel > 0) {
  303.           choice.select(sel - 1);
  304.         }
  305.         e.consume();
  306.         break;
  307.       case e.VK_HOME:
  308.         choice.select(0);
  309.         e.consume();
  310.         break;
  311.       case e.VK_END:
  312.         choice.select(choice.getItemCount() - 1);
  313.         e.consume();
  314.         break;
  315.       case e.VK_PAGE_DOWN:
  316.         choice.select(Math.min(sel + 10, choice.getItemCount() - 1));
  317.         e.consume();
  318.         break;
  319.       case e.VK_PAGE_UP:
  320.         choice.select(Math.max(sel - 10, 0));
  321.         e.consume();
  322.         break;
  323.     }
  324.   }
  325.  
  326.   public void keyReleased(KeyEvent e) {
  327.   }
  328.  
  329.   public void addKeyListener(KeyListener l) {
  330.     choice.addKeyListener(l);
  331.   }
  332.  
  333.   public void removeKeyListener(KeyListener l) {
  334.     choice.removeKeyListener(l);
  335.   }
  336.  
  337.   public void addFocusListener(FocusListener l) {
  338.     choice.addFocusListener(l);
  339.   }
  340.  
  341.   public void removeFocusListener(FocusListener l) {
  342.     choice.removeFocusListener(l);
  343.   }
  344.  
  345.   public void itemStateChanged(ItemEvent e) {
  346.     if (e.getID() == ItemEvent.ITEM_STATE_CHANGED) {
  347.       editSite.safeEndEdit(true);
  348.     }
  349.   }
  350.  
  351.   String        currentColumnName;
  352.   String []     sourceColumns;
  353.   String []     targetColumns;
  354.   Column []     pickListColumns;
  355.   String []     displayColumns;
  356.   DataSetView   pickListDataSet;
  357.   DataSet       targetDataSet;
  358.   DataRow       locateRow;
  359.   boolean       cache;
  360.   Variant       value;
  361.   Choice        choice = new Choice();
  362.   RowFilterListener listener;
  363.   ItemEditSite  editSite;
  364.   ResourceBundle resourceBundle;
  365. }
  366.