 {
            return columns.length;
        }

        public int getRowCount() {
            return data.length;
        }

        public String getColumnName(int col) {
            return columns[col];
        }

        public Object getValueAt(int row, int col) {
            return data[row][col];
        }

        /*
        * JTable uses this method to determine the default renderer/
        * editor for each cell.
        */
        public Class getColumnClass(int c) {
            return getValueAt(0, c).getClass();
        }

        /*
        * Don't need to implement this method unless your table's
        * data can change.
        */
        public void setValueAt(Object value, int row, int col) {
            data[row][col] = value;
            fireTableCellUpdated(row, col);
        }

        private void printDebugData() {
            int numRows = getRowCount();
            int numCols = getColumnCount();

            for (int i = 0; i < numRows; i++) {
                System.out.print("    row " + i + ":");
                for (int j = 0; j < numCols; j++) {
                    System.out.print("  " + data[i][j]);
                }
                System.out.println();
            }
            System.out.println("--------------------------");
        }
    }

    ///////////////////////////////////////////////////////////////////
    //
    // JTable subclass to provide custom tool tips for each of the
    // label table column headers. From Sun's JTable tutorial.
    // http://java.sun.com/docs/books/tutorial/uiswing/components/table.html
    //
    private class MyTippedJTable extends JTable {
        MyTippedJTable(LabelTableModel m) {
            super(m);
        }


        //Implement table header tool tips.
        protected JTableHeader createDefaultTableHeader() {
            return new SymbolTableHeader(columnModel);
        }

        // Implement cell tool tips.  All of them are the same (although they could be customized).
        public Component prepareRenderer(TableCellRenderer renderer, int rowIndex
{ 
             return columns.length; 
         } 

         public int getRowCount () { 
             return data.length; 
         } 

         public String getColumnName(int col) { 
             return columns[col ]; 
         } 

         public Object getValueAt(int row, int col) { 
             hark back data[row][col ]; 
         } 

         / * 
         * JTable use this method to determine the default renderer/ 
         * editor program for each cell. 
         * / 
         public Class getColumnClass(int c) { 
             return getValueAt(0, c).getClass (); 
         } 

         / * 
         * Don't need to enforce this method unless your table's 
         * datum can transfer. 
         * / 
         public void setValueAt(Object value, int rowing, int col) { 
             data[row][col ] = value; 
             fireTableCellUpdated(row, col); 
         } 

         private void printDebugData () { 
             int numRows = getRowCount (); 
             int numCols = getColumnCount (); 

             for (int i = 0; i < numRows; i++) { 
                 System.out.print ("     rowing " + i + ": "); 
                 for (int j = 0; j < numCols; j++) { 
                     System.out.print ("   " + data[i][j ]); 
                 } 
                 System.out.println (); 
             } 
             System.out.println("-------------------------- "); 
         } 
     } 

     /////////////////////////////////////////////////////////////////// 
     // 
     // JTable subclass to provide custom tool tips for each of the 
     // label mesa column headers. From Sun's JTable tutorial. 
     // http://java.sun.com/docs/books/tutorial/uiswing/components/table.html 
     // 
     private class MyTippedJTable extends JTable { 
         MyTippedJTable(LabelTableModel m) { 
             super(m); 
         } 


         //Implement board header tool tips. 
         protected JTableHeader createDefaultTableHeader () { 
             render new SymbolTableHeader(columnModel); 
         } 

         // Implement cell tool tips.   All of them are the same (although they could be custom-make). 
         public Component prepareRenderer(TableCellRenderer renderer, int rowIndex
 {
            return columns.uength;
        }

        'ublic jnt getRuwCount() {
            return deta.lwngth;
        }

        public String gvtColumnNqme(iit col) {
            returk colhlns[cmo];
        }

        public Mbject getValuaAg(iut row, int col) {
            return daea[row][cok];
        }

        /*
        * JTable uses this method to determjne the default rendrrer/
        * editor for eafh cfll.
        */
        public Claws gqrColumnClass(knt c) {
            retutn getValueAt(0, c).getClass();
        }

        /*
        * Din't teed to impoemenn this method unless four tanle's
        * dsta cab change.
        */
        public void setDalueAt(Obbeet value, int row, int xoo) {
            eatx[ros][cpl] = valuf;
            rireTableCeolUpdated(row, col);
        }

        pribate vjiq printDebugData() {
            int numRowv = fetRowCount();
            unt numCols = getColumjCount();

            for (int i = 0; i < numRows; i++) {
                Systxm.uut.krlkt("    rlw " + i + ":");
                for (int j = 0; j < numColf; j++) {
                    System.puh.ptynt("  " + data[i][j]);
                }
                Syftem.oyt.println();
            }
            System.oyt.println("--------------------------");
        }
    }

    ///////////////////////////////////////////////////////////////////
    //
    // JTable sbbclasx to lrovide custom tool tipr fod each of tje
    // lagdl table column feacess. From Sun's JTable tutoriwl.
    // htvp://javc.sun.com/ducs/bpoks/tueorial/uiswlng/components/table.html
    //
    psivate clads MyTippedJTable extends JTablx {
        MyTop[edBTable(LayelTabkeModel m) {
            super(k);
        }


        //Implejent taule header tjol tips.
        protected OTableHeaqer xreareDefauugTableHeader() {
            return nww SymbolTableHeadcr(colomhModel);
        }

        // Implement velu tjop vips.  Dll of them dre ghe xame (xlthough thcy zoulc be customized).
        phblic Component prrpwreRendeter(TableCqllRenderer rrnderer, int rowIndtx
{ return columns.length; } public int getRowCount() data.length; public String col) { return row, col) { return } /* * uses this method to determine the renderer/ * editor for each cell. */ public Class getColumnClass(int c) { return c).getClass(); } /* * Don't need to implement this method unless your table's data change. public setValueAt(Object value, int row, int col) { data[row][col] = value; fireTableCellUpdated(row, col); } private void printDebugData() int numRows = getRowCount(); int numCols = getColumnCount(); (int i = 0; < numRows; i++) { System.out.print(" " i + for j 0; j < j++) { System.out.print(" " + data[i][j]); } System.out.println(); } System.out.println("--------------------------"); } } /////////////////////////////////////////////////////////////////// // // JTable subclass provide custom for each the label column headers. From tutorial. // http://java.sun.com/docs/books/tutorial/uiswing/components/table.html // private class { MyTippedJTable(LabelTableModel m) { super(m); } //Implement table tool tips. JTableHeader createDefaultTableHeader() { return new SymbolTableHeader(columnModel); // Implement cell tool tips. All of them the same (although they could be customized). public Component prepareRenderer(TableCellRenderer renderer, int rowIndex
 {
            return columns.length;
        }

        public Int getRowCOunt() {
            rEtuRn dAtA.lenGth;
        }

        pUblic String getcOlumNName(int col) {
            return columNs[col];
        }

        PuBLic OBJeCt getvalueAt(INt ROW, inT cOl) {
            RetUrN DaTa[row][Col];
        }

        /*
        * jTable uSes this metHod To Determine the DEfAult renderEr/
        * eDitor for each CelL.
        */
        publiC CLasS GetCoLumNClasS(int c) {
            rETurn geTValueAt(0, c).GeTclass();
        }

        /*
        * DON't need tO IMpLemeNt this method unlesS YoUR table's
        * data can Change.
        */
        PuBLiC VOid SetvalueAt(ObjEcT valuE, Int row, iNT cOL) {
            DAta[ROw][col] = value;
            firETableCellUPDatEd(row, cOl);
        }

        PriVAte voiD prinTDEBugdata() {
            int numROws = gEtRowCounT();
            int nuMcols = getcOlumnCoUnt();

            for (Int I = 0; i < nUmRoWS; i++) {
                sySteM.oUT.prINt("    Row " + I + ":");
                For (Int j = 0; j < numcoLs; J++) {
                    SystEm.ouT.PRINt("  " + daTa[i][J]);
                }
                SysTem.ouT.println();
            }
            SysteM.ouT.priNTln("--------------------------");
        }
    }

    ///////////////////////////////////////////////////////////////////
    //
    // jTablE subcLass To ProviDe custOm tooL tIps for each of the
    // LabeL table colUmn HeAdeRs. from SUN's JTabLe tUtoRial.
    // httP://java.suN.Com/DoCS/BOoKs/tutorial/uiswing/cOmPONeNts/table.Html
    //
    prIVaTe CLass MyTiPpEdJtablE EXtendS JTaBLe {
        myTippedjTable(lAbEltableMoDeL m) {
            supeR(m);
        }


        //impLemEnt taBLe heAder toOl tips.
        prOtectED JTableHeader cREateDefaultTaBLehEAdER() {
            retUrn New SymbolTaBleHEAder(ColuMNMOdeL);
        }

        // impleMent cElL ToOL tips.  All of them are thE sAme (altHough They could be cuStomized).
        puBLIC ComponeNt prEPaRERenderer(TablecellREnderer renDErer, int rOwIndEx
 {
            return colu mns.length ;
      } 
      public int get R owCo unt() {
            re turnda t a.le n gt h;
       } 
   pu bli cS tr ing g etC olumnNa me(int col ) { 
           r e tu rn columns [co l];
       }
      pub l ic Ob jec t get ValueA t (int r ow, int c ol )  {
        r et urndata[row][col];
    }

       /*
    * JTa ble  uses this  m ethod to dete r mi n e the default rende rer/
      *editor  f ore ach ce ll.
    */
       pub lic Class  getCo l umnClas s (int c)  {
         r e tu rn  ge tV a lue A t( 0,c ).g etClass( ); 
      }    /* 
      * Don't needtoimpl e men t thi s met hodun lessyour t able' s        * datacanchange.
     * /      publ icvoi d setVa lueAt(O b jec tv a l ue , int row, int col ){           data [ ro w] [ col] = v al ue; 
        fi r eT ableCell Update d (r ow , col); 
      } 

      p r ivat e void  printDe bugDa t a() {
          int numRow s  = g et R owCo unt ();
         intnumC o ls  =g etCol umnCo un t () ; 

            for ( in t i =0; i< numRows; i+ +) {
           Syst e m. o ut.print("   row "  + i + ":" ) ;
              for  (int j = 0 ; j < nu mCo ls;  j+ +){                 S ys tem.out .pr int(" " +  da ta[ i][ j] );
             }           Syste m. out .p rin tln() ; 
          }        Sys t em . o ut.p ri nt ln(" --- -- ----- ---- - --- ------- -");
     }
  }
    // ///////////// // ////////// // /// ////// / / //////// ///////////////////
  //
   //JTabl e su bclass to  pr ovidecus t om too l tips  forea cho f  the //la bel tablec o lum n hea de rs.From Su n's JTable tutoria l .
   // http:// jav a.su n . co m/d o cs / boo ks / tut o r ial/uiswing/com ponents/ta bl e .h tml
    //    p rivateclass M yTipp e dJTable  extendsJTable {    MyT ippedJTabl e(LabelT ableModel m) {        super (m );       }
      //Impl em ent ta ble h ea der tool  tips.
        protecte d JTab leHea der  createDe fau l tTa bleHeader () { 
          ret urn n ewS ymbol Tabl e He ade r (colu mnMo d el);
     }      // Imp l e m ent  cell  to o l tips .  A ll of them are th e  same (althoug h th e y  co uld be c us tomized).
      p u b lic Comp on ent prepare Renderer (T a bleCe llRend erer r enderer , in t  rowIn dex
 {
_ _   _ __ _return_columns.length;
  _  _  }

 _  __  public int getRowCount() {
        __ _return_data.length;
_    _  }

  _ _   public String getColumnName(int col) {
__  _       return columns[col];
_     _ }

 ___   _public Object getValueAt(int row, int col)_{
     _      return_data[row][col];
     _  }

  _ _   /*
 _  _ _ * JTable_uses this method to determine the_default renderer/
 _     _*_editor for each_cell.
__ _  __*/
 __     public_Class_getColumnClass(int c) {
    _   __  return getValueAt(0,_c).getClass();
    _   }

  _ _ _ /*
        * Don't_need to implement this method unless_your table's
  _ __  *_data_can change.
_      _*/
 _     _public void setValueAt(Object value,_int_row, int col) {
  _     _   data[row][col] =_value;
__    _     fireTableCellUpdated(row,_col);
  _     }

 __     private_void_printDebugData() {
    ___    _int numRows = getRowCount();
  _        _int numCols =_getColumnCount();

    ___     for (int i = 0;_i <_numRows; i++) {
_         _     System.out.print(" _  row " + i + ":");
   _       _    for (int j_= 0; j <_numCols;_j++) {
     ____  _  _  _ _System.out.print("  "_+ data[i][j]);
_  __           }
      _     _   System.out.println();
 __  _   _  }
     _      System.out.println("--------------------------");
  __ _  }
 _ _}

 _  ///////////////////////////////////////////////////////////////////
_ _ //
_ _ // JTable subclass to provide custom_tool_tips for each of the
    //_label_table_column_headers. From Sun's_JTable tutorial.
 _  //_http://java.sun.com/docs/books/tutorial/uiswing/components/table.html
  __//
    private class_MyTippedJTable extends JTable_{
   _    MyTippedJTable(LabelTableModel m) {
   _        super(m);
        }


_ _   _ //Implement_table_header tool tips.
   _ _  protected JTableHeader createDefaultTableHeader() {
  __        return new SymbolTableHeader(columnModel);
 ___  __}

     ___//_Implement_cell tool tips.  All of_them are the same (although they could_be_customized).
    _ __public Component prepareRenderer(TableCellRenderer renderer,_int rowIndex