java隐藏窗口_java实现靠边隐藏窗口

import java.awt.BorderLayout;

import java.awt.Insets;

import java.awt.Point;

import javax.swing.JFrame;

import javax.swing.JLabel;

import javax.swing.JPanel;

/**

* @author qusic

*

*/

public class AutoHiddenFrame extends JFrame

{

private static final long serialVersionUID = 1L;

public static void main(String args[])

{

new AutoHiddenFrame();

}

public static final int NORMAL = 0;//窗体的普通状态

public static final int CANHIDD = 1;//窗体位于屏幕边缘,可以隐藏的状态

public static final int HIDDEN = 2;//窗体处于隐藏状态

private int state = NORMAL;//窗体的状态,让它初始化为普通状态

private Point hiddenPoint;//隐藏窗体时,窗体的位置

private Point visiblePoint;//窗体处于显示状态时的位置

private JLabel infoLabel;//用于显示信息的JLabel;

public AutoHiddenFrame()

{

JPanel p = new JPanel(new BorderLayout()) {

private static final long serialVersionUID = 1L;

public Insets getInsets()

{

return new Insets(3,3,3,3);

}

};

setContentPane(p);//替换掉原来的ContentPane,换上一个带有Insets的,至于为什么去看WindowMouseListener类

infoLabel = new JLabel();

add(infoLabel,BorderLayout.SOUTH);

setSize(300,200);

setDefaultCloseOperation(EXIT_ON_CLOSE);

setVisible(true);

new WindowLocationListener(this);

new WindowMouseListener(this);

WindowLocationListener.checkAutoHiddenState(this);//刚出来就检查一下窗体的位置

}

/**

* @param newState 新的状态

* 一定要是此类中定义的3中状态之一

*/

public void setStates(int newState)

{

if(newState == NORMAL || newState == CANHIDD || newState == HIDDEN)

{

state = newState;

}

}

/*

* 返回状态,注意此方法和setStates方法区别与JFrame中的setState()和getState()方法

*/

public int getStates()

{

return state;

}

/*

* 设置要显示时窗体的坐标

*/

public void setVisiblePoint(Point point)

{

visiblePoint = point;

}

/*

* 设置要隐藏是窗体的坐标

*/

public void setHiddenPoint(Point point)

{

hiddenPoint = point;

}

public void moveToVisible()

{

if(visiblePoint!=null)

{

WindowMover.moveToPoint(this, visiblePoint);

setStates(CANHIDD);

}

}

public void moveToHidden()

{

if(hiddenPoint!=null)

{

WindowMover.moveToPoint(this, hiddenPoint);

setStates(HIDDEN);

}

}

public void showInfo(String info)

{

infoLabel.setText(info);

}

public void clearInfo()

{

infoLabel.setText("");

}

}

import java.awt.Dimension;

import java.awt.Point;

import java.awt.Toolkit;

import java.awt.event.ComponentAdapter;

import java.awt.event.ComponentEvent;

public class WindowLocationListener extends ComponentAdapter {

public static final int HIDDEN_BOUND = 3; // 当窗体进入到屏幕边缘3像素以内就可以隐藏

public static final int VISIBLE_BOUND = 5; // 当窗体隐藏后要有5像素的部分露出来,不能完全隐藏

AutoHiddenFrame frame;

public WindowLocationListener(AutoHiddenFrame a) {

frame = a;

frame.addComponentListener(this);

}

public void componentMoved(ComponentEvent e) {

checkAutoHiddenState(frame);

// 当窗体移动就调用检查方法;

}

public static void checkAutoHiddenState(AutoHiddenFrame frame) {

// 当窗体状态不是隐藏的,再进行检查

if (frame.getStates() != AutoHiddenFrame.HIDDEN) {

// 首先获得屏幕的大小和窗体的坐标

Dimension screenSize = Toolkit.getDefaultToolkit().getScreenSize();

Point hiddenPoint = frame.getLocation();

Point visiblePoint = null;

boolean canhidden = false;

// 当窗体位于左边边缘

if (hiddenPoint.x <= HIDDEN_BOUND) {

hiddenPoint.move(VISIBLE_BOUND - frame.getWidth(),

hiddenPoint.y);

visiblePoint = new Point(0, hiddenPoint.y);

canhidden = true;

}

// 当窗体位于上边

else if (hiddenPoint.y <= HIDDEN_BOUND) {

hiddenPoint.setLocation(hiddenPoint.x, VISIBLE_BOUND

- frame.getHeight());

visiblePoint = new Point(hiddenPoint.x, 0);

canhidden = true;

}

// 当窗体位于右边

else if (hiddenPoint.x + frame.getWidth() >= screenSize.width

- HIDDEN_BOUND) {

hiddenPoint.setLocation(screenSize.width - VISIBLE_BOUND,

hiddenPoint.y);

visiblePoint = new Point(screenSize.width - frame.getWidth(),

hiddenPoint.y);

canhidden = true;

}

if (canhidden) {

// 如果符合以上几种情况的一种就可以隐藏

frame.setVisiblePoint(visiblePoint);

frame.setHiddenPoint(hiddenPoint);

frame.setStates(AutoHiddenFrame.CANHIDD);

frame.showInfo("进入可隐藏区域!");

} else {

// 如果不可以隐藏,那就是离开了边缘了

if (frame.getStates() == AutoHiddenFrame.CANHIDD) {

frame.showInfo("离开可应藏区域!");

}

frame.setVisiblePoint(frame.getLocation());

frame.setStates(AutoHiddenFrame.NORMAL);

}

}

}

}

import java.awt.Container;

import java.awt.MouseInfo;

import java.awt.Point;

import java.awt.event.ActionEvent;

import java.awt.event.ActionListener;

import java.awt.event.MouseAdapter;

import java.awt.event.MouseEvent;

import java.awt.event.WindowEvent;

import java.awt.event.WindowFocusListener;

import javax.swing.SwingUtilities;

import javax.swing.Timer;

public class WindowMouseListener extends MouseAdapter implements

ActionListener, WindowFocusListener {

private Timer timer;

private AutoHiddenFrame frame;

Container container;

public WindowMouseListener(AutoHiddenFrame a) {

frame = a;

container = frame.getContentPane();

container.addMouseListener(this);

// 注册鼠标侦听器到ContentPane上,因为我们可以加大它的Insets以提高鼠标进入和离开的灵敏度

frame.addWindowFocusListener(this);

// 注册一个焦点侦听器到窗体上

timer = new Timer(2000, this);

timer.setRepeats(false);

}

public void mouseEntered(MouseEvent e) {

// 当鼠标进入,就显示窗体

if (frame.getStates() == AutoHiddenFrame.HIDDEN) {

frame.moveToVisible();

} else {

frame.clearInfo();

}

}

public void mouseExited(MouseEvent e) {

// 当鼠标离开,启动计时器

if (frame.getStates() == AutoHiddenFrame.CANHIDD) {

if (!container.contains(e.getPoint())) {

frame.showInfo(timer.getDelay() / 1000 + "秒后自动隐藏窗口!");

// System.out.println("Mouse has exited the Dialog!");

timer.restart();

}

}

}

public void actionPerformed(ActionEvent e) {

// 计时器到期,检查鼠标是不是还在此窗体里面,不再的话,再开始隐藏

Point p = MouseInfo.getPointerInfo().getLocation();

SwingUtilities.convertPointFromScreen(p, container);

if (!container.contains(p)

&& frame.getStates() == AutoHiddenFrame.CANHIDD) {

frame.moveToHidden();

} else {

frame.clearInfo();

}

}

public void windowGainedFocus(WindowEvent e) {

// 得到焦点检查鼠标是不是在窗体上

Point p = MouseInfo.getPointerInfo().getLocation();

SwingUtilities.convertPointFromScreen(p, container);

if (container.contains(p)

&& frame.getStates() == AutoHiddenFrame.HIDDEN) {

frame.moveToVisible();

}

}

public void windowLostFocus(WindowEvent e) {

// 失去焦点,启动计时器

if (frame.getStates() == AutoHiddenFrame.CANHIDD) {

frame.showInfo("2秒后自动隐藏窗口!");

timer.restart();

}

}

}

import java.awt.Point;

import java.awt.event.ComponentListener;

import javax.swing.JFrame;

public class WindowMover extends Thread {

public static void moveToPoint(JFrame dialog, Point targetPoint) {

new WindowMover(dialog, targetPoint).start();

}

private static final int FRAMES = 15; // 最多移动多少动画帧

private JFrame window; // 要移动的窗口

private Point point; // 目的坐标

private int index; // 当前帧数

private int addedX; // 每次移动的X坐标增量

private int addedY; // 每次移动的Y坐标的增量

ComponentListener componentListeners[];// 组件侦听器数组

/*

* 定义私有的构造方法,应调用静态方法moveToPoint;

*/

private WindowMover(JFrame window, Point targetPoint) {

this.window = window;

window.getGlassPane().setVisible(true);

// 设置此窗体的GlassPane为显示的,以阻止子组件接收鼠标事件,减少事件触发

// 同样,移除此窗体上的组件侦听器,防止再次触发窗体移动事件

componentListeners = window.getComponentListeners();

for (ComponentListener cl : componentListeners) {

window.removeComponentListener(cl);

}

Point wl = window.getLocation();

point = targetPoint;

index = 0; // 初始化帧书为0;

// 计算每次移动量

addedX = (point.x - wl.x) / FRAMES;

if (addedX == 0 && point.x != wl.x) {

addedX = point.x < wl.x ? -1 : 1;

}

addedY = (point.y - wl.y) / FRAMES;

if (addedY == 0 && point.y != wl.y) {

addedY = point.y < wl.y ? -1 : 1;

}

}

public void run() {

if (window.getLocation().equals(point))

return;// 如果已在目的点，则返回

if (!window.isVisible())

return;// 如果窗口是不可视的则返回

while (index < FRAMES) {

Point p = window.getLocation();

if (p.x != point.x)

p.translate(addedX, 0);

if (p.y != point.y)

p.translate(0, addedY);

window.setLocation(p);

index++;

try {

Thread.sleep(15);

} catch (Exception e) {

}

}

window.setLocation(point);

// 还原所做的操作

window.getGlassPane().setVisible(false);

for (ComponentListener cl : componentListeners) {

window.addComponentListener(cl);

}

// 释放资源,使gc可以回收此对象

window = null;

point = null;

componentListeners = null;

System.out.println("finsh Moved");

}

}

分享到：

2009-05-03 10:25

浏览 4447

评论

1 楼

pcenshao

2010-08-06

lz 真厉害 很好的例子