Nested Layout Managers?

[Chris Baty]

Hi guys,
I'm working on a keyboard layout for people with special needs so I created my own lay manager:

  
package com.cripcloud.com;

import java.awt.Point;
import java.lang.Math;

public class HexPoints {
	public Point axRt;
	public Point upRt;
	public Point upLt;
	public Point axLt;
	public Point dnLt;
	public Point dnRt;


	public Point getAxRt() {
		return axRt;
	}


	public void setAxRt(Point axRt) {
		this.axRt = axRt;
	}


	public Point getUpRt() {
		return upRt;
	}


	public void setUpRt(Point upRt) {
		this.upRt = upRt;
	}


	public Point getUpLt() {
		return upLt;
	}


	public void setUpLt(Point upLt) {
		this.upLt = upLt;
	}


	public Point getAxLt() {
		return axLt;
	}


	public void setAxLt(Point axLt) {
		this.axLt = axLt;
	}


	public Point getDnLt() {
		return dnLt;
	}


	public void setDnLt(Point dnLt) {
		this.dnLt = dnLt;
	}


	public Point getDnRt() {
		return dnRt;
	}


	public void setDnRt(Point dnRt) {
		this.dnRt = dnRt;
	}


	public HexPoints() {
		
	}
	
	
	public  HexPoints(Point center, int s) {
		axRt = new Point((int)center.x + s, center.y);
		upRt = new Point((int)(center.x + s / 2), (int)(center.y - s * Math.sqrt(3) / 2));
		upLt = new Point((int)(center.x - s / 2), (int)(center.y - s * Math.sqrt(3) /  2));
		axLt = new Point(center.x - s, center.y);
		dnRt = new Point((int)(center.x + s / 2), (int)(center.y + s * Math.sqrt(3) / 2));
		dnLt = new Point((int)(center.x - s / 2), (int)(center.y + s * Math.sqrt(3) / 2));
	}

	public int getHeight(int s) {
		return (int) (s * Math.sqrt(3));
	}
	public int getWidth(int s) {
		return s * 2;
	}

}

  

This Works.

    
import java.awt.Color; 
import java.awt.Component;
import java.awt.Container; 
import java.awt.Dimension; 
import java.awt.Font;
import java.awt.FontMetrics;
import java.awt.Graphics; 
import java.awt.Point;
import java.awt.Polygon;
import javax.swing.JButton; 

  /*  This class draws a perfect hexagon shaped button.  
   *  different colors are added for rollover function.
   *  Buttons are intended for a virtual keyboard.
   */

public class HexButton extends JButton {
	private static final long serialVersionUID = 1L; 
	private Color outerColor = Color.gray; 
	private Color defaultColor = Color.gray; 
	private Color innerColor = Color.yellow; 
	private Color textColor = Color.BLACK; 
	boolean gotFontSize = false;
	int fontSize = 12;
	private int side = 20;
	//  Buttons are intended for a virtual keyboard
	//  so only one char per key.
	private char key;
	private String title;
	private int xFontOffset;
	private int yFontOffset;

	public int getSide() {
		return side;
	}

	public void setSide(int si) {
		side = si;
	}

	public HexButton(char label) { 
		 key = label; 
		 title = ""+label; 
	} 
	public HexButton() { 
	} 
	
	//@Override 
    protected void paintComponent(Graphics g) { 
        Dimension originalSize = getPreferredSize();  
        int x = originalSize.width;
        side = x / 2;
        int y = (int) ( side * Math.sqrt(3)); 
        originalSize.setSize(new Dimension(x,y));

        //  Form outer shape
        HexPoints hp = new HexPoints(new Point(x/2,y/2),side);
    	Polygon thisHex = new Polygon();
        thisHex.addPoint(hp.getAxRt().x,hp.getAxRt().y);
        thisHex.addPoint(hp.getUpRt().x,hp.getUpRt().y);
        thisHex.addPoint(hp.getUpLt().x,hp.getUpLt().y);
        thisHex.addPoint(hp.getAxLt().x,hp.getAxLt().y);
        thisHex.addPoint(hp.getDnLt().x,hp.getDnLt().y);
        thisHex.addPoint(hp.getDnRt().x,hp.getDnRt().y);
        g.setColor(outerColor); 
        g.drawPolygon(thisHex); 
        g.fillPolygon(thisHex);

        //  Form outer shape
    	hp  = new HexPoints(new Point(x/2,y/2),side-4);
    	thisHex.addPoint(hp.getAxRt().x,hp.getAxRt().y);
        thisHex.addPoint(hp.getUpRt().x,hp.getUpRt().y);
        thisHex.addPoint(hp.getUpLt().x,hp.getUpLt().y);
        thisHex.addPoint(hp.getAxLt().x,hp.getAxLt().y);
        thisHex.addPoint(hp.getDnLt().x,hp.getDnLt().y);
        thisHex.addPoint(hp.getDnRt().x,hp.getDnRt().y);
        g.setColor(innerColor); 
        g.drawPolygon(thisHex); 
        g.fillPolygon(thisHex);

        //  Size font to key
        g.setColor(textColor); 
    	Font f = new Font("Dialog", Font.BOLD, fontSize);
    	FontMetrics fm = g.getFontMetrics(f);
        if ( !gotFontSize ) {
        	while ( fm.getHeight() <= (x * .75) ){
            	f = new Font("Dialog", Font.BOLD, fontSize++);
            	fm = g.getFontMetrics(f);
        	}
        	gotFontSize = true;
        	xFontOffset = x/2 - side/2;
        	yFontOffset = y/2 + side/2;
        }
        g.setFont(f);
        g.drawString(""+key, xFontOffset, yFontOffset);
    } 

	//@Override 
    public Dimension getPreferredSize() { 
		// Dimension encloses hexagon
    	return new Dimension( 2 * side, (int) (side * Math.sqrt(3)));
    }

	public char getKey() {
		// TODO Auto-generated method stub
		return key;
	}

	public String getString() {
		// TODO Auto-generated method stub
		return title;
	}

	public void setOuterColor(Color change) {
		this.outerColor =  change;
	} 

}

This works okay on macs especially. Here's my layoutmanager:

   
import java.awt.Component;
import java.awt.Container;
import java.awt.Point;
import java.awt.Dimension;
import java.awt.LayoutManager2;
import java.awt.Rectangle;
import java.util.ArrayList;

/*  This layout manager arranges hexagonally-shaped buttons into
 *  a honeycomb-like configuration.  The buttons are placed the 
 *  keyboard from the center out, using quasi-radial coordinates.
 *  So key(0,0) would be the center and key(2,3) would be the
 *  forth key in the third radius, 0 being the key closest
 *  to 3 o'clock.
 */


public class HoneycombLayout implements LayoutManager2 {
	//  Length of hexagon side
	public int side = 10;
    public static ArrayList<Point> keys;
	public static Point center;
    private static int maxR = 12;
	private int preferredWidth = 2 * side, preferredHeight = (int) (side * Math.sqrt(3));

	public HoneycombLayout() {
	}
    
	  // Find nexxt key available
    public Point findKey(){
    	for ( int i=0; i<=maxR; i++)
    		for ( int j=0; j<6*i; j++)
    			if ( gotKey(i,j) )
    				continue;
    			else
    				return new Point(i,j);
		return null;
    }

    // Is key already being used
    public boolean gotKey(int r, int ang) {
    	if ( keys != null )
		    for ( int i=1; i<keys.size(); i++)
		    	if (keys.get(i).equals(new Point(r,ang)) )
					return true;
   		return false;
   }

    /* Required by LayoutManager. */
    public void addLayoutComponent(Component comp, int radius, int angle) {
//    	int n = keys.size()+1;

	    Dimension compPS = null;
	    if ( !gotKey(radius,angle)) {
			Point thisPoint = new Point(radius,angle);    	
			int x;
			int y;
		    compPS = comp.getPreferredSize();
		    x = thisPoint.x;
		    y = thisPoint.y;
		    int w = compPS.width;
		    int h = compPS.height;
		    comp.setBounds(x, y, w, h);
	    }
    }

    // removes key from arraylist
     private void delKey(Point thisPoint) {
     	for ( int i=1; i<keys.size(); i++)
     		if ( keys.get(i).equals(thisPoint) )
     			keys.remove(i);
 	}

    @SuppressWarnings("null")
	public Point findComponent(Component comp, Rectangle rIn) {
	    Dimension compPS = null;
	    Component testC = null;
	    Point testP;
		int x;
		int y;

		System.out.println("rIn is " + rIn );
		System.out.println("comp is " + comp.getX() );
	    compPS = comp.getPreferredSize();
	    int w = compPS.width;
	    int h = compPS.height;
    	
    	for ( int i=0; i<maxR; i++)
    		for ( int j=0; j<i*6; j++){
    			testP = getPoint(center,i,j);
			    x = testP.x;
			    y = testP.y;
			    testC.setBounds(x, y, w, h);
    			if ( rIn.equals(testC.getBounds()) ) 
    				return testP;    	
    		}
    	return null;
    }

    /* Required by LayoutManager. */
    public void addLayoutComponent(String name, Component comp) {
	    Dimension compPS = null;
    	Point thisPoint = findKey();    	
    	int x;
    	int y;
        compPS = comp.getPreferredSize();
        x = thisPoint.x;
        y = thisPoint.y;
        int w = compPS.width;
        int h = compPS.height;
        comp.setBounds(x, y, w, h);
    }

    /* Required by LayoutManager. */
    public void removeLayoutComponent(Component comp) {
	    Point pIn = new Point(comp.getBounds().x, comp.getBounds().y);
	    //Point thisPoint = findComponent(comp,rIn);    	
	    delKey(pIn);
        comp.repaint();
	    //comp.setBounds(0, 0, 0, 0);
    }

	public int getSide() {
		return side;
	}

	//  Can't reset set without resetting length and width
    public void setSide(int side) {
		this.side = side;
	    preferredWidth = 2 * side;
	    preferredHeight = (int) (side * Math.sqrt(3));
	}

	/* Required by LayoutManager. */
	public Dimension preferredLayoutSize(Container target) {
		return target.getSize();
	}

    /**
     * Returns minimum size based on side length
     */
    public Dimension minimumLayoutSize(Container target) {
      return new Dimension(this.preferredWidth,this.preferredHeight);
    }
    
    public void layoutContainer(Container parent) {
    	center = new Point((int)parent.getWidth()/2,(int)parent.getHeight()/2);
    	keys = new ArrayList<Point>();
    	Point thisPoint;
    	int x, y, w, h;
    	int n = parent.getComponentCount();

	    Component comp = null;
	    Dimension compPS = null;
	    if (n == 1) {
	      comp = parent.getComponent(0);
	      x = center.x;
	      y = center.y;

	      compPS = comp.getPreferredSize();
	      w = compPS.width;
	      h = compPS.height;
	      comp.setBounds(x, y, w, h);
	    } else {
	    	int ang = 0;
	    	int angLimit = 0;
	    	int rad = 0;
	    	for (int i = 0; i < n; i++) {
    	        comp = parent.getComponent(i);
    	        compPS = comp.getPreferredSize();
    	        if ( rad == 0 ) {
	    	        thisPoint = new Point((int) center.getX(), center.y);
    	        	rad = 1;
    	        	ang = 0;
    	        	angLimit = 6;
    	        } else if ( (ang+1) == angLimit ) {
		    	   thisPoint = getPoint(center, rad, ang);
	    	       ang = 0;
	    	       rad++;
	    	       angLimit = rad * 6;
    	        } else {
    	        	thisPoint = getPoint(center, rad, ang);
    	        	ang++;
    	        } // end if
    	        keys.add(thisPoint);
    	        x = thisPoint.x;
    	        y = thisPoint.y;
    	        w = compPS.width;
    	        h = compPS.height;
    	        comp.setBounds(x, y, w, h);
	    	} // for
	    }
    }
    
    /*
     *   This method determines the exact location of the center of
     *   a key, based on radius and quasi-angle.  It calculates the 
     *   point closest to 3 o'clock and marches around the hexagon
     *   until it ends on the angIn and returns that point.
     */
    public Point getPoint(Point center, int radius, int angIn) {
    	Point thePt;
    	int start = radius / 2;
    	int slice = radius * 6; 
    	
    	if ( radius == 0 )  // radius is 0
    		thePt = new Point(center.x, center.y);
    	else if ( (radius % 2) == 0) {  //  Even radius
    		thePt = new Point((center.x + (radius-1 )*3*side), center.y);
    		if (angIn == 0)
    			return thePt;
    	} else { // Odd radius
    		thePt = new Point((int)(center.x+radius*3*side/2), (int)(center.y - side * Math.sqrt(3)/2));
    		if (angIn == 0)
    			return thePt;
    	}
    	//printPoint("thePt in is ", thePt);
		int turn1 = start;
		int turn2 = turn1 + radius;
		int turn3 = turn2 + radius;
		int turn4 = turn3 + radius;
		int turn5 = turn4 + radius;
		int turn6 = turn5 + radius;
    	
		for (int i = 1; i <= angIn; i++){
			if ( i <= turn1)
				thePt.setLocation(thePt.x, (int)(thePt.y-Math.sqrt(3)*side));
			else if ( ( i > turn1) && ( i <= turn2) )
				thePt.setLocation(thePt.x-3*side/2 , (int)(thePt.y-Math.sqrt(3)*side/2));
			else if ( ( i > turn2) && ( i <= turn3) )
				thePt.setLocation(thePt.x-3*side/2 , (int)(thePt.y+Math.sqrt(3)*side/2));
			else if ( ( i > turn3) && ( i <= turn4) )
				thePt.setLocation(thePt.x , (int)(thePt.y+Math.sqrt(3)*side));
			else if ( ( i > turn4) && ( i <= turn5) )
				thePt.setLocation(thePt.x+3*side/2 , (int)(thePt.y+Math.sqrt(3)*side/2));
			else if ( ( i > turn5) && ( i <= turn6) )
				thePt.setLocation(thePt.x+3*side/2 , (int)(thePt.y-Math.sqrt(3)*side/2));
			else if ( ( i > turn6) && ( i <= slice) )
				thePt.setLocation(thePt.x , (int)(thePt.y-Math.sqrt(3)*side));
		}
    	//printPoint("thePt out is ", thePt);
		return thePt;
    }
    
    private void printPoint(String s, Point p){
    	System.out.println(s + "Point is x="+p.x+", y="+p.y);
    }

    /**
     * Returns a String representation of this CircleLayout.
     * 
     * @return A String that represents this CircleLayout
     */
    public String toString() {
      return this.getClass().getName();
    }

	@Override
	public void addLayoutComponent(Component arg0, Object arg1) {
		// TODO Auto-generated method stub
		
	}

	@Override
	public float getLayoutAlignmentX(Container arg0) {
		// TODO Auto-generated method stub
		return 0;
	}

	@Override
	public float getLayoutAlignmentY(Container arg0) {
		// TODO Auto-generated method stub
		return 0;
	}

	@Override
	public void invalidateLayout(Container arg0) {
		// TODO Auto-generated method stub
		
	}

	@Override
	public Dimension maximumLayoutSize(Container arg0) {
		// TODO Auto-generated method stub
		return null;
	}
}

 

This has issues but works. Here's my tester:

   
import java.awt.Color;
import java.awt.GridBagConstraints;
import java.awt.GridBagLayout;
import java.awt.GridLayout;
import java.awt.event.MouseEvent;
import java.awt.event.MouseListener;
import java.io.BufferedInputStream;
import java.io.DataInputStream;
import java.io.File;
import java.io.FileInputStream;
import java.util.ArrayList;
import java.util.Collections;

import javax.swing.JFrame;
import javax.swing.JPanel;
import javax.swing.JTextArea;
public class KeyTest2 extends JFrame {

	JPanel keyboard;
	JTextArea text;
	private static char predecessor;
	private static String bigString = "";
	GridBagConstraints manCons, cons;


	public static char[] keys = {'A','B','C','D','E',' ','F','G','H','I','J','K','L','M','N','O','P','Q','R','S','T','U','V','W','X','Y','Z', '1', '2', '3','4','5','6','7','8','9','0', '/',',','.',';','c','/','`','t','r',(char)24};
	private static HoneycombLayout hl = new HoneycombLayout();
	private static ChPar[] myChars = new ChPar[keys.length];
	private static boolean gotFollower = false;
	static ChPar[][] cFollowers = new ChPar[keys.length][keys.length]; 
	public static char[] newKeys = new char[keys.length];

	public KeyTest2() {
		super("test");

	    //setLayout(new GridLayout(2,0));
		GridBagLayout mainGB = new GridBagLayout();
		manCons = new GridBagConstraints();
		setLayout(mainGB);
	    text = new JTextArea(20,80);
		buildGridBagConstraints(manCons, 0, 0, 1, 1, 100, 30);
		manCons.fill = GridBagConstraints.CENTER;
		mainGB.setConstraints(text, manCons);
	    add(text);
	    keyboard = new JPanel(hl);
		hl.setSide(40);
		char key;
		for (int i=0; i<newKeys.length; i++){
			final HexButton hb = new HexButton(newKeys[i]);
			hb.setSide(39);
			hb.addMouseListener(new MouseAction());
			hl.addLayoutComponent(hb,i,0);
			keyboard.add(hb);
		}

		buildGridBagConstraints(manCons, 0, 1, 1, 1, 0, 70);
		manCons.fill = GridBagConstraints.CENTER;
		mainGB.setConstraints(keyboard, manCons);
		add(keyboard);
	}


	public void buildGridBagConstraints(GridBagConstraints myGBC, int gx, int gy, int gw, int gh, int wx, int wy) {
		manCons.gridx = gx;
		manCons.gridy = gy;
		manCons.gridwidth = gw;
		manCons.gridheight = gh;
		manCons.weightx = wx;
		manCons.weighty = wy;
	}
	public  void redrawKeys() {

		hl.setSide(40);
		char key;
		for (int i=0; i<newKeys.length; i++){
			final HexButton hb = new HexButton(newKeys[i]);
			hb.setSide(39);
			hb.addMouseListener(new MouseAction());
			hl.addLayoutComponent(hb,i,0);
			keyboard.add(hb);
		}	
	}


	public static int matchKey(char[] kys, char cIn){
		for (int i=0; i<kys.length; i++) {
			if ( kys[i]  == cIn)
				return i;
		}
		return -1;
	}


	public static void loadKeys(){
		ArrayList<ChPar> chArray = new ArrayList<ChPar>();
		for ( int i=1; i<myChars.length; i++ )
			if ( myChars[i].cIn != 0)
				chArray.add(myChars[i]);

		char[] myKeys = keys;
		for (int i=0; i<keys.length; i++) 
			myKeys[i] = keys[i];
		
	/*	System.out.println("Mykeys in:");
		for (int j=0; j<myKeys.length; j++)
			System.out.print("myKey[ " + j + "] = " + myKeys[j] + "; ");
		System.out.println();*/

		Collections.sort(chArray);
		
		char dumy = '%';
		int spot = -1;
		for (int i=1; i<chArray.size(); i++) {
			//for (int i=0; i<=fq.size()-1; i++) {
			try {
				dumy = chArray.get(i).getcIn();
				spot = matchKey(myKeys,dumy);
				myKeys[spot] = myKeys[i]; 
				myKeys[i] = dumy;
				spot = i;
			} catch (Exception e){
			}
			for (int j=0; j<myKeys.length; j++)
				newKeys[j] = myKeys[j];				

		}
	}

	public static void loadFollowerKeys(char c){
		int pk = charInKey(c);
		System.out.println("pk = " + pk + " or etter " + keys[pk]);
		System.out.println("cFollowers[] len = " + cFollowers[pk].length);
		ArrayList<ChPar> chArray = new ArrayList<ChPar>();
		for ( int i=0; i<cFollowers[pk].length; i++ )
			if ( cFollowers[pk][i].ct != 0 ) 
				chArray.add(cFollowers[pk][i]);
		char[] myKeys = keys;
		System.out.println("Old newKeys:");
		for (int i=0; i<keys.length; i++) {
			myKeys[i] = keys[i];
			System.out.print("newKeys["+ i + "] = " + newKeys[i] + "; ");
		}
		System.out.println();

		Collections.sort(chArray);
		
		char dumy = '%';
		int spot = -1;
		for (int i=1; i<chArray.size(); i++) {
			//for (int i=0; i<=fq.size()-1; i++) {
			try {
				dumy = chArray.get(i).getcIn();
				spot = matchKey(myKeys,dumy);
				myKeys[spot] = myKeys[i-1]; 
				myKeys[i-1] = dumy;
				spot = i;
			} catch (Exception e){
			}
		}
		System.out.println("New newKeys:");
		for (int j=0; j<myKeys.length; j++){
			newKeys[j] = myKeys[j];	
			System.out.print("newKeys["+ j + "] = " + newKeys[j] + "; ");
		}
		System.out.println();			
	}

	public static void readFile(){
		String lIn;
		
		//File fIn = new File("/Users/batymahn/Documents/workspace/KeyboardApplet/src/test.rtf");
		//File fIn = new File("/Users/batymahn/Documents/workspace/KeyboardApplet/src/tese.txt");
		//File fIn = new File("C:/Users/batymahn/Documents/test.txt");
		File fIn = new File("/Users/batymahn/Documents/workspace/KeyboardApplet/bin/test.rtf");
		FileInputStream fSt = null;
		BufferedInputStream bISt = null;
		DataInputStream dISt = null;
		System.out.println("look in " + fIn.getPath());
		
		try {
			fSt = new FileInputStream(fIn);
			bISt = new BufferedInputStream(fSt);
			dISt = new DataInputStream(bISt);
			//fSt.getFD()
				
			while ( dISt.available() != 0 ) {
				lIn = dISt.readLine();
				bigString += lIn;
//				System.out.println(lIn);
			}
			dISt.close();
			bISt.close();
			fSt.close();
		} catch (Exception e) {
			System.out.println("file not found..");
			System.out.println(e.toString());
			
		}
	}

	private static void loadChALs() {
		for ( int i=0; i<keys.length; i++) {
			myChars[i] = new ChPar(keys[i]);
			for ( int j=0; j<keys.length; j++ )
				cFollowers[i][j] = new ChPar(keys[j]);
		}
		
	}

	public static int charInKey(char c){
			for ( int i=0; i<keys.length; i++ )
				if ( keys[i] == c)
					return i;
		return -1;
	}
	

	public static boolean charInArray(char c){
		try {
			for ( int i=1; i<myChars.length; i++ )
				if ( myChars[i].cIn == c)
				return true;
		} catch(Exception e){
			System.out.println(e.toString());			
		}
		return false;
	}
	
	public static void addCharCt(char c){
		for ( int i=1; i<myChars.length; i++ )
			if ( myChars[i].cIn == c){
				myChars[i].increment();
				break;
			}
	}
	
	public static void addChar(char c){
		if ( charInArray(c) )
			addCharCt(c);
	}		
	
	public static boolean isChar(char c){
		for ( int i=0; i<keys.length; i++ )
			if ( keys[i] == c) 
				return true;
		return false;
	}
	
	public static void incremFollowers(int chos, char c){
		int folC = charInKey(c);
		if (  (cFollowers[chos][folC] != null) ) {
			if  (cFollowers[chos][folC].getcIn() == c   ) {
				cFollowers[chos][folC].increment();
			}
		} else
			System.out.println("cFollowers is null"  );
			
	}
	
	public static boolean isInFollower(int pred, char c){
		int folC = charInKey(c);
		if ( cFollowers[pred][folC] == null )
			return false;
		else if ( cFollowers[pred][folC].getcIn() == c )
			return true;
		else 
			return false;

	}
	
	public static void addFollower( char c){

		for (int i=0; i<keys.length; i++)
			if ( keys[i] == predecessor ){
				if ( isInFollower(i,c) ){
					int tc = charInKey(c);
					incremFollowers(i,c);
					break;
				} 
			}
	}


	
	public static void process(){
		System.out.println("String has  " + bigString.length());
		for (int i=0; i<bigString.length(); i++){
			char c = Character.toUpperCase(bigString.charAt(i));
			if ( isChar(c) ) {
				addChar(c);			// do character statistics
				if ( gotFollower)	// do follower statistics
					addFollower(c);
				gotFollower = true;
				predecessor = c;
			} else {
				gotFollower = false;
				predecessor = '~';
			}
		}
	}

	public static void main(String[] args){

		// Load character counting statistics.

		loadChALs();
		readFile();
		process();
		loadKeys();
		KeyTest2 eg = new KeyTest2();
		eg.setVisible(true);
		eg.setSize(1000, 800);
		eg.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
	}
	
	
	class MouseAction implements MouseListener {
		
		@Override				
		public void mouseClicked(MouseEvent e) {
			HexButton myBtn = (HexButton)e.getComponent();
			System.out.println("Button "+myBtn.getKey()+" clicked");
			char cIn = myBtn.getKey();
			text.setText(text.getText() + cIn);
			keyboard.removeAll();
			loadFollowerKeys(cIn);
			redrawKeys();
			//repaint();
		
		}

		@Override
		public void mouseEntered(MouseEvent e) {
			HexButton myBtn = (HexButton)e.getComponent();
			myBtn.setOuterColor(Color.GREEN);
			myBtn.paintComponent(myBtn.getGraphics());
		}

		@Override
		public void mouseExited(MouseEvent e) {
			HexButton myBtn = (HexButton)e.getComponent();
			myBtn.setOuterColor(Color.GRAY);
			myBtn.repaint();
		}

		@Override
		public void mousePressed(MouseEvent e) {
			// TODO Auto-generated method stub
			
		}

		@Override
		public void mouseReleased(MouseEvent e) {
			// TODO Auto-generated method stub
			
		}
	}
}

 

The challenge is that my layoutmanager seems to screw-up the gridbaglayout so I can't control the exact size and placement of the keyboard. I've tried the gridlayout but it clips the top and bottom keys. Any ideas would be welcome.
Chris

[Alan Mehio]

Chris,
I did not get the time to look at it; however, I am posting this response in order to make it on top.


Cheers
Alan