Problems with Graphics

Question

Hello,
My instructor is wanting me to use the MVC paradigm. He was telling me that I should be able to put my deal() method in my Model.java. How can I access paintComponent() from the Model.java? If I put the deal() method in the View.java, then it is fine. I have been racking my brains all day long with this. Can anyone please take a look and let me know what I am doing wrong?
Thanks,
E
//======================================
//======================================
//NewSolitaireController.java
import java.awt.*;
import java.awt.event.*;
import javax.swing.*;
import javax.swing.event.*;
public class NewSolitaireController extends JApplet
     //==========================================applet constructor
     public NewSolitaireController()
         this.setContentPane(new NewSolitaireView());
    }//===========================================end constructor
    //=================================================method main
    public static void main(String[] args)
        JFrame window = new JFrame();
        window.setTitle("Solitaire by EK");
        window.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        window.setContentPane(new NewSolitaireView());
        window.pack();
        //window.setResizable(false);
            window.show();
    }//======================================================end main
}//=========================================endclass SolitaireProject
//================================================
//================================================
//NewSolitaireView.java
import java.awt.*;
import java.awt.event.*;
import javax.swing.*;
import javax.swing.event.*;
//import java.util.*;
public class NewSolitaireView extends JPanel //implements MouseListener, MouseMotionListener
     //================================================================instance variables
     private GraphicsPanel boardDisplay_;
     private NewSolitaireModel     gameLogic_ = new NewSolitaireModel();
     private boolean gameOver_ = false;
     int clubPosition = 0;
     int diamondPosition = 0;
     int heartPosition = 0;
     int spadePosition = 0;
     private final int ACES_DIST_BETWEEN_CARDS = 87;
     private final int ACES_DIST_FROM_LEFT = 350;
     private final int ACES_DIST_FROM_TOP = 50;
     private final int ACES_MAX = 611;
     private final int PLAYCARDS_DIST_FROM_LEFT = 175;     
     private final int PLAYCARDS_DIST_FROM_TOP = 175;
     private final int PLAYCARDS_DIST_BETWEEN_COLS = 87;
     private final int PLAYCARDS_DIST_BETWEEN_ROWS_BACKS = 5;
     private final int PLAYCARDS_DIST_BETWEEN_ROWS_FACES = 30;
     private final int PLAYCARDS_MAX = 697;
     private final int PILE_DIST_FROM_LEFT = 50;
     private final int PILE_DIST_FROM_TOP = 50;
     private final int SHOWCARD_DIST_FROM_LEFT = 50;
     private final int SHOWCARD_DIST_FROM_TOP = 175;
     private static final int CARD_WIDTH = 77;                              
     private static final int CARD_HEIGHT = 110;
     private final int CARDS_PER_SUIT = 13;                                   //Suit limit
     private final int CARDS_PER_DECK = 52;                                   //Deck limit
     private int initialX = 0;                                                       //x coord - set from drag
     private int initialY = 0;                                                       //y coord - set from drag
     private int _dragFromX = 0;                                                  //Displacement inside image of mouse press
     private int _dragFromY = 0;                                                  //Displacement inside image of mouse press
     private Card[] _club = new Card[CARDS_PER_SUIT];               //Creates an array of clubs
     private Card[] _diamond = new Card[CARDS_PER_SUIT];          //Creates an array of diamonds
     private Card[] _heart = new Card[CARDS_PER_SUIT];               //Creates an array of hearts
     private Card[] _spade = new Card[CARDS_PER_SUIT];               //Creates an array of spades
     private Card[] _deckFront = new Card[CARDS_PER_DECK];          //Creates an array of cardfronts
     private Card[] _deckBack = new Card[CARDS_PER_DECK];          //Creates an array of cardbacks
     private Card _currentCard = null;                                        //Current draggable card
     //====================================================NewSolitaireView constructor
     public NewSolitaireView()
          String suitC = "c";                    //This is the character in the club image names that will be loaded                    
          String suitD = "d";                    //This is the character in the diamond image names that will be loaded
          String suitH = "h";                    //This is the character in the heart image names that will be loaded
          String suitS = "s";                    //This is the character in the spade image names that will be loaded
          String faces = "a23456789tjqk";     //These are the characters in the face image names that will be loaded
          int crdFrontPosition = 0;
          //=========================================================Read in the clubs
            for(int clubCounter = 0; clubCounter < suitC.length(); clubCounter ++)                    
               for(int face = 0; face < faces.length(); face ++)                    
                    ImageIcon imgFront = new ImageIcon(faces.charAt(face) + suitC.charAt(clubCounter) + ".gif");
                    Image image = imgFront.getImage();
                    Image scaledImage = image.getScaledInstance(CARD_WIDTH, CARD_HEIGHT, Image.SCALE_FAST);
                    imgFront.setImage(scaledImage);
                    _club[clubPosition ++] = new Card(imgFront, initialX ++, initialY ++);
                    _deckFront[crdFrontPosition ++] = new Card(imgFront, initialX ++, initialY ++);     
          //=======================================================Read in the diamonds
            for(int diamondCounter = 0; diamondCounter < suitD.length(); diamondCounter ++)                    
               for(int face = 0; face < faces.length(); face ++)                    
                    ImageIcon imgFront = new ImageIcon(faces.charAt(face) + suitD.charAt(diamondCounter) + ".gif");
                    Image image = imgFront.getImage();
                    Image scaledImage = image.getScaledInstance(CARD_WIDTH, CARD_HEIGHT, Image.SCALE_FAST);
                    imgFront.setImage(scaledImage);
                    _diamond[diamondPosition ++] = new Card (imgFront, initialX ++, initialY ++);
                    _deckFront[crdFrontPosition ++] = new Card (imgFront, initialX ++, initialY ++);
          //=======================================================Read in the hearts
            for(int heartCounter = 0; heartCounter < suitH.length(); heartCounter ++)                    
               for(int face = 0; face < faces.length(); face ++)                    
                    ImageIcon imgFront = new ImageIcon(faces.charAt(face) + suitH.charAt(heartCounter) + ".gif");
                    Image image = imgFront.getImage();
                    Image scaledImage = image.getScaledInstance(CARD_WIDTH, CARD_HEIGHT, Image.SCALE_FAST);
                    imgFront.setImage(scaledImage);
                    _heart[heartPosition ++] = new Card (imgFront, initialX ++, initialY ++);
                    _deckFront[crdFrontPosition ++] = new Card (imgFront, initialX ++, initialY ++);
          //==========================================================Read in the spades
            for(int spadeCounter = 0; spadeCounter < suitS.length(); spadeCounter ++)                    
               for(int face = 0; face < faces.length(); face ++)                    
                    ImageIcon imgFront = new ImageIcon(faces.charAt(face) + suitS.charAt(spadeCounter) + ".gif");
                    Image image = imgFront.getImage();
                    Image scaledImage = image.getScaledInstance(CARD_WIDTH, CARD_HEIGHT, Image.SCALE_FAST);
                    imgFront.setImage(scaledImage);
                    _spade[spadePosition ++] = new Card (imgFront, initialX ++, initialY ++);
                    _deckFront[crdFrontPosition ++] = new Card (imgFront, initialX ++, initialY ++);
          int crdBackPosition = 0;
          //Load the card back image into an array of 52 cardbacks and resize each cardback
          for(int crdBack = 0; crdBack < CARDS_PER_DECK; crdBack ++)
               ImageIcon imgBack = new ImageIcon("b.gif");
               Image image = imgBack.getImage();
               Image scaledImage = image.getScaledInstance(CARD_WIDTH, CARD_HEIGHT, Image.SCALE_FAST);
               imgBack.setImage(scaledImage);
               _deckBack[crdBackPosition ++]     = new Card (imgBack, initialX ++, initialY ++);
          //============================================================Create  buttons
      JButton newGameButton = new JButton("New Game");
          JButton exitButton = new JButton("Exit");
          //========================================================Create controlPanel
      JPanel controlPanel = new JPanel();
          controlPanel.add(newGameButton);
          controlPanel.add(exitButton);
          //=======================================================Create GraphicsPanel
          boardDisplay_ = new GraphicsPanel();
          //======================================Set the layout and add the components
          this.add(controlPanel);
          this.add(boardDisplay_);
          //===================================================Add listeners to buttons
          exitButton.addActionListener(new ExitAction());     
          newGameButton.addActionListener(new NewGameAction());                    
     }//==============================================end NewSolitaireView constructor
     class GraphicsPanel extends JPanel //implements MouseListener
          //===================================class GraphicsPanel constructor
          public GraphicsPanel()
               //Initialize graphics
               this.setPreferredSize(new Dimension(850, 500));
               this.setBackground(Color.white);     
           //this.addMouseListener(this);     
          }//=======================================end GraphicsPanel constructor
          //=================================================method paintComponent     
          public void paintComponent(Graphics g)
               super.paintComponent(g);                                   //Required for background.
               //update(g); 
               g.drawRect(PILE_DIST_FROM_LEFT, PILE_DIST_FROM_TOP, CARD_WIDTH, CARD_HEIGHT);
               g.drawRect(SHOWCARD_DIST_FROM_LEFT, SHOWCARD_DIST_FROM_TOP, CARD_WIDTH, CARD_HEIGHT);
               for(int position1 = ACES_DIST_FROM_LEFT; position1 <= ACES_MAX; position1 += ACES_DIST_BETWEEN_CARDS)
                    g.drawRect(position1, ACES_DIST_FROM_TOP, CARD_WIDTH, CARD_HEIGHT);
               for(int position2 = PLAYCARDS_DIST_FROM_LEFT; position2 <= PLAYCARDS_MAX; position2 += PLAYCARDS_DIST_BETWEEN_COLS)
                    g.drawRect(position2, PLAYCARDS_DIST_FROM_TOP, CARD_WIDTH, CARD_HEIGHT);          
               //This is to test the card images, but they are not working
               for(int k = 0; k < 51; k ++)
                    Card c = _deckFront[k];
                    c.image.paintIcon(this, g, c.x, c.y);
          }//=====================================================end paintComponent method
     }//========================================================end class GraphicsPanel
     //======================================================================class Card
     class Card
          javax.swing.ImageIcon image;
          int x;
          int y;
          public Card(javax.swing.ImageIcon image, int x, int y)
               this.image = image;
               this.x = x;
               this.y = y;
     }//=================================================================end class Card
     //===========================================================inner class ExitAction
     class ExitAction implements ActionListener
          public void actionPerformed(ActionEvent e)
               System.exit(0);
          }//==========================================================end actionPerformed
     }//=======================================================end inner class ExitAction
     //=========================================================inner class NewGameAction
     class NewGameAction implements ActionListener
          public void actionPerformed(ActionEvent e)
               gameLogic_.shuffle();
               //gameLogic_.deal(Graphics g);
               repaint();
          }//===========================================================end actionPerformed
     }//=====================================================end inner class NewGameAction
}//===========================================================end class NewSolitaireView
//==========================================
//==========================================
//NewSolitaireModel.java
import java.awt.*;
import java.awt.event.*;
import javax.swing.*;
import javax.swing.event.*;
import java.util.*;
//import javax.swing.ImageIcon.*;
//import java.awt.Image.*;
//import java.awt.Graphics.*;
class NewSolitaireModel
     private NewSolitaireView     gameGUI_ = new NewSolitaireView();
     private final int ACES_DIST_BETWEEN_CARDS = 87;
     private final int ACES_DIST_FROM_LEFT = 350;
     private final int ACES_DIST_FROM_TOP = 50;
     private final int ACES_MAX = 611;
     private final int PLAYCARDS_DIST_FROM_LEFT = 175;     
     private final int PLAYCARDS_DIST_FROM_TOP = 175;
     private final int PLAYCARDS_DIST_BETWEEN_COLS = 87;
     private final int PLAYCARDS_DIST_BETWEEN_ROWS_BACKS = 5;
     private final int PLAYCARDS_DIST_BETWEEN_ROWS_FACES = 30;
     private final int PLAYCARDS_MAX = 697;
     private final int PILE_DIST_FROM_LEFT = 50;
     private final int PILE_DIST_FROM_TOP = 50;
     private final int SHOWCARD_DIST_FROM_LEFT = 50;
     private final int SHOWCARD_DIST_FROM_TOP = 175;     
     private final int FIRST_CARD_AFTER_DEAL = 29;
     private final int CARDS_PER_DECK = 52;                                   //Deck limit
     private Card[] _deckFront = new Card[CARDS_PER_DECK];          //Creates an array of cardfronts
     private Card[] _deckBack = new Card[CARDS_PER_DECK];          //Creates an array of cardbacks
     //===============================================NewSolitaireModel constructor
     public NewSolitaireModel()
          shuffle();
          //repaint();
     }//==============================================end NewSolitaireModel constructor
     public void deal(Graphics g)
          //================================================Deal the cards for game play
          //=========This is done initially and everytime the new game button is pressed
          //===========================================Uses paintComponent for paintIcon
          //========================Deal the first row of cards (top 7), first 1 face up
          int crd1 = 1;
          int col1 = PLAYCARDS_DIST_FROM_LEFT;
          int fromTop1 = PLAYCARDS_DIST_FROM_TOP;
          Card df = _deckFront[crd1];
          ImageIcon icon;
          //icon.paintIcon(df, g, col1, fromTop1);
          //=========================================================next 6 face down
          crd1 = 2;
          col1 = col1 + PLAYCARDS_DIST_BETWEEN_COLS;
          for(int count = 0; count < 6; count ++)
               Card db = _deckBack[crd1];
               //image.paintIcon(db, g, col1, fromTop1);
               crd1 ++;
               col1 += PLAYCARDS_DIST_BETWEEN_COLS;
          //====================Deal the second row of cards (next 6), first 1 face up
          int crd2 = 8;
          int col2 = 262;
          int fromTop2 = fromTop1 + PLAYCARDS_DIST_BETWEEN_ROWS_BACKS;
          df = _deckFront[crd2];
          //df.image.paintIcon(this, g, col2, fromTop2);
          //==========================================================next 5 face down
          crd2 = 9;
          col2 = col2 + PLAYCARDS_DIST_BETWEEN_COLS;
          for(int count = 0; count < 5; count ++)
               Card db = _deckBack[crd2];
               //db.image.paintIcon(this, g, col2, fromTop2);
               crd2 ++;
               col2 += PLAYCARDS_DIST_BETWEEN_COLS;
          //======================Deal the third row of cards (next 5), first 1 face up
          int crd3 = 14;
          int col3 = 349;
          int fromTop3 = fromTop2 + PLAYCARDS_DIST_BETWEEN_ROWS_BACKS;
          df = _deckFront[crd3];
          //df.image.paintIcon(this, g, col3, fromTop3);
          //==========================================================next 4 face down
          crd3 = 15;
          col3 = col3 + PLAYCARDS_DIST_BETWEEN_COLS;
          for(int count = 0; count < 4; count ++)
               Card db = _deckBack[crd3];
               //db.image.paintIcon(this, g, col3, fromTop3);
               crd3 ++;
               col3 += PLAYCARDS_DIST_BETWEEN_COLS;
          //===================Deal the fourth row of cards (next 4), first 1 face up 
          int crd4 = 19;
          int col4 = 436;
          int fromTop4 = fromTop3 + PLAYCARDS_DIST_BETWEEN_ROWS_BACKS;
          df = _deckFront[crd4];
          //df.image.paintIcon(this, g, col4, fromTop4);
          //========================================================next 3 face down
          crd4 = 20;
          col4 = col4 + PLAYCARDS_DIST_BETWEEN_COLS;
          for(int count = 0; count < 3; count ++)
               Card db = _deckBack[crd4];
               //db.image.paintIcon(this, g, col4, fromTop4);
               crd4 ++;
               col4 += PLAYCARDS_DIST_BETWEEN_COLS;
          //====================Deal the fifth row of cards (next 3), first 1 face up
          int crd5 = 23;
          int col5 = 523;
          int fromTop5 = fromTop4 + PLAYCARDS_DIST_BETWEEN_ROWS_BACKS;
          df = _deckFront[crd5];
          //df.image.paintIcon(this, g, col5, fromTop5);
          //==========================================================next 2 face down
          crd5 = 24;
          col5 = col5 + PLAYCARDS_DIST_BETWEEN_COLS;
          for(int count = 0; count < 2; count ++)
               Card db = _deckBack[crd5];
               //db.image.paintIcon(this, g, col5, fromTop5);
               crd5 ++;
               col5 += PLAYCARDS_DIST_BETWEEN_COLS;
          //====================Deal the sixth row of cards (next 2), first 1 face up
          int crd6 = 26;
          int col6 = 610;
          int fromTop6 = fromTop5 + PLAYCARDS_DIST_BETWEEN_ROWS_BACKS;
          df = _deckFront[crd6];
          //df.image.paintIcon(this, g, col6, fromTop6);
          //==================================================second 1 face down
          crd6 = 27;
          col6 = col6 + PLAYCARDS_DIST_BETWEEN_COLS;
          for(int count = 0; count < 1; count ++)
               Card db = _deckBack[crd6];
               //db.image.paintIcon(this, g, col6, fromTop6);
               crd6 ++;
               col6 += PLAYCARDS_DIST_BETWEEN_COLS;
          //====================Deal the seventh row of cards (next 1) face up           
          int crd7 = 28;
          int col7 = 697;
          int fromTop7 = fromTop6 + PLAYCARDS_DIST_BETWEEN_ROWS_BACKS;
          df = _deckFront[crd7];
          //df.image.paintIcon(this, g, col7, fromTop7);
          //=============Put the undealt cards in the upper left stack to use for game play
          for(int playCard = FIRST_CARD_AFTER_DEAL; playCard < CARDS_PER_DECK; playCard ++)
               Card db = _deckBack[playCard];
               //db.image.paintIcon(this, g, PILE_DIST_FROM_LEFT, PILE_DIST_FROM_TOP);
     }//============================================================end method deal
     //=============================================================method displayImage
     private void displayImage(int k)
          //Graphics g = getGraphics();
     //=================================================================method shuffle
     public void shuffle()
          Random rgen = new Random(); // Random number generator
          // Shuffle by exchanging each element randomly
          for (int i = 0; i < CARDS_PER_DECK; i ++)
               int randomPosition = rgen.nextInt(CARDS_PER_DECK);
               Card temp = _deckFront;
               _deckFront[i] = _deckFront[randomPosition];
               _deckFront[randomPosition] = temp;
     }//===============================================================end method shuffle               
}//=============================================end class NewSolitaireModel

Answer 1

I would have deal() in the model. I think that's where it belongs, because deal() should probably be distributing the cards in some random manner into some container (abstractly speaking). The view can then get the cards from that container when it's notified that the deal() happened...
public class DeckModel {
   private List listeners = new ArrayList();
   private List available = new ArrayList();
   private List played = new ArrayList();
   public void deal() {
      // take all cards, shuffle them, put them into "available"
      fireCardsShuffled();// listeners can then get from available and display them however
   public void play(Card c) {
      played.add(c);
      available.remove(c);
      fireCardsPlayed(c);
   public void fireCardsPlayed(Card c) {
      // notifiy listeners
      for(int x = 0; x < listeners.size(); x++) {
         ((DeckListener)listeners.get(x)).cardPlayed(new DeckEvent(this, c));
   public void fireCardsShuffled() {
      // notifiy listeners
      for(int x = 0; x < listeners.size(); x++) {
         ((DeckListener)listeners.get(x)).cardsShuffled(new DeckEvent(this, null));
   public void addDeckListener(DeckListener dl) {
       listeners.add(dl); // maybe have a remove method.
// deck listener, implemented by the view.
public interface DeckListener {
   public void cardsShuffled(DeckEvent de);
   public void cardPlayed(DeckEvent de);
}Something along those lines.