>> From: David Malkovsky <###@###.### <mailto:###@###.###>>
>> To: "'Rob Clark (E-mail)'" <Rob.Clark@Eng>
>> Subject: Imformation on an import regression in JDK 1.1.1 beta code
>> Date: Wed, 12 Mar 1997 15:17:37 -0500
>> Mime-Version: 1.0
>> Content-Transfer-Encoding: 7bit
>>
>> Rob,
>>
>> The following report is from one of our senior developers on our IDE.
>> The problem he reports did not occur in JDK 1.1 but does happen with
>> the code drop of Feb 27 (JDK 1.1.1B win32 2_27). As he notes in his
>> description, this problem will be something our users will see almost
>> immediately; they will drop a widget and when they try to move is
>> final position with the mouse they will lose control on the widget.
>> Can you get his report to Amy Fowler? Here is his description of the
>> problem:
>>
>>
>> I have made changes that allow the 1.1.1 version of the JDK to be
>> used. That said, however, I have to point out a problem that I have
>> not seen before. In a frame, create a button. Grab the move handle on
>> the bottom and move up. If you do this slowly then the component will
>> move. If, however, your mouse pointer ever moves over the button then
>> the button quits moving and will not move again until you release the
>> mouse button and start over. It is easier to see dragging on the
>> bottom border but I have reproduced this behavior from the top border
>> as well.
>>
>> I have scanned the bug database and found 4034656 which appears to be
>> the same bug. This bug is marked closed with no release specified
>> which I assume means that it wasn't fixed. Is there anyway we can get
>> additional info? This problem is something our users will see almost
>> immediately.
>>
>> BugId: 4034656
>> Release Fixed: NULL
>> Priority: 1
>> State: closed
>> Submit Date: Feb 25 1997
>> Synopsis: Win32:MouseDrag issues an event incorrectly
>> Description: Click a mouse on a component derived either from Canva or
>> Panel Class,
>> and drag the mouse out of the component (with the mouse being kept
>> pressed) so that the first drag event is issued outside the component.
>> The drag event is issued not to the component where the mouse is
>> clicked first but to a component where the mouse is located. Or if
>> the mouse is released outside the component where it was pressed, a
>> MOUSE_RELEASED event is not issued.
>>
>> David B. Malkovsky
>> SAS Institute Inc.
>> Email: ###@###.###
>> Phone: 919/677-8000, x7723; FAX:919/677-4444
>>

Here is my code to test the problem. Sorry it is so long but it appears
to be related to the amount of time I am spending in the mouse routines:

import java.awt.*;
import java.awt.event.*;

class Test extends Frame
{
Checkbox cbox = null;
MouseHandler m = null;

class MouseHandler implements MouseListener, MouseMotionListener,
WindowListener
{
Component mover = null;
int moveType = 0;
Point hitPoint = null;

public void windowOpened(WindowEvent e)
{
}
public void windowClosing(WindowEvent e)
{
System.exit(0);
}
public void windowClosed(WindowEvent e)
{
}
public void windowIconified(WindowEvent e)
{
}
public void windowDeiconified(WindowEvent e)
{
}
public void windowActivated(WindowEvent e)
{
}
public void windowDeactivated(WindowEvent e)
{
}
public void mouseClicked(MouseEvent e)
{
}
public void mousePressed(MouseEvent evt)
{
// walk through components and test the handles
Component[] cList = getComponents();
hitPoint = new Point(evt.getX(),evt.getY());

//System.out.println("hitPoint:"+hitPoint);
for(int i=0;i<cList.length;++i)
{
JHandle handle = new JHandle(cList[i]);
moveType = handle.hitHandle(hitPoint.x, hitPoint.y);
if (moveType != JHandle.noHit)
{
mover = cList[i];
hitPoint.translate(-cList[i].getLocation().x,
-cList[i].getLocation().y);
//System.out.println("hitPoint:"+hitPoint);
return;
}
}

}
public void mouseReleased(MouseEvent e)
{
}
public void mouseEntered(MouseEvent e)
{
}
public void mouseExited(MouseEvent e)
{
}
public void mouseDragged(MouseEvent evt)
{
if (mover != null)
{
int newHeight;
int newWidth;
Rectangle size = mover.getBounds();


int x = evt.getX();
int y = evt.getY();

switch(moveType)
{
case JHandle.moveHandle: // MOVE
mover.setLocation(x - hitPoint.x, y - hitPoint.y);
break;
case JHandle.nwHandle: // NW anchor SE corner
newWidth = size.x - (x - hitPoint.x);
newHeight = size.y - (y - hitPoint.y);
mover.setBounds(x - hitPoint.x, y - hitPoint.y,
size.width+newWidth, size.height+newHeight);
break;
case JHandle.wHandle: // W Anchor E side
newWidth = size.x - (x - hitPoint.x);
mover.setBounds(x - hitPoint.x, size.y,
size.width+newWidth, size.height);
break;
case JHandle.swHandle: // SW Anchor NE corner
newWidth = size.x - (x - hitPoint.x);
newHeight = y - size.y;
mover.setBounds(x - hitPoint.x, size.y,
size.width+newWidth, newHeight);
break;
case JHandle.neHandle: // NE Anchor SW corner
newWidth = x - size.x;
newHeight = size.y - (y - hitPoint.y);
mover.setBounds(size.x, y - hitPoint.y,
newWidth, size.height+newHeight);
break;
case JHandle.eHandle: // E Anchor W side
newWidth = x - size.x;
mover.setBounds(size.x, size.y,
newWidth, size.height);
break;
case JHandle.seHandle: // SE Anchor NW corner
newWidth = x - size.x;
newHeight = y - size.y;
mover.setBounds(size.x, size.y,
newWidth, newHeight);
break;
case JHandle.nHandle: // N Anchor S side
newHeight = size.y - (y - hitPoint.y);
mover.setBounds(size.x, y - hitPoint.y,
size.width, size.height + newHeight);
break;
case JHandle.sHandle: // S Anchor N side
newHeight = y - size.y;
mover.setBounds(size.x, size.y,
size.width, newHeight);
break;
}
repaint();

}

}
public void mouseMoved(MouseEvent evt)
{
Cursor c = Cursor.getDefaultCursor();
if (mover == null)
{
// walk through components and test the handles
Component[] cList = getComponents();
Point point = new Point(evt.getX(),evt.getY());


for(int i=0;i<cList.length;++i)
{
JHandle handle = new JHandle(cList[i]);
moveType = handle.hitHandle(point.x, point.y);
Cursor tmpCursor = handle.handleCursor(moveType);
if (tmpCursor.getType() != Cursor.DEFAULT_CURSOR)
{
setCursor(tmpCursor);
return;
}
}
}
setCursor(c);
}
}
public Test()
{
setBackground(Color.lightGray);
m = new MouseHandler();
addMouseListener(m);
addMouseMotionListener(m);
addWindowListener(m);
setLayout(null);
setSize(500,500);
addNotify();
cbox = new Checkbox("CheckBox");
cbox.setBounds(30, 30, 60, 15);
add(cbox);
cbox.setVisible(true);
show();
}

public void paint(Graphics g)
{
super.paint(g);
Component[] c = getComponents();
for(int i = 0;i<c.length;++i)
{
JHandle handle = new JHandle(c[i]);
handle.paint(g);
}

}

public static void main(String argv[])
{
Test t;
t = new Test();
}

}

class JHandle
{
public int x;
public int y;
int width;
int height;
Component comp = null;
boolean noDraw = false;

public static final int moveHandle = -1;
public static final int noHit = 0;
public static final int nwHandle = 1;
public static final int wHandle = 2;
public static final int swHandle = 3;
public static final int neHandle = 4;
public static final int eHandle = 5;
public static final int seHandle = 6;
public static final int nHandle = 7;
public static final int sHandle = 8;


public JHandle(Component c)
{
comp = c;
Rectangle b = c.getBounds();
x = b.x-5;// - c.getParent().insets().left;
y = b.y-5;// - c.getParent().insets().top;
width = b.width+10;
height = b.height+10;
//System.out.println("insets; "+c.getParent().insets()+" bounds:
"+c.bounds());
//System.out.println("x:"+x+" y:"+y+" w:"+width+" h:"+height);
}


public int hitHandle(int dx, int dy)
{
if (comp.getBounds().contains(dx, dy))
return JHandle.noHit;

// now translate the point to the handle to make computation easier
dx = dx - x;
dy = dy - y;
        if ((dx < 0) || (dy < 0) || (dx > width) || (dy > height))
            return JHandle.noHit;
if (dx < 10) {
if (dy < 10)
return JHandle.nwHandle;
if (dy > height - 9)
return JHandle.swHandle;
if ((dy > (height/2)-3) && (dy < (height/2)+3))
return JHandle.wHandle;
return JHandle.moveHandle;
}
if (dx > width - 10) {
if (dy < 10)
return JHandle.neHandle;
if (dy > height - 9)
return JHandle.seHandle;
if ((dy > (height/2)-3) && (dy < (height/2)+3))
return JHandle.eHandle;
return JHandle.moveHandle;
}
if ((dx > (width/2)-3) && (dx < (width/2)+3))
if (dy <= 5)
return JHandle.nHandle;
else
return JHandle.sHandle;
return JHandle.moveHandle;
}


public void paint(Graphics g)
{
// Move handles
if (noDraw) return;
Color back = comp.getParent().getBackground();

        g.setColor(back);
        g.fill3DRect(x,y,width, 5, false);
        g.fill3DRect(x,y,5, height, false);
        g.fill3DRect(x+width-5, y, 5, height, false);
        g.fill3DRect(x,y+height-5, width, 5, false);

// Resize handles upper left
g.setColor(back);
g.fillRect(x,y,9,4);
g.fillRect(x,y,4,9);
g.setColor(back.brighter());
g.drawLine(x,y,x+9,y);
g.drawLine(x,y,x,y+9);
g.setColor(back.darker());
g.drawLine(x+1,y+9,x+4,y+9);
g.drawLine(x+4,y+4,x+4,y+9);
g.drawLine(x+4,y+4,x+9,y+4);
g.drawLine(x+9,y+1,x+9,y+4);

// Resize handles upper right
g.setColor(back);
g.fillRect(x+width-10,y,9,4);
g.fillRect(x+width-5,y,4,9);
g.setColor(back.brighter());
g.drawLine(x+width-10,y,x+width-1,y);
g.drawLine(x+width-10,y,x+width-10,y+4);
g.drawLine(x+width-5,y+5,x+width-5,y+9);
g.setColor(back.darker());
g.drawLine(x+width-9,y+4,x+width-5,y+4);
g.drawLine(x+width-4,y+9,x+width-1,y+9);
g.drawLine(x+width-1,y+1,x+width-1,y+9);

// Resize handles lower left
g.setColor(back);
g.fillRect(x,y+height-10,4,9);
g.fillRect(x,y+height-5,9,4);
g.setColor(back.brighter());
g.drawLine(x,y+height-10,x+4,y+height-10);
g.drawLine(x,y+height-10,x,y+height-1);
g.drawLine(x+4,y+height-5,x+9,y+height-5);
g.setColor(back.darker());
g.drawLine(x+4,y+height-9,x+4,y+height-5);
g.drawLine(x+1,y+height-1,x+9,y+height-1);
g.drawLine(x+9,y+height-4,x+9,y+height-1);

// Resize handles lower right
g.setColor(back);
g.fillRect(x+width-10,y+height-5,9,4);
g.fillRect(x+width-5,y+height-10,4,9);
g.setColor(back.brighter());
g.drawLine(x+width-5,y+height-10,x+width-1,y+height-10);
g.drawLine(x+width-5,y+height-10,x+width-5,y+height-5);
g.drawLine(x+width-10,y+height-5,x+width-5,y+height-5);
g.drawLine(x+width-10,y+height-5,x+width-10,y+height-1);
g.setColor(back.darker());
g.drawLine(x+width-9,y+height-1,x+width-1,y+height-1);
g.drawLine(x+width-1,y+height-9,x+width-1,y+height-1);

g.setColor(back);
g.fill3DRect(x+(width/2)-3, y, 7, 5, true);
g.fill3DRect(x+(width/2)-3, y+height-5, 7, 5, true);
g.fill3DRect(x, y+(height/2)-3, 5, 7, true);
g.fill3DRect(x+width-5, y+(height/2)-3, 5, 7, true);
}

public boolean handleCursor(int dx, int dy, Frame frame)
{
return handleCursor(hitHandle(dx, dy), frame);
}

public boolean handleCursor(int hitType, Frame frame)
{
Cursor c = null;
switch(hitType)
{
case JHandle.moveHandle:
c = new Cursor(Cursor.MOVE_CURSOR);
break;
case JHandle.nwHandle:
c = new Cursor(Cursor.NW_RESIZE_CURSOR);
break;
case JHandle.wHandle:
c = new Cursor(Cursor.W_RESIZE_CURSOR);
break;
case JHandle.swHandle:
c = new Cursor(Cursor.SW_RESIZE_CURSOR);
break;
case JHandle.neHandle:
c = new Cursor(Cursor.NE_RESIZE_CURSOR);
break;
case JHandle.eHandle:
c = new Cursor(Cursor.E_RESIZE_CURSOR);
break;
case JHandle.seHandle:
c = new Cursor(Cursor.SE_RESIZE_CURSOR);
break;
case JHandle.nHandle:
c = new Cursor(Cursor.N_RESIZE_CURSOR);
break;
case JHandle.sHandle:
c = new Cursor(Cursor.S_RESIZE_CURSOR);
break;
case JHandle.noHit:
default:
return false;
}
frame.setCursor(c);
return true;
}

public Cursor handleCursor(int hitType)
{
int cursorType = Cursor.DEFAULT_CURSOR;
switch(hitType)
{
case JHandle.moveHandle:
cursorType = Cursor.MOVE_CURSOR;
break;
case JHandle.nwHandle:
cursorType = Cursor.NW_RESIZE_CURSOR;
break;
case JHandle.wHandle:
cursorType = Cursor.W_RESIZE_CURSOR;
break;
case JHandle.swHandle:
cursorType = Cursor.SW_RESIZE_CURSOR;
break;
case JHandle.neHandle:
cursorType = Cursor.NE_RESIZE_CURSOR;
break;
case JHandle.eHandle:
cursorType = Cursor.E_RESIZE_CURSOR;
break;
case JHandle.seHandle:
cursorType = Cursor.SE_RESIZE_CURSOR;
break;
case JHandle.nHandle:
cursorType = Cursor.N_RESIZE_CURSOR;
break;
case JHandle.sHandle:
cursorType = Cursor.S_RESIZE_CURSOR;
break;
case JHandle.noHit:
default:
cursorType = Cursor.DEFAULT_CURSOR;
break;
}

return Cursor.getPredefinedCursor(cursorType);
}

}

Jim Adams
###@###.###
SAS Institute