Application: gvSIG desktop » Library: org.gvsig.tools

/**

 * gvSIG. Desktop Geographic Information System.

 *

 * Copyright (C) 2007-2013 gvSIG Association.

 *

 * This program is free software; you can redistribute it and/or

 * modify it under the terms of the GNU General Public License

 * as published by the Free Software Foundation; either version 2

 * of the License, or (at your option) any later version.

 *

 * This program is distributed in the hope that it will be useful,

 * but WITHOUT ANY WARRANTY; without even the implied warranty of

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

 * GNU General Public License for more details.

 *

 * You should have received a copy of the GNU General Public License

 * along with this program; if not, write to the Free Software

 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,

 * MA  02110-1301, USA.

 *

 * For any additional information, do not hesitate to contact us

 * at info AT gvsig.com, or visit our website www.gvsig.com.

 */

package org.gvsig.tools;

import junit.framework.Test;

import junit.framework.TestCase;

import junit.framework.TestSuite;

/**

 * Unit test for simple App.

 */

public class AppTest extends TestCase {

    /**

     * @return the suite of tests being tested

     */

    public static Test suite() {

        return new TestSuite(AppTest.class);

    }

    /**

     * Create the test case

     * 

     * @param testName

     *            name of the test case

     */

    public AppTest(String testName) {

        super(testName);

    }

    /**

     * Rigourous Test :-)

     */

    public void testApp() {

        assertTrue(true);

    }

}

package org.gvsig.texteditor;

import java.awt.Container;

import java.awt.Point;

import java.awt.Rectangle;

import java.awt.event.ActionEvent;

import java.awt.event.ActionListener;

import javax.swing.JComponent;

import javax.swing.JPanel;

import javax.swing.JViewport;

import javax.swing.SwingUtilities;

import javax.swing.event.CaretEvent;

import javax.swing.event.ChangeEvent;

import javax.swing.event.ChangeListener;

import javax.swing.event.DocumentEvent;

import javax.swing.event.DocumentListener;

import javax.swing.text.BadLocationException;

import javax.swing.text.Document;

import javax.swing.text.Element;

import javax.swing.text.JTextComponent;

import org.gvsig.tools.swing.api.ChangeListenerHelper;

import org.gvsig.tools.swing.api.ToolsSwingLocator;

import org.gvsig.tools.swing.api.viewer.AbstractJViewer;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

/**

 *

 * @author jjdelcerro

 */

public abstract class AbstractJTextEditor extends AbstractJViewer implements JTextEditor {

    protected static final Logger LOGGER = LoggerFactory.getLogger(DefaultJTextEditor.class);

    protected static class UpdateCaretPositionActionEventImpl 

                extends ActionEvent 

                implements UpdateCaretPositionActionEvent 

        {

        private final int line;

        private final int column;

        private final boolean hasLineAndCol;

        public UpdateCaretPositionActionEventImpl(Object comp, int line, int column, boolean hasLineAndCol) {

            super(comp, 1, "UpdateCaretPosition");

            this.line = line;

            this.column = column;

            this.hasLineAndCol = hasLineAndCol;

        }

        @Override

        public int getLine() {

            return this.line;

        }

        @Override

        public int getColumn() {

            return this.column;

        }

        @Override

        public boolean hasLineAndColumn() {

            return this.hasLineAndCol;

        }

    }

    protected JPanel panel;

    protected ChangeListenerHelper changeListeners;

    protected ActionListener updateCaretPositionListener;

    public AbstractJTextEditor(TextEditorManager factory) {

        super(factory);

        this.panel = new JPanel();

        this.changeListeners = ToolsSwingLocator.getToolsSwingManager().createChangeListenerHelper();

        final JTextComponent textComponent = this.getJTextComponent();

        final Document textDocument = textComponent.getDocument();

        textDocument.addDocumentListener(new DocumentListener() {

            @Override

            public void insertUpdate(DocumentEvent e) {

                changeListeners.fireEvent(new ChangeEvent(AbstractJTextEditor.this));

            }

            @Override

            public void removeUpdate(DocumentEvent e) {

                changeListeners.fireEvent(new ChangeEvent(AbstractJTextEditor.this));

            }

            @Override

            public void changedUpdate(DocumentEvent e) {

                changeListeners.fireEvent(new ChangeEvent(AbstractJTextEditor.this));

            }

        });

        textComponent.addCaretListener((CaretEvent e) -> {

            if (updateCaretPositionListener == null) {

                return;

            }

            int lineNumber = 1;

            int columnNumber = 0;

            int currentPosition = textComponent.getCaretPosition();

            try {

                String strText = textDocument.getText(0, currentPosition);

                char arrText[] = strText.toCharArray();

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

                    if (arrText[i] == '\n') {

                        lineNumber++;

                    }

                }

                columnNumber = currentPosition - strText.lastIndexOf('\n');

            } catch (BadLocationException ble) {

                System.err.println(ble);

            }

            updateCaretPositionListener.actionPerformed(

                    new UpdateCaretPositionActionEventImpl(

                            this, lineNumber, columnNumber, true

                    )

            );

        });

    }

    @Override

    public JComponent asJComponent() {

        return this.panel;

    }

    @Override

    public void addChangeListener(ChangeListener listener) {

        this.changeListeners.addChangeListener(listener);

    }

    @Override

    public ChangeListener[] getChangeListeners() {

        return this.changeListeners.getChangeListeners();

    }

    @Override

    public void removeChangeListener(ChangeListener listener) {

        this.changeListeners.removeChangeListener(listener);

    }

    @Override

    public void removeAllChangeListener() {

        this.changeListeners.removeAllChangeListener();

    }

    @Override

    public boolean hasChangeListeners() {

        return this.changeListeners.hasChangeListeners();

    }

    @Override

    public void selectLine(int line) {

        JTextComponent editor = this.getJTextComponent();

        editor.requestFocusInWindow();

        String code = editor.getText();

        int lineCounter = 0;

        int initialSelection = 0;

        int finalSelection = 0;

        for (int j = 0; j < code.length(); j++) {

            if (code.charAt(j) == '\n') {

                lineCounter++;

                if (lineCounter == line - 1) {

                    initialSelection = j;

                }

                if (lineCounter == line || (finalSelection == 0 && j == code.length() - 1)) {

                    finalSelection = j;

                }

            }

        }

        editor.select(initialSelection, finalSelection);

    }

    @Override

    public void gotoline(int line) {

        JTextComponent component = getJTextComponent();

        Element root = component.getDocument().getDefaultRootElement();

        int lineno = Math.max(line, 1);

        int maxlines = root.getElementCount();

        lineno = Math.min(lineno, maxlines);

        int startOfLineOffset = root.getElement(lineno - 1).getStartOffset();

        component.setCaretPosition(startOfLineOffset);

        Container container = SwingUtilities.getAncestorOfClass(JViewport.class, component);

        if (container == null) {

            return;

        }

        int y = -1;

        try {

            Rectangle r = component.modelToView(component.getCaretPosition());

            JViewport viewport = (JViewport) container;

            int extentHeight = viewport.getExtentSize().height;

            int viewHeight = viewport.getViewSize().height;

            y = Math.max(0, r.y - ((extentHeight - r.height) / 2));

            y = Math.min(y, viewHeight - extentHeight);

            viewport.setViewPosition(new Point(0, y));

        } catch (BadLocationException ble) {

            LOGGER.warn("Can't set view position (y=" + y + ").", ble);

        }

        try {

            component.setCaretPosition(startOfLineOffset + 1);

        } catch (Exception e) {

            LOGGER.warn("Can't set caret position (position=" + (startOfLineOffset + 1) + ").", e);

        }

    }

    @Override

    public int getLineCount() {

        JTextComponent textComponent = this.getJTextComponent();

        Element map = textComponent.getDocument().getDefaultRootElement();

        return map.getElementCount();

    }

    @Override

    public void addUpdateCaretPositionActionListener(ActionListener listener) {

        this.updateCaretPositionListener = listener;

    }

    @Override

    public boolean isModified() {

        throw new UnsupportedOperationException("Not supported yet."); //To change body of generated methods, choose Tools | Templates.

    }

}

package org.gvsig.texteditor;

import java.awt.BorderLayout;

import java.awt.Font;

import java.awt.event.ActionEvent;

import java.awt.event.ActionListener;

import java.io.File;

import java.io.IOException;

import java.nio.charset.StandardCharsets;

import java.util.Objects;

import javax.swing.JFileChooser;

import javax.swing.JMenu;

import javax.swing.JMenuBar;

import javax.swing.JMenuItem;

import javax.swing.JOptionPane;

import javax.swing.JScrollPane;

import javax.swing.JTextArea;

import javax.swing.event.UndoableEditEvent;

import javax.swing.text.JTextComponent;

import javax.swing.undo.CannotUndoException;

import javax.swing.undo.UndoManager;

import org.apache.commons.io.FileUtils;

/**

 *

 * @author gvSIG Team

 */

public class DefaultJTextEditor extends AbstractJTextEditor {

    private JTextArea textArea;

    // Is File Saved/Opened

    private boolean opened = false;

    private boolean saved = false;

    private File openedFile;

    // Undo manager for managing the storage of the undos

    // so that the can be redone if requested

    private UndoManager undo;

    private String mimeType;

    @SuppressWarnings("OverridableMethodCallInConstructor")

    public DefaultJTextEditor(TextEditorManager factory) {

        super(factory);

        JMenuBar menuBar = new JMenuBar();

        JMenu fileMenu = new JMenu("File");

        addMenuItem(fileMenu, "Open...", (ActionEvent e) -> {

            doOpenFile();

        });

        addMenuItem(fileMenu, "Save", (ActionEvent e) -> {

            doSaveFile();

        });

        addMenuItem(fileMenu, "Save as...", (ActionEvent e) -> {

            doSaveAsFile();

        });

        addMenuItem(fileMenu, "Close", (ActionEvent e) -> {

            doClose();

        });

        JMenu editMenu = new JMenu("Edit");

        addMenuItem(editMenu, "Undo", (ActionEvent e) -> {

            doUndo();

        });

        addMenuItem(editMenu, "Redo", (ActionEvent e) -> {

            doRedo();

        });

        addMenuItem(editMenu, "Select all", (ActionEvent e) -> {

            doSelectAll();

        });

        addMenuItem(editMenu, "Cut", (ActionEvent e) -> {

            doCut();

        });

        addMenuItem(editMenu, "Copy", (ActionEvent e) -> {

            doCopy();

        });

        addMenuItem(editMenu, "Paste", (ActionEvent e) -> {

            doPaste();

        });

        menuBar.add(fileMenu);

        menuBar.add(editMenu);

        undo = new UndoManager();

        textArea.getDocument().addUndoableEditListener((UndoableEditEvent e) -> {

            undo.addEdit(e.getEdit());

        });

        this.panel.setLayout(new BorderLayout());

        this.panel.add(menuBar, BorderLayout.NORTH);

        JScrollPane scroll = new JScrollPane(

                getJTextComponent(), 

                JScrollPane.VERTICAL_SCROLLBAR_ALWAYS, 

                JScrollPane.HORIZONTAL_SCROLLBAR_ALWAYS

        );

        this.panel.add(scroll, BorderLayout.CENTER);

    }

    private void addMenuItem(JMenu menu, String text, ActionListener listener) {

        JMenuItem item = new JMenuItem(text);

        item.addActionListener(listener);

        item.setEnabled(true);

        menu.add(item);

    }

    private void saveFile(File file) {

        try {

            FileUtils.write(file, textArea.getText());

            saved = true;

        } catch (IOException ex) {

            LOGGER.warn("Can't save file (" + Objects.toString(file) + ")", ex);

        }

    }

    private void doOpenFile() {

        JFileChooser open = new JFileChooser();

        open.showOpenDialog(null);

        File file = open.getSelectedFile();

        try {

            openedFile = file;

            String s = FileUtils.readFileToString(file);

            textArea.setText(s);

            opened = true;

        } catch (IOException ex) {

            LOGGER.warn("Can't open file (" + Objects.toString(file) + ")", ex);

        }

    }

    private void doSaveFile() {

        JFileChooser save = new JFileChooser();

        File file = save.getSelectedFile();

        if (opened == false && saved == false) {

            save.showSaveDialog(null);

            int confirmationResult;

            if (file.exists()) {

                confirmationResult = JOptionPane.showConfirmDialog(this.panel, "Replace existing file?");

                if (confirmationResult == JOptionPane.YES_OPTION) {

                    saveFile(file);

                }

            } else {

                saveFile(file);

            }

        } else {

            try {

                FileUtils.write(openedFile, textArea.getText());

            } catch (IOException ex) {

                LOGGER.warn("Can't save file (" + Objects.toString(file) + ")", ex);

            }

        }

    }

    private void doSaveAsFile() {

        JFileChooser saveAs = new JFileChooser();

        saveAs.showSaveDialog(null);

        File filename = saveAs.getSelectedFile();

        int confirmationResult;

        if (filename.exists()) {

            confirmationResult = JOptionPane.showConfirmDialog(this.panel, "Replace existing file?");

            if (confirmationResult == JOptionPane.YES_OPTION) {

                saveFile(filename);

            }

        } else {

            saveFile(filename);

        }

    }

    private void doClose() {

        this.panel.setVisible(false);

    }

    private void doUndo() {

        try {

            undo.undo();

        } catch (CannotUndoException ex) {

            LOGGER.warn("Can't undo", ex);

        }

    }

    private void doRedo() {

        try {

            undo.redo();

        } catch (CannotUndoException ex) {

            LOGGER.warn("Can't redo", ex);

        }

    }

    private void doSelectAll() {

        textArea.selectAll();

    }

    private void doCopy() {

        textArea.copy();

    }

    private void doPaste() {

        textArea.paste();

    }

    private void doCut() {

        textArea.cut();

    }

    @Override

    public void setMimetype(String mimeType) {

        this.mimeType = mimeType;

    }

    @Override

    public String getMimetype() {

        return this.mimeType;

    }

    @Override

    public void setContents(Object data) {

        if( data instanceof String ) {

            this.textArea.setText((String) data);

            return;

        }

        if( data instanceof byte[] ) {

            this.textArea.setText(new String((byte[]) data));

            return;

        }

        super.setContents(data);

    }

    @Override

    public byte[] getBytes() {

        return this.textArea.getText().getBytes(StandardCharsets.UTF_8);

    }

    @Override

    public String getContents() {

        return this.textArea.getText();

    }

    @Override

    public void clean() {

        this.setContents("");

    }

    @Override

    public JTextComponent getJTextComponent() {

        if (this.textArea == null) {

            textArea = new JTextArea(30, 50);

            textArea.setEditable(true);

            Font textFont = new Font("Verdana", 0, 14);

            textArea.setFont(textFont);

        }

        return this.textArea;

    }

}

package org.gvsig.texteditor;

import org.gvsig.tools.swing.api.viewer.AbstractViewerFactory;

public class DefaultTextEditorManager extends AbstractViewerFactory implements TextEditorManager {

    public DefaultTextEditorManager() {

        super("TextEditor", "Text", "text/plain", true);

    }

    @Override

    public JTextEditor createTextEditor() {

        DefaultJTextEditor editor = new DefaultJTextEditor(this);

        return editor;

    }

    @Override

    public boolean isApplicable(Object... args) {

        Object data = args[0];

        return data instanceof String || data instanceof byte[];

    }

}

/**

 * gvSIG. Desktop Geographic Information System.

 *

 * Copyright (C) 2007-2023 gvSIG Association.

 *

 * This program is free software; you can redistribute it and/or

 * modify it under the terms of the GNU General Public License

 * as published by the Free Software Foundation; either version 3

 * of the License, or (at your option) any later version.

 *

 * This program is distributed in the hope that it will be useful,

 * but WITHOUT ANY WARRANTY; without even the implied warranty of

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

 * GNU General Public License for more details.

 *

 * You should have received a copy of the GNU General Public License

 * along with this program; if not, write to the Free Software

 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,

 * MA  02110-1301, USA.

 *

 * For any additional information, do not hesitate to contact us

 * at info AT gvsig.com, or visit our website www.gvsig.com.

 */

package org.gvsig.tools.swing.impl.hexeditor;

import java.io.InputStream;

import org.gvsig.tools.swing.api.viewer.AbstractViewerFactory;

import org.gvsig.tools.swing.api.viewer.JViewer;

/**

 *

 * @author jjdelcerro

 * @param <T>

 */

public class HexEditorFactory<T> extends AbstractViewerFactory<T> {

    public HexEditorFactory() {

        super("HexEditor", "Hexadecimal", "application/octet-stream", false);

    }

    @Override

    public JViewer<T> createViewer() {

        return new HexEditor(this);

    }

    @Override

    public boolean isApplicable(Object... args) {

        Object data = args[0];

        if( data instanceof byte[] ) {

            return true;

        }

        if( data instanceof String ) {

            return true;

        }

        if( data instanceof InputStream ) {

            return true;

        }

        return false;

    }

}

package org.gvsig.tools.swing.impl.hexeditor.swing;

import java.awt.datatransfer.DataFlavor;

import java.awt.datatransfer.Transferable;

import java.awt.datatransfer.UnsupportedFlavorException;

import java.io.IOException;

import java.io.StringReader;

/*

 * Based on portions of code from ajaxproxy in GitHub

 * Copyright (c) 2008 Robert Futrell

 * https://github.com/mdeanda/ajaxproxy/tree/master/src/main/java/org/fife/ui/hex

 */

class ByteArrayTransferable implements Transferable {

	private int offset;

	private byte[] bytes;

	private static final DataFlavor[] FLAVORS = {

		DataFlavor.stringFlavor,

		DataFlavor.plainTextFlavor,

	};

	/**

	 * Creates a transferable object.

	 *

	 * @param bytes The bytes to transfer.

	 */

	public ByteArrayTransferable(int offset, byte[] bytes) {

		this.offset = offset;

		if (bytes!=null) {

			this.bytes = (byte[])bytes.clone();

		}

		else {

			this.bytes = new byte[0];

		}

	}

	/**

	 * Returns the number of bytes being transferred.

	 *

	 * @return The number of bytes being transferred.

	 * @see #getOffset()

	 */

	public int getLength() {

		return bytes.length;

	}

	/**

	 * Returns the offset of the first byte being transferred.

	 *

	 * @return The offset of the first byte.

	 * @see #getLength()

	 */

	public int getOffset() {

		return offset;

	}

	/**

	 * Returns the data being transferred in a format specified by the

	 * <code>DataFlavor</code>.

	 *

	 * @param flavor Dictates in what format the data should be returned.

	 * @throws UnsupportedFlavorException If the specified flavor is not

	 *         supported.

	 * @throws IOException If an IO error occurs.

	 * @see DataFlavor#getRepresentationClass()

	 */

	public Object getTransferData(DataFlavor flavor)

			throws UnsupportedFlavorException, IOException {

		if (flavor.equals(FLAVORS[0])) {

			return new String(bytes); // Use platform default charset.

		}

		else if (flavor.equals(FLAVORS[1])) {

			return new StringReader(new String(bytes));

		}

	    throw new UnsupportedFlavorException(flavor);

	}

	/**

	 * Returns an array of DataFlavor objects indicating the flavors the data 

	 * can be provided in.  The array is ordered according to preference for 

	 * providing the data (from most richly descriptive to least descriptive).

	 *

	 * @return An array of data flavors in which this data can be transferred.

	 */

	public DataFlavor[] getTransferDataFlavors() {

		return (DataFlavor[])FLAVORS.clone();

	}

	/**

	 * Returns whether a data flavor is supported.

	 *

	 * @param flavor The flavor to check.

	 * @return Whether the specified flavor is supported.

	 */

	public boolean isDataFlavorSupported(DataFlavor flavor) {

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

			if (flavor.equals(FLAVORS[i])) {

				return true;

			}

		}

		return false;

	}

}

package org.gvsig.tools.swing.impl.hexeditor.swing;

import java.awt.Component;

import java.awt.Graphics;

import javax.swing.AbstractListModel;

import javax.swing.BorderFactory;

import javax.swing.DefaultListCellRenderer;

import javax.swing.JLabel;

import javax.swing.JList;

import javax.swing.ListSelectionModel;

import javax.swing.border.EmptyBorder;

import javax.swing.border.Border;

import javax.swing.event.TableModelEvent;

import javax.swing.event.TableModelListener;

/*

 * Based on portions of code from ajaxproxy in GitHub

 * Copyright (c) 2008 Robert Futrell

 * https://github.com/mdeanda/ajaxproxy/tree/master/src/main/java/org/fife/ui/hex

 */

/**

 * Header of the hex table; displays address of the first byte on the

 * row.

 */

class HexEditorRowHeader extends JList implements TableModelListener {

	private static final long serialVersionUID = 1L;

	private HexTable table;

	private RowHeaderListModel model;

	private static final Border CELL_BORDER =

							BorderFactory.createEmptyBorder(0,5,0,5);

	/**

	 * Constructor.

	 *

	 * @param table The table displaying the hex content.

	 */

	public HexEditorRowHeader(HexTable table) {

		this.table = table;

		model = new RowHeaderListModel();

		setModel(model);

		setFocusable(false);

		setFont(table.getFont());

		setFixedCellHeight(table.getRowHeight());

		setCellRenderer(new CellRenderer());

		setBorder(new RowHeaderBorder());

		setSelectionMode(ListSelectionModel.SINGLE_INTERVAL_SELECTION);

		syncRowCount(); // Initialize to initial size of table.

		table.getModel().addTableModelListener(this);

	}

	public void addSelectionInterval(int anchor, int lead) {

		super.addSelectionInterval(anchor, lead);

		int min = Math.min(anchor, lead);

		int max = Math.max(anchor, lead);

		table.setSelectedRows(min, max);

	}

	public void removeSelectionInterval(int index0, int index1) {

		super.removeSelectionInterval(index0, index1);

		int anchor = getAnchorSelectionIndex();

		int lead = getLeadSelectionIndex();

		table.setSelectedRows(Math.min(anchor, lead), Math.max(anchor, lead));

	}

	public void setSelectionInterval(int anchor, int lead) {

		super.setSelectionInterval(anchor, lead);

		int min = Math.min(anchor, lead);

		int max = Math.max(anchor, lead);

		// Table may be showing 0 bytes, but we're showing 1 row header

		if (max<table.getRowCount()) {

			table.setSelectedRows(min, max);

		}

	}

	private void syncRowCount() {

		if (table.getRowCount()!=model.getSize()) {

			// Always keep 1 row, even if showing 0 bytes in editor

			model.setSize(Math.max(1, table.getRowCount()));

		}

	}

	public void tableChanged(TableModelEvent e) {

		syncRowCount();

	}

	/**

	 * Renders the cells of the row header.

	 *

	 * @author Robert Futrell

	 * @version 1.0

	 */

	private class CellRenderer extends DefaultListCellRenderer {

		private static final long serialVersionUID = 1L;

		public CellRenderer() {

			setHorizontalAlignment(JLabel.RIGHT);

		}

		public Component getListCellRendererComponent(JList list, Object value,

							int index, boolean selected, boolean hasFocus) {

			// Never paint cells as "selected."

			super.getListCellRendererComponent(list, value, index,

												false, hasFocus);

			setBorder(CELL_BORDER);

//			setBackground(table.getBackground());

			return this;

		}

	}

	/**

	 * List model used by the header for the hex table.

	 *

	 * @author Robert Futrell

	 * @version 1.0

	 */

	private static class RowHeaderListModel extends AbstractListModel {

		private static final long serialVersionUID = 1L;

		private int size;

		public Object getElementAt(int index) {

			return "0x" + Integer.toHexString(index*16);

		}

		public int getSize() {

			return size;

		}

		public void setSize(int size) {

			int old = this.size;

			this.size = size;

			int diff = size - old;

			if (diff>0) {

				fireIntervalAdded(this, old, size-1);

			}

			else if (diff<0) {

				fireIntervalRemoved(this, size+1, old-1);

			}

		}

	}

	/**

	 * Border for the entire row header.  This draws a line to separate the

	 * header from the table contents, and gives a small amount of whitespace

	 * to separate the two.

	 *

	 * @author Robert Futrell

	 * @version 1.0

	 */

	private class RowHeaderBorder extends EmptyBorder {

		private static final long serialVersionUID = 1L;

		public RowHeaderBorder() {

			super(0,0,0,2);

		}

	    public void paintBorder(Component c, Graphics g, int x, int y,

	    						int width, int height) {

	    	x = x + width - this.right;

//	    	g.setColor(table.getBackground());

//	    	g.fillRect(x,y, width,height);

	    	g.setColor(table.getGridColor());

	    	g.drawLine(x,y, x,y+height);

	    }

	}

}

package org.gvsig.tools.swing.impl.hexeditor.swing;

import java.awt.AWTEvent;

import java.awt.Color;

import java.awt.Component;

import java.awt.Dimension;

import java.awt.Font;

import java.awt.FontMetrics;

import java.awt.Graphics;

import java.awt.Graphics2D;

import java.awt.Point;

import java.awt.Rectangle;

import java.awt.event.FocusEvent;

import java.awt.event.FocusListener;

import java.awt.event.KeyEvent;

import java.io.IOException;

import java.io.InputStream;

import java.util.Map;

import javax.swing.DefaultCellEditor;

import javax.swing.JTable;

import javax.swing.JTextField;

import javax.swing.ListSelectionModel;

import javax.swing.UIManager;

import javax.swing.table.DefaultTableCellRenderer;

import javax.swing.table.TableCellRenderer;

import javax.swing.table.TableColumn;

import javax.swing.text.AbstractDocument;

import javax.swing.text.AttributeSet;

import javax.swing.text.BadLocationException;

import javax.swing.text.Document;

import javax.swing.text.DocumentFilter;

import javax.swing.text.JTextComponent;

import org.gvsig.tools.swing.impl.hexeditor.event.SelectionChangedEvent;

import org.gvsig.tools.swing.impl.hexeditor.event.SelectionChangedListener;

/*

 * Based on portions of code from ajaxproxy in GitHub

 * Copyright (c) 2008 Robert Futrell

 * https://github.com/mdeanda/ajaxproxy/tree/master/src/main/java/org/fife/ui/hex

 */

/**

 * The table displaying the hex content of a file.  This is the meat of

 * the hex viewer.

 *

 */

class HexTable extends JTable {

	private static final long serialVersionUID = 1L;

	private final HexEditorComponent hexEditor;

	private HexTableModel model;

	int leadSelectionIndex;

	int anchorSelectionIndex;

	private static final Color ANTERNATING_CELL_COLOR = new Color(240,240,240);

	private CellEditor cellEditor = new CellEditor();

	/**

	 * Creates a new table to display hex data.

	 *

	 * @param hexEditor The parent hex editor component.

	 * @param model The table model to use.

	 */

	public HexTable(HexEditorComponent hexEditor, HexTableModel model) {

		super(model);

		this.hexEditor = hexEditor;

		this.model = model;

		enableEvents(AWTEvent.KEY_EVENT_MASK);

		setAutoResizeMode(JTable.AUTO_RESIZE_OFF);

		setFont(new Font("Monospaced", Font.PLAIN, 14));

//setRowHeight(28);

		setCellSelectionEnabled(true);

		setSelectionMode(ListSelectionModel.SINGLE_INTERVAL_SELECTION);

		setDefaultEditor(Object.class, cellEditor);

		setDefaultRenderer(Object.class, new CellRenderer());

		getTableHeader().setReorderingAllowed(false);

		setShowGrid(false);

		FontMetrics fm = getFontMetrics(getFont());

		Font headerFont = UIManager.getFont("TableHeader.font");

		FontMetrics headerFM = hexEditor.getFontMetrics(headerFont);

		int w = fm.stringWidth("www"); // cell contents, 0-255

		w = Math.max(w, headerFM.stringWidth("+99"));

		for (int i=0; i<getColumnCount(); i++) {

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

			if (i<16) {

				column.setPreferredWidth(w);

			}

			else {

				column.setPreferredWidth(HexEditorComponent.DUMP_COLUMN_WIDTH);

			}

		}

		setPreferredScrollableViewportSize(

				new Dimension(w*16+HexEditorComponent.DUMP_COLUMN_WIDTH, 25*getRowHeight()));

		anchorSelectionIndex = leadSelectionIndex = 0;

	}

	/**

	 * Registers a prospect who is interested when the text selection from the

	 * hex editor becomes changed.

	 * 

	 * @param l The concerning listener.

	 * @see #removeSelectionChangedListener(SelectionChangedListener)

	 */

	public void addSelectionChangedListener(SelectionChangedListener l) {

		listenerList.add(SelectionChangedListener.class, l);

	}

	/**

	 * Returns the column for the cell containing data that is the closest

	 * to the specified cell.  This is used when, for example, the user clicks

	 * on an "empty" cell in the last row of the table.

	 *  

	 * @param row The row of the cell clicked on.

	 * @param col The column of the cell clicked on.

	 * @return The column of the closest cell containing data.

	 */

	private int adjustColumn(int row, int col) {

		if (col<0) {

			return 0;

		}

		if (row==getRowCount()-1) {

			int lastRowCount = model.getByteCount()%16;

			if (lastRowCount==0) {

				lastRowCount = 16;

			}

			if (lastRowCount<16) { // Last row's not entirely full

				return Math.min(col, (model.getByteCount()%16)-1);

			}

		}

		return Math.min(col, getColumnCount()-1-1);

	}

	/**

	 * Returns the offset into the bytes being edited represented at the

	 * specified cell in the table, if any.

	 *

	 * @param row The row in the table.

	 * @param col The column in the table.

	 * @return The offset into the byte array, or <code>-1</code> if the

	 *         cell does not represent part of the byte array (such as the

	 *         tailing "ascii dump" column's cells).

	 * @see #offsetToCell(int)

	 */

	public int cellToOffset(int row, int col) {

		// Check row and column individually to prevent them being invalid

		// values but still pointing to a valid offset in the buffer.

		if (row<0 || row>=getRowCount() ||

				col<0 || col>15) { // Don't include last column (ascii dump)

			return -1;

		}

		int offs = row*16 + col;

		return (offs>=0 && offs<model.getByteCount()) ? offs : -1;

	}

	/**

	 * Changes the selected byte range.

	 *

	 * @param row

	 * @param col

	 * @param toggle

	 * @param extend

	 * @see #changeSelectionByOffset(int, boolean)

	 * @see #setSelectedRows(int, int)

	 * @see #setSelectionByOffsets(int, int)

	 */

	public void changeSelection(int row, int col, boolean toggle,

								boolean extend) {

	    // remind previous selection range

		int prevSmallest = getSmallestSelectionIndex();

		int prevLargest = getLargestSelectionIndex();

		// Don't allow the user to select the "ascii dump" or any

		// empty cells in the last row of the table.

		col = adjustColumn(row, col);

		if (row<0) {

			row = 0;

		}

		// Clear the old selection (may not be necessary).

		repaintSelection();

		if (extend) {

			leadSelectionIndex = cellToOffset(row, col);

		}

		else {

			anchorSelectionIndex = leadSelectionIndex = cellToOffset(row, col);

		}

        // Scroll after changing the selection as blit scrolling is

		// immediate, so that if we cause the repaint after the scroll we

		// end up painting everything!

		if (getAutoscrolls()) {

			ensureCellIsVisible(row, col);

		}

		// Draw the new selection.

		repaintSelection();

		fireSelectionChangedEvent(prevSmallest, prevLargest);

	}

	/**

	 * Changes the selection by an offset into the bytes being edited.

	 *

	 * @param offset

	 * @param extend

	 * @see #changeSelection(int, int, boolean, boolean)

	 * @see #setSelectedRows(int, int)

	 * @see #setSelectionByOffsets(int, int)

	 */

	public void changeSelectionByOffset(int offset, boolean extend) {

		offset = Math.max(0, offset);

		offset = Math.min(offset, model.getByteCount()-1);

		int row = offset/16;

		int col = offset%16;

		changeSelection(row, col, false, extend);

	}

	/**

	 * Clears the selection.  The "lead" of the selection is set back to the

	 * position of the "anchor."

	 */

	public void clearSelection() {

		if (anchorSelectionIndex>-1) { // Always true unless an error

			leadSelectionIndex = anchorSelectionIndex;

		}

		else {

			anchorSelectionIndex = leadSelectionIndex = 0;

		}

		repaintSelection();

	}

	/**

	 * Ensures the specified cell is visible.

	 *

	 * @param row The row of the cell.

	 * @param col The column of the cell.

	 */

	private void ensureCellIsVisible(int row, int col) {

		Rectangle cellRect = getCellRect(row, col, false);

		if (cellRect != null) {

			scrollRectToVisible(cellRect);

		}

	}

	/**

	 * Notifies any listeners that the selection has changed.

	 * 

	 * @see #addSelectionChangedListener(SelectionChangedListener)

	 * @see #removeSelectionChangedListener(SelectionChangedListener)

	 * @param e Contains proper information.

	 */

	private void fireSelectionChangedEvent(int prevSmallest, int prevLargest) {

		// Lazily create the event

		SelectionChangedEvent e = null;

		// Guaranteed non-null array

		Object[] listeners = listenerList.getListenerList();

		// Process last to first

		for (int i=listeners.length-2; i>=0; i-=2) {

			if (listeners[i]==SelectionChangedListener.class) {

				if (e==null) {

				    e = new SelectionChangedEvent(this,

				    	prevSmallest, prevLargest,

				    	getSmallestSelectionIndex(), getLargestSelectionIndex());

				}

				((SelectionChangedListener)listeners[i+1]).selectionChanged(e);

			}

		}

	}

	/**

	 * Returns the byte at the specified offset.

	 *

	 * @param offset The offset.

	 * @return The byte.

	 */

	public byte getByte(int offset) {

		return model.getByte(offset);

	}

        public byte[] getBytes() {

            return this.model.getBytes();

        }

	/**

	 * Returns the number of bytes being edited.

	 *

	 * @return The number of bytes.

	 */

	public int getByteCount() {

		return model.getByteCount();

	}

	/**

	 * Returns the rendering hints for text that will most accurately reflect

	 * those of the native windowing system.

	 *

	 * @return The rendering hints, or <code>null</code> if they cannot be

	 *         determined.

	 */

	private Map getDesktopAntiAliasHints() {

		return (Map)getToolkit().getDesktopProperty("awt.font.desktophints");

	}

	/**

	 * Returns the largest selection index.

	 *

	 * @return The largest selection index.

	 * @see #getSmallestSelectionIndex()

	 */

	public int getLargestSelectionIndex() {

		int index = Math.max(leadSelectionIndex, anchorSelectionIndex);

		return Math.max(index, 0); // Don't return -1 if table is empty

	}

	/**

	 * Returns the smallest selection index.

	 *

	 * @return The smallest selection index.

	 * @see #getLargestSelectionIndex()

	 */

	public int getSmallestSelectionIndex() {

		int index = Math.min(leadSelectionIndex, anchorSelectionIndex);

		return Math.max(index, 0); // Don't return -1 if table is empty

	}

	public boolean isCellEditable(int row, int col) {

		return cellToOffset(row, col)>-1;

	}

	public boolean isCellSelected(int row, int col) {

		int offset = cellToOffset(row, col);

		if (offset==-1) { // "Ascii dump" column

			return false;

		}

		int start = getSmallestSelectionIndex();

		int end = getLargestSelectionIndex();

		return offset>=start && offset<=end;

	}

	/**

	 * Returns the cell representing the specified offset into the hex

	 * document.

	 *

	 * @param offset The offset into the document.

	 * @return The cell, in the form <code>(row, col)</code>.  If the

	 *         specified offset is invalid, <code>(-1, -1)</code> is returned.

	 * @see #cellToOffset(int, int)

	 */

	public Point offsetToCell(int offset) {

		if (offset<0 || offset>=model.getByteCount()) {

			return new Point(-1, -1);

		}

		int row = offset/16;

		int col = offset%16;

		return new Point(row, col);

	}

	/**

	 * Sets the contents in the hex editor to the contents of the specified

	 * file.

	 *

	 * @param fileName The name of the file to open.

	 * @throws IOException If an IO error occurs.

	 */

	public void open(String fileName) throws IOException {

		model.setBytes(fileName); // Fires tableDataChanged event

	}

	/**

	 * Sets the contents in the hex editor to the contents of the specified

	 * input stream.

	 *

	 * @param in An input stream.

	 * @throws IOException If an IO error occurs.

	 */

	public void open(InputStream in) throws IOException {

		model.setBytes(in);

	}

	public Component prepareRenderer(TableCellRenderer renderer, int row,

									int column) {

		Object value = getValueAt(row, column);

		boolean isSelected = isCellSelected(row, column);

		boolean hasFocus = cellToOffset(row, column)==leadSelectionIndex;

		return renderer.getTableCellRendererComponent(this, value,

										isSelected, hasFocus, row, column);

	}

	protected void processKeyEvent (java.awt.event.KeyEvent e) {

		// TODO: Convert into Actions and put into InputMap/ActionMap?

		if (e.getID()==KeyEvent.KEY_PRESSED) {

			switch (e.getKeyCode()) {

				case KeyEvent.VK_LEFT:

					boolean extend = e.isShiftDown();

					int offs = Math.max(leadSelectionIndex-1, 0);

					changeSelectionByOffset(offs, extend);

					e.consume();

					break;

				case KeyEvent.VK_RIGHT:

					extend = e.isShiftDown();

					offs = Math.min(leadSelectionIndex+1, model.getByteCount()-1);

					changeSelectionByOffset(offs, extend);

					e.consume();

					break;

				case KeyEvent.VK_UP:

					extend = e.isShiftDown();

					offs = Math.max(leadSelectionIndex-16, 0);

					changeSelectionByOffset(offs, extend);

					e.consume();

					break;

				case KeyEvent.VK_DOWN:

					extend = e.isShiftDown();

					offs = Math.min(leadSelectionIndex+16, model.getByteCount()-1);

					changeSelectionByOffset(offs, extend);

					e.consume();

					break;

				case KeyEvent.VK_PAGE_DOWN:

					extend = e.isShiftDown();

					int visibleRowCount = getVisibleRect().height/getRowHeight();

					offs = Math.min(leadSelectionIndex+visibleRowCount*16,

									model.getByteCount()-1);

					changeSelectionByOffset(offs, extend);

					e.consume();

					break;

				case KeyEvent.VK_PAGE_UP:

					extend = e.isShiftDown();

					visibleRowCount = getVisibleRect().height/getRowHeight();

					offs = Math.max(leadSelectionIndex-visibleRowCount*16, 0);

					changeSelectionByOffset(offs, extend);

					e.consume();

					break;

				case KeyEvent.VK_HOME:

					extend = e.isShiftDown();

					offs = (leadSelectionIndex/16)*16;

					changeSelectionByOffset(offs, extend);

					e.consume();

					break;

				case KeyEvent.VK_END:

					extend = e.isShiftDown();

					offs = (leadSelectionIndex/16)*16 + 15;

					offs = Math.min(offs, model.getByteCount()-1);

					changeSelectionByOffset(offs, extend);

					e.consume();

					break;

			}

		}

		super.processKeyEvent(e);

	}

	/**

	 * Tries to redo the last action undone.

	 *

	 * @return Whether there is another action to redo after this one.

	 * @see #undo()

	 */

	public boolean redo() {

		return model.redo();

	}

	/**

	 * Removes a range of bytes.

	 *

	 * @param offs The offset of the range of bytes to remove.

	 * @param len The number of bytes to remove.

	 * @see #replaceBytes(int, int, byte[])

	 */

	void removeBytes(int offs, int len) {

		model.removeBytes(offs, len);

	}

	private void repaintSelection() {

		// TODO: Repaint only selected lines.

		repaint();

	}

	/**

	 * Removes a listener who isn't any longer interested whether the text

	 * selection from the hex editor becomes changed.

	 * 

	 * @param l The concerning previous prospect.

	 * @see #addSelectionChangedListener(SelectionChangedListener)

	 */

	public void removeSelectionChangedListener(SelectionChangedListener l) {

		listenerList.remove(SelectionChangedListener.class, l);

	}