Welcome to the Java Programming Forums


The professional, friendly Java community. 21,500 members and growing!


The Java Programming Forums are a community of Java programmers from all around the World. Our members have a wide range of skills and they all have one thing in common: A passion to learn and code Java. We invite beginner Java programmers right through to Java professionals to post here and share your knowledge. Become a part of the community, help others, expand your knowledge of Java and enjoy talking with like minded people. Registration is quick and best of all free. We look forward to meeting you.


>> REGISTER NOW TO START POSTING


Members have full access to the forums. Advertisements are removed for registered users.

Results 1 to 2 of 2

Thread: JFrame Menu bar errors.

  1. #1
    Member
    Join Date
    Feb 2012
    Location
    Azle/Arlington
    Posts
    31
    My Mood
    Torn
    Thanks
    2
    Thanked 0 Times in 0 Posts

    Question JFrame Menu bar errors.

    I am trying to get a menubar for a number puzzle game i am working on.

    Here is my code as of yet.

    thats the code for the game. Im trying to mix in a lil bit of code for a menu bar to allow me to change the theme.

    I know i need to implement action listeners for each theme and when that action is clicked i want to change the ThemeBC to 1 color using RGB r1,g1,b1 and ThemeF to a second color using r2,g2,b2. (but i want to be able to switch the theme by clicking a different 1 in the middle of a game and having it update. Any and all help would be appreciated as I would be taking up some of your time.

     
    \\JamesWilliams period 5
     
    import java.awt.*;
    import java.awt.event.*;
    import java.applet.*;
    import java.util.Random;
    import javax.swing.*;
     
    public class JDub extends Applet
    {
     
     
     
    	// These are all global / class variables.
    	private int size;
    	private String lastLetter;
    	private int rows;
    	private int cols;
    	private int rowsXcols;
    	private int moveCounter = 0;
    	private int moveCounterUpdated = 0;
    	private Graphics g;
    	// rects is a matrix of rectangles.
    	private Rectangle rects[][];
    	// scramble is declared as a static array of boolean values.
    	private boolean scramble[];
    	// matrix is declared as a two dimentional static array of Strings.
    	private String matrix[][];
    	// rnd is declared as an object of the Random class.
    	private Random rnd;
    	// blankR is declared as an integer variable to indicate a blank row number.
    	private int blankR;
    	// blankC is declared as an integer variable to indicate a column number.
    	private int blankC;
            private String label = null;
     
    	private int cellSize;
    	private String player;
     	private Button _myButton;
    	int r1 = 0;
    	int r2 = 255;
    	int g1 = 0;
            int g2 = 255;
    	int b1 = 0;
    	int b2 = 255;
    	color ThemeBC = new color(r1,g1,b1);
    	color ThemeF = new color(r2,g2,b2);
     
     
     
    	public static void main(String ad[])
        {
     
            JFrame jwill = new JFrame();
            JDub a=new JDub();
            jwill.getContentPane().add(a, BorderLayout.CENTER);
            jwill.setSize(new Dimension(700,700));
            jwill.setResizable(false);
            jwill.setDefaultCloseOperation(JFrame.DISPOSE_ON_CLOSE);
            jwill.setVisible(true);
    	// Create the menu bar
    	JMenuBar menuBar = new JMenuBar();
     
    	// Create a menu
    	JMenu menu = new JMenu("Theme");
    	menuBar.add(menu);
     
    	// Create a menu item
    	JMenuItem item = new JMenuItem("Xmas");
    	item.addActionListener(actionListener);
    	menu.add(item);
     
    	// Install the menu bar in the frame
    	jwill.setJMenuBar(menuBar);
     
     
        }
     
     
     
      public void init() {
        _myButton = new Button (getParameter (
                            "label"));
        _myButton.addActionListener (
          new AbstractAction () {
            public void actionPerformed (
                          ActionEvent event) {
              Frame f = new Frame("Frame");
              f.pack();
              f.show();
            }
          }
        );
        add (_myButton);
      }
     
     
     
     
     
    	////////////////////////////////////////////////////////////////////////////////////////////////
     
    	/* The init method is a void method used to initialize the class variables. */
    	{
    		player = "";
     
    		// This is a call to the enterSizeAndPlayersName method.
    		enterSizeAndPlayersName();
     
    		/** size is a global variable returned by the above method.
    		* size is the number of rows and columns for this puzzle.
    		* 540 pixels is the size of the whole puzzle.  Therefore the
    		* cellSize of a 3 by 3 is 540/3 or 180 pixels.*/
    		if (size >= 2) cellSize = 400 / size;
     
    		else cellSize = 540 / size;
     
    		/** The size of the rects matrix, an object of the Rectangle
    		* class, is determined by the values of row +1 & col +1. So
    		* a 3 X 3 will have 4 rows and 4 columns.**/
    		rects = new Rectangle[rows + 1][cols +1];
     
     
    		for(int row = 1; row <= rows; row++)
    		{
    			for(int col = 1; col <= cols; col++)
    			{
    				int x = (col - 1) * cellSize + cellSize;
    				int y = (row - 1) * cellSize + cellSize;
     
    				rects[row][col] = new Rectangle(x,y,cellSize,cellSize);
     
    			}
    		}
     
    		// matrix is defined here as a rows + 2 by cols + 2 matrix of Strings.
    		matrix = new String[rows+2][cols+2];
     
    		// scramble is defined here as a  rows by cols + 1 elements of booleans.
    		scramble = new boolean[rowsXcols + 1];
     
    		// This for loop will fill the scramble array with 16 values of false.
    		for (int k = 1; k <=rowsXcols; k++)
    			scramble[k] = false;
     
    		// rnd is defined as a Random object without a seed value.
    		rnd = new Random();
     
    		// A 6 by 6 matrix is filled with the "#" pound sign as a String.
    		for (int r = 0; r <= rows + 1; r++)
    			for (int c = 0; c <= cols + 1; c++)
    				matrix[r][c] = "#";
     
    		/* Then a 4 by 4 matrix is defined inside the 6 by 6 matrix but
    		 * starting at 1,1 instead of 0,0.  This matrix will be filled
    		 * with letters supplied by the getLetter method with the last of the
    		 * sixteen letters (P) being blanked out by the if statement
    		 * if(matrix[r][c].equals("L")) */
    		for (int r = 1; r <= rows; r++)
    			for (int c = 1; c <= cols; c++)
    			{
    				matrix[r][c] = getLetter();
    				if (matrix[r][c].equals(lastLetter))
    				{
    					// Here the blankR varaible is defined as the r number that would
    					// normally hold the letter lastLetter.
    					blankR = r;
     
    					// Here the blankC varaible is defined as the c number that would
    					// normally hold the letter lastLetter.
    					blankC = c;
    				}
    			}
    	} // End of the init method ////////////////////////////////////////////////////////////////////
    	////////////////////////////////////////////////////////////////////////////////////////////////
     
        ////////////////////////////////////////////////////////////////////////////////////////////////
    	/** The enterSize method is a void method that will prompt the user for a 3 for a 3 X 3 grid, a
    	 *  4 for a 4 X 4 grid and a 5 for a 5 X 5 grid for the Letter Puzzle. **/
    	public void enterSizeAndPlayersName()
    	{
    		// Prompt the user for a grid size.
    		String prompt = "Enter Play Level\n 3 - 3 X 3 Grid\n 4 - 4 X 4 Grid\n 5 - 5 X 5 Grid\n 6 - 6 X 6 Grid\n 7 - 7 X 7 Grid\n 8 - 8 X 8 Grid\n 9 - 9 X 9 Grid\n 10 - 10 X 10 Grid\n";
     
    		// Assign the number entered to a string variable named sizeString.
    		String sizeString = JOptionPane.showInputDialog(prompt);
     
    		String IdiotMax = "The max is 10 X 10 moron";
    		String IdiotMin = "The min is 2 X 2 idiot";
                    String tryagain = "";
     
     
     
    		// Convert sizeString into integer variable size using the parseInt method of Integer class.
    		size = Integer.parseInt(sizeString);
     
    		if (size > 10)
    		{
                            tryagain = IdiotMax + "! Would you like to try again?";
    			int retry = JOptionPane.showConfirmDialog(null,
    			tryagain,
    			"Click Yes or No:",
    			JOptionPane.YES_NO_OPTION);
     
    			if (retry == JOptionPane.YES_OPTION) {enterSizeAndPlayersName(); }
    			else if (retry == JOptionPane.NO_OPTION) {System.exit(0);}
    		}
     
    		if (size < 2)
    		{
    			tryagain = IdiotMin + "! Would you like to try again?";
    			int retry = JOptionPane.showConfirmDialog(null,
    			tryagain,
    			"Click Yes or No:",
    			JOptionPane.YES_NO_OPTION);
     
    			if (retry == JOptionPane.YES_OPTION) {enterSizeAndPlayersName(); }
    			else if (retry == JOptionPane.NO_OPTION) {System.exit(0);}
     
    		}
     
    		String playerNamePrompt = "Enter Your Full Name as the player. \n";
    		player = JOptionPane.showInputDialog(playerNamePrompt);
     
    		// Size is the number of rows and columns in the grid.
    		rows = size;
    		cols = size;
     
    		// A 3 by 3 grid will have 9 (3 * 3) cells.
    		rowsXcols = rows * cols;
     
    		// The size will determine the value of lastLetter variable.
    		switch (size)
    		{
    			case 2: lastLetter = "4"; break;
    			case 3: lastLetter = "9"; break;
    			case 4: lastLetter = "16"; break;
    			case 5: lastLetter = "25"; break;
    			case 6: lastLetter = "36"; break;
    			case 7: lastLetter = "49"; break;
    			case 8: lastLetter = "64"; break;
    			case 9: lastLetter = "81"; break;
    			case 10: lastLetter = "100"; break;
    		}
    	} // End of the enterSize method ///////////////////////////////////////////////////////////////
    	////////////////////////////////////////////////////////////////////////////////////////////////
     
     
     
     
     
     
     
    	////////////////////////////////////////////////////////////////////////////////////////////////
    	/* This is the getLetter method and it is called by the init method to get a letter
    	 * to draw in the 4 by 4 matrix inside the 6 by 6 matrix of #'s. */
    	public String getLetter()
    	{
    		// The String letter is initalized to an empty string.
    		String letter = "";
     
    		// The boolean varaible Done is declared and defined as "false".
    		boolean Done = false;
     
    		// While Done is not true (false) this loop will continue.
    		while(!Done)
    		{
    			// A new integer variable rndNum is declared and defined as a random
    			// integer between 1 and 16.
    			int rndNum = rnd.nextInt(rowsXcols) + 1;
     
    			// If the scramble array at element rndNum is false (each element is the
    			// array is defined as false), then the if statement is executed.
    			if (scramble[rndNum] == false)
    			{
    				// Capital letter A is 65 in Unicode and ASCII codes.  Therefore, the
    				// rndNum + 64 will range between A and P. Here the String letter is
    				// defined as the character of the value at rndNum + 64.
    				letter = String.valueOf(rndNum);
     
    				// The element at rndNum in the scramble array is declared to be true
    				// so that the letters are only assigned once. Each time a letter is
    				// assigned that recatangle's scramble value is turned to true.
    				scramble[rndNum] = true;
     
    				// The while loop will execute once and only once each time
    				Done = true;
    			}
    		}
    		return letter;
    	} // End of the getLetter method ///////////////////////////////////////////////////////////////
    	////////////////////////////////////////////////////////////////////////////////////////////////
     
     
     
     
     
     
     
    	////////////////////////////////////////////////////////////////////////////////////////////////
    	/* The paint method will draw the grid lines and each capital letter assigned to
    	 * each matrix point. */
    	public void paint(Graphics out)
    	{
    		// g is the global object of the Graphics class while output is the local variable.
    		g=out;
     
                    g.setColor(new Color(0,100,0));
                    g.fillRect(0,0,800,800);
                    g.setColor(Color.BLUE);
    		// This is a call to the drawGrid method and we are passing it the global variable g.
    		drawGrid(g);
     
    		// Font attributes are set here.
    		g.setFont(new Font("Arial",Font.BOLD,20));
     
    		// Author's name is displayed.
    		g.drawString("J-Will's Number Puzzle",20,40);
     
    		// Moves Taken string is displayed at 390 x and 40 y.
    		g.drawString("Moves Taken ",390,40);
     
    		// The current player from the JOption pane input window is displayed at (20, 60).
    		g.drawString("Current Player:  " + player,40,60);
     
    		// This is where the moveCounter will be displayed.
    		g.drawRect(530, 15, 150, 50);
     
    		// The moverCounter is shown as an empty string plus the number.
    		String counter = "" + moveCounter;
     
    		/** If the moverCounter is less than the moveCounterUpdated variable, then the
    		 *  swap method has been called and the moveCounterUpdated++; statement has
    		 *  added one to the moveCounterUpdated variable.  That will cause the
    		 *  moveCounter to be one less than the moveCounterUpdated.  That is when the
    		 *  old number needs to be blanked out with a white rectangle. **/
    		if(moveCounter < moveCounterUpdated)
    		{
    			// The color white is set.
    			g.setColor(new Color(0,100,0));
     
    			// The display area for the moveCounter is painted white = blanked.
    			g.fillRect(531,16,148,48);
     
    			// After the area is blanked moveCounter is assigned moveCounterUpdated.
    			moveCounter = moveCounterUpdated;
    		}
     
    		/** After moveCounter is updated a new number of moves needs to be displayed. **/
    		if(moveCounter == moveCounterUpdated)
    		{
    			// Change the color to burnt orange of UT is 204,85,0 or HTML CC5500.
    			g.setColor(Color.RED);
     
    			// Change the Font and Font size.
    			g.setFont(new Font("Arial",Font.BOLD,49));
     
    			// Draw the number in the rectangle.
    			g.drawString(counter,535,58);
    		}
     
     
    		for (int r = 1; r <= rows; r++)
    		{
    			for (int c = 1; c <= cols; c++)
    			{
    				int y =  (r - 1) * cellSize + cellSize;
    				int x =  (c - 1) * cellSize + cellSize;
    				drawLetter(g,matrix[r][c],x,y);
    			}
    		}
     
     
    	} // End of the paint method  //////////////////////////////////////////////////////////////////
    	////////////////////////////////////////////////////////////////////////////////////////////////
     
     
     
     
     
     
     
    	////////////////////////////////////////////////////////////////////////////////////////////////
    	/* The drawGrid method will draw the outline and lines for the three by three grid. */
    	public void drawGrid(Graphics g)
    	{
    		for(int r = 1; r <= rows; r++)
    		{
    			for(int c = 1; c <= cols; c++)
    			{
    				int y = 20 + (r - 1) * cellSize + cellSize;
    				int x = 10 + (c - 1) * cellSize + cellSize;
     
    				g.drawRect(x,y,cellSize,cellSize);
     
    			}
    		}
    	} // End of drawGrid method  ///////////////////////////////////////////////////////////////////
    	////////////////////////////////////////////////////////////////////////////////////////////////
     
     
     
     
     
     
     
    	////////////////////////////////////////////////////////////////////////////////////////////////
    	/* The drawLetter will draw the appropiate letter in the appropiate matrix location
    	 * and it will be an Arial font that is bold and size 200.  The offset will center
    	 * the letter inside the 200 by 200 square. unless the letter is an lastLetter, in which
    	 * case a blank is draw at that locaton. */
    	public void drawLetter(Graphics g, String letter, int x, int y)
    	{
    		g.setFont(new Font("Arial",Font.BOLD,cellSize - 10));
     
    		int offSetX = x + 12;
    		int offSetY = y + 20 + (cellSize * 4 / 5 );
    		int offSetX2 = offSetX + 10;
    		int offSetY2 = offSetY;
     
    		int num = Integer.parseInt(letter);
     
     
     
    		if (letter.equals(lastLetter))
    		{
    			g.setColor(new Color(0,100,0));
    			g.fillRect(x+11,y+21,cellSize - 2,cellSize - 2);
    		}
    		else
    		{
     
    			if (num < 10)
    		{
    			g.setColor(Color.RED);
    			g.drawString(letter,offSetX2, offSetY2);
    		}
    		else
    		{
    			g.setColor(Color.RED);
    			g.drawString(letter,offSetX,offSetY);
    		}
    		}
    	} // End of drawLetter method
    	////////////////////////////////////////////////////////////////////////////////////////////////
     
     
     
     
     
     
     
    	////////////////////////////////////////////////////////////////////////////////////////////////
    	/*
    	 * The mouseDown method will detect if the mouse is depressed inside one of the
    	 * 9 recatangles. It will also check to see if any of the 8 rectangles around
    	 * the current rectangle is empty(the one with the letter "I"), using the
    	 * okSquare() method.  If both of those conditions are true then the letter
    	 * is swapped places with the letter "I".
    	 **/
    	public boolean mouseDown(Event e, int x, int y)
    	{
    		/* If you click in the rectangle and that rectangle has the letter I
    		 * in one of the four adjoining squares, then that letter is swapped with
    		 * the letter "I" which is the empty square because the last letter is the
    		 * series is made to be blank so that one square is always empty. */
    		for (int r = 1; r <= rows; r++)
    		{
    			for (int c = 1; c <= cols; c++)
    			{
     
    				if(rects[r][c].inside(x,y) && okSquare(r,c))
    				swap(r,c);
    			}
    		}
     
     
     
    		return true;
     
    	} //End of mouseDown method ////////////////////////////////////////////////////////////////////
    	////////////////////////////////////////////////////////////////////////////////////////////////
     
     
     
     
     
     
     
    	////////////////////////////////////////////////////////////////////////////////////////////////
    	/* The okSquare method is sent the row and column numbers
    	 * of the a 3 by 3 matrix location as defined by the r and
    	 * the c values.  The square is OK if the square above [r-1], or
    	 * the square below [r+1], or the square to the left [c-1], or
    	 * the square to right [c+1] contains the letter "I" and is
    	 * therefore blank or empty. If any of those four conditions
    	 * are true then the value of true is returned and okSquare
    	 * condition is true. */
    	public boolean okSquare(int r, int c)
    	{
    		boolean temp = false;
    		if (matrix[r-1][c].equals(lastLetter))
    			temp = true;
    		else if (matrix[r+1][c].equals(lastLetter))
    			temp = true;
    		else if (matrix[r][c-1].equals(lastLetter))
    			temp = true;
    		else if (matrix[r][c+1].equals(lastLetter))
    			temp = true;
    		return temp;
    	} // End of okSquare method  ///////////////////////////////////////////////////////////////////
    	////////////////////////////////////////////////////////////////////////////////////////////////
     
     
     
     
     
     
     
    	////////////////////////////////////////////////////////////////////////////////////////////////
    	/* The row and column number of the blank square is swapped with
    	 * the row and column number passed to this method and then the
    	 * entire applet is redrawn with repaint() method. */
    	public void swap(int r, int c)
    	{
    		moveCounterUpdated ++;
    		matrix[blankR][blankC] = matrix[r][c];
    		matrix[r][c] = lastLetter;
    		blankR = r;
    		blankC = c;
     
                    repaint();
     
                    youwin(g);
    	} // End of swap method  ///////////////////////////////////////////////////////////////////////
    	////////////////////////////////////////////////////////////////////////////////////////////////
     
    	public void youwin(Graphics g)
    	{
    	String mn = "";
    	if (moveCounterUpdated <= 1)
    	{ moveCounterUpdated = 1; mn = " move!!!";}
    	else
    	{ mn = " moves!";}
    	String Winner = "Congrats " + player + " on solving the " + size + " by " + size + " puzzle in " + moveCounterUpdated + mn;
            String Loss = "TROLOLOLOLO, You can not win them all!!!!!!!!!!!!";
     
     
    	if (size >= 6)
    	{Winner = Winner + "\n What? Would you like a cookie???";}
     
    	boolean Win = false;
    	boolean lose = false;
    	switch (size)
    	{
    		case 2: Win = win2x2(); lose = lose2x2();break;
    		case 3: Win = win3x3();break;
    		case 4: Win = win4x4();break;
    		case 5: Win = win5x5();break;
    		case 6: Win = win6x6();break;
    		case 7: Win = win7x7();break;
    		case 8: Win = win8x8();break;
    		case 9: Win = win9x9();break;
    		case 10: Win = win10x10();
    	}
     
    	if(Win)
    	{
            JOptionPane.showMessageDialog(this, Winner);
            System.exit(0);
            }
     
    	if(lose)
    	{
    	JOptionPane.showMessageDialog(this, Loss);
            System.exit(0);
            }
    	}
     
     
    	public boolean lose2x2()
    	{
    	boolean lose = false;
     
    	if(matrix[1][1].equals("2") && matrix[1][2].equals("1"))
    	{ lose = true;   }
    		return lose;
    	}
     
    	public boolean win2x2()
    	{
    	boolean win = false;
     
    	if(matrix[1][1].equals("1") && matrix[1][2].equals("2") &&
    	   matrix[2][1].equals("3"))
    	{  	win = true;  }
     
    	   return win;
    	}
     
    	public boolean win3x3()
    	{
    	boolean win = false;
     
    	if(matrix[1][1].equals("1") && matrix[1][2].equals("2") && matrix[1][3].equals("3") &&
    	   matrix[2][1].equals("4") && matrix[2][2].equals("5") && matrix[2][3].equals("6") &&
    	   matrix[3][1].equals("7") && matrix[3][2].equals("8"))
    	{	win = true;   }
     
     
    		return win;
    	}
     
    	public boolean win4x4()
    	{
    	boolean win = false;
     
    	if(matrix[1][1].equals("1") && matrix[1][2].equals("2") && matrix[1][3].equals("3") && matrix[1][4].equals("4") &&
    	   matrix[2][1].equals("5") && matrix[2][2].equals("6") && matrix[2][3].equals("7") && matrix[2][4].equals("8") &&
    	   matrix[3][1].equals("9") && matrix[3][2].equals("10") && matrix[3][3].equals("11") && matrix[3][4].equals("12") &&
    	   matrix[4][1].equals("13") && matrix[4][2].equals("14") && matrix[4][3].equals("15") )
    	{	win = true;   }
     
     
    		return win;
    	}
     
    	public boolean win5x5()
    	{
        boolean win = false;
     
        if (matrix[1][1].equals("1") && matrix[1][2].equals("2") && matrix[1][3].equals("3") && matrix[1][4].equals("4") && matrix[1][5].equals("5") &&
        	matrix[2][1].equals("6") && matrix[2][2].equals("7") && matrix[2][3].equals("8") && matrix[2][4].equals("9") && matrix[2][5].equals("10") &&
        	matrix[3][1].equals("11") && matrix[3][2].equals("12") && matrix[3][3].equals("13") && matrix[3][4].equals("14") && matrix[3][5].equals("15") &&
        	matrix[4][1].equals("16") && matrix[4][2].equals("17") && matrix[4][3].equals("18") && matrix[4][4].equals("19") && matrix[4][5].equals("20") &&
        	matrix[5][1].equals("21") && matrix[5][2].equals("22") && matrix[5][3].equals("23") && matrix[5][4].equals("24"))
        	{ win = true; }
     
        	return win;
    	}
     
    	public boolean win6x6()
    	{
    	boolean win = false;
     
        if (matrix[1][1].equals("1") && matrix[1][2].equals("2") && matrix[1][3].equals("3") && matrix[1][4].equals("4") && matrix[1][5].equals("5") && matrix[1][6].equals("6") &&
    	matrix[2][1].equals("7") && matrix[2][2].equals("8") && matrix[2][3].equals("9") && matrix[2][4].equals("10") && matrix[2][5].equals("11") && matrix[2][6].equals("12") &&
    	matrix[3][1].equals("13") && matrix[3][2].equals("14") && matrix[3][3].equals("15") && matrix[3][4].equals("16") && matrix[3][5].equals("17") && matrix[3][6].equals("18") &&
    	matrix[4][1].equals("19") && matrix[4][2].equals("20") && matrix[4][3].equals("21") && matrix[4][4].equals("22") && matrix[4][5].equals("23") && matrix[4][6].equals("24") &&
    	matrix[5][1].equals("25") && matrix[5][2].equals("26") && matrix[5][3].equals("27") && matrix[5][4].equals("28") && matrix[5][5].equals("29") && matrix[5][6].equals("30") &&
    	matrix[6][1].equals("31") && matrix[6][2].equals("32") && matrix[6][3].equals("33") && matrix[6][4].equals("34") && matrix[6][5].equals("35"))
    	{ win = true; }
     
    	return win;
    	}
     
    	public boolean win7x7()
    	{
    		boolean win = false;
     
    	if (matrix[1][1].equals("1") && matrix[1][2].equals("2") && matrix[1][3].equals("3") && matrix[1][4].equals("4") && matrix[1][5].equals("5") && matrix[1][6].equals("6") && matrix[1][7].equals("7") &&
    		matrix[2][1].equals("8") && matrix[2][2].equals("9") && matrix[2][3].equals("10") && matrix[2][4].equals("11") && matrix[2][5].equals("12") && matrix[2][6].equals("13") && matrix[2][7].equals("14") &&
    		matrix[3][1].equals("15") && matrix[3][2].equals("16") && matrix[3][3].equals("17") && matrix[3][4].equals("18") && matrix[3][5].equals("19") && matrix[3][6].equals("20") && matrix[3][7].equals("21") &&
    		matrix[4][1].equals("22") && matrix[4][2].equals("23") && matrix[4][3].equals("24") && matrix[4][4].equals("25") && matrix[4][5].equals("26") && matrix[4][6].equals("27") && matrix[4][7].equals("28") &&
    		matrix[5][1].equals("29") && matrix[5][2].equals("30") && matrix[5][3].equals("31") && matrix[5][4].equals("32") && matrix[5][5].equals("33") && matrix[5][6].equals("34") && matrix[5][7].equals("35") &&
    		matrix[6][1].equals("36") && matrix[6][2].equals("37") && matrix[6][3].equals("38") && matrix[6][4].equals("39") && matrix[6][5].equals("40") && matrix[6][6].equals("41") && matrix[6][7].equals("42") &&
    		matrix[7][1].equals("43") && matrix[7][2].equals("44") && matrix[7][3].equals("45") && matrix[7][4].equals("46") && matrix[7][5].equals("47") && matrix[7][6].equals("48"))
    		{ win = true; }
     
        	return win;
    	}
     
    	public boolean win8x8()
    	{
    	boolean win = false;
     
    	if (matrix[1][1].equals("1") && matrix[1][2].equals("2") && matrix[1][3].equals("3") && matrix[1][4].equals("4") &&
    		matrix[1][5].equals("5") && matrix[1][6].equals("6") && matrix[1][7].equals("7") && matrix[1][8].equals("8") &&
    		matrix[2][1].equals("9") && matrix[2][2].equals("10") && matrix[2][3].equals("11") && matrix[2][4].equals("12") &&
    		matrix[2][5].equals("13") && matrix[2][6].equals("14") && matrix[2][7].equals("15") && matrix[2][8].equals("16") &&
    		matrix[3][1].equals("17") && matrix[3][2].equals("18") && matrix[3][3].equals("19") && matrix[3][4].equals("20") &&
    		matrix[3][5].equals("21") && matrix[3][6].equals("22") && matrix[3][7].equals("23") && matrix[3][8].equals("24") &&
    		matrix[4][1].equals("25") && matrix[4][2].equals("26") && matrix[4][3].equals("27") && matrix[4][4].equals("28") &&
    		matrix[4][5].equals("29") && matrix[4][6].equals("30") && matrix[4][7].equals("31") && matrix[4][8].equals("32") &&
    		matrix[5][1].equals("33") && matrix[5][2].equals("34") && matrix[5][3].equals("35") && matrix[5][4].equals("36") &&
    		matrix[5][5].equals("37") && matrix[5][6].equals("38") && matrix[5][7].equals("39") && matrix[5][8].equals("40") &&
    		matrix[6][1].equals("41") && matrix[6][2].equals("42") && matrix[6][3].equals("43") && matrix[6][4].equals("44") &&
    		matrix[6][5].equals("45") && matrix[6][6].equals("46") && matrix[6][7].equals("47") && matrix[6][8].equals("48") &&
    		matrix[7][1].equals("49") && matrix[7][2].equals("50") && matrix[7][3].equals("51") && matrix[7][4].equals("52") &&
    		matrix[7][5].equals("53") && matrix[7][6].equals("54") && matrix[7][7].equals("55") && matrix[7][8].equals("56") &&
    		matrix[8][1].equals("57") && matrix[8][2].equals("58") && matrix[8][3].equals("59") && matrix[8][4].equals("60") &&
    		matrix[8][5].equals("61") && matrix[8][6].equals("62") && matrix[8][7].equals("63"))
    		{win = true;}
     
        	return win;
    	}
     
    	public boolean win9x9()
    	{
    	boolean win = false;
            if ( matrix[1][1].equals("1") && matrix[1][2].equals("2") && matrix[1][3].equals("3") && matrix[1][4].equals("4") && matrix[1][5].equals("5") &&
                 matrix[1][6].equals("6") && matrix[1][7].equals("7") && matrix[1][8].equals("8") && matrix[1][9].equals("9") &&
                 matrix[2][1].equals("10") && matrix[2][2].equals("11") && matrix[2][3].equals("12") && matrix[2][4].equals("13") && matrix[2][5].equals("14") &&
                 matrix[2][6].equals("15") && matrix[2][7].equals("16") && matrix[2][8].equals("17") && matrix[2][9].equals("18") &&
                 matrix[3][1].equals("19") && matrix[3][2].equals("20") && matrix[3][3].equals("21") && matrix[3][4].equals("22") && matrix[3][5].equals("23") &&
                 matrix[3][6].equals("24") && matrix[3][7].equals("25") && matrix[3][8].equals("26") && matrix[3][9].equals("27") &&
                 matrix[4][1].equals("28") && matrix[4][2].equals("29") && matrix[4][3].equals("30") && matrix[4][4].equals("31") && matrix[4][5].equals("32") &&
                 matrix[4][6].equals("33") && matrix[4][7].equals("34") && matrix[4][8].equals("35") && matrix[4][9].equals("36") &&
                 matrix[5][1].equals("37") && matrix[5][2].equals("38") && matrix[5][3].equals("39") && matrix[5][4].equals("40") && matrix[5][5].equals("41") &&
                 matrix[5][6].equals("42") && matrix[5][7].equals("43") && matrix[5][8].equals("44") && matrix[5][9].equals("45") &&
                 matrix[6][1].equals("46") && matrix[6][2].equals("47") && matrix[6][3].equals("48") && matrix[6][4].equals("49") && matrix[6][5].equals("50") &&
                 matrix[6][6].equals("51") && matrix[6][7].equals("52") && matrix[6][8].equals("53") && matrix[6][9].equals("54") &&
                 matrix[7][1].equals("55") && matrix[7][2].equals("56") && matrix[7][3].equals("57") && matrix[7][4].equals("58") && matrix[7][5].equals("59") &&
                 matrix[7][6].equals("60") && matrix[7][7].equals("61") && matrix[7][8].equals("62") && matrix[7][9].equals("63") &&
                 matrix[8][1].equals("64") && matrix[8][2].equals("65") && matrix[8][3].equals("66") && matrix[8][4].equals("67") && matrix[8][5].equals("68") &&
                 matrix[8][6].equals("69") && matrix[8][7].equals("70") && matrix[8][8].equals("71") && matrix[8][9].equals("72") &&
                 matrix[9][1].equals("73") && matrix[9][2].equals("74") && matrix[9][3].equals("75") && matrix[9][4].equals("76") && matrix[9][5].equals("77") &&
                 matrix[9][6].equals("78") && matrix[9][7].equals("79") && matrix[9][8].equals("80"))
            { win = true; }
        	return win;
    	}
     
    	public boolean win10x10()
    	{
    	boolean win = false;
    	if ( matrix[1][1].equals("1") && matrix[1][2].equals("2") && matrix[1][3].equals("3") && matrix[1][4].equals("4") && matrix[1][5].equals("5") &&
    		 matrix[1][6].equals("6") && matrix[1][7].equals("7") && matrix[1][8].equals("8") && matrix[1][9].equals("9") && matrix[1][10].equals("10") &&
    		 matrix[2][1].equals("11") && matrix[2][2].equals("12") && matrix[2][3].equals("13") && matrix[2][4].equals("14") && matrix[2][5].equals("15") &&
    		 matrix[2][6].equals("16") && matrix[2][7].equals("17") && matrix[2][8].equals("18") && matrix[2][9].equals("19") && matrix[2][10].equals("20") &&
    		 matrix[3][1].equals("21") && matrix[3][2].equals("22") && matrix[3][3].equals("23") && matrix[3][4].equals("24") && matrix[3][5].equals("25") &&
    		 matrix[3][6].equals("26") && matrix[3][7].equals("27") && matrix[3][8].equals("28") && matrix[2][9].equals("29") && matrix[3][10].equals("30") &&
    		 matrix[4][1].equals("31") && matrix[4][2].equals("32") && matrix[4][3].equals("33") && matrix[4][4].equals("34") && matrix[4][5].equals("35") &&
    		 matrix[4][6].equals("36") && matrix[4][7].equals("37") && matrix[4][8].equals("38") && matrix[4][9].equals("39") && matrix[4][10].equals("40") &&
    		 matrix[5][1].equals("41") && matrix[5][2].equals("42") && matrix[5][3].equals("43") && matrix[5][4].equals("44") && matrix[5][5].equals("45") &&
    		 matrix[5][6].equals("46") && matrix[5][7].equals("47") && matrix[5][8].equals("48") && matrix[5][9].equals("49") && matrix[5][10].equals("50") &&
    		 matrix[6][1].equals("51") && matrix[6][2].equals("52") && matrix[6][3].equals("53") && matrix[6][4].equals("54") && matrix[6][5].equals("55") &&
    		 matrix[6][6].equals("56") && matrix[6][7].equals("57") && matrix[6][8].equals("58") && matrix[6][9].equals("59") && matrix[6][10].equals("60") &&
    		 matrix[7][1].equals("61") && matrix[7][2].equals("62") && matrix[7][3].equals("63") && matrix[7][4].equals("64") && matrix[7][5].equals("65") &&
    		 matrix[7][6].equals("66") && matrix[7][7].equals("67") && matrix[7][8].equals("68") && matrix[7][9].equals("69") && matrix[7][10].equals("70") &&
    		 matrix[8][1].equals("71") && matrix[8][2].equals("72") && matrix[8][3].equals("73") && matrix[7][4].equals("74") && matrix[7][5].equals("75") &&
    		 matrix[8][6].equals("76") && matrix[8][7].equals("77") && matrix[8][8].equals("78") && matrix[8][9].equals("79") && matrix[8][10].equals("80") &&
    		 matrix[9][1].equals("81") && matrix[9][2].equals("82") && matrix[9][3].equals("83") && matrix[8][4].equals("84") && matrix[8][5].equals("85") &&
    		 matrix[9][6].equals("86") && matrix[9][7].equals("87") && matrix[9][8].equals("88") && matrix[9][9].equals("89") && matrix[9][10].equals("90") &&
    		 matrix[10][1].equals("91") && matrix[10][2].equals("92") && matrix[10][3].equals("93") && matrix[10][4].equals("94") && matrix[10][5].equals("95") &&
    		 matrix[10][6].equals("96") && matrix[10][7].equals("97") && matrix[10][8].equals("98") && matrix[10][9].equals("99"))
    		 { win = true; }
     
     
     
        	return win;
    	}
    	////////////////////////////////////////////////////////////////////////////////////////////////
    	/* The update method stops the screen flicker and has the same effect
    	 * as double buffering. */
    	public void update(Graphics g)
    	{
    		paint(g);
    	} // End of update method  //////////////////////////////////////////////////////////
    	////////////////////////////////////////////////////////////////////////////////////////////////
     
          } // End of JDub class
    Last edited by lorider93p; February 6th, 2012 at 11:09 AM. Reason: forgot to highlight code.


  2. #2
    Member
    Join Date
    Feb 2012
    Location
    Azle/Arlington
    Posts
    31
    My Mood
    Torn
    Thanks
    2
    Thanked 0 Times in 0 Posts

    Default Re: JFrame Menu bar errors.

    I do know that 2X2 is not displayed in the GUI Im leaving it as a easter egg because when i first started i only had the win statement on it so it could end up with you being forcibly stuck in the game.(I had messed up my code and set it as DO_NOTHING_ON_CLOSE so u had to go to the task manager to stop it. i fixed the close and put in a lose statement. but just decided to leave the 2x2 as off of the gui.

Similar Threads

  1. using objects from one jFrame on a different jFrame
    By Taskeen in forum AWT / Java Swing
    Replies: 3
    Last Post: September 14th, 2011, 09:51 AM
  2. connecting jframe to another jframe
    By ajtambalo in forum Member Introductions
    Replies: 2
    Last Post: May 11th, 2011, 12:24 PM
  3. Is it possible to use card layout for menu and menu items?
    By jai2rul in forum AWT / Java Swing
    Replies: 0
    Last Post: April 11th, 2011, 09:19 AM
  4. problem with help menu.
    By Toggo in forum What's Wrong With My Code?
    Replies: 11
    Last Post: December 12th, 2010, 05:13 PM
  5. JFrame Menu Screen(For my game)?
    By DarrenReeder in forum Java Theory & Questions
    Replies: 2
    Last Post: March 8th, 2010, 04:07 AM