CD Actual Thematic 7: Programming/CDAT7.iso/Share/Java/JDesignerPro/Jdp3_0.exe/data1.cab/Program_Files/JDPTextGrid.class

Java Class File | 1999-04-09 | 44.7 KB | 3,799 lines

import java.awt.Color;
import java.awt.Component;
import java.awt.Container;
import java.awt.Dimension;
import java.awt.Event;
import java.awt.Font;
import java.awt.FontMetrics;
import java.awt.Graphics;
import java.awt.Image;
import java.awt.Insets;
import java.awt.List;
import java.awt.Panel;
import java.awt.Rectangle;
import java.awt.Scrollbar;
import java.awt.image.ImageObserver;
import java.util.Date;
import java.util.StringTokenizer;
import java.util.Vector;

public class JDPTextGrid extends Panel {
   JDPUser user;
   Scrollbar scrollEast;
   Scrollbar scrollSouth;
   Image offscreen;
   Rectangle offscreensize;
   Event thisEvent;
   JDPMaskEdit JDPMaskEditMain;
   String[][] currentText;
   String[][] rowKey;
   String[] recordLockValue;
   String[] editMask;
   String[] editMaskType;
   int currentSelectedRow;
   int currentSelectedColumn;
   boolean[] columnSelected;
   boolean[] rowSelected;
   boolean[][] cellSelected;
   boolean[][] cellChanged;
   Font[][] cellFont;
   Color[][] cellColor;
   boolean[] rowChanged;
   int[] columnWidth;
   int[] columnHeight;
   boolean[] rightJustify;
   boolean columnHeaderOn = true;
   String[] columnHeader;
   int[] columnHeaderStyle;
   int[] columnStyle;
   Color[] columnHeaderColor;
   Color[] columnColor;
   Color[] columnBGColor;
   boolean[] columnProtected;
   boolean[][] fieldProtected;
   boolean[] columnDisabled;
   boolean[][] fieldDisabled;
   boolean[] sortDescending;
   int lockedColumns;
   boolean scrollEastDisabled;
   boolean scrollSouthDisabled;
   Scrollbar pullDownScroll;
   int[][] fieldType;
   int[] fieldTypeCol;
   int[][] spinnerMin;
   int[][] spinnerMax;
   boolean[][] isPullDown;
   boolean[] isPullDownCol;
   int[][] pullDownType;
   int[] pullDownColType;
   Rectangle pullDownRect;
   boolean isPulledDown;
   List[][] pullDownList;
   JDPList pullDownDisplayList;
   Vector[][] pullDownValue;
   JDPCalendarPicker calendar;
   JDPPopupComponent popup;
   int xindexpulldown;
   int yindexpulldown;
   int xpulldown;
   int ypulldown;
   int wpulldown;
   int hpulldown;
   Rectangle[] pullDownCells;
   int columnHeaderHeight;
   int columnHeadHeight;
   int lastFontHeight;
   boolean rowHeaderOn = true;
   String[] rowHeader;
   String rowHeadJustify;
   int rowHeaderWidth = 25;
   int rowHeadWidth;
   Color[][] rowGridColor;
   Color[][] columnGridColor;
   int[] columnOrder;
   Color gridColor;
   int minimumWidth = 60;
   int minimumHeight = 60;
   String clipBoard = "";
   boolean[][] cursorInThisField;
   boolean fieldSelected;
   boolean[][] saveColumnSelected;
   char[] buffer;
   int nChars;
   int maxchars = 30;
   boolean highlight;
   // $FF: renamed from: gr java.awt.Graphics
   Graphics field_0;
   Rectangle[][] mouseRect;
   Rectangle[] colButton;
   Rectangle[] rowButton;
   Rectangle[] colHeadRect;
   Rectangle[] rowHeadRect;
   int totalColumns;
   int totalRows;
   int totalDataRows;
   int currentColumn;
   int currentRow;
   int prevColumn;
   int prevRow;
   int cursorColumn;
   int cursorRow;
   int xOffset;
   int yOffset;
   int originalxOffset;
   int displayedColumns;
   int displayedRows;
   int dragCount;
   boolean draggingColMouse;
   boolean draggingColButton;
   boolean columnMoved;
   int saveColumnWidth;
   int currentXpos;
   int columnButtonOffset;
   int dragCol;
   int initColXpoint;
   boolean draggingRowMouse;
   int saveColumnHeight;
   int dragRow;
   int initRowYpoint;
   Rectangle Bounds;
   int[] widths;
   Font lastFont;
   Font lastPlainFont;
   Font plainFont;
   Font boldFont;
   // $FF: renamed from: fm java.awt.FontMetrics
   FontMetrics field_1;
   boolean thisGridOnly;
   int initSelectColumn = -1;
   int initSelectRow = -1;
   boolean mousePressed;
   int lastpos;
   int thisSubstring;
   int selectedFrom;
   int selectedTo;
   int cursorPos;
   int initcursorPos;
   int lastevtx;
   int lastevty;
   boolean paintAll;
   boolean fieldDisplay;
   int visColumns;
   int visRows;
   boolean nothingChanged;
   Dimension prevSize;
   String[] maskEdit;
   String[] maskType;
   String searchString = "";
   boolean sortingEnabled;
   Color textHighlightText;
   Color textHighlight;
   Color back;
   Component[][] customPopup;
   Rectangle upButton;
   Rectangle downButton;
   Rectangle checkboxRect;
   public static final int COLUMN_MOVED = 10001;
   public static final int COLUMN_RESIZED = 10002;
   public static final int ROW_RESIZED = 10003;
   public static final int TEXTFIELD = 0;
   public static final int PULLDOWN = 1;
   public static final int SPINNER = 2;
   public static final int CHECKBOX = 3;
   public static final int REGULAR = 0;
   public static final int DATE = 1;
   public static final int CUSTOM = 2;
   public static final int EXTENDED_REGULAR = 3;

   void repaintColHead(int var1, int var2) {
      if (this.draggingColMouse) {
         if (var1 < 0) {
            this.rowHeaderWidth = this.saveColumnWidth + var2 - this.initColXpoint;
            ((Component)this).repaint(1, 5, this.Bounds.width, this.columnHeadHeight + 1);
         } else if (this.saveColumnWidth + var2 - this.initColXpoint > 10) {
            this.columnWidth[this.columnOrder[var1 + this.xOffset]] = this.saveColumnWidth + var2 - this.initColXpoint;
            ((Component)this).repaint(this.initColXpoint - this.saveColumnWidth, 5, this.Bounds.width, this.columnHeadHeight + 1);
         }
      } else if (var1 < 0) {
         this.rowHeaderWidth = this.saveColumnWidth + var2 - this.initColXpoint;
         ((Component)this).repaint(1, 5, this.Bounds.width, this.columnHeadHeight + 1);
      } else {
         this.currentXpos = var2;
         ((Component)this).repaint(this.rowHeadWidth, 5, this.Bounds.width, this.columnHeadHeight + 1);
      }

      this.nothingChanged = false;
   }

   void repaintRowHead(int var1, int var2) {
      if (var1 < 0) {
         this.columnHeaderHeight = this.saveColumnHeight + var2 - this.initRowYpoint;
         ((Component)this).repaint();
      } else {
         if (this.saveColumnHeight + var2 - this.initRowYpoint > 15) {
            this.columnHeight[var1 + this.yOffset] = this.saveColumnHeight + var2 - this.initRowYpoint;
            ((Component)this).repaint();
         }

      }
   }

   public void setSpinnerMax(int var1, int var2, int var3) {
      this.setFieldType(var1, var2, 2);
      this.spinnerMax[var1][var2] = var3 - 999999999;
      this.reDraw();
   }

   public void sortItems(boolean var1, int var2, boolean var3) {
      Object var4 = null;
      int var5 = 0;
      float var7 = -9999999.0F;
      float var8 = 0.0F;
      long var9 = -9999999L;
      long[] var11 = null;
      if (this.pullDownColType[var2] == 1) {
         var11 = new long[this.totalRows];

         for(int var22 = 0; var22 < this.totalRows; ++var22) {
            var11[var22] = 0L;
            String var6 = this.currentText[var2][var22];
            if (var6 != null && !var6.equals("")) {
               var11[var22] = JDPDate.unformat(var6).getTime();
            }
         }
      }

      int var42 = this.totalRows;

      for(int var23 = 0; var23 < var42; ++var23) {
         var5 = var23;
         String var28 = null;
         var9 = -9999999L;
         var7 = -9999999.0F;

         for(int var24 = var23; var24 < var42; ++var24) {
            boolean var25 = true;

            for(int var26 = 0; var26 < this.totalColumns; ++var26) {
               if (this.currentText[var26][var24] != null && !this.currentText[var26][var24].equals("")) {
                  var25 = false;
                  break;
               }
            }

            if (!var25) {
               String var30 = this.currentText[var2][var24];
               if (var30 == null) {
                  var30 = "";
               }

               if (this.rightJustify[var2]) {
                  try {
                     var8 = Float.valueOf(var30);
                  } catch (Exception var27) {
                     var8 = 0.0F;
                  }

                  if (var7 == -9999999.0F || !var3 && var8 < var7 || var3 && var8 > var7) {
                     var7 = var8;
                     var5 = var24;
                  }
               } else if (this.pullDownColType[var2] == 1) {
                  if (var9 == -9999999L || !var3 && var11[var24] < var9 || var3 && var11[var24] > var9) {
                     var9 = var11[var24];
                     var5 = var24;
                  }
               } else {
                  if (var1) {
                     var30 = var30.toLowerCase();
                  }

                  if (var28 == null || !var3 && var30.compareTo(var28) < 0 || var3 && var30.compareTo(var28) > 0) {
                     var28 = var30;
                     var5 = var24;
                  }
               }
            }
         }

         if (var23 < var5 || var5 != -1) {
            boolean var12 = this.rowChanged[var23];
            this.rowChanged[var23] = this.rowChanged[var5];
            this.rowChanged[var5] = var12;
            int var13 = this.columnHeight[var23];
            this.columnHeight[var23] = this.columnHeight[var5];
            this.columnHeight[var5] = var13;
            if (var11 != null) {
               long var14 = var11[var23];
               var11[var23] = var11[var5];
               var11[var5] = var14;
            }

            if (!this.rowHeader[0].equals("0")) {
               String var16 = this.rowHeader[var23];
               this.rowHeader[var23] = this.rowHeader[var5];
               this.rowHeader[var5] = var16;
            }

            for(int var43 = 0; var43 < this.totalColumns; ++var43) {
               String var38 = this.currentText[var43][var23];
               this.currentText[var43][var23] = this.currentText[var43][var5];
               this.currentText[var43][var5] = var38;
               Color var18 = this.cellColor[var43][var23];
               this.cellColor[var43][var23] = this.cellColor[var43][var5];
               this.cellColor[var43][var5] = var18;
               Font var17 = this.cellFont[var43][var23];
               this.cellFont[var43][var23] = this.cellFont[var43][var5];
               this.cellFont[var43][var5] = var17;
               var18 = this.rowGridColor[var43][var23];
               this.rowGridColor[var43][var23] = this.rowGridColor[var43][var5];
               this.rowGridColor[var43][var5] = var18;
               var18 = this.columnGridColor[var43][var23];
               this.columnGridColor[var43][var23] = this.columnGridColor[var43][var5];
               this.columnGridColor[var43][var5] = var18;
               var12 = this.fieldProtected[var43][var23];
               this.fieldProtected[var43][var23] = this.fieldProtected[var43][var5];
               this.fieldProtected[var43][var5] = var12;
               var12 = this.fieldDisabled[var43][var23];
               this.fieldDisabled[var43][var23] = this.fieldDisabled[var43][var5];
               this.fieldDisabled[var43][var5] = var12;
               var12 = this.isPullDown[var43][var23];
               this.isPullDown[var43][var23] = this.isPullDown[var43][var5];
               this.isPullDown[var43][var5] = var12;
               var13 = this.pullDownType[var43][var23];
               this.pullDownType[var43][var23] = this.pullDownType[var43][var5];
               this.pullDownType[var43][var5] = var13;
               if (this.pullDownList[var43].length > 1) {
                  List var20 = this.pullDownList[var43][var23];
                  this.pullDownList[var43][var23] = this.pullDownList[var43][var5];
                  this.pullDownList[var43][var5] = var20;
                  Vector var19 = this.pullDownValue[var43][var23];
                  this.pullDownValue[var43][var23] = this.pullDownValue[var43][var5];
                  this.pullDownValue[var43][var5] = var19;
               }

               if (this.customPopup[var43].length > 1) {
                  Component var21 = this.customPopup[var43][var23];
                  this.customPopup[var43][var23] = this.customPopup[var43][var5];
                  this.customPopup[var43][var5] = var21;
               }
            }

            if (this.rowKey != null) {
               for(int var44 = 0; var44 < this.rowKey[0].length; ++var44) {
                  String var39 = this.rowKey[var23][var44];
                  this.rowKey[var23][var44] = this.rowKey[var5][var44];
                  this.rowKey[var5][var44] = var39;
               }
            }
         }
      }

      this.reDraw();
   }

   int[] getWidths() {
      this.field_1 = this.field_0.getFontMetrics();
      this.widths = this.field_1.getWidths();
      return this.widths;
   }

   public int getSpinnerMax(int var1, int var2) {
      return this.spinnerMax[var1][var2] + 999999999;
   }

   public void setColumnHeaderHeight(int var1) {
      this.columnHeaderHeight = var1;
      this.reDraw();
   }

   public int getColumnHeaderHeight() {
      return this.columnHeaderHeight;
   }

   public void setColumnSelected(int var1, boolean var2) {
      this.columnSelected[var1] = var2;

      for(int var3 = 0; var3 < this.totalRows; ++var3) {
         this.cellSelected[var1][var3] = var2;
      }

      this.currentSelectedColumn = var1;
      this.reDraw();
   }

   public boolean getColumnSelected(int var1) {
      return this.columnSelected[var1];
   }

   public void setGridColor(Color var1) {
      this.gridColor = var1;
      this.reDraw();
   }

   public Color getGridColor() {
      return this.gridColor;
   }

   public void newTable() {
      if (this.currentText == null || this.currentText.length < 1) {
         this.currentText = new String[50][50];
      }

      this.totalColumns = this.currentText.length;
      this.totalRows = this.currentText[0].length;
      if (this.editMask == null || this.editMask.length != this.totalColumns) {
         this.editMask = new String[this.totalColumns];
      }

      if (this.editMaskType == null || this.editMaskType.length != this.totalColumns) {
         this.editMaskType = new String[this.totalColumns];
      }

      if (this.columnSelected == null || this.cellSelected.length != this.totalColumns) {
         this.columnSelected = new boolean[this.totalColumns];
      }

      if (this.recordLockValue == null || this.recordLockValue.length != this.totalRows) {
         this.recordLockValue = new String[this.totalRows];
      }

      if (this.rowSelected == null || this.rowSelected.length != this.totalRows) {
         this.rowSelected = new boolean[this.totalRows];
      }

      if (this.cellSelected == null || this.cellSelected.length != this.totalColumns || this.cellSelected[0].length != this.totalRows) {
         this.cellSelected = new boolean[this.totalColumns][this.totalRows];
      }

      if (this.cellChanged == null || this.cellChanged.length != this.totalColumns || this.cellChanged[0].length != this.totalRows) {
         this.cellChanged = new boolean[this.totalColumns][this.totalRows];
      }

      if (this.cellColor == null || this.cellColor.length != this.totalColumns || this.cellColor[0].length != this.totalRows) {
         this.cellColor = new Color[this.totalColumns][this.totalRows];
      }

      if (this.cellFont == null || this.cellFont.length != this.totalColumns || this.cellFont[0].length != this.totalRows) {
         this.cellFont = new Font[this.totalColumns][this.totalRows];
      }

      if (this.rowGridColor == null || this.rowGridColor.length != this.totalColumns || this.rowGridColor[0].length != this.totalRows) {
         this.rowGridColor = new Color[this.totalColumns][this.totalRows];
      }

      if (this.columnGridColor == null || this.columnGridColor.length != this.totalColumns || this.columnGridColor[0].length != this.totalRows) {
         this.columnGridColor = new Color[this.totalColumns][this.totalRows];
      }

      if (this.rowChanged == null || this.rowChanged.length != this.totalRows) {
         this.rowChanged = new boolean[this.totalRows];
      }

      if (this.rightJustify == null || this.rightJustify.length != this.totalColumns) {
         this.rightJustify = new boolean[this.totalColumns];
      }

      if (this.columnHeader == null || this.columnHeader.length != this.totalColumns) {
         this.columnHeader = new String[this.totalColumns];

         for(int var1 = 0; var1 < this.totalColumns; ++var1) {
            this.columnHeader[var1] = Integer.toString(var1);
         }
      }

      if (this.columnHeaderStyle == null || this.columnHeaderStyle.length != this.totalColumns) {
         this.columnHeaderStyle = new int[this.totalColumns];

         for(int var4 = 0; var4 < this.totalColumns; ++var4) {
            this.columnHeaderStyle[var4] = 1;
         }
      }

      if (this.columnStyle == null || this.columnStyle.length != this.totalColumns) {
         this.columnStyle = new int[this.totalColumns];

         for(int var5 = 0; var5 < this.totalColumns; ++var5) {
            this.columnStyle[var5] = 0;
         }
      }

      if (this.columnHeaderColor == null || this.columnHeaderColor.length != this.totalColumns) {
         this.columnHeaderColor = new Color[this.totalColumns];

         for(int var6 = 0; var6 < this.totalColumns; ++var6) {
            this.columnHeaderColor[var6] = Color.black;
         }
      }

      if (this.columnColor == null || this.columnColor.length != this.totalColumns) {
         this.columnColor = new Color[this.totalColumns];

         for(int var7 = 0; var7 < this.totalColumns; ++var7) {
            this.columnColor[var7] = Color.black;
         }
      }

      if (this.columnBGColor == null || this.columnBGColor.length != this.totalColumns) {
         this.columnBGColor = new Color[this.totalColumns];

         for(int var8 = 0; var8 < this.totalColumns; ++var8) {
            this.columnBGColor[var8] = Color.white;
         }
      }

      if (this.columnProtected == null || this.columnProtected.length != this.totalColumns) {
         this.columnProtected = new boolean[this.totalColumns];
      }

      if (this.fieldProtected == null || this.fieldProtected.length != this.totalColumns || this.fieldProtected[0].length != this.totalRows) {
         this.fieldProtected = new boolean[this.totalColumns][this.totalRows];
      }

      if (this.columnDisabled == null || this.columnDisabled.length != this.totalColumns) {
         this.columnDisabled = new boolean[this.totalColumns];
      }

      if (this.fieldDisabled == null || this.fieldDisabled.length != this.totalColumns || this.fieldDisabled[0].length != this.totalRows) {
         this.fieldDisabled = new boolean[this.totalColumns][this.totalRows];
      }

      if (this.sortDescending == null || this.sortDescending.length != this.totalColumns) {
         this.sortDescending = new boolean[this.totalColumns];
      }

      if (this.fieldType == null || this.fieldType.length != this.totalColumns || this.fieldType[0].length != this.totalRows) {
         this.fieldType = new int[this.totalColumns][this.totalRows];
      }

      if (this.fieldTypeCol == null || this.fieldTypeCol.length != this.totalColumns) {
         this.fieldTypeCol = new int[this.totalColumns];
      }

      if (this.spinnerMin == null || this.spinnerMin.length != this.totalColumns || this.spinnerMin[0].length != this.totalRows) {
         this.spinnerMin = new int[this.totalColumns][this.totalRows];
      }

      if (this.spinnerMax == null || this.spinnerMax.length != this.totalColumns || this.spinnerMax[0].length != this.totalRows) {
         this.spinnerMax = new int[this.totalColumns][this.totalRows];
      }

      if (this.isPullDown == null || this.isPullDown.length != this.totalColumns || this.isPullDown[0].length != this.totalRows) {
         this.isPullDown = new boolean[this.totalColumns][this.totalRows];
      }

      if (this.isPullDownCol == null || this.isPullDownCol.length != this.totalColumns) {
         this.isPullDownCol = new boolean[this.totalColumns];
      }

      if (this.pullDownType == null || this.pullDownType.length != this.totalColumns || this.pullDownType[0].length != this.totalRows) {
         this.pullDownType = new int[this.totalColumns][this.totalRows];
      }

      if (this.pullDownColType == null || this.pullDownColType.length != this.totalColumns) {
         this.pullDownColType = new int[this.totalColumns];
      }

      if (this.pullDownList == null || this.pullDownList.length != this.totalColumns) {
         this.pullDownList = new List[this.totalColumns][this.totalRows];
      }

      if (this.pullDownValue == null || this.pullDownValue.length != this.totalColumns) {
         this.pullDownValue = new Vector[this.totalColumns][this.totalRows];
      }

      if (this.customPopup == null || this.customPopup.length != this.totalColumns || this.customPopup[0].length != this.totalRows) {
         this.customPopup = new Component[this.totalColumns][this.totalRows];
      }

      if (this.rowHeader == null || this.rowHeader.length != this.totalRows) {
         this.rowHeader = new String[this.totalRows];

         for(int var9 = 0; var9 < this.totalRows; ++var9) {
            this.rowHeader[var9] = Integer.toString(var9);
         }
      }

      if (this.columnWidth == null || this.columnWidth.length != this.totalColumns) {
         this.columnWidth = new int[this.totalColumns];

         for(int var10 = 0; var10 < this.totalColumns; ++var10) {
            this.columnWidth[var10] = 100;
         }
      }

      if (this.columnHeight == null || this.columnHeight.length != this.totalRows) {
         this.columnHeight = new int[this.totalRows];

         for(int var11 = 0; var11 < this.totalRows; ++var11) {
            this.columnHeight[var11] = 18;
         }
      }

      if (this.columnOrder == null || this.columnOrder.length != this.totalColumns) {
         this.columnOrder = new int[this.totalColumns];

         for(int var12 = 0; var12 < this.totalColumns; this.columnOrder[var12] = var12++) {
         }
      }

      if (this.field_0 != null) {
         for(int var13 = 0; var13 < this.totalRows; ++var13) {
            this.field_0.setFont(this.boldFont);
            this.columnHeight[var13] = this.StringHeight() + 3;

            for(int var2 = 0; var2 < this.totalColumns; ++var2) {
               if (this.cellFont[var2][var13] != null) {
                  this.field_0.setFont(this.cellFont[var2][var13]);
                  int var3 = this.StringHeight();
                  if (var3 > this.columnHeight[var13]) {
                     this.columnHeight[var13] = var3 + 2;
                  }
               }
            }
         }
      }

      this.buffer = new char[this.maxchars];
      this.mouseRect = new Rectangle[this.totalColumns][this.totalRows];
      this.colButton = new Rectangle[this.totalColumns];
      this.rowButton = new Rectangle[this.totalRows];
      this.colHeadRect = new Rectangle[this.totalColumns + 1];
      this.rowHeadRect = new Rectangle[this.totalRows + 1];
      this.cursorInThisField = new boolean[this.totalColumns][this.totalRows];
      this.saveColumnSelected = new boolean[this.totalColumns][this.totalRows];
      if (this.currentColumn >= this.totalColumns) {
         this.currentColumn = 0;
      }

      if (this.currentRow >= this.totalRows) {
         this.currentRow = 0;
      }

      if (this.scrollEast != null) {
         this.scrollEast.setValue(0);
      }

      if (this.scrollSouth != null) {
         this.scrollSouth.setValue(0);
      }

      this.visColumns = 0;
      this.visRows = 0;
      this.xOffset = 0;
      this.yOffset = 0;
      this.isPulledDown = false;
      this.nothingChanged = false;
      ((Component)this).repaint();
   }

   public void setFieldTypeCol(int var1, int var2) {
      this.fieldTypeCol[var1] = var2;
      this.setPullDownCol(var1, var2 == 1);
      if (var2 == 3) {
         this.setColumnProtected(var1, true);
      }

      this.reDraw();
   }

   public int getCurrentRow() {
      return this.currentRow;
   }

   public int getCurrentColumn() {
      return this.currentColumn;
   }

   public int getFieldTypeCol(int var1) {
      return this.fieldTypeCol[var1];
   }

   public void layout() {
      ((Component)this).repaint();
   }

   void drawSelectedField(int var1, int var2, int var3, int var4, int var5, int var6) {
      int var7 = this.columnOrder[this.currentColumn];
      if (this.isPulledDown && this.currentText[var1][var2].equals("") && (this.isPullDown[var7][this.getPulldownRow(var7, this.currentRow)] || this.isPullDownCol[var7])) {
         if (this.pullDownType[var7][this.getPulldownRow(var7, this.currentRow)] != 1 && this.pullDownColType[var7] != 1) {
            if (this.pullDownType[var7][this.getPulldownRow(var7, this.currentRow)] != 2 && this.pullDownColType[var7] != 2 && this.pullDownList[var7][this.getPulldownRow(var7, this.currentRow)].countItems() > 0) {
               this.currentText[var7][this.currentRow] = this.pullDownList[var7][this.getPulldownRow(var7, this.currentRow)].getItem(0);
               this.selectedFrom = 0;
               this.selectedTo = this.currentText[var7][this.currentRow].length();
            }
         } else if (this.calendar != null) {
            this.currentText[var7][this.currentRow] = this.calendar.getDateString();
         }
      }

      if ((this.isPullDown[var7][this.getPulldownRow(var7, this.currentRow)] || this.isPullDownCol[var7]) && (this.columnProtected[var7] || this.fieldProtected[var7][this.currentRow])) {
         this.selectedFrom = 0;
         this.selectedTo = this.currentText[var7][this.currentRow].length();
      }

      String var8 = this.currentText[var7][this.currentRow];
      this.lastpos = 0;
      if (this.cursorPos < 0) {
         this.cursorPos = 0;
      }

      if (this.selectedFrom < 0) {
         this.selectedFrom = 0;
      }

      if (this.selectedTo < 0) {
         this.selectedTo = 0;
      }

      if (this.selectedTo > var8.length()) {
         this.selectedTo = var8.length();
      }

      if (this.selectedFrom > var8.length()) {
         this.selectedFrom = var8.length();
      }

      if (this.cursorPos > var8.length()) {
         this.cursorPos = var8.length();
      }

      if (this.cursorPos < this.lastpos) {
         this.lastpos = this.cursorPos - 1;
      }

      if (this.lastpos < 0) {
         this.lastpos = 0;
      }

      this.field_0.setColor(this.columnBGColor[var1]);
      this.field_0.fillRect(var3 + 3, var4 + 3, var5 - 5, var6 - 5);
      if (this.cellColor[var1][var2] != null) {
         this.field_0.setColor(this.cellColor[var1][var2]);
      } else {
         this.field_0.setColor(this.columnColor[var1]);
      }

      if (this.cellFont[var1][var2] != null) {
         this.field_0.setFont(this.cellFont[var1][var2]);
      } else if (this.columnStyle[var1] == 1) {
         this.field_0.setFont(this.boldFont);
      }

      int var9 = this.StringHeight();
      if (this.thisSubstring > var8.length()) {
         this.thisSubstring = var8.length();
      }

      this.field_0.drawString(var8.substring(0, this.thisSubstring), var3 + 3, var4 + var9 - 1);
      if (this.selectedFrom < this.selectedTo) {
         int var10 = 0;
         int var11 = var5 - 1;
         int var12 = var8.length();
         if (var12 > this.selectedTo) {
            var12 = this.selectedTo;
         }

         if (var12 > this.thisSubstring) {
            var12 = this.thisSubstring;
         }

         int var13 = this.lastpos;
         if (var13 < this.selectedFrom) {
            var13 = this.selectedFrom;
            var10 = this.user.u.StringWidth(this.field_0, var8.substring(this.lastpos, this.selectedFrom));
         }

         this.user.u.StringWidth(this.field_0, var8.substring(var13, var12));
         var11 = this.user.u.StringWidth(this.field_0, var8.substring(var13, var12));
         if (var11 > var5 - 5) {
            var11 = var5 - 5;
         }

         this.field_0.setColor(this.textHighlight);
         this.field_0.fillRect(var3 + 3 + var10, var4 + 2, var11, var6 - 3);
         this.field_0.setColor(this.textHighlightText);
         this.field_0.drawString(var8.substring(var13, var12), var3 + 3 + var10, var4 + var9 - 1);
      } else if (this.fieldSelected) {
         int var14 = this.user.u.StringWidth(this.field_0, var8.substring(this.lastpos).substring(0, this.cursorPos - this.lastpos));
         Font var16 = this.field_0.getFont();
         Font var17 = new Font(var16.getName(), var16.getStyle(), var16.getSize() + 2);
         if (!this.columnProtected[this.columnOrder[this.currentColumn]] && !this.fieldProtected[this.columnOrder[this.currentColumn]][this.currentRow] && !this.columnDisabled[this.columnOrder[this.currentColumn]] && !this.fieldDisabled[this.columnOrder[this.currentColumn]][this.currentRow]) {
            this.field_0.setFont(var17);
            this.field_0.drawString("|", var3 + 2 + var14, var4 + var9 - 1);
         }

         this.field_0.setFont(this.plainFont);
      }

      this.field_0.setColor(this.textHighlight);
      this.field_0.drawRect(var3 + 1, var4 + 1, var5 - 2, var6 - 2);
      this.field_0.drawRect(var3 + 2, var4 + 2, var5 - 4, var6 - 4);
      if (var1 == this.totalColumns - 1) {
         this.thisGridOnly = false;
      }

      if (!this.isPullDown[var1][var2] && !this.isPullDownCol[var1]) {
         if (this.fieldType[var1][var2] != 3 && this.fieldTypeCol[var1] != 3) {
            if (this.fieldType[var1][var2] == 2 || this.fieldTypeCol[var1] == 2) {
               this.drawSpinner(var1, var2, var3, var4, var5, var6);
            }
         } else {
            this.drawCheckbox(var1, var2, var3, var4, var5, var6);
         }

         this.pullDownRect = null;
      } else {
         if (!this.fieldDisabled[this.columnOrder[this.currentColumn]][this.currentRow] && !this.columnDisabled[this.columnOrder[this.currentColumn]]) {
            this.drawPullDown(var1, var2, var3, var4, var5, var6);
         }

      }
   }

   public String getSelectedText() {
      return this.currentText[this.getCurrentColumn()][this.getCurrentRow()].substring(this.selectedFrom, this.selectedTo);
   }

   public void setTableDimensions(int var1, int var2) {
      this.currentText = new String[var1][var2];
      this.newTable();
   }

   public Dimension getTableDimensions() {
      return new Dimension(this.totalColumns, this.totalRows);
   }

   public void setCellFont(int var1, int var2, Font var3) {
      this.cellFont[var1][var2] = var3;
      this.reDraw();
   }

   public boolean getSortingEnabled() {
      return this.sortingEnabled;
   }

   public void setSortingEnabled(boolean var1) {
      this.sortingEnabled = var1;
   }

   public Font getCellFont(int var1, int var2) {
      return this.cellFont[var1][var2];
   }

   public void setColumnEnabled(int var1, boolean var2) {
      this.columnDisabled[var1] = !var2;
      this.reDraw();
   }

   public boolean getColumnEnabled(int var1) {
      return !this.columnDisabled[var1];
   }

   public void setPullDownColType(int var1, int var2) {
      this.isPullDownCol[var1] = true;
      this.pullDownType[var1][0] = var2;
      this.setFieldTypeCol(var1, 1);
      this.reDraw();
   }

   public void setMinimumWidth(int var1) {
      this.minimumWidth = var1;
   }

   public int getMinimumWidth() {
      return this.minimumWidth;
   }

   int StringHeight() {
      if (this.field_0 == null) {
         return 0;
      } else {
         if (this.lastFont == null || this.field_0.getFont().getSize() != this.lastFont.getSize()) {
            this.getWidths();
            this.lastFont = this.field_0.getFont();
         }

         return this.field_1.getHeight();
      }
   }

   public void setEditMask(String var1, int var2, String var3) {
      this.editMask[var2] = var3;
      this.editMaskType[var2] = var1;
   }

   public void setSpinnerMin(int var1, int var2, int var3) {
      this.setFieldType(var1, var2, 2);
      this.spinnerMin[var1][var2] = var3 + 999999999;
      this.reDraw();
   }

   public int getSpinnerMin(int var1, int var2) {
      return this.spinnerMin[var1][var2] - 999999999;
   }

   public void setPopupComponent(int var1, int var2, Component var3) {
      this.customPopup[var1][var2] = var3;
      this.pullDownType[var1][var2] = 2;
   }

   public void setPopupComponent(int var1, Component var2) {
      this.customPopup[var1][0] = var2;
      this.pullDownColType[var1] = 2;
   }

   public Component getPopupComponent(int var1, int var2) {
      return this.customPopup[var1][var2];
   }

   public Component getPopupComponent(int var1) {
      return this.customPopup[var1][0];
   }

   void reorderColumns(int var1, int var2) {
      if (var1 >= this.lockedColumns) {
         int var3 = 0;
         int var4 = 0;

         for(int var8 = var2 - this.columnButtonOffset; var3 < var8 - this.rowHeadWidth && var4 + this.xOffset < this.totalColumns; ++var4) {
            var3 += this.columnWidth[this.columnOrder[var4 + this.xOffset]];
         }

         --var4;
         int var5 = var1 + this.originalxOffset;
         int var6 = var4 + this.xOffset;
         if (var6 < this.lockedColumns - 1) {
            var6 = this.lockedColumns - 1;
         }

         int var7 = this.columnOrder[var5];
         var4 = var5;
         if (var5 < var6) {
            for(var4 = var5; var4 < var6; ++var4) {
               if (this.columnOrder[var4] != this.columnOrder[var4 + 1]) {
                  this.columnMoved = true;
               }

               this.columnOrder[var4] = this.columnOrder[var4 + 1];
            }
         }

         if (var5 > var6) {
            for(var4 = var5; var4 > var6 + 1; --var4) {
               if (this.columnOrder[var4] != this.columnOrder[var4 - 1]) {
                  this.columnMoved = true;
               }

               this.columnOrder[var4] = this.columnOrder[var4 - 1];
            }
         }

         this.columnOrder[var4] = var7;
         ((Component)this).repaint();
      }
   }

   public void setSpinnerMaxCol(int var1, int var2) {
      this.setFieldTypeCol(var1, 2);
      this.spinnerMax[var1][0] = var2 - 999999999;
      this.reDraw();
   }

   public int getSpinnerMaxCol(int var1) {
      return this.spinnerMax[var1][0] + 999999999;
   }

   public void setColumnProtected(int var1, boolean var2) {
      this.columnProtected[var1] = var2;
      this.reDraw();
   }

   public boolean getColumnProtected(int var1) {
      return this.columnProtected[var1];
   }

   void repaintGrid(int var1, int var2) {
      int var5 = 2;
      int var6 = 2;
      if (this.fieldSelected) {
         if (var1 < this.xOffset) {
            this.xOffset = var1;
            this.thisGridOnly = false;
         }

         if (var2 < this.yOffset) {
            this.yOffset = var2;
            this.thisGridOnly = false;
         }

         if (var1 > this.xOffset + this.displayedColumns) {
            this.xOffset = var1;
            this.thisGridOnly = false;
         }

         if (var2 > this.yOffset + this.displayedRows) {
            this.yOffset = var2;
            this.thisGridOnly = false;
         }

         ((Component)this).repaint();
      }

      var1 -= this.xOffset;
      var2 -= this.yOffset;
      if (var1 < this.columnWidth.length) {
         if (var2 < this.columnHeight.length) {
            if (this.rowHeaderOn) {
               var5 += this.rowHeaderWidth;
            }

            int var7;
            for(var7 = 0; var7 < var1; ++var7) {
               var5 += this.columnWidth[this.columnOrder[var7 + this.xOffset]];
            }

            int var10000 = this.columnWidth[this.columnOrder[var7 + this.xOffset]];
            if (this.columnHeaderOn) {
               var6 += this.columnHeaderHeight;
            }

            for(var7 = 0; var7 < var2; ++var7) {
               var6 += this.columnHeight[var7 + this.yOffset];
            }

            var10000 = this.columnHeight[var7 + this.yOffset];
            this.fieldDisplay = true;
            ((Component)this).repaint();
         }
      }
   }

   public int getTableColumns() {
      return this.totalColumns;
   }

   public void setRowHeaderOn(boolean var1) {
      this.rowHeaderOn = var1;
      this.reDraw();
   }

   public boolean getRowHeaderOn() {
      return this.rowHeaderOn;
   }

   public void setLockedColumns(int var1) {
      this.lockedColumns = var1;
   }

   public int getLockedColumns() {
      return this.lockedColumns;
   }

   public void setCellEnabled(int var1, int var2, boolean var3) {
      this.fieldDisabled[var1][var2] = !var3;
      this.reDraw();
   }

   public boolean getCellEnabled(int var1, int var2) {
      return !this.fieldDisabled[var1][var2];
   }

   public void setScrollEastDisabled(boolean var1) {
      this.scrollEastDisabled = var1;
      this.reDraw();
   }

   public boolean getScrollEastDisabled() {
      return this.scrollEastDisabled;
   }

   void createCalendar() {
      if (this.calendar == null) {
         this.calendar = new JDPCalendarPicker();
         this.calendar.setBorder(true);
         this.calendar.setFont(((Component)this).getFont());
         this.calendar.setForeground(((Component)this).getForeground());
         this.calendar.setBackground(this.back);
      }

   }

   public Insets insets() {
      return new Insets(3, 3, 0, 0);
   }

   void drawDatePullDown() {
      this.pullDownCells = null;
      if (!this.isPulledDown) {
         if (this.popup.isVisible() && this.popup.getEventListener().equals(this)) {
            this.popup.hide();
            ((Component)this).requestFocus();
         }

      } else {
         byte var1 = 0;
         this.xpulldown += ((Component)this).bounds().x;
         this.ypulldown += ((Component)this).bounds().y;

         for(Container var2 = ((Component)this).getParent(); var2 != null && !var2.equals(this.popup.getParent()); var2 = ((Component)var2).getParent()) {
            Rectangle var3 = ((Component)var2).bounds();
            this.xpulldown += var3.x;
            this.ypulldown += var3.y;
         }

         this.loadPulldown();
         Container var5 = this.popup.getParent();
         if (var5 != null) {
            Rectangle var4 = ((Component)var5).bounds();
            if (this.ypulldown + this.hpulldown + var1 < var4.height) {
               this.popup.display(this.xpulldown + 3, this.ypulldown + this.hpulldown + 2);
            } else {
               this.popup.display(this.xpulldown + 3, this.ypulldown - this.hpulldown + 2);
            }
         } else {
            this.popup.display(this.xpulldown + 3, this.ypulldown - var1);
         }

         this.popup.setEventListener(this);
         this.calendar.requestFocus();
      }
   }

   void drawCustomPullDown() {
      this.pullDownCells = null;
      if (!this.isPulledDown) {
         if (this.popup.isVisible() && this.popup.getEventListener().equals(this)) {
            this.popup.hide();
            ((Component)this).requestFocus();
         }

      } else {
         byte var1 = 0;
         this.xpulldown += ((Component)this).bounds().x;
         this.ypulldown += ((Component)this).bounds().y;

         for(Container var2 = ((Component)this).getParent(); var2 != null && !var2.equals(this.popup.getParent()); var2 = ((Component)var2).getParent()) {
            Rectangle var3 = ((Component)var2).bounds();
            this.xpulldown += var3.x;
            this.ypulldown += var3.y;
         }

         FontMetrics var7 = ((Component)this).getGraphics().getFontMetrics();
         var7.getHeight();
         this.popup.removeAll();
         this.popup.setFont(((Component)this).getFont());
         this.popup.setForeground(((Component)this).getForeground());
         this.popup.setBackground(this.back);
         int var4 = 0;
         if (this.customPopup != null) {
            if (this.customPopup[this.currentColumn].length > 1 && this.customPopup[this.currentColumn][this.currentRow] != null) {
               var4 = this.currentRow;
            }

            if (this.customPopup[this.currentColumn][var4] != null) {
               this.popup.add("Center", this.customPopup[this.currentColumn][var4]);
            }
         }

         Container var5 = this.popup.getParent();
         if (var5 != null) {
            Rectangle var6 = ((Component)var5).bounds();
            if (this.ypulldown + this.hpulldown + var1 < var6.height) {
               this.popup.display(this.xpulldown + 3, this.ypulldown + this.hpulldown + 2);
            } else {
               this.popup.display(this.xpulldown + 3, this.ypulldown - this.hpulldown + 2);
            }
         } else {
            this.popup.display(this.xpulldown + 3, this.ypulldown - var1);
         }

         this.popup.setEventListener(this);
         this.customPopup[this.currentColumn][var4].requestFocus();
      }
   }

   void keyDown(Event var1) {
      int var2 = this.currentColumn;
      int var3 = this.columnOrder[this.currentColumn];
      int var4 = this.currentRow;
      String var5 = this.currentText[var3][var4];
      this.fieldSelected = true;
      if (var1.modifiers == 2) {
         switch (var1.key) {
            case 3:
               if (this.cellSelected[var2][var4]) {
                  this.clipBoard = var5;
                  return;
               }

               if (this.selectedFrom < this.selectedTo) {
                  this.clipBoard = var5.substring(this.selectedFrom, this.selectedTo);
               }

               return;
            case 22:
               if (this.cellSelected[var2][var4]) {
                  this.currentText[var3][this.currentRow] = this.clipBoard;
               } else {
                  String var9 = var5.substring(0, this.selectedFrom) + this.clipBoard + var5.substring(this.selectedTo);
                  this.currentText[var3][this.currentRow] = var9;
               }

               this.cursorPos += this.clipBoard.length();
               this.selectedFrom = this.cursorPos;
               this.selectedTo = this.cursorPos;
               this.thisGridOnly = true;
               this.repaintGrid(this.currentColumn, this.currentRow);
               return;
            case 24:
               if (this.cellSelected[var2][var4]) {
                  this.clipBoard = var5;
                  this.currentText[var3][this.currentRow] = "";
                  this.cursorPos = 0;
               } else if (this.selectedFrom < this.selectedTo) {
                  this.clipBoard = var5.substring(this.selectedFrom, this.selectedTo);
                  this.currentText[var3][this.currentRow] = var5.substring(0, this.selectedFrom) + var5.substring(this.selectedTo);
                  this.cursorPos = this.selectedFrom;
               }

               this.selectedFrom = this.cursorPos;
               this.selectedTo = this.cursorPos;
               this.thisGridOnly = true;
               this.repaintGrid(this.currentColumn, this.currentRow);
               return;
            default:
         }
      } else {
         switch (var1.key) {
            case 8:
            case 127:
               if (!this.columnProtected[var3] && !this.fieldProtected[var3][var4] && !this.columnDisabled[var3] && !this.fieldDisabled[var3][var4] && var5.length() > 0 && (this.cursorPos > 0 && var1.key == 8 || this.cursorPos >= 0 && var1.key == 127)) {
                  String var6;
                  if (this.selectedFrom == this.selectedTo) {
                     if (var1.key == 8) {
                        var6 = var5.substring(0, this.selectedFrom - 1) + var5.substring(this.selectedTo);
                        this.cursorPos += -1;
                     } else {
                        var6 = var5.substring(0, this.selectedFrom);
                        if (var5.length() > this.selectedTo + 1) {
                           var6 = var6 + var5.substring(this.selectedTo + 1);
                        }
                     }
                  } else {
                     var6 = var5.substring(0, this.selectedFrom) + var5.substring(this.selectedTo);
                     this.cursorPos = this.selectedFrom;
                  }

                  this.selectedFrom = this.cursorPos;
                  this.selectedTo = this.cursorPos;
                  this.currentText[var3][var4] = var6;
                  this.cellChanged[var3][var4] = true;
                  this.rowChanged[var4] = true;
                  this.thisGridOnly = true;
                  this.repaintGrid(this.currentColumn, this.currentRow);
               }

               return;
            case 9:
            case 10:
               if (var1.modifiers == 1) {
                  --var1.modifiers;
                  this.shiftField(-1, 0, var1);
                  return;
               }

               this.shiftField(1, 0, var1);
               return;
            default:
               if (!this.columnProtected[var3] && !this.fieldProtected[var3][var4] && !this.columnDisabled[var3] && !this.fieldDisabled[var3][var4]) {
                  this.buffer = new char[1];
                  this.buffer[0] = (char)var1.key;
                  String var8 = new String(new String(this.buffer));
                  String var7 = var5;
                  if (this.selectedFrom <= var5.length() && this.selectedTo <= var5.length()) {
                     var7 = var5.substring(0, this.selectedFrom) + var8 + var5.substring(this.selectedTo);
                  }

                  if (this.selectedFrom == this.selectedTo) {
                     ++this.cursorPos;
                  } else {
                     this.cursorPos = this.selectedFrom + 1;
                  }

                  this.selectedFrom = this.cursorPos;
                  this.selectedTo = this.cursorPos;
                  this.currentText[var3][var4] = var7;
                  this.thisGridOnly = true;
                  this.cellChanged[var3][var4] = true;
                  this.rowChanged[var4] = true;
                  this.repaintGrid(this.currentColumn, this.currentRow);
               }
         }
      }
   }

   public void setCursorInThisCell(int var1, int var2) {
      this.cursorInThisField = new boolean[this.totalColumns][this.totalRows];
      this.currentColumn = 0;
      this.currentRow = 0;
      if (var1 >= 0) {
         this.currentColumn = var1;
      }

      if (var2 >= 0) {
         this.currentRow = var2;
      }

      this.selectedFrom = 0;
      this.selectedTo = 0;
      if (var1 >= 0 && var2 >= 0) {
         for(this.cursorInThisField[var1][var2] = true; this.xOffset >= var1; this.xOffset += -1) {
         }

         while(this.yOffset >= var2) {
            this.yOffset += -1;
         }

         while(this.xOffset < var1 && var1 > this.xOffset + this.displayedColumns - 2) {
            ++this.xOffset;
         }

         while(this.yOffset < var2 && var2 > this.yOffset + this.displayedRows - 2) {
            ++this.yOffset;
         }

         this.setCellSelected(var1, var2, true);
         if (this.currentText[var1][var2] != null) {
            this.selectedTo = this.currentText[var1][var2].length();
         }
      }

      this.reDraw();
   }

   public boolean getCursorInThisCell(int var1, int var2) {
      return this.cursorInThisField[var1][var2];
   }

   int getPulldownRow(int var1, int var2) {
      return this.isPullDownCol[var1] ? 0 : var2;
   }

   public void setRowChanged(int var1, boolean var2) {
      this.rowChanged[var1] = var2;
   }

   public boolean getRowChanged(int var1) {
      return this.rowChanged[var1];
   }

   public void reDraw() {
      this.thisGridOnly = false;
      this.nothingChanged = false;
      ((Component)this).repaint();
   }

   public void paint(Graphics var1) {
      this.update(var1);
   }

   public void setRowSelected(int var1, boolean var2) {
      this.rowSelected[var1] = var2;

      for(int var3 = 0; var3 < this.totalColumns; ++var3) {
         this.cellSelected[var3][var1] = var2;
      }

      this.currentSelectedRow = var1;
      this.reDraw();
   }

   public boolean getRowSelected(int var1) {
      return this.rowSelected[var1];
   }

   public void setCellProtected(int var1, int var2, boolean var3) {
      this.fieldProtected[var1][var2] = var3;
      this.reDraw();
   }

   public boolean getCellProtected(int var1, int var2) {
      return this.fieldProtected[var1][var2];
   }

   public int getSelectedColumn() {
      return this.currentSelectedColumn;
   }

   void shiftField(int var1, int var2, Event var3) {
      int var4 = this.xOffset;
      int var5 = this.yOffset;
      this.fieldSelected = false;
      this.prevColumn = this.currentColumn;
      this.prevRow = this.currentRow;
      int var6 = this.columnOrder[this.currentColumn];
      if (this.isPulledDown && this.pullDownType[var6][this.getPulldownRow(var6, this.currentRow)] != 1 && this.pullDownColType[var6] != 1 && this.pullDownType[var6][this.getPulldownRow(var6, this.currentRow)] != 2 && this.pullDownColType[var6] != 2) {
         int var14 = this.pullDownList[var6][this.getPulldownRow(var6, this.currentRow)].getSelectedIndex();
         if (var14 + var2 > this.pullDownList[var6][this.getPulldownRow(var6, this.currentRow)].countItems()) {
            var2 = this.pullDownList[var6][this.getPulldownRow(var6, this.currentRow)].countItems() - var14;
         }

         if (var14 + var2 >= 0 && var14 + var2 < this.pullDownList[var6][this.getPulldownRow(var6, this.currentRow)].countItems()) {
            this.pullDownList[var6][this.getPulldownRow(var6, this.currentRow)].select(var14 + var2);
            this.pullDownList[var6][this.getPulldownRow(var6, this.currentRow)].makeVisible(var14 + var2);
            this.currentText[var6][this.currentRow] = this.pullDownList[var6][this.getPulldownRow(var6, this.currentRow)].getSelectedItem();
         }

         ((Component)this).repaint();
      } else {
         this.cursorInThisField[this.currentColumn][this.currentRow] = false;
         if (var3.modifiers == 1) {
            for(int var7 = 0; var7 < this.totalColumns; ++var7) {
               this.columnSelected[var7] = false;

               for(int var8 = 0; var8 < this.totalRows; ++var8) {
                  this.rowSelected[var8] = false;
                  this.saveColumnSelected[var7][var8] = this.cellSelected[var7][var8];
                  if (var3.modifiers != 2) {
                     this.cellSelected[var7][var8] = false;
                  }
               }
            }

            this.cursorColumn += var1;
            this.cursorRow += var2;
            if (this.cursorColumn < this.xOffset && this.xOffset > 0) {
               this.xOffset += -1;
            }

            if (this.cursorColumn - this.xOffset >= this.displayedColumns - 1 && this.displayedColumns < this.totalColumns) {
               ++this.xOffset;
            }

            if (this.cursorRow < this.yOffset && this.yOffset > 0) {
               this.yOffset += -1;
            }

            if (this.cursorRow - this.yOffset >= this.displayedRows - 1 && this.displayedRows < this.totalRows) {
               ++this.yOffset;
            }

            this.paintAll = true;
         } else {
            this.resetSelections();
            if (!this.paintAll) {
               this.repaintGrid(this.currentColumn, this.currentRow);
            }

            this.currentColumn += var1;
            this.currentRow += var2;
            if (this.currentColumn >= this.totalColumns) {
               this.currentColumn = 0;
               ++this.currentRow;
            }

            if (this.currentRow >= this.totalRows) {
               this.currentRow = 0;
            }

            if (this.currentColumn < 0) {
               this.currentColumn = 0;
            }

            if (this.currentRow < 0) {
               this.currentRow = 0;
            }

            this.cursorColumn = this.currentColumn;
            this.cursorRow = this.currentRow;
            this.initSelectColumn = this.cursorColumn;
            this.initSelectRow = this.cursorRow;
            if (this.currentColumn < this.xOffset && this.xOffset > 0) {
               this.xOffset += -1;
            }

            if (this.currentColumn - this.xOffset >= this.displayedColumns - 1 && this.displayedColumns < this.totalColumns) {
               ++this.xOffset;
            }

            if (this.currentRow < this.yOffset && this.yOffset > 0) {
               this.yOffset += -1;
            }

            if (this.currentRow - this.yOffset >= this.displayedRows - 1 && this.displayedRows < this.totalRows) {
               ++this.yOffset;
            }
         }

         if (var3.modifiers == 1) {
            int var13 = this.cursorColumn - this.initSelectColumn;
            byte var15 = 1;
            if (var13 < 0) {
               var15 = -1;
            }

            int var9 = this.cursorRow - this.initSelectRow;
            byte var10 = 1;
            if (var9 < 0) {
               var10 = -1;
            }

            for(int var11 = this.initSelectColumn; var11 != this.cursorColumn + var15; var11 += var15) {
               for(int var12 = this.initSelectRow; var12 != this.cursorRow + var10; var12 += var10) {
                  if (var11 < this.totalColumns && var12 < this.totalRows && var11 >= 0 && var12 >= 0) {
                     this.cellSelected[var11][var12] = true;
                  }
               }
            }

            for(int var16 = 0; var16 < this.displayedColumns; ++var16) {
               for(int var17 = 0; var17 < this.displayedRows; ++var17) {
                  if (var16 + this.xOffset < this.totalColumns && var17 + this.yOffset < this.totalRows && this.cellSelected[var16 + this.xOffset][var17 + this.yOffset] != this.saveColumnSelected[var16 + this.xOffset][var17 + this.yOffset]) {
                  }
               }
            }
         }

         this.cursorInThisField[this.currentColumn][this.currentRow] = true;
         if (this.currentText[this.currentColumn][this.currentRow] == null) {
            this.currentText[this.currentColumn][this.currentRow] = "";
         }

         this.cursorPos = this.currentText[this.currentColumn][this.currentRow].length();
         this.selectedFrom = 0;
         this.selectedTo = this.cursorPos;
         this.fieldDisplay = true;
         if (this.xOffset != var4) {
            ((Component)this).repaint();
         } else if (this.yOffset != var5) {
            ((Component)this).repaint();
         } else if (this.paintAll) {
            ((Component)this).repaint();
         } else {
            this.repaintGrid(this.currentColumn, this.currentRow);
         }

         this.thisEvent = new Event(this, 1005, "JDPTextGrid");
         ((Component)this).postEvent(this.thisEvent);
         this.thisEvent = new Event(this, 1004, "JDPTextGrid");
      }
   }

   void drawCheckbox(int var1, int var2, int var3, int var4, int var5, int var6) {
      Color var7 = this.field_0.getColor();
      this.field_0.setColor(this.columnBGColor[var1]);
      this.field_0.fillRect(var3 + 3, var4 + 3, var5 - 5, var6 - 5);
      var3 = var3 + var5 / 2 - 4;
      var4 += 4;
      this.field_0.setColor(JDPUtils.darker(this.gridColor));
      this.field_0.drawRect(var3, var4 - 1, 10, 10);
      if (this.cursorInThisField[this.columnOrder[var1]][var2]) {
         this.checkboxRect = new Rectangle(var3 + 3, var4 + 1, 12, 12);
      }

      if (this.currentText[var1][var2].equals("Y")) {
         this.field_0.setColor(Color.black);
         this.field_0.drawLine(var3 + 2, var4 + 3, var3 + 4, var4 + 5);
         this.field_0.drawLine(var3 + 2, var4 + 4, var3 + 4, var4 + 6);
         this.field_0.drawLine(var3 + 2, var4 + 5, var3 + 4, var4 + 7);
         this.field_0.drawLine(var3 + 4, var4 + 5, var3 + 8, var4 + 1);
         this.field_0.drawLine(var3 + 4, var4 + 6, var3 + 8, var4 + 2);
         this.field_0.drawLine(var3 + 4, var4 + 7, var3 + 8, var4 + 3);
      }

      this.field_0.setColor(var7);
   }

   public void resetSelections() {
      int var1 = -1;
      this.currentSelectedRow = -1;
      this.currentSelectedColumn = -1;

      for(int var2 = 0; var2 < this.totalColumns; ++var2) {
         this.columnSelected[var2] = false;

         for(int var3 = 0; var3 < this.totalRows; ++var3) {
            if (this.rowSelected[var3]) {
               var1 = var3;
            }

            this.rowSelected[var3] = false;
            if (this.cellSelected[var2][var3]) {
               this.paintAll = true;
            }

            this.cellSelected[var2][var3] = false;
         }
      }

      if (var1 >= 0) {
         this.thisEvent = new Event(this, 702, new Integer(var1));
         ((Component)this).postEvent(this.thisEvent);
      }

   }

   public String getText(int var1, int var2) {
      return this.currentText[var1][var2];
   }

   public void setText(String var1) {
      this.currentText[this.columnOrder[this.currentColumn]][this.currentRow] = var1;
      this.reDraw();
   }

   public void setFieldType(int var1, int var2, int var3) {
      this.fieldType[var1][var2] = var3;
      this.setPullDown(var1, var2, var3 == 1);
      if (var3 == 3) {
         this.setCellProtected(var1, var2, true);
      }

      this.reDraw();
   }

   public int getFieldType(int var1, int var2) {
      return this.fieldType[var1][var2];
   }

   public void setText(String var1, int var2, int var3) {
      this.currentText[this.columnOrder[var2]][var3] = var1;
      this.reDraw();
   }

   public String getText() {
      return this.currentText[this.columnOrder[this.currentColumn]][this.currentRow];
   }

   public void setPullDownType(int var1, int var2, int var3) {
      this.isPullDown[var1][var2] = true;
      this.pullDownType[var1][var2] = var3;
      this.reDraw();
   }

   public void setRowHeaderWidth(int var1) {
      this.rowHeaderWidth = var1;
      this.reDraw();
   }

   public int getColumnOffset() {
      return this.xOffset;
   }

   public void setColumnOffset(int var1) {
      this.xOffset = var1;
      this.reDraw();
   }

   public int getRowHeaderWidth() {
      return this.rowHeaderWidth;
   }

   public void setRowHeader(int var1, String var2) {
      this.rowHeader[var1] = var2;
      this.reDraw();
   }

   public String getRowHeader(int var1) {
      return this.rowHeader[var1];
   }

   public void select(int var1, int var2) {
      this.selectedFrom = var1;
      this.selectedTo = var2;
      this.cursorPos = var1;
      this.reDraw();
   }

   void loadPulldown() {
      this.createCalendar();
      this.calendar.setDate(this.getText());
      FontMetrics var1 = ((Component)this).getGraphics().getFontMetrics();
      var1.getHeight();
      this.popup.removeAll();
      this.popup.setFont(((Component)this).getFont());
      this.popup.setForeground(((Component)this).getForeground());
      this.popup.setBackground(this.back);
      this.popup.add("Center", this.calendar);
   }

   public void setColumnHeaderColor(int var1, Color var2) {
      this.columnHeaderColor[var1] = var2;
      this.reDraw();
   }

   public Color getColumnHeaderColor(int var1) {
      return this.columnHeaderColor[var1];
   }

   public void setColumnColor(int var1, Color var2) {
      this.columnColor[var1] = var2;
      this.reDraw();
   }

   public Color getColumnColor(int var1) {
      return this.columnColor[var1];
   }

   public void setColumnBGColor(int var1, Color var2) {
      this.columnBGColor[var1] = var2;
      this.reDraw();
   }

   public Color getColumnBGColor(int var1) {
      return this.columnBGColor[var1];
   }

   public void setRowGridColor(int var1, int var2, Color var3) {
      this.rowGridColor[var1][var2] = var3;
      this.reDraw();
   }

   public Color getRowGridColor(int var1, int var2) {
      return this.rowGridColor[var1][var2];
   }

   public void setMinimumHeight(int var1) {
      this.minimumHeight = var1;
   }

   public Dimension preferredSize() {
      return this.minimumSize();
   }

   public int getMinimumHeight() {
      return this.minimumHeight;
   }

   public void setSpinnerMinCol(int var1, int var2) {
      this.setFieldTypeCol(var1, 2);
      this.spinnerMin[var1][0] = var2 + 999999999;
      this.reDraw();
   }

   public int getSpinnerMinCol(int var1) {
      return this.spinnerMin[var1][0] - 999999999;
   }

   public void setRightJustify(int var1, boolean var2) {
      this.rightJustify[var1] = var2;
      this.reDraw();
   }

   public boolean getRightJustify(int var1) {
      return this.rightJustify[var1];
   }

   public void setRowKeyArray(String[][] var1) {
      this.rowKey = var1;
   }

   public String[][] getRowKeyArray() {
      return this.rowKey;
   }

   public JDPTextGrid(JDPUser var1) {
      this.user = var1;
      if (!JDPUser.classactivated) {
         System.out.println("Software Violation - this class may only be used in conjunction with JDesignerPro.");
      } else {
         this.textHighlightText = JDPUtils.getTextHighlightText();
         this.textHighlight = JDPUtils.getTextHighlight();
         this.Bounds = ((Component)this).bounds();
         this.JDPMaskEditMain = new JDPMaskEdit();
         this.popup = var1.popup;
         this.newTable();
      }
   }

   public int getSelectionStart() {
      return this.selectedFrom;
   }

   String updateSpinner(int var1) {
      int var2 = 0;

      try {
         var2 = Integer.parseInt(this.getText()) + var1;
      } catch (Exception var3) {
      }

      if (this.fieldTypeCol[this.columnOrder[this.currentColumn]] == 2) {
         if (var2 < this.spinnerMin[this.columnOrder[this.currentColumn]][0] - 999999999) {
            var2 = this.spinnerMin[this.columnOrder[this.currentColumn]][0] - 999999999;
            this.setText(Integer.toString(var2));
         }

         if (var2 > this.spinnerMax[this.columnOrder[this.currentColumn]][0] + 999999999) {
            var2 = this.spinnerMax[this.columnOrder[this.currentColumn]][0] + 999999999;
            this.setText(Integer.toString(var2));
         }
      } else if (this.fieldType[this.columnOrder[this.currentColumn]][this.currentRow] == 2) {
         if (var2 < this.spinnerMin[this.columnOrder[this.currentColumn]][this.currentRow] - 999999999) {
            var2 = this.spinnerMin[this.columnOrder[this.currentColumn]][this.currentRow] - 999999999;
            this.setText(Integer.toString(var2));
         }

         if (var2 > this.spinnerMax[this.columnOrder[this.currentColumn]][this.currentRow] + 999999999) {
            var2 = this.spinnerMax[this.columnOrder[this.currentColumn]][this.currentRow] + 999999999;
            this.setText(Integer.toString(var2));
         }
      }

      return Integer.toString(var2);
   }

   void drawPullDownList() {
      this.pullDownCells = null;
      if (this.isPulledDown) {
         int var1 = this.columnOrder[this.currentColumn];
         this.xindexpulldown = var1;
         this.yindexpulldown = this.currentRow;
         if (this.isPullDown[var1][this.getPulldownRow(var1, this.currentRow)] || this.isPullDownCol[this.xindexpulldown]) {
            int var2 = this.pullDownList[this.xindexpulldown][this.getPulldownRow(this.xindexpulldown, this.yindexpulldown)].countItems();

            int var3;
            for(var3 = var2; this.ypulldown + this.hpulldown * (var3 + 1) > ((Component)this).bounds().height - 7; --var3) {
            }

            if (var3 < 2) {
               for(var3 = var2; this.ypulldown - this.hpulldown * (var3 + 1) < this.columnHeadHeight - 15; --var3) {
               }

               this.ypulldown -= this.hpulldown * (var3 + 1);
            }

            if (this.pullDownList[this.xindexpulldown][this.getPulldownRow(this.xindexpulldown, this.yindexpulldown)].getVisibleIndex() == -1) {
               this.pullDownList[this.xindexpulldown][this.getPulldownRow(this.xindexpulldown, this.yindexpulldown)].makeVisible(this.pullDownList[this.xindexpulldown][this.getPulldownRow(this.xindexpulldown, this.yindexpulldown)].getSelectedIndex());
            }

            int var4 = this.pullDownList[this.xindexpulldown][this.getPulldownRow(this.xindexpulldown, this.yindexpulldown)].getVisibleIndex();
            if (var4 + var3 > var2) {
               var4 = var2 - var3;
            }

            if (var4 < 0) {
               var4 = 0;
            }

            int var5 = var4 + var3;
            if (var5 > var2) {
               var5 = var2;
            }

            this.field_0.setColor(this.columnBGColor[this.xindexpulldown]);
            this.field_0.fillRect(this.xpulldown + 1, this.ypulldown + this.hpulldown, this.wpulldown - 2, this.hpulldown * var3);
            this.field_0.setColor(Color.black);
            this.field_0.drawRect(this.xpulldown, this.ypulldown + this.hpulldown, this.wpulldown - 1, this.hpulldown * var3);
            this.pullDownCells = new Rectangle[var2];
            if (this.cellColor[this.xindexpulldown][this.yindexpulldown] != null) {
               this.field_0.setColor(this.cellColor[this.xindexpulldown][this.yindexpulldown]);
            } else {
               this.field_0.setColor(this.columnColor[this.xindexpulldown]);
            }

            if (this.cellFont[this.xindexpulldown][this.yindexpulldown] != null) {
               this.field_0.setFont(this.cellFont[this.xindexpulldown][this.yindexpulldown]);
            } else if (this.columnStyle[this.xindexpulldown] == 1) {
               this.field_0.setFont(this.boldFont);
            }

            int var6 = this.StringHeight();
            boolean var7 = false;

            for(int var8 = var4; var8 < var5; ++var8) {
               String var9 = this.pullDownList[this.xindexpulldown][this.getPulldownRow(this.xindexpulldown, this.yindexpulldown)].getItem(var8);
               int var10 = var9.length();
               int var11 = this.user.u.StringWidth(this.field_0, var9);
               if (var11 > this.wpulldown - 12) {
                  var10 = 0;

                  while(this.user.u.StringWidth(this.field_0, var9.substring(0, var10++)) < this.wpulldown - 12) {
                  }
               }

               if (var10 > var9.length()) {
                  var10 = var9.length();
               }

               Color var12 = this.field_0.getColor();
               if (this.pullDownList[this.xindexpulldown][this.getPulldownRow(this.xindexpulldown, this.yindexpulldown)].getSelectedIndex() == var8) {
                  this.field_0.setColor(this.textHighlight);
                  this.field_0.fillRect(this.xpulldown + 1, this.ypulldown + this.hpulldown + this.hpulldown * (var8 - var4), this.wpulldown - 2, this.hpulldown);
                  this.field_0.setColor(this.textHighlightText);
               } else {
                  this.field_0.setColor(var12);
               }

               this.field_0.drawString(var9.substring(0, var10), this.xpulldown + 3, this.ypulldown + this.hpulldown + this.hpulldown * (var8 - var4) + var6 - 1);
               this.field_0.setColor(var12);
               this.pullDownCells[var8] = new Rectangle(this.xpulldown, this.ypulldown + this.hpulldown + this.hpulldown * (var8 - var4), this.wpulldown, this.hpulldown);
            }

            if (var4 <= 0 && var3 >= this.pullDownList[this.xindexpulldown][this.getPulldownRow(this.xindexpulldown, this.yindexpulldown)].countItems()) {
               if (this.pullDownScroll != null) {
                  this.pullDownScroll.hide();
               }

            } else {
               if (this.pullDownScroll == null) {
                  this.pullDownScroll = new Scrollbar(1, 0, 5, 0, 100);
                  ((Container)this).add(this.pullDownScroll);
               }

               int var13 = 0;
               if (System.getProperty("java.vendor").startsWith("Netscape") && System.getProperty("java.version").compareTo("1.1.5") < 0 || System.getProperty("java.vendor").startsWith("Microsoft") && System.getProperty("java.version").compareTo("1.1.4") < 0) {
                  var13 = var3;
               }

               this.pullDownScroll.setValues(var4, var3, 0, this.pullDownList[this.xindexpulldown][this.getPulldownRow(this.xindexpulldown, this.yindexpulldown)].countItems() - var13);
               this.pullDownScroll.move(this.xpulldown + this.wpulldown - 8, this.ypulldown + this.hpulldown + 4);
               this.pullDownScroll.resize(11, var3 * this.hpulldown);
               this.pullDownScroll.show();
            }
         }
      }
   }

   public void setPullDownList(int var1, int var2, List var3) {
      this.pullDownList[var1][var2] = var3;
      this.reDraw();
   }

   public void setCellChanged(int var1, int var2, boolean var3) {
      this.cellChanged[var1][var2] = var3;
   }

   public boolean getCellChanged(int var1, int var2) {
      return this.cellChanged[var1][var2];
   }

   public void setColumnWidth(int var1, int var2) {
      this.columnWidth[var1] = var2;
      this.reDraw();
   }

   public int getColumnWidth(int var1) {
      return this.columnWidth[var1];
   }

   public List getPullDownList(int var1, int var2) {
      return this.pullDownList[var1][var2];
   }

   public void setColumnHeader(int var1, String var2) {
      this.columnHeader[var1] = var2;
      this.reDraw();
   }

   public String getColumnHeader(int var1) {
      return this.columnHeader[var1];
   }

   void drawPullDown(int var1, int var2, int var3, int var4, int var5, int var6) {
      int var7 = this.columnOrder[this.currentColumn];
      if (var3 + var5 > ((Component)this).bounds().width - 19) {
         var5 = ((Component)this).bounds().width - 19 - var3;
      }

      int var8 = var3 + var5 - 10;
      this.field_0.setColor(this.columnBGColor[var1]);
      this.field_0.drawRect(var3 + 1, var4 + 1, var5 - 2, var6 - 2);
      this.field_0.drawRect(var3 + 2, var4 + 2, var5 - 4, var6 - 4);
      this.drawButton("", Color.black, 1, var8, var4 + 2, 10, var6 - 3);
      int[] var9 = new int[]{var8 + 4, var8 + 2, var8 + 7, var8 + 4};
      int[] var10 = new int[]{var4 + 11, var4 + 8, var4 + 8, var4 + 11};
      this.field_0.setColor(Color.black);
      this.field_0.fillPolygon(var9, var10, 3);
      this.field_0.setColor(JDPUtils.darker(this.gridColor));
      this.field_0.drawRect(var8 - 1, var4 + 1, var8 + 10, var4 + var6 - 4);
      if (!this.columnProtected[var7] && !this.fieldProtected[var7][this.currentRow]) {
         this.pullDownRect = new Rectangle(var8, var4 + 2, 10, var6 - 3);
      } else {
         this.pullDownRect = new Rectangle(var3, var4 + 2, var5, var6 - 3);
         if (this.currentText[var7][this.currentRow] == null || this.currentText[var7][this.currentRow].equals("")) {
            if (this.pullDownType[var7][this.getPulldownRow(var7, this.currentRow)] != 1 && this.pullDownColType[var7] != 1) {
               if (this.pullDownType[var7][this.getPulldownRow(var7, this.currentRow)] != 2 && this.pullDownColType[var7] != 2 && this.pullDownList[var7][this.getPulldownRow(var7, this.currentRow)].countItems() > 0) {
                  this.currentText[var7][this.currentRow] = this.pullDownList[var7][this.getPulldownRow(var7, this.currentRow)].getItem(0);
               }
            } else if (this.calendar != null) {
               this.currentText[var7][this.currentRow] = this.calendar.getDateString();
            }
         }
      }

      if (this.isPulledDown) {
         this.xindexpulldown = var1 + this.xOffset;
         this.yindexpulldown = var2 + this.yOffset;
         this.xpulldown = var3;
         this.ypulldown = var4;
         this.wpulldown = var5;
         this.hpulldown = var6;
         if (this.pullDownType[var7][this.getPulldownRow(var7, this.currentRow)] != 1 && this.pullDownColType[var7] != 1 && this.pullDownType[var7][this.getPulldownRow(var7, this.currentRow)] != 2 && this.pullDownColType[var7] != 2) {
            int var11 = 0;

            while(true) {
               if (var11 >= this.pullDownList[var7][this.getPulldownRow(var7, this.currentRow)].countItems()) {
                  return;
               }

               if (this.currentText[var7][this.currentRow].equals(this.pullDownList[var7][this.getPulldownRow(var7, this.currentRow)].getItem(var11))) {
                  if (this.pullDownList[var7][this.getPulldownRow(var7, this.currentRow)].getSelectedIndex() == -1) {
                     this.pullDownList[var7][this.getPulldownRow(var7, this.currentRow)].select(var11);
                  }

                  if (this.pullDownList[var7][this.getPulldownRow(var7, this.currentRow)].getVisibleIndex() == -1) {
                     this.pullDownList[var7][this.getPulldownRow(var7, this.currentRow)].makeVisible(var11);
                     return;
                  }
                  break;
               }

               ++var11;
            }
         }
      } else if (this.pullDownType[var7][this.getPulldownRow(var7, this.currentRow)] != 1 && this.pullDownColType[var7] != 1 && this.pullDownType[var7][this.getPulldownRow(var7, this.currentRow)] != 2 && this.pullDownColType[var7] != 2) {
         for(int var12 = 0; var12 < this.pullDownList[var7][this.getPulldownRow(var7, this.currentRow)].countItems(); ++var12) {
            if (this.currentText[var7][this.currentRow].equals(this.pullDownList[var7][this.getPulldownRow(var7, this.currentRow)].getItem(var12))) {
               this.pullDownList[var7][this.getPulldownRow(var7, this.currentRow)].select(var12);
               this.pullDownList[var7][this.getPulldownRow(var7, this.currentRow)].makeVisible(var12);
            }
         }
      }

   }

   void drawListPullDown() {
      this.pullDownCells = null;
      if (!this.isPulledDown) {
         if (this.popup.isVisible() && this.popup.getEventListener().equals(this)) {
            this.popup.hide();
            ((Component)this).requestFocus();
         }

      } else {
         byte var1 = 0;
         this.xpulldown += ((Component)this).bounds().x;
         this.ypulldown += ((Component)this).bounds().y;

         for(Container var2 = ((Component)this).getParent(); var2 != null && !var2.equals(this.popup.getParent()); var2 = ((Component)var2).getParent()) {
            Rectangle var3 = ((Component)var2).bounds();
            this.xpulldown += var3.x;
            this.ypulldown += var3.y;
         }

         FontMetrics var8 = ((Component)this).getGraphics().getFontMetrics();
         int var4 = var8.getHeight() + 2;
         this.popup.removeAll();
         this.popup.setFont(((Component)this).getFont());
         this.popup.setForeground(((Component)this).getForeground());
         this.popup.setBackground(this.back);
         this.xindexpulldown = this.columnOrder[this.currentColumn];
         this.yindexpulldown = this.currentRow;
         if (this.pullDownDisplayList == null) {
            this.pullDownDisplayList = new JDPList(this.user);
            this.pullDownDisplayList.threeDBorder = false;
         }

         this.pullDownDisplayList.clear();

         for(int var5 = 0; var5 < this.pullDownList[this.xindexpulldown][this.getPulldownRow(this.xindexpulldown, this.yindexpulldown)].countItems(); ++var5) {
            this.pullDownDisplayList.addItem(this.pullDownList[this.xindexpulldown][this.getPulldownRow(this.xindexpulldown, this.yindexpulldown)].getItem(var5));
         }

         int var9 = this.pullDownList[this.xindexpulldown][this.getPulldownRow(this.xindexpulldown, this.yindexpulldown)].getSelectedIndex();
         if (var9 >= 0) {
            this.pullDownDisplayList.select(var9);
            this.pullDownDisplayList.makeVisible(var9);
         }

         this.popup.add("Center", this.pullDownDisplayList);
         this.pullDownDisplayList.setMinWidth(this.columnWidth[this.xindexpulldown]);
         this.pullDownDisplayList.setMinHeight(var4 * this.pullDownDisplayList.countItems() + 6);
         Container var6 = this.popup.getParent();
         if (var6 != null) {
            Rectangle var7 = ((Component)var6).bounds();
            if (this.ypulldown + this.hpulldown + var1 < var7.height) {
               this.popup.display(this.xpulldown + 3, this.ypulldown + this.hpulldown + 3, this.ypulldown + 4);
            } else {
               this.popup.display(this.xpulldown + 3, this.ypulldown - this.hpulldown + 3, this.ypulldown + 4);
            }
         } else {
            this.popup.display(this.xpulldown + 3, this.ypulldown - var1);
         }

         this.popup.setEventListener(this);
         this.pullDownDisplayList.requestFocus();
      }
   }

   void drawButton(String var1, Color var2, int var3, int var4, int var5, int var6, int var7) {
      this.drawButton(var1, (String)null, var2, var3, var4, var5, var6, var7);
   }

   void drawButton(String var1, boolean var2, Color var3, int var4, int var5, int var6, int var7, int var8) {
      String var9 = "Left";
      if (var2) {
         var9 = "Right";
      }

      this.drawButton(var1, var9, var3, var4, var5, var6, var7, var8);
   }

   public int getPrevRow() {
      return this.prevRow;
   }

   void drawButton(String var1, String var2, Color var3, int var4, int var5, int var6, int var7, int var8) {
      if (this.columnHeader != null && this.columnHeader.length > 1 && this.columnHeader[0] != null && this.columnHeader[0].equals("0") && this.columnHeader[1].equals("1")) {
         var2 = null;
      }

      this.field_0.setColor(this.back);
      this.field_0.fillRect(var5 + 1, var6 + 1, var7 - 1, var8 - 1);
      this.field_0.setColor(JDPUtils.brighter(this.back));
      this.field_0.drawLine(var5, var6, var5 + var7, var6);
      this.field_0.drawLine(var5, var6, var5, var6 + var8);
      this.field_0.setColor(JDPUtils.darker(JDPUtils.darker(this.gridColor)));
      this.field_0.setColor(Color.black);
      this.field_0.drawLine(var5 - 1, var6, var5 - 1, var6 + var8);
      this.field_0.drawLine(var5, var6 + var8, var5 + var7 - 2, var6 + var8);
      this.field_0.drawLine(var5 + var7 - 1, var6, var5 + var7 - 1, var6 + var8);
      this.field_0.setColor(var3);
      if (var1 != null) {
         if (var4 == 1) {
            this.field_0.setFont(this.boldFont);
         } else {
            this.field_0.setFont(this.plainFont);
         }

         int var9 = 0;
         if (var2 == null) {
            var9 = var5 + var7 / 2 - this.user.u.StringWidth(this.field_0, var1) / 2;
         } else if (var2.equals("Right")) {
            var9 = var5 + var7 - this.user.u.StringWidth(this.field_0, var1) - 3;
         } else {
            var9 = var5 + 2;
         }

         if (var9 <= var5) {
            var9 = var5 + 1;
         }

         int var10 = this.StringHeight() - 5;
         int var11 = var10 + (var8 - var10) / 2;
         if (var1.indexOf("|") >= 0) {
            var11 = var10 + 2;

            for(StringTokenizer var12 = new StringTokenizer(var1, "|"); var12.hasMoreTokens(); var11 += var10 + 2) {
               this.field_0.drawString(var12.nextToken(), var9, var6 + var11);
            }
         } else {
            if (var11 <= var10) {
               var11 = var10;
            }

            this.field_0.drawString(var1, var9, var6 + var11);
         }

         this.field_0.setFont(this.plainFont);
      }

      this.field_0.setColor(Color.black);
   }

   public boolean handleEvent(Event var1) {
      if (!((Component)this).isEnabled()) {
         return true;
      } else {
         int var2 = this.columnOrder[this.currentColumn];
         if (this.pullDownScroll != null && var1.target.equals(this.pullDownScroll) && this.isPulledDown) {
            this.nothingChanged = false;
            switch (var1.id) {
               case 601:
               case 602:
               case 603:
               case 604:
               case 605:
                  this.pullDownList[var2][this.getPulldownRow(var2, this.currentRow)].makeVisible(this.pullDownScroll.getValue());
                  ((Component)this).repaint();
                  return true;
               default:
                  return true;
            }
         } else if (this.scrollEast != null && var1.target.equals(this.scrollEast)) {
            this.nothingChanged = false;
            this.isPulledDown = false;
            switch (var1.id) {
               case 601:
                  this.yOffset += -1;
                  ((Component)this).repaint();
                  return true;
               case 602:
                  ++this.yOffset;
                  ((Component)this).repaint();
                  return true;
               case 603:
                  this.yOffset = this.scrollEast.getValue();
                  ((Component)this).repaint();
                  return true;
               case 604:
                  this.yOffset = this.scrollEast.getValue();
                  ((Component)this).repaint();
                  return true;
               case 605:
                  this.yOffset = this.scrollEast.getValue();
                  ((Component)this).repaint();
                  return true;
               default:
                  return false;
            }
         } else if (this.scrollSouth != null && var1.target.equals(this.scrollSouth)) {
            this.nothingChanged = false;
            this.isPulledDown = false;
            switch (var1.id) {
               case 601:
                  this.xOffset += -1;
                  ((Component)this).repaint();
                  return true;
               case 602:
                  ++this.xOffset;
                  ((Component)this).repaint();
                  return true;
               case 603:
                  this.xOffset = this.scrollSouth.getValue();
                  ((Component)this).repaint();
                  return true;
               case 604:
                  this.xOffset = this.scrollSouth.getValue();
                  ((Component)this).repaint();
                  return true;
               case 605:
                  this.xOffset = this.scrollSouth.getValue();
                  ((Component)this).repaint();
                  return true;
               default:
                  return false;
            }
         } else {
            switch (var1.id) {
               case 202:
               case 205:
                  ((Component)this).repaint();
                  return false;
               case 401:
                  this.nothingChanged = false;
                  if ((var1.key == 10 || var1.key > 31 && var1.key < 127) && (this.isPulledDown || (this.isPullDown[var2][this.currentRow] || this.isPullDownCol[var2]) && (this.columnProtected[var2] || this.fieldProtected[var2][this.currentRow]))) {
                     if (this.pullDownType[var2][this.getPulldownRow(var2, this.currentRow)] != 1 && this.pullDownColType[var2] != 1) {
                        if (this.pullDownType[var2][this.getPulldownRow(var2, this.currentRow)] != 2 && this.pullDownColType[var2] != 2) {
                           byte[] var26 = new byte[]{(byte)var1.key};
                           String var10001 = this.searchString;
                           this.searchString = var10001 + new String(var26);
                           if (!this.searchString.endsWith("\n")) {
                              for(int var34 = 0; var34 < this.pullDownList[var2][this.getPulldownRow(var2, this.currentRow)].countItems(); ++var34) {
                                 if (this.pullDownList[var2][this.getPulldownRow(var2, this.currentRow)].getItem(var34).startsWith(this.searchString)) {
                                    this.pullDownList[var2][this.getPulldownRow(var2, this.currentRow)].select(var34);
                                    this.pullDownList[var2][this.getPulldownRow(var2, this.currentRow)].makeVisible(var34);
                                    if (!this.isPulledDown) {
                                       this.currentText[var2][this.currentRow] = this.pullDownList[var2][this.getPulldownRow(var2, this.currentRow)].getSelectedItem();
                                    }

                                    ((Component)this).repaint();
                                    return false;
                                 }
                              }
                           } else {
                              this.searchString = "";
                              this.currentText[var2][this.currentRow] = this.pullDownList[var2][this.getPulldownRow(var2, this.currentRow)].getSelectedItem();
                              this.isPulledDown = false;
                           }
                        } else {
                           this.isPulledDown = false;
                        }
                     } else {
                        this.isPulledDown = false;
                     }

                     this.rowChanged[this.currentRow] = true;
                     this.fieldSelected = false;
                     this.selectedFrom = 0;
                     this.selectedTo = 0;
                     this.prevColumn = this.currentColumn;
                     this.prevRow = this.currentRow;
                     if (var1.key == 10) {
                        this.thisEvent = new Event(this, 1001, "JDPTextGrid");
                     } else {
                        this.thisEvent = new Event(this, 1005, "JDPTextGrid");
                     }

                     ((Component)this).repaint();
                     return true;
                  } else {
                     if (var1.key == 10) {
                        this.thisEvent = new Event(this, 1001, "JDPTextGrid");
                        ((Component)this).getParent().postEvent(this.thisEvent);
                        this.thisEvent = null;
                     }

                     if (var1.key != 32 || this.fieldType[var2][this.currentRow] != 3 && this.fieldTypeCol[var2] != 3) {
                        this.keyDown(var1);
                        if (this.downButton != null) {
                           this.updateSpinner(0);
                        }

                        return true;
                     } else {
                        if (this.currentText[var2][this.currentRow].equals("Y")) {
                           this.currentText[var2][this.currentRow] = "N";
                        } else {
                           this.currentText[var2][this.currentRow] = "Y";
                        }

                        this.cellChanged[var2][this.currentRow] = true;
                        this.rowChanged[this.currentRow] = true;
                        this.thisGridOnly = true;
                        ((Component)this).repaint();
                        return true;
                     }
                  }
               case 402:
                  if (this.editMask[this.currentColumn] != null && !this.editMask[this.currentColumn].equals("")) {
                     if (this.editMaskType[this.currentColumn].equals("String")) {
                        this.JDPMaskEditMain.formatString(this, this.editMask[this.currentColumn]);
                     } else if (this.editMaskType[this.currentColumn].equals("Float")) {
                        this.JDPMaskEditMain.formatFloat(this, this.editMask[this.currentColumn]);
                     }
                  }

                  return false;
               case 403:
                  this.nothingChanged = false;
                  switch (var1.key) {
                     case 1002:
                        if (this.isPulledDown) {
                           this.shiftField(0, -10, var1);
                           return true;
                        }

                        this.yOffset = this.yOffset - this.displayedRows + 1;
                        ((Component)this).repaint();
                        return true;
                     case 1003:
                        if (this.isPulledDown) {
                           this.shiftField(0, 10, var1);
                           return true;
                        }

                        this.yOffset = this.yOffset + this.displayedRows - 1;
                        ((Component)this).repaint();
                        return true;
                     case 1004:
                        this.shiftField(0, -1, var1);
                        return true;
                     case 1005:
                        if (!this.isPulledDown && (this.isPullDown[var2][this.currentRow] || this.isPullDownCol[var2]) && !this.columnDisabled[var2] && !this.fieldDisabled[var2][this.currentRow]) {
                           this.isPulledDown = true;
                           ((Component)this).repaint();
                           return true;
                        }

                        this.shiftField(0, 1, var1);
                        return true;
                     case 1006:
                        if (this.isPulledDown) {
                           this.isPulledDown = false;
                           ((Component)this).repaint();
                           return true;
                        }

                        if (this.fieldSelected) {
                           this.cursorPos += -1;
                           this.thisGridOnly = true;
                           if (var1.modifiers == 1) {
                              if (this.cursorPos >= this.selectedFrom) {
                                 this.selectedTo = this.cursorPos;
                              } else {
                                 this.selectedFrom = this.cursorPos;
                              }
                           } else {
                              if (this.selectedFrom < this.selectedTo) {
                                 this.cursorPos = this.selectedFrom;
                              }

                              this.selectedFrom = this.cursorPos;
                              this.selectedTo = this.cursorPos;
                           }

                           this.repaintGrid(this.currentColumn, this.currentRow);
                        } else {
                           this.shiftField(-1, 0, var1);
                        }

                        return true;
                     case 1007:
                        if (this.isPulledDown) {
                           this.isPulledDown = false;
                           ((Component)this).repaint();
                           return true;
                        }

                        if (this.fieldSelected) {
                           ++this.cursorPos;
                           this.thisGridOnly = true;
                           if (var1.modifiers == 1) {
                              if (this.cursorPos <= this.selectedTo) {
                                 this.selectedFrom = this.cursorPos;
                              } else {
                                 this.selectedTo = this.cursorPos;
                              }
                           } else {
                              if (this.selectedFrom < this.selectedTo) {
                                 this.cursorPos = this.selectedTo;
                              }

                              this.selectedFrom = this.cursorPos;
                              this.selectedTo = this.cursorPos;
                           }

                           this.repaintGrid(this.currentColumn, this.currentRow);
                        } else {
                           this.shiftField(1, 0, var1);
                        }

                        return true;
                     default:
                        return false;
                  }
               case 501:
                  if (var1.target != this) {
                     return false;
                  } else {
                     this.nothingChanged = false;
                     ((Component)this).requestFocus();
                     this.mousePressed = true;
                     this.dragCount = 0;
                     if (this.pullDownRect != null && this.pullDownRect.inside(var1.x, var1.y)) {
                        if (!this.isPulledDown) {
                           if (!this.columnDisabled[var2] && !this.fieldDisabled[var2][this.currentRow]) {
                              this.isPulledDown = true;
                           }
                        } else {
                           this.isPulledDown = false;
                           this.prevColumn = this.currentColumn;
                           this.prevRow = this.currentRow;
                           this.thisEvent = new Event(this, 1005, "JDPTextGrid");
                        }

                        ((Component)this).repaint();
                        return true;
                     } else if (this.isPulledDown) {
                        if (this.pullDownCells != null) {
                           for(int var25 = 0; var25 < this.pullDownCells.length; ++var25) {
                              if (this.pullDownCells[var25] != null && this.pullDownCells[var25].inside(var1.x, var1.y)) {
                                 this.pullDownList[var2][this.getPulldownRow(var2, this.currentRow)].select(var25);
                                 this.isPulledDown = false;
                                 this.currentText[var2][this.currentRow] = this.pullDownList[var2][this.getPulldownRow(var2, this.currentRow)].getSelectedItem();
                                 this.rowChanged[this.currentRow] = true;
                                 this.fieldSelected = false;
                                 this.selectedFrom = 0;
                                 this.selectedTo = 0;
                                 this.prevColumn = this.currentColumn;
                                 this.prevRow = this.currentRow;
                                 this.thisEvent = new Event(this, 1005, "JDPTextGrid");
                                 ((Component)this).repaint();
                                 return true;
                              }
                           }
                        }

                        this.prevColumn = this.currentColumn;
                        this.prevRow = this.currentRow;
                        this.thisEvent = new Event(this, 1005, "JDPTextGrid");
                        this.isPulledDown = false;
                        this.thisGridOnly = false;
                        ((Component)this).repaint();
                        return true;
                     } else {
                        if (var1.y < this.columnHeadHeight + 4) {
                           if (this.colHeadRect[0] != null && this.colHeadRect[0].inside(var1.x, var1.y)) {
                              this.saveColumnWidth = this.rowHeaderWidth;
                              this.dragCol = -1;
                              this.initColXpoint = var1.x;
                              this.draggingColMouse = true;
                              this.repaintColHead(this.dragCol, var1.x);
                              return true;
                           }

                           for(int var24 = 0; var24 < this.displayedColumns; ++var24) {
                              if (this.colButton[var24] != null && this.colButton[var24].inside(var1.x, var1.y)) {
                                 if (var1.modifiers != 1) {
                                    this.initSelectColumn = -1;
                                    this.initSelectRow = -1;
                                 }

                                 if (var1.modifiers != 2) {
                                    this.resetSelections();
                                 }

                                 int var33 = 0;

                                 for(int var37 = 0; var37 < var24; ++var37) {
                                    var33 += this.columnWidth[this.columnOrder[var37 + this.xOffset]];
                                 }

                                 this.columnButtonOffset = var1.x - var33 - this.rowHeadWidth;
                                 this.dragCol = var24;
                                 this.initColXpoint = var1.x;
                                 this.draggingColButton = true;
                                 this.originalxOffset = this.xOffset;
                                 return true;
                              }

                              if (this.colHeadRect[var24 + 1] != null && this.colHeadRect[var24 + 1].inside(var1.x, var1.y)) {
                                 this.saveColumnWidth = this.columnWidth[this.columnOrder[var24 + this.xOffset]];
                                 this.dragCol = var24;
                                 this.initColXpoint = var1.x;
                                 this.draggingColMouse = true;
                                 this.repaintColHead(this.dragCol, var1.x);
                                 return true;
                              }
                           }
                        } else if (var1.x < this.rowHeadWidth) {
                           if (this.rowHeadRect[0] != null && this.rowHeadRect[0].inside(var1.x, var1.y)) {
                              this.saveColumnHeight = this.columnHeaderHeight;
                              this.dragRow = -1;
                              this.initRowYpoint = var1.y;
                              this.draggingRowMouse = true;
                              this.repaintRowHead(this.dragRow, var1.y);
                              return true;
                           }

                           for(int var23 = 0; var23 < this.displayedRows; ++var23) {
                              if (this.rowButton[var23] != null && this.rowButton[var23].inside(var1.x, var1.y)) {
                                 if (var1.modifiers != 1) {
                                    this.initSelectColumn = -1;
                                    this.initSelectRow = -1;
                                 }

                                 if (var1.modifiers != 2) {
                                    this.resetSelections();
                                 }

                                 this.currentSelectedRow = var23 + this.yOffset;
                                 this.rowSelected[var23 + this.yOffset] = true;

                                 for(int var32 = 0; var32 < this.totalColumns; ++var32) {
                                    this.cellSelected[var32][var23 + this.yOffset] = true;
                                 }

                                 this.setCursorInThisCell(0, var23 + this.yOffset);
                                 this.thisEvent = new Event(this, (new Date()).getTime(), 701, var1.x, var1.y, var1.key, var1.modifiers, new Integer(var23 + this.yOffset));
                                 ((Component)this).repaint(this.rowHeadWidth + 1, this.columnHeadHeight + 1, this.Bounds.width, this.Bounds.height);
                                 return true;
                              }

                              if (this.rowHeadRect[var23 + 1] != null && this.rowHeadRect[var23 + 1].inside(var1.x, var1.y)) {
                                 this.saveColumnHeight = this.columnHeight[var23 + this.yOffset];
                                 this.dragRow = var23;
                                 this.initRowYpoint = var1.y;
                                 this.draggingRowMouse = true;
                                 this.repaintRowHead(this.dragRow, var1.y);
                                 return true;
                              }
                           }
                        } else {
                           if (this.checkboxRect != null && this.checkboxRect.inside(var1.x, var1.y)) {
                              if (this.currentText[var2][this.currentRow].equals("Y")) {
                                 this.currentText[var2][this.currentRow] = "N";
                              } else {
                                 this.currentText[var2][this.currentRow] = "Y";
                              }

                              this.cellChanged[this.columnOrder[this.currentColumn]][this.currentRow] = true;
                              this.rowChanged[this.currentRow] = true;
                              this.repaintGrid(this.currentColumn, this.currentRow);
                              return true;
                           }

                           if ((this.downButton == null || !this.downButton.inside(var1.x, var1.y)) && (this.upButton == null || !this.upButton.inside(var1.x, var1.y))) {
                              for(int var22 = 0; var22 < this.displayedColumns; ++var22) {
                                 for(int var31 = 0; var31 < this.displayedRows; ++var31) {
                                    if (this.mouseRect[var22][var31] != null && this.mouseRect[var22][var31].inside(var1.x, var1.y)) {
                                       if (var1.modifiers != 1) {
                                          this.initSelectColumn = -1;
                                          this.initSelectRow = -1;
                                       }

                                       if (var1.modifiers != 2) {
                                          this.resetSelections();
                                       }

                                       this.cursorInThisField[this.currentColumn][this.currentRow] = false;
                                       if (!this.paintAll) {
                                          this.repaintGrid(this.currentColumn, this.currentRow);
                                       }

                                       if (this.initSelectColumn < 0) {
                                          this.initSelectColumn = var22 + this.xOffset;
                                          this.initSelectRow = var31 + this.yOffset;
                                       }

                                       if (this.currentColumn == var22 + this.xOffset && this.currentRow == var31 + this.yOffset) {
                                          int var36 = 0;
                                          if (this.cellFont[this.columnOrder[var22 + this.xOffset]][var31 + this.yOffset] != null) {
                                             this.field_0.setFont(this.cellFont[this.columnOrder[var22 + this.xOffset]][var31 + this.yOffset]);
                                          } else if (this.columnStyle[this.columnOrder[var22 + this.xOffset]] == 1) {
                                             this.field_0.setFont(this.boldFont);
                                          }

                                          while(this.lastpos + var36 <= this.currentText[this.columnOrder[var22 + this.xOffset]][var31 + this.yOffset].length() && this.mouseRect[var22][var31].x + this.user.u.StringWidth(this.field_0, this.currentText[this.columnOrder[var22 + this.xOffset]][var31 + this.yOffset].substring(this.lastpos, this.lastpos + var36)) < var1.x) {
                                             ++var36;
                                          }

                                          this.cursorPos = this.lastpos + var36 - 1;
                                          this.selectedFrom = this.cursorPos;
                                          this.selectedTo = this.cursorPos;
                                          this.fieldSelected = true;
                                          this.initcursorPos = this.cursorPos;
                                          this.thisGridOnly = true;
                                          this.prevColumn = this.currentColumn;
                                          this.prevRow = this.currentRow;
                                       } else {
                                          this.prevColumn = this.currentColumn;
                                          this.prevRow = this.currentRow;
                                          this.thisEvent = new Event(this, 1005, "JDPTextGrid");
                                          ((Component)this).postEvent(this.thisEvent);
                                          this.thisEvent = new Event(this, (new Date()).getTime(), 1004, var1.x, var1.y, var1.key, var1.modifiers, "JDPTextGrid");
                                          this.fieldSelected = false;
                                          this.cursorPos = this.currentText[this.columnOrder[var22 + this.xOffset]][var31 + this.yOffset].length();
                                          this.selectedFrom = 0;
                                          this.selectedTo = this.cursorPos;
                                       }

                                       this.currentColumn = var22 + this.xOffset;
                                       this.currentRow = var31 + this.yOffset;
                                       this.cursorColumn = this.currentColumn;
                                       this.cursorRow = this.currentRow;
                                       this.cursorInThisField[this.currentColumn][this.currentRow] = true;
                                       this.fieldDisplay = true;
                                       if (this.isPulledDown || !this.isPullDown[this.columnOrder[this.currentColumn]][this.currentRow] && !this.isPullDownCol[this.columnOrder[this.currentColumn]] || this.columnDisabled[this.columnOrder[this.currentColumn]] || this.fieldDisabled[this.columnOrder[this.currentColumn]][this.currentRow] || !this.columnProtected[this.columnOrder[this.currentColumn]] && !this.fieldProtected[this.columnOrder[this.currentColumn]][this.currentRow]) {
                                          if (!this.paintAll) {
                                             this.repaintGrid(this.currentColumn, this.currentRow);
                                          } else {
                                             ((Component)this).repaint();
                                          }

                                          return true;
                                       }

                                       this.thisGridOnly = false;
                                       this.isPulledDown = true;
                                       ((Component)this).repaint();
                                       return true;
                                    }
                                 }
                              }

                              return false;
                           }

                           byte var21 = 1;
                           if (this.downButton.inside(var1.x, var1.y)) {
                              var21 = -1;
                           }

                           this.setText(this.updateSpinner(var21));
                           this.selectedFrom = 0;
                           this.selectedTo = this.getText().length();
                           this.thisGridOnly = true;
                           this.cellChanged[this.columnOrder[this.currentColumn]][this.currentRow] = true;
                           this.rowChanged[this.currentRow] = true;
                           this.repaintGrid(this.currentColumn, this.currentRow);
                           return true;
                        }

                        return false;
                     }
                  }
               case 502:
                  this.nothingChanged = false;
                  this.dragCount = 0;
                  if (var1.target != this) {
                     return false;
                  } else if (this.draggingColMouse) {
                     this.thisEvent = new Event(this, (new Date()).getTime(), 10002, var1.x, var1.y, var1.key, var1.modifiers, new Integer(this.dragCol));
                     ((Component)this).repaint();
                     this.draggingColMouse = false;
                     return true;
                  } else if (this.draggingColButton) {
                     this.reorderColumns(this.dragCol, var1.x);
                     if (!this.columnMoved) {
                        this.columnSelected[this.dragCol + this.xOffset] = true;

                        for(int var20 = 0; var20 < this.totalRows; ++var20) {
                           this.cellSelected[this.dragCol + this.xOffset][var20] = true;
                        }

                        if (this.sortingEnabled) {
                           this.sortItems(false, this.columnOrder[this.dragCol + this.xOffset], this.sortDescending[this.dragCol + this.xOffset]);
                           this.sortDescending[this.dragCol + this.xOffset] = !this.sortDescending[this.dragCol + this.xOffset];
                           this.setCursorInThisCell(this.dragCol + this.xOffset, -1);
                        }

                        this.currentSelectedColumn = this.dragCol + this.xOffset;
                        this.thisEvent = new Event(this, (new Date()).getTime(), 701, var1.x, var1.y, var1.key, var1.modifiers, new Integer(this.dragCol));
                     } else {
                        this.thisEvent = new Event(this, (new Date()).getTime(), 10001, var1.x, var1.y, var1.key, var1.modifiers, new Integer(this.dragCol));
                     }

                     ((Component)this).repaint();
                     this.columnMoved = false;
                     this.draggingColButton = false;
                     return true;
                  } else if (this.draggingRowMouse) {
                     this.thisEvent = new Event(this, (new Date()).getTime(), 10003, var1.x, var1.y, var1.key, var1.modifiers, new Integer(this.dragRow));
                     ((Component)this).repaint();
                     this.draggingRowMouse = false;
                     return true;
                  } else {
                     if (this.mousePressed) {
                        this.mousePressed = false;
                     }

                     for(int var19 = 0; var19 < this.displayedColumns; ++var19) {
                        for(int var30 = 0; var30 < this.displayedRows; ++var30) {
                           if (this.mouseRect[var19][var30] != null && this.mouseRect[var19][var30].inside(var1.x, var1.y) && (this.columnDisabled[this.columnOrder[this.currentColumn]] || this.fieldDisabled[this.columnOrder[this.currentColumn]][this.currentRow])) {
                              this.thisEvent = new Event(this, (new Date()).getTime(), 701, var1.x, var1.y, var1.key, var1.modifiers, new Integer(var30 + this.yOffset));
                              ((Component)this).postEvent(this.thisEvent);
                              this.thisEvent = null;
                              return true;
                           }
                        }
                     }

                     return false;
                  }
               case 503:
                  if (this.user.jdpMainWindow != null) {
                     if (this.user.jdpMainWindow.getCursorType() == 3) {
                        return false;
                     }

                     for(int var17 = 0; var17 < this.colHeadRect.length; ++var17) {
                        if (this.colHeadRect[var17] != null && this.colHeadRect[var17].inside(var1.x, var1.y)) {
                           this.user.jdpMainWindow.setCursor(10);
                           return false;
                        }
                     }

                     for(int var18 = 0; var18 < this.rowHeadRect.length; ++var18) {
                        if (this.rowHeadRect[var18] != null && this.rowHeadRect[var18].inside(var1.x, var1.y)) {
                           this.user.jdpMainWindow.setCursor(8);
                           return false;
                        }
                     }

                     this.user.jdpMainWindow.setCursor(0);
                  }

                  return false;
               case 505:
                  if (this.user.jdpMainWindow != null) {
                     if (this.user.jdpMainWindow.getCursorType() == 3) {
                        return false;
                     }

                     this.user.jdpMainWindow.setCursor(0);
                  }

                  return false;
               case 506:
                  this.nothingChanged = false;
                  if (!this.mousePressed && this.dragCount++ >= 2) {
                     if (var1.x == this.lastevtx && var1.y == this.lastevty) {
                        return true;
                     }

                     if (this.draggingColMouse) {
                        if (var1.x != this.lastevtx) {
                           this.repaintColHead(this.dragCol, var1.x);
                        }

                        this.lastevtx = var1.x;
                        return true;
                     }

                     if (this.draggingColButton) {
                        if (var1.x == this.lastevtx) {
                           return true;
                        }

                        if (var1.x < this.rowHeadWidth) {
                           if (this.xOffset > 0) {
                              this.xOffset += -1;
                           }

                           var1.x = this.rowHeadWidth + 3;
                        }

                        if (var1.x > this.Bounds.width - this.rowHeadWidth) {
                           ++this.xOffset;
                           var1.x = this.Bounds.width - this.rowHeadWidth - 2;
                        }

                        this.repaintColHead(this.dragCol, var1.x);
                        this.lastevtx = var1.x;
                        return true;
                     }

                     if (this.draggingRowMouse) {
                        if (var1.y != this.lastevty) {
                           this.repaintRowHead(this.dragRow, var1.y);
                        }

                        this.lastevty = var1.y;
                        return true;
                     }

                     this.lastevty = var1.y;
                     this.lastevtx = var1.x;
                     if (this.fieldSelected) {
                        if (var1.x > this.rowHeadWidth && var1.y > this.columnHeadHeight) {
                           int var13;
                           for(var13 = 0; this.lastpos + var13 <= this.currentText[var2][this.currentRow].length() && this.mouseRect[this.currentColumn - this.xOffset][this.currentRow - this.yOffset].x + this.user.u.StringWidth(this.field_0, this.currentText[var2][this.currentRow].substring(this.lastpos, this.lastpos + var13)) < var1.x; ++var13) {
                           }

                           int var4 = this.lastpos + var13 - 1;
                           if (var4 < 0 && this.cursorPos == 0) {
                              return true;
                           }

                           if (var4 < this.cursorPos) {
                              this.cursorPos = var4;
                              if (this.cursorPos >= this.selectedFrom) {
                                 this.selectedTo = this.cursorPos;
                              } else {
                                 this.selectedFrom = this.cursorPos;
                                 this.selectedTo = this.initcursorPos;
                              }

                              this.thisGridOnly = true;
                              this.repaintGrid(this.currentColumn, this.currentRow);
                              return true;
                           }

                           if (var4 > this.cursorPos) {
                              this.cursorPos = var4;
                              if (this.cursorPos <= this.selectedTo) {
                                 this.selectedFrom = this.cursorPos;
                              } else {
                                 this.selectedTo = this.cursorPos;
                                 this.selectedFrom = this.initcursorPos;
                              }

                              this.thisGridOnly = true;
                              this.repaintGrid(this.currentColumn, this.currentRow);
                              return true;
                           }
                        }
                     } else {
                        int var14 = this.rowHeadWidth;
                        int var27 = this.columnHeadHeight;
                        if (var1.x < this.rowHeadWidth) {
                           if (this.xOffset > 0) {
                              this.xOffset += -1;
                              var27 = 0;
                           }

                           var1.x = this.rowHeadWidth + 3;
                        }

                        if (var1.x > this.Bounds.width - this.rowHeadWidth) {
                           ++this.xOffset;
                           var27 = 0;
                           var1.x = this.Bounds.width - this.rowHeadWidth - 2;
                        }

                        if (var1.y < this.columnHeadHeight + 3) {
                           if (this.yOffset > 0) {
                              this.yOffset += -1;
                              var14 = 0;
                           }

                           var1.y = this.columnHeadHeight + 3;
                        }

                        if (var1.y > this.Bounds.height - this.columnHeadHeight) {
                           ++this.yOffset;
                           var14 = 0;
                           var1.y = this.Bounds.height - this.columnHeadHeight - 2;
                        }

                        for(int var5 = 0; var5 < this.totalColumns; ++var5) {
                           this.columnSelected[var5] = false;

                           for(int var6 = 0; var6 < this.totalRows; ++var6) {
                              this.rowSelected[var6] = false;
                              this.saveColumnSelected[var5][var6] = this.cellSelected[var5][var6];
                              if (var1.modifiers != 2) {
                                 this.cellSelected[var5][var6] = false;
                              }
                           }
                        }

                        this.currentSelectedRow = -1;
                        this.currentSelectedColumn = -1;

                        for(int var35 = 0; var35 < this.displayedColumns; ++var35) {
                           for(int var38 = 0; var38 < this.displayedRows; ++var38) {
                              if (this.mouseRect[var35][var38] != null && this.mouseRect[var35][var38].inside(var1.x, var1.y)) {
                                 if (this.initSelectColumn < 0) {
                                    this.initSelectColumn = var35 + this.xOffset;
                                    this.initSelectRow = var38 + this.yOffset;
                                    this.cellSelected[this.initSelectColumn][this.initSelectRow] = true;
                                 } else {
                                    int var7 = var35 + this.xOffset - this.initSelectColumn;
                                    byte var8 = 1;
                                    if (var7 < 0) {
                                       var8 = -1;
                                    }

                                    int var9 = var38 + this.yOffset - this.initSelectRow;
                                    byte var10 = 1;
                                    if (var9 < 0) {
                                       var10 = -1;
                                    }

                                    for(int var11 = this.initSelectColumn; var11 != var35 + this.xOffset + var8; var11 += var8) {
                                       for(int var12 = this.initSelectRow; var12 != var38 + this.yOffset + var10; var12 += var10) {
                                          if (var11 < this.totalColumns && var12 < this.totalRows && var11 >= 0 && var12 >= 0) {
                                             this.cellSelected[var11][var12] = true;
                                          }
                                       }
                                    }
                                 }

                                 ((Component)this).repaint();
                                 return true;
                              }
                           }
                        }

                        ((Component)this).repaint();
                     }

                     return false;
                  }

                  this.mousePressed = false;
                  return true;
               case 701:
                  if (var1.target.equals(this.pullDownDisplayList)) {
                     this.setText(this.pullDownDisplayList.getSelectedItem());
                     this.cellChanged[this.columnOrder[this.currentColumn]][this.currentRow] = true;
                     this.rowChanged[this.currentRow] = true;
                     if (!this.isPulledDown) {
                        return true;
                     }

                     this.isPulledDown = false;
                     if (this.columnProtected[this.columnOrder[this.getCurrentColumn()]] || this.fieldProtected[this.columnOrder[this.getCurrentColumn()]][this.getCurrentRow()]) {
                        this.selectedFrom = 0;
                        this.selectedTo = this.getText().length();
                     }

                     this.pullDownList[this.columnOrder[this.getCurrentColumn()]][this.getPulldownRow(this.columnOrder[this.getCurrentColumn()], this.getCurrentRow())].select(this.pullDownDisplayList.getSelectedIndex());
                     this.thisEvent = new Event(this, 1005, "JDPTextGrid");
                     ((Component)this).repaint();
                     return true;
                  }

                  return false;
               case 1001:
                  if (var1.target.equals(this.calendar)) {
                     this.setText(this.calendar.getDateString());
                     this.cellChanged[this.columnOrder[this.currentColumn]][this.currentRow] = true;
                     this.rowChanged[this.currentRow] = true;
                     if (!this.isPulledDown) {
                        return true;
                     }

                     this.isPulledDown = false;
                     if (this.columnProtected[this.columnOrder[this.getCurrentColumn()]] || this.fieldProtected[this.columnOrder[this.getCurrentColumn()]][this.getCurrentRow()]) {
                        this.selectedFrom = 0;
                        this.selectedTo = this.getText().length();
                     }

                     ((Component)this).repaint();
                     return true;
                  } else {
                     if (var1.target instanceof Component && !var1.target.equals(this)) {
                        if (var1.arg instanceof String) {
                           this.setText((String)var1.arg);
                        }

                        this.cellChanged[this.columnOrder[this.currentColumn]][this.currentRow] = true;
                        this.rowChanged[this.currentRow] = true;
                        if (!this.isPulledDown) {
                           return false;
                        }

                        this.isPulledDown = false;
                        if (this.columnProtected[this.columnOrder[this.getCurrentColumn()]] || this.fieldProtected[this.columnOrder[this.getCurrentColumn()]][this.getCurrentRow()]) {
                           this.selectedFrom = 0;
                           this.selectedTo = this.getText().length();
                        }

                        ((Component)this).repaint();
                        Event var3 = new Event(this, var1.when, var1.id, var1.x, var1.y, var1.key, var1.modifiers, var1.arg);
                        super.postEvent(var3);
                        return true;
                     }

                     return false;
                  }
               case 1005:
                  if (var1.target.equals(this) && this.isPulledDown) {
                     return true;
                  }

                  if (!var1.target.equals(this) && !var1.target.equals(this.pullDownScroll) && (this.calendar == null || !var1.target.equals(this.calendar) && !var1.target.equals(this.calendar.leftButton) && !var1.target.equals(this.calendar.rightButton)) && this.isPulledDown) {
                     this.isPulledDown = false;
                     this.thisGridOnly = false;
                     ((Component)this).repaint();
                  }

                  return false;
               default:
                  return false;
            }
         }
      }
   }

   public void setCellSelected(int var1, int var2, boolean var3) {
      this.cellSelected[var1][var2] = var3;
      this.reDraw();
   }

   public boolean getCellSelected(int var1, int var2) {
      return this.cellSelected[var1][var2];
   }

   public void setPullDown(int var1, int var2, boolean var3) {
      this.isPullDown[var1][var2] = var3;
      this.setFieldType(var1, var2, 1);
      this.reDraw();
   }

   public boolean getPullDown(int var1, int var2) {
      return this.isPullDown[var1][var2];
   }

   public int getColumnOrder(int var1) {
      return this.columnOrder[var1];
   }

   public void setCellColor(int var1, int var2, Color var3) {
      this.cellColor[var1][var2] = var3;
      this.reDraw();
   }

   public Color getCellColor(int var1, int var2) {
      return this.cellColor[var1][var2];
   }

   public void setColumnGridColor(int var1, int var2, Color var3) {
      this.columnGridColor[var1][var2] = var3;
      this.reDraw();
   }

   public Color getColumnGridColor(int var1, int var2) {
      return this.columnGridColor[var1][var2];
   }

   public int getPrevColumn() {
      return this.prevColumn;
   }

   public int getSelectionEnd() {
      return this.selectedTo;
   }

   public void setPullDownValue(int var1, int var2, Vector var3) {
      this.pullDownValue[var1][var2] = var3;
   }

   public void update(Graphics var1) {
      byte var2 = 6;
      byte var3 = 5;
      int var4 = 1;
      int var5 = 1;
      int var6 = 0;
      this.upButton = null;
      this.downButton = null;
      this.checkboxRect = null;
      this.thisGridOnly = false;
      Rectangle var11 = ((Component)this).getParent().getParent().bounds();
      var11.height -= var3;
      var11.width -= var2;
      if (this.Bounds == null || var11.width != this.Bounds.width || var11.height != this.Bounds.height) {
         this.nothingChanged = false;
      }

      Dimension var12 = ((Component)this).size();
      if (this.prevSize == null || var12.width != this.prevSize.width || var12.height != this.prevSize.height) {
         this.nothingChanged = false;
      }

      this.back = ((Component)this).getBackground();
      if (this.gridColor == null) {
         this.gridColor = ((Component)this).getParent().getBackground();
      }

      this.plainFont = ((Component)this).getFont();
      this.boldFont = new Font(this.plainFont.getName(), 1, this.plainFont.getSize());
      if (this.field_0 != null) {
         this.field_0.setFont(this.plainFont);
         this.prevSize = var12;
         int var13 = this.StringHeight();
         if (var13 != this.lastFontHeight) {
            if (this.columnHeaderHeight == 0) {
               this.columnHeaderHeight = var13;
            }

            this.lastFontHeight = var13;

            for(int var14 = 0; var14 < this.totalRows; ++var14) {
               this.columnHeight[var14] = var13 + 3;
            }

            this.nothingChanged = false;
         }

         if (this.lastPlainFont != null && this.plainFont.getName().equals(this.lastPlainFont.getName())) {
            this.nothingChanged = false;
            this.lastPlainFont = this.plainFont;
         }
      }

      if (!this.isPulledDown && this.popup != null && this.popup.getEventListener() != null && this.popup.getEventListener().equals(this)) {
         this.searchString = "";
         this.pullDownRect = null;
         this.popup.hide();
      }

      if (this.nothingChanged && this.offscreen != null) {
         var1.drawImage(this.offscreen, var2 - 3, var3 - 2, (ImageObserver)null);
         var1.clearRect(0, var12.height - 2, var12.width, var12.height);
         var1.clearRect(var12.width - 3, 0, var12.width, var12.height);
      } else {
         this.nothingChanged = true;
         byte var30 = 15;
         if (this.scrollSouthDisabled) {
            var30 = 3;
         }

         this.Bounds = ((Component)this).bounds();
         Rectangle var10000 = this.Bounds;
         var10000.height -= var3;
         var10000 = this.Bounds;
         var10000.width -= var2;
         Rectangle var31 = ((Component)this).bounds();
         var31.height -= var3;
         var31.width -= var2;
         if (this.Bounds.width > 0 && this.Bounds.height > 0) {
            if (this.offscreen == null || this.Bounds.width != this.offscreensize.width || this.Bounds.height != this.offscreensize.height) {
               this.offscreen = ((Component)this).createImage(this.Bounds.width, this.Bounds.height);
               this.offscreensize = this.Bounds;
               this.field_0 = this.offscreen.getGraphics();
               this.field_0.setFont(this.plainFont);
            }

            if (!this.isPulledDown && this.pullDownScroll != null && this.pullDownScroll.isVisible()) {
               this.pullDownScroll.hide();
               this.nothingChanged = false;
            }

            int var7;
            int var8;
            int var9;
            int var10;
            if (!this.thisGridOnly) {
               this.columnHeadHeight = this.columnHeaderHeight;
               this.rowHeadWidth = this.rowHeaderWidth;
               if (!this.columnHeaderOn) {
                  this.columnHeadHeight = 0;
               }

               if (!this.rowHeaderOn) {
                  this.rowHeadWidth = 0;
               }

               this.field_0.setColor(Color.black);
               var7 = 0;
               var9 = 0;
               var8 = 0;
               var10 = 0;
               if (this.xOffset < 0) {
                  this.xOffset = 0;
               }

               int var15;
               for(var15 = 0; var15 < this.Bounds.width - 15 - this.rowHeadWidth && var8 + this.xOffset < this.totalColumns; ++var8) {
                  var15 += this.columnWidth[this.columnOrder[var8 + this.xOffset]];
               }

               if (var15 < this.Bounds.width - 15 - this.rowHeadWidth && this.xOffset > 0) {
                  this.xOffset = this.totalColumns - 1;

                  int[] var10001;
                  int[] var10002;
                  int var10005;
                  for(var15 = 0; var15 < this.Bounds.width - 15 - this.rowHeadWidth && this.xOffset >= 0; var15 += var10001[var10002[var10005]]) {
                     var10001 = this.columnWidth;
                     var10002 = this.columnOrder;
                     var10005 = this.xOffset;
                     this.xOffset = var10005 + -1;
                  }

                  ++this.xOffset;
                  int var58 = var15 - this.columnWidth[this.columnOrder[this.xOffset]];
                  var8 = this.totalColumns - this.xOffset - 1;
                  ++this.xOffset;
                  ++this.xOffset;
               }

               if (var8 > this.totalColumns) {
                  var8 = this.totalColumns;
               }

               if (this.yOffset < 0) {
                  this.yOffset = 0;
               }

               int var16;
               for(var16 = 0; var16 < this.Bounds.height - var30 - this.columnHeadHeight && var10 + this.yOffset < this.totalRows; ++var10) {
                  var16 += this.columnHeight[var10 + this.yOffset];
               }

               if (var16 < this.Bounds.height - var30 - this.columnHeadHeight && this.yOffset > 0) {
                  this.yOffset = this.totalRows - 1;

                  int[] var61;
                  int var10004;
                  for(var16 = 0; var16 < this.Bounds.height - var30 - this.columnHeadHeight && this.yOffset >= 0; var16 += var61[var10004]) {
                     var61 = this.columnHeight;
                     var10004 = this.yOffset;
                     this.yOffset = var10004 + -1;
                  }

                  ++this.yOffset;
                  int var59 = var16 - this.columnHeight[this.yOffset];
                  var10 = this.totalRows - this.yOffset - 1;
                  ++this.yOffset;
                  ++this.yOffset;
               }

               if (var10 > this.totalRows) {
                  var10 = this.totalRows;
               }

               this.displayedColumns = var8;
               this.displayedRows = var10;
               if (this.displayedRows <= this.totalRows && !this.scrollEastDisabled) {
                  if (this.scrollEast == null) {
                     this.scrollEast = new Scrollbar(1, 0, 5, 0, 100);
                     ((Container)this).add(this.scrollEast);
                  }

                  this.scrollEast.move(this.Bounds.width - 10, 5);
                  this.scrollEast.resize(12, this.Bounds.height - var30);
                  this.scrollEast.show();
               } else {
                  this.displayedRows = this.totalRows;
                  var10 = this.totalRows;
                  if (this.scrollEast != null) {
                     this.scrollEast.hide();
                  }
               }

               if (this.displayedColumns <= this.totalColumns && !this.scrollSouthDisabled) {
                  if (this.scrollSouth == null) {
                     this.scrollSouth = new Scrollbar(0, 0, 5, 0, 100);
                     ((Container)this).add(this.scrollSouth);
                  }

                  this.scrollSouth.move(5, this.Bounds.height - 10);
                  if (this.scrollEast != null && this.scrollEast.isVisible()) {
                     this.scrollSouth.resize(this.Bounds.width - 15, 12);
                  } else {
                     this.scrollSouth.resize(this.Bounds.width - 3, 12);
                  }

                  this.scrollSouth.show();
               } else {
                  this.displayedColumns = this.totalColumns;
                  var8 = this.totalColumns;
                  if (this.scrollSouth != null) {
                     this.scrollSouth.hide();
                  }
               }

               if (this.xOffset > this.totalColumns - this.displayedColumns) {
                  this.xOffset = this.totalColumns - this.displayedColumns;
               }

               if (this.yOffset > this.totalRows - this.displayedRows) {
                  this.yOffset = this.totalRows - this.displayedRows;
               }

               int var17 = 0;

               for(int var18 = 0; var18 < this.totalRows; ++var18) {
                  var17 += this.columnHeight[var18];
               }

               if (this.scrollEast != null) {
                  int var44 = this.scrollEast.getValue();
                  int var19 = (int)((float)this.totalRows * ((float)(this.Bounds.height - var30 - this.columnHeadHeight) / (float)var17));
                  int var20 = (int)((float)this.totalRows * (((float)var17 - ((float)this.Bounds.height - (float)var30 - (float)this.columnHeadHeight)) / (float)var17)) + 1;
                  int var21 = 0;
                  if (System.getProperty("java.vendor").startsWith("Netscape") && System.getProperty("java.version").compareTo("1.1.5") < 0 || System.getProperty("java.vendor").startsWith("Microsoft") && System.getProperty("java.version").compareTo("1.1.4") < 0) {
                     var21 = var19;
                  }

                  this.scrollEast.setValues(var44, var19, 0, var20 + var19 - var21);
               }

               var17 = 0;

               for(int var45 = 0; var45 < this.totalColumns; ++var45) {
                  var17 += this.columnWidth[this.columnOrder[var45]];
               }

               if (this.scrollSouth != null) {
                  int var46 = this.scrollSouth.getValue();
                  int var48 = (int)((float)this.totalColumns * ((float)(this.Bounds.width - 15 - this.rowHeadWidth) / (float)var17));
                  int var50 = (int)((float)this.totalColumns * (((float)var17 - ((float)this.Bounds.width - 15.0F - (float)this.rowHeadWidth)) / (float)var17)) + 1;
                  int var52 = 0;
                  if (System.getProperty("java.vendor").startsWith("Netscape") && System.getProperty("java.version").compareTo("1.1.5") < 0 || System.getProperty("java.vendor").startsWith("Microsoft") && System.getProperty("java.version").compareTo("1.1.4") < 0) {
                     var52 = var48;
                  }

                  this.scrollSouth.setValues(var46, var48, 0, var50 + var48 - var52);
               }

               if (this.rowHeaderOn && this.columnHeaderOn) {
                  this.drawButton("", (String)null, Color.black, 1, var4 + 1, var5 + 1, this.rowHeadWidth, this.columnHeadHeight);
               }
            } else {
               var7 = this.currentColumn - this.xOffset;
               var8 = this.displayedColumns;
               var9 = this.currentRow - this.yOffset;
               var10 = this.currentRow - this.yOffset + 1;
               if (this.rowHeaderOn) {
                  var4 += this.rowHeaderWidth;
               }

               int var33 = 0;

               for(int var34 = 0; var34 < var7; ++var34) {
                  var4 += this.columnWidth[this.columnOrder[var34 + this.xOffset]];
               }

               if (this.columnHeaderOn) {
                  var5 = var5 + this.columnHeaderHeight + 1;
               }

               for(var33 = 0; var33 < var9; ++var33) {
                  var5 += this.columnHeight[var33 + this.yOffset];
               }

               int var60 = this.columnHeight[var33 + this.yOffset];
            }

            if (this.columnHeaderOn) {
               this.colHeadRect[0] = new Rectangle(this.rowHeaderWidth + var4 + 1, var5 + 3, 4, this.columnHeadHeight);
            }

            for(int var36 = var7; var36 < var8; ++var36) {
               if (var36 + this.xOffset >= this.columnOrder.length) {
                  this.xOffset = 0;
               }

               int var40 = this.columnOrder[var36 + this.xOffset];
               int var43 = var36 + this.xOffset;
               int var47 = this.columnWidth[var40];
               if (this.rowHeaderOn && var36 == 0 && !this.thisGridOnly) {
                  var4 += this.rowHeadWidth;
               }

               if (!this.thisGridOnly) {
                  var5 = 1;
                  if (this.columnHeaderOn) {
                     this.drawButton(this.columnHeader[var40], this.rightJustify[var40], this.columnHeaderColor[var40], this.columnHeaderStyle[var40], var4 + 1, var5 + 1, var47, this.columnHeadHeight);
                     this.colButton[var36] = new Rectangle(var4 + 5, var5 + 3, var47 - 4, this.columnHeadHeight);
                     this.colHeadRect[var36 + 1] = new Rectangle(var4 + var47 + 1, var5 + 3, 4, this.columnHeadHeight);
                     var5 = var5 + this.columnHeadHeight + 1;
                  }
               }

               if (!this.draggingColMouse && !this.draggingColButton) {
                  if (this.rowHeaderOn && var36 == 0) {
                     this.rowHeadRect[0] = new Rectangle(var4 - this.rowHeadWidth + 3, var5 + 1, this.rowHeadWidth, 4);
                  }

                  for(int var51 = var9; var51 < var10; ++var51) {
                     var6 = this.columnHeight[var51 + this.yOffset];
                     if (this.rowHeaderOn && var36 == 0 && !this.thisGridOnly) {
                        var4 -= this.rowHeadWidth;
                        this.drawButton(this.rowHeader[var51 + this.yOffset], this.rowHeadJustify, Color.black, 1, var4 + 1, var5 + 1, this.rowHeadWidth, var6 - 1);
                        this.rowButton[var51] = new Rectangle(var4 + 3, var5 + 5, this.rowHeadWidth, var6 - 4);
                        this.rowHeadRect[var51 + 1] = new Rectangle(var4 + 3, var5 + var6 + 1, this.rowHeadWidth, 4);
                        var4 += this.rowHeadWidth;
                     }

                     if (!this.draggingRowMouse) {
                        int var53 = var51 + this.yOffset;
                        if (this.currentText[var40][var53] == null) {
                           this.currentText[var40][var53] = "";
                        }

                        boolean var22 = false;
                        boolean var23 = false;
                        int var24 = 0;

                        for(int var25 = var36 + this.xOffset - 1; var25 >= this.xOffset; --var25) {
                           int var26 = this.columnOrder[var25];
                           var24 += this.columnWidth[var26];
                           if (this.cellFont[var26][var53] != null) {
                              this.field_0.setFont(this.cellFont[var26][var53]);
                           } else if (this.columnStyle[var26] == 1) {
                              this.field_0.setFont(this.boldFont);
                           }

                           if (this.currentText[var26][var53] != null && !this.currentText[var26][var53].equals("") && this.user.u.StringWidth(this.field_0, this.currentText[var26][var53]) > var24 - 2) {
                              var22 = true;
                              if (this.cursorInThisField[var25][var53] && this.fieldSelected) {
                                 var23 = true;
                              }

                              if (!this.thisGridOnly) {
                                 break;
                              }
                           }

                           if (this.currentText[var26][var53] != null && !this.currentText[var26][var53].equals("") && !this.thisGridOnly && !this.fieldSelected || this.thisGridOnly && this.cursorInThisField[var25][var53]) {
                              break;
                           }
                        }

                        this.field_0.setFont(this.plainFont);
                        if (this.fieldDisplay && this.cursorInThisField[var43][var53] || !this.currentText[var40][var53].equals("") && !var23 || !var22) {
                           if (this.cellFont[var40][var53] != null) {
                              this.field_0.setFont(this.cellFont[var40][var53]);
                           } else if (this.columnStyle[var40] == 1) {
                              this.field_0.setFont(this.boldFont);
                           }

                           int var54 = this.user.u.StringWidth(this.field_0, this.currentText[var40][var53]);
                           int var49 = var47;
                           this.thisSubstring = this.currentText[var40][var53].length();
                           if (var54 > var47 && var43 + 1 < this.totalColumns && (!this.fieldSelected || this.fieldSelected && !this.cursorInThisField[var43][var53]) && (this.currentText[this.columnOrder[var43 + 1]][var53] != null && !this.currentText[this.columnOrder[var43 + 1]][var53].equals("") || this.cursorInThisField[var43 + 1][var53])) {
                              this.thisSubstring = 0;

                              while(this.currentText[var40][var53].length() > this.thisSubstring && this.user.u.StringWidth(this.field_0, this.currentText[var40][var53].substring(0, this.thisSubstring++)) < var47) {
                              }
                           } else {
                              for(int var55 = var36 + this.xOffset; var54 + 3 > var49 && var55 + 1 < this.totalColumns; var49 += this.columnWidth[this.columnOrder[var55]]) {
                                 ++var55;
                              }

                              if (var54 > var49 && var43 + 1 < this.totalColumns) {
                                 this.thisSubstring = 0;

                                 while(this.user.u.StringWidth(this.field_0, this.currentText[var40][var53].substring(0, this.thisSubstring++)) < var47) {
                                 }
                              }
                           }

                           if (this.fieldSelected) {
                              this.mouseRect[var36][var51] = new Rectangle(var4 + 3, var5 + 3, var49, var6);
                           } else {
                              this.mouseRect[var36][var51] = new Rectangle(var4 + 3, var5 + 3, var47, var6);
                           }

                           if (this.cursorInThisField[var43][var53]) {
                              this.drawSelectedField(var40, var53, var4, var5, var49, var6);
                           } else {
                              if (this.cellSelected[var43][var53]) {
                                 this.field_0.setColor(this.textHighlight);
                              } else {
                                 this.field_0.setColor(this.columnBGColor[var40]);
                              }

                              this.field_0.fillRect(var4 + 1, var5 + 1, var49 - 1, var6 - 1);
                              if (this.rowGridColor[var40][var53] != null) {
                                 this.field_0.setColor(this.rowGridColor[var40][var53]);
                              } else {
                                 this.field_0.setColor(this.gridColor);
                              }

                              this.field_0.drawLine(var4, var5, var4 + var49, var5);
                              this.field_0.drawLine(var4, var5 + var6, var4 + var49, var5 + var6);
                              if (this.columnGridColor[var40][var53] != null) {
                                 this.field_0.setColor(this.columnGridColor[var40][var53]);
                              } else {
                                 this.field_0.setColor(this.gridColor);
                              }

                              this.field_0.drawLine(var4, var5, var4, var5 + var6);
                              this.field_0.drawLine(var4 + var49, var5, var4 + var49, var5 + var6);
                              this.field_0.setColor(Color.black);
                              if (this.columnHeaderOn && var51 == 0) {
                                 this.field_0.drawLine(var4 + 1, var5, var4 + var49 - 1, var5);
                              }

                              if (this.rowHeaderOn && var36 == 0) {
                                 this.field_0.drawLine(var4, var5, var4, var5 + var6);
                              }

                              if (this.cellSelected[var43][var53]) {
                                 this.field_0.setColor(this.textHighlightText);
                              } else if (this.cellColor[var40][var53] != null) {
                                 this.field_0.setColor(this.cellColor[var40][var53]);
                              } else {
                                 this.field_0.setColor(this.columnColor[var40]);
                              }

                              if (this.cellFont[var40][var53] != null) {
                                 this.field_0.setFont(this.cellFont[var40][var53]);
                              } else if (this.columnStyle[var40] == 1) {
                                 this.field_0.setFont(this.boldFont);
                              }

                              int var56 = 0;
                              if (this.rightJustify[var40]) {
                                 var56 = var47 - this.user.u.StringWidth(this.field_0, this.currentText[var40][var53]) - 5;
                                 if (var56 < 0) {
                                    var56 = 0;
                                 }
                              }

                              int var27 = this.StringHeight();
                              if (this.fieldType[var40][var53] != 3 && this.fieldTypeCol[var40] != 3) {
                                 if (this.currentText[var40][var53] != null && this.currentText[var40][var53].length() > 0) {
                                    this.field_0.drawString(this.currentText[var40][var53].substring(0, this.thisSubstring), var4 + 3 + var56, var5 + var27 - 1);
                                 }
                              } else {
                                 this.drawCheckbox(var40, var53, var4, var5, var47, var6);
                              }
                           }
                        }
                     }

                     if (!this.thisGridOnly) {
                        var5 += var6;
                     }

                     this.field_0.setFont(this.plainFont);
                  }
               }

               var4 += var47;
            }

            if (this.draggingColButton) {
               int var37 = this.columnOrder[this.dragCol + this.originalxOffset];
               if (this.columnHeaderStyle[var37] == 1) {
                  this.field_0.setFont(this.boldFont);
               } else {
                  this.field_0.setFont(this.plainFont);
               }

               int var41 = this.user.u.StringWidth(this.field_0, this.columnHeader[var37]);
               if (var41 < this.columnWidth[var37]) {
                  var41 = this.columnWidth[var37];
               }

               this.drawButton(this.columnHeader[var37], this.rightJustify[var37], this.columnHeaderColor[var37], this.columnHeaderStyle[var37], this.currentXpos - this.columnButtonOffset, 2, var41, this.columnHeadHeight);
            }

            if (!this.thisGridOnly) {
               this.field_0.setColor(this.back);
               if (var4 < this.Bounds.width) {
                  this.field_0.fillRect(var4 + 1, 1, this.Bounds.width - 1, this.Bounds.height - 1);
                  this.field_0.fillRect(var4, this.columnHeaderHeight + 3, this.Bounds.width - 1, this.Bounds.height - 1);
               }

               if (var5 < this.Bounds.height) {
                  this.field_0.fillRect(1, var5 + 1, this.Bounds.width - 1, this.Bounds.height - 1);
               }

               if (this.scrollEast != null && this.scrollSouth != null && this.scrollEast.isVisible() && this.scrollSouth.isVisible()) {
                  this.field_0.setColor(this.back);
                  this.field_0.fillRect(this.Bounds.width - 14, this.Bounds.height - 14, 13, 13);
               }

               this.field_0.setColor(JDPUtils.darker(this.gridColor));
               this.field_0.drawLine(0, 0, 0, this.Bounds.height);
               this.field_0.drawLine(0, 0, this.Bounds.width, 0);
               this.field_0.setColor(JDPUtils.darker(JDPUtils.darker(this.gridColor)));
               this.field_0.drawLine(1, 1, this.Bounds.width - 1, 1);
               this.field_0.drawLine(1, 1, 1, this.Bounds.height - 1);
            }

            this.field_0.setColor(this.back);
            this.field_0.drawLine(2, this.Bounds.height - 2, this.Bounds.width - 2, this.Bounds.height - 2);
            this.field_0.drawLine(this.Bounds.width - 2, 2, this.Bounds.width - 2, this.Bounds.height - 2);
            this.field_0.setColor(JDPUtils.brighter(this.back));
            this.field_0.drawLine(1, this.Bounds.height - 1, this.Bounds.width - 1, this.Bounds.height - 1);
            this.field_0.drawLine(this.Bounds.width - 1, 1, this.Bounds.width - 1, this.Bounds.height - 1);
            this.fieldDisplay = false;
            this.thisGridOnly = false;
            this.paintAll = false;
            int var38 = this.columnOrder[this.currentColumn];
            if ((this.getPulldownRow(var38, this.currentRow) < 0 || this.getPulldownRow(var38, this.currentRow) >= this.pullDownType[var38].length || this.pullDownType[var38][this.getPulldownRow(var38, this.currentRow)] != 1) && this.pullDownColType[var38] != 1) {
               if ((this.getPulldownRow(var38, this.currentRow) < 0 || this.getPulldownRow(var38, this.currentRow) >= this.pullDownType[var38].length || this.pullDownType[var38][this.getPulldownRow(var38, this.currentRow)] != 2) && this.pullDownColType[var38] != 2) {
                  if ((this.getPulldownRow(var38, this.currentRow) < 0 || this.getPulldownRow(var38, this.currentRow) >= this.pullDownType[var38].length || this.pullDownType[var38][this.getPulldownRow(var38, this.currentRow)] != 3) && this.pullDownColType[var38] != 3) {
                     this.drawPullDownList();
                  } else {
                     this.drawListPullDown();
                  }
               } else {
                  this.drawCustomPullDown();
               }
            } else {
               this.drawDatePullDown();
            }

            var1.drawImage(this.offscreen, var2 - 3, var3 - 2, (ImageObserver)null);
            var1.clearRect(0, var12.height - 2, var12.width, var12.height);
            var1.clearRect(var12.width - 3, 0, var12.width, var12.height);
            if (this.thisEvent != null) {
               ((Component)this).postEvent(this.thisEvent);
            }

            this.thisEvent = null;
            if (!this.nothingChanged) {
               ((Component)this).repaint();
            }

         }
      }
   }

   public Vector getPullDownValue(int var1, int var2) {
      return this.pullDownValue[var1][var2];
   }

   public int getTableRows() {
      return this.totalRows;
   }

   void drawSpinner(int var1, int var2, int var3, int var4, int var5, int var6) {
      Color var7 = this.field_0.getColor();
      var6 /= 2;
      var3 = var3 + var5 - 6;
      this.upButton = new Rectangle(var3, var4 + 4, 9, var6);
      this.downButton = new Rectangle(var3, var4 + 4 + var6, 9, var6);
      this.drawButton("", Color.black, 1, var3 - 3, var4 + 1, 9, var6 - 1);
      int var8 = var3 + 1;
      int var9 = var4 + var6 / 2;
      int[] var10 = new int[]{var8 - 3, var8, var8 + 3, var8 - 3};
      int[] var11 = new int[]{var9 + 2, var9 - 2, var9 + 2, var9 + 2};
      this.field_0.setColor(Color.black);
      this.field_0.fillPolygon(var10, var11, 3);
      this.drawButton("", Color.black, 1, var3 - 3, var4 + 1 + var6, 9, var6 - 1);
      var9 += var6;
      int[] var12 = new int[]{var8 - 2, var8, var8 + 3, var8 - 2};
      int[] var13 = new int[]{var9 - 1, var9 + 2, var9 - 1, var9 - 1};
      this.field_0.setColor(Color.black);
      this.field_0.fillPolygon(var12, var13, 3);
      this.field_0.setColor(var7);
   }

   public void setColumnHeaderStyle(int var1, int var2) {
      this.columnHeaderStyle[var1] = var2;
      this.reDraw();
   }

   public int getColumnHeaderStyle(int var1) {
      return this.columnHeaderStyle[var1];
   }

   public void setColumnStyle(int var1, int var2) {
      this.columnStyle[var1] = var2;
      this.reDraw();
   }

   public int getColumnStyle(int var1) {
      return this.columnStyle[var1];
   }

   public void setRowHeight(int var1, int var2) {
      this.columnHeight[var1] = var2;
      this.reDraw();
   }

   public int getRowHeight(int var1) {
      return this.columnHeight[var1];
   }

   public int getSelectedRow() {
      return this.currentSelectedRow;
   }

   public int getRowOffset() {
      return this.yOffset;
   }

   public void setRowOffset(int var1) {
      this.yOffset = var1;
      this.reDraw();
   }

   public Dimension minimumSize() {
      Dimension var1 = new Dimension(this.minimumWidth, this.minimumHeight);
      return var1;
   }

   public void setPullDownCol(int var1, boolean var2) {
      this.isPullDownCol[var1] = var2;
      this.reDraw();
   }

   public boolean getPullDownCol(int var1) {
      return this.isPullDownCol[var1];
   }

   public int getDisplayedRows() {
      return this.displayedRows;
   }

   public int getDisplayedColumns() {
      return this.displayedColumns;
   }

   public void setColumnHeaderOn(boolean var1) {
      this.columnHeaderOn = var1;
      this.reDraw();
   }

   public boolean getColumnHeaderOn() {
      return this.columnHeaderOn;
   }

   public String[] getSelectedKey() {
      String[] var1 = null;
      if (this.currentRow >= 0 && this.currentRow < this.rowKey.length) {
         var1 = new String[this.rowKey[0].length];

         for(int var2 = 0; var2 < var1.length; ++var2) {
            var1[var2] = this.rowKey[this.currentRow][var2];
         }
      }

      return var1;
   }

   public void setRowKey(String var1, int var2, int var3) {
      this.rowKey[var2][var3] = var1;
   }

   public String getRowKey(int var1, int var2) {
      return this.rowKey[var1][var2];
   }

   public void setScrollSouthDisabled(boolean var1) {
      this.scrollSouthDisabled = var1;
      this.reDraw();
   }

   public boolean getScrollSouthDisabled() {
      return this.scrollSouthDisabled;
   }
}