package test.core;

import java.util.HashSet;

public class MyObject
{
    State state = State.State1;
    HashSet<MyObjectObserver> observers =  new HashSet<MyObjectObserver>();

    public static enum State
    {
        State1,
        State2,
        State3
    }

    public synchronized void addObserver(MyObjectObserver observer)
    {
        if(observer != null)
            observers.add(observer);
    }

    public synchronized void removeObserver(MyObjectObserver observer)
    {
        observers.remove(observer);
    }

    public synchronized void setState(State newState)
    {
        if(state != newState)
        {
            State oldState = state;
            state = newState;
            for(MyObjectObserver observer : observers)
            {
                observer.onStateChanged(oldState, newState);
            }
        }
    }

    public synchronized State getState()
    {
        return state;
    }
}

package test.core;

public interface MyObjectObserver
{
    public void onStateChanged(MyObject.State oldState, MyObject.State newState);
}

package test;

import test.core.MyObject;

public interface Application
{
    public void run(MyObject object);
}

package test.cli;

import test.Application;
import test.core.MyObject;
import test.core.MyObjectObserver;
import java.util.Scanner;

public class CliApplication
    implements Application, MyObjectObserver
{
    private boolean needPrompt = true;

    @Override
    public void run(MyObject object)
    {
        Scanner stdin = new Scanner(System.in);
        object.addObserver(this);
        while(true)
        {
            showPrompt();
            String input = stdin.nextLine().trim();
            if(input.equals("q")) break;
            int number;
            try
            {
                number = Integer.parseInt(input);
            }
            catch(NumberFormatException e)
            {
                System.out.println(String.format("\"%s\" is not number", input));
                needPrompt = true;
                continue;
            }
            MyObject.State state;
            switch(number)
            {
            case 1:
                state = MyObject.State.State1;
                break;
            case 2:
                state = MyObject.State.State2;
                break;
            case 3:
                state = MyObject.State.State3;
                break;
            default:
                System.out.println(
                    String.format("\"%d\" is wrong number", number));
                needPrompt = true;
                continue;
            }
            object.setState(state);
        }
        object.removeObserver(this);
    }

    void showPrompt()
    {
        if(needPrompt)
        {
            System.out.print("Enter state number or 'q' for exit:\n" +
                "    1: State1\n" +
                "    2: State2\n" +
                "    3: State3\n: ");
        }
        needPrompt = false;
    }

    @Override
    public void onStateChanged(MyObject.State oldState, MyObject.State newState)
    {
        System.out.println(String.format(
            "\nObject state was changed from \"%s\" to \"%s\"",
            oldState.toString(), newState.toString()));
        needPrompt = true;
        showPrompt();
    }
}

package test.gui;

import test.Application;
import test.core.MyObject;


public class GuiApplication
    implements Application
{
    @Override
    public void run(MyObject object)
    {
        MainWindow window = new MainWindow(object);
        window.setDefaultCloseOperation(MainWindow.EXIT_ON_CLOSE);
        window.setVisible(true);
    }
}

package test.gui;

import test.core.MyObject;
import test.core.MyObjectObserver;

import javax.swing.*;
import java.awt.*;
import java.awt.event.*;

public class MainWindow
    extends JFrame
    implements MyObjectObserver
{
    private JComboBox comboBox;
    private MyObject object;

    class ComboBoxListener
        implements ActionListener
    {
        @Override
        public void actionPerformed(ActionEvent e)
        {
            MyObject.State state = (MyObject.State)comboBox.getSelectedItem();
            if(state != null)
                object.setState(state);
        }
    }

    class MainWindowListener
        extends WindowAdapter
    {
        @Override
        public void windowOpened(WindowEvent e)
        {
            object.addObserver(MainWindow.this);
        }

        @Override
        public void windowClosed(WindowEvent e)
        {
            object.removeObserver(MainWindow.this);
        }
    }

    public MainWindow(MyObject object)
    {
        this.object = object;
        comboBox = new JComboBox(MyObject.State.values());
        comboBox.setSelectedItem(object.getState());
        comboBox.addActionListener(new ComboBoxListener());
        add(comboBox);
        addWindowListener(new MainWindowListener());
        setMinimumSize(new Dimension(200, 50));
        pack();
    }

    @Override
    public void onStateChanged(MyObject.State oldState, MyObject.State newState)
    {
        comboBox.setSelectedItem(newState);
    }
}

package test;

import test.cli.CliApplication;
import test.core.MyObject;
import test.gui.GuiApplication;

class ApplicationRunner
    implements Runnable
{
    private Application application;
    private MyObject object;

    public ApplicationRunner(Application application, MyObject object)
    {
        this.application = application;
        this.object = object;
    }

    @Override
    public void run()
    {
        application.run(object);
    }
}

public class Main
{
    static MyObject object = new MyObject();

    static Application[] getApplications()
    {
        return new Application[]
        {
            new CliApplication(),
            new GuiApplication()
        };
    }

    public static void main(String[] args)
    {
        for(Application app : getApplications())
        {
            ApplicationRunner runner = new ApplicationRunner(app, object);
            Thread thread = new Thread(runner);
            thread.start();
        }
    }
}

package polygon;


public class CPoints
{
    // Массив абсцисс.
    private int[] m_x;
    // Массив ординат.
    private int[] m_y;
    // Количество точек.
    private int m_count;
    // Вместимость.
    private int m_capacity;
    // Количество элементов, добавляемых при расширении.
    private final int m_block_size;
    // Минимальный размер m_block_size.
    private final int m_block_size_minimal = 10;
    
    // Устанавливает размер блока в значение по умолчанию.
    public CPoints()
    {
        m_block_size = m_block_size_minimal;
        m_count = 0;
        m_capacity = 0;
        increase();        
    }

    // default_block_size - размер блока, если меньше чем
    // m_block_size_minimal,то игнорируется.
    public CPoints(int default_block_size)
    {
        if(default_block_size < m_block_size_minimal)
            default_block_size = m_block_size_minimal;
        m_block_size = default_block_size;
        m_count = 0;
        m_capacity = 0;
        increase();
    }

    // Добавляет точку в конец массива.
    public void push(final int x, final int y)
    {
        // Если добавлять некуда, то увеличиваем размер массивов.
        if(m_count == m_capacity)
            increase();

        m_x[m_count] = x;
        m_y[m_count] = y;
        m_count++;
    }

    // Удаляет последнюю точку.
    public void pop()
    {
        if(m_count > 0)
            m_count--;
    }

    /// Возвращает размер массива.
    public int count()
    {
        return m_count;
    }

    // Возвращает массив X'ов.
    public final int[] getXArray()
    {
        return m_x;
    }

    // Возвращает массив Y'ов.
    public final int[] getYArray()
    {
        return m_y;
    }
    
    // Увеличевает размер массивов на m_block_size.
    private void increase()
    {
        int new_capasity = m_capacity + m_block_size;
        if(m_capacity != 0)
        {
            int[] tempx = new int[new_capasity];
            int[] tempy = new int[new_capasity];
            
            for(int i = 0; i < m_capacity; i++)
            {
                tempx[i] = m_x[i];
                tempy[i] = m_y[i];
            }
            
            m_x = tempx;
            m_y = tempy;
        }
        else
        {
            m_x = new int[new_capasity];
            m_y = new int[new_capasity];
        }
        m_capacity = new_capasity;
    }
}

package polygon;


public class CDeterminant
{
    public static boolean determine(final CPoints points, int x, int y)
    {

        boolean result = false;
        int count = points.count();
        int[] xp = points.getXArray();
        int[] yp = points.getYArray();


        for (int i = 0, j = count - 1; i < count; j = i++)
        {
            if(xp[j] == xp[i] || yp[j] == yp[i]) // Деление на ноль.
                continue;

            if(((yp[i] <= y && y < yp[j]) || (yp[j] <= y && y < yp[i])))
            {
                float x1 = xp[i];
                float y1 = yp[i];
                float x2 = xp[j];
                float y2 = yp[j];

                float k = (y2 - y1) / (x2 - x1);
                float b = y1 - k * x1;
                float cross_x = (y - b) / k;

                if((float)x > cross_x)
                    result = !result;
            }
        }
        return result;
    }
}

package polygon;

import java.awt.Color;
import java.awt.Graphics2D;
import java.awt.Graphics;
import java.awt.event.KeyAdapter;
import java.awt.event.KeyEvent;
import java.awt.event.MouseAdapter;
import java.awt.event.MouseEvent;
import javax.swing.JPanel;
import javax.swing.JFrame;
import javax.swing.JOptionPane;

class CPanel
    extends JPanel
{
    // Флаг того, что полигон был замкнут.
    private boolean m_polygon_end;
    // Вершины полигона.
    private CPoints m_points;
    // Абсциса определяемой точки.
    private int m_x;
    // Ордината определяемой точки.
    private int m_y;
    // Флаг того, что точка была установлена.
    private boolean m_point_end;

    public CPanel()
    {
        m_points = new CPoints();
        m_polygon_end = false;
        m_point_end = false;

        CMouseHandler mouse_handler = new CMouseHandler();
        addMouseListener(mouse_handler);
        addMouseMotionListener(mouse_handler);
        addKeyListener(new CKeyHandler());
        setFocusable(true); // Для обработки клавиатурных сообщений.
        setBackground(Color.white);
    }

    @Override public void paintComponent(Graphics g)
    {
        super.paintComponent(g);
        Graphics2D graphics = (Graphics2D)g;

        if(m_polygon_end)
        {
            graphics.drawPolygon(m_points.getXArray(),
                m_points.getYArray(), m_points.count());
            if(m_point_end)
                graphics.fillOval(m_x - 5, m_y - 5, 10, 10);
        }
        else
        {
            graphics.drawPolyline(m_points.getXArray(),
                m_points.getYArray(), m_points.count());
        }
    }


    private class CMouseHandler
        extends MouseAdapter
    {
        @Override public void mouseClicked(MouseEvent event)
        {
            if(!m_polygon_end)
            {
                if(event.getButton() == MouseEvent.BUTTON1)
                {
                    m_points.push(event.getX(), event.getY());
                    repaint();
                }
                else if(event.getButton() == MouseEvent.BUTTON3)
                {
                    // В полигоне не может быть меньше трёх точек.
                    if(m_points.count() >= 4)
                    {
                        m_points.pop(); // Убираем хвост.
                        m_polygon_end = true;
                        repaint();
                    }
                }
            }
            else if(event.getButton() == MouseEvent.BUTTON1)
            {
                m_x = event.getX();
                m_y = event.getY();
                m_point_end = true;
                repaint();
                String msg = CDeterminant.determine(m_points, m_x, m_y) ?
                    "Точка лежит внутри полигона" :
                    "Точка лежит вне полигона";
                JOptionPane.showMessageDialog(null, msg, "Положение точки",
                    JOptionPane.INFORMATION_MESSAGE);
            }
        }

        @Override public void mouseMoved(MouseEvent event)
        {
            if(!m_polygon_end)
            {
                m_points.pop();
                m_points.push(event.getX(), event.getY());
                repaint();
            }
        }
    } // private class CMouseHandler

    private class CKeyHandler
        extends KeyAdapter
    {
        @Override public void keyPressed(KeyEvent event)
        {
            if(event.getKeyCode() == KeyEvent.VK_ESCAPE)
            {
                m_points = new CPoints();
                m_point_end = false;
                m_polygon_end = false;
                repaint();
            }
        }
    } // private class CKeyHandler
} // class CPanel

public class CMainWindow
    extends JFrame
{
    public CMainWindow()
    {
        setTitle("Определение принадлежности точки полигону");
        setSize(800, 600);
        setBackground(Color.white);

        getContentPane().add(new CPanel());
    }
}

package polygon;

public class CMain
{
    public static void main(String params[])
    {
        CMainWindow wnd = new CMainWindow();
        wnd.setDefaultCloseOperation(CMainWindow.EXIT_ON_CLOSE);
        wnd.setVisible(true);
    }
}