class Employee
{
    public Employee(String name, int age, char sex, double salary)
    {
        this.name = name;
        this.age = age;
        this.sex = sex;
        this.salary = salary;
    };

    public String getName()
    {
        return name;    // we don't need "this" because it is implicit
    }

    public int getAge()
    {
        return age;
    }

    public void setAge(int age)
    {
        this.age = age;    // we have a local "age", and the class "age" so use "this"
    }

    public char getSex()
    {
        return sex;
    }

    public double getSalary()
    {
        return salary;
    }

    // We don't have a setSalary, as it could be abused
    public void giveRaise(double amount)
    {
        log(INFO, mame + " got raise of " + amount);  // record raises to the log, so they can be reviewed
        salary += amount;
    }

    private String name;
    private int age;
    private char sex;
    private double salary;
};

public void giveRaise(double amount)
{
    int level = INFO;
    // Raises should be annual
    if (lastRaised - today() < 335) level = WARNING;
    // More than 20% raise is suspicious
    if (amount > salary / 5) level = WARNING;
    log(level, mame + " got raise of " + amount);  // record raises to the log, so they can be reviewed
    salary += amount;
    lastRaised = today();
}

public String toString()
{
    StringBuffer buffer = new StringBuffer(name);
    buffer.append(" (");
    buffer.append(sex);
    buffer.append(") ");
    buffer.append(salary);
    return buffer.toString();
}

    private Sudoku()
    {
        //The board is a 9x9 grid
        board = new JDigit[9][9];
        timeStart = System.currentTimeMillis();
        running = true;
        entering = false;
        completed = false;
        solved = false;
        //Initialize the counts with how many bits are set
        counts = new int[1024];
        for (int count = 0; count < 1024; count++)
        {
            int bits = 0;
            for (int bit = 1; bit < 10; bit++)
            {
                if (((1 << bit) & count) != 0)
                {
                    bits++;
                }
            }
            counts[count] = bits;
        }
    };

    boolean possible()
    {
        if (completed) return true;
        completed = true;
        boolean error = false;
        //We do 2 passes, because we get 2nd order effects in invalid cases
        for (int pass = 0; pass < 2; pass++)
        {
            for (int x = 0; x < 9; x++)
            {
                for (int y = 0; y < 9; y++)
                {
                    //If there was an error, or an empty square we didn't finish
                    if (board[x][y].error || board[x][y].getDigit() == Digit.EMPTY)
                    {
                        completed = false;
                    }
                    int found = 0;
                    //Check all the squares along vertical, horizontal, and in the same grid
                    for (int test = 0; test < 9; test++)
                    {
                        Digit digit = Digit.EMPTY;
                        if (test != y)
                        {
                            digit = board[x][test].getDigit();
                            found |= 1 << digit.value();
                        }
                        if (test != x)
                        {
                            digit = board[test][y].getDigit();
                            found |= 1 << digit.value();
                        }
                        int xStart = x - x % 3;
                        int yStart = y - y % 3;
                        for (int xAdd = 0; xAdd < 3; xAdd++)
                        {
                            for (int yAdd = 0; yAdd < 3; yAdd++)
                            {
                                int currX = xStart + xAdd;
                                int currY = yStart + yAdd;
                                if (currX != x || currY != y)
                                {
                                    digit = board[currX][currY].getDigit();
                                    found |= 1 << digit.value();
                                }
                            }
                        }
                    }
                    //Check if the square matches the possible (and update the copy)
                    error |= board[x][y].setPossible(~found & 1022);
                    //If all 9 values found, then we must have an error
                    if (counts[found] == 9) error = true;
                }
            }
        }
        //Once we have completed, set the time taken
        if (completed)
        {
            totalTime = time();
            running = false;
        }
        return !error;
    }

    boolean findSquare(boolean tryHarder)
    {
        //Update the list of possibles
        possible();
        if (completed) return true;

        int x = rnd.nextInt(9);
        int y = rnd.nextInt(9);

        int startX = x;
        int startY = y;
        while (true)
        {
            if (board[x][y].getDigit() == Digit.EMPTY)
            {
                int maybe = board[x][y].possible;
                if (counts[maybe] == 1)
                {
                    //Only 1 possibility, so let's pick it
                    Digit digit = Digit.fromMask(maybe);
                    find.digit = digit;
                    find.x = x;
                    find.y = y;
                    return true;
                }
            }
            x++;
            x %= 9;
            if (x == startX)
            {
                y++;
                y %= 9;
                if (y == startY)
                {
                    if (tryHarder) break;
                    return false;
                }
            }
        }

        //Now check for only 1 valid place for a digit
        while (true)
        {
            if (board[x][y].getDigit() == Digit.EMPTY)
            {
                int maybe = board[x][y].possible;
                int possible = 0;
                int baseX = x - x % 3;
                int baseY = y - y % 3;
                for (int check = 0; check < 9; check++)
                {
                    //First check the row, for possible
                    if (check != x)
                    {
                        possible |= board[check][y].possible;
                    }
                    //Then check the column, for possible
                    if (check != y)
                    {
                        possible |= board[x][check].possible;
                    }
                    int gridX = baseX + check % 3;
                    int gridY = baseY + check / 3;
                    //Finally check the grid, for possible
                    if (gridX != x || gridY != y)
                    {
                        possible |= board[gridX][gridY].possible;
                    }
                }

                maybe &= ~possible; //There is only 1 possible place for a value in the square, so this must be it

                if (maybe != 0)
                {
                    //There is only 1 place the digit can go, so lets place it
                    Digit digit = Digit.fromMask(maybe);
                    find.digit = digit;
                    find.x = x;
                    find.y = y;
                    return true;
                }
            }
            x++;
            x %= 9;
            if (x == startX)
            {
                y++;
                y %= 9;
                if (y == startY)
                {
                    break;
                }
            }
        }

        /*Ok, we have NO simple solution, but we may have a 2 part solution
        123
        456
        000 <- These 000 could be 789 and we can't determine which

        Assume we have, the further restrictions
        123
        456
        000 <- First digit can't be 7, second can't be 8, third can't be 9 (8,9),(7,9),(7,8)
        We pick 2 elements that can share a value in common (and effect each other), in this
        case we pick first and last values, and we try assigning them, we then check for error
        if there was an error, we know the values can not be correct and that the reverse case
        must be true. If there is no error, that doesn't mean it is correct on the other hand
        since we may not have explored enough possible solutions that we know it will be an
        error.
         */
        while (true)
        {
            if (board[x][y].getDigit() == Digit.EMPTY)
            {
                int maybe = board[x][y].possible;
                if (counts[maybe] == 2)
                {
                    //See if there is a square, that shares the characteristics we are looking for
                    Digit digit = deepCheck(x,y,maybe);
                    if (digit != Digit.EMPTY)
                    {
                        find.digit = digit;
                        find.x = x;
                        find.y = y;
                        return true;
                    }
                }
            }
            x++;
            x %= 9;
            if (x == startX)
            {
                y++;
                y %= 9;
                if (y == startY)
                {
                    break;
                }
            }
        }

        return false;
    }

    void help()
    {
        String help = "<html><body style='width: 250px; padding: 5px;' align='center'>"
                            + "<h1>Sudoku - Help</h1>"
                            + "The idea of Sudoku is to add digits to the grid,<br/>"
                            + "until it is full. You can only add a number,<br/>"
                            + "if it not already present in the same 3x3 grid,<br/>"
                            + "or on the same horizontal or vertical line.<br/>"
                            + "The game is timed, you can press Hint which fills<br/>"
                            + "in a square for you, but adds a 1 minute penalty<br/>"
                            + "to your time. If you have a value that is invalid<br/>"
                            + "the square will change color to <font color='red'>red</font>. You can clear<br/>"
                            + "an existing value by entering a 0, or by pressing<br/>"
                            + "backspace or delete.<br/>";
        new CompleteDialog(SudokuView.display,"Sudoku - Help",help);
    }

    public boolean focusNext()
    {
        //Default case is next digit
        int xAdd = 1;
        int yAdd = 0;

        //If we are at right of panel
        if (x % 3 == 2)
        {
            //We want to move down instead, and change x to left
            yAdd = 1;
            xAdd = -2;
            //If we are at the bottom of the panel move to the panel at the right
            if (y % 3 == 2)
            {
                yAdd = -2;
                xAdd = 1;
                //If we are at the right edge, go to the panel at the next line
                if (x == 8)
                {
                    xAdd = -8;
                    yAdd = 1;
                }
            }
        }

        //Try and focus (moveFocus returns false is it is unable to move to the next)
        return moveFocus(xAdd,yAdd);
    }

    public void setDigit(Digit digit)
    {
        //Are we entering a puzzle?
        if (Sudoku.game.isEntering())
        {
            //Fixed square (unless it is 0)
            fixed = digit.value() != 0;
            //Answer is the value we entered
            answer = digit;
            //Set the correct background color
            if (fixed)
            {
                setBackground(SudokuView.fixedCol);
            }
            else
            {
                setBackground(SudokuView.background);
                if (this == SudokuView.focused)
                {
                    setBackground(SudokuView.background.brighter().brighter());
                }
            }
        }
        else
        {
            //If it was fixed value, make sure nothing else caused an error
            if (fixed)
            {
                Sudoku.game.possible();
                checkError();
                return;
            }
        }

        this.digit = digit;
        image = getImage(digit);

        //Check for errors and repaint (if not entering)
        if (!Sudoku.game.isEntering())
        {
            Sudoku.game.possible();
            checkError();
            repaint();
        }
    }

    void swap(JDigit other)
    {
        Digit save = this.digit;
        this.digit = other.digit;
        other.digit = save;
        save = answer;
        answer = other.answer;
        other.answer = save;
        Image saveImage = image;
        image = other.image;
        other.image = saveImage;
    }

import java.awt.*;
import java.util.Random;

/**
 * Created with IntelliJ IDEA.
 * Date: 5/22/13
 * Time: 10:14 PM
 */

/**
 * The main game (Model)
 */
public class Sudoku
{
    /**
     * Singleton instance of the Sudoku game
     */
    static Sudoku game;

    //The grid that represents the state of the game
    private JDigit board[][];

    //Used to determine how long ago the game started
    private long timeStart;
    //Is the clock running?
    private boolean running;
    //Are we entering values (For Enter Puzzle mode)
    private boolean entering;
    Random rnd = new Random();
    //Has puzzle been completed
    private boolean completed;
    //Once puzzle is solved (during hint() we don't need to solve it again)
    private boolean solved;
    //How long did it take
    private String totalTime;

    //How many digits are set in a bitfield
    private int[] counts;

    //For returning data to hint()
    private XYDigit find = new XYDigit();

    private Sudoku()
    {
        //The board is a 9x9 grid
        board = new JDigit[9][9];
        timeStart = System.currentTimeMillis();
        running = true;
        entering = false;
        completed = false;
        solved = false;
        //Initialize the counts with how many bits are set
        counts = new int[1024];
        for (int count = 0; count < 1024; count++)
        {
            int bits = 0;
            for (int bit = 1; bit < 10; bit++)
            {
                if (((1 << bit) & count) != 0)
                {
                    bits++;
                }
            }
            counts[count] = bits;
        }
    };

    /**
     * Start a new game
     * @param difficulty Easy, Medium, Hard or Enter Puzzle
     */
    void start(String difficulty)
    {
        entering = true;
        solved = false;
        //Set the title with the difficulty level
        SudokuView.display.setTitle("Sudoku - " + difficulty);
        if (difficulty == "Enter Puzzle")
        {
            //entering a new puzzle
            enter();
        }
        else
        {
            //Create a grid
            createGrid(difficulty);
            timeStart = System.currentTimeMillis();
            completed = false;
            running = true;
            solved = true;  //We actually have an answer
        }

        for (int x = 0; x < 9; x++)
        {
            for (int y = 0; y < 9; y++)
            {
                //Repaint all the elements
                board[x][y].repaint();
            }
        }
    }

    /**
     * Create a grid by shuffling
     * @param difficulty
     */
    private void createGrid(String difficulty)
    {
        Digit rows[] = {Digit.ONE, Digit.FOUR, Digit.SEVEN, Digit.TWO, Digit.FIVE, Digit.EIGHT, Digit.THREE, Digit.SIX, Digit.NINE};
        completed = false;

        //Empty the grid
        for (int x = 0; x < 9; x++)
            for (int y = 0; y < 9; y++)
                board[x][y].setDigit(Digit.EMPTY);

        //Generate a grid that is valid
        for (int y = 0; y < 9; y++)
        {
            Digit curr = rows[y];
            for (int x = 0; x < 9; x++)
            {
                board[x][y].setDigit(curr);
                board[x][y].error = false;
                curr = curr.next();
            }
        }

        //Now we shuffle the grid (http://blog.forret.com/2006/08/a-sudoku-challenge-generator/ for the algorithm)
        //The shuffles make it so that we have a valid solution at all points
        for (int shuffles = 0; shuffles < 20; shuffles++)
        {
            for (int set = 0; set < 3; set++)
            {
                shuffleRow(set*3);
                shuffleColumn(set*3);
            }
            shuffleBlocks();
        }

        //Now go through and hide some blocks
        int hide = 3;
        if (difficulty == "Medium")

        {
            hide = 4;
        }
        if (difficulty == "Hard")
        {
            hide = 5;
        }

        for (int x = 0; x < 9; x++)
        {
            int hides = hide;
            while (hides > 0)
            {
                int y = rnd.nextInt(9);
                //Hide some squares from column
                if (board[x][y].getDigit() != Digit.EMPTY)
                {
                    Digit original = board[x][y].getDigit();
                    board[x][y].setDigit(Digit.EMPTY);
                    board[x][y].answer = original;
                }
                hides--;
            }
        }

        for (int y = 0; y < 9; y++)
        {
            int hides = hide;
            while (hides > 0)
            {
                int x = rnd.nextInt(9);
                //Hide some squares from row
                if (board[x][y].getDigit() != Digit.EMPTY)
                {
                    Digit original = board[x][y].getDigit();
                    board[x][y].setDigit(Digit.EMPTY);
                    board[x][y].answer = original;
                }
                hides--;
            }
        }

        entering = false;

//      if (difficulty != "Hard")
        {
            do
            {
                if (true) break;
                //What was hard is now medium (squares with 2 possible values), and hard is possible for computer to solve
                if (!hint(difficulty != "Easy", difficulty == "Hard"))
                {
                    //Ok, find a random square that is empty and set it to correct value
                    int x = rnd.nextInt(9);
                    int y = rnd.nextInt(9);
                    int startX = x;
                    int startY = y;
                    while (true)
                    {
                        if (board[x][y].getDigit() != board[x][y].answer && counts[board[x][y].possible] > 1)
                        {
                            entering = true;
                            board[x][y].setDigit(board[x][y].answer);
                            entering = false;
                            break;
                        }
                        x++;
                        x %= 9;
                        if (x == startX)
                        {
                            y++;
                            y %= 9;
                            if (y == startY)
                            {
                                throw new RuntimeException("Unable to solve????");
                            }
                        }
                    }
                }
            } while (!completed);
            //Reset the board back to the puzzle
            reset();
        }
    }

    /**
     * Check the grid and fill out for each square the possible values
     * @return false if there was an error
     */
    boolean possible()
    {
        if (completed) return true;
        completed = true;
        boolean error = false;
        //We do 2 passes, because we get 2nd order effects in invalid cases
        for (int pass = 0; pass < 2; pass++)
        {
            for (int x = 0; x < 9; x++)
            {
                for (int y = 0; y < 9; y++)
                {
                    //If there was an error, or an empty square we didn't finish
                    if (board[x][y].error || board[x][y].getDigit() == Digit.EMPTY)
                    {
                        completed = false;
                    }
                    int found = 0;
                    //Check all the squares along vertical, horizontal, and in the same grid
                    for (int test = 0; test < 9; test++)
                    {
                        Digit digit = Digit.EMPTY;
                        if (test != y)
                        {
                            digit = board[x][test].getDigit();
                            found |= 1 << digit.value();
                        }
                        if (test != x)
                        {
                            digit = board[test][y].getDigit();
                            found |= 1 << digit.value();
                        }
                        int xStart = x - x % 3;
                        int yStart = y - y % 3;
                        for (int xAdd = 0; xAdd < 3; xAdd++)
                        {
                            for (int yAdd = 0; yAdd < 3; yAdd++)
                            {
                                int currX = xStart + xAdd;
                                int currY = yStart + yAdd;
                                if (currX != x || currY != y)
                                {
                                    digit = board[currX][currY].getDigit();
                                    found |= 1 << digit.value();
                                }
                            }
                        }
                    }
                    //Check if the square matches the possible (and update the copy)
                    error |= board[x][y].setPossible(~found & 1022);
                    //If all 9 values found, then we must have an error
                    if (counts[found] == 9) error = true;
                }
            }
        }
        //Once we have completed, set the time taken
        if (completed)
        {
            totalTime = time();
            running = false;
        }
        return !error;
    }

    /**
     * Swap 2 rows in the same grid around
     * @param base
     */
    void shuffleRow(int base)
    {
        int a = rnd.nextInt(3);
        int b = rnd.nextInt(3);
        if (a == b)
        {
            a = (a + 1) % 3;
        }
        a += base;
        b += base;
        for (int x = 0; x < 9; x++)
        {
            board[x][a].swap(board[x][b]);
        }
    }

    /**
     * Swap 2 columns in the same grid around
     * @param base
     */
    void shuffleColumn(int base)
    {
        int a = rnd.nextInt(3);

        int b = rnd.nextInt(3);
        if (a == b)
        {
            a = (a + 1) % 3;
        }
        a += base;
        b += base;

        for (int y = 0; y < 9; y++)
        {
            board[a][y].swap(board[b][y]);
        }
    }

    /**
     * Swap a line of a grid around
     */
    void shuffleBlocks()
    {
        int a = rnd.nextInt(3);
        int b = rnd.nextInt(3);
        if (a == b)
        {
            a = (a + 1) % 3;
        }
        a *= 3;
        b *= 3;
        for (int x = 0; x < 9; x++)
            for (int y = 0; y < 3; y++)
                board[x][a+y].swap(board[x][b+y]);
    }

    /**
     * Save the state for backtracking
     * @return the current state
     */
    private Digit[][] saveGrid()
    {
        Digit[][] save = new Digit[9][9];

        for (int x = 0; x < 9; x++)
        {
            for (int y = 0; y < 9; y++)
            {
                save[x][y] = board[x][y].getDigit();
            }
        }

        return save;
    }

    /**
     * Restore the previous state (for backtracking)
     * @param load
     */
    private void loadGrid(Digit[][] load)
    {
        for (int x = 0; x < 9; x++)
        {
            for (int y = 0; y < 9; y++)
            {
                board[x][y].tryDigit(load[x][y]);
            }
        }
    }

    /**
     * Find a valid square
     * @param tryHarder find a square using more complex logic
     * @return true if it found a square
     */
    boolean findSquare(boolean tryHarder)
    {
        //Update the list of possibles
        possible();
        if (completed) return true;

        int x = rnd.nextInt(9);
        int y = rnd.nextInt(9);

        int startX = x;
        int startY = y;
        while (true)
        {
            if (board[x][y].getDigit() == Digit.EMPTY)
            {
                int maybe = board[x][y].possible;
                if (counts[maybe] == 1)
                {
                    //Only 1 possibility, so let's pick it
                    Digit digit = Digit.fromMask(maybe);
                    find.digit = digit;
                    find.x = x;
                    find.y = y;
                    return true;
                }
            }
            x++;
            x %= 9;
            if (x == startX)
            {
                y++;
                y %= 9;
                if (y == startY)
                {
                    if (tryHarder) break;
                    return false;
                }
            }
        }

        //Now check for only 1 valid place for a digit
        while (true)
        {
            if (board[x][y].getDigit() == Digit.EMPTY)
            {
                int maybe = board[x][y].possible;
                int possible = 0;
                int baseX = x - x % 3;
                int baseY = y - y % 3;
                for (int check = 0; check < 9; check++)
                {
                    //First check the row, for possible
                    if (check != x)
                    {
                        possible |= board[check][y].possible;
                    }
                    //Then check the column, for possible
                    if (check != y)
                    {
                        possible |= board[x][check].possible;
                    }
                    int gridX = baseX + check % 3;
                    int gridY = baseY + check / 3;
                    //Finally check the grid, for possible
                    if (gridX != x || gridY != y)
                    {
                        possible |= board[gridX][gridY].possible;
                    }
                }

                maybe &= ~possible; //There is only 1 possible place for a value in the square, so this must be it

                if (maybe != 0)
                {
                    //There is only 1 place the digit can go, so lets place it
                    Digit digit = Digit.fromMask(maybe);
                    find.digit = digit;
                    find.x = x;
                    find.y = y;
                    return true;
                }
            }
            x++;
            x %= 9;
            if (x == startX)
            {
                y++;
                y %= 9;
                if (y == startY)
                {
                    break;
                }
            }
        }

        /*Ok, we have NO simple solution, but we may have a 2 part solution
        123
        456
        000 <- These 000 could be 789 and we can't determine which

        Assume we have, the further restrictions
        123
        456
        000 <- First digit can't be 7, second can't be 8, third can't be 9 (8,9),(7,9),(7,8)
        We pick 2 elements that can share a value in common (and effect each other), in this
        case we pick first and last values, and we try assigning them, we then check for error
        if there was an error, we know the values can not be correct and that the reverse case
        must be true. If there is no error, that doesn't mean it is correct on the other hand
        since we may not have explored enough possible solutions that we know it will be an
        error.
         */
        while (true)
        {
            if (board[x][y].getDigit() == Digit.EMPTY)
            {
                int maybe = board[x][y].possible;
                if (counts[maybe] == 2)
                {
                    //See if there is a square, that shares the characteristics we are looking for
                    Digit digit = deepCheck(x,y,maybe);
                    if (digit != Digit.EMPTY)
                    {
                        find.digit = digit;
                        find.x = x;
                        find.y = y;
                        return true;
                    }
                }
            }
            x++;
            x %= 9;
            if (x == startX)
            {
                y++;
                y %= 9;
                if (y == startY)
                {
                    break;
                }
            }
        }

        return false;
    }

    /**
     * Find the next square (pick it randomly)
     * @param tryHarder
     * @param deep attempt to solve
     * @return true if it managed to find a square
     */
    boolean hint(boolean tryHarder,boolean deep)
    {
        possible();
        if (completed) return true;

        //First check the board for any squares that don't match the answer

        for (int x = 0; x < 9; x++)
        {
            for (int y = 0; y < 9; y++)
            {
                Digit answer = board[x][y].answer;
                if (answer != Digit.EMPTY)
                {
                    Digit digit = board[x][y].getDigit();
                    if (digit != Digit.EMPTY && digit != answer)
                    {
                        board[x][y].setDigit(answer);
                        board[find.x][find.y].moveFocus(0,0);
                        timeStart -= 60000; //Add 1 minute penalty every time you use hint
                        return true;
                    }
                }
            }
        }

        //find a square, and if we did, update the display and apply a penalty
        if (findSquare(tryHarder))
        {
            board[find.x][find.y].setDigit(find.digit);
            board[find.x][find.y].moveFocus(0,0);
            timeStart -= 60000; //Add 1 minute penalty every time you use hint
            return true;
        }

        if (!deep)
        {
            return false;
        }

        //Now do deep solution, and find a square
        if (!solved)
        {
            return false;
            //if (!solve(0,0)) return false;
            //solved = true;
        }

        //Find a square, where we already have an answer and reveal it
        for (int x = 0; x < 9; x++)
        {
            for (int y = 0; y < 9; y++)
            {
                if (board[x][y].getDigit() == Digit.EMPTY)
                {
                    board[x][y].setDigit(board[x][y].answer);
                    board[x][y].moveFocus(0,0);
                    timeStart -= 60000; //Add 1 minute penalty every time you use hint
                    return true;
                }
            }
        }

        return false;
    }

    /**
     * This number should not appear anywhere in the row.
     * @param y
     * @param digit
     * @return
     */
    public boolean checkHorizontal(int y, Digit digit)
    {
        for (int x = 0; x < 9; x++)
        {
            if (board[x][y].getDigit() == digit)
            {
                return false;
            }
        }
        return true;
    }

    /**
     * This number should not appear anywhere in the column
     * @param x
     * @param digit
     * @return
     */
    public boolean checkVertical(int x, Digit digit)
    {
        for (int y = 0; y < 9; y++)
        {
            if (board[x][y].getDigit() == digit)
            {
                return false;
            }
        }
        return true;
    }

    /**
     * This number should not appear anywhere in the box
     * @param x
     * @param y
     * @param digit
     * @return
     */
    private boolean checkBox(int x, int y, Digit digit)
    {
        // Round down to nearest 3.
        int xStart = (x / 3) * 3;
        int yStart = (y / 3) * 3;
        for (x = xStart; x < xStart + 3; x++)
        {
            for (y = yStart; y < yStart + 3; y++)
            {
                if (board[x][y].getDigit() == digit)
                {
                    return false;
                }
            }
        }
        return true;
    }

    /**
     * Check if digit a valid possibility
     * @param x
     * @param y
     * @param digit
     * @return
     */
    boolean check(int x, int y, Digit digit)
    {
        // All checks must pass.
        return checkHorizontal(y, digit)
                && checkVertical(x, digit)
                && checkBox(x, y, digit);
    }

    /**
     * Recursive solution finder
     * @param x
     * @param y
     * @return
     */
    public boolean solve(int x, int y)
    {
        // Got to the end?
        if (y >= 9)
        {
            //Reached the end
            return true;
        }
        // If the cell is empty
        if (board[x][y].getDigit() == Digit.EMPTY)
        {
            Digit[][] save = saveGrid();
            // Find a valid number for the empty cell
            for (Digit digit : Digit.digits)
            {
                // Can this number be put there?
                if (check(x, y, digit))
                {
                    // Yes!
                    //System.out.println(x+","+y+"="+digit);
                    board[x][y].tryDigit(digit);
                    // Try that.
                    //Now fill in the rest of the board as far possible
                    while (findSquare(true))
                    {
                        if (completed) return true;
                        board[find.x][find.y].tryDigit(find.digit);
                    }
                    if (next(x, y))
                    {
                        return true;
                    }
                }
            }
            // Clean up.
            board[x][y].answer = board[x][y].getDigit();
            loadGrid(save);
        }
        else
        {
            // Move on.
            if (next(x, y))
            {
                return true;
            }
        }
        // Failed to find a solution.
        return false;
    }

    /**
     * Now attempt to solve the next square
     * @param x
     * @param y
     * @return
     */
    public boolean next(int x, int y)
    {
        if (x < 8)
        {
            // Step right.
            return solve(x + 1, y);
        }
        else
        {
            // Step down.
            return solve(0, y + 1);
        }
    }

    /**
     * Perform a check along vertical, horizontal and in box for another square
     * with 2 digits in the possible list where at least one of them matches
     * @param x
     * @param y
     * @param maybe
     * @return
     */
    private Digit deepCheck(int x, int y, int maybe)
    {
        Digit found = Digit.EMPTY;
        int baseX = x - x % 3;
        int baseY = y - y % 3;
        for (int check = 0; check < 9; check++)
        {
            //First check the row, for possible
            if ((maybe & board[check][y].possible) != 0)
            {
                found = check(x, y, check, y);
                if (found != Digit.EMPTY) return found;
            }
            //Then check the column, for possible
            if ((maybe & board[x][check].possible) != 0)
            {
                found = check(x, y, x, check);
                if (found != Digit.EMPTY) return found;
            }
            int gridX = baseX + check % 3;
            int gridY = baseY + check / 3;
            //Finally check the grid, for possible
            if ((maybe & board[gridX][gridY].possible) != 0)
            {
                found = check(x, y, gridX, gridY);
                if (found != Digit.EMPTY) return found;
            }
        }
        return found;
    }

    /**
     * Check if a digit matches
     * @param x
     * @param y
     * @param x2
     * @param y2
     * @return
     */
    private Digit check(int x, int y, int x2, int y2)
    {
        if (x == x2 && y == y2) return Digit.EMPTY;
        if (board[x2][y2].getDigit() != Digit.EMPTY) return Digit.EMPTY;
        //We know [x,y] has only 2 components, so check [x2,y2]
        int found = board[x2][y2].possible;
        if (counts[found] != 2) return Digit.EMPTY;
        int maybe = board[x][y].possible;
        if (maybe == found) return Digit.EMPTY;
        Digit shared = Digit.fromMask(found & maybe);
        Digit digit = Digit.fromMask(maybe ^ (found & maybe));
        Digit other = Digit.fromMask(found ^ (found & maybe));
        board[x][y].setDigit(shared);
        board[x2][y2].setDigit(other);
        boolean ok = !possible();
        board[x][y].setDigit(Digit.EMPTY);
        board[x2][y2].setDigit(Digit.EMPTY);
        if (ok)
        {
//          System.out.println("Found " + digit + " with deep check at " + x + "," + y);
            return digit;
        }
        return Digit.EMPTY;
    }

    /**
     * Attempt to solve the puzzle
     * @return
     */
    boolean solve()
    {
        while (!completed)
        {
            if (!hint(true,true))
            {
                return false;
            }
        }
        return true;
    }

    /**
     * Reset the grid back to default
     */
    void reset()
    {
        entering = false;
        for (int x = 0; x < 9; x++)
            for (int y = 0; y < 9; y++)
                board[x][y].setDigit(Digit.EMPTY);
        completed = false;
        running = true;
    }

    /**
     * Create a dialog box with the help text
     */
    void help()
    {
        String help = "<html><body style='width: 250px; padding: 5px;' align='center'>"
                            + "<h1>Sudoku - Help</h1>"
                            + "The idea of Sudoku is to add digits to the grid,<br/>"
                            + "until it is full. You can only add a number,<br/>"
                            + "if it not already present in the same 3x3 grid,<br/>"
                            + "or on the same horizontal or vertical line.<br/>"
                            + "The game is timed, you can press Hint which fills<br/>"
                            + "in a square for you, but adds a 1 minute penalty<br/>"
                            + "to your time. If you have a value that is invalid<br/>"
                            + "the square will change color to <font color='red'>red</font>. You can clear<br/>"
                            + "an existing value by entering a 0, or by pressing<br/>"
                            + "backspace or delete.<br/>";
        new CompleteDialog(SudokuView.display,"Sudoku - Help",help);
    }

    /**
     * We are entering a puzzle, so set up the grid for it
     */
    void enter()
    {
        completed = false;

        for (int x = 0; x < 9; x++)
            for (int y = 0; y < 9; y++)
                board[x][y].setDigit(Digit.EMPTY);
        running = false;
        SudokuView.setFocused(0,0);
    }

    /**
     * Are we entering a puzzle
     * @return
     */
    boolean isEntering()
    {
        return entering;
    }

    /**
     * Have we finished the puzzle
     * @return
     */
    boolean isCompleted()
    {
        return completed;
    }

    /**
     * We have finished entering the puzzle
     */
    void finishEntering()
    {
        entering = false;
        timeStart = System.currentTimeMillis();
        running = true;
        SudokuView.display.setTitle("Sudoku - Custom Puzzle");
    }

    /**
     * Return the time as a string
     * @return How long have we taken (up to 59:59)
     */
    String time()
    {
        if (!running)
        {
            if (completed)
            {
                return totalTime;
            }
            return "00:00";
        }

        long elapsed = System.currentTimeMillis() - timeStart;
        int seconds = (int)(elapsed / 1000);
        int minutes = seconds / 60;
        seconds %= 60;
        if (minutes > 59)
        {
            return "59:59";
        }
        return String.format("%02d:%02d",minutes,seconds);
    }

    /**
     * The main entry point
     * @param args
     */
    public static void main(String args[])
    {
        game = new Sudoku();
        EventQueue.invokeLater(new Runnable()
        {
            //@Override
            public void run()
            {
                SudokuView.createGUI(game.board);
            }
        });
    }
}

/**
 * Created with IntelliJ IDEA.
 * Date: 5/22/13
 * Time: 10:15 PM
 */

import javax.swing.*;
import javax.swing.border.Border;
import java.awt.*;
import java.awt.event.*;
import java.awt.image.BufferedImage;
import java.util.EnumSet;

/**
 * Main Display Class, handles the display of the elements
 */
public class SudokuView extends JPanel
{
    /**
     * The currently highlighted square
     */
    static JDigit focused = null;
    /**
     * The popup menu for entering the digits
     */
    static JPopupMenu popup = new JPopupMenu();
    /**
     * The main grid
     */
    static JDigit[][] board;
    /**
     * The main display frame
     */
    static JFrame display;
    /**
     * The current time taken
     */
    static JLabel timeLabel;

    /**
     * Default grid color
     */
    static Color background = new Color(0xe0e000);

    /**
     * Default color of popup
     */
    static Color popupColor = new Color(0x00e0e0);

    /**
     * Color to indicate error
     */
    static Color errorCol = new Color(0xe00000);

    /**
     * Color of puzzle square
     */
    static Color fixedCol = new Color(0xe0e0e0);

    /**
     * Create the GUI of the grid
     * @param board
     */
    public static void createGUI(JDigit[][] board)
    {
        SudokuView.board = board;
        //The main frame for the display
        display = new JFrame();
        display.setTitle("Sudoku");
        //Buttons to add
        JButton easy = new JButton("Easy");
        JButton medium = new JButton("Medium");
        JButton hard = new JButton("Hard");
        JButton hint = new JButton("Hint");
        JButton solve = new JButton("Solve");
        JButton quit = new JButton("Quit");
        JButton reset = new JButton("Reset");
        JButton enter = new JButton("Enter Puzzle");
        JButton help = new JButton("Help");
        timeLabel = new JLabel("Time: 00:00");
        timeLabel.setHorizontalAlignment(JLabel.CENTER);
        easy.addActionListener(new ButtonPress());
        medium.addActionListener(new ButtonPress());
        hard.addActionListener(new ButtonPress());
        hint.addActionListener(new ButtonPress());
        solve.addActionListener(new ButtonPress());
        quit.addActionListener(new ButtonPress());
        reset.addActionListener(new ButtonPress());
        enter.addActionListener(new ButtonPress());
        help.addActionListener(new ButtonPress());
        display.setDefaultCloseOperation(JFrame.DISPOSE_ON_CLOSE);
        InputMap inputMap = new InputMap();
        ActionMap actionMap = new ActionMap();
        //The clear keys
        inputMap.put(KeyStroke.getKeyStroke(KeyEvent.VK_0, 0), " ");
        inputMap.put(KeyStroke.getKeyStroke(KeyEvent.VK_NUMPAD0, 0), " ");
        inputMap.put(KeyStroke.getKeyStroke(KeyEvent.VK_BACK_SPACE, 0), " ");
        inputMap.put(KeyStroke.getKeyStroke(KeyEvent.VK_DELETE, 0), " ");
        actionMap.put(" ", new SelectAction(Digit.EMPTY));
        //Move the cursor keys to change the focused square
        inputMap.put(KeyStroke.getKeyStroke(KeyEvent.VK_UP, 0), "Up");
        inputMap.put(KeyStroke.getKeyStroke(KeyEvent.VK_DOWN, 0), "Down");
        inputMap.put(KeyStroke.getKeyStroke(KeyEvent.VK_LEFT, 0), "Left");
        inputMap.put(KeyStroke.getKeyStroke(KeyEvent.VK_RIGHT, 0), "Right");
        actionMap.put("Up", new KeyAction(0,-1));
        actionMap.put("Down", new KeyAction(0,1));
        actionMap.put("Left", new KeyAction(-1,0));
        actionMap.put("Right", new KeyAction(1, 0));
        popup.setLayout(new GridLayout(3, 3));
        //Set the digits of popup
        for (Digit d : Digit.digits)
        {
            Action select = new SelectAction(d);
            inputMap.put(KeyStroke.getKeyStroke(KeyEvent.VK_0 + d.value(), 0), d.toString());
            inputMap.put(KeyStroke.getKeyStroke(KeyEvent.VK_NUMPAD0 + d.value(), 0), d.toString());
            actionMap.put(d.toString(), select);
            popup.add(new PickDigit(d));
        }
        popup.setBorder(BorderFactory.createLineBorder(Color.black, 2));
        popup.setInputMap(WHEN_ANCESTOR_OF_FOCUSED_COMPONENT,inputMap);
        popup.setActionMap(actionMap);
        //We are using GridBagLayout to have custom layout (it was GridLayout before)
        display.setLayout(new GridBagLayout());
        GridBagConstraints c = new GridBagConstraints();
        //Add the 9 3x3 squares
        for (int panel = 0; panel < 9; panel++)
        {
            int xStart = (panel % 3) * 3;
            int yStart = (panel / 3) * 3;
            JPanel frame = new JPanel();
            frame.setInputMap(WHEN_ANCESTOR_OF_FOCUSED_COMPONENT,inputMap);
            frame.setActionMap(actionMap);
            frame.setLayout(new GridLayout(3, 3));
            for (Digit d : Digit.digits)
            {
                int x = xStart + (d.value() - 1) % 3;
                int y = yStart + (d.value() - 1) / 3;
                SudokuView digit = new SudokuView(board,d,x,y);
                frame.add(digit);
            }
            frame.setVisible(true);
            frame.setBorder(BorderFactory.createLineBorder(Color.black, 2));
            c.gridx = panel % 3;
            c.gridy = panel / 3;
            display.add(frame,c);
        }
        //Add the buttons
        JPanel buttons = new JPanel();
        buttons.setLayout(new GridLayout(3, 1));
        buttons.add(easy);
        buttons.add(hint);
        buttons.add(help);
        c.fill = GridBagConstraints.HORIZONTAL;
        c.gridx = 0;
        c.gridy = 3;
        //Make them bigger vertically
        c.ipady = 50;

        display.add(buttons,c);

        buttons = new JPanel();
        buttons.setLayout(new GridLayout(3, 1));
        buttons.add(medium);
        buttons.add(solve);
        buttons.add(enter);
        c.gridx = 1;
        display.add(buttons,c);

        buttons = new JPanel();
        buttons.setLayout(new GridLayout(3, 1));
        buttons.add(hard);
        buttons.add(reset);
        buttons.add(quit);
        c.gridx = 2;
        display.add(buttons,c);
        JPanel time = new JPanel();
        time.add(timeLabel);
        c.gridx = 0;
        c.gridy = 4;
        //Make the time stretch all the way across
        c.gridwidth = 3;
        c.ipady = 0;
        display.add(time,c);

        //Create a "tick" event handler, to update the time every second
        ActionListener updateClockAction = new ActionListener() {
          public void actionPerformed(ActionEvent e) {
              // Assumes clock is a JLabel
              timeLabel.setText("Time: " + Sudoku.game.time());
            }
        };

        //Generate a grid, to solve
        Sudoku.game.start("Easy");

        //The event happens every 1 second
        Timer t = new Timer(1000, updateClockAction);
        t.start();

        display.pack();
        display.setVisible(true);
    }

    /**
     * Move focus to a particular square
     * @param x
     * @param y
     */
    public static void setFocused(int x,int y)
    {
        focused = board[x][y];
        focused.grabFocus();
    }

The Java simple homework help being provided by our experts has all the ingredients of an effective programming solution with simply written and nicely commented codes. Students get help with Java homework that satisfies their needs from all perspectives. The Java homework answers that we provide are not verbose and drawn out. Instead, they are crisp, precise and to the point.

    /**
     * Create an element
     * @param board the game board
     * @param digit value to enter
     * @param x position (0-8)
     * @param y position (0-8)
     */
    SudokuView(JDigit[][] board,Digit digit,int x,int y)
    {
        this.setLayout(new BorderLayout());
        this.setBorder(BorderFactory.createLineBorder(Color.black, 1));
        this.setBackground(SudokuView.background);

        JDigit cellValue = new JDigit(digit,x,y);
        add(cellValue, BorderLayout.CENTER);
        board[x][y] = cellValue;
    }

    /**
     * Have we completed the game, if so display a message
     */
    public static void checkSolved()
    {
        Sudoku.game.possible();
        if (Sudoku.game.isCompleted())
        {
            CompleteDialog wellDone = new CompleteDialog(SudokuView.display,"Well Done","You completed the game in " + Sudoku.game.time());
        }
    }

    /**
     * Unable to automatically solve the problem
     */
    public static void unableToSolve()
    {
        CompleteDialog error = new CompleteDialog(SudokuView.display,"Error","Unable to solve the problem.");
    }
}

;

import javax.swing.*;
import java.awt.*;
import java.awt.event.ActionEvent;
import java.awt.event.FocusEvent;
import java.awt.event.FocusListener;
import java.awt.image.BufferedImage;

/**
 * Created with IntelliJ IDEA.
 * Date: 5/31/13
 * Time: 9:12 PM
 */

/**
 * JDigit is the main interface element, it handles a single square with a number in it
 * But it also keeps track of it's error condition, the possible values it can contain
 * And the expected value
 */
class JDigit extends JButton
{

    //Size of grid square
    private static final int SIZE = 96;
    //Base of the character
    private static final int BASE = SIZE / 8;
    private static final Font FONT = new Font("Serif", Font.BOLD, SIZE);
    //Used to keep track of focus
    private static MouseFocus mouseFocus = new MouseFocus();

    //The displayed value
    private Digit digit;
    //Image to display
    private Image image;
    private int width, height;
    //Grid x & y
    private int x,y;
    //One of the numbers in puzzle that can't be changed
    private boolean fixed;
    /**
     * Whether the square is valid
     */
    boolean error;
    /**
     * Bit field for possible
     */
    int possible;
    /**
     * The expected value
     */
    Digit answer;

    /**
     * Move the focus to the next square
     * @return false if it was the last square on the grid
     */
    public boolean focusNext()
    {
        //Default case is next digit
        int xAdd = 1;
        int yAdd = 0;

        //If we are at right of panel
        if (x % 3 == 2)
        {
            //We want to move down instead, and change x to left
            yAdd = 1;
            xAdd = -2;
            //If we are at the bottom of the panel move to the panel at the right
            if (y % 3 == 2)
            {
                yAdd = -2;
                xAdd = 1;
                //If we are at the right edge, go to the panel at the next line
                if (x == 8)
                {
                    xAdd = -8;
                    yAdd = 1;
                }
            }
        }

        //Try and focus (moveFocus returns false is it is unable to move to the next)
        return moveFocus(xAdd,yAdd);
    }

    /**
     * Move focus relative to the current square
     * @param xAdd amount to add to x
     * @param yAdd amount to add to y
     * @return false if out of range
     */
    public boolean moveFocus(int xAdd,int yAdd)
    {
        int newX = x + xAdd;
        int newY = y + yAdd;

        if (newX < 0 || newX > 8 || newY < 0 || newY > 8)
        {
            return false;
        }

        SudokuView.setFocused(newX, newY);

        return true;
    }

    /**
     * Common initializer (for grid and popup)
     */
    private void init()
    {
        fixed = false;
        error = false;
        setForeground(Color.black);
        setBorderPainted(false);
        setRolloverEnabled(true);
        image = getImage(digit);
    }

    /**
     * Create an element on the grid
     * @param digit
     * @param x
     * @param y
     */
    public JDigit(Digit digit,int x,int y)
    {
        this.digit = digit;
        this.x = x;
        this.y = y;
        setPreferredSize(new Dimension(48, 48));
        setBackground(SudokuView.background);
        setAction(new ButtonAction());
        addFocusListener(new FocusHandler());
        addMouseListener(mouseFocus);
        init();
    }

    /**
     * Create a popup element
     * @param digit
     */
    public JDigit(Digit digit)
    {
        this.digit = digit;
        this.x = -1;
        setPreferredSize(new Dimension(32, 32));
        setBackground(SudokuView.popupColor);
        setAction(new PopupAction());
        init();
    }

    /**
     * @return The digit in the cell
     */
    public Digit getDigit()
    {
        return digit;
    }

    @Override
    public String toString()
    {
        return "JDigit{" +
                "digit=" + digit +
                ", possible=" + Digit.fromBits(possible) +
                ", answer=" + answer +
                '}';
    }

    /**
     * Set the possible combinations, and check if the contents match
     * @param possible
     * @return error condition
     */
    public boolean setPossible(int possible)
    {
        this.possible = possible;
        return checkError();
    }

    /**
     * Check if the square changed error state
     * @return error state
     */
    private boolean checkError()
    {
        //So we can check if error state changed
        boolean oldError = error;
        error = false;
        if (digit != Digit.EMPTY)
        {
            //Check if the contents are possible
            if (((1 << digit.value()) & possible) == 0)
            {
                error = true;
            }
            possible = 1 << digit.value();  //Only 1 possible if we have a digit
        }
        //If error state, changed do a repaint with new background color
        if (oldError != error)
        {
            if (error)
            {
                this.setBackground(SudokuView.errorCol);
            }
            else
            {
                this.setBackground(SudokuView.background);
            }
            repaint();
        }
        return error;
    }

    /**
     * Lightweight way of accessing the grid
     * @param digit replacement value
     */
    public void tryDigit(Digit digit)
    {
        this.digit = digit;
    }

    /**
     * Set digit, check for error, repaint
     * @param digit
     */
    public void setDigit(Digit digit)
    {
        //Are we entering a puzzle?
        if (Sudoku.game.isEntering())
        {
            //Fixed square (unless it is 0)
            fixed = digit.value() != 0;
            //Answer is the value we entered
            answer = digit;
            //Set the correct background color
            if (fixed)
            {
                setBackground(SudokuView.fixedCol);
            }
            else
            {
                setBackground(SudokuView.background);
                if (this == SudokuView.focused)
                {
                    setBackground(SudokuView.background.brighter().brighter());
                }
            }
        }
        else
        {
            //If it was fixed value, make sure nothing else caused an error
            if (fixed)
            {
                Sudoku.game.possible();
                checkError();
                return;
            }
        }

        this.digit = digit;
        image = getImage(digit);

        //Check for errors and repaint (if not entering)
        if (!Sudoku.game.isEntering())
        {
            Sudoku.game.possible();
            checkError();
            repaint();
        }
    }

    @Override
    /**
     * Display Digit
     * @param g - Graphics
     */
    protected void paintComponent(Graphics g)
    {
        //Get the width, height and color of the digit
        int w = getWidth();
        int h = getHeight();
        g.setColor(getBackground());
        if (fixed)
        {
            g.setColor(SudokuView.fixedCol);
            if (SudokuView.focused == this)
            {
                g.setColor(SudokuView.fixedCol.brighter().brighter());
            }

Our online experts also explain that Java programming is a portable and robust language, thus making java to remove error like situations by highlighting the compile time error checking and runtime checking. The multithreading features of java enable the user to write programs that can simultaneously perform many tasks.

The students come to us with request like do my Java assignment because we are one the most exhaustive solution providers. The Java programming project help service being provided by our experts ensures a speedy delivery of the homework solution that caters to your needs. The Java homework problems that the students get as part of the various evaluation tests meets with the precise answers by our experts through help with Java assignment. Java is one of the most commonly used programming languages across the globe these days, that is why we have also initiated Java programming assignment help services to imbibe the programming concepts in java amongst the students in the best way possible.

        }
        if (this.error)
        {
            g.setColor(SudokuView.errorCol);
            if (SudokuView.focused == this)
            {
                g.setColor(SudokuView.errorCol.brighter().brighter());
            }
        }
        //If we are dealing with the popup, we want the colors to reflect what is
        //available
        if (x < 0)
        {
            g.setColor(SudokuView.errorCol);
            //Get the original digit, so we can clear it, and regenerate the possibilities
            Digit saveDigit = SudokuView.focused.getDigit();
            SudokuView.focused.tryDigit(Digit.EMPTY);
            Sudoku.game.possible();
            SudokuView.focused.tryDigit(saveDigit);
            //Get the list of possible values
            String digits = Digit.fromBits(SudokuView.focused.possible);
            //If the digit is one of the possibles change the background color from the error
            if (digits.contains(digit.toString()))
            {
                g.setColor(SudokuView.popupColor);
            }
        }
        //Draw the blank square
        g.fillRect(0, 0, w, h);
        //Then draw the number on top
        g.drawImage(image,
                0, 0, w, h,
                0, 0, width, height, null);
    }

One of the defining java features is the Interpreter, which translates the Java byte code into native machine code. One of the other features of java is its high performance that helps us to understand the use of Just-In-Time compilers that enables high performance. Java is distributed because of the distributed environment of the internet. Java is more dynamic than C or C++.

/**

    /**
     * @param digit
     * @return Get the image of the digit
     */
    private Image getImage(Digit digit)
    {
        //Create an image of the digit
        BufferedImage bi = new BufferedImage(
                SIZE, SIZE, BufferedImage.TYPE_INT_ARGB);
        Graphics2D g2d = bi.createGraphics();
        g2d.setRenderingHint(
                RenderingHints.KEY_ANTIALIASING,
                RenderingHints.VALUE_ANTIALIAS_ON);
        g2d.setColor(this.getForeground());
        g2d.setFont(FONT);
        FontMetrics fm = g2d.getFontMetrics();
        width = fm.stringWidth(digit.toString());
        height = fm.getAscent();
        g2d.drawString(digit.toString(), 0, height - BASE);
        g2d.dispose();
        return bi;
    }

    /**
     * Swap 2 squares around used in shuffle
     * @param other
     */
    void swap(JDigit other)
    {
        Digit save = this.digit;
        this.digit = other.digit;
        other.digit = save;
        save = answer;
        answer = other.answer;
        other.answer = save;
        Image saveImage = image;
        image = other.image;
        other.image = saveImage;
    }

    /**
     * Display popup grid
     */
    private class ButtonAction extends AbstractAction
    {
        //@Override
        public void actionPerformed(ActionEvent e)
        {
            if (fixed) return;
            if (Sudoku.game.isCompleted()) return;
            SudokuView.popup.show(JDigit.this,  width/2 -getWidth(), -getHeight() + height/4);
            SudokuView.popup.requestFocus();
        }
    }

    /**
     * Select digit from popup
     */
    private class PopupAction extends AbstractAction
    {
        //@Override
        public void actionPerformed(ActionEvent e)
        {
            SudokuView.popup.setVisible(false);
            SudokuView.focused.setDigit(digit);
            Sudoku.game.possible();
            checkError();
            if (Sudoku.game.isEntering())
            {
                if (!SudokuView.focused.error)
                {
                    if (!SudokuView.focused.focusNext())
                    {
                        Sudoku.game.finishEntering();
                    }
                }
            }
            //See if we solved the game
            SudokuView.checkSolved();
        }
    }

    /**
     * Select the grid element under the cursor
     */
    private class FocusHandler implements FocusListener
    {

        private Color background = getBackground();

        //@Override
        public void focusGained(FocusEvent e)
        {
            setBackground(background.brighter().brighter());
            SudokuView.focused = JDigit.this;
            //If focused changed, then disable the popup
            SudokuView.popup.setVisible(false);
            Sudoku.game.possible();
            checkError();
            JDigit.this.repaint();
        }

        //@Override
        public void focusLost(FocusEvent e)
        {
            if (e.getComponent() == SudokuView.focused)
            {
                if (SudokuView.focused.fixed)
                {
                    setBackground(SudokuView.fixedCol);
                }
                else