| gvSIG desktop 1

/*

 * Created on 27-abr-2004

 *

 * To change the template for this generated file go to

 * Window>Preferences>Java>Code Generation>Code and Comments

 */

package com.iver.cit.gvsig.gui.legendmanager.panels;

/**

 * @author fjp

 *

 * To change the template for this generated type comment go to

 * Window>Preferences>Java>Code Generation>Code and Comments

 */

/*

 * TableRenderDemo.java is a 1.4 application that requires no other files.

 */

import java.awt.Component;

import java.awt.Dimension;

import java.awt.GridLayout;

import java.util.Iterator;

import java.util.Set;

import java.util.TreeMap;

import javax.swing.JPanel;

import javax.swing.JScrollPane;

import javax.swing.JTable;

import javax.swing.table.DefaultTableModel;

import javax.swing.table.TableCellRenderer;

import javax.swing.table.TableColumn;

import com.iver.cit.gvsig.fmap.core.v02.FSymbol;

import com.iver.mdiApp.Utilities;

public class FSymbolTable extends JPanel {

        private boolean DEBUG = true;

        // private  MyTableModel m_TableModel;

        private JTable table;

        public void addRow(Object[] vector)

        {

                MyTableModel m = (MyTableModel) table.getModel();

                m.addRow(vector); 

        }

        public void removeSelectedRows()

        {

                MyTableModel m = (MyTableModel) table.getModel();

                int [] selectedRows = table.getSelectedRows();

                for (int i=selectedRows.length-1; i >= 0; i--)

                {

                        m.removeRow(selectedRows[i]);

                }

        }

        public void fillTableFromSymbolList(FSymbol[] symbols, Object[] values, String[] descriptions)

        {        

                // Object clave;

                FSymbol theSymbol; 

                for (int i=0; i < symbols.length; i++)

                { 

                        theSymbol = symbols[i];

                        Object[] theRow = new Object[3];

                        theRow[0] = theSymbol;

                        theRow[1] = values[i];

                        theRow[2] = descriptions[i];

                        addRow(theRow);

                }

        }

        public Object getFieldValue(int row, int col)

        {

                MyTableModel m = (MyTableModel) table.getModel();

                return m.getValueAt(row, col); 

        }

        public int getRowCount()

        {

                MyTableModel m = (MyTableModel) table.getModel();

                return m.getRowCount(); 

        }

        public void removeAllItems()

        {

                table.setModel(new MyTableModel());

                setUpSymbolColumn(table, table.getColumnModel().getColumn(0));                

        }

        public FSymbolTable() {

                super(new GridLayout(1,0));

                table = new JTable(new MyTableModel());

                table.setPreferredScrollableViewportSize(new Dimension(500, 70));

                //Create the scroll pane and add the table to it.

                JScrollPane scrollPane = new JScrollPane(table);

                //Set up column sizes.

                initColumnSizes(table);

                setUpSymbolColumn(table, table.getColumnModel().getColumn(0));

                //Add the scroll pane to this panel.

                add(scrollPane);

                table.setRowSelectionAllowed(true);

        }

        /*

         * This method picks good column sizes.

         * If all column heads are wider than the column's cells'

         * contents, then you can just use column.sizeWidthToFit().

         */

        private void initColumnSizes(JTable table) {

                MyTableModel model = (MyTableModel)table.getModel();

                TableColumn column = null;

                Component comp = null;

                int headerWidth = 0;

                int cellWidth = 0;

                TableCellRenderer headerRenderer =

                        table.getTableHeader().getDefaultRenderer();

                /* for (int i = 0; i < table.getColumnCount(); i++) {

                        column = table.getColumnModel().getColumn(i);

                        comp = headerRenderer.getTableCellRendererComponent(

                                                                 null, column.getHeaderValue(),

                                                                 false, false, 0, 0);

                        headerWidth = comp.getPreferredSize().width;

                        comp = table.getDefaultRenderer(model.getColumnClass(i)).

                                                         getTableCellRendererComponent(

                                                                 table, longValues[i],

                                                                 false, false, 0, i);

                        cellWidth = comp.getPreferredSize().width;

                        if (DEBUG) {

                                System.out.println("Initializing width of column "

                                                                   + i + ". "

                                                                   + "headerWidth = " + headerWidth

                                                                   + "; cellWidth = " + cellWidth);

                        }

                        //XXX: Before Swing 1.1 Beta 2, use setMinWidth instead.

                        column.setPreferredWidth(Math.max(headerWidth, cellWidth));

                } */

        }

        public void setUpSymbolColumn(JTable table,

                                                                 TableColumn m_FSymbolComlumn) {

                //Set up the editor 

                /* JComboBox comboBox = new JComboBox();

                comboBox.addItem("Snowboarding");

                comboBox.addItem("Rowing");

                comboBox.addItem("Knitting");

                comboBox.addItem("Speed reading");

                comboBox.addItem("Pool");

                comboBox.addItem("None of the above");

                sportColumn.setCellEditor(new DefaultCellEditor(comboBox));

                //Set up tool tips 

                DefaultTableCellRenderer renderer =

                                new DefaultTableCellRenderer();

                renderer.setToolTipText("Click for combo box"); */

                m_FSymbolComlumn.setMaxWidth(100);

                m_FSymbolComlumn.setWidth(60);

                m_FSymbolComlumn.setPreferredWidth(60);

                m_FSymbolComlumn.setMinWidth(50);

                FCellEditor editor = new FCellEditor();

                m_FSymbolComlumn.setCellEditor(editor);

                FCellRenderer renderer = new FCellRenderer(true);

                m_FSymbolComlumn.setCellRenderer(renderer);

        }

        class MyTableModel extends DefaultTableModel { //  AbstractTableModel {

                private String[] columnNames = {Utilities.getMessage(this,"Simbolo"),

                                                Utilities.getMessage(this,"Valor"),

                                                Utilities.getMessage(this,"Etiqueta") };

                public int getColumnCount() {

                        return columnNames.length;

                }

                public String getColumnName(int col) {

                        return columnNames[col];

                }

                /*

                 * JTable uses this method to determine the default renderer/

                 * editor for each cell.  If we didn't implement this method,

                 * then the last column would contain text ("true"/"false"),

                 * rather than a check box.

                 */

                public Class getColumnClass(int c) {

                        return getValueAt(0, c).getClass();

                }

                /*

                 * Don't need to implement this method unless your table's

                 * editable.

                 */

                public boolean isCellEditable(int row, int col) {

                        //Note that the data/cell address is constant,

                        //no matter where the cell appears onscreen.

                        //if (col > 0) {

                                return true;

                        /* } else {

                                return false;

                        } */

                }

                /*

                 * Don't need to implement this method unless your table's

                 * data can change.

                 */

                /* public void setValueAt(Object value, int row, int col) {

                        if (DEBUG) {

                                System.out.println("Setting value at " + row + "," + col

                                                                   + " to " + value

                                                                   + " (an instance of "

                                                                   + value.getClass() + ")");

                        }

                        // FSymbol theSymbol;

                        switch (col)

                        {

                                case 0: // Simbolo

                                        // m_FRenderer.setValueSymbol(row,(FSymbol) value);

                                        break;

                                case 1: // Clave

                                        FInterval newInterval = FInterval.parseString((String) value);

                                        this.setValueAt(newInterval,row,col);

                                        break;

                                case 2: // Etiqueta

                                        // theSymbol = m_FRenderer.getSymbolByID(row);

                                        // theSymbol.m_Descrip = (String) value;

                        }

                        // 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("--------------------------");

                } */

        }

}