Problem when repainting rectangles

[Mathias Nilsson]

Hi!

I want a user to draw rectangles in a Indesign fashion. Yoy should be able to resize and so on. The problem is that when I drag the mouse real fast the rectangle moves to a position that is not correct

If someone could look at this code. If you press the 1 button you can
select rectangles and move them. If you press the 2 button you can drag rectangles. Please try and drag them fast and you will see them jump around.

I use the technique that if the offset Point. ( The first point on the mouse ) i less than the mouse coordinate in the drag then the x , y of the rectangle becomes the drag mouse coordinate. I think the problem lies here but I don't know why and what I'm doing wrong. Here is my code. It is under process so It is not built with speed in mind. If you have another approach to my problem then please tell me.

 
import javax.swing.*;
import java.awt.*;
import java.awt.geom.*;
import java.awt.event.*;
import java.util.*;
 
public class Tester extends JFrame{

public static int ACTION = 1;
public static int EDGE_POSITION = -1;
 
public Tester(){

this.getContentPane().setLayout( new BorderLayout() );
this.getContentPane().add( new Rects(), BorderLayout.EAST );



JPanel panel = new JPanel();
panel.setPreferredSize( new Dimension( 150 , 400 ) );

JButton b1 = new JButton( "1" );
JButton b2 = new JButton( "2" );

b1.addActionListener(
new ActionListener(){
public void actionPerformed( ActionEvent e ){
ACTION = 1;
}
}
);

b2.addActionListener(
new ActionListener(){
public void actionPerformed( ActionEvent e ){
ACTION = 2;
}
}
);

panel.add( b1 );
panel.add( b2 );
this.getContentPane().add( panel, BorderLayout.WEST );

this.setDefaultCloseOperation( JFrame.EXIT_ON_CLOSE );
this.setSize( new Dimension(400 , 400 ) ) ;
this.setVisible( true );


}

class Block{

private int MAX_EDGES = 9;
private int EDGE_WIDTH = 6;
private int EDGE_HEIGHT = 6;
private int EDGE_SPACE = 3;
private boolean isSelector = false;
private Rectangle rect;
private Vector edges;
private boolean m_IsActive = false;

Block( Rectangle rect ){
this( rect, false );
}

Block( Rectangle rect, boolean selector ){
this.rect = rect;
this.isSelector = selector;
}

public boolean isActive(){
return this.m_IsActive;
}

public void setActive( boolean state ){

if( this.isSelector ){
state = false;
}


if( state ){

edges = new Vector( MAX_EDGES );
for( int i = 0; i < MAX_EDGES; i++ ){
edges.add( new Rectangle() );
}

}else{
if( edges != null ){
edges.clear();
}
edges = null;
}

this.m_IsActive = state;
}

public Rectangle getRectangle(){
return this.rect;
}

public boolean isSelector(){
return this.isSelector;
}

public Vector getEdges(){
return this.edges;
}
 
public void updateEdgeBounds(){
if( this.isActive() ){
double height = this.rect.getHeight();
double width = this.rect.getWidth();
double x = this.rect.getX();
double y = this.rect.getY();

for( int i = 0; i < edges.size(); i++ ){
Rectangle edge = ( Rectangle ) edges.elementAt( i );

switch( i ){
case 0: // Upper left
edge.setRect( x - EDGE_SPACE, y - EDGE_SPACE, EDGE_WIDTH , EDGE_HEIGHT );
break;
case 1: // Upper middle
edge.setRect( ( int ) ( x - EDGE_SPACE + ( width / 2 ) ), ( int )( y - EDGE_SPACE ), EDGE_WIDTH , EDGE_HEIGHT );
break;
case 2: // Upper right
edge.setRect( ( int ) ( x + width - EDGE_SPACE ),( int ) ( y - EDGE_SPACE ), EDGE_WIDTH , EDGE_HEIGHT );
break;
case 3: // Middle left
edge.setRect( ( int ) ( x - EDGE_SPACE ),( int ) ( y - EDGE_SPACE + height / 2  ), EDGE_WIDTH , EDGE_HEIGHT );
break;
case 4: // bottom Left
edge.setRect( ( int ) ( x - EDGE_SPACE ),( int ) ( y + height - EDGE_SPACE  ), EDGE_WIDTH , EDGE_HEIGHT );
break;
case 5: // bottom middle
edge.setRect( ( int ) ( x - EDGE_SPACE +(  width / 2 ) ),( int ) ( y + height - EDGE_SPACE  ), EDGE_WIDTH , EDGE_HEIGHT );
break;
case 6: // bottom right
edge.setRect( ( int ) ( x + width - EDGE_SPACE ),( int ) ( y + height - EDGE_SPACE  ), EDGE_WIDTH , EDGE_HEIGHT );
break;
case 7: // Middle right
edge.setRect( ( int ) ( x + width - EDGE_SPACE ),( int ) ( y - EDGE_SPACE + height / 2  ), EDGE_WIDTH , EDGE_HEIGHT );
break;
case 8: // Middle
edge.setRect( ( int ) ( x - 2 + ( width / 2 ) ),( int ) ( y - 2 + ( height / 2 )  ), 4 , 4 );
break;
}
}
}
}

public void setBlockBounds( Point offset, Point point ){
  
double height = 0;
double width = 0;
double x = this.rect.getX();
double y = this.rect.getY();

if( point.getY() < offset.getY() ){
y = point.getY();

height = offset.getY() - point.getY();
}else{
height = point.getY() - offset.getY();
}

if( point.getX() < offset.getX() ){
x = point.getX();

width = offset.getX() - point.getX();
}else{
width = point.getX() - offset.getX();
}



this.rect.setRect( x , y , width , height );
this.updateEdgeBounds();
 }
}

class Rects extends JPanel
implements MouseListener, MouseMotionListener, KeyListener {

boolean pressedEvent = false;
boolean moveBlockEvent = false;
private Block dragRect;
private Vector rects;
private Point  offsetPoint;
final  float dash1[] = { 2.0f };
  final  BasicStroke dashed = new BasicStroke(1.0f,BasicStroke.CAP_BUTT, BasicStroke.JOIN_MITER, 10.0f, dash1, 0.0f);
  final  BasicStroke normal = new BasicStroke(1);
 
  
  

 Rects() {
 setPreferredSize( new Dimension( 250 , 400  ) );
         setBackground(Color.white);
         addMouseListener(this);
         addMouseMotionListener(this);
         rects = new Vector();
addKeyListener( this );
      }

public void paintComponent( Graphics g ){

super.paintComponent( g );
Graphics2D g2 = (Graphics2D)g;

for( int i = 0; i < rects.size(); i++ ){
g2.setStroke( normal );

g2.setColor( new Color( 79, 153, 255 ) );
Block block = ( Block ) rects.elementAt( i );

if( block.isSelector() ){
g2.setColor( new Color( 0 , 0 , 0 ) );
g2.setStroke( dashed );
}


g2.draw( block.getRectangle() );

if( block.isActive() ){
Vector a = block.getEdges();
for( int j = 0; j < a.size(); j++ ){
Rectangle rect = ( Rectangle ) a.elementAt( j );
g2.setColor( new Color( 79, 153, 255 ) );
g2.draw( rect );

if( j != 8 ){
g2.setColor( Color.WHITE );
g2.fillRect(rect.x + 1, rect.y + 1, rect.width - 1, rect.height - 1);
}else{

g2.fillRect(rect.x + 1, rect.y + 1, rect.width - 1, rect.height - 1);
}
}
}

 
}


g2.dispose();



}

public void mousePressed(MouseEvent evt) { 

System.out.println( "pressed : " + EDGE_POSITION + "\n" );

if( EDGE_POSITION != -1 ){
moveBlockEvent = true;
}
if( pressedEvent )
return;

pressedEvent = true;
mouseClickEvent( evt );
      } // end mousePressed()
 
      public void mouseReleased(MouseEvent evt) {
 
Point p = evt.getPoint();

if( offsetPoint.getX() == p.getX() && offsetPoint.getY() == p.getY() ){

}else{

if( ACTION == 2 ){
Block b = new Block( new Rectangle( offsetPoint ) );
b.setActive( true );
b.setBlockBounds( offsetPoint, p );

rects.add( b );
}else{

if( moveBlockEvent ){

Block block = new Block( new Rectangle( 
( int )dragRect.getRectangle().getX(),
( int )dragRect.getRectangle().getY(),
( int )dragRect.getRectangle().getWidth(),
( int )dragRect.getRectangle().getHeight()
) );
block.setActive( true );
block.updateEdgeBounds();
rects.add( block );


}else{

for( int i = 0; i < rects.size(); i++ ){
Block block = ( Block ) rects.elementAt( i );

if( dragRect.getRectangle().intersects( block.getRectangle() ) ){
block.setActive( true );
block.updateEdgeBounds();
}else{
block.setActive( false );
block.updateEdgeBounds();
}


}


}
}
}

moveBlockEvent = false;
pressedEvent = false;
EDGE_POSITION = -1;
rects.remove( dragRect );
dragRect = null;
p = null;
offsetPoint = null;
repaint();
 
      }
  
  public void mouseClickEvent( MouseEvent evt ){
  
  
  offsetPoint = evt.getPoint();
if( dragRect != null && moveBlockEvent ){

offsetPoint = null;
switch( EDGE_POSITION ){
case 0:
offsetPoint = new Point( ( int )( dragRect.getRectangle().getX() + dragRect.getRectangle().getWidth() ), ( int ) ( dragRect.getRectangle().getY() + dragRect.getRectangle().getHeight() ) );
break;
case 1:
offsetPoint = new Point( ( int )( dragRect.getRectangle().getX() ), ( int ) ( dragRect.getRectangle().getY() + dragRect.getRectangle().getHeight() ) );
break;
case 2:
offsetPoint = new Point( ( int )( dragRect.getRectangle().getX() ), ( int ) ( dragRect.getRectangle().getY() + dragRect.getRectangle().getHeight() ) );
break;
case 3:
offsetPoint = new Point( ( int )( dragRect.getRectangle().getX() + + dragRect.getRectangle().getWidth()  ), ( int ) ( dragRect.getRectangle().getY() ) );
break;
case 4:
offsetPoint = new Point( ( int )( dragRect.getRectangle().getX() + dragRect.getRectangle().getWidth() ), ( int ) ( dragRect.getRectangle().getY()  ) );
break;
case 5:
offsetPoint = new Point( ( int )( dragRect.getRectangle().getX()), ( int ) ( dragRect.getRectangle().getY()  ) );
break;
case 6:
offsetPoint = new Point( ( int )( dragRect.getRectangle().getX() ), ( int ) ( dragRect.getRectangle().getY()  ) );
break;
}
rects.remove( dragRect );





}else{
switch( ACTION ){
case 1:
for( int i = 0; i < rects.size(); i++ ){
Block block = ( Block ) rects.elementAt( i );
if( block.getRectangle().contains( offsetPoint ) ){

block.setActive( true );
block.updateEdgeBounds();
}else{
block.setActive( false );
}


}
dragRect = new Block( new Rectangle( offsetPoint ), true );
break;

case 2:
// Inactivate last added Block
if( rects.size() > 0 ){
Block block = ( Block ) rects.elementAt( rects.size() - 1 );
block.setActive( false );
}
dragRect = new Block( new Rectangle( offsetPoint ) );
break;
}

}


    rects.add( dragRect );
  }
 
      public void mouseDragged(MouseEvent evt) {

Point p = evt.getPoint();




System.out.println( offsetPoint.getX() + ":" + offsetPoint.getY() );

if( moveBlockEvent ){
switch( EDGE_POSITION ){

case 1:

p = new Point( ( int ) ( dragRect.getRectangle().getX() + dragRect.getRectangle().getWidth() ),
( int ) evt.getY() 
);


break;
case 3:

p = new Point( ( int ) ( evt.getX()  ),
( int ) ( dragRect.getRectangle().getY() + dragRect.getRectangle().getHeight()  ) 
);
break;

case 5:

p = new Point( ( int ) ( dragRect.getRectangle().getX() + dragRect.getRectangle().getWidth() ),
( int ) evt.getY() 
);
break;

}
}
dragRect.setBlockBounds( offsetPoint, p );
 repaint();
 


      }  // end mouseDragged()
 
      public void mouseClicked(MouseEvent evt) {
  return;
  }
      public void mouseEntered(MouseEvent evt) {
  
if( moveBlockEvent )
return;
  
  if( ACTION == 2 ){
this.setCursor( Cursor.getPredefinedCursor( Cursor.CROSSHAIR_CURSOR  ) );
}

if( ACTION == 1 ){
this.setCursor( Cursor.getPredefinedCursor( Cursor.DEFAULT_CURSOR  ) );
}
  
  this.requestFocusInWindow();
  }
      public void mouseExited(MouseEvent evt) { }
      public void mouseMoved(MouseEvent evt) {
 
  if( moveBlockEvent )
return;
  
if( ACTION == 1  ){


this.setCursor( Cursor.getPredefinedCursor( Cursor.DEFAULT_CURSOR  ) );
Point point = evt.getPoint();

for( int i = 0; i < rects.size(); i++ ){
Block block = ( Block ) rects.elementAt( i );
if( block.isActive() ){
Vector a = block.getEdges();
for( int j = 0; j < a.size(); j++ ){
Rectangle rect = ( Rectangle ) a.elementAt( j );

if( rect.contains( point ) ){

switch( j ){
case 0:
this.setCursor( Cursor.getPredefinedCursor( Cursor.SE_RESIZE_CURSOR  ) );
break;
case 1:
this.setCursor( Cursor.getPredefinedCursor( Cursor.S_RESIZE_CURSOR  ) );
break;
case 2:
this.setCursor( Cursor.getPredefinedCursor( Cursor.SW_RESIZE_CURSOR  ) );
break;
case 3:
this.setCursor( Cursor.getPredefinedCursor( Cursor.E_RESIZE_CURSOR  ) );
break;
case 4:
this.setCursor( Cursor.getPredefinedCursor( Cursor.NE_RESIZE_CURSOR  ) );
break;
case 5:
this.setCursor( Cursor.getPredefinedCursor( Cursor.N_RESIZE_CURSOR  ) );
break;
case 6:
this.setCursor( Cursor.getPredefinedCursor( Cursor.NW_RESIZE_CURSOR  ) );
break;
case 7:
this.setCursor( Cursor.getPredefinedCursor( Cursor.W_RESIZE_CURSOR  ) );
break;
case 8:
this.setCursor( Cursor.getPredefinedCursor( Cursor.MOVE_CURSOR  ) );
break;

}
dragRect = block;
EDGE_POSITION = j;
return;
}
 
}

}
}

}
  
  }
  public void keyTyped( KeyEvent evt  ){}
  public void keyPressed( KeyEvent evt ){

int x = 0;
int y = 0;

if( evt.getKeyCode() == 39 || evt.getKeyChar() == KeyEvent.VK_KP_RIGHT || evt.getKeyChar() == KeyEvent.KEY_LOCATION_RIGHT  ){
x = 1;
}

if( evt.getKeyCode() == 37 || evt.getKeyChar() == KeyEvent.VK_KP_LEFT || evt.getKeyChar() == KeyEvent.KEY_LOCATION_LEFT  ){
x = -1;
}

if( evt.getKeyCode() == 38 || evt.getKeyChar() == KeyEvent.VK_KP_UP  ){
y = -1;
}

if( evt.getKeyCode() == 40 || evt.getKeyChar() == KeyEvent.VK_KP_DOWN  ){
y = 1;
}

if( x != 0 || y != 0 ){
for( int i = 0; i < rects.size(); i++ ){
Block block = ( Block ) rects.elementAt( i );
if( block.isActive() ){
block.getRectangle().setLocation( ( int )block.getRectangle().getX() + x , ( int )block.getRectangle().getY()+ y );
 block.updateEdgeBounds();
}
}
}
repaint();
  }
  
  public void delete(){
for( int i = 0; i < rects.size(); i++ ){
Block block = ( Block ) rects.elementAt( i );
if( block.isActive() ){
rects.remove( block );
this.delete();
}
}
  }
  
  public void keyReleased( KeyEvent evt ){
  if( evt.getKeyChar() == KeyEvent.VK_BACK_SPACE ){

this.delete();
repaint();
}


  
  }
  
}

public static void main( String args[] ){

new Tester();

}

}

[Craig Wood]

Works better now. I changed the class names so you can run this as–is without name–clashing.
Made changes in each class, mostly finishing up the mouse code. Moving the Block rect
requires a different technique than dragging its sides/corners. mouseReleased is still
rough but I think enough of your question is answered now.

import java.awt.*;
import java.awt.event.*;
import java.awt.geom.*;
import java.util.*;
import javax.swing.*;
 
public class TesterRx extends JFrame{
    public static int ACTION = 1;
    public static int EDGE_POSITION = -1;
 
    public TesterRx(){
        this.getContentPane().setLayout( new BorderLayout() );  // default
        this.getContentPane().add( new RectsRx(), BorderLayout.CENTER );
 
        JPanel panel = new JPanel();
//        panel.setPreferredSize( new Dimension( 150 , 400 ) );
 
        JButton b1 = new JButton( "1" );
        JButton b2 = new JButton( "2" );
 
        b1.addActionListener(new ActionListener(){
            public void actionPerformed( ActionEvent e ){
                ACTION = 1;
            }
        });
 
        b2.addActionListener(new ActionListener(){
            public void actionPerformed( ActionEvent e ){
                ACTION = 2;
            }
        });
 
        panel.add( b1 );
        panel.add( b2 );
        this.getContentPane().add( panel, BorderLayout.SOUTH );
 
        this.setDefaultCloseOperation( EXIT_ON_CLOSE );
        this.setSize( new Dimension(400 , 400 ) ) ;
        this.setVisible( true );
    }
 
    class BlockRx{
        private int MAX_EDGES = 9;
        private int EDGE_WIDTH = 6;
        private int EDGE_HEIGHT = 6;
        private int EDGE_SPACE = 3;
        private boolean isSelector = false;
        private Rectangle rect;
        private Vector edges;
        private boolean m_IsActive = false;
 
        BlockRx( Rectangle rect ){
            this( rect, false );
        }
 
        BlockRx( Rectangle rect, boolean selector ){
            this.rect = rect;
            this.isSelector = selector;
        }
 
        public boolean isActive(){
            return this.m_IsActive;
        }
 
        public void setActive( boolean state ){
            if( this.isSelector ){
                state = false;
            }
 
            if( state ){
                edges = new Vector( MAX_EDGES );
                for( int i = 0; i < MAX_EDGES; i++ ){
                    edges.add( new Rectangle() );
                }
            }else{
                if( edges != null ){
                    edges.clear();
                }
                edges = null;
            }
 
            this.m_IsActive = state;
        }
 
        public Rectangle getRectangle(){
            return this.rect;
        }
 
        public boolean isSelector(){
            return this.isSelector;
        }
 
        public Vector getEdges(){
            return this.edges;
        }
 
        public void updateEdgeBounds(){
            if( this.isActive() ){
                double height = this.rect.getHeight();
                double width = this.rect.getWidth();
                double x = this.rect.getX();
                double y = this.rect.getY();
 
                for( int i = 0; i < edges.size(); i++ ){
                    Rectangle edge = ( Rectangle ) edges.elementAt( i );
 
                    switch( i ){
                        case 0: // Upper left
                            edge.setRect( x - EDGE_SPACE, y - EDGE_SPACE,
                                              EDGE_WIDTH , EDGE_HEIGHT );
                            break;
                        case 1: // Upper middle
                            edge.setRect( ( int ) ( x - EDGE_SPACE + ( width / 2 ) ),
                                          ( int )( y - EDGE_SPACE ),
                                           EDGE_WIDTH , EDGE_HEIGHT );
                            break;
                        case 2: // Upper right
                            edge.setRect( ( int ) ( x + width - EDGE_SPACE ),
                                          ( int ) ( y - EDGE_SPACE ),
                                           EDGE_WIDTH , EDGE_HEIGHT );
                            break;
                        case 3: // Middle left
                            edge.setRect( ( int ) ( x - EDGE_SPACE ),
                                          ( int ) ( y - EDGE_SPACE + height / 2 ),
                                           EDGE_WIDTH , EDGE_HEIGHT );
                            break;
                        case 4: // bottom Left
                            edge.setRect( ( int ) ( x - EDGE_SPACE ),
                                          ( int ) ( y + height - EDGE_SPACE ),
                                           EDGE_WIDTH , EDGE_HEIGHT );
                            break;
                        case 5: // bottom middle
                            edge.setRect( ( int ) ( x - EDGE_SPACE +( width / 2 ) ),
                                          ( int ) ( y + height - EDGE_SPACE ),
                                           EDGE_WIDTH , EDGE_HEIGHT );
                            break;
                        case 6: // bottom right
                            edge.setRect( ( int ) ( x + width - EDGE_SPACE ),
                                          ( int ) ( y + height - EDGE_SPACE ),
                                           EDGE_WIDTH , EDGE_HEIGHT );
                            break;
                        case 7: // Middle right
                            edge.setRect( ( int ) ( x + width - EDGE_SPACE ),
                                          ( int ) ( y - EDGE_SPACE + height / 2 ),
                                           EDGE_WIDTH , EDGE_HEIGHT );
                            break;
                        case 8: // Middle
                            edge.setRect( ( int ) ( x - 2 + ( width / 2 ) ),
                                          ( int ) ( y - 2 + ( height / 2 ) ), 4 , 4 );
                            break;
                    }
                }
            }
        }
 
        public void setBlockBounds( Point offset, Point point ){
            double height = 0;
            double width = 0;
            double x = this.rect.getX();
            double y = this.rect.getY();
 
            if( point.getY() < offset.getY() ){
                y = point.getY();
 
                height = offset.getY() - point.getY();
            }else{
                height = point.getY() - offset.getY();
            }
 
            if( point.getX() < offset.getX() ){
                x = point.getX();
 
                width = offset.getX() - point.getX();
            }else{
                width = point.getX() - offset.getX();
            }
 
            this.rect.setRect( x , y , width , height );
            this.updateEdgeBounds();
        }
 
        public void moveBlock(int dx, int dy) {
            rect.translate(dx, dy);
            updateEdgeBounds();
        }
    }
 
    class RectsRx extends JPanel
                implements MouseListener, MouseMotionListener, KeyListener {
        boolean pressedEvent = false;
        boolean moveBlockEvent = false;
        private BlockRx dragRect;
        private Vector rects;
        private Point offsetPoint;
        final float dash1[] = { 2.0f };
        final BasicStroke dashed = new BasicStroke(1.0f,BasicStroke.CAP_BUTT,
                                       BasicStroke.JOIN_MITER, 10.0f, dash1, 0.0f);
        final BasicStroke normal = new BasicStroke(1);
 
        RectsRx() {
//            setPreferredSize( new Dimension( 250 , 400 ) );
            setBackground(Color.white);
            addMouseListener(this);
            addMouseMotionListener(this);
            rects = new Vector();
            addKeyListener( this );
        }
 
        /** See method signature in JComponent api. */
        protected void paintComponent( Graphics g ){
            super.paintComponent( g );
            Graphics2D g2 = (Graphics2D)g;
 
            for( int i = 0; i < rects.size(); i++ ){
                g2.setStroke( normal );
 
                g2.setColor( new Color( 79, 153, 255 ) );
                BlockRx block = ( BlockRx ) rects.elementAt( i );
 
                if( block.isSelector() ){
                    g2.setColor( new Color( 0 , 0 , 0 ) );
                    g2.setStroke( dashed );
                }
 
                g2.draw( block.getRectangle() );
 
                if( block.isActive() ){
                    Vector a = block.getEdges();
                    for( int j = 0; j < a.size(); j++ ){
                        Rectangle rect = ( Rectangle ) a.elementAt( j );
                        g2.setColor( new Color( 79, 153, 255 ) );
                        g2.draw( rect );
 
                        if( j != 8 ){
                            g2.setColor( Color.WHITE );
                            g2.fillRect(rect.x + 1, rect.y + 1,
                                        rect.width - 1, rect.height - 1);
                        }else{
 
                            g2.fillRect(rect.x + 1, rect.y + 1,
                                        rect.width - 1, rect.height - 1);
                        }
                    }
                }
            }
            // Not needed, java will take care of this when inside its
            // own painting methods.
//            g2.dispose();
        }
 
        public void mousePressed(MouseEvent evt) { 
            System.out.println( "pressed : " + EDGE_POSITION + "\n" );
 
            if( EDGE_POSITION != -1 ){
                moveBlockEvent = true;
            }
            if( pressedEvent )
                return;
 
            pressedEvent = true;
            mouseClickEvent( evt );
        }
 
        public void mouseReleased(MouseEvent evt) {
            Point p = evt.getPoint();
 
            if( offsetPoint.getX() == p.getX() && offsetPoint.getY() == p.getY() ){
                // Just finished dragging a Block.
                if( moveBlockEvent ){
                    BlockRx block = new BlockRx( new Rectangle( 
                                      ( int )dragRect.getRectangle().getX(),
                                      ( int )dragRect.getRectangle().getY(),
                                      ( int )dragRect.getRectangle().getWidth(),
                                      ( int )dragRect.getRectangle().getHeight()
                                                               ) );
                    rects.add( block );
                }
            }else{
                if( ACTION == 2 ){      // Set new Block.
                    BlockRx b = new BlockRx( new Rectangle( offsetPoint ) );
                    b.setActive( true );
                    b.setBlockBounds( offsetPoint, p );
 
                    rects.add( b );
                }else{                  // Adjusting an existing Block edge.
                    if( moveBlockEvent ){
                        BlockRx block = new BlockRx( new Rectangle( 
                                          ( int )dragRect.getRectangle().getX(),
                                          ( int )dragRect.getRectangle().getY(),
                                          ( int )dragRect.getRectangle().getWidth(),
                                          ( int )dragRect.getRectangle().getHeight()
                                                                   ) );
                        block.setActive( true );
                        block.updateEdgeBounds();
                        rects.add( block );
 
                    }else{
 
                        for( int i = 0; i < rects.size(); i++ ){
                            BlockRx block = ( BlockRx ) rects.elementAt( i );
 
                            if( dragRect.getRectangle().intersects(
                                                 block.getRectangle() ) ){
                                block.setActive( true );
                                block.updateEdgeBounds();
                            }else{
                                block.setActive( false );
                                block.updateEdgeBounds();
                            }
                        }
                    }
                }
            }
 
            moveBlockEvent = false;
            pressedEvent = false;
            EDGE_POSITION = -1;
            rects.remove( dragRect );
            dragRect = null;
            p = null;
            offsetPoint = null;
            repaint();
        }
 
        public void mouseClickEvent( MouseEvent evt ){
            offsetPoint = evt.getPoint(); 
            if( dragRect != null && moveBlockEvent ){
 
                // This was causing a NullPointerException for
                // unspecified EDGE_POSITIONs.
//                offsetPoint = null;
                // This is another option for resetting offsetPoint.
                //offsetPoint.setLocation(-1, -1);
                switch( EDGE_POSITION ){
                    case 0: // Upper left
                        offsetPoint =
                            new Point( ( int )( dragRect.getRectangle().getX() +
                                           dragRect.getRectangle().getWidth() ),
                                       ( int ) ( dragRect.getRectangle().getY() +
                                           dragRect.getRectangle().getHeight() ) );
                        break;
                    case 1: // Upper middle
                        offsetPoint =
                            new Point( ( int )( dragRect.getRectangle().getX() ),
                                       ( int ) ( dragRect.getRectangle().getY() +
                                           dragRect.getRectangle().getHeight() ) );
                        break;
                    case 2: // Upper right
                        offsetPoint =
                            new Point( ( int )( dragRect.getRectangle().getX() ),
                                       ( int ) ( dragRect.getRectangle().getY() +
                                           dragRect.getRectangle().getHeight() ) );
                        break;
                    case 3: // Middle left
                        offsetPoint =
                            new Point( ( int )( dragRect.getRectangle().getX() +
                                           dragRect.getRectangle().getWidth() ),
                                       ( int ) ( dragRect.getRectangle().getY() ) );
                        break;
                    case 4: // bottom Left
                        offsetPoint =
                            new Point( ( int )( dragRect.getRectangle().getX() +
                                           dragRect.getRectangle().getWidth() ),
                                       ( int ) ( dragRect.getRectangle().getY() ) );
                        break;
                    case 5: // bottom middle
                        offsetPoint =
                            new Point( ( int )( dragRect.getRectangle().getX()),
                                       ( int ) ( dragRect.getRectangle().getY() ) );
                        break;
                    case 6: // bottom right
                        offsetPoint =
                            new Point( ( int )( dragRect.getRectangle().getX() ),
                                       ( int ) ( dragRect.getRectangle().getY() ) );
                        break;
                    case 7: // Middle right
                        offsetPoint.setLocation(dragRect.getRectangle().x,
                                                dragRect.getRectangle().y);
                        break;
                    case 8: // Middle
                        // We need offsetPont == evt.getPoint() for this case.
                        break;
                } 
                rects.remove( dragRect );
 
            }else{
                switch( ACTION ){
                    case 1:
                        for( int i = 0; i < rects.size(); i++ ){
                            BlockRx block = ( BlockRx ) rects.elementAt( i );
                            if( block.getRectangle().contains( offsetPoint ) ){
 
                                block.setActive( true );
                                block.updateEdgeBounds();
                            }else{
                                block.setActive( false );
                            }
                        }
                        dragRect = new BlockRx( new Rectangle( offsetPoint ), true );
                        break;
                    case 2:
                        // Inactivate last added Block
                        if( rects.size() > 0 ){
                            BlockRx block =
                                ( BlockRx ) rects.elementAt( rects.size() - 1 );
                            block.setActive( false );
                        }
                        dragRect = new BlockRx( new Rectangle( offsetPoint ) );
                        break;
                }
            }
 
            rects.add( dragRect );
        }
 
        public void mouseDragged(MouseEvent evt) {
            Point p = evt.getPoint();
 
            System.out.println( offsetPoint.getX() + ":" + offsetPoint.getY() );
 
            if( moveBlockEvent ){
                switch( EDGE_POSITION ){
                    case 1: // Upper middle
                        p.x = dragRect.getRectangle().x +
                              dragRect.getRectangle().width;
                        break;
                    case 3: // Middle left
                        p = new Point( ( int ) ( evt.getX() ),
                                       ( int ) ( dragRect.getRectangle().getY() +
                                                 dragRect.getRectangle().getHeight() ) );
                        break;
                    case 5: // bottom middle
                        p = new Point( ( int ) ( dragRect.getRectangle().getX() +
                                                 dragRect.getRectangle().getWidth() ),
                                       ( int ) evt.getY() );
                        break;
                    case 7: // Middle right
                        p.y = dragRect.getRectangle().y +
                              dragRect.getRectangle().height;
                        break;
                    case 8: // Middle
                        // Special case, see below.
                        break;
                } 
            }
            if(EDGE_POSITION == 8) {
                int dx = p.x - offsetPoint.x;
                int dy = p.y - offsetPoint.y;
                dragRect.moveBlock( dx, dy );
                offsetPoint = p;
            }
            else
                dragRect.setBlockBounds( offsetPoint, p );
            repaint();
        }
 
        public void mouseClicked(MouseEvent evt) {
            return;
        }
 
        public void mouseEntered(MouseEvent evt) {
 
            if( moveBlockEvent )
                return;
 
            if( ACTION == 2 ){
                this.setCursor( Cursor.getPredefinedCursor( Cursor.CROSSHAIR_CURSOR ) );
            }
 
            if( ACTION == 1 ){
                this.setCursor( Cursor.getPredefinedCursor( Cursor.DEFAULT_CURSOR ) );
            }
 
            this.requestFocusInWindow();
        }
 
        public void mouseExited(MouseEvent evt) { }
 
        public void mouseMoved(MouseEvent evt) {
 
            if( moveBlockEvent )
                return;
 
            if( ACTION == 1 ){
                this.setCursor( Cursor.getPredefinedCursor( Cursor.DEFAULT_CURSOR ) );
                Point point = evt.getPoint();
 
                for( int i = 0; i < rects.size(); i++ ){
                    BlockRx block = ( BlockRx ) rects.elementAt( i );
                    if( block.isActive() ){
                        Vector a = block.getEdges();
                        for( int j = 0; j < a.size(); j++ ){
                            Rectangle rect = ( Rectangle ) a.elementAt( j );
 
                            if( rect.contains( point ) ){
 
                                switch( j ){
                                    case 0: // Upper left
                                        this.setCursor( Cursor.getPredefinedCursor(
                                                            Cursor.SE_RESIZE_CURSOR ) );
                                        break;
                                    case 1: // Upper middle
                                        this.setCursor( Cursor.getPredefinedCursor(
                                                            Cursor.S_RESIZE_CURSOR ) );
                                        break;
                                    case 2: // Upper right
                                        this.setCursor( Cursor.getPredefinedCursor(
                                                            Cursor.SW_RESIZE_CURSOR ) );
                                        break;
                                    case 3: // Middle left
                                        this.setCursor( Cursor.getPredefinedCursor(
                                                            Cursor.E_RESIZE_CURSOR ) );
                                        break;
                                    case 4: // bottom Left
                                        this.setCursor( Cursor.getPredefinedCursor(
                                                            Cursor.NE_RESIZE_CURSOR ) );
                                        break;
                                    case 5: // bottom middle
                                        this.setCursor( Cursor.getPredefinedCursor(
                                                            Cursor.N_RESIZE_CURSOR ) );
                                        break;
                                    case 6: // bottom right
                                        this.setCursor( Cursor.getPredefinedCursor(
                                                            Cursor.NW_RESIZE_CURSOR ) );
                                        break;
                                    case 7: // Middle right
                                        this.setCursor( Cursor.getPredefinedCursor(
                                                            Cursor.W_RESIZE_CURSOR ) );
                                        break;
                                    case 8: // Middle
                                        this.setCursor( Cursor.getPredefinedCursor(
                                                            Cursor.MOVE_CURSOR ) );
                                        break;
                                }
                                dragRect = block;
                                EDGE_POSITION = j;
                                return;
                            }
                        }
                    }
                }
            }
        }
 
        public void keyTyped( KeyEvent evt ){}
 
        public void keyPressed( KeyEvent evt ){
 
            int x = 0;
            int y = 0;
 
            if( evt.getKeyCode() == 39 || evt.getKeyChar() == KeyEvent.VK_KP_RIGHT ||
                       evt.getKeyChar() == KeyEvent.KEY_LOCATION_RIGHT ){
                x = 1;
            }
 
            if( evt.getKeyCode() == 37 || evt.getKeyChar() == KeyEvent.VK_KP_LEFT ||
                       evt.getKeyChar() == KeyEvent.KEY_LOCATION_LEFT ){
                x = -1;
            }
 
            if( evt.getKeyCode() == 38 || evt.getKeyChar() == KeyEvent.VK_KP_UP ){
                y = -1;
            }
 
            if( evt.getKeyCode() == 40 || evt.getKeyChar() == KeyEvent.VK_KP_DOWN ){
                y = 1;
            }
 
            if( x != 0 || y != 0 ){
                for( int i = 0; i < rects.size(); i++ ){
                    BlockRx block = ( BlockRx ) rects.elementAt( i );
                    if( block.isActive() ){
                        block.getRectangle().setLocation( 
                                   ( int )block.getRectangle().getX() + x ,
                                   ( int )block.getRectangle().getY()+ y );
                        block.updateEdgeBounds();
                    }
                }
            }
            repaint();
        }
 
        public void delete(){
            for( int i = 0; i < rects.size(); i++ ){
                BlockRx block = ( BlockRx ) rects.elementAt( i );
                if( block.isActive() ){
                    rects.remove( block );
                    this.delete();
                }
            }
        }
 
        public void keyReleased( KeyEvent evt ){
            if( evt.getKeyChar() == KeyEvent.VK_BACK_SPACE ){
 
                this.delete();
                repaint();
            }
        }
    }
 
    public static void main( String args[] ){
        new TesterRx();
    }
}

[Mathias Nilsson]

Thanks alot

But there is still a major problem when resizing the block

When I place a block it works fine. When i want to resize it and drag ex upper right corner real fast the block "JUMPS". It means it does not retain x and y coordinates. I don't know why but and I can't it. Do you know what the problem is?

[Craig Wood]

Do you mean that the entire Block moves with no edges/parts stationary?
Or that the lines of the Block cannot be drawn quickly enough with rapid
movement and appear jumpy?
Using the TesterRx class, when I drag the upper right corner slower or
faster, the block resizes okay. The lower left corner remains stationary,
the top side and right side move with the mouse pointer. The y coordinate
of the upper left corner changes and the x coordinate of the lower right
corner changes — but I would say this is the expected behavior. The
entire block does not translate when dragging a corner or side edge. The
moving lines, especially the ones connected to the mouse pointer, do
appear jumpy when the mouse is moved very fast. But this seems normal/not excessive for this kind of program.

[Mathias Nilsson]

Ok thanks.... I tried it in Indesign but it doesn't get jumpy there.

I have tried to create a rule that is for the grid mesurement. The TesterRX and the new panel is in the
same JScrollpane. When i try to scroll the JscollPane the RuleRx flickers a lot. It is a very small JPanel. I there a better way of doing this beside using image.

class RulerRx extends JPanel{
    
    
    RulerRx(){
    setBackground( Color.WHITE );
    }
    
    
    public void paintComponent( Graphics g ){
super.paintComponent( g );


g.setColor( new Color( 140 , 140 , 140 ) );
g.drawLine( 3 , 0 , 1221, 0 );

g.setColor( Color.black );
g.drawLine( 3 , 15 , 1221, 15 );

int j = 0;
int startY = 0;
int stopY = 15;
int f = 0;
int s = 0;
int h = 0;
int randomInt = 1;
boolean randomUsed = false;
int k = 0;
 
for( int i = -10; i <= 420; i++ ){
if( h == 1 || h == 6 ){
randomInt = 0 + ( int )( Math.random() * 4 );
randomUsed = false;
}
if( f == randomInt && ! randomUsed ){
j += 2;
randomUsed = true;
}else{
j+= 3;
}


if( k == 3 ){
k = 0;
 
j += 1;


}
if( h == 0 && i != 420 ){
g.setFont( new Font( "arial" , Font.PLAIN, 9 ) );
g.drawString( "" + i, j + 3 , 10 );
}

startY = 13;
if( h == 0 ){
startY = 1;
}

if( s == 5 ){
startY = 11;
}

g.drawLine(  j ,  startY , j ,  stopY );

f++;
if( f == 5 ){
f = 0;
}

h++;
s++;

if( h == 10 ){
k++;
h = 0;
}
if( s == 10 ){
s = 0;
}

}

    
    }
    
    }

This is a mesure in mm and a pixel is 0.353 mm so I have to cheat a little as you can see.


// Mathias

[Craig Wood]

I added your RulerRx class and the RectsRx class to a JPanel and put it in a JScrollPane
and it worked okay — no flickering, jerkiness or rough behavior.

public class TesterRx extends JFrame{
    ...
    public TesterRx(){
        JPanel center = new JPanel(new BorderLayout());
        center.add(new RR(), "First");  // RulerRx
        center.add(new RectsRx());
        this.getContentPane().add( new JScrollPane(center), BorderLayout.CENTER );
    ...
 
    class RectsRx extends JPanel
                implements MouseListener, MouseMotionListener, KeyListener {
        ...
        RectsRx() {
            setPreferredSize( new Dimension( 600, 600 ) );

Have you seen how rulers are added to a custom component in the tutorial page How to Use Scroll Panes?
It is demonstrated in the section Providing Custom Decorations.

[Mathias Nilsson]

Thanks!

It worked for me now. Many thanks.

Is there anything special that I should think about when designing this. Is there a better approach on dragging the rectangles? Or perhaps the onmose over method.

// Mathias