| /* |
| * Copyright 2005-2007 Sun Microsystems, Inc. All Rights Reserved. |
| * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. |
| * |
| * This code is free software; you can redistribute it and/or modify it |
| * under the terms of the GNU General Public License version 2 only, as |
| * published by the Free Software Foundation. Sun designates this |
| * particular file as subject to the "Classpath" exception as provided |
| * by Sun in the LICENSE file that accompanied this code. |
| * |
| * This code is distributed in the hope that it will be useful, but WITHOUT |
| * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or |
| * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License |
| * version 2 for more details (a copy is included in the LICENSE file that |
| * accompanied this code). |
| * |
| * You should have received a copy of the GNU General Public License version |
| * 2 along with this work; if not, write to the Free Software Foundation, |
| * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. |
| * |
| * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara, |
| * CA 95054 USA or visit www.sun.com if you need additional information or |
| * have any questions. |
| */ |
| |
| package sun.awt.X11; |
| |
| import java.awt.*; |
| import java.awt.event.*; |
| import java.awt.peer.TrayIconPeer; |
| import sun.awt.*; |
| import java.awt.image.*; |
| import java.text.BreakIterator; |
| import java.util.Vector; |
| import java.lang.reflect.Field; |
| import java.util.logging.Logger; |
| import java.util.logging.Level; |
| import java.util.AbstractQueue; |
| import java.util.concurrent.ArrayBlockingQueue; |
| import java.security.AccessController; |
| import java.security.PrivilegedAction; |
| import java.lang.reflect.InvocationTargetException; |
| |
| public class XTrayIconPeer implements TrayIconPeer { |
| private static final Logger ctrLog = Logger.getLogger("sun.awt.X11.XTrayIconPeer.centering"); |
| |
| TrayIcon target; |
| TrayIconEventProxy eventProxy; |
| XTrayIconEmbeddedFrame eframe; |
| TrayIconCanvas canvas; |
| Balloon balloon; |
| Tooltip tooltip; |
| PopupMenu popup; |
| String tooltipString; |
| boolean isTrayIconDisplayed; |
| long eframeParentID; |
| final XEventDispatcher parentXED, eframeXED; |
| |
| static final XEventDispatcher dummyXED = new XEventDispatcher() { |
| public void dispatchEvent(XEvent ev) {} |
| }; |
| |
| volatile boolean isDisposed; |
| |
| boolean isParentWindowLocated; |
| int old_x, old_y; |
| int ex_width, ex_height; |
| |
| final static int TRAY_ICON_WIDTH = 24; |
| final static int TRAY_ICON_HEIGHT = 24; |
| |
| XTrayIconPeer(TrayIcon target) |
| throws AWTException |
| { |
| this.target = target; |
| |
| eventProxy = new TrayIconEventProxy(this); |
| |
| canvas = new TrayIconCanvas(target, TRAY_ICON_WIDTH, TRAY_ICON_HEIGHT); |
| |
| eframe = new XTrayIconEmbeddedFrame(); |
| |
| eframe.setSize(TRAY_ICON_WIDTH, TRAY_ICON_HEIGHT); |
| eframe.add(canvas); |
| |
| // Fix for 6317038: as EmbeddedFrame is instance of Frame, it is blocked |
| // by modal dialogs, but in the case of TrayIcon it shouldn't. So we |
| // set ModalExclusion property on it. |
| AccessController.doPrivileged(new PrivilegedAction() { |
| public Object run() { |
| eframe.setModalExclusionType(Dialog.ModalExclusionType.TOOLKIT_EXCLUDE); |
| return null; |
| } |
| }); |
| |
| |
| if (XWM.getWMID() != XWM.METACITY_WM) { |
| parentXED = dummyXED; // We don't like to leave it 'null'. |
| |
| } else { |
| parentXED = new XEventDispatcher() { |
| // It's executed under AWTLock. |
| public void dispatchEvent(XEvent ev) { |
| if (isDisposed() || ev.get_type() != XlibWrapper.ConfigureNotify) { |
| return; |
| } |
| |
| XConfigureEvent ce = ev.get_xconfigure(); |
| |
| ctrLog.log(Level.FINE, "ConfigureNotify on parent of {0}: {1}x{2}+{3}+{4} (old: {5}+{6})", |
| new Object[] { XTrayIconPeer.this, ce.get_width(), ce.get_height(), |
| ce.get_x(), ce.get_y(), old_x, old_y }); |
| |
| // A workaround for Gnome/Metacity (it doesn't affect the behaviour on KDE). |
| // On Metacity the EmbeddedFrame's parent window bounds are larger |
| // than TrayIcon size required (that is we need a square but a rectangle |
| // is provided by the Panel Notification Area). The parent's background color |
| // differs from the Panel's one. To hide the background we resize parent |
| // window so that it fits the EmbeddedFrame. |
| // However due to resizing the parent window it loses centering in the Panel. |
| // We center it when discovering that some of its side is of size greater |
| // than the fixed value. Centering is being done by "X" (when the parent's width |
| // is greater) and by "Y" (when the parent's height is greater). |
| |
| // Actually we need this workaround until we could detect taskbar color. |
| |
| if (ce.get_height() != TRAY_ICON_HEIGHT && ce.get_width() != TRAY_ICON_WIDTH) { |
| |
| // If both the height and the width differ from the fixed size then WM |
| // must level at least one side to the fixed size. For some reason it may take |
| // a few hops (even after reparenting) and we have to skip the intermediate ones. |
| ctrLog.log(Level.FINE, "ConfigureNotify on parent of {0}. Skipping as intermediate resizing.", |
| XTrayIconPeer.this); |
| return; |
| |
| } else if (ce.get_height() > TRAY_ICON_HEIGHT) { |
| |
| ctrLog.log(Level.FINE, "ConfigureNotify on parent of {0}. Centering by \"Y\".", |
| XTrayIconPeer.this); |
| |
| XlibWrapper.XMoveResizeWindow(XToolkit.getDisplay(), eframeParentID, |
| ce.get_x(), |
| ce.get_y()+ce.get_height()/2-TRAY_ICON_HEIGHT/2, |
| TRAY_ICON_WIDTH, |
| TRAY_ICON_HEIGHT); |
| ex_height = ce.get_height(); |
| ex_width = 0; |
| |
| } else if (ce.get_width() > TRAY_ICON_WIDTH) { |
| |
| ctrLog.log(Level.FINE, "ConfigureNotify on parent of {0}. Centering by \"X\".", |
| XTrayIconPeer.this); |
| |
| XlibWrapper.XMoveResizeWindow(XToolkit.getDisplay(), eframeParentID, |
| ce.get_x()+ce.get_width()/2 - TRAY_ICON_WIDTH/2, |
| ce.get_y(), |
| TRAY_ICON_WIDTH, |
| TRAY_ICON_HEIGHT); |
| ex_width = ce.get_width(); |
| ex_height = 0; |
| |
| } else if (isParentWindowLocated && ce.get_x() != old_x && ce.get_y() != old_y) { |
| // If moving by both "X" and "Y". |
| // When some tray icon gets removed from the tray, a Java icon may be repositioned. |
| // In this case the parent window also lose centering. We have to restore it. |
| |
| if (ex_height != 0) { |
| |
| ctrLog.log(Level.FINE, "ConfigureNotify on parent of {0}. Move detected. Centering by \"Y\".", |
| XTrayIconPeer.this); |
| |
| XlibWrapper.XMoveWindow(XToolkit.getDisplay(), eframeParentID, |
| ce.get_x(), |
| ce.get_y() + ex_height/2 - TRAY_ICON_HEIGHT/2); |
| |
| } else if (ex_width != 0) { |
| |
| ctrLog.log(Level.FINE, "ConfigureNotify on parent of {0}. Move detected. Centering by \"X\".", |
| XTrayIconPeer.this); |
| |
| XlibWrapper.XMoveWindow(XToolkit.getDisplay(), eframeParentID, |
| ce.get_x() + ex_width/2 - TRAY_ICON_WIDTH/2, |
| ce.get_y()); |
| } else { |
| ctrLog.log(Level.FINE, "ConfigureNotify on parent of {0}. Move detected. Skipping.", |
| XTrayIconPeer.this); |
| } |
| } |
| old_x = ce.get_x(); |
| old_y = ce.get_y(); |
| isParentWindowLocated = true; |
| } |
| }; |
| } |
| eframeXED = new XEventDispatcher() { |
| // It's executed under AWTLock. |
| XTrayIconPeer xtiPeer = XTrayIconPeer.this; |
| |
| public void dispatchEvent(XEvent ev) { |
| if (isDisposed() || ev.get_type() != XlibWrapper.ReparentNotify) { |
| return; |
| } |
| |
| XReparentEvent re = ev.get_xreparent(); |
| eframeParentID = re.get_parent(); |
| |
| if (eframeParentID == XToolkit.getDefaultRootWindow()) { |
| |
| if (isTrayIconDisplayed) { // most likely Notification Area was removed |
| SunToolkit.executeOnEventHandlerThread(xtiPeer.target, new Runnable() { |
| public void run() { |
| SystemTray.getSystemTray().remove(xtiPeer.target); |
| } |
| }); |
| } |
| return; |
| } |
| |
| if (!isTrayIconDisplayed) { |
| addXED(eframeParentID, parentXED, XlibWrapper.StructureNotifyMask); |
| |
| isTrayIconDisplayed = true; |
| XToolkit.awtLockNotifyAll(); |
| } |
| } |
| }; |
| |
| addXED(getWindow(), eframeXED, XlibWrapper.StructureNotifyMask); |
| |
| XSystemTrayPeer.getPeerInstance().addTrayIcon(this); // throws AWTException |
| |
| // Wait till the EmbeddedFrame is reparented |
| long start = System.currentTimeMillis(); |
| final long PERIOD = 2000L; |
| XToolkit.awtLock(); |
| try { |
| while (!isTrayIconDisplayed) { |
| try { |
| XToolkit.awtLockWait(PERIOD); |
| } catch (InterruptedException e) { |
| break; |
| } |
| if (System.currentTimeMillis() - start > PERIOD) { |
| break; |
| } |
| } |
| } finally { |
| XToolkit.awtUnlock(); |
| } |
| |
| // This is unlikely to happen. |
| if (!isTrayIconDisplayed || eframeParentID == 0 || |
| eframeParentID == XToolkit.getDefaultRootWindow()) |
| { |
| throw new AWTException("TrayIcon couldn't be displayed."); |
| } |
| |
| eframe.setVisible(true); |
| updateImage(); |
| |
| balloon = new Balloon(this, eframe); |
| tooltip = new Tooltip(this, eframe); |
| |
| addListeners(); |
| } |
| |
| public void dispose() { |
| if (SunToolkit.isDispatchThreadForAppContext(target)) { |
| disposeOnEDT(); |
| } else { |
| try { |
| SunToolkit.executeOnEDTAndWait(target, new Runnable() { |
| public void run() { |
| disposeOnEDT(); |
| } |
| }); |
| } catch (InterruptedException ie) { |
| } catch (InvocationTargetException ite) {} |
| } |
| } |
| |
| private void disposeOnEDT() { |
| // All actions that is to be synchronized with disposal |
| // should be executed either under AWTLock, or on EDT. |
| // isDisposed value must be checked. |
| XToolkit.awtLock(); |
| isDisposed = true; |
| XToolkit.awtUnlock(); |
| |
| removeXED(getWindow(), eframeXED); |
| removeXED(eframeParentID, parentXED); |
| eframe.realDispose(); |
| balloon.dispose(); |
| isTrayIconDisplayed = false; |
| XToolkit.targetDisposedPeer(target, this); |
| } |
| |
| public static void suppressWarningString(Window w) { |
| WindowAccessor.setTrayIconWindow(w, true); |
| } |
| |
| public void setToolTip(String tooltip) { |
| tooltipString = tooltip; |
| } |
| |
| public void updateImage() { |
| Runnable r = new Runnable() { |
| public void run() { |
| canvas.updateImage(target.getImage()); |
| } |
| }; |
| |
| if (!SunToolkit.isDispatchThreadForAppContext(target)) { |
| SunToolkit.executeOnEventHandlerThread(target, r); |
| } else { |
| r.run(); |
| } |
| } |
| |
| public void displayMessage(String caption, String text, String messageType) { |
| Point loc = getLocationOnScreen(); |
| Rectangle screen = eframe.getGraphicsConfiguration().getBounds(); |
| |
| // Check if the tray icon is in the bounds of a screen. |
| if (!(loc.x < screen.x || loc.x >= screen.x + screen.width || |
| loc.y < screen.y || loc.y >= screen.y + screen.height)) |
| { |
| balloon.display(caption, text, messageType); |
| } |
| } |
| |
| // It's synchronized with disposal by EDT. |
| public void showPopupMenu(int x, int y) { |
| if (isDisposed()) |
| return; |
| |
| assert SunToolkit.isDispatchThreadForAppContext(target); |
| |
| PopupMenu newPopup = target.getPopupMenu(); |
| if (popup != newPopup) { |
| if (popup != null) { |
| eframe.remove(popup); |
| } |
| if (newPopup != null) { |
| eframe.add(newPopup); |
| } |
| popup = newPopup; |
| } |
| |
| if (popup != null) { |
| Point loc = ((XBaseWindow)eframe.getPeer()).toLocal(new Point(x, y)); |
| popup.show(eframe, loc.x, loc.y); |
| } |
| } |
| |
| |
| // ****************************************************************** |
| // ****************************************************************** |
| |
| |
| private void addXED(long window, XEventDispatcher xed, long mask) { |
| if (window == 0) { |
| return; |
| } |
| XToolkit.awtLock(); |
| try { |
| XlibWrapper.XSelectInput(XToolkit.getDisplay(), window, mask); |
| } finally { |
| XToolkit.awtUnlock(); |
| } |
| XToolkit.addEventDispatcher(window, xed); |
| } |
| |
| private void removeXED(long window, XEventDispatcher xed) { |
| if (window == 0) { |
| return; |
| } |
| XToolkit.awtLock(); |
| try { |
| XToolkit.removeEventDispatcher(window, xed); |
| } finally { |
| XToolkit.awtUnlock(); |
| } |
| } |
| |
| // Private method for testing purposes. |
| private Point getLocationOnScreen() { |
| return eframe.getLocationOnScreen(); |
| } |
| |
| private Rectangle getBounds() { |
| Point loc = getLocationOnScreen(); |
| return new Rectangle(loc.x, loc.y, loc.x + TRAY_ICON_WIDTH, loc.y + TRAY_ICON_HEIGHT); |
| } |
| |
| void addListeners() { |
| canvas.addMouseListener(eventProxy); |
| canvas.addMouseMotionListener(eventProxy); |
| } |
| |
| long getWindow() { |
| return ((XEmbeddedFramePeer)eframe.getPeer()).getWindow(); |
| } |
| |
| boolean isDisposed() { |
| return isDisposed; |
| } |
| |
| static class TrayIconEventProxy implements MouseListener, MouseMotionListener { |
| XTrayIconPeer xtiPeer; |
| |
| TrayIconEventProxy(XTrayIconPeer xtiPeer) { |
| this.xtiPeer = xtiPeer; |
| } |
| |
| public void handleEvent(MouseEvent e) { |
| //prevent DRAG events from being posted with TrayIcon source(CR 6565779) |
| if (e.getID() == MouseEvent.MOUSE_DRAGGED) { |
| return; |
| } |
| |
| // Event handling is synchronized with disposal by EDT. |
| if (xtiPeer.isDisposed()) { |
| return; |
| } |
| Point coord = XBaseWindow.toOtherWindow(xtiPeer.getWindow(), |
| XToolkit.getDefaultRootWindow(), |
| e.getX(), e.getY()); |
| |
| if (e.isPopupTrigger()) { |
| xtiPeer.showPopupMenu(coord.x, coord.y); |
| } |
| |
| e.translatePoint(coord.x - e.getX(), coord.y - e.getY()); |
| // This is a hack in order to set non-Component source to MouseEvent |
| // instance. |
| // In some cases this could lead to unpredictable result (e.g. when |
| // other class tries to cast source field to Component). |
| // We already filter DRAG events out (CR 6565779). |
| e.setSource(xtiPeer.target); |
| Toolkit.getDefaultToolkit().getSystemEventQueue().postEvent(e); |
| } |
| public void mouseClicked(MouseEvent e) { |
| if ((e.getClickCount() > 1 || xtiPeer.balloon.isVisible()) && |
| e.getButton() == MouseEvent.BUTTON1) |
| { |
| ActionEvent aev = new ActionEvent(xtiPeer.target, ActionEvent.ACTION_PERFORMED, |
| xtiPeer.target.getActionCommand(), e.getWhen(), |
| e.getModifiers()); |
| Toolkit.getDefaultToolkit().getSystemEventQueue().postEvent(aev); |
| } |
| if (xtiPeer.balloon.isVisible()) { |
| xtiPeer.balloon.hide(); |
| } |
| handleEvent(e); |
| } |
| public void mouseEntered(MouseEvent e) { |
| xtiPeer.tooltip.enter(); |
| handleEvent(e); |
| } |
| public void mouseExited(MouseEvent e) { |
| xtiPeer.tooltip.exit(); |
| handleEvent(e); |
| } |
| public void mousePressed(MouseEvent e) { |
| handleEvent(e); |
| } |
| public void mouseReleased(MouseEvent e) { |
| handleEvent(e); |
| } |
| public void mouseDragged(MouseEvent e) { |
| handleEvent(e); |
| } |
| public void mouseMoved(MouseEvent e) { |
| handleEvent(e); |
| } |
| } |
| |
| static boolean isTrayIconStuffWindow(Window w) { |
| return (w instanceof Tooltip) || |
| (w instanceof Balloon) || |
| (w instanceof XTrayIconEmbeddedFrame); |
| } |
| |
| // *************************************** |
| // Special embedded frame for tray icon |
| // *************************************** |
| |
| private static class XTrayIconEmbeddedFrame extends XEmbeddedFrame { |
| public XTrayIconEmbeddedFrame(){ |
| super(XToolkit.getDefaultRootWindow(), true, true); |
| } |
| |
| public boolean isUndecorated() { |
| return true; |
| } |
| |
| public boolean isResizable() { |
| return false; |
| } |
| |
| // embedded frame for tray icon shouldn't be disposed by anyone except tray icon |
| public void dispose(){ |
| } |
| |
| public void realDispose(){ |
| super.dispose(); |
| } |
| }; |
| |
| // *************************************** |
| // Classes for painting an image on canvas |
| // *************************************** |
| |
| static class TrayIconCanvas extends IconCanvas { |
| TrayIcon target; |
| boolean autosize; |
| |
| TrayIconCanvas(TrayIcon target, int width, int height) { |
| super(width, height); |
| this.target = target; |
| } |
| |
| // Invoke on EDT. |
| protected void repaintImage(boolean doClear) { |
| boolean old_autosize = autosize; |
| autosize = target.isImageAutoSize(); |
| |
| curW = autosize ? width : image.getWidth(observer); |
| curH = autosize ? height : image.getHeight(observer); |
| |
| super.repaintImage(doClear || (old_autosize != autosize)); |
| } |
| } |
| |
| static class IconCanvas extends Canvas { |
| volatile Image image; |
| IconObserver observer; |
| int width, height; |
| int curW, curH; |
| |
| IconCanvas(int width, int height) { |
| this.width = curW = width; |
| this.height = curH = height; |
| } |
| |
| // Invoke on EDT. |
| public void updateImage(Image image) { |
| this.image = image; |
| if (observer == null) { |
| observer = new IconObserver(); |
| } |
| repaintImage(true); |
| } |
| |
| // Invoke on EDT. |
| protected void repaintImage(boolean doClear) { |
| Graphics g = getGraphics(); |
| if (g != null) { |
| try { |
| if (isVisible()) { |
| if (doClear) { |
| update(g); |
| } else { |
| paint(g); |
| } |
| } |
| } finally { |
| g.dispose(); |
| } |
| } |
| } |
| |
| // Invoke on EDT. |
| public void paint(Graphics g) { |
| if (g != null && curW > 0 && curH > 0) { |
| BufferedImage bufImage = new BufferedImage(curW, curH, BufferedImage.TYPE_INT_ARGB); |
| Graphics2D gr = bufImage.createGraphics(); |
| if (gr != null) { |
| try { |
| gr.setColor(getBackground()); |
| gr.fillRect(0, 0, curW, curH); |
| gr.drawImage(image, 0, 0, curW, curH, observer); |
| gr.dispose(); |
| |
| g.drawImage(bufImage, 0, 0, curW, curH, null); |
| } finally { |
| gr.dispose(); |
| } |
| } |
| } |
| } |
| |
| class IconObserver implements ImageObserver { |
| public boolean imageUpdate(final Image image, final int flags, int x, int y, int width, int height) { |
| if (image != IconCanvas.this.image || // if the image has been changed |
| !IconCanvas.this.isVisible()) |
| { |
| return false; |
| } |
| if ((flags & (ImageObserver.FRAMEBITS | ImageObserver.ALLBITS | |
| ImageObserver.WIDTH | ImageObserver.HEIGHT)) != 0) |
| { |
| SunToolkit.executeOnEventHandlerThread(IconCanvas.this, new Runnable() { |
| public void run() { |
| repaintImage(false); |
| } |
| }); |
| } |
| return (flags & ImageObserver.ALLBITS) == 0; |
| } |
| } |
| } |
| |
| // *************************************** |
| // Classes for toolitp and balloon windows |
| // *************************************** |
| |
| static class Tooltip extends InfoWindow { |
| XTrayIconPeer xtiPeer; |
| Label textLabel = new Label(""); |
| Runnable starter = new Runnable() { |
| public void run() { |
| display(); |
| }}; |
| |
| final static int TOOLTIP_SHOW_TIME = 10000; |
| final static int TOOLTIP_START_DELAY_TIME = 1000; |
| final static int TOOLTIP_MAX_LENGTH = 64; |
| final static int TOOLTIP_MOUSE_CURSOR_INDENT = 5; |
| final static Color TOOLTIP_BACKGROUND_COLOR = new Color(255, 255, 220); |
| final static Font TOOLTIP_TEXT_FONT = XWindow.defaultFont; |
| |
| Tooltip(XTrayIconPeer xtiPeer, Frame parent) { |
| super(parent, Color.black); |
| this.xtiPeer = xtiPeer; |
| |
| suppressWarningString(this); |
| |
| setCloser(null, TOOLTIP_SHOW_TIME); |
| textLabel.setBackground(TOOLTIP_BACKGROUND_COLOR); |
| textLabel.setFont(TOOLTIP_TEXT_FONT); |
| add(textLabel); |
| } |
| |
| /* |
| * WARNING: this method is executed on Toolkit thread! |
| */ |
| void display() { |
| String tip = xtiPeer.tooltipString; |
| if (tip == null) { |
| return; |
| } else if (tip.length() > TOOLTIP_MAX_LENGTH) { |
| textLabel.setText(tip.substring(0, TOOLTIP_MAX_LENGTH)); |
| } else { |
| textLabel.setText(tip); |
| } |
| |
| // Execute on EDT to avoid deadlock (see 6280857). |
| SunToolkit.executeOnEventHandlerThread(xtiPeer.target, new Runnable() { |
| public void run() { |
| if (xtiPeer.isDisposed()) { |
| return; |
| } |
| Point pointer = (Point)AccessController.doPrivileged(new PrivilegedAction() { |
| public Object run() { |
| if (!isPointerOverTrayIcon(xtiPeer.getBounds())) { |
| return null; |
| } |
| return MouseInfo.getPointerInfo().getLocation(); |
| } |
| }); |
| if (pointer == null) { |
| return; |
| } |
| show(new Point(pointer.x, pointer.y), TOOLTIP_MOUSE_CURSOR_INDENT); |
| } |
| }); |
| } |
| |
| void enter() { |
| XToolkit.schedule(starter, TOOLTIP_START_DELAY_TIME); |
| } |
| |
| void exit() { |
| XToolkit.remove(starter); |
| if (isVisible()) { |
| hide(); |
| } |
| } |
| |
| boolean isPointerOverTrayIcon(Rectangle trayRect) { |
| Point p = MouseInfo.getPointerInfo().getLocation(); |
| return !(p.x < trayRect.x || p.x > (trayRect.x + trayRect.width) || |
| p.y < trayRect.y || p.y > (trayRect.y + trayRect.height)); |
| } |
| } |
| |
| static class Balloon extends InfoWindow { |
| final static int BALLOON_SHOW_TIME = 10000; |
| final static int BALLOON_TEXT_MAX_LENGTH = 256; |
| final static int BALLOON_WORD_LINE_MAX_LENGTH = 16; |
| final static int BALLOON_WORD_LINE_MAX_COUNT = 4; |
| final static int BALLOON_ICON_WIDTH = 32; |
| final static int BALLOON_ICON_HEIGHT = 32; |
| final static int BALLOON_TRAY_ICON_INDENT = 0; |
| final static Color BALLOON_CAPTION_BACKGROUND_COLOR = new Color(200, 200 ,255); |
| final static Font BALLOON_CAPTION_FONT = new Font(Font.DIALOG, Font.BOLD, 12); |
| |
| XTrayIconPeer xtiPeer; |
| Panel mainPanel = new Panel(); |
| Panel captionPanel = new Panel(); |
| Label captionLabel = new Label(""); |
| Button closeButton = new Button("X"); |
| Panel textPanel = new Panel(); |
| IconCanvas iconCanvas = new IconCanvas(BALLOON_ICON_WIDTH, BALLOON_ICON_HEIGHT); |
| Label[] lineLabels = new Label[BALLOON_WORD_LINE_MAX_COUNT]; |
| ActionPerformer ap = new ActionPerformer(); |
| |
| Image iconImage; |
| Image errorImage; |
| Image warnImage; |
| Image infoImage; |
| boolean gtkImagesLoaded; |
| |
| Displayer displayer = new Displayer(); |
| |
| Balloon(final XTrayIconPeer xtiPeer, Frame parent) { |
| super(parent, new Color(90, 80 ,190)); |
| this.xtiPeer = xtiPeer; |
| |
| suppressWarningString(this); |
| |
| setCloser(new Runnable() { |
| public void run() { |
| if (textPanel != null) { |
| textPanel.removeAll(); |
| textPanel.setSize(0, 0); |
| iconCanvas.setSize(0, 0); |
| XToolkit.awtLock(); |
| try { |
| displayer.isDisplayed = false; |
| XToolkit.awtLockNotifyAll(); |
| } finally { |
| XToolkit.awtUnlock(); |
| } |
| } |
| } |
| }, BALLOON_SHOW_TIME); |
| |
| add(mainPanel); |
| |
| captionLabel.setFont(BALLOON_CAPTION_FONT); |
| captionLabel.addMouseListener(ap); |
| |
| captionPanel.setLayout(new BorderLayout()); |
| captionPanel.add(captionLabel, BorderLayout.WEST); |
| captionPanel.add(closeButton, BorderLayout.EAST); |
| captionPanel.setBackground(BALLOON_CAPTION_BACKGROUND_COLOR); |
| captionPanel.addMouseListener(ap); |
| |
| closeButton.addActionListener(new ActionListener() { |
| public void actionPerformed(ActionEvent e) { |
| hide(); |
| } |
| }); |
| |
| mainPanel.setLayout(new BorderLayout()); |
| mainPanel.setBackground(Color.white); |
| mainPanel.add(captionPanel, BorderLayout.NORTH); |
| mainPanel.add(iconCanvas, BorderLayout.WEST); |
| mainPanel.add(textPanel, BorderLayout.CENTER); |
| |
| iconCanvas.addMouseListener(ap); |
| |
| for (int i = 0; i < BALLOON_WORD_LINE_MAX_COUNT; i++) { |
| lineLabels[i] = new Label(); |
| lineLabels[i].addMouseListener(ap); |
| lineLabels[i].setBackground(Color.white); |
| } |
| |
| displayer.start(); |
| } |
| |
| void display(String caption, String text, String messageType) { |
| if (!gtkImagesLoaded) { |
| loadGtkImages(); |
| } |
| displayer.display(caption, text, messageType); |
| } |
| |
| private void _display(String caption, String text, String messageType) { |
| captionLabel.setText(caption); |
| |
| BreakIterator iter = BreakIterator.getWordInstance(); |
| if (text != null) { |
| iter.setText(text); |
| int start = iter.first(), end; |
| int nLines = 0; |
| |
| do { |
| end = iter.next(); |
| |
| if (end == BreakIterator.DONE || |
| text.substring(start, end).length() >= 50) |
| { |
| lineLabels[nLines].setText(text.substring(start, end == BreakIterator.DONE ? |
| iter.last() : end)); |
| textPanel.add(lineLabels[nLines++]); |
| start = end; |
| } |
| if (nLines == BALLOON_WORD_LINE_MAX_COUNT) { |
| if (end != BreakIterator.DONE) { |
| lineLabels[nLines - 1].setText( |
| new String(lineLabels[nLines - 1].getText() + " ...")); |
| } |
| break; |
| } |
| } while (end != BreakIterator.DONE); |
| |
| |
| textPanel.setLayout(new GridLayout(nLines, 1)); |
| } |
| |
| if ("ERROR".equals(messageType)) { |
| iconImage = errorImage; |
| } else if ("WARNING".equals(messageType)) { |
| iconImage = warnImage; |
| } else if ("INFO".equals(messageType)) { |
| iconImage = infoImage; |
| } else { |
| iconImage = null; |
| } |
| |
| if (iconImage != null) { |
| Dimension tpSize = textPanel.getSize(); |
| iconCanvas.setSize(BALLOON_ICON_WIDTH, (BALLOON_ICON_HEIGHT > tpSize.height ? |
| BALLOON_ICON_HEIGHT : tpSize.height)); |
| } |
| |
| SunToolkit.executeOnEventHandlerThread(xtiPeer.target, new Runnable() { |
| public void run() { |
| if (xtiPeer.isDisposed()) { |
| return; |
| } |
| Point parLoc = getParent().getLocationOnScreen(); |
| Dimension parSize = getParent().getSize(); |
| show(new Point(parLoc.x + parSize.width/2, parLoc.y + parSize.height/2), |
| BALLOON_TRAY_ICON_INDENT); |
| if (iconImage != null) { |
| iconCanvas.updateImage(iconImage); // call it after the show(..) above |
| } |
| } |
| }); |
| } |
| |
| public void dispose() { |
| displayer.interrupt(); |
| super.dispose(); |
| } |
| |
| void loadGtkImages() { |
| if (!gtkImagesLoaded) { |
| errorImage = (Image)Toolkit.getDefaultToolkit().getDesktopProperty( |
| "gtk.icon.gtk-dialog-error.6.rtl"); |
| warnImage = (Image)Toolkit.getDefaultToolkit().getDesktopProperty( |
| "gtk.icon.gtk-dialog-warning.6.rtl"); |
| infoImage = (Image)Toolkit.getDefaultToolkit().getDesktopProperty( |
| "gtk.icon.gtk-dialog-info.6.rtl"); |
| gtkImagesLoaded = true; |
| } |
| } |
| |
| class ActionPerformer extends MouseAdapter { |
| public void mouseClicked(MouseEvent e) { |
| // hide the balloon by any click |
| hide(); |
| if (e.getButton() == MouseEvent.BUTTON1) { |
| ActionEvent aev = new ActionEvent(xtiPeer.target, ActionEvent.ACTION_PERFORMED, |
| xtiPeer.target.getActionCommand(), |
| e.getWhen(), e.getModifiers()); |
| Toolkit.getDefaultToolkit().getSystemEventQueue().postEvent(aev); |
| } |
| } |
| } |
| |
| class Displayer extends Thread { |
| final int MAX_CONCURRENT_MSGS = 10; |
| |
| ArrayBlockingQueue<Message> messageQueue = new ArrayBlockingQueue<Message>(MAX_CONCURRENT_MSGS); |
| boolean isDisplayed; |
| |
| Displayer() { |
| setDaemon(true); |
| } |
| |
| public void run() { |
| while (true) { |
| Message msg = null; |
| try { |
| msg = (Message)messageQueue.take(); |
| } catch (InterruptedException e) { |
| return; |
| } |
| |
| /* |
| * Wait till the previous message is displayed if any |
| */ |
| XToolkit.awtLock(); |
| try { |
| while (isDisplayed) { |
| try { |
| XToolkit.awtLockWait(); |
| } catch (InterruptedException e) { |
| return; |
| } |
| } |
| isDisplayed = true; |
| } finally { |
| XToolkit.awtUnlock(); |
| } |
| _display(msg.caption, msg.text, msg.messageType); |
| } |
| } |
| |
| void display(String caption, String text, String messageType) { |
| messageQueue.offer(new Message(caption, text, messageType)); |
| } |
| } |
| |
| class Message { |
| String caption, text, messageType; |
| |
| Message(String caption, String text, String messageType) { |
| this.caption = caption; |
| this.text = text; |
| this.messageType = messageType; |
| } |
| } |
| } |
| |
| static class InfoWindow extends Window { |
| Container container; |
| Closer closer; |
| |
| InfoWindow(Frame parent, Color borderColor) { |
| super(parent); |
| container = new Container() { |
| public Insets getInsets() { |
| return new Insets(1, 1, 1, 1); |
| } |
| }; |
| setLayout(new BorderLayout()); |
| setBackground(borderColor); |
| add(container, BorderLayout.CENTER); |
| container.setLayout(new BorderLayout()); |
| |
| closer = new Closer(); |
| } |
| |
| public Component add(Component c) { |
| container.add(c, BorderLayout.CENTER); |
| return c; |
| } |
| |
| void setCloser(Runnable action, int time) { |
| closer.set(action, time); |
| } |
| |
| // Must be executed on EDT. |
| protected void show(Point corner, int indent) { |
| assert SunToolkit.isDispatchThreadForAppContext(InfoWindow.this); |
| |
| pack(); |
| |
| Dimension size = getSize(); |
| // TODO: When 6356322 is fixed we should get screen bounds in |
| // this way: eframe.getGraphicsConfiguration().getBounds(). |
| Dimension scrSize = Toolkit.getDefaultToolkit().getScreenSize(); |
| |
| if (corner.x < scrSize.width/2 && corner.y < scrSize.height/2) { // 1st square |
| setLocation(corner.x + indent, corner.y + indent); |
| |
| } else if (corner.x >= scrSize.width/2 && corner.y < scrSize.height/2) { // 2nd square |
| setLocation(corner.x - indent - size.width, corner.y + indent); |
| |
| } else if (corner.x < scrSize.width/2 && corner.y >= scrSize.height/2) { // 3rd square |
| setLocation(corner.x + indent, corner.y - indent - size.height); |
| |
| } else if (corner.x >= scrSize.width/2 && corner.y >= scrSize.height/2) { // 4th square |
| setLocation(corner.x - indent - size.width, corner.y - indent - size.height); |
| } |
| |
| InfoWindow.super.show(); |
| InfoWindow.this.closer.schedule(); |
| } |
| |
| public void hide() { |
| closer.close(); |
| } |
| |
| class Closer implements Runnable { |
| Runnable action; |
| int time; |
| |
| public void run() { |
| doClose(); |
| } |
| |
| void set(Runnable action, int time) { |
| this.action = action; |
| this.time = time; |
| } |
| |
| void schedule() { |
| XToolkit.schedule(this, time); |
| } |
| |
| void close() { |
| XToolkit.remove(this); |
| doClose(); |
| } |
| |
| // WARNING: this method may be executed on Toolkit thread. |
| private void doClose() { |
| SunToolkit.executeOnEventHandlerThread(InfoWindow.this, new Runnable() { |
| public void run() { |
| InfoWindow.super.hide(); |
| invalidate(); |
| if (action != null) { |
| action.run(); |
| } |
| } |
| }); |
| } |
| } |
| } |
| } |