Sensation

[Java] 프레임 이동, 투명, 모양 정의한 예제소스

tobby48 — Fri, 07 Aug 2009 09:05:22 GMT

급하게 해서 주석이 없는 .....

import java.awt.BorderLayout;
import java.awt.Color;
import java.awt.Dimension;
import java.awt.GradientPaint;
import java.awt.Graphics;
import java.awt.Graphics2D;
import java.awt.Paint;
import java.awt.Point;
import java.awt.Shape;
import java.awt.event.ComponentEvent;
import java.awt.event.ComponentListener;
import java.awt.event.MouseAdapter;
import java.awt.event.MouseEvent;
import java.awt.event.MouseMotionAdapter;
import java.awt.geom.RoundRectangle2D;

import javax.swing.JFrame;
import javax.swing.JPanel;

public class MovePanel extends JFrame implements ComponentListener {

   /**
   *
   */
   private static final long serialVersionUID = 1L;

   public JPanel jPanel1 = new JPanel(){
       /* (non-Javadoc)
       * @see javax.swing.JComponent#paintComponent(java.awt.Graphics)
       */
       protected void paintComponent(Graphics g) {
           if (g instanceof Graphics2D) {
               Paint p = new GradientPaint(getWidth(), getHeight(), new Color(221, 221, 221, 50), 0.0f, 0.0f,
                       new Color(221, 221, 221, 150), true);
               Graphics2D g2d = (Graphics2D) g;
               g2d.setPaint(p);
               g2d.fillRect(0, 0, getWidth(), getHeight());
           } else {
               super.paintComponent(g);
           }
       }
   };

   /* move by mouse pointer */
   Point mainFrameLocation = new Point(0, 0);
   Point mouseClickedLocation = new Point(0, 0);

   public MovePanel() {

//       jPanel1.setOpaque(true);
       addMouseListener(new FrameMove_mouseAdapter(this));
       addMouseMotionListener(new FrameMove_mouseMotionAdapter(this));

       /* root frame */
       setDefaultCloseOperation(javax.swing.WindowConstants.DISPOSE_ON_CLOSE);
       setMinimumSize(new Dimension(200, 200));
       setUndecorated(true);

       getContentPane().add(jPanel1, BorderLayout.CENTER);
       setLocationRelativeTo(null);

       addComponentListener(this);
   }

   public static void main(String[] args) {

       java.awt.EventQueue.invokeLater(new Runnable() {
           public void run() {
               MovePanel mainFrame = new MovePanel();
               mainFrame.setVisible(true);
               com.sun.awt.AWTUtilities.setWindowOpacity(mainFrame, 80.0f / 100.0f);
           }
       });
   }

   public void componentHidden(ComponentEvent arg0) {
       // TODO Auto-generated method stub

   }

   public void componentMoved(ComponentEvent arg0) {
       // TODO Auto-generated method stub

   }

   public void componentResized(ComponentEvent arg0) {
       // TODO Auto-generated method stub
       Shape shape = new RoundRectangle2D.Float(0, 0, getWidth(),
               getHeight(), 20, 20);
       com.sun.awt.AWTUtilities.setWindowShape(this, shape);
   }

   public void componentShown(ComponentEvent arg0) {
       // TODO Auto-generated method stub

   }
}

/**
* @author tobby48 2009. 07. 22
*/
class FrameMove_mouseAdapter extends MouseAdapter {
   private MovePanel frame;

   FrameMove_mouseAdapter(MovePanel mainframe) {
       this.frame = mainframe;
   }

   public void mousePressed(MouseEvent e) {
       frame.mouseClickedLocation.x = e.getX();
       frame.mouseClickedLocation.y = e.getY();
   }

   public void mouseReleased(MouseEvent e) {
   }
}

/**
* @author tobby48 2009. 07. 22
*/
class FrameMove_mouseMotionAdapter extends MouseMotionAdapter {
   private MovePanel frame;

   FrameMove_mouseMotionAdapter(MovePanel mainframe) {
       this.frame = mainframe;
   }

   public void mouseMove(MouseEvent e) {}

   public void mouseDragged(MouseEvent e) {
       frame.setLocation(e.getLocationOnScreen().x - frame.mouseClickedLocation.x,
               e.getLocationOnScreen().y - frame.mouseClickedLocation.y);
   }
}

tag : jpanel, jframe, mousemotion, mouseev, shape

[java] 프레임 모양바꾸기, 투명하게 만들기

tobby48 — Wed, 29 Jul 2009 01:43:50 GMT

네이트온 메신저에 보면, 메신저 창을 투명하게 할 수도 있다.

또한 frame을 원 형태로 만들수 있지 않을까 싶어서 찾아봤다.

아래 AWTUtilitiesWrapper 클래스와 빨간색 표시 코드만 참조해서 보면 된다.

import java.awt.Component;
import java.awt.GraphicsConfiguration;
import java.awt.Shape;
import java.awt.Window;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.util.logging.Level;
import java.util.logging.Logger;

/**
*
* @author Anthony Petrov (머리 좋은 사람 같다....................................................)
*/
public class AWTUtilitiesWrapper {

    private static Class awtUtilitiesClass;
    private static Class translucencyClass;
    private static Method mIsTranslucencySupported, mIsTranslucencyCapable,
            mSetWindowShape, mSetWindowOpacity, mSetWindowOpaque;
    public static Object PERPIXEL_TRANSPARENT, TRANSLUCENT,
            PERPIXEL_TRANSLUCENT;

    static void init() {
        try {
            awtUtilitiesClass = Class.forName("com.sun.awt.AWTUtilities");
            translucencyClass = Class
                    .forName("com.sun.awt.AWTUtilities$Translucency");
            if (translucencyClass.isEnum()) {
                Object[] kinds = translucencyClass.getEnumConstants();
                if (kinds != null) {
                    PERPIXEL_TRANSPARENT = kinds[0];
                    TRANSLUCENT = kinds[1];
                    PERPIXEL_TRANSLUCENT = kinds[2];
                }
            }
            mIsTranslucencySupported = awtUtilitiesClass.getMethod(
                    "isTranslucencySupported", translucencyClass);
            mIsTranslucencyCapable = awtUtilitiesClass.getMethod(
                    "isTranslucencyCapable", GraphicsConfiguration.class);
            mSetWindowShape = awtUtilitiesClass.getMethod("setWindowShape",
                    Window.class, Shape.class);
            mSetWindowOpacity = awtUtilitiesClass.getMethod("setWindowOpacity",
                    Window.class, float.class);
            mSetWindowOpaque = awtUtilitiesClass.getMethod("setWindowOpaque",
                    Window.class, boolean.class);
        } catch (NoSuchMethodException ex) {
            Logger.getLogger(AWTUtilitiesWrapper.class.getName()).log(
                    Level.SEVERE, null, ex);
        } catch (SecurityException ex) {
            Logger.getLogger(AWTUtilitiesWrapper.class.getName()).log(
                    Level.SEVERE, null, ex);
        } catch (ClassNotFoundException ex) {
            Logger.getLogger(AWTUtilitiesWrapper.class.getName()).log(
                    Level.SEVERE, null, ex);
        }
    }

    static {
        init();
    }

    private static boolean isSupported(Method method, Object kind) {
        if (awtUtilitiesClass == null || method == null) {
            return false;
        }
        try {
            Object ret = method.invoke(null, kind);
            if (ret instanceof Boolean) {
                return ((Boolean) ret).booleanValue();
            }
        } catch (IllegalAccessException ex) {
            Logger.getLogger(AWTUtilitiesWrapper.class.getName()).log(
                    Level.SEVERE, null, ex);
        } catch (IllegalArgumentException ex) {
            Logger.getLogger(AWTUtilitiesWrapper.class.getName()).log(
                    Level.SEVERE, null, ex);
        } catch (InvocationTargetException ex) {
            Logger.getLogger(AWTUtilitiesWrapper.class.getName()).log(
                    Level.SEVERE, null, ex);
        }
        return false;
    }

    public static boolean isTranslucencySupported(Object kind) {
        if (translucencyClass == null) {
            return false;
        }
        return isSupported(mIsTranslucencySupported, kind);
    }

    public static boolean isTranslucencyCapable(GraphicsConfiguration gc) {
        return isSupported(mIsTranslucencyCapable, gc);
    }

    private static void set(Method method, Window window, Object value) {
        if (awtUtilitiesClass == null || method == null) {
            return;
        }
        try {
            method.invoke(null, window, value);
        } catch (IllegalAccessException ex) {
            Logger.getLogger(AWTUtilitiesWrapper.class.getName()).log(
                    Level.SEVERE, null, ex);
        } catch (IllegalArgumentException ex) {
            Logger.getLogger(AWTUtilitiesWrapper.class.getName()).log(
                    Level.SEVERE, null, ex);
        } catch (InvocationTargetException ex) {
            Logger.getLogger(AWTUtilitiesWrapper.class.getName()).log(
                    Level.SEVERE, null, ex);
        }
    }

    private static void set(Method method, Component component, Object value) {
        if (awtUtilitiesClass == null || method == null) {
            return;
        }
        try {
            method.invoke(null, component, value);
        } catch (IllegalAccessException ex) {
            Logger.getLogger(AWTUtilitiesWrapper.class.getName()).log(
                    Level.SEVERE, null, ex);
        } catch (IllegalArgumentException ex) {
            Logger.getLogger(AWTUtilitiesWrapper.class.getName()).log(
                    Level.SEVERE, null, ex);
        } catch (InvocationTargetException ex) {
            Logger.getLogger(AWTUtilitiesWrapper.class.getName()).log(
                    Level.SEVERE, null, ex);
        }
    }

    public static void setWindowShape(Window window, Shape shape) {
        set(mSetWindowShape, window, shape);
    }

    public static void setWindowOpacity(Window window, float opacity) {
        set(mSetWindowOpacity, window, Float.valueOf(opacity));
    }

    public static void setWindowOpaque(Window window, boolean opaque) {
        set(mSetWindowOpaque, window, Boolean.valueOf(opaque));
    }

    public static void setComponentShape(Component component, Shape shape) {
        set(mSetWindowShape, component, shape);
    }
}

package layer;

import java.awt.BorderLayout;
import java.awt.Dimension;
import java.awt.GraphicsConfiguration;
import java.awt.Image;
import java.awt.Point;
import java.awt.Toolkit;
import java.io.IOException;
import java.net.URL;

import javax.swing.JFrame;
import javax.swing.JSplitPane;
import javax.swing.RootPaneContainer;

import panel.AutoSystemControlPanel;
import panel.MediaMainPanel;
import panel.MediaPlayControlPanel;
import panel.MediaPlayListPanel;
import panel.MediaTitlePanel;
import basicUI.MainBasicSplitPaneUI;
import env.EnvValue;
import env.StaticMethod;

/**
* @author tobby48 2009. 07. 20
*/
public class MediaMainFrame extends JFrame implements RootPaneContainer {

    /**
    *
    */
    private static final long serialVersionUID = 1L;

    /* layout */
    public JSplitPane mainSplitPane;

    public MediaMainPanel mainPlayerRightPanel;
    public AutoSystemControlPanel mainAutoSystemControlPanel;

    public MediaTitlePanel titlePanel;
    public MediaPlayListPanel playListPanel;
    public MediaPlayControlPanel playControlPanel;

    /* move by mouse pointer */
    public Point mouseClickedLocation = new Point(0, 0);

    /**
    * @param gc
    */
    public MediaMainFrame(GraphicsConfiguration gc) {
        super(gc);
        try {
            initComponents();
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        StaticMethod.applyWindowShape(this, 20, 20); // frame 의 양 모서리들을 약간 둥근 형태로 설정
        AWTUtilitiesWrapper.setWindowOpacity(this, 75.0f / 100.0f); // 75% 로 frame 를 투명하게 설정
        setLocationRelativeTo(null);
    }

    /**
    *
    */
    private void initComponents() throws IOException {

        /* right of frame */
        mainPlayerRightPanel = new MediaMainPanel();

        /* left of frame */
        mainAutoSystemControlPanel = new AutoSystemControlPanel();

        /* panel2 */
        titlePanel = new MediaTitlePanel(this);
        titlePanel.setPreferredSize(new Dimension(EnvValue.TITLEFRAME_WIDTH,
                EnvValue.TITLEFRAME_HEIGHT));
        mainPlayerRightPanel.add(titlePanel, BorderLayout.NORTH);

        /* panel3 */
        playListPanel = new MediaPlayListPanel();
        playListPanel.setPreferredSize(new Dimension(
                EnvValue.PLAYLISTFRAME_WIDTH, EnvValue.PLAYLISTFRAME_HEIGHT));
        mainPlayerRightPanel.add(playListPanel, BorderLayout.CENTER);

        /* panel4 */
        playControlPanel = new MediaPlayControlPanel();
        playControlPanel.setPreferredSize(new Dimension(
                EnvValue.PLAYCONTROLFRAME_WIDTH,
                EnvValue.PLAYCONTROLFRAME_HEIGHT));
        mainPlayerRightPanel.add(playControlPanel, BorderLayout.SOUTH);

        mainSplitPane = new JSplitPane(JSplitPane.HORIZONTAL_SPLIT,
                mainAutoSystemControlPanel, mainPlayerRightPanel);
        mainSplitPane.setResizeWeight(0.5);
        mainSplitPane.setDividerLocation(10);
        mainSplitPane.setOneTouchExpandable(true);
        mainSplitPane.setContinuousLayout(true);
        mainSplitPane.setVisible(true);

        Image imgPuzzle = null;

        try {
            imgPuzzle = Toolkit
                    .getDefaultToolkit()
                    .getImage(
                            new URL(
                                    "file:///D:/lg-nortel/env/eclipse-SDK-3.3-win32/workspace/Java/MediaDHO/border.gif"));
        } catch (Exception e) {
        }

        MainBasicSplitPaneUI main = new MainBasicSplitPaneUI(imgPuzzle);
        mainSplitPane.setDividerSize(10);
        mainSplitPane.setUI(main);

        /* root frame */
        setDefaultCloseOperation(javax.swing.WindowConstants.DISPOSE_ON_CLOSE);
        setMinimumSize(new Dimension(EnvValue.MAINFRAME_WIDTH,
                EnvValue.MAINFRAME_HEIGHT));
        setUndecorated(true);

        getContentPane().add(mainSplitPane, BorderLayout.CENTER);

        // pack();
    }
}

/**
* @author tobby48
* 2009. 07. 24
*/
public class StaticMethod {

    /**
    *
    */
    /**
    * @param component
    * @param arcw
    * @param arch
    */
    public static synchronized void applyWindowShape(final Window component, final float arcw, final float arch) {
        if (component == null) {
            return;
        }
        component.addComponentListener(new ComponentAdapter() {
            /* (non-Javadoc)
            * @see java.awt.event.ComponentAdapter#componentResized(java.awt.event.ComponentEvent)
            */
            @Override
            public void componentResized(ComponentEvent evt) {
                Shape shape = new RoundRectangle2D.Float(0, 0, component.getWidth(),
                        component.getHeight(), arcw, arch);
                AWTUtilitiesWrapper.setWindowShape(component, shape);
            }
        });
    }

    /**
    * @param path
    * @return
    */
    public static ImageIcon createImageIcon(String path) {
        java.net.URL imgURL = MediaMainFrame.class.getResource(path);
        if (imgURL != null) {
            return new ImageIcon(imgURL);
        } else {
            System.err.println("Couldn't find file: " + path);
            return null;
        }
    }
}

tag : AWTUtilitiesWrapper, setWindowShape, setWindowOpacity, 투명, 모양

[java] 프레임 스크린 중앙에 배치하기

tobby48 — Wed, 29 Jul 2009 01:33:06 GMT

일반적으로 java 를 실행하게 되면
Screen 중앙에 배치되지 않고, 왼쪽 상단에 배치된다.

그래서 보통 아래와 같은 절차로 Screen 중앙에 프레임을 배치시킨다.

Dimension dim = Toolkit.getDefaultToolkit().getScreenSize();
frame.setLocation((dim.width/2)-(frame.getWidth()/2), (dim.height/2)-(frame.getHeight()/2));

마음속으로 Screen 중앙을 왼쪽, 오른쪽으로 양분한 다음 위 코드를 생각해보면

쉽게 만들수 있는 코드이다.

나또한 대학2년때 위와 같이 코딩했었다.

하지만 다른 방법이 있다.

단 한줄이면 된다.

frame.setLocationRelativeTo(null);

이제 코딩 쉽게 하자.

API를 수시로 참조하여 메소드를 많이 아는 것이 코딩의 힘이다. Java 나 C# 같은 언어는 더더욱..

tag : setLocationRelativeTo, 중앙, Toolkit, 프레임

[java] Component 재정의로 나만의 UI 꾸미기(JPanel, JScrollBar)

tobby48 — Wed, 29 Jul 2009 01:15:46 GMT

우리는 일반적으로 JAVA로 GUI를 꾸밀때 Swing 를 사용하게 된다

JPanel panel = new JPanel();
JLabel label = new JLabel("안녕하세요");
panel.add(label);

이런식으로 코딩을 하게되면, java에서 제공해주는 JPanel 과 JLabel component를 그대로 사용하게 된다
따라서 정해진 모양과 색상을 그대로 사용하게 되어 멋진(?) UI를 구성하긴 어렵다.

일반적인 대학 수업과정 중에서는 다루지 않거나, 깊게 생각하진 않는게 일반적이다.
java api를 보면 개발자를 위해 클래스를 재정의 함으로써, UI구성을 위한 Look&Feel 용 component를 제공해주고 있다.
이 종류로써는 javax.swing.plaf.basic 패키지 내에 있는 Basic로 시작하는 클래스들이다.
또한 JPanel 같은 클래스는 panel 배경의 색깔을 바꾸는 방법이 있다.
JPanel 클래스를 상속하여, protected void paintComponent(Graphics g) 메소드를 오버라이딩 하여 재정의하면 된다.
해당 클래스내의 메소드는 java가 component를 구성하면서 내부적으로 호출하기 때문에 개발자는 메소드만 오버라이딩 해주면 된다.

아래 코드를 참고하여 실행하면 그 차이를 느낄 수 있다.

<기본으로 제공하는 component 를 사용하는 경우>
JScrollPane tableScrollPane = new JScrollPane();
JPanel panel = new JPanel();
panel.add(tableScrollPane);

<사용자 재정의 component 를 사용하는 경우>
JScrollPane tableScrollPane = new JScrollPane();
JPanel panel = new AutoSystemControlPanel();
tableScrollPane.getVerticalScrollBar().setUI(new PlayListScrollBarUI());
panel.add(tableScrollPane);

/**
* @author tobby48
* 2009. 07. 28
*/
public class AutoSystemControlPanel extends JPanel {

    public AutoSystemControlPanel(){
        setLayout(new BorderLayout());
        initComponents();
        setDoubleBuffered(false);
        setOpaque(false);
    }

    private void initComponents() {
        // TODO Auto-generated method stub
     ...
    }

    /* (non-Javadoc)
    * @see javax.swing.JComponent#paintComponent(java.awt.Graphics)
    */
    protected void paintComponent(Graphics g) {
        if (g instanceof Graphics2D) {
            Paint p = new GradientPaint(0.0f, 0.0f, new Color(
                    EnvValue.BACKGROUND_RED, EnvValue.BACKGROUND_GREEN,
                    EnvValue.BACKGROUND_BLUE, 50), getWidth(), getHeight(),
                    new Color(EnvValue.BACKGROUND_RED, EnvValue.BACKGROUND_GREEN,
                            EnvValue.BACKGROUND_BLUE, 150), true);
            Graphics2D g2d = (Graphics2D) g;
            g2d.setPaint(p);
            g2d.fillRect(0, 0, getWidth(), getHeight());
        } else {
            super.paintComponent(g);
        }
    }
}

/**
* @author tobby48
* 2009. 07. 28
*/
public final class PlayListScrollBarUI extends BasicScrollBarUI {
    /*
    * (non-Javadoc)
    * ScrollBar 를 구성할때의 색상을 지정, thumbRect와 trackRect 과 같은 필드는 api 를 참조하면 그림과 함께 어느것인지
     * 자세하게 나온다.
    * @see javax.swing.plaf.basic.BasicScrollBarUI#configureScrollBarColors()
    */
    protected void configureScrollBarColors() {
        thumbRect.width = 5;
        trackRect.width = 5;

        thumbColor = new Color(0x336699);
        thumbDarkShadowColor = new Color(0x009999);
        thumbHighlightColor = new Color(0xffccff);
        thumbLightShadowColor = new Color(0x99ccff);
        trackColor = new Color(0x99cccc);
        trackHighlightColor = new Color(0x006699);

//        AWTUtilitiesWrapper.setComponentShape((Window)thumbRect, shape);
    }

    /*
    * (non-Javadoc)
    * ScrollBar 상단에 화살표 모양의 버튼 색상 지정
    * @see javax.swing.plaf.basic.BasicScrollBarUI#createDecreaseButton(int)
    */
    protected JButton createDecreaseButton(int orientation) {
        JButton button = new BasicArrowButton(orientation);
        button.setBackground(new Color(51, 102, 153));
        button.setForeground(new Color(51, 102, 153));
        return button;
    }

    /*
    * (non-Javadoc)
    * ScrollBar 하단에 화살표 모양의 버튼 색상 지정
    * @see javax.swing.plaf.basic.BasicScrollBarUI#createIncreaseButton(int)
    */
    protected JButton createIncreaseButton(int orientation) {
        JButton button = new BasicArrowButton(orientation);
        button.setBackground(new Color(51, 102, 153));
        button.setForeground(new Color(51, 102, 153));
        return button;
    }
    @Override
    protected Dimension getMaximumThumbSize() {
        // TODO Auto-generated method stub
        return new Dimension(10, 20);
    }
}

위와 같이, JPanel 를 상속한 클래스를 사용하여 배경을 GradientPaint 효과를 준 뒤,
BasicScrollBarUI 클래스를 상속하여 ScrollBar를 재정의하여 JScrollPane 클래스의 getVerticalScrollBar().setUI() 를 사용하여
수직 스크롤바를 얻어 UI를 재정의한 클래스의 객체로 지정하게 되면 멋진 panel 과 scrollbar 를 얻을 수 있다.

Basic 계열 클래스들은 종류가 더 많다.
각자 취향에 맞는 component 를 구성해 보는것도 재미있는 시간이 될 것 같다.

tag : javax.swing.plaf.basic, paintComponent, setUI, BasicScrollBarUI, GradientPaint

[Java] mouseDragged()에서 흔들림 없이 Component 이동

tobby48 — Thu, 23 Jul 2009 02:04:38 GMT

어렵지 않은 부분이었지만 몇시간 동안 해맸네요.
계속 JPanel이 흔들려서 고생하였습니다.

아래 붉은 부분을 getLocationOnScreen() 을 쓰지 않고, frame.jPanel1.getMousePosition() 을 사용하다보니
계속 JPanel 이 흔들리더군요.
MouseEvent 객체인 e의 메소드인 getX() 와 getY() 값이 반복적으로 바뀌면서 흔들림이 일어났습니다.

네이버에 찾아보니 뚜렷한 방법은 없고, Adapter 로 구현해서 그렇다고들 하던데,
이벤트를 Adapter로 받지 않고 해보아도 동일한 문제가 있었기에 설득력이 없었습니다.

핵심코드는 붉은 색으로 표기하였습니다.

package gui;

import java.awt.BorderLayout;
import java.awt.Cursor;
import java.awt.Dimension;
import java.awt.Point;
import java.awt.event.MouseAdapter;
import java.awt.event.MouseEvent;
import java.awt.event.MouseListener;
import java.awt.event.MouseMotionAdapter;
import java.awt.event.MouseMotionListener;

import javax.swing.JFrame;
import javax.swing.JPanel;

public class MovePanel extends JFrame {

   /**
   *
   */
   private static final long serialVersionUID = 1L;

   public JPanel jPanel1 = new JPanel();

   /* move by mouse pointer */
   Point mainFrameLocation = new Point(0, 0);
   Point mouseClickedLocation = new Point(0, 0);

   public MovePanel() {

//       jPanel1.setOpaque(true);
       addMouseListener(new FrameMove_mouseAdapter(this));
       addMouseMotionListener(new FrameMove_mouseMotionAdapter(this));

       /* root frame */
       setDefaultCloseOperation(javax.swing.WindowConstants.DISPOSE_ON_CLOSE);
       setMinimumSize(new Dimension(200, 200));
       setUndecorated(true);

       getContentPane().add(jPanel1, BorderLayout.CENTER);
       setLocationRelativeTo(null);
   }

   public static void main(String[] args) {

       java.awt.EventQueue.invokeLater(new Runnable() {
           public void run() {

               MovePanel mainFrame = new MovePanel();
               mainFrame.setVisible(true);
           }
       });
   }
}

/**
* @author tobby48 2009. 07. 22
*/
class FrameMove_mouseAdapter extends MouseAdapter {
   private MovePanel frame;

   FrameMove_mouseAdapter(MovePanel mainframe) {
       this.frame = mainframe;
   }

   public void mousePressed(MouseEvent e) {
       frame.mouseClickedLocation.x = e.getX();
       frame.mouseClickedLocation.y = e.getY();
   }

   public void mouseReleased(MouseEvent e) {
   }
}

/**
* @author tobby48 2009. 07. 22
*/
class FrameMove_mouseMotionAdapter extends MouseMotionAdapter {
   private MovePanel frame;

   FrameMove_mouseMotionAdapter(MovePanel mainframe) {
       this.frame = mainframe;
   }

   public void mouseMove(MouseEvent e) {}

   public void mouseDragged(MouseEvent e) {
       frame.setLocation(e.getLocationOnScreen().x - frame.mouseClickedLocation.x,
               e.getLocationOnScreen().y - frame.mouseClickedLocation.y);
   }
}

tag : 드래그앤드롭, MouseMotionListner, component, 이동, getLocationOnScreen, getMousePosition, mouseDragged, drag

리눅스 한글깨짐

tobby48 — Wed, 10 Jun 2009 08:53:00 GMT

http://blog.naver.com/ckwnan?Redirect=Log&logNo=20054958713

[JAVA] jfreechart를 이용하여 차트 그리기

tobby48 — Sun, 07 Jun 2009 23:57:27 GMT

jfreechart를 이용하여 차트 그리기

어떤 국가의 구매 고객이 많은지 알아보기 위하여 국가별로 한 번이라도 상품을 구매한 적이 있는 고객을 대상으로 하여 국가별 구매 고객 비율을 파이차트로 그려 보자.

다음이 과정은 이미 시행되었음을 가정한다.

① 이클립스와 톰켓을 다운로드 하여 설치하고, 이들을 연동 시킨다.

② jdbcdeom를 다운로드한 후, 이클립스에 프로젝트에 추가한다.

[File] → [Import] → [General] → [Existing projects into Workspace]

☞ jdbcdemo 다운로드

③ 다음을 다운로드 하여 압축을 풀고 lib에 추가한다.

☞ 추가할 라이브러리 다운로드

① SQL 쿼리를 작성하고 그 결과를 확인해 보자.

[SQL]

select country_name as nation, count,
    to_char(RATIO_TO_REPORT(count) OVER (), '9.999') AS ratio
from(
    select country_id, count(*) as count
    from (
      SELECT country_id
      FROM customers Cu
      WHERE EXISTS (
        SELECT *
        FROM Sales S
        WHERE Cu.cust_id=S.cust_id
      )
    )
    group by country_id
) T, countries Co
where T.country_id=Co.country_id
order by count

[result]

② 작성된 SQL 쿼리를 바탕으로 파이차트를 그리기 위해 어떤 데이터셋을 사용할 것인지 판단하여야한다. 데이터셋으로는 DefaultPieDataset 클래스를 이용하기로 하고, 파이차트를 그리기 위해 ChartFactory클래스의 createPieChart 메서드를 이용한다.

■ DefaultPieDataset 클래스의 setValue 메서드

■ ChartFactory 클래스의 createPieChart 메서드

③ index.jsp와 BarChart.java를 다음과 같이 수정한다.

[index.jsp]

<%@ page language="java" contentType="text/html; charset=EUC-KR"

pageEncoding="EUC-KR"%>

<%@page import="java.sql.*"%>

<%@page import="lab.s2c.jdbc.DBHandle"%>

<%@page import="lab.s2c.chart.*"%>

<%@page import="org.jfree.chart.servlet.ServletUtilities"%>

Connection conn = null;

ResultSet rs = null;

Statement stmt = null;

ResultSetMetaData rsmd = null;

int columnCount = 0;

String sql =

"select country_name as nation, count, "

+" to_char(RATIO_TO_REPORT(count) OVER () , '9.999') AS ratio "

+"from( "

+" select country_id, count(*) as count "

+" from ( "

+" SELECT country_id "

+" FROM customers Cu "

+" WHERE EXISTS ( "

+" SELECT * "

+" FROM Sales S "

+" WHERE Cu.cust_id = S.cust_id "

+" ) "

+" group by country_id "

+") T, countries Co "

+"where T.country_id= Co.country_id "

+"order by count ";

DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">

<html>

<head>

<title>JDBC Demotitle>

head>

<body>

try {

conn = (new DBHandle()).dbConnection();

stmt = conn.createStatement();

rs = stmt.executeQuery(sql);

rsmd = rs.getMetaData();

columnCount = rsmd.getColumnCount();

<h3>Result by Tableh3>

<thead>

for (int i=0; i< columnCount; i++) {

}

tr>

thead>

<tbody>

while(rs.next()) {

for (int i=0; i< columnCount; i++) {

}

tr>

}

tbody>

table>

<h3>Result by Charth3>

/*PieChart*/

Chart pieChart = new Chart();

rs = stmt.executeQuery(sql);

while(rs.next()) {

pieChart.addValue(rs.getString(1),rs.getDouble(3));

}

String fileName = ServletUtilities.saveChartAsPNG(pieChart.createPieChart

("Pie Chart - Buyer Ratio"), 600, 500, session);

String graphURL = request.getContextPath() + "/displayChart?filename=" +

fileName;

rs.close();

stmt.close();

conn.close();

}catch(Exception e) {

out.print("Occured Exception");

}

body>

html>

[Chart.java]

package lab.s2c.chart;

import org.jfree.chart.ChartFactory;

import org.jfree.chart.JFreeChart;

import org.jfree.data.general.DefaultPieDataset;

public class Chart {

private DefaultPieDataset dataset = null;

public Chart(){

this.dataset = new DefaultPieDataset();

}

public void addValue(String key, double value){

this.dataset.setValue(key, value);

}

public JFreeChart createPieChart(String title){

JFreeChart chart = ChartFactory.createPieChart(

title, //java.lang.String title

dataset, //PieDataset dataset

false, //boolean legend

false, //boolean tooltips

false); //java.util.Locale locale

return chart;

}

[result]

[출처] jfreechart를 이용하여 차트 그리기 |작성자 유노추노

[Java] 비행기 시뮬레이션

tobby48 — Thu, 04 Jun 2009 07:33:37 GMT

[본 코드는 퍼가실때 댓글 남겨주세요.]

과제알바로 구현해봤던 것..

콘솔로 Landing , Terminal , Take-off 상태 표시
동적 메모리 할당 알고리즘 FF, BF, LF 는 미구현
국제선, 국내선 간에 우선순위 큐 적용

일단 비행기 도착시간이 저장된 파일이 필요 (아래 data.txt파일)

5개 java 파일과 data.txt 파일을 같은 디렉토리에 놓고,

javac *.java 컴파일 후,
java AirportSim data.txt 로 실행

<< 파일명 : data.txt >>
70000 D
60000 I
50000 I
10015 D
10014 D
10013 I
10012 D
10011 I
10010 I
10009 D
10008 D
10007 D
10006 I
10005 I
10004 D
10003 D
10002 D
10001 I
10000 I
5000 D
4000 D
3000 I
2000 D
1000 I
1 D

import java.io.IOException;

/**
* 최초 비행기 시뮬레이션을 실행하기 위한 클래스
*
*
* @author tobby48 2009. 06. 02
*/
public class AirportSim {
    final static int MAX_MODEL_TIME = 86400;

    final static int LQ_NS = 2; // number of landing queue servers

    final static int LQ_ST = 6; // landing queue service time (minutes)

    final static int LQ_OT = 'F'; // landing queue operation/scheduling type

    final static int TQ_NS = 3; // number of terminal queue servers

    final static int TQ_ST = 20; // terminal queue service time (minutes)

    final static int TQ_OT = 'B'; // terminal queue operation/scheduling type

    final static int TOQ_NS = 1; // number of take?off queue servers

    final static int TOQ_ST = 12; // take?off queue service time (minutes)

    final static int TOQ_OT = 'F'; // take?off queue operation/scheduling type

    /**
    * @param args
    */
    public static void main(String args[]) {
        External_File dataFile = null;
        try {
            dataFile = new External_File(args[0]);
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        Simulate Airport = new Simulate(MAX_MODEL_TIME, LQ_NS, LQ_ST, LQ_OT,
                TQ_NS, TQ_ST, TQ_OT, TOQ_NS, TOQ_ST, TOQ_OT);
        Airport.Init_Simulation(dataFile);
        Airport.Run_Simulation();
        Airport.End_Simulation();
    }

}

import java.io.BufferedReader;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStreamReader;

/**
* arrival time 이 저장된 파일의 내용을 읽기 위한 클래스
*
* @author tobby48 2009. 06. 02
*/
public class External_File {
    private BufferedReader Ext_File;

    /**
    * 생성자
    *
    * @param ext_file
    *            파일의 경로
    * @throws IOException
    */
    public External_File(String ext_file) throws IOException {
        Ext_File = new BufferedReader(new InputStreamReader(
                new FileInputStream(ext_file)));
    }

    /**
    * 파일의 내용을 한줄씩 문자열로 리턴
    *
    * @return
    * @throws IOException
    */
    public String getLine() throws IOException {
        return Ext_File.readLine();
    }

    /**
    * 파일의 끝을 알림
    *
    * @return
    * @throws IOException
    */
    public boolean havehitEOF() throws IOException {
        return !Ext_File.ready();
    }

    /**
    * 파일읽기 완료 후 파일을 위한 리더(BufferedReader)을 닫음
    *
    * @throws IOException
    */
    public void close() throws IOException {
        Ext_File.close();
    }

}

import java.util.Vector;

/**
* 비행기 클래스
*
* @author tobby48 2009. 06. 02
*/
public class Plane {
    /**
    * 비행기 ID
    */
    private Integer id;

    /**
    * 비행기 arrival time
    */
    private Integer arrivalTime;

    /**
    * 비행기 service 시작시간을 Vector로 저장(landing, terminal, takeoff 각각)
    */
    private Vector serviceStartTime;

    /**
    * 비행기 service 종료시간을 Vector로 저장(landing, terminal, takeoff 각각)
    */
    private Vector serviceEndTime;

    /**
    * 비행기 waiting 시간을 Vector로 저장(landing, terminal, takeoff 각각)
    */
    private Vector waitingTime;

    /**
    * 비행기가 서비스를 받는 시간
    */
    private Integer servicingTime;

    /**
    * 국제선, 국내선 인지 판별(국내선 'D', 국제선 'I')
    */
    private Character airlineType;

    /**
    * 생성자
    *
    * @param arrivalTime
    *            비행기 도착시간
    */
    public Plane(Integer arrivalTime) {
        this.arrivalTime = arrivalTime;
        this.serviceStartTime = new Vector();
        this.serviceEndTime = new Vector();
        this.waitingTime = new Vector();
        this.servicingTime = new Integer(0);
    }

    /**
    * 해당 server에 대한 service 종료시간을 리턴
    *
    * @param serverIndex
    *            server 인덱스
    * @return 서비스 종료시간
    */
    public Integer getServiceEndTime(Integer serverIndex) {
        return serviceEndTime.get(serverIndex);
    }

    /**
    * 파라미터의 시간으로 service 종료시간을 추가
    *
    * @param serverIndex
    *            서비스 종료시간
    */
    public void addServiceEndTime(Integer serverIndex) {
        this.serviceEndTime.add(serverIndex);
    }

    /**
    * 비행기 ID 리턴
    *
    * @return 비행기 ID
    */
    public Integer getId() {
        return id;
    }

    /**
    * 비행기 ID 지정
    *
    * @param id
    *            비행기 ID
    */
    public void setId(Integer id) {
        this.id = id;
    }

    /**
    * 비행기 도착시간 리턴
    *
    * @return 비행기 도착시간
    */
    public Integer getArrivalTime() {
        return arrivalTime;
    }

    /**
    * 비행기 대기시간 추가
    *
    * @param time
    *            비행기 대기시간
    */
    public void addWaitingTime(Integer time) {
        this.waitingTime.add(time);
    }

    /**
    * 해당 서버의 대기시간 리턴
    *
    * @param serverIndex
    *            서버 인덱스
    * @return 해당 서버의 대기시간
    */
    public Integer getWaitingTime(Integer serverIndex) {
        return waitingTime.get(serverIndex);
    }

    /**
    * 해당 서버의 서비스 시작시간을 리턴
    *
    * @param serverIndex
    *            서버 인덱스
    * @return 서비스 시작시간
    */
    public Integer getServiceStartTime(Integer serverIndex) {
        return serviceStartTime.get(serverIndex);
    }

    /**
    * 서비스 시작시간 추가
    *
    * @param time
    *            서비스 시작시간
    */
    public void addServiceStartTime(Integer time) {
        this.serviceStartTime.add(time);
    }

    /**
    * 서비스 받은 시간을 리턴
    *
    * @return 서비스 받은 시간
    */
    public Integer getServicingTime() {
        return servicingTime;
    }

    /**
    * 서비스 받는 중(서비스 시간을 증가)
    */
    public void addServicingTime() {
        Integer temp = this.getServicingTime();
        this.servicingTime = ++temp;
    }

    /**
    * 서비스 받는 중일때 서비스 시간을 갱신
    *
    * @param time
    *            서비스 경과 시간
    */
    public void setServicingTime(Integer time) {
        this.servicingTime = time;
    }

    /**
    * 비행기 타입을 리턴
    *
    * @return 비행기가 국내선인지 국제선인지 리턴
    */
    public Character getAirlineType() {
        return airlineType;
    }

    /**
    * 비행기 타입을 지정
    *
    * @param airlineType
    *            비행기 타입('D' or 'I')
    */
    public void setAirlineType(Character airlineType) {
        this.airlineType = airlineType;
    }
}

import java.util.Vector;

/**
* 시뮬레이션 동작을 수행 및 통괄하는 클래스
*
* @author tobby48 2009. 06. 02
*/
public class Server {
    /**
    * 서비스중인 비행기를 저장한 객체
    */
    private Vector planeQueue;
    /**
    * 대기시간을 저장한 객체
    */
    private Vector waitingTimeQueue;

    /**
    * 전체 수행시간을 저장한 객체
    */
    private Vector totalOperatingTime;

    /**
    * 서버수를 임시로 저장
    */
    private Integer serverNumTemp; // number of queue servers

    /**
    * 서비스 시간, 초단위로 저장하기 위해 *60
    */
    private Integer serviceTime; // queue service time (minutes)

    /**
    * First Fit, Best Fit, Least Fit 알고리즘
    */
    private Integer osType; // queue operation/scheduling type

    /**
    * 서버수
    */
    private Integer serverNum;

    /**
    * 생성자 초기값 설정
    *
    * @param serverNum
    *            서버수
    * @param serviceTime
    *            서비스 시간
    * @param osType
    *            FF, BF, LF 알고리즘
    */
    public Server(Integer serverNum, Integer serviceTime, Integer osType) {
        this.planeQueue = new Vector();
        this.waitingTimeQueue = new Vector();
        this.totalOperatingTime = new Vector(serverNum);
        for (int i = 0; i < serverNum; i++) {
            this.totalOperatingTime.add(i, 0);
        }
        this.serverNumTemp = this.serverNum = serverNum;
        this.serviceTime = serviceTime * 60;
        this.osType = osType;
    }

    /**
    * 비행기를 큐에 저장 서버수만큼은 바로 서비스를 제공하기 위해 큐에 서비스시간과 다음 서비스 시작시간을 저장 서버수를 초과할 시에는
    * 대기시간으로 인해 다음 서비스 시작시간을 모르기 때문에 저장하지 않음
    *
    * @param plane
    *            비행기
    * @param currentTime
    *            현재시간
    */
    public void addPlane(Plane plane, Integer currentTime) {

        /* service 갯수가 수요량을 충족하기 때문에 바로 service */
        if (serverNumTemp > 0)
            serverNumTemp--;

        /* service 시작, 대기, 종료, 다음 서버의 시작시간을 지정 */
        plane.setServicingTime(0);
        plane.addServiceStartTime(currentTime);
        planeQueue.add(plane);
    }

    /**
    *     큐 안의 비행기들을 국제선, 국내선 우선순위에 의해서 재배치 유무
    * @return    큐 안의 비행기들을 재배치 유무
    */
    private boolean rearrangeStatQueue() {
        int stat1 = 0, stat2 = 0;

        /* 재배치할 필요없는 조건 */
        for (int jj = 0; jj < planeQueue.size(); jj++) {
            /* 서버수 내에 있는 비행기가 모두 국제선일 경우에는 재배치할 필요가 없다. */
            if ((jj < (serverNum - serverNumTemp))
                    && (planeQueue.get(jj).getAirlineType() == 'I'))
                stat1++;
            /* 서버수 밖에 있는 비행기가 모두 국내선일 경우에는 재배치할 필요가 없다. */
            else if (((serverNum - serverNumTemp) <= jj)
                    && (planeQueue.get(jj).getAirlineType() == 'D'))
                stat2++;
        }

        /* 위 조건 두개를 다 만족안해야만 TRUE 를 리턴하여 재배치한다. */
        if (stat1 != (serverNum - serverNumTemp))
            return true;
        else if (stat2 != (planeQueue.size() - (serverNum - serverNumTemp)))
            return true;
        else
            return false;
    }

    /**
    *     큐 안의 비행기들을 재배치
    */
    private void rearrangeQueue() {

        /* 재배치할 필요 없는 조건에 둘다 만족 안할때만 재배치 */
        if (rearrangeStatQueue()
                && ((serverNum - serverNumTemp) < planeQueue.size())) {

            /* 큐 안의 비행기만을 체크 */
            for (int i = serverNum - serverNumTemp; i < planeQueue.size(); i++) {
                Plane plane = planeQueue.get(i);

                /* 서버수 내에 D가 있으면 서버수 밖의 I를 끼워넣고, D는 한칸 밀림 */
                if (plane.getAirlineType() == 'I') {
                    for (int ii = 0; ii < (serverNum - serverNumTemp); ii++) {
                        if (planeQueue.get(ii).getAirlineType() == 'D')
                            planeQueue.add(ii, planeQueue.remove(i));
                    }
                }

                /* 더이상 재배치할 필요가 없으면 For문 빠져나옴 */
                if (!rearrangeStatQueue())
                    break;
            }
        }
    }

    /**
    * 현재시간을 매번 체크하여, 서비스종료되는 비행기를 추적 TRUE를 리턴하면 서비스 종료되는 비행기가 있다.
    *
    * @param serverIndex
    *            서버 인덱스
    * @param currentTime
    *            현재시간
    * @return 서비스 종료되는 비행기 있다 없다?
    */
    public Plane upDate(Integer serverIndex, Integer currentTime) {

        /* 큐가 있다면 */
        if (planeQueue.isEmpty())
            return null;

        /* 국제선, 국내선 간에 큐를 재배치 */
        rearrangeQueue();

        /* 서버수 내에 있는 비행기들은 서비스를 받기 때문에 서비스 받는시간을 증가 */
        for (int i = 0; i < (serverNum - serverNumTemp); i++) {
            Plane plane = planeQueue.get(i);
            plane.addServicingTime();

            /* 서비스를 받던 시간이 서비스 시간과 같다면, 서비스가 종료된 것이기 때문에 다음 서버로 넘겨줘야 한다. */
            if (plane.getServicingTime().intValue() - 1 == serviceTime) {

                /* 서비스 종료시간과 대기시간을 저장 */
                plane.addWaitingTime(currentTime - serviceTime
                        - plane.getServiceStartTime(serverIndex));
                plane.addServiceEndTime(plane.getServiceStartTime(serverIndex)
                        + plane.getWaitingTime(serverIndex));

                /* waitingTime 및 operationTime 저장 */
                waitingTimeQueue.add(currentTime - serviceTime
                        - plane.getServiceStartTime(serverIndex));
                totalOperatingTime.add(i, totalOperatingTime.get(i)
                        + serviceTime);

                /* 서비스 종료된 비행기를 큐에서 삭제 */
                Plane endingPlane = planeQueue.remove(i);

                /*
                * 서비스 종료된 비행기를 리턴, 큐 크기가 서버수 보다 같거나 클땐, 서버 수를 하나 줄인다. 처음에 큐에 저장할 시에 덜
                * 줄였던 서버수를 여기서 줄임
                */
                if (planeQueue.size() < serverNum)
                    serverNumTemp++;

                return endingPlane;

            }
        }
        return null;
    }

    /**
    * 서버수를 리턴
    *
    * @return 서버수
    */
    public Integer getServerNum() {
        return serverNum;
    }

    /**
    * 서비스 시간 리턴
    *
    * @return 서비스 시간
    */
    public Integer getServiceTime() {
        return serviceTime;
    }

    /**
    * First Fit, Best Fit, Least Fit 알고리즘 리턴
    *
    * @return First Fit, Best Fit, Least Fit 알고리즘
    */
    public Character getOsType() {
        return (char) (osType - 0);
    }

    /**
    * 대기시간의 평균을 리턴
    *
    * @return 대기시간 평균
    */
    public Integer getAvgWaitingTime() {
        Integer avgValue = new Integer(0);
        for (int i = 0; i < waitingTimeQueue.size(); i++)
            avgValue += waitingTimeQueue.get(i);
        avgValue /= waitingTimeQueue.size();
        return avgValue;
    }

    /**
    * 전체 대기시간 리턴
    *
    * @return 전체 대기시간
    */
    public Integer getTotalWaitingTime() {
        Integer tatalValue = new Integer(0);
        for (int i = 0; i < waitingTimeQueue.size(); i++)
            tatalValue += waitingTimeQueue.get(i);
        return tatalValue;
    }

    /**
    * 가장 큰 대기시간 리턴
    *
    * @return 가장 큰 대기시간
    */
    public Integer getMaxWaitingTime() {
        Integer maxValue = new Integer(0);
        for (int i = 0; i < waitingTimeQueue.size() - 1; i++) {
            if (waitingTimeQueue.get(i).compareTo(waitingTimeQueue.get(i + 1)) < 0)
                maxValue = waitingTimeQueue.get(i + 1);
        }
        return maxValue;
    }

    /**
    * 해당 서버의 전체 서비스를 제공한 시간을 리턴
    *
    * @param index
    *            서버 인덱스
    * @return
    */
    public Integer getTotalIdleTime(Integer index) {
        return totalOperatingTime.get(index);
    }
}

import java.io.IOException;
import java.util.ArrayList;
import java.util.Stack;
import java.util.Vector;

/**
* 시뮬레이션에 대한 초기설정과 출력결과를 보여주는 클래스
*
* @author tobby48 2009. 06. 02
*/
public class Simulate {
    /**
     * 전체 시간 (여기서는 하루(86400초)
     */
    private int MAX_MODEL_TIME;
    /**
     * 최종 결과를 저장할 ArrayList 객체
     */
    private ArrayList resultPlaneList;
    /**
     * Landing을 위한 Server 객체
     */
    private Server arrivalServer;
    /**
     * Terminal을 위한 Server 객체
     */
    private Server terminalServer;
    /**
     * Takeoff을 위한 Server 객체
     */
    private Server takeoffServer;

    /**
     * 생성자 Main함수가 있는 클래스로부터 초기값들을 넘겨받은 뒤, 각각의 Server객체를 초기화한다.
     *
     * @param maxModelTime
     * @param lqNs
     * @param lqSt
     * @param lqOt
     * @param tqNs
     * @param tqSt
     * @param tqOt
     * @param toqNs
     * @param toqSt
     * @param toqOt
     */
    public Simulate(int maxModelTime, int lqNs, int lqSt, int lqOt, int tqNs,
            int tqSt, int tqOt, int toqNs, int toqSt, int toqOt) {
        // TODO Auto-generated constructor stub
        this.MAX_MODEL_TIME = maxModelTime;

        resultPlaneList = new ArrayList();
        arrivalServer = new Server(lqNs, lqSt, lqOt);
        terminalServer = new Server(tqNs, tqSt, tqOt);
        takeoffServer = new Server(toqNs, toqSt, toqOt);
    }

    /**
     * data file 을 읽어서 arrival time 을 stack 에 추가하는 함수
     *
     * @param dataFile
     *            arrival time이 저장된 파일
     */
    public void Init_Simulation(External_File dataFile) {
        // TODO Auto-generated method stub

        Vector tempArrivalTime = new Vector();
        Vector tempAirplaneType = new Vector();
        Integer id = new Integer(0);

        /*    파일에서 arriveTime을 저장할 Stack    */
        Stack arriveStack = new Stack();
        Stack airplaneStack = new Stack();

        try {
            /* data file 을 한 라인씩 읽어서 Stack에 저장 */
            while (!dataFile.havehitEOF()) {
                String[] tempArray = dataFile.getLine().split(" ");
                arriveStack.add(Integer.parseInt(tempArray[0]));
                airplaneStack.add(tempArray[1].charAt(0));
            }

            /* 정렬을 위한 임시벡터에 저장 */
            while(!arriveStack.isEmpty())
                tempArrivalTime.add(arriveStack.pop());

            /* 정렬을 위한 임시벡터에 저장 */
            while(!airplaneStack.isEmpty())
                tempAirplaneType.add(airplaneStack.pop());

            /* arrival time 으로 정렬    */
            for (int i = 0; i < tempArrivalTime.size() - 1; i++) {
                for (int j = i; j < tempArrivalTime.size(); j++) {

                    if (Integer.valueOf(tempArrivalTime.get(i)) > Integer.valueOf(tempArrivalTime.get(j))) {
                        Integer temp = tempArrivalTime.get(i);
                        tempArrivalTime.set(i, tempArrivalTime.get(j));
                        tempArrivalTime.set(j, temp);

                        Character tempChar = tempAirplaneType.get(i);
                        tempAirplaneType.set(i, tempAirplaneType.get(j));
                        tempAirplaneType.set(j, tempChar);
                    }
                }
            }

            /* plane의 id값, 국내선인지 국제선인지 저장 */
            while (id < tempArrivalTime.size()){
                Plane plane = new Plane(tempArrivalTime.get(id));
                plane.setId(id + 1);
                plane.setAirlineType(tempAirplaneType.get(id));
                resultPlaneList.add(plane);
                id++;
            }

        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }

    /**
     * 시뮬레이션 동작을 수행하는 함수
     */
    public void Run_Simulation() {

        /* 초기화 */
        Integer currentTime = new Integer(0);
        Integer index = new Integer(0);
        boolean stat = false;

        // TODO Auto-generated method stub
        /*
         * while 구문 안쪽
         * 1. 현재시간을 계속 증가
         * 2. stack에 저장된 비행기의 arrival time을 가져와 arrival 대기 큐에 저장
         * 3. stack에 있는 비행기를 추가하기 위해 arrival 큐에 비행기를 추가할수 있는지 여부를 체크
         * 4. 비행기의 arrival(현재시간) 값 만큼 arrival queue을 업데이트 시킨다.
         * 5. arrival queue에서 서비스시간 끝난 비행기에 대해서는 terminal queue로 이동(3번~5번 과정 순차적 체크)
         * 6. takeoff queue까지 업데이트를 완료한 다음 1번과정 반복
         */

        /*    최초 arrival time 값을 얻음    */
        Plane plane = resultPlaneList.get(index);

        /*    1일 동안의 비행 시뮬레이션 동작    */
        while (currentTime <= MAX_MODEL_TIME) {
            Plane tempPlane;

            /*    stack안의 arrival time을 모두 arrival 대기큐에 저장    */
            if (!stat && currentTime.equals(plane.getArrivalTime())) {
                arrivalServer.addPlane(plane, currentTime);

                /*    stack이 비어있다면 더이상 pop을 수행하지 않음    */
                if (index < (resultPlaneList.size()-1))
                    plane = resultPlaneList.get(++index);
                else
                    stat = true;

                /*    동일한 도착시간을 가진 비행기를 처리하기 위해 현재시간을 증가시키지 않고 continue    */
                if(currentTime.equals(plane.getArrivalTime()))
                    continue;
            }

            /*    현재시간으로부터 각각의 Server객체들이     landing -> terminal -> takeoff 로의 이동
             *
             *     landing 과정이 끝난 plane은 terminal로,
             *     terminal 과정이 끝난 plane은 takeoff로,
             *     takeoff 과정이 끝난 plane은 최종 plane객체들을 저장하는 ArrayList객체에 저장*/
            while ((tempPlane = arrivalServer.upDate(0, currentTime)) != null)
                terminalServer.addPlane(tempPlane, currentTime);

            while ((tempPlane = terminalServer.upDate(1, currentTime)) != null)
                takeoffServer.addPlane(tempPlane, currentTime);

            while ((tempPlane = takeoffServer.upDate(2, currentTime)) != null);

            currentTime++;
        }
    }

    /**
     *     시뮬레이션 결과값을 출력하는 함수
     */
    public void End_Simulation() {
        // TODO Auto-generated method stub
        System.out.println("*******************************************");
        System.out.println("*************** AIRPORT MODELING SIMULATION");
        System.out.println("*******************************************");
        System.out.println("\nMODELING PARAMETERS:");
        System.out.println("=======================");
        System.out.println("Total Time Of Simulation (Servers Operating) : "
                + MAX_MODEL_TIME + " seconds");
        System.out.println("\nAirport Service\tNumber\tService Time\tServer");
        System.out.println("Operation Type\tServers\tsecs.\tmin.\tScheduling");
        System.out.println("===============\t=======\t============\t===========");
        System.out.println("Landing Runways\t" + arrivalServer.getServerNum()
                + "\t" + arrivalServer.getServiceTime() + "\t"
                + +arrivalServer.getServiceTime() / 60 + "\t"
                + arrivalServer.getOsType());
        System.out.println("Terminal Gates\t" + terminalServer.getServerNum()
                + "\t" + terminalServer.getServiceTime() + "\t"
                + +terminalServer.getServiceTime() / 60 + "\t"
                + terminalServer.getOsType());
        System.out.println("Take-Off\t" + takeoffServer.getServerNum() + "\t"
                + takeoffServer.getServiceTime() + "\t"
                + +takeoffServer.getServiceTime() / 60 + "\t"
                + takeoffServer.getOsType());
        System.out.println("\nINDIVIDUAL PLANE INFORMATION AT DEPARTURE:    (All times in seconds)");
        System.out.println("===========================================");
        System.out.println("\n\tPlane\tInternational/\tTime\tTime\tLQ Wt.\tTime\tTime\tLQ Wt.\tTime\tTime\tLQ Wt.");
        System.out.println("#\tID#\tDomestic Type\tIn LQ\tOut LQ\tTime\tIn LQ\tOut LQ\tTime\tIn LQ\tOut LQ\tTime");
        System.out.println("==\t=====\t=============\t=====\t======\t======\t=====\t======\t======\t=====\t======\t======");

        for (int i = 0; i < resultPlaneList.size(); i++) {
            Plane plane = resultPlaneList.get(i);
            System.out.println(i + 1 + "\t" + plane.getId() + "\t" + plane.getAirlineType() + "\t\t"
                    + plane.getServiceStartTime(0) + "\t"
                    + plane.getServiceEndTime(0) + "\t"
                    + plane.getWaitingTime(0) + "\t"
                    + plane.getServiceStartTime(1) + "\t"
                    + plane.getServiceEndTime(1) + "\t"
                    + plane.getWaitingTime(1) + "\t"
                    + plane.getServiceStartTime(2) + "\t"
                    + plane.getServiceEndTime(2) + "\t"
                    + plane.getWaitingTime(2));
        }
        System.out.println("\nSUMMARY OF PLANE INFORMATION STATISTICS: (All times in seconds)");
        System.out.println("========================================");
        System.out.println("Number of Planes processed: " + resultPlaneList.size());
        System.out.println("\nAirport Service\t\tTotal Wait\tAverage\t\tMaximum");
        System.out.println("Operation Type\t\tTime\t\tWait Time\tWait Time");
        System.out.println("===============\t\t==========\t============\t===========");
        System.out.println("Landing Runways\t\t"
                + arrivalServer.getTotalWaitingTime() + "\t\t"
                + arrivalServer.getAvgWaitingTime() + "\t\t"
                + arrivalServer.getMaxWaitingTime());
        System.out.println("Terminal Gates\t\t"
                + terminalServer.getTotalWaitingTime() + "\t\t"
                + terminalServer.getAvgWaitingTime() + "\t\t"
                + terminalServer.getMaxWaitingTime());
        System.out.println("Take-Off Runways\t"
                + takeoffServer.getTotalWaitingTime() + "\t\t"
                + takeoffServer.getAvgWaitingTime() + "\t\t"
                + takeoffServer.getMaxWaitingTime());
        System.out.println("\nSUMMARY OF SERVER INFORMATION STATISTICS: (All times in seconds)");
        System.out.println("========================================");
        System.out.println("\n                    Server    Total Time      Total Idle     Percent");
        System.out.println("Server Type           #       In Operation      Time        Idle Time");
        System.out.println("================    ======    ============    ===========   ==========");
        System.out.println("Landing Server:");
        for (int j = 0; j < arrivalServer.getServerNum(); j++) {
            System.out.println("\t\t\t" + (j + 1) + "\t" + MAX_MODEL_TIME
                            + "\t\t" + (MAX_MODEL_TIME - arrivalServer.getTotalIdleTime(j))
                            + "\t\t" + ((MAX_MODEL_TIME - arrivalServer.getTotalIdleTime(j)) * 100 / MAX_MODEL_TIME)
                            + "%");
        }
        System.out.println("Terminal Server:");
        for (int j = 0; j < terminalServer.getServerNum(); j++) {
            System.out.println("\t\t\t" + (j + 1) + "\t" + MAX_MODEL_TIME
                            + "\t\t" + (MAX_MODEL_TIME - terminalServer.getTotalIdleTime(j))
                            + "\t\t" + ((MAX_MODEL_TIME - terminalServer.getTotalIdleTime(j)) * 100 / MAX_MODEL_TIME)
                            + "%");
        }
        System.out.println("Take-Off Server:");
        for (int j = 0; j < takeoffServer.getServerNum(); j++) {
            System.out.println("\t\t\t" + (j + 1) + "\t" + MAX_MODEL_TIME
                            + "\t\t" + (MAX_MODEL_TIME - takeoffServer.getTotalIdleTime(j))
                            + "\t\t" + ((MAX_MODEL_TIME - takeoffServer.getTotalIdleTime(j)) * 100 / MAX_MODEL_TIME)
                            + "%");
        }
    }
}

희귀? 최소자승법?

tobby48 — Tue, 26 May 2009 00:49:40 GMT

1. 회귀의 개념
두 변인이 일관된 관계일 때 한 변인의 알려진 값을 이용하여 다른 쪽의 대응 값을 예측 할 수 있다.한 변인을 다른 변인으로부터 예언하는 문제를 회귀라 부른다. 회귀라는 용어는 변인들 사이의 관계성을 기술하고 한 변인을 다른변인으로부터 예언하는 다양한 기법들을 의미한다.

2. 최소자승법이란?
일반적으로 두 변인 X와 Y간의 직선관계를 방정식으로 나타낼 수 있다. 이 때,
와 같은 회귀선으로 나타낸다. 이러한 X, Y 두 변인 사이의 관계를 분석하는 것을 단순회귀분석이라 한다. 이 때 적합한회귀선을 구하기 위하여 이용되는 기준을 최소자승법이라 한다. 즉, 에서 다른 직선들의 b0와 b1의 구체적인 값들은 서로 다를것이다. 목적은 어떤 선이 실제 자료점들과 가장 근접한지를 결정하는 것이다. 직선이 자료점들에 얼마나 적합한지를 판정하려면 첫단계는 각 자료점과 직선 사이의 거리를 수학적으로 정하는 것이다. 자료의 모든 X값에 대하여 직선방정식은 직선 위의 Y값을결정할 것이다. 이 값은 예측된 Y이고 으로 표기한다.
실제 자료점(Y)과 직선위의 예측된 점간의 수직적 거리를 측정하며 이 거리는 직선과 실제자료 사이의 오차를 측정한다.실제자료점(Y)과 직선상의 예측점()간의 거리는 Y-‘으로 나타낸다. 회귀의 목표는 이 거리를 최소화하는 직선의 방정식을 찾는것이다.
이 거리중 어떤것은 (+)이고 어떤 것은 (-)일 것이므로 오차의 일률적인 측정치를 얻기 위해 각 거리를 자승하여 합하는 과정이필요하다. 다음으로 직선과 자료간의 전체 오차를 결정하기 위하여 모든 자료점에 대해 자승된 오차를 합한다. 따라서, 최소자승법은이러한 오차들의 자승의 합(∑e2)이 최소가 되게 하는 일차방정식을 구하는 과정이다.

[출처]
http://mybox.happycampus.com/cwk11/689327

DT regression test

tobby48 — Tue, 26 May 2009 00:42:59 GMT

회귀 테스트(regression test)란 소프트웨어의 유지보수단계에서수행하는 테스트중 한가지로서, 어떤 프로그램에 수정이 가해진 이후에 해당 프로그램이 제대로 동작하는 것을 확인하기 위해 수행되는 테스트를 말합니다.

SQL에서의 Regression Test라고 하는 것은 어떤 Query를 변경하였을 때, 그 Query의 실행 결과를 참조하는 곳에서 제대로 기능을 수행하는지를 검증하는 테스트를 말합니다.

[출처]

http://kin.naver.com/detail/detail.php?d1id=1&dir_id=10110&eid=yX6RP9Ia+Ny70KD8xzAtO9Je+HsUhrI8&qb=cmVncmVzc2lvbg==&enc=utf8&pid=fmVIodoi5U4ssctveiRsss--247541&sid=Shs2HjAjG0oAABpQD@c