Generalized Component Resizing

Question

Hey people,
I wrote a "Component Resizer" which takes care of resizing components. Any component as opposed to just a window or a dialog.
One problem I noticed while resizing dialogs for example was that when I resize the dialog, the internal panes do not get adjust themselves to the new contained size. Now this happens even if I am using say GridBagLayout or GridLayout.
Another problem I noticed is that then a component inside a container is resized, the new size is retained until the parent container for this component itself is resized. Then it goes back to its original size. I guess this is because of the layout manager but then, this happens even when I use null layout. I have posted the code here (it's really long).
Any suggestions?
thanx,
-vijai.
Main resize handler:
* Copyright (c) 2004,
* Vijayaraghavan Kalyanapasupathy
* [email protected]
* See accompanying project license for license terms and agreement.
* The use of the intellectual property contained herein is subject
* to the terms of the license agreement. If no license agreement
* can be found at the locations from where you obtained this
* sofwtare/file/code fragment contact the author for the license.
* Contributors: Vijayaraghavan Kalyanapasupathy
* Created     : 4:03:42 AM, Dec 2, 2004
* Project     : SwingComponents
package org.swingcomponents.components;
import java.awt.Component;
import java.awt.Cursor;
import java.awt.Dimension;
import java.awt.event.MouseAdapter;
import java.awt.event.MouseEvent;
import java.awt.event.MouseListener;
import java.awt.event.MouseMotionListener;
import javax.swing.JComponent;
import org.apache.log4j.Logger;
/**<p>
* A configurable listener which can resize any component that can generate mouse drag and mouse events.
* </p>
* <p>
* General model for this is that <br/>
* <ul>
*  <li> On demand resizing region margin
*  <li> On demand resizing directions modification
* </ul>
* </p>
* @author Vijayaraghavan Kalyanapasupathy
public class ComponentResizer extends    MouseAdapter
                              implements MouseListener,
                                         MouseMotionListener {
     static final int DEFAULT_MARGIN = 8;
      * The sensitivity on the left side within which a mouse drag is interpreted as a resize action.
     static int c_leftmargin   = DEFAULT_MARGIN;
      * The sensitivity on the right side within which a mouse drag is interpreted as a resize action.
     static int c_rightmargin  = DEFAULT_MARGIN;
      * The sensitivity on the top within which a mouse drag is interpreted as a resize action.
     static int c_topmargin    = DEFAULT_MARGIN;
      * The sensitivity on the bottom within which a mouse drag is interpreted as a resize action.
     static int c_bottommargin = DEFAULT_MARGIN;
      * Sets the default margins for all newly generated resizers.
      * @param p_top The new top margin
      * @param p_left The new left side margin
      * @param p_bottom The new bottom margin
      * @param p_right The new right side margin
     public static void setDefaultMargins(int p_top,int p_left,int p_bottom,int p_right) {
          c_logger.debug("Attempting to change application wide margins to: ("+p_top+","+p_left+","+p_bottom+","+p_right+")");
          c_leftmargin   = p_left > 0 ? p_left : c_leftmargin;
          c_rightmargin  = p_right > 0 ? p_right : c_rightmargin;
          c_topmargin    = p_top > 0 ? p_top : c_topmargin;
          c_bottommargin = p_bottom > 0 ? p_bottom : c_bottommargin;
          c_logger.debug("Changed application wide margins to: ("+c_topmargin+","+c_leftmargin+","+c_bottommargin+","+c_rightmargin+")");
      * Retrieves the default application wide left margin used for newly created resizers.
      * @return The default left margin
     public static int getDefaultLeftMargin() {
          return c_leftmargin;
      * Retrieves the default application wide top margin used for newly created resizers.
      * @return The default top margin
     public static int getDefaultTopMargin() {
          return c_topmargin;
      * Retrieves the default application wide right margin used for newly created resizers.
      * @return The default right margin
     public static int getDefaultRightMargin() {
          return c_rightmargin;
      * Retrieves the default application wide bottom margin used for newly created resizers.
      * @return The default bottom margin
     public static int getDefaultBottomMargin() {
          return c_bottommargin;     
      * The standard log4j logger that all instances of this class use
      * to log messages.
     static Logger c_logger = Logger.getLogger(ComponentResizer.class);
     /* The cursors for each direction */
     /** The top resize cursor */
     static final Cursor c_topcursor         = Cursor.getPredefinedCursor(Cursor.N_RESIZE_CURSOR);
     /** The left side resize cursor */
     static final Cursor c_leftcursor        = Cursor.getPredefinedCursor(Cursor.W_RESIZE_CURSOR);
     /** The right side resize cursor */
     static final Cursor c_rightcursor       = Cursor.getPredefinedCursor(Cursor.E_RESIZE_CURSOR);
     /** The bottom resize cursor */
     static final Cursor c_bottomcursor      = Cursor.getPredefinedCursor(Cursor.S_RESIZE_CURSOR);
     /** The topleft resize cursor */
     static final Cursor c_topleftcursor     = Cursor.getPredefinedCursor(Cursor.NW_RESIZE_CURSOR);
     /** The topright resize cursor */
     static final Cursor c_toprightcursor    = Cursor.getPredefinedCursor(Cursor.NE_RESIZE_CURSOR);
     /** The bottomleft resize cursor */
     static final Cursor c_bottomleftcursor  = Cursor.getPredefinedCursor(Cursor.SW_RESIZE_CURSOR);
     /** The bottomright resize cursor */
     static final Cursor c_bottomrightcursor = Cursor.getPredefinedCursor(Cursor.SE_RESIZE_CURSOR);
      * Method that performs initialization stuff.
     protected void InitializeResizer() {
          c_logger.debug("Initializing resizer: ");
          m_leftmargin   = c_leftmargin;
          m_rightmargin  = c_rightmargin;
          m_bottommargin = c_bottommargin;
          m_topmargin    = c_topmargin;
          c_logger.debug("Initialized default margins from application wide settings: ("+m_topmargin+","+m_leftmargin+","+m_bottommargin+","+m_rightmargin+")");
          c_logger.debug("Setting default resize options: ");
          m_allowTopLeftResize    = m_allowTopRightResize    = true;
          m_allowBottomLeftResize = m_allowBottomRightResize = true;
          m_allowLeftResize       = m_allowRightResize       = true;
          m_allowTopResize        = m_allowBottomResize      = true;
          c_logger.debug("Getting component default cursor: ");
          m_componentcursor = m_component.getCursor();
     /** The resizer specific left side margin */
     int m_leftmargin;
     /** The resizer specific top margin */
     int m_topmargin;
     /** The resizer specific right side margin */
     int m_rightmargin;
     /** The resizer specific bottom margin */
     int m_bottommargin;
     /** Indicates that top side resizing should be allowed. */
     boolean m_allowTopResize;
     /** Indicates that bottom side resizing should be allowed. */
     boolean m_allowBottomResize;
     /** Indicates that left side resizing should be allowed. */
     boolean m_allowLeftResize;
     /** Indicates that right side resizing should be allowed. */
     boolean m_allowRightResize;
     /** Indicates that top left resizing should be allowed. */
     boolean m_allowTopLeftResize;
     /** Indicates that top right resizing should be allowed. */
     boolean m_allowTopRightResize;
     /** Indicates that bottom left resizing should be allowed. */
     boolean m_allowBottomLeftResize;
     /** Indicates that bottom right resizing should be allowed. */
     boolean m_allowBottomRightResize;
     /** The component that we are focussing on */
     Component m_component = null;
     /** The layout key for the component */
     String m_layoutkey = null;
      * Creates a new component resizer that attaches itself as a mouse listener and
      * as a mouse motion listener to the given component.
      * @param p_component The component to attach the listener to.
      * @param p_layoutkey The key used in the layout manager of the component's parent for this object.
     public ComponentResizer(Component p_component,String p_layoutkey) {
          super();
          m_component = p_component;
          m_layoutkey = p_layoutkey;
          if(m_component != null) {
               c_logger.debug("Initializing resizer for: "+m_component);
               InitializeResizer();
               m_component.getToolkit().setDynamicLayout(true);
               m_component.addMouseListener(this);
               m_component.addMouseMotionListener(this);
          }else {
               c_logger.warn("Component is null: ");
      * Sets the resizer specific bottom margin.
      * @param p_bottommargin The bottommargin to set.
     public void setBottomMargin(int p_bottommargin) {
          c_logger.debug("Attempting to set top margin to: "+p_bottommargin);
          m_bottommargin = p_bottommargin > 0 ? p_bottommargin : m_bottommargin;
          c_logger.debug("Bottom margin set to: "+m_bottommargin);
      * Sets the resizer specific left side margin.
      * @param p_leftmargin The leftmargin to set.
     public void setLeftMargin(int p_leftmargin) {
          c_logger.debug("Attempting to set left margin to: "+p_leftmargin);
          m_leftmargin = p_leftmargin > 0 ? p_leftmargin : m_leftmargin;
          c_logger.debug("Left margin set to: "+m_leftmargin);
      * Sets the resizer specific right side margin.
      * @param p_rightmargin The rightmargin to set.
     public void setRightMargin(int p_rightmargin) {
          c_logger.debug("Attempting to set right margin to: "+p_rightmargin);
          m_rightmargin = p_rightmargin > 0 ? p_rightmargin : m_rightmargin;
          c_logger.debug("Right margin set to: "+m_rightmargin);
      * Sets the resizer specific top margin.
      * @param p_topmargin The topmargin to set.
     public void setTopMargin(int p_topmargin) {
          c_logger.debug("Attempting to set top margin to: "+p_topmargin);
          m_topmargin = p_topmargin > 0 ? p_topmargin : m_topmargin;
          c_logger.debug("Top margin set to: "+m_topmargin);
      * Returns the bottom margin.
      * @return Returns the bottommargin.
     public int getBottomMargin() {
          return m_bottommargin;
      * Returns the left margin.
      * @return Returns the leftmargin.
     public int getLeftMargin() {
          return m_leftmargin;
      * Returns the right margin.
      * @return Returns the rightmargin.
     public int getRightMargin() {
          return m_rightmargin;
      * Returns the top margin.
      * @return Returns the topmargin.
     public int getTopMargin() {
          return m_topmargin;
      * @return Returns the allowBottomLeftResize.
     public boolean isAllowBottomLeftResize() {
          return m_allowBottomLeftResize;
      * @return Returns the allowBottomResize.
     public boolean isAllowBottomResize() {
          return m_allowBottomResize;
      * @return Returns the allowBottomRightResize.
     public boolean isAllowBottomRightResize() {
          return m_allowBottomRightResize;
      * @return Returns the allowLeftResize.
     public boolean isAllowLeftResize() {
          return m_allowLeftResize;
      * @return Returns the allowRightResize.
     public boolean isAllowRightResize() {
          return m_allowRightResize;
      * @return Returns the allowTopLeftResize.
     public boolean isAllowTopLeftResize() {
          return m_allowTopLeftResize;
      * @return Returns the allowTopResize.
     public boolean isAllowTopResize() {
          return m_allowTopResize;
      * @return Returns the allowTopRightResize.
     public boolean isAllowTopRightResize() {
          return m_allowTopRightResize;
      * @param p_allowBottomLeftResize The allowBottomLeftResize to set.
     public void setAllowBottomLeftResize(boolean p_allowBottomLeftResize) {
          c_logger.debug("Setting bottom left resizing to: "+p_allowBottomLeftResize);
          m_allowBottomLeftResize = p_allowBottomLeftResize;
      * @param p_allowBottomResize The allowBottomResize to set.
     public void setAllowBottomResize(boolean p_allowBottomResize) {
          c_logger.debug("Setting bottom resizing to: "+p_allowBottomResize);
          m_allowBottomResize = p_allowBottomResize;
      * @param p_allowBottomRightResize The allowBottomRightResize to set.
     public void setAllowBottomRightResize(boolean p_allowBottomRightResize) {
          c_logger.debug("Setting bottom right resizing to: "+p_allowBottomRightResize);
          m_allowBottomRightResize = p_allowBottomRightResize;
      * @param p_allowLeftResize The allowLeftResize to set.
     public void setAllowLeftResize(boolean p_allowLeftResize) {
          c_logger.debug("Setting left resizing to: "+p_allowLeftResize);
          m_allowLeftResize = p_allowLeftResize;
      * @param p_allowRightResize The allowRightResize to set.
     public void setAllowRightResize(boolean p_allowRightResize) {
          c_logger.debug("Setting right side resizing to: "+p_allowRightResize);
          m_allowRightResize = p_allowRightResize;
      * @param p_allowTopLeftResize The allowTopLeftResize to set.
     public void setAllowTopLeftResize(boolean p_allowTopLeftResize) {
          c_logger.debug("Setting top left resizing to: "+p_allowTopLeftResize);
          m_allowTopLeftResize = p_allowTopLeftResize;
      * @param p_allowTopResize The allowTopResize to set.
     public void setAllowTopResize(boolean p_allowTopResize) {
          c_logger.debug("Setting top side resizing to: "+p_allowTopResize);
          m_allowTopResize = p_allowTopResize;
      * @param p_allowTopRightResize The allowTopRightResize to set.
     public void setAllowTopRightResize(boolean p_allowTopRightResize) {
          c_logger.debug("Setting top right resizing to: "+p_allowTopRightResize);
          m_allowTopRightResize = p_allowTopRightResize;
      * Following are the methods that do all the real stuff.
     /* We define constants that allow us to determine where the cursor is. */
     static final int TOP         = 0x0001;
     static final int BOTTOM      = 0x0002;
     static final int LEFT        = 0x0100;
     static final int RIGHT       = 0x0200;
     static final int TOPLEFT     = 0x0101;
     static final int TOPRIGHT    = 0x0201;
     static final int BOTTOMLEFT  = 0x0102;
     static final int BOTTOMRIGHT = 0x0202;
     static final int UNKNOWN     = 0x0000;
     protected int whereX(int p_x) {
          // check if on left side
          if(p_x >= 0 &&
             p_x <= m_leftmargin) {
               c_logger.debug("Cursor is on LEFT");
               return LEFT;
          // check if on right side
          if(p_x <= m_component.getWidth() &&
             p_x >= m_component.getWidth()-m_rightmargin) {
               c_logger.debug("Cursor is on RIGHT");
               return RIGHT;
          return UNKNOWN;
     protected int whereY(int p_y) {
          // check if on top side
          if(p_y >= 0 &&
             p_y <= m_topmargin) {
               c_logger.debug("Cursor is on TOP");
               return TOP;
          // check if on bottom side
          if(p_y <= m_component.getHeight() &&
             p_y >= m_component.getHeight()-m_bottommargin) {
               c_logger.debug("Cursor is on BOTTOM");
               return BOTTOM;
          return UNKNOWN;
     protected int where(int p_x,int p_y) {
          c_logger.debug("Determining pointer location: ");
          int l_composite = (whereX(p_x) | whereY(p_y));
          switch(l_composite) {
               case LEFT:
                    c_logger.debug("Left");
                    break;
               case RIGHT:
                    c_logger.debug("Right");
                    break;
               case BOTTOM:
                    c_logger.debug("Bottom");
                    break;
               case TOP:
                    c_logger.debug("Top");
                    break;
               case TOPLEFT:
                    c_logger.debug("Top left");
                    break;
               case TOPRIGHT:
                    c_logger.debug("Top right");
                    break;
               case BOTTOMLEFT:
                    c_logger.debug("Bottom left");
                    break;
               case BOTTOMRIGHT:
                    c_logger.debug("Bottom right");
                    break;
          return l_composite;
      * The component's default cursor.
     Cursor m_componentcursor;
     boolean m_resizingcursor;
     boolean m_dragready;
     protected void changeCursor(int p_where) {
          c_logger.debug("Changing cursor: ");
          m_resizingcursor = true;
          switch(p_where) {
               case LEFT:
                    if(m_allowLeftResize) {
                         m_component.setCursor(c_leftcursor);
                    }else {
                         m_resizingcursor = false;
                    break;
               case RIGHT:
                    if(m_allowRightResize) {
                         m_component.setCursor(c_rightcursor);
                    }else {
                         m_resizingcursor = false;
                    break;
               case TOP:
                    if(m_allowTopResize) {
                         m_component.setCursor(c_topcursor);
                    }else {
                         m_resizingcursor = false;
                    break;
               case BOTTOM:
                    if(m_allowBottomResize) {
                         m_component.setCursor(c_bottomcursor);
                    }else {
                         m_resizingcursor = false;
                    break;
               case TOPLEFT:
                    if(m_allowTopLeftResize) {
                         m_component.setCursor(c_topleftcursor);
                    }else {
                         m_resizingcursor = false;
                    break;
               case TOPRIGHT:
                    if(m_allowTopRightResize) {
                         m_component.setCursor(c_toprightcursor);
                    }else {
                         m_resizingcursor = false;
                    break;
               case BOTTOMLEFT:
                    if(m_allowBottomLeftResize) {
                         m_component.setCursor(c_bottomleftcursor);
                    }else {
                         m_resizingcursor = false;
                    break;
               case BOTTOMRIGHT:
                    if(m_allowBottomRightResize) {
                         m_component.setCursor(c_bottomrightcursor);
                    }else {
                         m_resizingcursor = false;
                    break;
               default:
                    c_logger.debug("Reverting to default component cursor: ");
                    m_resizingcursor = false;
                    m_component.setCursor(m_componentcursor);
                    break;
     protected void modifyBounds(int p_newx,int p_newy,int p_newwidth,int p_newheight) {
          m_component.setBounds(p_newx,p_newy,p_newwidth,p_newheight);
          m_component.setSize(p_newwidth,p_newheight);
          /*if(m_component.getParent() != null) {
               LayoutManager l_manager = m_component.getParent().getLayout();
               if(l_manager != null) {
                    l_manager.removeLayoutComponent(m_component);
                    l_manager.addLayoutComponent(m_layoutkey,m_component);
          if(m_component instanceof JComponent) {
               ((JComponent) m_component).setPreferredSize(new Dimension(p_newwidth,p_newheight));
          m_component.repaint();
     protected void resizeLeft(MouseEvent p_e) {
          c_logger.debug("Resizing left side: ");
          if(p_e.getX() <= m_component.getWidth()-m_leftmargin-m_rightmargin-4) {
               int l_newx = m_component.getX();
               int l_newwidth = m_component.getWidth();
               c_logger.debug("Eligible for leftward resize: ");
               if(p_e.getX() <= 0) {
                    c_logger.debug("Leftward drag: ");
                    l_newx = p_e.getX()+m_component.getX();
                    l_newwidth = m_component.getWidth()-p_e.getX();
               }else {
                    c_logger.debug("anti-Leftward drag: ");
                    l_newx = m_component.getX()-p_e.getX();
                    l_newwidth = m_component.getWidth()-p_e.getX();
               c_logger.debug("Component new X: "+l_newx);
               c_logger.debug("Component new W: "+l_newwidth);
               modifyBounds(l_newx,m_component.getY(),l_newwidth,m_component.getHeight());
     protected void resizeBottom(MouseEvent p_e) {
          c_logger.debug("Resizing bottom side: ");
          if(p_e.getY() >= m_topmargin+m_bottommargin+4) {
               c_logger.debug("Eligible for bottom side resize: ");
               int l_newheight = p_e.getY();
               c_logger.debug("Component new H: "+l_newheight);
               modifyBounds(m_component.getX(),m_component.getY(),m_component.getWidth(),l_newheight);
     protected void resizeRight(MouseEvent p_e) {
          c_logger.debug("Resizing right side: ");
          if(p_e.getX() >= m_leftmargin+m_rightmargin+4) {
               c_logger.debug("Eligible for right side resize: ");
               int l_newwidth = p_e.getX();
               c_logger.debug("Component new W: "+l_newwidth);
               modifyBounds(m_component.getX(),m_component.getY(),l_newwidth,m_component.getHeight());
     protected void resizeTop(MouseEvent p_e) {
          c_logger.debug("Resizing top side: ");
          if(p_e.getY() <= m_component.getHeight()-m_topmargin-m_bottommargin-4) {
               int l_newy = m_component.getY();
               int l_newheight = m_component.getHeight();
               c_logger.debug("Eligible for top side resize: ");
               if(p_e.getY() <= 0) {
                    c_logger.debug("Topward drag: ");
                    l_newy = m_component.getY()+p_e.getY();
                    l_newheight = m_component.getHeight()-p_e.getY();
               }else {
                    c_logger.debug("anti-Topward drag: ");
                    l_newy = m_component.getY()+p_e.getY();
                    l_newheight = m_component.getHeight()-p_e.getY();
               c_logger.debug("Component new Y: "+l_newy);
               c_logger.debug("Component new H: "+l_newheight);
               modifyBounds(m_component.getX(),l_newy,m_component.getWidth(),l_newheight);
     protected void resizeBottomLeft(MouseEvent p_e) {
          c_logger.debug("Resizing southwest...");
          resizeBottom(p_e);
          resizeLeft(p_e);
     protected void resizeBottomRight(MouseEvent p_e) {
          c_logger.debug("Resizing southeast...");
          resizeBottom(p_e);
          resizeRight(p_e);
     protected void resizeTopLeft(MouseEvent p_e) {
          c_logger.debug("Resizing northwest...");
          resizeTop(p_e);
          resizeLeft(p_e);
     protected void resizeTopRight(MouseEvent p_e) {
          c_logger.debug("Resizing northeast...");
          resizeTop(p_e);
          resizeRight(p_e);
     /* (non-Javadoc)
      * @see java.awt.event.MouseMotionListener#mouseDragged(java.awt.event.MouseEvent)
     public void mouseDragged(MouseEvent p_e) {
          c_logger.debug("Dragged at: "+p_e.getX()+","+p_e.getY());
          if(m_resizingcursor) {
               c_logger.debug("Resizing... ");
               switch(m_component.getCursor().getType()) {
                    case Cursor.E_RESIZE_CURSOR:
                         resizeRight(p_e);
                         break;
                    case Cursor.SE_RESIZE_CURSOR:
                         resizeBottomRight(p_e);
                         break;
                    case Cursor.N_RESIZE_CURSOR:
                         resizeTop(p_e);
                         break;
                    case Cursor.NE_RESIZE_CURSOR:
                         resizeTopRight(p_e);
                         break;
                    case Cursor.S_RESIZE_CURSOR:
                         resizeBottom(p_e);
                         break;
                    case Cursor.SW_RESIZE_CURSOR:
                         resizeBottomLeft(p_e);
                         break;
                    case Cursor.NW_RESIZE_CURSOR:
                         resizeTopLeft(p_e);
                         break;
                    case Cursor.W_RESIZE_CURSOR:
                         resizeLeft(p_e);
                         break;
     /* (non-Javadoc)
      * @see java.awt.event.MouseMotionListener#mouseMoved(java.awt.event.MouseEvent)
     public void mouseMoved(MouseEvent p_e) {
          c_logger.debug("Moved at: "+p_e.getX()+","+p_e.getY());
          changeCursor(where(p_e.getX(),p_e.getY()));
     /* (non-Javadoc)
      * @see java.awt.event.MouseListener#mouseClicked(java.awt.event.MouseEvent)
     public void mouseClicked(MouseEvent p_e) {
          c_logger.debug("Clicked at: "+p_e.getX()+","+p_e.getY());
     /* (non-Javadoc)
      * @see java.awt.event.MouseListener#mouseEntered(java.awt.event.MouseEvent)
     public void mouseEntered(MouseEvent p_e) {
          c_logger.debug("Entered at: "+p_e.getX()+","+p_e.getY());
     /* (non-Javadoc)
      * @see java.awt.event.MouseListener#mouseExited(java.awt.event.MouseEvent)
     public void mouseExited(MouseEvent p_e) {
          c_logger.debug("Exited at: "+p_e.getX()+","+p_e.getY());
          if(!m_dragready) {
               changeCursor(UNKNOWN);
     /* (non-Javadoc)
      * @see java.awt.event.MouseListener#mousePressed(java.awt.event.MouseEvent)
     public void mousePressed(MouseEvent p_e) {
          c_logger.debug("Pressed at: "+p_e.getX()+","+p_e.getY());
          if(m_resizingcursor) {
               m_dragready = true;
     /* (non-Javadoc)
      * @see java.awt.event.MouseListener#mouseReleased(java.awt.event.MouseEvent)
     public void mouseReleased(MouseEvent p_e) {
          c_logger.debug("Released at: "+p_e.getX()+","+p_e.getY());
          m_dragready = false;
}Test file:
* Copyright (c) 2004,
* Vijayaraghavan Kalyanapasupathy
* [email protected]
* See accompanying project license for license terms and agreement.
* The use of the intellectual property contained herein is subject
* to the terms of the license agreement. If no license agreement
* can be found at the locations from where you obtained this
* sofwtare/file/code fragment contact the author for the license.
* Contributors: Vijayaraghavan Kalyanapasupathy
* Created     : 4:55:08 AM, Dec 2, 2004
* Project     : SwingComponents
package org.swingcomponents.tests;
import java.awt.Color;
import java.awt.Dimension;
import javax.swing.JDialog;
import javax.swing.JFrame;
import javax.swing.JPanel;
import javax.swing.JTextArea;
import javax.swing.border.LineBorder;
import org.netbeans.lib.awtextra.AbsoluteConstraints;
import org.netbeans.lib.awtextra.AbsoluteLayout;
import org.swingcomponents.components.ComponentResizer;
* @author Vijayaraghavan Kalyanapasupathy
public class TestComponentResizer {
     public static void testUndecoratedDialog() {
          try {
               JDialog.setDefaultLookAndFeelDecorated(false);
               JDialog l_dialog = new JDialog(new JFrame());
               JDialog.setDefaultLookAndFeelDecorated(true);
               l_dialog.setUndecorated(true);
               l_dialog.setLocation(400,500);
               l_dialog.setSize(300,300);
               l_dialog.setVisible(true);
               l_dialog.setDefaultCloseOperation(JDialog.EXIT_ON_CLOSE);
               l_dialog.setBackground(Color.BLACK);
               JPanel l_panel = new JPanel();
               l_panel.setBorder(LineBorder.createGrayLineBorder());
               l_dialog.getContentPane().add(l_panel);
               ComponentResizer l_resizer = new ComponentResizer(l_dialog,null);
               l_dialog.pack();
               l_dialog.show();
          }catch (Throwable t) {
               t.printStackTrace(System.err);
     public static void testJTextArea() {
          try {
               JFrame l_frame = new JFrame("Test DropDownDialog") {
                    public Dimension getPreferredSize() {
                         return new Dimension(800,600);
               JTextArea l_area = new JTextArea(10,40);
               ComponentResizer l_resizer = new ComponentResizer(l_area,null);
               l_frame.getContentPane().setLayout(new AbsoluteLayout());
               l_frame.getContentPane().add(l_area, new AbsoluteConstraints(300,400,300,300));
               l_frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
               l_frame.pack();
               l_frame.show();
          }catch(Throwable t) {
               t.printStackTrace(System.err);
     public static void main(String[] args) {
          testJTextArea();
          //testUndecoratedDialog();
}

Answer 1

Apologies,
I have left out the AbsoluteLayout and AbsoluteConstraints, but the same effect can supposedly be achieved using null layout and absolute positioning. This doesn't work for me, so if you would like those files (from netBeans) I will post them as well.
thanx,
-vijai.