《Java 编程技巧1001条》第410条: 检测双击的另一种方法
2017-12-24 20:34
435 查看
《Java 编程技巧1001条》第11章 事件驱动 第410条 检测双击的另一种方法
410 An Alternative Way to Detect Double-Clicks
410 检测Double-Clicks的另一种方法
In Tip 409, you learned how to detect double-click operations using the Event class clickCount variable. Unfortunately, depending on your release of Java, you may find that clickCount does not always contain the correct value. An alternative way to detect double-click mouse operations is to determine the time interval between clicks yourself. To do this, you can check the Event class when variable. If two mouse clicks occur within a specific interval of time, your applet can treat the mouse clicks as a double-click operation. The following program, altDoubleClick.java, demonstrates how you might check the interval between mouseDown events using the when variable:
在TIP 409中,你已知道了怎样利用clickCount变量来检测double-click操作. 不幸的是,利用clickCount变量来检测double-click操作,在不同的Java版本下,并不总是提供可靠的值. 检测double-click操作的另一种方法是由你自己来确定击键的时间间隔. 为了做这一事,你可检测Event类. 如果两次mouse 点击事件出现在一个指定的时间间隔内,你的程序就可把它当作一个double-click来处理. 以下的altDouble-Click.java程序将告诉你怎样利用when变量来检测两次mouseDown事件之间的时间间隔:
import java.applet.*;
import java.awt.*;
public class altDoubleClick extends Applet {
static int lastclick = 0;
static long maxdelay = 100;
static int doubleclick = 0;
public void init()
{
resize(400, 300);
}
public boolean mouseDown(Event evt, int x, int y)
{
long delay = evt.when - lastclick;
if ((delay > maxdelay) || (doubleclick == 0))
doubleclick = 1;
else
doubleclick++;
if (evt.clickCount == 1)
System.out.println("mouseDown: single click");
else if (evt.clickCount == 2)
System.out.println("mouseDown: double click");
else if (evt.clickCount == 3)
System.out.println("mouseDown: tripple click");
else if (evt.clickCount > 3)
System.out.println("mouseDown: many clicks");
return(true);
}
}on most operating systems, a user can set the sensitivity for double
clicks. However, the when variable technique in this tip has no way to
adjust sensitivity based on the operating-system settings.
在大多数操作系统中,用户可以设置double clicks的灵敏性. 但是,对本TIP中使
用的when变量没有办法利用操作系统的设置来调整灵敏度.
411 Detecting Mouse Click Modifier Keys
411 检测鼠标点击修饰键
From the time of the first graphical-user interface, there have been
mouse-click and key combinations that users perform for special purposes.
For example, in many graphical programs, drawing with the Shift key
depressed causes an oval tool to draw circles.
为了实现特殊的用途,自从第一个图形用户接口诞生时起,就有把鼠标键和键盘键组合
在一起的用法. 例如,在大多数图形程序中, 如果鼠标作图时同时按下了Shift键,将使
椭圆工具(oval tool)画成圆.
To detect a mouse-click modifier key within a Java applet, you check the
Event class modifiers variable. Java defines a set of constants in the
Event class that your programs can use to check for a specific modifier key
such as SHIFT_MASK, CTRL_MASK, and ALT_MASK. To determine if the user has
pressed a specific key, you perform a bitwise AND operation of the
corresponding constant and the modifier variable. The following program,
singleModifier.java, demonstrates how your programs detect if a user
modified the mouse operation by holding down the Shift key:
在Java应用程序中,为了检测鼠标点击修饰键,你可检查Event类的modifiers变量.
Java在事件类中定义了一组供你用来检测特殊修饰键的常量,如SHIFT_MASK, CTRL_MASK,
和 ALT_MASK. 为了检测用户是否已按下某个特殊键,你可以对modifiers变量和对应
的常量实行按位乘(AND)运算. 以下的singleModifier.java程序告诉你怎样检查用户
在利用mouse操作时是否同时按下了Shift键.
import java.awt.*;
import java.applet.*;
public class singleModifier extends Applet {
public boolean mouseDown(Event evt, int x, int y)
{
if ((evt.modifiers & Event.SHIFT_MASK) != 0)
System.out.println("mouseDown and Shift key pressed");
else
System.out.println("mouseDown");
return(true);
}
}
412 Understanding the Multi-Button Mouse Problem
412 了解多按钮(Multi-Button)鼠标问题
In the previous tips, you have learned how to detect when the user clicks
the mouse. On some platforms, the mouse has more than one button.
Unfortunately, Java does not provide a clear way to distinguish between
mouse buttons. In fact, to date, only undocumented techniques existwhich
might not work in future versions of Java. Also, if you create a program
that requires more than one mouse button, your program will be platform
dependent. Until a solution is built into the language, we recommend that
you just assume that there is only one mouse button. With that said, the
following program, multiMouse.java, will now demonstrate an undocumented
technique for detecting the second and third mouse button:
在前面的TIP中,你已知道了怎样检测用户是否已按下mouse键. 在有的平台上,mouse
可以有多个button. 不幸的是, Java不提供区别mouse button的确切方法. 事实上,
到目前为止,只有不成文的技术在用, 它们对今后的Java版本有可能不使用. 同样,如
果你创建一个要使用更多button的程序,你的程序就可能和平台有关. 这个问题在语
言中的解决方案出来之前,我们建议你就假设只有一个mouse button. 据此, 以下的
这一个程序, multiMouse.java, 现在只是用来检测第二和第三个mouse button的一
种不规范的方法:
import java.applet.*;
import java.awt.*;
public class multiMouse extends Applet {
public void init()
{
resize(400, 300);
}
public boolean mouseDown(Event evt, int x, int y)
{
if ((evt.modifiers & Event.ALT_MASK) > 0)
System.out.println("mouseDown: middle button");
else if ((evt.modifiers & Event.META_MASK) > 0)
System.out.println("mouseDown: right button");
else
System.out.println("mouseDown: left button");
return(true);
}
}
As you can see, the program detects the other mouse buttons by checking the
modifier keys. Currently, the other mouse buttons are equivalent to a
standard mouse click with a modifier key pressed. Remember, however, these
techniques may not work in future versions of Java.
你可看到,程序检测其它的mouse button 是利用了modifier键. 这里,其它的mouse
button等价为点击mouse同时按下了一个modifier键. 但要记住, 这些方法在今后的
Java版本中可能不使用.
413 Using mouseEnter and mouseExit
413 使用mouseEnter和mouseExit
You have learned that your applets can handle mouseMove events when a user
moves a mouse around the screen. Within your programs, you can use the
event coordinates to manually check when a mouse enters a window or
control. However, Java has two functions that can do this for you:
mouseEnter and mouseExit. Java calls the mouseEnter when a mouse enters a
component. Likewise, Java calls the mouseExit when the mouse leaves that
component. For example, you might use these methods to display a pop-up
help message that tells a user about a particular control or button. The
following program, mouseEnterExit.java, demonstrates how your programs can
detect when a mouse enters and leaves an applet window:
你已知道了,当用户利用mouse在屏幕上移动mouse光标时,你的应用程序是怎样来处理
mouseMove事件的. 在你的程序中,你可以利用mouse事件的坐标来检测一个mouse是进
入一个窗口或者是一个控制对象图标. 但是,Java有两个供你使用的功能:mouseEnter
和 mouseExit. Java在mouse进入某一成员范围时调用mouseEnter,同样, Java在mouse
离开某一成员范围时调用了mouseExit. 例如,你可以用这些方法来显示一个弹出式消
息,告诉用户有关的特殊控制或按钮. 以下的mouseEnterExit.java程序说明了你的程
序怎样来检测mouse何时进入/退出一个应用程序窗口:
import java.awt.*;
import java.applet.*;
public class mouseEnterExit extends Applet {
public boolean mouseEnter(Event evt, int x, int y)
{
System.out.println("mouseEnter");
return(true);
}
public boolean mouseExit(Event evt, int x, int y)
{
System.out.println("mouseExit");
return(true);
}
}
The first message will cause the status window (the window that displays
the message "mouseEnter") to be in front of the applet. For the mouseEnter
and mouseExit methods to work, you must click the applet so that it becomes
the front-most window.
这里的第一个消息将使状态窗口(显示消息"mouseEnter"的窗口)变为应用程序的front
窗口. 为使mouseEnter 和 mouseExit 方法工作,你必须点击你的应用程序,使它成为
最前端的那个窗口.
414 Understanding Keyboard Events
414 了解键盘事件
In the previous tips, you learned about the events that are generated by
the mouse. As you will learn, another set of important events is generated
from the keyboard. When Java generates a keyboard event, it passes an Event
object that contains information about the key pressed. Java recognizes
normal keys, modifier keys, and special keys. For normal keys, the event
object contains the keys ASCII value. For the function, arrow, and other
special keys, there are no ASCII codes, so Java uses special Java-defined
codes. In Tip 411, you learned how to detect modifier keys. The modifier
keys are stored in the modifiers variable in the Event object. The
following tips describe how to handle various keyboard events.
在以上的TIP中,你已知道了由mouse生成的有关事件. 你将会了解, 另一类重要的事件
是由键盘产生的.当Java产生一键盘事件时,它传递了包含有关按下键信息的事件对象.
Java将辨识出所按的一般的键还是修饰键,或者还是特殊键. 对于功能键,光标移动用
的箭头键,以及另一些特殊键,它们是没有自己的ASCII码的,所以Java使用了由自己定
义的专用代码. 在TIP 411中你将知道怎样检测修饰键. 修饰键存储在Event对象的修
饰字变量(modifiers variable)中. 以下的TIPS描述了怎样处理各种键盘事件.
415 Using the keyDown Method
415 使用键盘事件
As you have learned, Java provides convenience methods that make capturing
mouse events easy. For example, when the user holds down the mouse button,
Java will call the mouseDown method. Similarly, when the user presses a
keyboard key, Java will call the keyDown convenience method. The arguments
to the keyDown method are the Event object and a key code. The following
program, keyDownApplet.java, demonstrates how to capture key strokes and
display them within the status window:
正如你所了解的那样,Java提供的convenience方法使得事件的捕捉变得容易. 例如,
用户按下mouse键时,Java将调用mouseDown方法. 类似地,当用户按键盘上的键时,
Java将调用keyDown方法. keyDown方法的自变量是Event对象和所按键的代码. 以下
keyDownApplet.java程序说明了捕捉按键并将它们显示在状态窗口中:
import java.applet.*;
import java.awt.*;
public class keyDownApplet extends Applet {
public boolean keyDown(Event evt, int code)
{
System.out.println("keyDown:" + (char)code);
return(true);
}
}
416 Using the keyUp Method
416 使用keyUp方法
As you have learned, Java provides separate events for mouse-down and
mouse-up operations. Thus, it should not surprise you that Java provides
separate events for key-down and key-up operations. When the user releases
a keyboard key, Java calls the keyUp convenience method. The arguments to
the keyUp method are the Event object and a key code. The following
program, keyUpApplet.java, demonstrates how to detect a key up event:
正如你所了解的那样,Java为mouse-down和mouse-up操作独立地提供了事件. 因此,你
也不会奇怪Java为key-down和key-up操作提供两类不同的事件. 当用户释放某个键时,
Java调用了key-Up convenience 方法. key-Up方法的自变量是Event对象和所按键的
代码. 以下keyUpApplet.java程序说明了怎样检测按键的释放事件:
import java.applet.*;
import java.awt.*;
public class keyUpApplet extends Applet {
public boolean keyDown(Event evt, int code)
{
System.out.println("keyDown:" + (char) code);
return(true);
}
public boolean keyUp(Event evt, int code)
{
System.out.println("keyUp:" + (char) code);
return(true);
}
}
417 Detecting Multiple Modifier Keys
417 检测多重变动键
In Tip 414, you learned that Java supports three types of keyboard
characters. The first type are normal keys, which you learned to handle in
the previous two tips. Another type of keys are the modifier keys. In Tip
415, you learned how to detect if the user has pressed a modifier key
during a mouse click. Now, you will learn how to detect if multiple
modifier keys were pressed at the same time.
在TIP 414中,你已知道了Java支持三种类型的键盘字符. 第一种类型是正常的键,这
一种类型你已在前两个TIP中学过了. 另一种类型的键是修饰键,TIP 415中你已学过
了怎样检测用户在击mouse键时按下了一个修饰键. 现在,你将学到怎样检测用户是否
同时按下多个修饰键.
The Event class modifiers variable is a bit field that lets a variable
contain multiple flags. Within the modifiers variable, Java sets one bit
for each of the Shift, Ctrl, and Alt keys. Within your program, you can
test which modifiers are set by performing a bitwise AND operation of the
modifier constant and the modifiers variable. The following program,
multipleModifier.java, demonstrates how to detect the Shift and Ctrl
modifier keys when a normal key has been pressed:
Event类的modifiers(修饰键)变量是一个bit域,这样在一个变量中可容纳多个标记.
在modifiers变量中,Java为Shift, Ctrl 和 Alt三个键分别设置一个bit. 在你的程
序中,你可以对modifiers变量和modifiers常量实行按位乘(AND)操作,来检侧哪一个
modifiers(修饰键)被设置了. 以下的程序multipleModifier.java说明怎样来检测
用户在按正常键的同时也按下了Shift和Ctrl修饰键:
import java.applet.*;
import java.awt.*;
public class mutitipleModifier extends Applet {
public void init()
{
resize(400, 300);
}
public boolean keyDown(Event evt, int key)
{
if (((evt.modifiers & Event.SHIFT_MASK) > 0) &&
((evt.modifiers & Event.CTRL_MASK) > 0))
System.out.println("SHIFT and CTRL pressed");
return(true);
}
}
418 An Alternative Way to Detect Keyboard Modifier Keys
418 检测键盘变动键的另一种方法
In the previous tip, you learned how to detect keyboard modifier keys by
examining the Event class modifiers variable. An alternative way to check
for modifier keys is to use the methods built into the Event class:
controlDown, metaDown, or shiftDown. You can use these methods instead of
performing a bitwise AND operation of the modifier constants with the
modifiers variable. The following program, altModifierKey.java,
demonstrates how to check for modifier keys using the built-in Event class
methods:
在以上的TIP中,你已知道了怎样利用查看事件类modifier变量的办法来检测键盘的修
饰键. 检测修饰键的另一中办法是在Event类中建立的controlDown, metaDown, 或
shiftDown三种方法. 你可使用这些方法来代替modifiers变量和modifiers常量之间
的按位乘操作. 以下的程序altModifierKey.java说明怎样利用内建的Evenr类方法,来
检测修饰键:
import java.applet.*;
import java.awt.*;
public class altModifierKey extends Applet {
public void init()
{
resize(400, 300);
}
public boolean keyDown(Event evt, int key)
{
if (evt.controlDown() && evt.shiftDown())
System.out.println("SHIFT and CTRL pressed");
return(true);
}
}
419 Detecting Special Keys
419 检测特殊键
You have learned how to detect normal and modifier keys. For special keys,
such as the keyboard arrow and function keys, you must check the key code
like you did for normal keys. However, instead of using the ASCII codes,
you use the special key constants defined in the Event class. Table 419
lists the Event class special key constants .
你已知道了怎样来检测用户按的正常键和修饰键. 对于键盘上的箭头键和功能键之类
的特殊键,你必须象检测正常键那样地来查看它们的代码. 但是,你可以不直接使用它
们的ASCII码,而改用由Event类定义的特殊键常量. 表419列出了Event类定义的特殊
键常量.
Special Keys Description
F1, F2, F3, F4, F5, F6
Function keys
F7, F8, F9, F10, F11, F12
Function keys
Left, Right
Left and right arrow keys
Up, Down
Up and down arrow keys
Home, End
Home and End keys
PgUp, PgDown
PageUp and PageDown keys
Table 419 Event class key constants.
表419 Event类定义的特殊键常量
The following program, testApplet.java, demonstrates how to detect special
keys.
以下的程序testApplet.java, 说明了怎样检测特殊键:
import java.applet.*;
import java.awt.*;
public class testApplet extends Applet {
public void init()
{
resize(400, 300);
}
public boolean keyDown(Event evt, int key)
{
switch (key) {
case Event.UP: System.out.println("Up arrow");
break;
case Event.DOWN: System.out.println("Down arrow");
break;
case Event.LEFT: System.out.println("Left arrow");
break;
case Event.RIGHT: System.out.println("Right arrow");
break;
}
return(true);
}
}
相关文章推荐
- 《Java 编程技巧1001条》第418条:检测多个修饰键的另一方法
- 《Java 编程技巧1001条》第417条: 检测多个修饰键
- 《Java 编程技巧1001条》 第408条: 使用mouseMove方法,
- 《Java 编程技巧1001条》 第407条:使用mouseDrag方法,
- 《Java 编程技巧1001条》第419条:检测专用键
- 《Java 编程技巧1001条》 第423条: 检测窗口何时已图标化(Iconified)
- 《Java 编程技巧1001条》第409...条: 使用crickCount方法,
- 《Java 编程技巧1001条》 第411条: 检测鼠标单击修饰键,
- 《Java 编程技巧1001条》 第404条: 了解实用方法
- 《Java 编程技巧1001条》第415条:使用keyDown方法
- 《Java 编程技巧1001条》 第420...条: 使用handle event 方法
- 《Java 编程技巧1001条》 第406条: 使用mouseUp方法
- 《Java 编程技巧1001条》第416条:使用keyUp方法
- 《Java 编程技巧1001条》 第405条: 使用mouseDoun方法
- 《Java 编程技巧1001条》第402-406条: 了解事件驱动程序,
- 《Java 编程技巧1001条》 第395与396条 :了解和使用冒泡排序
- 《Java 编程技巧1001条》第401条:数组中存不同对象
- 《Java 编程技巧1001条》 第386条: 声明多维数组
- 《Java 编程技巧1001条》 第400条: 使用数组复制
- 《Java 编程技巧1001条》 第387条: 建立多维数组