闪烁托盘图标 [英] Blinking Tray Icon

查看:114
本文介绍了闪烁托盘图标的处理方法,对大家解决问题具有一定的参考价值,需要的朋友们下面随着小编来一起学习吧!

问题描述

我知道如何使用java在窗口的系统托盘中放置一个图标,但执行系统托盘图标闪烁的最佳方法是什么?或者如果我可以不时更换任何图标或某些事件(在应用程序运行时),
请提前分享您的经验

I know how to place an icon in window's systray using java, But what the best method to perform systray icon Blinking? or if I can replace any icon time to time or at some event (while the application is running), Kindly share your experiences thanks in advance

推荐答案


  • 在某些基础上更改图标没有问题,输出为闪烁图标

    • there no issue to change Icon on some bases with output as blinking Icon

      创建一个 BufferedImage数组队列

      启动 Swing Timer 关于所需事件并更改 BufferedImage 某些时期的图标

      start Swing Timer on desired event and change BufferedImage or Icons on some period

      并停止 Swing Timer 在保留一段时间后或将 ActionListener 添加到消息,另一种方法可以确定 LEFT RIGHT 鼠标按钮 MouseL istener (对于图标系统托盘中)一个用于停止计时器,第二个为 JPopup

      and to stop Swing Timer after some time remained or add ActionListener to the Message, another way could be determine LEFT or RIGHT mouse button from MouseListener ( for Icon in System Tray) one for stop of Timer, second for JPopup

      编辑

      例如,我提到你可以添加 ActionListener 或MouseListener,你可以在那里停止Swing Timer

      for example, as I mentioned you can add ActionListener or MouseListener, there you can to stop Swing Timer

      import java.awt.AWTException;
      import java.awt.Color;
      import java.awt.Component;
      import java.awt.Graphics;
      import java.awt.Graphics2D;
      import java.awt.GraphicsConfiguration;
      import java.awt.GraphicsDevice;
      import java.awt.GraphicsEnvironment;
      import java.awt.Image;
      import java.awt.MenuItem;
      import java.awt.PopupMenu;
      import java.awt.SystemTray;
      import java.awt.TrayIcon;
      import java.awt.event.ActionEvent;
      import java.awt.event.ActionListener;
      import java.awt.image.BufferedImage;
      import java.beans.PropertyChangeEvent;
      import java.beans.PropertyChangeListener;
      import java.util.logging.Level;
      import java.util.logging.Logger;
      import javax.swing.AbstractAction;
      import javax.swing.Action;
      import javax.swing.Icon;
      import javax.swing.ImageIcon;
      import javax.swing.SwingUtilities;
      import javax.swing.Timer;
      import javax.swing.UIManager;
      
      public class ActiveTray {
      
          private SystemTray tray;
          private TrayIcon trayIcon;
          private Icon icon, icon1;
          private Image image, image1;
          private Timer timer;
      
          public ActiveTray() {
              if (SystemTray.isSupported() == false) {
                  System.err.println("No system tray available");
                  return;
              }
              tray = SystemTray.getSystemTray();
              PropertyChangeListener propListener = new PropertyChangeListener() {
      
                  public void propertyChange(PropertyChangeEvent evt) {
                      TrayIcon oldTray[] = (TrayIcon[]) evt.getOldValue();
                      TrayIcon newTray[] = (TrayIcon[]) evt.getNewValue();
                      System.out.println(oldTray.length + " / " + newTray.length);
                  }
              };
              tray.addPropertyChangeListener("trayIcons", propListener);
              icon = new BevelArrowIcon(BevelArrowIcon.UP, false, false);
              image = iconToImage(icon);
              icon1 = new BevelArrowIcon(BevelArrowIcon.DOWN, false, false);
              image1 = iconToImage(icon1);
              PopupMenu popup = new PopupMenu();
              MenuItem item = new MenuItem("Hello, World");
              trayIcon = new TrayIcon(image, "Tip Text", popup);
              ActionListener menuActionListener = new ActionListener() {
      
                  public void actionPerformed(ActionEvent e) {
                      trayIcon.displayMessage("Good-bye", "Cruel World",
                              TrayIcon.MessageType.WARNING);
                  }
              };
              item.addActionListener(menuActionListener);
              popup.add(item);
              ActionListener actionListener = new ActionListener() {
      
                  public void actionPerformed(ActionEvent e) {
                      tray.remove(trayIcon);
                  }
              };
              trayIcon.addActionListener(actionListener);
              try {
                  tray.add(trayIcon);
                  start();
              } catch (AWTException ex) {
                  Logger.getLogger(ActiveTray.class.getName()).log(Level.SEVERE, null, ex);
              }
      
          }
      
          private void start() {
              timer = new javax.swing.Timer(125, updateCol());
              timer.start();
              trayIcon.displayMessage(null, "  Aplication Loaded  ", TrayIcon.MessageType.NONE);
          }
      
          private Action updateCol() {
              return new AbstractAction("Icon load action") {
      
                  private static final long serialVersionUID = 1L;
      
                  @Override
                  public void actionPerformed(ActionEvent e) {
                      Runnable doRun = new Runnable() {
      
                          @Override
                          public void run() {
                              Image img = trayIcon.getImage();
                              if (img == image) {
                                  trayIcon.setImage(image1);
                              } else {
                                  trayIcon.setImage(image);
                              }
                          }
                      };
                      SwingUtilities.invokeLater(doRun);
                  }
              };
          }
      
          public static void main(String args[]) {
              ActiveTray activeTray = new ActiveTray();
          }
      
          static Image iconToImage(Icon icon) {
              if (icon instanceof ImageIcon) {
                  return ((ImageIcon) icon).getImage();
              } else {
                  int w = icon.getIconWidth();
                  int h = icon.getIconHeight();
                  GraphicsEnvironment ge =
                          GraphicsEnvironment.getLocalGraphicsEnvironment();
                  GraphicsDevice gd = ge.getDefaultScreenDevice();
                  GraphicsConfiguration gc = gd.getDefaultConfiguration();
                  BufferedImage image = gc.createCompatibleImage(w, h);
                  Graphics2D g = image.createGraphics();
                  icon.paintIcon(null, g, 0, 0);
                  g.dispose();
                  return image;
              }
          }
      
          static class BevelArrowIcon implements Icon {
      
              public static final int UP = 0;         // direction
              public static final int DOWN = 1;
              private static final int DEFAULT_SIZE = 16;
              private Color edge1;
              private Color edge2;
              private Color fill;
              private int size;
              private int direction;
      
              public BevelArrowIcon(int direction, boolean isRaisedView,
                      boolean isPressedView) {
                  if (isRaisedView) {
                      if (isPressedView) {
                          init(UIManager.getColor("controlLtHighlight"),
                                  UIManager.getColor("controlDkShadow"),
                                  UIManager.getColor("controlShadow"),
                                  DEFAULT_SIZE, direction);
                      } else {
                          init(UIManager.getColor("controlHighlight"),
                                  UIManager.getColor("controlShadow"),
                                  UIManager.getColor("control"),
                                  DEFAULT_SIZE, direction);
                      }
                  } else {
                      if (isPressedView) {
                          init(UIManager.getColor("controlDkShadow"),
                                  UIManager.getColor("controlLtHighlight"),
                                  UIManager.getColor("controlShadow"),
                                  DEFAULT_SIZE, direction);
                      } else {
                          init(UIManager.getColor("controlShadow"),
                                  UIManager.getColor("controlHighlight"),
                                  UIManager.getColor("control"),
                                  DEFAULT_SIZE, direction);
                      }
                  }
              }
      
              public BevelArrowIcon(Color edge1, Color edge2, Color fill,
                      int size, int direction) {
                  init(edge1, edge2, fill, size, direction);
              }
      
              @Override
              public void paintIcon(Component c, Graphics g, int x, int y) {
                  switch (direction) {
                      case DOWN:
                          drawDownArrow(g, x, y);
                          break;
                      case UP:
                          drawUpArrow(g, x, y);
                          break;
                  }
              }
      
              @Override
              public int getIconWidth() {
                  return size;
              }
      
              @Override
              public int getIconHeight() {
                  return size;
              }
      
              private void init(Color edge1, Color edge2, Color fill,
                      int size, int direction) {
                  edge1 = Color.red;
                  edge2 = Color.blue;
                  this.edge1 = edge1;
                  this.edge2 = edge2;
                  this.fill = fill;
                  this.size = size;
                  this.direction = direction;
              }
      
              private void drawDownArrow(Graphics g, int xo, int yo) {
                  g.setColor(edge1);
                  g.drawLine(xo, yo, xo + size - 1, yo);
                  g.drawLine(xo, yo + 1, xo + size - 3, yo + 1);
                  g.setColor(edge2);
                  g.drawLine(xo + size - 2, yo + 1, xo + size - 1, yo + 1);
                  int x = xo + 1;
                  int y = yo + 2;
                  int dx = size - 6;
                  while (y + 1 < yo + size) {
                      g.setColor(edge1);
                      g.drawLine(x, y, x + 1, y);
                      g.drawLine(x, y + 1, x + 1, y + 1);
                      if (0 < dx) {
                          g.setColor(fill);
                          g.drawLine(x + 2, y, x + 1 + dx, y);
                          g.drawLine(x + 2, y + 1, x + 1 + dx, y + 1);
                      }
                      g.setColor(edge2);
                      g.drawLine(x + dx + 2, y, x + dx + 3, y);
                      g.drawLine(x + dx + 2, y + 1, x + dx + 3, y + 1);
                      x += 1;
                      y += 2;
                      dx -= 2;
                  }
                  g.setColor(edge1);
                  g.drawLine(xo + (size / 2), yo + size - 1, xo
                          + (size / 2), yo + size - 1);
              }
      
              private void drawUpArrow(Graphics g, int xo, int yo) {
                  g.setColor(edge1);
                  int x = xo + (size / 2);
                  g.drawLine(x, yo, x, yo);
                  x--;
                  int y = yo + 1;
                  int dx = 0;
                  while (y + 3 < yo + size) {
                      g.setColor(edge1);
                      g.drawLine(x, y, x + 1, y);
                      g.drawLine(x, y + 1, x + 1, y + 1);
                      if (0 < dx) {
                          g.setColor(fill);
                          g.drawLine(x + 2, y, x + 1 + dx, y);
                          g.drawLine(x + 2, y + 1, x + 1 + dx, y + 1);
                      }
                      g.setColor(edge2);
                      g.drawLine(x + dx + 2, y, x + dx + 3, y);
                      g.drawLine(x + dx + 2, y + 1, x + dx + 3, y + 1);
                      x -= 1;
                      y += 2;
                      dx += 2;
                  }
                  g.setColor(edge1);
                  g.drawLine(xo, yo + size - 3, xo + 1, yo + size - 3);
                  g.setColor(edge2);
                  g.drawLine(xo + 2, yo + size - 2, xo + size - 1, yo + size - 2);
                  g.drawLine(xo, yo + size - 1, xo + size, yo + size - 1);
              }
          }
      }
      

      这篇关于闪烁托盘图标的文章就介绍到这了,希望我们推荐的答案对大家有所帮助,也希望大家多多支持IT屋!

查看全文
登录 关闭
扫码关注1秒登录
发送“验证码”获取 | 15天全站免登陆