Working with Layout Managers. Notes 1. In part 2, note that the Gam.pdf

Working with Layout Managers. Notes: 1. In part 2, note that the Game class inherits from
JPanel. Therefore, the panel you are asked to add to the center of the content pane is the "game"
object. 2. In part 4, at the end of the function, call validate(). This is not mentioned in the book,
but it is mentioned in the framework comments.
import javax.swing.*;
import java.awt.*;
import java.awt.event.*;
public class Game extends JPanel
{
private JButton [][] squares;
private TilePuzzle game;
public Game( int newSide )
{
game = new TilePuzzle( newSide );
setUpGameGUI( );
}
public void setUpGame( int newSide )
{
game.setUpGame( newSide );
setUpGameGUI( );
}
public void setUpGameGUI( )
{
removeAll( ); // remove all components
setLayout( new GridLayout( game.getSide( ),
game.getSide( ) ) );
squares = new JButton[game.getSide( )][game.getSide( )];
ButtonHandler bh = new ButtonHandler( );
// for each button: generate button label,
// instantiate button, add to container,
// and register listener
for ( int i = 0; i < game.getSide( ); i++ )
{
for ( int j = 0; j < game.getSide( ); j++ )
{

squares[i][j] = new JButton( game.getTiles( )[i][j] );
add( squares[i][j] );
squares[i][j].addActionListener( bh );
}
}
setSize( 300, 300 );
setVisible( true );
}
private void update( int row, int col )
{
for ( int i = 0; i < game.getSide( ); i++ )
{
for ( int j = 0; j < game.getSide( ); j++ )
{
squares[i][j].setText( game.getTiles( )[i][j] );
}
}
if ( game.won( ) )
{
JOptionPane.showMessageDialog( Game.this,
"Congratulations! You won! Setting up new game" );
// int sideOfPuzzle = 3 + (int) ( 4 * Math.random( ) );
// setUpGameGUI( );
}
}
private class ButtonHandler implements ActionListener
{
public void actionPerformed( ActionEvent ae )
{
for( int i = 0; i < game.getSide( ); i++ )
{
for( int j = 0; j < game.getSide( ); j++ )
{
if ( ae.getSource( ) == squares[i][j] )
{
if ( game.tryToPlay( i, j ) )

update( i, j );
return;
} // end if
} // end inner for loop
} // outer for loop
} // end actionPerformed method
} // end ButtonHandler class
} // end Game class
import java.awt.*;
public class NestedLayoutPractice extends JFrame
{
private Container contents;
private Game game;
private BorderLayout bl;
private JLabel bottom;
// ***** Task 1: declare a JPanel named top
// also declare three JButton instance variables
// that will be added to the JPanel top
// these buttons will determine the grid size of the game:
// 3-by-3, 4-by-4, or 5-by-5
// Part 1 student code starts here:
// Part 1 student code ends here.
public NestedLayoutPractice()
{
super("Practicing layout managers");
contents = getContentPane();
// ***** Task 2:
// instantiate the BorderLayout manager bl
// set the layout manager of the content pane contents to bl:
game = new Game(3); // instantiating the GamePanel object
// add panel (game) to the center of the content pane
bottom = new JLabel("Have fun playing this Tile Puzzle game",

SwingConstants.CENTER);
// ***** Task 3:
// instantiate the JPanel component named top
// set the layout of top to a 1-by-3 grid
// instantiate the JButtons that determine the grid size
// add the buttons to JPanel top
// add JPanel top to the content pane as its north component
// ***** Task 5:
// Note: search for and complete Task 4 before performing this task
// declare and instantiate an ActionListener
// register the listener on the 3 buttons
// that you declared in Task 1
contents.add(bottom, BorderLayout.SOUTH);
setSize(325, 325);
setVisible(true);
}
// ***** Task 4:
// create a private inner class that implements ActionListener
// your method should identify which of the 3 buttons
// was the source of the event
// depending on which button was pressed,
// call the setUpGame method of the Game class
// with arguments 3, 4, or 5
// the API of that method is:
// public void setUpGame(int nSides)
// At the end of the method call validate()
public static void main(String[] args)
{
NestedLayoutPractice nl = new NestedLayoutPractice();
nl.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

}
}
public class TilePuzzle
{
private int side; // grid size for game 1
private String[][] tiles;
private int emptyRow;
private int emptyCol;
public TilePuzzle( int newSide )
{
setUpGame( newSide );
}
public void setUpGame( int newSide )
{
if ( side > 0 )
side = newSide;
else
side = 3;
side = newSide;
tiles = new String[side][side];
emptyRow = side - 1;
emptyCol = side - 1;
for ( int i = 0; i < side; i++ )
{
for ( int j = 0; j < side; j++ )
{
tiles[i][j] = String.valueOf( ( side * side )
- ( side * i + j + 1 ) );
}
}
// set empty tile to blank
tiles[side - 1][side - 1] = "";
}
public int getSide( )
{
return side;

}
/*
public int getEmptyRow( )
{
return emptyRow;
}
public int getEmptyCol( )
{
return emptyCol;
}
*/
public String[][] getTiles( )
{
return tiles;
}
public boolean tryToPlay( int row, int col )
{
if ( possibleToPlay( row, col ) )
{
// play: switch empty String and tile label at row, col
tiles[emptyRow][emptyCol] = tiles[row][col];
tiles[row][col] = "";
emptyRow = row;
emptyCol = col;
return true;
}
else
return false;
}
public boolean possibleToPlay( int row, int col )
{
if ( ( col == emptyCol && Math.abs( row - emptyRow ) == 1 )
|| ( row == emptyRow && Math.abs( col - emptyCol ) == 1 ) )
return true;
else
return false;

}
public boolean won( )
{
for ( int i = 0; i < side ; i++ )
{
for ( int j = 0; j < side; j++ )
{
if ( !( tiles[i][j].equals(
String.valueOf( i * side + j + 1 ) ) )
&& ( i != side - 1 || j != side - 1 ) )
return false;
}
}
return true;
}
}
Programming Activity 12-2 Guidance
==================================
Overview
--------
There are 5 parts.
Make sure you complete the parts in numerical order.
Notice that part 4 occurs in the code after part 5.
As stated in the part 5 comments, you should complete part 4 before
part 5 because part 5 has a step that says:
"// declare and instantiate an ActionListener"
This ActionListener must be an object of the private inner button handler class
that you write in part 4.
The 5 parts of 12-2 each have helpful comments.
The comments will guide you about what code to write.
Button instantiation
--------------------
Suppose you define a button as follows:
JButton three;
To instantiate it with its label set to "3 x 3", you would write:
three = new JButton("3 x 3");

Part 2
------
Note that the Game class inherits from JPanel.
Therefore, the panel you are asked to add to the center of the
content pane is the "game" object.
Part 4 button handler
---------------------
You have to create a private inner class to handle events from any
of the three game setup buttons.
This course is cumulative. Each new chapter builds on previous chapters.
Week 4 had a video called Java GUI Button Components.
The code for that video was supplied in a folder in week 4.
Here is a section of the code shown in that video:
private class CommandHandler implements ActionListener
{
public void actionPerformed(ActionEvent e)
{
Object source = e.getSource();
if (source == btnDisplayTrees)
{
displayTrees();
return;
}
if (source == btnDisplayWater)
{
displayWater();
return;
}
if (source == btnPackWindow)
{
packWindow();
return;
}
if (source == btnReset)
{
reset();

return;
}
}
etc.
The above code shows a private inner class named CommandHandler that
handles button events. You can name your button handler whatever you want,
such as ButtonHandler, but you must use the same name in part 5 after the comment:
In the above video example, there is an if test for each button event.
Each of the if blocks does something and then returns.
In your button handler, you also have to do a certain thing for each button
as specified in the comments. However, you cannot then simply return because
validate() must be called at the end of the function--no matter which button
was clicked. There are 2 simple ways to achieve this:
1) Use nested if/else's followed by the validate() call, or
2) Call validate() after each button's processing and then return
from each one as in the video example.
Part 4 setUpGame()
------------------
The part 4 comments include:
To call a function we need an object of its class.
Does our framework code have an object for us of type Game?
Looking near the beginning of the NestedLayoutPractice class
that we are in, you will see the following declaration:
private Game game;
So, game is an object reference of type Game that we can use.
Your framework starting code already includes the following line
of code in part 2:
This is where the game object is actually created. It is passed
a value of 3 in the constructor call. This will cause the game

to be created with 3 rows by 3 columns of numbered squares.
Now back to your part 4 handler comments. The comments say to change
the game setup as instructed based on which button was clicked.
If you look at the example user interface you will see that there
are 3 buttons to change the game to 3 x 3, or 4 x 4, or 5 x 5 squares.
You should have already declared these buttons in part 1 and created
them in part 3 as instructed.
In part 4, your event handler function must handle when each of the
buttons is clicked. If, for exaample, the 4 x 4 button is clicked, then
you should have the following line of code for that event:
game.setUpGame(4);
Don't overthink this. It is a simple function call using the game
object, its setUpGame() method, and a literal parameter of 4.
At the end of the function, call
Solution
NestedLayoutPractice.java
import java.awt.*;
public class NestedLayoutPractice extends JFrame
{
private Container contents;
private Game game;
private BorderLayout bl;
private JLabel bottom;
private JPanel top;
private JButton btnDisplayTrees;
private JButton btnDisplayWater;
private JButton btnPackWindow;
// ***** Task 1: declare a JPanel named top
// also declare three JButton instance variables
// that will be added to the JPanel top
// these buttons will determine the grid size of the game:

// 3-by-3, 4-by-4, or 5-by-5
public NestedLayoutPractice(){
super("Practicing layout managers");
contents = getContentPane();
// ***** Task 2:
// instantiate the BorderLayout manager bl
bl = new BorderLayout();
// set the layout manager of the content pane contents to bl:-------
bl.layoutContainer(contents);
// add panel (game) to the center of the content pane
contents.add(game);
bottom = new JLabel("Have fun playing this Tile Puzzle game",
SwingConstants.CENTER);
// ***** Task 3:
// instantiate the JPanel component named top
top = new JPanel();
top.setLayout(new GridLayout(1, 3, 5, 5));
// set the layout of top to a 1-by-3 grid--------
// instantiate the JButtons that determine the grid size
btnDisplayTrees = new JButton("3 x 3");
btnDisplayWater = new JButton("4 x 4");
btnPackWindow = new JButton("5 x 5");
// add the buttons to JPanel top
top.add(btnDisplayTrees);
top.add(btnDisplayWater);
top.add(btnPackWindow);
// add JPanel top to the content pane as its north component
top.add(contents,BorderLayout.NORTH);

// ***** Task 5:
// Note: search for and complete Task 4 before performing this task
CommandHandler ch = new CommandHandler();
// register the listener on the 3 buttons
btnDisplayTrees.addActionListener(ch);
btnDisplayWater.addActionListener(ch);
btnPackWindow.addActionListener(ch);
// that you declared in Task 1
contents.add(bottom, BorderLayout.SOUTH);
setSize(325, 325);
setVisible(true);
}
// ***** Task 4:
// create a private inner class that implements ActionListener
// your method should identify which of the 3 buttons
// was the source of the event
// At the end of the method call validate()
private class CommandHandler implements ActionListener{
public void actionPerformed(ActionEvent e){
Object source = e.getSource();
if (source == btnDisplayTrees){
//displayTrees();
game.setUpGame(3);
game.validate();
return;

}
if (source == btnDisplayWater){
// displayWater();
game.setUpGame(4);
game.validate();
return;
}
if (source == btnPackWindow){
//packWindow();
game.setUpGame(5);
game.validate();
return;
}
// if (source == btnReset){
// reset();
// return;
// }
}
}
public static void main(String[] args){
NestedLayoutPractice nl = new NestedLayoutPractice();
nl.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
}
}

Working with Layout Managers. Notes 1. In part 2, note that the Gam.pdf

Recommended

Recommended

More Related Content

Similar to Working with Layout Managers. Notes 1. In part 2, note that the Gam.pdf

Similar to Working with Layout Managers. Notes 1. In part 2, note that the Gam.pdf (20)

More from udit652068

More from udit652068 (20)

Recently uploaded

Recently uploaded (20)

Working with Layout Managers. Notes 1. In part 2, note that the Gam.pdf