Форум программистов [Powered by Invision Power Board]

Код


if (r>=0 & r<=12){
         if (row == r & column==0){     
        setBackground(Color.RED);
        }
}

Код



 import java.util.Map;
 import java.util.TreeMap;
 import javax.swing.*;
 import javax.swing.table.*;
 import java.util.Vector;

 public class JTableX extends JTable
 {
     protected Map<Integer, RowEditorModel> rem =  new TreeMap<Integer, RowEditorModel>();
     protected Map<Integer, RowRendererModel> rrm = new TreeMap<Integer, RowRendererModel>();

     public JTableX()
     {
         super();
     }

     public JTableX(TableModel tm)
     {
         super(tm);
     }

     public JTableX(TableModel tm, TableColumnModel cm)
     {
         super(tm,cm);
     }

     public JTableX(TableModel tm, TableColumnModel cm,
      ListSelectionModel sm)
     {
         super(tm,cm,sm);
     }

     public JTableX(int rows, int cols)
     {
         super(rows,cols);
     }

     public JTableX(final Vector rowData, final Vector columnNames)
     {
         super(rowData, columnNames);
     }

     public JTableX(final Object[][] rowData, final Object[] colNames)
     {
         super(rowData, colNames);
     }

     // new constructor
     public JTableX(TableModel tm, RowEditorModel rm, int col)
     {
         super(tm,null,null);
         rem.put(col, rm);
     }

     public void setRowEditorModel(RowEditorModel rm, int col)
     {
         rem.put(col, rm);
     }

     public RowEditorModel getRowEditorModel(int col)
     {
         return rem.get(col);
     }

     public void setRowRendererModel(RowRendererModel rm, int col)
     {
         rrm.put(col, rm);
     }

     public RowRendererModel getRowRendererModel(int col)
     {
         return rrm.get(col);
     }     
     
    @Override
     public TableCellEditor getCellEditor(int row, int col)
     {
        TableCellEditor tmpEditor = null;
        if (rem.get(col) != null)
             tmpEditor = rem.get(col).getEditor(row);
        else if (rem.get(-1) != null)
            tmpEditor = rem.get(-1).getEditor(row);
        if (tmpEditor != null)
            return tmpEditor;
        return super.getCellEditor(row,col);
    }
     
    @Override
     public TableCellRenderer getCellRenderer(int row, int col) {
        TableCellRenderer tmpRenderer = null;
        if (rrm.get(col) != null)
            tmpRenderer = rrm.get(col).getRenderer(row);
        else if (rrm.get(-1) != null)
            tmpRenderer = rrm.get(-1).getRenderer(row);
        if (tmpRenderer != null)
            return tmpRenderer;
         return super.getCellRenderer(row, col);
     }
    
}

Код



import javax.swing.table.*;
import java.util.*;

public class RowRendererModel
{
     private Hashtable data;
     public RowRendererModel()
     {
         data = new Hashtable();
     }
     public void addRendererForRow(int row, TableCellRenderer e )
     {
         data.put(new Integer(row), e);
     }
     public void removeRendererForRow(int row)
     {
         data.remove(new Integer(row));
     }
     public TableCellRenderer getRenderer(int row)
     {
         return (TableCellRenderer)data.get(new Integer(row));
     }
 }

Код


private JTable getJTable() {
        if (jTable == null) {
            jTable = new JTable();            
        }
        return jTable;
    }

Код


    jButton.addActionListener(new java.awt.event.ActionListener() {
                public void actionPerformed(java.awt.event.ActionEvent e) {                
                    jTable.setModel(getDB());        
                    int withCol[]= {5,160,60,25,50,40};
                    setWith(withCol);
                    ColumnRendererproba  cr=new ColumnRendererproba ();
                    cr.r=Integer.parseInt(jTextField.getText().trim());
                }
            });

Код


public class ColumnRendererproba extends DefaultTableCellRenderer 
{
    public static int r=-1;
    public Component getTableCellRendererComponent(JTable table, Object value,
                    boolean isSelected, boolean hasFocus, int row, int column) 
    { 
     
     if (r>=0 & r<=12){
         if (row == r && column==0){         
             setBackground(Color.RED);
        }
         
     
     }
     
        return super.getTableCellRendererComponent(table, value, isSelected, hasFocus, row, column);
    }
}

Код


package Sbit;

import java.sql.Connection;
import java.sql.Driver;
import java.sql.DriverManager;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.ResultSetMetaData;
import java.sql.SQLException;
import java.sql.Statement;
import java.sql.Types;
import java.util.Vector;
import javax.swing.table.AbstractTableModel;

/*
 * Created on 14.06.2004
 *
 * To change the template for this generated file go to
 * Window&gt;Preferences&gt;Java&gt;Code Generation&gt;Code and Comments
 */

/**
 * @author golden
 *
 * To change the template for this generated type comment go to
 * Window&gt;Preferences&gt;Java&gt;Code Generation&gt;Code and Comments
 */

public class database extends AbstractTableModel{
    
    /**
     * 
     */
    private static final long serialVersionUID = 1L;
    public String[] columnNames;
    public String[] dbcolumnNames;
    public Vector rows = new Vector();
    public ResultSetMetaData metaData;
    public static Statement statement;
    public ResultSet resultSet;
    public Connection con; 
    public String tableName;
    
    public int getColumnCount()
    {
      return columnNames.length;
    }

    public String getColumnName(int n)
    {
      return columnNames[n];
    }
    public String getDBColumnName(int n)
    {
      return dbcolumnNames[n];
    }
    public int getDBColumnCount()
    {
      return dbcolumnNames.length;
    }
    
    public int getRowCount()
    {
        return rows.size();
    }
    public int addRow()
    {

        int r=rows.size()+1;
        return r;
    }

    public Object getValueAt(int aRow, int aColumn)
    {
        Vector row = (Vector)rows.elementAt(aRow);
        
        return row.elementAt(aColumn);
    }
//-----------------------------------------------------------------------------------------------
    public database(String query, String DBNAME, String USERNAME, String PASSWORD, String tableName, String tableName1, String tableName2,String[] columnNames)
    {
       
        this.columnNames = columnNames; 
        this.tableName = tableName;
        fireTableDataChanged();

        Driver d;
        try{
            d = (Driver)Class.forName("org.postgresql.Driver").newInstance();
        }
        catch (Exception e) {
            System.out.println("Error 1");
            System.out.println(e.getStackTrace());
        }
        try{
            String ip="";
            Ip Ip = new Ip();
            ip=Ip.ip;
            if(con==null){
            con = DriverManager.getConnection
            ("jdbc:postgresql://"+ip+":5432/"+DBNAME,USERNAME,PASSWORD);            
        statement = con.createStatement();
            }
        SqlReload(query);
        resultSet.close();
        statement.close();
        }
        catch(SQLException e)
        {
            System.out.println(e.getMessage());
        }
    }
    
//---------------------------------------------------------------------------------------------
    public boolean isCellEditable(int row, int column)
    {
        /*try
        {
          return metaData.isWritable(column+1);
            
        }
        catch (SQLException e)
        {
          return false;
        }*/
        return true;
    }
//--------------------------------------------------------------------------------------------

    public void setValueAt(Object value, int row, int column)
    {
      try
        {
          String columnName = dbcolumnNames[column];
         String query =
            "UPDATE "+tableName+
            " SET "+columnName+" = "+
             dbRepresentation(column, value)+
            " WHERE ";
        
        for(int col = 0; col < getColumnCount();col++)
        {
          String colName = getDBColumnName(col);

          if (colName==columnName)
           {
            continue;
           }
                          if (col != 0)
                           {
                             query = query + " and ";
                            }
                             query = query + colName +" = "+
                             dbRepresentation(col, getValueAt(row, col));
           }
        PreparedStatement pstmt =
        con.prepareStatement(query);
        pstmt.executeUpdate();
        Object val;
        val = tbRepresentation(column,value);
        Vector dataRow = (Vector)rows.elementAt(row);
        dataRow.setElementAt(val, column);
        fireTableDataChanged();
        
        fireTableCellUpdated(row,column);
        }
        catch (Exception ex)
        {
           System.err.println(ex);
        }
    }
    

//-------------------------------------------------------------------------------------------    
    public Object dbRepresentation(int column, Object value) throws NumberFormatException
    {
    
        Object val;
        int type;
        if (value == null)
        {
            return "null";
        }
        try
        {    
           type = metaData.getColumnType(column+1);
        }
        catch (SQLException e)
        {
          return value.toString();
        }
        
        
        switch(type)
        {
            case Types.BIGINT:
                return val = new Long(value.toString().trim());
            case Types.CHAR:
                 return val = "'"+new String(value.toString().trim())+"'";
            case Types.TINYINT:
            case Types.SMALLINT:
            case Types.INTEGER:
                return val = new Integer(value.toString().trim());
            
            case Types.REAL:
            case Types.FLOAT:
            case Types.DOUBLE:
            case Types.NUMERIC:
                return val = new Double(value.toString().trim());
            
            default: return val = "'"+new String(value.toString().trim())+"'";
        }
     }
    //---------------------------------------------------------------------------------------
    public Object tbRepresentation(int column, Object value)   throws NumberFormatException
    {
        
        Object val;
        int type;
        if (value == null)
         {   return "null";   }
      try
       { type = metaData.getColumnType(column+1); }
      catch (SQLException e) {   return value.toString().trim(); }

      switch(type)
       {
         case Types.BIGINT:
               return val = new Long(value.toString().trim());
         case Types.TINYINT:
         case Types.SMALLINT:
         case Types.INTEGER:
              return val = new Integer(value.toString().trim());
         case Types.REAL:
         case Types.FLOAT:
         case Types.DOUBLE:
         case Types.NUMERIC:     
               return val = new Double(value.toString().trim());
         default: return val = new String(value.toString());
               
        }
    }
    //---------------------------------------------------------------------------------------

    
    public void SqlReload(String query)
    {
     try{
         fireTableDataChanged();
                resultSet = statement.executeQuery(query);
                metaData = resultSet.getMetaData();
                int numberOfColumns =  metaData.getColumnCount();
                dbcolumnNames = new String[numberOfColumns];
                for(int column = 1; column <= numberOfColumns; column++)
                {
                    dbcolumnNames[column-1] =
                    metaData.getColumnName(column);
                }
                rows = new Vector();
                while (resultSet.next())
                {
                   Vector newRow = new Vector();
                    for (int i = 1; i <=  getColumnCount(); i++)
                    {
                      newRow.addElement(resultSet.getObject(i));
                    }
                    
                    rows.addElement(newRow);
                }
     }
     catch(SQLException e)
        {
            System.out.println(e.getMessage());
        }
    }
//----------------------------------------------------------------------------------------
    public void SqlInsert(String query,String query1)
    {
            try{
                PreparedStatement pstmt =
                    con.prepareStatement(query);
                    pstmt.executeUpdate();
                   SqlReload(query1);
                }
        catch(SQLException e)
        {
            System.out.println(e.getMessage());
        }
    }
//******************************************************************************************    
    
    public void Sql(String query1)
    {
            try{
                PreparedStatement pstmt =
                    con.prepareStatement(query1);
                    pstmt.executeUpdate();
//                 SqlReload(query1);
                }
        catch(SQLException e)
        {
            System.out.println(e.getMessage());
        }
    }
  //---------------------------------------------------------------------------------------
    public void SqlDelete(String query,String query1,int cur_row)
    {
            try{   
                String query_=query;
                query_= query_ + tbRepresentation(0, getValueAt(cur_row, 0));
                fireTableDataChanged();
                PreparedStatement pstmt = con.prepareStatement(query_);
            
                  System.out.println(query_);
                
                pstmt.executeUpdate();
                
              SqlReload(query1);
            }
        catch(SQLException e)
        {
            System.out.println(e.getMessage());
        }
    }
  //---------------------------------------------------------------------------------------    
    
     public void fireTableRowsDeleted(int firstRow, int lastRow) {
          }
     public void fireTableRowsInserted(int firstRow, int lastRow) {
          }    
    
    
//------------------------------------------------------
}

Цитата(izver84 @ 14.1.2010, 16:02

)

public static int r=-1;

Цитата(dorogoyIV @ 15.1.2010, 16:51

)

что такое
Цитата(izver84 @ 14.1.2010, 16:02 Найти цитируемый пост)
public static int r=-1;

?

Код


  ColumnRendererproba  cr=new ColumnRendererproba ();
                    cr.r=Integer.parseInt(jTextField.getText().trim());//число в текстфилде передаётся рендеру

Код


  if (r>=0 & r<=12){//если число между 0 и 12 закрасить ячейку(строка = r,стобец0)
         if (row == r && column==0){         
             setBackground(Color.RED);
        }

Код


/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */

package Jservers;

import java.awt.Color;
import java.awt.Component;
import javax.swing.BorderFactory;
import javax.swing.JTable;
import javax.swing.border.Border;
//import javax.swing.border.EmptyBorder;
import javax.swing.border.EtchedBorder;
import javax.swing.border.MatteBorder;
import javax.swing.table.DefaultTableCellRenderer;

/**
 *
 * @author Admin
 */
//Класс для окраски таблицы Jboard , в классе Fire указываеться что это класс-рендер нужно использовать вместо стандартного
//Алгоритм: Окрашивает строки с надписью 'AlARM' в 7 столбце(столбец действия) в красный цвет, если тревога закрыта то в данном поле
//будет 'ОК' и он окрасит её в зеленый цвет
//Также тут учтено , как окрашивать выделенную строку и не выделенную (Разной яркостью зеленого и красного)
public class FileListCellRenderer extends DefaultTableCellRenderer {
//Border blackline, raisedetched, loweredetched, raisedbevel, loweredbevel, empty;

Border blackline = BorderFactory.createLineBorder(Color.black);
Border raisedetched = BorderFactory.createEtchedBorder(EtchedBorder.RAISED);
Border loweredetched = BorderFactory.createEtchedBorder(EtchedBorder.LOWERED);
Border raisedbevel = BorderFactory.createRaisedBevelBorder();
Border loweredbevel = BorderFactory.createLoweredBevelBorder();
Border empty = BorderFactory.createEmptyBorder();
//Border noFocusBorder = new EmptyBorder(2, 0, 2, 0);

  public Color newRed = new Color(255, 164, 164);
   public Color newRedAct = new Color(255, 106, 106);
    public Color newBlue = new Color(225, 255, 255);
       public Color newBlueAct = new Color(171, 252, 252);
     public Color lightgreen = new Color(204, 255, 204);
  public Component getTableCellRendererComponent(  JTable table, Object value, boolean isSelected, boolean hasFocus,int row,int col)
{

     Component comp = super.getTableCellRendererComponent(table,  value, isSelected, hasFocus, row, col);
      String s =  table.getModel().getValueAt(row,7).toString();

 comp.setBackground(s.equals("ALARM")? newRed : newBlue );
  comp.setForeground(s.equals("ALARM")? Color.BLACK : Color.BLACK);
 if (isSelected)
            {
 setBorder(new MatteBorder(1, 0, 1, 0, Color.DARK_GRAY) );
    comp.setBackground(s.equals("ALARM")? newRedAct: newBlueAct );
    comp.setForeground(s.equals("ALARM")? Color.BLACK: Color.BLACK);
            }
   repaint();
     return( comp );
 }


}

Код


JBoard.setDefaultRenderer(Object.class, new FileListCellRenderer());