/ - Diff - Library: org.gvsig.tools - gvSIG

Revision 2937

     /*
      * Copyright (c) 2008 Robert Futrell
      * All rights reserved.
+     *
      * Redistribution and use in source and binary forms, with or without
      * modification, are permitted provided that the following conditions are met:
      *     * Redistributions of source code must retain the above copyright
      *       notice, this list of conditions and the following disclaimer.
      *     * Redistributions in binary form must reproduce the above copyright
      *       notice, this list of conditions and the following disclaimer in the
      *       documentation and/or other materials provided with the distribution.
      *     * Neither the name "HexEditor" nor the names of its contributors may
      *       be used to endorse or promote products derived from this software
      *       without specific prior written permission.
+     *
      * THIS SOFTWARE IS PROVIDED BY ''AS IS'' AND ANY EXPRESS OR IMPLIED
      * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
      * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO
      * EVENT SHALL THE CONTRIBUTORS TO THIS SOFTWARE BE LIABLE FOR ANY DIRECT,
      * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
      * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
      * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
      * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
      * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
      * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
      */
     package org.gvsig.tools.swing.impl.hexeditor;
     import java.io.BufferedInputStream;
     import java.io.ByteArrayOutputStream;
     import java.io.File;
     import java.io.FileInputStream;
     import java.io.IOException;
     import java.io.InputStream;
     public class ByteBuffer {
     	/**
     	 * The byte buffer that contains the document content.
     	 */
     	private byte[] buffer;
     	public ByteBuffer(int size) {
     		buffer = new byte[size];
+    	}
     	public ByteBuffer(String file) throws IOException {
     		this(new File(file));
+    	}
     	public ByteBuffer(File file) throws IOException {
     		int size = (int)file.length();
     		if (size<0) { // Probably never happens.
     			throw new IOException("Negative file length: " + size);
+    		}
     		buffer = new byte[size];
     		if (size>0) {
     			BufferedInputStream in = new BufferedInputStream(
     										new FileInputStream(file));
     			int pos = 0;
     			int count = 0;
     			try {
     				while (pos<buffer.length &&
     						(count=in.read(buffer, pos, buffer.length-pos))>-1) {
     					pos += count;
+    				}
     			} finally {
     				in.close();
+    			}
+    		}
+    	}
     	/**
     	 * Creates a buffer representing the contents read from an input stream.
+    	 *
     	 * @param in The input stream to read from.
     	 * @throws IOException If an IO error occurs.
     	 */
     	public ByteBuffer(InputStream in) throws IOException {
     		ByteArrayOutputStream baos = new ByteArrayOutputStream();
     		buffer = new byte[4096]; // Use as a temporary buffer.
     		int count = 0;
     		while ((count=in.read(buffer, 0,buffer.length))>-1) {
     			baos.write(buffer, 0,count);
+    		}
     		buffer = baos.toByteArray();
+    	}
     	public byte getByte(int offset) {
     		return buffer[offset];
+    	}
             public byte[] getBytes() {
                 return this.buffer;
+            }
     	public int getSize() {
     		return buffer.length;
+    	}
     	public void insertByte(int offset, byte b) {
     		byte[] buf2 = new byte[buffer.length+1];
     		System.arraycopy(buffer,0, buf2,0, offset);
     		buf2[offset] = b;
     		System.arraycopy(buffer,offset, buf2,offset+1, buffer.length-offset);
     		buffer = buf2;
+    	}
     	public void insertBytes(int offs, byte[] b) {
     		if (b==null || b.length==0) {
     			return;
+    		}
     		byte[] buf2 = new byte[buffer.length+b.length];
     		System.arraycopy(buffer,0,    buf2,0,             offs);
     		System.arraycopy(b,0,         buf2,offs,          b.length);
     		System.arraycopy(buffer,offs, buf2,offs+b.length, buffer.length-offs);
     		buffer = buf2;
+    	}
     	public int read(int offset, byte[] buf) {
     		if (buf==null) {
     			return -1;
+    		}
     		int count = Math.min(buf.length, getSize()-offset);
     		System.arraycopy(buffer,offset, buf,0, count);
     		return count;
+    	}
     	public void remove(int offset, int len) {
     		remove(offset, len, null);
+    	}
     	public void remove(int offset, int len, byte[] removed) {
     		if (removed!=null) {
     			System.arraycopy(buffer,offset, removed,0, len);
+    		}
     		byte[] buf = new byte[buffer.length-len];
     		System.arraycopy(buffer,0, buf,0, offset);
     		System.arraycopy(buffer,offset+len, buf,offset, buf.length-offset);
     		buffer = buf;
+    	}
     	public void setByte(int offset, byte b) {
     		buffer[offset] = b;
+    	}
+    }

     package org.gvsig.tools.swing.impl.hexeditor.event;
     import java.util.EventListener;
     import org.gvsig.tools.swing.impl.hexeditor.swing.HexEditor;
     /**
      * An object listening for events from a {@link HexEditor}.
+     *
      * @author Robert Futrell
      * @version 1.0
      */
     public interface HexEditorListener extends EventListener {
     	/**
     	 * Called when bytes in a hex editor are added, removed, or modified.
+    	 *
     	 * @param e The event object.
     	 */
     	public void hexBytesChanged(HexEditorEvent e);
+    }

     /*
      * Copyright (c) 2011 Robert Futrell
      * All rights reserved.
+     *
      * Redistribution and use in source and binary forms, with or without
      * modification, are permitted provided that the following conditions are met:
      *     * Redistributions of source code must retain the above copyright
      *       notice, this list of conditions and the following disclaimer.
      *     * Redistributions in binary form must reproduce the above copyright
      *       notice, this list of conditions and the following disclaimer in the
      *       documentation and/or other materials provided with the distribution.
      *     * Neither the name "HexEditor" nor the names of its contributors may
      *       be used to endorse or promote products derived from this software
      *       without specific prior written permission.
+     *
      * THIS SOFTWARE IS PROVIDED BY ''AS IS'' AND ANY EXPRESS OR IMPLIED
      * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
      * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO
      * EVENT SHALL THE CONTRIBUTORS TO THIS SOFTWARE BE LIABLE FOR ANY DIRECT,
      * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
      * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
      * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
      * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
      * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
      * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
      */
     package org.gvsig.tools.swing.impl.hexeditor.event;
     import java.util.EventObject;
     /**
      * Occurs when the cell selection within the hex editor becomes changed.
+     *
      * @author PAX
      * @version 1.0
      */
     public class SelectionChangedEvent extends EventObject {
     	private static final long serialVersionUID = 1L;
     	/**
     	 * The previous selection start index.
     	 */
     	private int previousSelecStart;
     	/**
     	 * The new selection start index.
     	 */
     	private int newSelecStart;
     	/**
     	 * The previous selection end index.
     	 */
     	private int previousSelecEnd;
     	/**
     	 * The new selection end index.
     	 */
     	private int newSelecEnd;
     	/**
     	 * Constructor.
+    	 *
     	 * @param source The instance which creates this event.
     	 * @param previousSelecStart The previous selection start index.
     	 * @param previousSelecEnd The previous selection end index.
     	 * @param newSelecStart The new selection start index.
     	 * @param newSelecEnd The new selection end index.
     	 */
     	public SelectionChangedEvent(Object source, int previousSelecStart,
     			int previousSelecEnd, int newSelecStart, int newSelecEnd) {
     		super(source);
     		this.previousSelecStart = previousSelecStart;
     		this.previousSelecEnd = previousSelecEnd;
     		this.newSelecStart = newSelecStart;
     		this.newSelecEnd = newSelecEnd;
+    	}
     	/**
     	 * @return The new selection end index.
     	 */
     	public int getNewSelecEnd() {
     		return this.newSelecEnd;
+    	}
     	/**
     	 * @return The new selection start index.
     	 */
     	public int getNewSelecStart() {
     		return this.newSelecStart;
+    	}
     	/**
     	 * @return The previous selection end index.
     	 */
     	public int getPreviousSelecEnd() {
     		return this.previousSelecEnd;
+    	}
     	/**
     	 * @return The previous selection start index.
     	 */
     	public int getPreviousSelecStart() {
     		return this.previousSelecStart;
+    	}
     	public String toString() {
     		StringBuffer result = new StringBuffer("Old selection: [");
     		result.append(getPreviousSelecStart()).append(", ");
     		result.append(getPreviousSelecEnd()).append("]; New selection: [");
     		result.append(getNewSelecStart()).append(", ");
     		result.append(getNewSelecEnd()).append(']');
     		return result.toString();
+    	}
+    }

     /*
      * Copyright (c) 2011 Robert Futrell
      * All rights reserved.
+     *
      * Redistribution and use in source and binary forms, with or without
      * modification, are permitted provided that the following conditions are met:
      *     * Redistributions of source code must retain the above copyright
      *       notice, this list of conditions and the following disclaimer.
      *     * Redistributions in binary form must reproduce the above copyright
      *       notice, this list of conditions and the following disclaimer in the
      *       documentation and/or other materials provided with the distribution.
      *     * Neither the name "HexEditor" nor the names of its contributors may
      *       be used to endorse or promote products derived from this software
      *       without specific prior written permission.
+     *
      * THIS SOFTWARE IS PROVIDED BY ''AS IS'' AND ANY EXPRESS OR IMPLIED
      * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
      * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO
      * EVENT SHALL THE CONTRIBUTORS TO THIS SOFTWARE BE LIABLE FOR ANY DIRECT,
      * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
      * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
      * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
      * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
      * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
      * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
      */
     package org.gvsig.tools.swing.impl.hexeditor.event;
     import java.util.EventListener;
     /**
      * Somebody who is interested whether the cell selection within the hex editor
      * becomes changed.
+     *
      * @author PAX
      * @version 1.0
      */
     public interface SelectionChangedListener extends EventListener {
     	/**
     	 * Becomes invoked as soon as the selection of the hex editor's content has
     	 * changed.
+    	 *
     	 * @param event Contains specific information about the previous selection
     	 *        state and the new one.
     	 */
     	public void selectionChanged(SelectionChangedEvent event);
+    }

     package org.gvsig.tools.swing.impl.hexeditor.event;
     import java.util.EventObject;
     import org.gvsig.tools.swing.impl.hexeditor.swing.HexEditor;
     /**
      * An event that is fired when certain events occur in a hex editor.
+     *
      * @author Robert Futrell
      * @version 1.0
      */
     public class HexEditorEvent extends EventObject {
     	private static final long serialVersionUID = 1L;
     	/**
     	 * The offset of the change.
     	 */
     	private int offset;
     	/**
     	 * The number of bytes added.
     	 */
     	private int added;
     	/**
     	 * The number of bytes removed.
     	 */
     	private int removed;
     	/**
     	 * Creates a new event object.
+    	 *
     	 * @param editor The source of this event.
     	 * @param offs The offset at which bytes were added or removed.
     	 * @param added The number of bytes added, or <code>0</code> for none.
     	 * @param removed The number of bytes removed, or <code>0</code> for none.
     	 */
     	public HexEditorEvent(HexEditor editor, int offs, int added, int removed) {
     		super(editor);
     		this.offset = offs;
     		this.added = added;
     		this.removed = removed;
+    	}
     	/**
     	 * Returns the number of bytes added.  If this value equals the number
     	 * of bytes removed, the bytes were actually modified.
+    	 *
     	 * @return The number of bytes added.
     	 * @see #getRemovedCount()
     	 */
     	public int getAddedCount() {
     		return added;
+    	}
     	/**
     	 * Returns the hex editor that fired this event.
+    	 *
     	 * @return The hex editor.
     	 */
     	public HexEditor getHexEditor() {
     		return (HexEditor)getSource();
+    	}
     	/**
     	 * Returns the offset of the change.
+    	 *
     	 * @return The offset of the change.
     	 */
     	public int getOffset() {
     		return offset;
+    	}
     	/**
     	 * Returns the number of bytes removed.  If this value equals the number
     	 * of bytes added, then the bytes were actually modified.
+    	 *
     	 * @return The number of bytes removed.
     	 * @see #getAddedCount()
     	 */
     	public int getRemovedCount() {
     		return removed;
+    	}
     	/**
     	 * Returns whether this was a "modification" of bytes; that is, no bytes
     	 * were added or removed, bytes were only modified.  This is equivalent
     	 * to <code>getAddedCount() == getRemovedCount()</code>.
+    	 *
     	 * @return Whether this is just a "modification" of bytes.
     	 */
     	public boolean isModification() {
     		return getAddedCount()==getRemovedCount();
+    	}
+    }

     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;
     /**
      * A <code>Transferable</code> that transfers an array of bytes.
+     *
      * @author Robert Futrell
      * @version 1.0
      */
     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;
+    	}
+    }

     /*
      * Copyright (c) 2008 Robert Futrell
      * All rights reserved.
+     *
      * Redistribution and use in source and binary forms, with or without
      * modification, are permitted provided that the following conditions are met:
      *     * Redistributions of source code must retain the above copyright
      *       notice, this list of conditions and the following disclaimer.
      *     * Redistributions in binary form must reproduce the above copyright
      *       notice, this list of conditions and the following disclaimer in the
      *       documentation and/or other materials provided with the distribution.
      *     * Neither the name "HexEditor" nor the names of its contributors may
      *       be used to endorse or promote products derived from this software
      *       without specific prior written permission.
+     *
      * THIS SOFTWARE IS PROVIDED BY ''AS IS'' AND ANY EXPRESS OR IMPLIED
      * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
      * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO
      * EVENT SHALL THE CONTRIBUTORS TO THIS SOFTWARE BE LIABLE FOR ANY DIRECT,
      * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
      * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
      * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
      * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
      * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
      * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
      */
     package org.gvsig.tools.swing.impl.hexeditor.swing;
     import java.awt.Color;
     import java.awt.EventQueue;
     import java.awt.Point;
     import java.awt.event.ActionEvent;
     import java.io.IOException;
     import java.io.InputStream;
     import javax.swing.Action;
     import javax.swing.JScrollPane;
     import javax.swing.TransferHandler;
     import javax.swing.UIManager;
     import org.gvsig.tools.swing.impl.hexeditor.event.HexEditorEvent;
     import org.gvsig.tools.swing.impl.hexeditor.event.HexEditorListener;
     import org.gvsig.tools.swing.impl.hexeditor.event.SelectionChangedListener;
     /**
      * A Swing hex editor component.<p>
+     *
      * The hex editor's functionality includes:
      * <ul>
      *    <li>Cut, copy, paste, delete of 1 or more bytes
      *    <li>Undo/redo
      *    <li>Selecting a contiguous block of bytes
      * </ul>
+     *
      * @author Robert Futrell
      * @version 1.0
      */
     public class HexEditor extends JScrollPane {
     	private static final long serialVersionUID = 1L;
     	/**
     	 * Property fired when the alternating of column background colors is
     	 * toggled.
     	 */
     	public static final String PROPERTY_ALTERNATE_COLUMN_BG = "alternateColBG";
     	/**
     	 * Property fired when the alternating of row background colors is
     	 * toggled.
     	 */
     	public static final String PROPERTY_ALTERNATE_ROW_BG = "alternateRowBG";
     	/**
     	 * Property fired when the highlight color of the ascii dump column
     	 * is changed.
     	 */
     	public static final String PROPERTY_ASCII_DUMP_HIGHLIGHT_COLOR =
     												"asciiDumpHighlightColor";
     	/**
     	 * Property fired when the visibility of the highlight in the "ascii
     	 * dump" column is toggled.
     	 */
     	public static final String PROPERTY_HIGHLIGHT_ASCII_DUMP =
     												"highlightAsciiDump";
     	/**
     	 * Property fired when the padding of low bytes (<code>0 - 15</code>)
     	 * is toggled.
     	 */
     	public static final String PROPERTY_PAD_LOW_BYTES = "padLowBytes";
     	/**
     	 * Property fired when the visibility of the grid is toggled.
     	 */
     	public static final String PROPERTY_SHOW_GRID = "showGrid";
     	private HexTable table;
     	private boolean alternateRowBG;
     	private boolean alternateColumnBG;
     	private boolean highlightSelectionInAsciiDump;
     	private Color highlightSelectionInAsciiDumpColor;
     	private boolean padLowBytes;
     	private static final TransferHandler DEFAULT_TRANSFER_HANDLER =
     							new HexEditorTransferHandler();
     	static final int DUMP_COLUMN_WIDTH		= 140;
     //	private static final String MSG = "org.fife.ui.hex.HexEditor";
     	/**
     	 * Creates a new <code>HexEditor</code> component.
     	 */
     	public HexEditor() {
     //		ResourceBundle msg = ResourceBundle.getBundle(MSG);
     		HexTableModel model = new HexTableModel(this); //, msg);
     		table = new HexTable(this, model);
     		setViewportView(table);
     		setShowRowHeader(true);
     		setAlternateRowBG(false);
     		setAlternateColumnBG(false);
     		setHighlightSelectionInAsciiDump(true);
     		setHighlightSelectionInAsciiDumpColor(new Color(255,255,192));
     		setPadLowBytes(true);
     		setCellEditable(true);
     		setTransferHandler(DEFAULT_TRANSFER_HANDLER);
+    	}
     	/**
     	 * Adds a hex editor listener to this editor.
+    	 *
     	 * @param l The listener to add.
     	 * @see #removeHexEditorListener(HexEditorListener)
     	 */
     	public void addHexEditorListener(HexEditorListener l) {
     		listenerList.add(HexEditorListener.class, l);
+    	}
     	/**
     	 * 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) {
     		table.addSelectionChangedListener(l);
+    	}
     	/**
     	 * 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) {
     		return table.cellToOffset(row, col);
+    	}
     	/**
     	 * Copies the currently selected bytes to the clipboard.
+    	 *
     	 * @see #cut()
     	 * @see #paste()
     	 * @see #delete()
     	 */
     	public void copy() {
     		invokeAction(TransferHandler.getCopyAction());
+    	}
     	/**
     	 * Removes the currently selected bytes and moves them to the clipboard.
+    	 *
     	 * @see #copy()
     	 * @see #paste()
     	 * @see #delete()
     	 */
     	public void cut() {
     		invokeAction(TransferHandler.getCutAction());
+    	}
     	/**
     	 * Removes the currently selected bytes.
+    	 *
     	 * @see #cut()
     	 * @see #copy()
     	 * @see #paste()
     	 */
     	public void delete() {
     		// Sanity check (should never happen)
     		if (table.leadSelectionIndex==-1 || table.anchorSelectionIndex==-1) {
     			UIManager.getLookAndFeel().provideErrorFeedback(table);
     			return;
+    		}
     		int start = table.getSmallestSelectionIndex();
     		int end = table.getLargestSelectionIndex();
     		int len = end-start+1;
     		removeBytes(start, len);
+    	}
     	/**
     	 * Notifies all interested listeners of an event in this hex editor.
+    	 *
     	 * @param offset The offset of the change.
     	 * @param added The number of bytes added.
     	 * @param removed The number of bytes removed.
     	 */
     	protected void fireHexEditorEvent(int offset, int added, int removed) {
     		HexEditorEvent e = null;
     		// Guaranteed to return a non-null array
     		Object[] listeners = listenerList.getListenerList();
     		// Process the listeners last to first, notifying
     		// those that are interested in this event
     		for (int i=listeners.length-2; i>=0; i-=2) {
     			if (listeners[i]==HexEditorListener.class) {
     				// Lazily create the event in case there are no listeners.
     				if (e==null) {
     					e = new HexEditorEvent(this, offset, added, removed);
+    				}
     				((HexEditorListener)listeners[i+1]).hexBytesChanged(e);
+    			}
+    		}
+    	}
     	/**
     	 * Returns whether the color of columns in the hex editor should alternate.
+    	 *
     	 * @return Whether the column color alternates.
     	 * @see #setAlternateColumnBG(boolean)
     	 * @see #getAlternateRowBG()
     	 */
     	public boolean getAlternateColumnBG() {
     		return alternateColumnBG;
+    	}
     	/**
     	 * Returns whether the color of rows in the hex editor should alternate.
+    	 *
     	 * @return Whether the row color alternates.
     	 * @see #setAlternateRowBG(boolean)
     	 * @see #getAlternateColumnBG()
     	 */
     	public boolean getAlternateRowBG() {
     		return alternateRowBG;
+    	}
     	/**
     	 * Returns the byte at the specified offset.
+    	 *
     	 * @param offset The offset.
     	 * @return The byte.
     	 */
     	public byte getByte(int offset) {
     		return table.getByte(offset);
+    	}
     	/**
     	 * Returns the number of bytes being edited.
+    	 *
     	 * @return The number of bytes.
     	 */
     	public int getByteCount() {
     		return table.getByteCount();
+    	}
             public byte[] getBytes() {
                 return this.table.getBytes();
+            }
     	/**
     	 * Returns whether the selected bytes should also appear selected in
     	 * the "ascii dump" column.
+    	 *
     	 * @return Whether the selected bytes should also be selected in the
     	 *         "ascii dump" column.
     	 * @see #setHighlightSelectionInAsciiDump(boolean)
     	 */
     	public boolean getHighlightSelectionInAsciiDump() {
     		return highlightSelectionInAsciiDump;
+    	}
     	/**
     	 * Returns the color used to highlight the selected bytes in the
     	 * "ascii dump" column.
+    	 *
     	 * @return The color used.
     	 * @see #setHighlightSelectionInAsciiDumpColor(Color)
     	 * @see #getHighlightSelectionInAsciiDump()
     	 */
     	public Color getHighlightSelectionInAsciiDumpColor() {
     		return highlightSelectionInAsciiDumpColor;
+    	}
     	/**
     	 * Returns the largest selection index.
+    	 *
     	 * @return The largest selection index.
     	 * @see #getSmallestSelectionIndex()
     	 */
     	public int getLargestSelectionIndex() {
     		return table.getLargestSelectionIndex();
+    	}
     	/**
     	 * Returns whether bytes that can be displayed as a single char
     	 * (i.e. <code>0 - 15</code>) are prepended with a "<code>0</code>"
     	 * char to make them two characters wide in the display.
+    	 *
     	 * @return Whether bytes with one-character hex representations
     	 *         will be prepended with a "<code>0</code>" in the display.
     	 * @see #setPadLowBytes(boolean)
     	 */
     	public boolean getPadLowBytes() {
     		return padLowBytes;
+    	}
     	/**
     	 * Returns the smallest selection index.
+    	 *
     	 * @return The smallest selection index.
     	 * @see #getLargestSelectionIndex()
     	 */
     	public int getSmallestSelectionIndex() {
     		return table.getSmallestSelectionIndex();
+    	}
     	/**
     	 * Returns the table actually containing the hex data.
+    	 *
     	 * @return The table.
     	 */
     	HexTable getTable() {
     		return table;
+    	}
     	private void invokeAction(Action a) {
     		a.actionPerformed(new ActionEvent(this, ActionEvent.ACTION_PERFORMED,
     								(String)a.getValue(Action.NAME),
     								EventQueue.getMostRecentEventTime(),
 ));
+    	}
     	/**
     	 * 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) {
     		return table.offsetToCell(offset);
+    	}
     	/**
     	 * 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 {
     		table.open(fileName);
+    	}
     	/**
     	 * 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 {
     		table.open(in);
+    	}
     	/**
     	 * "Pastes" the bytes in the clipboard into the current selection in
     	 * the hex editor.
+    	 *
     	 * @see #copy()
     	 * @see #cut()
     	 * @see #delete()
     	 */
     	public void paste() {
     		invokeAction(TransferHandler.getPasteAction());
+    	}
     	/**
     	 * Tries to redo the last action undone.
+    	 *
     	 * @return Whether there is another action to redo after this one.
     	 * @see #undo()
     	 */
     	public boolean redo() {
     		return table.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[])
     	 */
     	public void removeBytes(int offs, int len) {
     		table.removeBytes(offs, len);
     		table.changeSelectionByOffset(offs, false);
+    	}
     	/**
     	 * Removes the specified hex editor listener from this editor.
+    	 *
     	 * @param l The listener to remove.
     	 * @see #addHexEditorListener(HexEditorListener)
     	 */
     	public void removeHexEditorListener(HexEditorListener l) {
     		listenerList.remove(HexEditorListener.class, l);
+    	}
     	/**
     	 * 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) {
     		table.removeSelectionChangedListener(l);
+    	}
     	/**
     	 * Replaces a range of bytes.
+    	 *
     	 * @param offset The offset of the range of bytes to replace.
     	 * @param len The number of bytes to replace.
     	 * @param bytes The bytes to replace the range with.
     	 * @see #removeBytes(int, int)
     	 * @see #replaceSelection(byte[])
     	 */
     	public void replaceBytes(int offset, int len, byte[] bytes) {
     		if (len==1) { // Just insert if 1 bytes is selected.
     			len = 0;
+    		}
     		table.replaceBytes(offset, len, bytes);
     		table.changeSelectionByOffset(table.anchorSelectionIndex, false);
     		int count = bytes==null ? 0 : bytes.length;
     		table.setSelectionByOffsets(offset, offset+count-1);
+    	}
     	/**
     	 * Replaces the currently selected bytes (if greater or equal to 1) with the specified
     	 * new bytes.
+    	 *
     	 * @param bytes The new bytes.  If this is <code>null</code> or an empty
     	 *        array, calling this method simply removes the currently
     	 *        selected bytes.
     	 * @see #replaceBytes(int, int, byte[])
     	 */
     	public void replaceSelection(byte[] bytes) {
     		int offset = table.getSmallestSelectionIndex();
     		int len = table.getLargestSelectionIndex()-offset+1;
     		replaceBytes(offset, len, bytes);
+    	}
     	/**
     	 * Sets whether the column color should alternate in the hex editor.
     	 * This method fires a property change event of type
     	 * {@link #PROPERTY_ALTERNATE_COLUMN_BG}.
+    	 *
     	 * @param alternate Whether the column color should alternate.
     	 * @see #getAlternateColumnBG()
     	 * @see #setAlternateRowBG(boolean)
     	 */
     	public void setAlternateColumnBG(boolean alternate) {
     		if (alternate!=alternateColumnBG) {
     			this.alternateColumnBG = alternate;
     			table.repaint();
     			firePropertyChange(PROPERTY_ALTERNATE_COLUMN_BG,
     									!alternate, alternate);
+    		}
+    	}
     	/**
     	 * Sets whether the row color should alternate in the hex editor.  This
     	 * method fires a property change event of type
     	 * {@link #PROPERTY_ALTERNATE_ROW_BG}.
+    	 *
     	 * @param alternate Whether the row color should alternate.
     	 * @see #getAlternateRowBG()
     	 * @see #setAlternateColumnBG(boolean)
     	 */
     	public void setAlternateRowBG(boolean alternate) {
     		if (alternate!=alternateRowBG) {
     			this.alternateRowBG = alternate;
     			table.repaint();
     			firePropertyChange(PROPERTY_ALTERNATE_ROW_BG,!alternate, alternate);
+    		}
+    	}
     	/**
     	 * Toggles whether the cells in the hex editor are editable by clicking
     	 * in them.
+    	 *
     	 * @param cellEditable Whether individual editor cells should be editable.
     	 */
     	public void setCellEditable(boolean cellEditable) {
     		table.setCellEditable(cellEditable);
+    	}
     	/**
     	 * Sets whether the selected bytes should also appear selected in the
     	 * "ascii dump" column.  This method fires a property change event of
     	 * type {@link #PROPERTY_HIGHLIGHT_ASCII_DUMP}.
+    	 *
     	 * @param highlight Whether the selected bytes should also appear
     	 *        selected in the "ascii dump" column.
     	 * @see #getHighlightSelectionInAsciiDump()
     	 * @see #setHighlightSelectionInAsciiDumpColor(Color)
     	 */
     	public void setHighlightSelectionInAsciiDump(boolean highlight) {
     		if (highlight!=highlightSelectionInAsciiDump) {
     			highlightSelectionInAsciiDump = highlight;
     			table.repaint();
     			firePropertyChange(PROPERTY_HIGHLIGHT_ASCII_DUMP,
     								!highlight, highlight);
+    		}
+    	}
     	/**
     	 * Sets what color should be used for the "ascii dump" selection.
     	 * This method fires a property change event of type
     	 * {@link #PROPERTY_ASCII_DUMP_HIGHLIGHT_COLOR}.
+    	 *
     	 * @param c The color to use.
     	 * @see #getHighlightSelectionInAsciiDumpColor()
     	 * @see #setHighlightSelectionInAsciiDump(boolean)
     	 */
     	public void setHighlightSelectionInAsciiDumpColor(Color c) {
     		if (c!=null && !c.equals(highlightSelectionInAsciiDumpColor)) {
     			Color old = highlightSelectionInAsciiDumpColor;
     			highlightSelectionInAsciiDumpColor = c;
     			table.repaint();
     			firePropertyChange(PROPERTY_ASCII_DUMP_HIGHLIGHT_COLOR, old, c);
+    		}
+    	}
     	/**
     	 * Sets whether bytes that can be displayed as a single char
     	 * (i.e. <code>0 - 15</code>) are prepended with a "<code>0</code>"
     	 * char to make them two characters wide in the display.  This method
     	 * fires a property change event of type {@link #PROPERTY_PAD_LOW_BYTES}.
+    	 *
     	 * @param pad Whether to pad such bytes in the display.
     	 * @see #getPadLowBytes()
     	 */
     	public void setPadLowBytes(boolean pad) {
     		if (padLowBytes!=pad) {
     			padLowBytes = pad;
     			table.repaint();
     			firePropertyChange(PROPERTY_PAD_LOW_BYTES, !pad, pad);
+    		}
+    	}
     	/**
     	 * Sets the range of bytes to select in the hex editor.
+    	 *
     	 * @param startOffs The first byte to select.
     	 * @param endOffs The last byte to select.
     	 */
     	public void setSelectedRange(int startOffs, int endOffs) {
     		table.setSelectionByOffsets(startOffs, endOffs);
+    	}
     	/**
     	 * Toggles whether table's column header is visible.
+    	 *
     	 * @param show Whether to show the table column header.
     	 * @see #setShowRowHeader(boolean)
     	 */
     	public void setShowColumnHeader(boolean show) {
     		// Since table header is added to a parent JScrollPane as a
     		// column header, we have to remove it from the scrollpane to
     		// make it not visible.
     		setColumnHeaderView(show ? table.getTableHeader() : null);
+    	}
     	/**
     	 * Toggles whether the table's grid lines are visible.  This method
     	 * fires a property change event of type {@link #PROPERTY_SHOW_GRID}.
+    	 *
     	 * @param show Whether grid lines are visible.
     	 */
     	public void setShowGrid(boolean show) {
     		 // There is no "getShowGrid()" method.
     		if (show!=table.getShowHorizontalLines()) {
     			table.setShowGrid(show);
     			firePropertyChange(PROPERTY_SHOW_GRID, !show, show);
+    		}
+    	}
     	/**
     	 * Toggles whether table's row header is visible.
+    	 *
     	 * @param show Whether to show the table row header.
     	 * @see #setShowColumnHeader(boolean)
     	 */
     	public void setShowRowHeader(boolean show) {
     		setRowHeaderView(show ? new HexEditorRowHeader(table) : null);
+    	}
     	/**
     	 * Tries to undo the last action.
+    	 *
     	 * @return Whether there is another action to undo after this one.
     	 * @see #redo()
     	 */
     	public boolean undo() {
     		return table.undo();
+    	}
+    }

     /*
      * Copyright (c) 2008 Robert Futrell
      * All rights reserved.
+     *
      * Redistribution and use in source and binary forms, with or without
      * modification, are permitted provided that the following conditions are met:
      *     * Redistributions of source code must retain the above copyright
      *       notice, this list of conditions and the following disclaimer.
      *     * Redistributions in binary form must reproduce the above copyright
      *       notice, this list of conditions and the following disclaimer in the
      *       documentation and/or other materials provided with the distribution.
      *     * Neither the name "HexEditor" nor the names of its contributors may
      *       be used to endorse or promote products derived from this software
      *       without specific prior written permission.
+     *
      * THIS SOFTWARE IS PROVIDED BY ''AS IS'' AND ANY EXPRESS OR IMPLIED
      * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
      * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO
      * EVENT SHALL THE CONTRIBUTORS TO THIS SOFTWARE BE LIABLE FOR ANY DIRECT,
      * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
      * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
      * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
      * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
      * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
      * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
      */
     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;
     /**
      * Header of the hex table; displays address of the first byte on the
      * row.
+     *
      * @author Robert Futrell
      * @version 1.0
      */
     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

... This diff was truncated because it exceeds the maximum size that can be displayed.

Also available in: Unified diff

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

Revision 2937