背景动画 : 动画 « 高级图形 « Java

En
Java
1. 图形用户界面
2. 三维图形动画
3. 高级图形
4. 蚂蚁编译
5. Apache类库
6. 统计图
7. 
8. 集合数据结构
9. 数据类型
10. 数据库JDBC
11. 设计模式
12. 开发相关类
13. EJB3
14. 电子邮件
15. 事件
16. 文件输入输出
17. 游戏
18. 泛型
19. GWT
20. Hibernate
21. 本地化
22. J2EE平台
23. 基于J2ME
24. JDK-6
25. JNDI的LDAP
26. JPA
27. JSP技术
28. JSTL
29. 语言基础知识
30. 网络协议
31. PDF格式RTF格式
32. 映射
33. 常规表达式
34. 脚本
35. 安全
36. Servlets
37. Spring
38. Swing组件
39. 图形用户界面
40. SWT-JFace-Eclipse
41. 线程
42. 应用程序
43. Velocity
44. Web服务SOA
45. 可扩展标记语言
Java 教程
Java » 高级图形 » 动画屏幕截图 
背景动画

 
 

/*
 * Copyright (c) 2007, Romain Guy
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 *
 *   * Redistributions of source code must retain the above copyright
 *     notice, this list of conditions and the following disclaimer.
 *   * Redistributions in binary form must reproduce the above
 *     copyright notice, this list of conditions and the following
 *     disclaimer in the documentation and/or other materials provided
 *     with the distribution.
 *   * Neither the name of the TimingFramework project nor the names of its
 *     contributors may be used to endorse or promote products derived
 *     from this software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
 * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */

import java.awt.AlphaComposite;
import java.awt.BorderLayout;
import java.awt.Color;
import java.awt.Component;
import java.awt.Composite;
import java.awt.Container;
import java.awt.Cursor;
import java.awt.Dimension;
import java.awt.FlowLayout;
import java.awt.Font;
import java.awt.GradientPaint;
import java.awt.Graphics;
import java.awt.Graphics2D;
import java.awt.GridBagLayout;
import java.awt.HeadlessException;
import java.awt.Image;
import java.awt.Insets;
import java.awt.LayoutManager;
import java.awt.LayoutManager2;
import java.awt.Paint;
import java.awt.Rectangle;
import java.awt.RenderingHints;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.awt.event.ComponentAdapter;
import java.awt.event.ComponentEvent;
import java.awt.event.ComponentListener;
import java.awt.event.KeyAdapter;
import java.awt.event.KeyEvent;
import java.awt.event.MouseAdapter;
import java.awt.event.MouseEvent;
import java.awt.event.MouseMotionAdapter;
import java.awt.event.MouseWheelEvent;
import java.awt.event.MouseWheelListener;
import java.awt.font.FontRenderContext;
import java.awt.font.TextLayout;
import java.awt.geom.AffineTransform;
import java.awt.geom.Area;
import java.awt.geom.Ellipse2D;
import java.awt.geom.GeneralPath;
import java.awt.geom.Rectangle2D;
import java.awt.geom.RoundRectangle2D;
import java.awt.image.BufferedImage;
import java.io.File;
import java.io.FileFilter;
import java.io.IOException;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.LinkedList;
import java.util.List;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

import javax.imageio.ImageIO;
import javax.swing.JComponent;
import javax.swing.JFrame;
import javax.swing.JLabel;
import javax.swing.JPanel;
import javax.swing.JSeparator;
import javax.swing.JSlider;
import javax.swing.SwingUtilities;
import javax.swing.Timer;
import javax.swing.UIManager;
import javax.swing.UnsupportedLookAndFeelException;
import javax.swing.event.ChangeEvent;
import javax.swing.event.ChangeListener;

/**
 @author Romain Guy
 */
public class BackgroundAnimation_2008 extends JFrame {

  private AvatarChooser chooser;

  private CurvesPanel curves;

  public BackgroundAnimation_2008() throws HeadlessException {
    super("Stack Layout");

    buildContentPane();
    // buildDebugControls();

    startAnimation();

    setSize(640400);
    setLocationRelativeTo(null);

    setDefaultCloseOperation(EXIT_ON_CLOSE);
  }

  private void startAnimation() {
    Timer timer = new Timer(50new ActionListener() {
      public void actionPerformed(ActionEvent e) {
        curves.animate();
        curves.repaint();
      }
    });
    timer.start();
  }

  private void buildDebugControls() {
    JPanel pane = new JPanel(new BorderLayout());
    pane.setBackground(Color.WHITE);
    pane.add(new JSeparator(), BorderLayout.NORTH);

    final GraphPanel grapher = new GraphPanel();
    JPanel graphPane = new JPanel(new FlowLayout(FlowLayout.CENTER));
    graphPane.setOpaque(false);
    graphPane.add(grapher);

    JPanel buttonsPane = new JPanel(new FlowLayout(FlowLayout.CENTER));
    buttonsPane.setOpaque(false);

    JSlider spacing = new JSlider(JSlider.HORIZONTAL, 010040);
    spacing.setBackground(Color.WHITE);
    spacing.setPreferredSize(new Dimension(95, spacing.getPreferredSize().height));
    spacing.addChangeListener(new ChangeListener() {
      public void stateChanged(ChangeEvent e) {
        JSlider slider = (JSlidere.getSource();
        double spacing = slider.getValue() 100.0;
        chooser.setSpacing(spacing);
        grapher.spacing = spacing;
        grapher.repaint();
      }
    });

    JSlider sigma = new JSlider(JSlider.HORIZONTAL, 010050);
    sigma.setBackground(Color.WHITE);
    sigma.setPreferredSize(new Dimension(95, sigma.getPreferredSize().height));
    sigma.addChangeListener(new ChangeListener() {
      public void stateChanged(ChangeEvent e) {
        JSlider slider = (JSlidere.getSource();
        double sigma = slider.getValue() 100.0;
        chooser.setSigma(sigma);
        grapher.sigma = sigma;
        grapher.repaint();
      }
    });

    JSlider position = new JSlider(JSlider.HORIZONTAL, -1001000);
    position.setBackground(Color.WHITE);
    position.setPreferredSize(new Dimension(95, position.getPreferredSize().height));
    position.addChangeListener(new ChangeListener() {
      public void stateChanged(ChangeEvent e) {
        JSlider slider = (JSlidere.getSource();
        double position = slider.getValue() 100.0;
        chooser.setPosition(position);
        grapher.position = position;
        grapher.repaint();
      }
    });

    JSlider amount = new JSlider(JSlider.HORIZONTAL, 1155);
    amount.setBackground(Color.WHITE);
    amount.setPreferredSize(new Dimension(95, position.getPreferredSize().height));
    amount.addChangeListener(new ChangeListener() {
      public void stateChanged(ChangeEvent e) {
        JSlider slider = (JSlidere.getSource();
        int amount = slider.getValue();
        chooser.setAmount(amount);
        grapher.amount = amount;
        grapher.repaint();
      }
    });

    buttonsPane.add(new JLabel("Spacing: "));
    buttonsPane.add(spacing);
    buttonsPane.add(new JLabel("Sigma: "));
    buttonsPane.add(sigma);
    buttonsPane.add(new JLabel("Position: "));
    buttonsPane.add(position);
    buttonsPane.add(new JLabel("Amount: "));
    buttonsPane.add(amount);

    pane.add(buttonsPane, BorderLayout.NORTH);
    pane.add(graphPane, BorderLayout.CENTER);

    add(pane, BorderLayout.SOUTH);
  }

  private void buildContentPane() {
    JPanel pane = new JPanel();
    pane.setLayout(new StackLayout());

    GradientPanel gradient = new GradientPanel();
    chooser = new AvatarChooser();
    curves = new CurvesPanel();

    pane.add(gradient, StackLayout.TOP);
    pane.add(chooser, StackLayout.TOP);
    pane.add(curves, StackLayout.TOP);

    add(pane);
  }

  private class GraphPanel extends JComponent {
    private double spacing = 0.4;

    private double position = 0.0;

    private double sigma = 0.5;

    private int amount = 5;

    @Override
    public Dimension getPreferredSize() {
      return new Dimension(20060);
    }

    @Override
    public boolean isOpaque() {
      return false;
    }

    @Override
    protected void paintComponent(Graphics g) {
      Graphics2D g2 = (Graphics2Dg;
      g2.setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON);

      g2.setColor(Color.BLACK);
      g2.drawLine(05010050);
      g2.drawLine(5005060);

      g2.setColor(Color.BLUE);
      double lastY = 50.0;
      for (int x = 0; x < 100; x++) {
        double y = chooser.computeModifier((50.0 - x25.045.0 10;
        if (x == 0) {
          lastY = y;
        }
        g2.drawLine(x - 160 (intlastY, x, 60 (inty);
        lastY = y;
      }

      g2.setColor(Color.RED);

      for (int i = 0; i < amount; i++) {
        double offset = ((amount / 2- i* spacing;

        double x = (100.0 5.02.0;
        x += 25.0 (position + offset);

        if (x > 100) {
          continue;
        }

        double y = 60.0 (chooser.computeModifier(position + offset45.0 10);
        g2.fill(new Rectangle2D.Double(x, y - 15.05.0));
      }

      g2.setColor(Color.GREEN.darker());
      g2.drawLine(2502560);
      g2.drawLine(7507560);

      g2.setColor(Color.DARK_GRAY);
      g2.drawString("Sigma: " + sigma, 110.0f16.0f);
      g2.drawString("Spacing: " + spacing, 110.0f30.0f);
      g2.drawString("Position: " + position, 110.0f44.0f);
    }
  }

  public static void main(String[] args) {
    try {
      UIManager.setLookAndFeel(UIManager.getCrossPlatformLookAndFeelClassName());
    catch (ClassNotFoundException ex) {
      ex.printStackTrace();
    catch (IllegalAccessException ex) {
      ex.printStackTrace();
    catch (InstantiationException ex) {
      ex.printStackTrace();
    catch (UnsupportedLookAndFeelException ex) {
      ex.printStackTrace();
    }

    SwingUtilities.invokeLater(new Runnable() {
      public void run() {
        BackgroundAnimation_2008 tester = new BackgroundAnimation_2008();
        tester.setVisible(true);
      }
    });
  }
}

/*
 * Copyright (c) 2007, Romain Guy All rights reserved.
 
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are met:
 *  * Redistributions of source code must retain the above copyright notice,
 * this list of conditions and the following disclaimer. * Redistributions in
 * binary form must reproduce the above copyright notice, this list of
 * conditions and the following disclaimer in the documentation and/or other
 * materials provided with the distribution. * Neither the name of the
 * TimingFramework project nor the names of its contributors may be used to
 * endorse or promote products derived from this software without specific prior
 * written permission.
 
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
 * POSSIBILITY OF SUCH DAMAGE.
 */

class AvatarChooser extends JPanel {
  private static final double ANIM_SCROLL_DELAY = 450;

  private List<Image> avatars = null;

  private boolean loadingDone = false;

  private Thread picturesFinder = null;

  private Timer scrollerTimer = null;

  private Timer faderTimer = null;

  private Timer passwordTimer;

  private float veilAlphaLevel = 0.0f;

  private float alphaLevel = 0.0f;

  private float textAlphaLevel = 0.0f;

  private int avatarIndex;

  private double avatarPosition = 0.0;

  private double avatarSpacing = 0.4;

  private int avatarAmount = 5;

  private double sigma;

  private double rho;

  private double exp_multiplier;

  private double exp_member;

  private boolean damaged = true;

  private DrawableAvatar[] drawableAvatars;

  private String textAvatar;

  private FocusGrabber focusGrabber;

  private AvatarScroller avatarScroller;

  private CursorChanger cursorChanger;

  private MouseWheelScroller wheelScroller;

  private KeyScroller keyScroller;

  public AvatarChooser() {
    GridBagLayout layout = new GridBagLayout();
    setLayout(layout);

    findAvatars();
    setSigma(0.5);

    addComponentListener(new DamageManager());

    initInputListeners();
    addInputListeners();
  }

  public void setAmount(int amount) {
    if (amount > avatars.size()) {
      throw new IllegalArgumentException("Too many avatars");
    }

    this.avatarAmount = amount;
    repaint();
  }

  // XXX package access for debugging purpose only
  void setPosition(double position) {
    this.avatarPosition = position;
    this.damaged = true;
    repaint();
  }

  public void setSigma(double sigma) {
    this.sigma = sigma;
    this.rho = 1.0;
    computeEquationParts();
    this.rho = computeModifierUnprotected(0.0);
    computeEquationParts();
    this.damaged = true;
    repaint();
  }

  public void setSpacing(double avatarSpacing) {
    if (avatarSpacing < 0.0 || avatarSpacing > 1.0) {
      throw new IllegalArgumentException("Spacing must be < 1.0 and > 0.0");
    }

    this.avatarSpacing = avatarSpacing;
    this.damaged = true;
    repaint();
  }

  @Override
  public Dimension getPreferredSize() {
    return new Dimension(128 3128 2);
  }

  @Override
  public Dimension getMaximumSize() {
    return new Dimension(Integer.MAX_VALUE, Integer.MAX_VALUE);
  }

  @Override
  public boolean isOpaque() {
    return false;
  }

  @Override
  public boolean isFocusable() {
    return true;
  }

  @Override
  protected void paintChildren(Graphics g) {
    Graphics2D g2 = (Graphics2Dg;

    Composite oldComposite = g2.getComposite();
    g2.setComposite(AlphaComposite.getInstance(AlphaComposite.SRC_OVER, veilAlphaLevel));
    super.paintChildren(g);
    g2.setComposite(oldComposite);
  }

  @Override
  protected void paintComponent(Graphics g) {
    super.paintComponent(g);

    if (!loadingDone && faderTimer == null) {
      return;
    }

    Insets insets = getInsets();

    int x = insets.left;
    int y = insets.top;

    int width = getWidth() - insets.left - insets.right;
    int height = getHeight() - insets.top - insets.bottom;

    Graphics2D g2 = (Graphics2Dg;
    g2.setRenderingHint(RenderingHints.KEY_INTERPOLATION,
        RenderingHints.VALUE_INTERPOLATION_BILINEAR);
    g2.setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON);
    Composite oldComposite = g2.getComposite();

    if (damaged) {
      drawableAvatars = sortAvatarsByDepth(x, y, width, height);
      damaged = false;
    }

    drawAvatars(g2, drawableAvatars);

    if (drawableAvatars.length > 0) {
      drawAvatarName(g2);
    }

    g2.setComposite(oldComposite);
  }

  private void drawAvatars(Graphics2D g2, DrawableAvatar[] drawableAvatars) {
    for (DrawableAvatar avatar : drawableAvatars) {
      AlphaComposite composite = AlphaComposite.getInstance(AlphaComposite.SRC_OVER, (floatavatar
          .getAlpha());
      g2.setComposite(composite);
      g2.drawImage(avatars.get(avatar.getIndex())(intavatar.getX()(intavatar.getY(), avatar
          .getWidth(), avatar.getHeight()null);
    }
  }

  private DrawableAvatar[] sortAvatarsByDepth(int x, int y, int width, int height) {
    List<DrawableAvatar> drawables = new LinkedList<DrawableAvatar>();
    for (int i = 0; i < avatars.size(); i++) {
      promoteAvatarToDrawable(drawables, x, y, width, height, i - avatarIndex);
    }

    DrawableAvatar[] drawableAvatars = new DrawableAvatar[drawables.size()];
    drawableAvatars = drawables.toArray(drawableAvatars);
    Arrays.sort(drawableAvatars);
    return drawableAvatars;
  }

  private void drawAvatarName(Graphics2D g2) {
    Composite composite = g2.getComposite();
    g2.setComposite(AlphaComposite.getInstance(AlphaComposite.SRC_OVER, textAlphaLevel));

    double bulletWidth = 150.0;
    double bulletHeight = 30.0;

    double x = (getWidth() - bulletWidth2.0;
    double y = (getHeight() 1642.0 - bulletHeight * 1.4;

    drawAvatarBullet(g2, x, y, bulletWidth, bulletHeight);
    drawAvatarText(g2, y, bulletHeight);

    g2.setComposite(composite);
  }

  private void drawAvatarText(Graphics2D g2, double y, double bulletHeight) {
    FontRenderContext context = g2.getFontRenderContext();
    Font font = new Font("Dialog", Font.PLAIN, 18);
    TextLayout layout = new TextLayout(textAvatar, font, context);
    Rectangle2D bounds = layout.getBounds();

    float text_x = (float) ((getWidth() - bounds.getWidth()) 2.0);
    float text_y = (float) (y + (bulletHeight - layout.getAscent() - layout.getDescent()) 2.0)
        + layout.getAscent() - layout.getLeading();

    g2.setColor(Color.BLACK);
    layout.draw(g2, text_x, text_y + 1);
    g2.setColor(Color.WHITE);
    layout.draw(g2, text_x, text_y);
  }

  private void drawAvatarBullet(Graphics2D g2, double x, double y, double bulletWidth,
      double bulletHeight) {
    RoundRectangle2D bullet = new RoundRectangle2D.Double(0.00.0, bulletWidth, bulletHeight,
        bulletHeight, bulletHeight);
    Ellipse2D curve = new Ellipse2D.Double(-20.0, bulletHeight / 2.0, bulletWidth + 40.0,
        bulletHeight);

    g2.translate(x, y);

    g2.translate(-1, -2);
    g2.setColor(new Color(000170));
    g2.fill(new RoundRectangle2D.Double(0.00.0, bulletWidth + 2, bulletHeight + 4,
        bulletHeight + 4, bulletHeight + 4));
    g2.translate(12);

    Color startColor = new Color(10040);
    Color endColor = new Color(175165225);

    Paint paint = g2.getPaint();
    g2.setPaint(new GradientPaint(0.0f0.0f, startColor, 0.0f(floatbulletHeight, endColor));
    g2.fill(bullet);

    startColor = new Color(5050);
    endColor = new Color(105100155);
    g2.setPaint(new GradientPaint(0.0f0.0f, startColor, 0.0f(floatbulletHeight, endColor));

    Area area = new Area(bullet);
    area.intersect(new Area(curve));
    g2.fill(area);

    g2.setPaint(paint);
    g2.translate(-x, -y);
  }

  private void promoteAvatarToDrawable(List<DrawableAvatar> drawables, int x, int y, int width,
      int height, int offset) {
    double spacing = offset * avatarSpacing;
    double avatarPosition = this.avatarPosition + spacing;

    if (avatarIndex + offset < || avatarIndex + offset >= avatars.size()) {
      return;
    }

    Image avatar = avatars.get(avatarIndex + offset);

    int avatarWidth = avatar.getWidth(null);
    int avatarHeight = avatar.getHeight(null);

    double result = computeModifier(avatarPosition);

    int newWidth = (int) (avatarWidth * result);
    if (newWidth == 0) {
      return;
    }

    int newHeight = (int) (avatarHeight * result);
    if (newHeight == 0) {
      return;
    }

    double avatar_x = x + (width - newWidth2.0;
    double avatar_y = y + (height - newHeight / 2.02.0;

    double semiWidth = width / 2.0;

    avatar_x += avatarPosition * semiWidth;

    if (avatar_x >= width || avatar_x < -newWidth) {
      return;
    }

    drawables.add(new DrawableAvatar(avatarIndex + offset, avatar_x, avatar_y, newWidth, newHeight,
        avatarPosition, result));
  }

  private void startFader() {
    faderTimer = new Timer(35new FaderAction());
    faderTimer.start();
  }

  private void computeEquationParts() {
    exp_multiplier = Math.sqrt(2.0 * Math.PI/ sigma / rho;
    exp_member = 4.0 * sigma * sigma;
  }

  // XXX package access for debug purpose only
  double computeModifier(double x) {
    double result = computeModifierUnprotected(x);
    if (result > 1.0) {
      result = 1.0;
    else if (result < -1.0) {
      result = -1.0;
    }

    return result;
  }

  private double computeModifierUnprotected(double x) {
    return exp_multiplier * Math.exp((-x * x/ exp_member);
  }

  private void addInputListeners() {
    addMouseListener(focusGrabber);
    addMouseListener(avatarScroller);
    addMouseMotionListener(cursorChanger);
    addMouseWheelListener(wheelScroller);
    addKeyListener(keyScroller);
  }

  private void initInputListeners() {
    // input listeners are all stateless
    // hence they can be instantiated once
    focusGrabber = new FocusGrabber();
    avatarScroller = new AvatarScroller();
    cursorChanger = new CursorChanger();
    wheelScroller = new MouseWheelScroller();
    keyScroller = new KeyScroller();
  }

  private void removeInputListeners() {
    removeMouseListener(focusGrabber);
    removeMouseListener(avatarScroller);
    removeMouseMotionListener(cursorChanger);
    removeMouseWheelListener(wheelScroller);
    removeKeyListener(keyScroller);
  }

  private void findAvatars() {
    avatars = new ArrayList<Image>();

    picturesFinder = new Thread(new PicturesFinderThread());
    picturesFinder.start();
  }

  private void setAvatarIndex(int index) {
    avatarIndex = index;
    textAvatar = "Photo " + index;
  }

  private void scrollBy(int increment) {
    if (loadingDone) {
      setAvatarIndex(avatarIndex + increment);

      if (avatarIndex < 0) {
        setAvatarIndex(0);
      else if (avatarIndex >= avatars.size()) {
        setAvatarIndex(avatars.size() 1);
      }

      damaged = true;
      repaint();
    }
  }

  private void scrollAndAnimateBy(int increment) {
    if (loadingDone && (scrollerTimer == null || !scrollerTimer.isRunning())) {
      int index = avatarIndex + increment;
      if (index < 0) {
        index = 0;
      else if (index >= avatars.size()) {
        index = avatars.size() 1;
      }

      DrawableAvatar drawable = null;

      for (DrawableAvatar avatar : drawableAvatars) {
        if (avatar.index == index) {
          drawable = avatar;
          break;
        }
      }

      if (drawable != null) {
        scrollAndAnimate(drawable);
      }
    }
  }

  private void scrollAndAnimate(DrawableAvatar avatar) {
    if (loadingDone) {
      scrollerTimer = new Timer(10new AutoScroller(avatar));
      scrollerTimer.start();
    }
  }

  private BufferedImage createReflectedPicture(BufferedImage avatar) {
    int avatarWidth = avatar.getWidth();
    int avatarHeight = avatar.getHeight();

    BufferedImage alphaMask = createGradientMask(avatarWidth, avatarHeight);

    return createReflectedPicture(avatar, alphaMask);
  }

  private BufferedImage createReflectedPicture(BufferedImage avatar, BufferedImage alphaMask) {
    int avatarWidth = avatar.getWidth();
    int avatarHeight = avatar.getHeight();

    BufferedImage buffer = createReflection(avatar, avatarWidth, avatarHeight);
    applyAlphaMask(buffer, alphaMask, avatarWidth, avatarHeight);

    return buffer;
  }

  private void applyAlphaMask(BufferedImage buffer, BufferedImage alphaMask, int avatarWidth,
      int avatarHeight) {
    Graphics2D g2 = buffer.createGraphics();
    g2.setComposite(AlphaComposite.DstOut);
    g2.drawImage(alphaMask, null, 0, avatarHeight);
    g2.dispose();
  }

  private BufferedImage createReflection(BufferedImage avatar, int avatarWidth, int avatarHeight) {
    BufferedImage buffer = new BufferedImage(avatarWidth, avatarHeight << 1,
        BufferedImage.TYPE_INT_ARGB);

    Graphics2D g = buffer.createGraphics();
    g.drawImage(avatar, null, null);
    g.translate(0, avatarHeight << 1);

    AffineTransform reflectTransform = AffineTransform.getScaleInstance(1.0, -1.0);
    g.drawImage(avatar, reflectTransform, null);
    g.translate(0, -(avatarHeight << 1));

    g.dispose();

    return buffer;
  }

  private BufferedImage createGradientMask(int avatarWidth, int avatarHeight) {
    BufferedImage gradient = new BufferedImage(avatarWidth, avatarHeight,
        BufferedImage.TYPE_INT_ARGB);
    Graphics2D g = gradient.createGraphics();
    GradientPaint painter = new GradientPaint(0.0f0.0fnew Color(1.0f1.0f1.0f0.5f)0.0f,
        avatarHeight / 2.0fnew Color(1.0f1.0f1.0f1.0f));
    g.setPaint(painter);
    g.fill(new Rectangle2D.Double(00, avatarWidth, avatarHeight));

    g.dispose();

    return gradient;
  }

  private DrawableAvatar getHitAvatar(int x, int y) {
    for (DrawableAvatar avatar : drawableAvatars) {
      Rectangle hit = new Rectangle((intavatar.getX()(intavatar.getY(), avatar.getWidth(),
          avatar.getHeight() 2);
      if (hit.contains(x, y)) {
        return avatar;
      }
    }

    return null;
  }

  private class PicturesFinderThread implements Runnable {
    public void run() {
      UnixGlobFileFilter allPngs = new UnixGlobFileFilter("*.jpg");

      try {
        FileTreeWalker walker = new FileTreeWalker(new File("."), allPngs);

        PictureLoader loader = new PictureLoader();
        walker.walk(loader);

        List<File> files = loader.getFilesList();
        for (int i = 0; i < files.size(); i++) {
          BufferedImage image = ImageIO.read(files.get(i));
          avatars.add(createReflectedPicture(image));

          if (i == (files.size() 2+ avatarAmount / 2) {
            setAvatarIndex(i - avatarAmount / 2);
            startFader();
          }
        }
      catch (IOException e) {
      }

      loadingDone = true;
    }

    private class PictureLoader implements FileTreeWalk {
      private List<File> filesList;

      private PictureLoader() {
        filesList = new ArrayList<File>();
      }

      private List<File> getFilesList() {
        Collections.sort(filesList);
        return filesList;
      }

      public void walk(File path) {
        filesList.add(path);
      }
    }
  }

  private class FaderAction implements ActionListener {
    private long start = 0;

    private FaderAction() {
      alphaLevel = 0.0f;
      textAlphaLevel = 0.0f;
    }

    public void actionPerformed(ActionEvent e) {
      if (start == 0) {
        start = System.currentTimeMillis();
      }

      alphaLevel = (System.currentTimeMillis() - start500.0f;
      textAlphaLevel = alphaLevel;

      if (alphaLevel > 1.0f) {
        alphaLevel = 1.0f;
        textAlphaLevel = 1.0f;
        faderTimer.stop();
      }

      repaint();
    }
  }

  private class DrawableAvatar implements Comparable {
    private int index;

    private double x;

    private double y;

    private int width;

    private int height;

    private double zOrder;

    private double position;

    private DrawableAvatar(int index, double x, double y, int width, int height, double position,
        double zOrder) {
      this.index = index;
      this.x = x;
      this.y = y;
      this.width = width;
      this.height = height;
      this.position = position;
      this.zOrder = zOrder;
    }

    public int compareTo(Object o) {
      double zOrder2 = ((DrawableAvataro).zOrder;

      if (zOrder < zOrder2) {
        return -1;
      else if (zOrder > zOrder2) {
        return 1;
      }
      return 0;
    }

    public double getPosition() {
      return position;
    }

    public double getAlpha() {
      return zOrder * alphaLevel;
    }

    public int getHeight() {
      return height;
    }

    public int getIndex() {
      return index;
    }

    public int getWidth() {
      return width;
    }

    public double getX() {
      return x;
    }

    public double getY() {
      return y;
    }
  }

  private class MouseWheelScroller implements MouseWheelListener {
    public void mouseWheelMoved(MouseWheelEvent e) {
      int increment = e.getWheelRotation();
      scrollAndAnimateBy(increment);
    }
  }

  private class KeyScroller extends KeyAdapter {
    @Override
    public void keyPressed(KeyEvent e) {
      int keyCode = e.getKeyCode();
      switch (keyCode) {
      case KeyEvent.VK_LEFT:
      case KeyEvent.VK_UP:
        scrollAndAnimateBy(-1);
        break;
      case KeyEvent.VK_RIGHT:
      case KeyEvent.VK_DOWN:
        scrollAndAnimateBy(1);
        break;
      case KeyEvent.VK_END:
        scrollBy(avatars.size() - avatarIndex - 1);
        break;
      case KeyEvent.VK_HOME:
        scrollBy(-avatarIndex - 1);
        break;
      case KeyEvent.VK_PAGE_UP:
        scrollAndAnimateBy(-avatarAmount / 2);
        break;
      case KeyEvent.VK_PAGE_DOWN:
        scrollAndAnimateBy(avatarAmount / 2);
        break;
      }
    }
  }

  private class FocusGrabber extends MouseAdapter {
    @Override
    public void mouseClicked(MouseEvent e) {
      requestFocus();
    }
  }

  private class AvatarScroller extends MouseAdapter {
    @Override
    public void mouseClicked(MouseEvent e) {
      if ((faderTimer != null && faderTimer.isRunning())
          || (scrollerTimer != null && scrollerTimer.isRunning()) || drawableAvatars == null) {
        return;
      }

      if (e.getButton() == MouseEvent.BUTTON1) {
        DrawableAvatar avatar = getHitAvatar(e.getX(), e.getY());
        if (avatar != null && avatar.getIndex() != avatarIndex) {
          scrollAndAnimate(avatar);
        }
      }
    }
  }

  private class DamageManager extends ComponentAdapter {
    @Override
    public void componentResized(ComponentEvent e) {
      damaged = true;
    }
  }

  private class AutoScroller implements ActionListener {
    private double position;

    private int index;

    private long start;

    private AutoScroller(DrawableAvatar avatar) {
      this.index = avatar.getIndex();
      this.position = avatar.getPosition();
      this.start = System.currentTimeMillis();
    }

    public void actionPerformed(ActionEvent e) {
      long elapsed = System.currentTimeMillis() - start;
      if (elapsed < ANIM_SCROLL_DELAY / 2.0) {
        textAlphaLevel = (float) (1.0 2.0 (elapsed / ANIM_SCROLL_DELAY));
      else {
        textAlphaLevel = (float) (((elapsed / ANIM_SCROLL_DELAY0.52.0);
        if (textAlphaLevel > 1.0f) {
          textAlphaLevel = 1.0f;
        }
      }

      if (textAlphaLevel < 0.1f) {
        textAlphaLevel = 0.1f;
        textAvatar = "LoginName" + index;
      }

      double newPosition = (elapsed / ANIM_SCROLL_DELAY* -position;

      if (elapsed >= ANIM_SCROLL_DELAY) {
        ((Timere.getSource()).stop();

        setAvatarIndex(index);
        setPosition(0.0);
        return;
      }

      setPosition(newPosition);
    }
  }

  private class CursorChanger extends MouseMotionAdapter {
    @Override
    public void mouseMoved(MouseEvent e) {
      if ((scrollerTimer != null && scrollerTimer.isRunning()) || drawableAvatars == null) {
        return;
      }

      DrawableAvatar avatar = getHitAvatar(e.getX(), e.getY());
      if (avatar != null) {
        getParent().setCursor(Cursor.getPredefinedCursor(Cursor.HAND_CURSOR));
      else {
        getParent().setCursor(Cursor.getPredefinedCursor(Cursor.DEFAULT_CURSOR));
      }
    }
  }
}

/*
 * Copyright (c) 2007, Romain Guy All rights reserved.
 
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are met:
 *  * Redistributions of source code must retain the above copyright notice,
 * this list of conditions and the following disclaimer. * Redistributions in
 * binary form must reproduce the above copyright notice, this list of
 * conditions and the following disclaimer in the documentation and/or other
 * materials provided with the distribution. * Neither the name of the
 * TimingFramework project nor the names of its contributors may be used to
 * endorse or promote products derived from this software without specific prior
 * written permission.
 
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
 * POSSIBILITY OF SUCH DAMAGE.
 */

class CurvesPanel extends JPanel {
  protected RenderingHints hints;

  protected int counter = 0;

  protected Color start = new Color(255255255200);

  protected Color end new Color(2552552550);

  public CurvesPanel() {
    this(new BorderLayout());
  }

  public CurvesPanel(LayoutManager manager) {
    super(manager);
    hints = createRenderingHints();
  }

  protected RenderingHints createRenderingHints() {
    RenderingHints hints = new RenderingHints(RenderingHints.KEY_ANTIALIASING,
        RenderingHints.VALUE_ANTIALIAS_ON);
    hints.put(RenderingHints.KEY_INTERPOLATION, RenderingHints.VALUE_INTERPOLATION_BILINEAR);
    hints.put(RenderingHints.KEY_RENDERING, RenderingHints.VALUE_RENDER_QUALITY);
    return hints;
  }

  public void animate() {
    counter++;
  }

  @Override
  public boolean isOpaque() {
    return false;
  }

  @Override
  protected void paintComponent(Graphics g) {
    Graphics2D g2 = (Graphics2Dg;

    RenderingHints oldHints = g2.getRenderingHints();
    g2.setRenderingHints(hints);

    float width = getWidth();
    float height = getHeight();

    g2.translate(0, -30);

    drawCurve(g2, 20.0f, -10.0f20.0f, -10.0f, width / 2.0f 40.0f10.0f0.0f, -5.0f,
        width / 2.0f 401.0f0.0f5.0f50.0f5.0ffalse);

    g2.translate(030);
    g2.translate(0, height - 60);

    drawCurve(g2, 30.0f, -15.0f50.0f15.0f, width / 2.0f 40.0f1.0f15.0f, -25.0f,
        width / 2.0f1.0f 2.0f0.0f25.0f15.0f9.0ffalse);

    g2.translate(0, -height + 60);

    drawCurve(g2, height - 35.0f, -5.0f, height - 50.0f10.0f, width / 2.0f 40.0f1.0f,
        height - 35.0f, -25.0f, width / 2.0f1.0f 2.0f, height - 20.0f25.0f25.0f7.0ftrue);

    g2.setRenderingHints(oldHints);
  }

  protected void drawCurve(Graphics2D g2, float y1, float y1_offset, float y2, float y2_offset,
      float cx1, float cx1_offset, float cy1, float cy1_offset, float cx2, float cx2_offset,
      float cy2, float cy2_offset, float thickness, float speed, boolean invert) {
    float width = getWidth();

    float offset = (floatMath.sin(counter / (speed * Math.PI));

    float start_x = 0.0f;
    float start_y = offset * y1_offset + y1;
    float end_x = width;
    float end_y = offset * y2_offset + y2;

    float ctrl1_x = offset * cx1_offset + cx1;
    float ctrl1_y = offset * cy1_offset + cy1;
    float ctrl2_x = offset * cx2_offset + cx2;
    float ctrl2_y = offset * cy2_offset + cy2;

    GeneralPath thickCurve = new GeneralPath();
    thickCurve.moveTo(start_x, start_y);
    thickCurve.curveTo(ctrl1_x, ctrl1_y, ctrl2_x, ctrl2_y, end_x, end_y);
    thickCurve.lineTo(end_x, end_y + thickness);
    thickCurve.curveTo(ctrl2_x, ctrl2_y + thickness, ctrl1_x, ctrl1_y + thickness, start_x, start_y
        + thickness);
    thickCurve.lineTo(start_x, start_y);

    Rectangle bounds = thickCurve.getBounds();
    if (!bounds.intersects(g2.getClipBounds())) {
      return;
    }

    GradientPaint painter = new GradientPaint(0, bounds.y, invert ? end : start, 0, bounds.y
        + bounds.height, invert ? start : end);

    Paint oldPainter = g2.getPaint();
    g2.setPaint(painter);
    g2.fill(thickCurve);

    g2.setPaint(oldPainter);
  }
}

/*
 * Copyright (c) 2007, Romain Guy All rights reserved.
 
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are met:
 *  * Redistributions of source code must retain the above copyright notice,
 * this list of conditions and the following disclaimer. * Redistributions in
 * binary form must reproduce the above copyright notice, this list of
 * conditions and the following disclaimer in the documentation and/or other
 * materials provided with the distribution. * Neither the name of the
 * TimingFramework project nor the names of its contributors may be used to
 * endorse or promote products derived from this software without specific prior
 * written permission.
 
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
 * POSSIBILITY OF SUCH DAMAGE.
 */
class GradientPanel extends JPanel {
  protected BufferedImage gradientImage;

  protected Color gradientStart = new Color(204249124);

  protected Color gradientEnd = new Color(17422294);

  public GradientPanel() {
    this(new BorderLayout());
  }

  public GradientPanel(LayoutManager layout) {
    super(layout);
    addComponentListener(new GradientCacheManager());
  }

  @Override
  protected void paintComponent(Graphics g) {
    createImageCache();

    if (gradientImage != null) {
      g.drawImage(gradientImage, 00, getWidth(), getHeight()null);
    }
  }

  protected void createImageCache() {
    int width = 2;
    int height = getHeight();

    if (width == || height == 0) {
      return;
    }

    if (gradientImage == null || width != gradientImage.getWidth()
        || height != gradientImage.getHeight()) {

      gradientImage = new BufferedImage(width, height, BufferedImage.TYPE_INT_RGB);

      Graphics2D g2 = gradientImage.createGraphics();
      GradientPaint painter = new GradientPaint(00, gradientEnd, 0, height / 2, gradientStart);
      g2.setPaint(painter);

      Rectangle2D rect = new Rectangle2D.Double(00, width, height / 2.0);
      g2.fill(rect);

      painter = new GradientPaint(0, height / 2, gradientStart, 0, height, gradientEnd);
      g2.setPaint(painter);

      rect = new Rectangle2D.Double(0(height / 2.01.0, width, height);
      g2.fill(rect);

      g2.dispose();
    }
  }

  private void disposeImageCache() {
    synchronized (gradientImage) {
      gradientImage.flush();
      gradientImage = null;
    }
  }

  private class GradientCacheManager implements ComponentListener {
    public void componentResized(ComponentEvent e) {
    }

    public void componentMoved(ComponentEvent e) {
    }

    public void componentShown(ComponentEvent e) {
    }

    public void componentHidden(ComponentEvent e) {
      disposeImageCache();
    }
  }
}

/*
 * Copyright (c) 2007, Romain Guy All rights reserved.
 
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are met:
 *  * Redistributions of source code must retain the above copyright notice,
 * this list of conditions and the following disclaimer. * Redistributions in
 * binary form must reproduce the above copyright notice, this list of
 * conditions and the following disclaimer in the documentation and/or other
 * materials provided with the distribution. * Neither the name of the
 * TimingFramework project nor the names of its contributors may be used to
 * endorse or promote products derived from this software without specific prior
 * written permission.
 
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
 * POSSIBILITY OF SUCH DAMAGE.
 */

/**
 
 @author Romain Guy <romain.guy@mac.com>
 */
class StackLayout implements LayoutManager2 {
  public static final String BOTTOM = "bottom";

  public static final String TOP = "top";

  private List<Component> components = new LinkedList<Component>();

  public void addLayoutComponent(Component comp, Object constraints) {
    synchronized (comp.getTreeLock()) {
      if (BOTTOM.equals(constraints)) {
        components.add(0, comp);
      else if (TOP.equals(constraints)) {
        components.add(comp);
      else {
        components.add(comp);
      }
    }
  }

  public void addLayoutComponent(String name, Component comp) {
    addLayoutComponent(comp, TOP);
  }

  public void removeLayoutComponent(Component comp) {
    synchronized (comp.getTreeLock()) {
      components.remove(comp);
    }
  }

  public float getLayoutAlignmentX(Container target) {
    return 0.5f;
  }

  public float getLayoutAlignmentY(Container target) {
    return 0.5f;
  }

  public void invalidateLayout(Container target) {
  }

  public Dimension preferredLayoutSize(Container parent) {
    synchronized (parent.getTreeLock()) {
      int width = 0;
      int height = 0;

      for (Component comp : components) {
        Dimension size = comp.getPreferredSize();
        width = Math.max(size.width, width);
        height = Math.max(size.height, height);
      }

      Insets insets = parent.getInsets();
      width += insets.left + insets.right;
      height += insets.top + insets.bottom;

      return new Dimension(width, height);
    }
  }

  public Dimension minimumLayoutSize(Container parent) {
    synchronized (parent.getTreeLock()) {
      int width = 0;
      int height = 0;

      for (Component comp : components) {
        Dimension size = comp.getMinimumSize();
        width = Math.max(size.width, width);
        height = Math.max(size.height, height);
      }

      Insets insets = parent.getInsets();
      width += insets.left + insets.right;
      height += insets.top + insets.bottom;

      return new Dimension(width, height);
    }
  }

  public Dimension maximumLayoutSize(Container target) {
    return new Dimension(Integer.MAX_VALUE, Integer.MAX_VALUE);
  }

  public void layoutContainer(Container parent) {
    synchronized (parent.getTreeLock()) {
      int width = parent.getWidth();
      int height = parent.getHeight();

      Rectangle bounds = new Rectangle(00, width, height);

      int componentsCount = components.size();

      for (int i = 0; i < componentsCount; i++) {
        Component comp = components.get(i);
        comp.setBounds(bounds);
        parent.setComponentZOrder(comp, componentsCount - i - 1);
      }
    }
  }
}

/*
 * Copyright (c) 2007, Romain Guy All rights reserved.
 
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are met:
 *  * Redistributions of source code must retain the above copyright notice,
 * this list of conditions and the following disclaimer. * Redistributions in
 * binary form must reproduce the above copyright notice, this list of
 * conditions and the following disclaimer in the documentation and/or other
 * materials provided with the distribution. * Neither the name of the
 * TimingFramework project nor the names of its contributors may be used to
 * endorse or promote products derived from this software without specific prior
 * written permission.
 
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
 * POSSIBILITY OF SUCH DAMAGE.
 */

class FileTreeWalker {
  private File path;

  private static final FileFilter directoryFilter = new FileFilter() {
    public boolean accept(File pathname) {
      return pathname.isDirectory();
    }
  };

  private FileFilter filter;

  public FileTreeWalker(File paththrows IOException {
    this(path, new FileFilter() {
      public boolean accept(File pathname) {
        return pathname.isFile();
      }
    });
  }

  public FileTreeWalker(File path, FileFilter filterthrows IOException {
    if (path == null || !path.exists() || path.isFile()) {
      throw new IOException("Path " + path + " is not a valid directory.");
    }

    this.path = path;
    this.filter = filter;
  }

  public void walk(FileTreeWalk walk) {
    walkDirectory(walk, path);
  }

  private void walkDirectory(FileTreeWalk walk, File dir) {
    File[] files = dir.listFiles(filter);
    for (File file : files) {
      walk.walk(file);
    }

    File[] dirs = dir.listFiles(directoryFilter);
    for (File subDir : dirs) {
      walkDirectory(walk, subDir);
    }
  }
}

/*
 * Copyright (c) 2007, Romain Guy All rights reserved.
 
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are met:
 *  * Redistributions of source code must retain the above copyright notice,
 * this list of conditions and the following disclaimer. * Redistributions in
 * binary form must reproduce the above copyright notice, this list of
 * conditions and the following disclaimer in the documentation and/or other
 * materials provided with the distribution. * Neither the name of the
 * TimingFramework project nor the names of its contributors may be used to
 * endorse or promote products derived from this software without specific prior
 * written permission.
 
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
 * POSSIBILITY OF SUCH DAMAGE.
 */

interface FileTreeWalk {
  public void walk(File path);
}

/*
 * Copyright (c) 2007, Romain Guy All rights reserved.
 
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are met:
 *  * Redistributions of source code must retain the above copyright notice,
 * this list of conditions and the following disclaimer. * Redistributions in
 * binary form must reproduce the above copyright notice, this list of
 * conditions and the following disclaimer in the documentation and/or other
 * materials provided with the distribution. * Neither the name of the
 * TimingFramework project nor the names of its contributors may be used to
 * endorse or promote products derived from this software without specific prior
 * written permission.
 
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
 * POSSIBILITY OF SUCH DAMAGE.
 */

/**
 @author Romain Guy
 */
class UnixGlobFileFilter implements FileFilter {
  private Pattern pattern;

  public UnixGlobFileFilter(String filter) {
    pattern = Pattern.compile(globToRegex(filter));
  }

  public boolean accept(File file) {
    String path = file.getName();
    Matcher matcher = pattern.matcher(path);
    return matcher.matches();
  }

  private String globToRegex(String glob) {
    char c = '\0';
    boolean escape = false;
    boolean enclosed = false;
    StringBuffer buffer = new StringBuffer(glob.length());

    for (int i = 0; i < glob.length(); i++) {
      c = glob.charAt(i);

      if (escape) {
        buffer.append('\\');
        buffer.append(c);
        escape = false;
        continue;
      }

      switch (c) {
      case '*':
        buffer.append('.').append('*');
        break;
      case '?':
        buffer.append('.');
        break;
      case '\\':
        escape = true;
        break;
      case '.':
        buffer.append('\\').append('.');
        break;
      case '{':
        buffer.append('(');
        enclosed = true;
        break;
      case '}':
        buffer.append(')');
        enclosed = false;
        break;
      case ',':
        if (enclosed)
          buffer.append('|');
        else
          buffer.append(',');
        break;
      default:
        buffer.append(c);
      }
    }
    return buffer.toString();
  }
}


 

 
Related examples in the same category
1. 动画
2. 简单的动画技术简单的动画技术
3. Custom move interaction, Switching interactions, Update world extent geometry and Scroll handlingCustom move interaction, Switching interactions, Update world extent geometry and Scroll handling
4. 滚动处理滚动处理
5. 动画曲线动画曲线
6. 时钟时钟
7. 移动按钮
8. 移动按钮容器
9. 顺利移动
www.java2java.com | Contact Us
Copyright 2010 - 2030 Java Source and Support. All rights reserved.
All other trademarks are property of their respective owners.