JTree / DataModel Confusion

[D R Wilkinson]

Hello,

I am a little confused by the JTree, JSpinner, their models and their relationship to the applications data model that stores the data it/they display.

When using JTables I make my data model in the manner described below and it is relatively easy to plug that into the JTable.

Do I do the same with a JTree? If so, how?

My data model consists of :

Class : BookManager : Provides methods to manage the contents of an ArrayList that stores Book objects - add, remove, find, get, etc.
Class : Book : Provides methods to manage the contents of an ArrayList that stores Chapter objects - add, remove, find, get, etc.
Class : Chapter : Provides methods to manage the contents of an ArrayList that stores Scene objects - add, remove, find, get, etc.
Class : Scene : Provides getter/setter methods for two String fields - shortDescription and sceneBody.

I can manipulate and edit the data model using menuitems and display the data model in textual form - using the following menu commands..,

add book
delete book
next book
previous book

add chapter
delete chapter
next chapter
previous chapter

add scene
delete scene
next scene
previous scene

I want to use JMenuItems, a JSpinner and JTree in combination as both view and controller of the data model.

I know how to use JMenuItem's to add/remove Books but I don't know how to display these Book titles in the JSpinner.
I want to use a JSpinner to select the Book to display in the JTree.
I want to use a popup menu on the root node Book to add Chapters to the Book in the JTree.
I want to use a popup menu on Chapter nodes to add Scenes to the selected Chapter or delete the selected Chapter ( and all of its Books ).
I want to use a popup menu on Scene nodes to delete the selected Scene.

I am really confused by the JSpinner and JTree models that seem to sit between the JSpinner, JTree and my data model - I don't understand how I connect my data model to the JSpinner and JTree via their models.

Can anyone give me a little help.

Thanks
[ October 25, 2005: Message edited by: D R Wilkinson ]

[Craig Wood]

Have you looked at the How to Use Trees page in the tutorial? It has a lot of information about working with JTrees. If that doesn't help one of us might be able to offer a suggestion if you can tell more about your Project, Chapter and Scene map. Or give an idea of what you put into a JTable with this.

[tito bayuadji]

IMHO, in JTree the model at least 'tree like', using tree node or you can have your own tree. so it doesn't exactly the same as table model.

just my 2 cents

[D R Wilkinson]

Thanks for replying. I have included a simplified example of what I am trying to understand and achieve.

In the following example, I can manipulate the data in my data model using the menu items ( I know the data model manipulation is not fault perfect - it is just a quick demo of my problem ).

I want to understand how I can use the JSpinner to control the selection of any given Book within the books ArrayList in BookManager.

When a given Book is selected, I want the JTree to display that Books data ( ie Chapters and Scenes ).

When the root Book icon is selected and right clicked, I want the program to add a chapter icon to the tree that represents the Chapter object that is added to the Books data model - I also want to understand how this chapter icon in the JTree is linked to the Chapter object in the Book data model.

Similar functionality for the chapter icons - basically using the JTree to add, delete, select, etc the objects in the Book data model - instead of using the JMenuItems.

Maybe I am a bit stupid but I do not understand how I link the JSpinner and JTree to my data model and use them to manipulate / display the data models state.

From "How To Use Tree's" - Thus, if the TreeNode interface isn't suitable for your tree model, feel free to devise your own representation for tree nodes. For example, if you have a pre-existing hierarchical data structure, you don't need to duplicate it or force it into the TreeNode mold. You just need to implement your tree model so that it uses the information in the existing data structure.

I am aware that I need to implement the TreeModel and SpinnerModel interfaces somewhere ( possibly in my BookManager class ) but I am not sure if this is correct and if so, then how. I also guess that Listeners are involved in some way but I am unclear as to how and where.

I do not understand how, for example, clicking on a given chapter icon in the JTree selects the associated Chapter object in my Book data model.

Any help would be very welcome. Code follows...

 
import java.awt.*;
import java.awt.event.*;
import javax.swing.*;
 
/**
 * Write a description of class TreeModel here.
 * 
 * @author (your name) 
 * @version (a version number or a date)
 */
public class TreeModel extends JFrame {
 
    // ******************************************** //
    // Fields ************************************* //
    
    private JPanel mainPanel;
    private JPanel topPanel;
    private JPanel bottomPanel;
    private JPanel treePanel;
    private JPanel textPanel;
    private JPanel bookPanel;
    private JScrollPane treeScroll;
    private JScrollPane textScroll;
    private JTree tree;
    private JTextArea textArea;
    private JSpinner bookList;
    private BookManager bookManager;
    private JMenuBar menuBar;
    private JMenu menu;
    private JMenuItem addBook;
    private JMenuItem deleteBook;
    private JMenuItem nextBook;
    private JMenuItem previousBook;
    private JMenuItem addChapter;
    private JMenuItem deleteChapter;
    private JMenuItem nextChapter;
    private JMenuItem previousChapter;
    private JMenuItem addScene;
    private JMenuItem deleteScene;
    private JMenuItem nextScene;
    private JMenuItem previousScene;
 
    // End of fields ****************************** //
    // ******************************************** //
    // Constructors ******************************* //
 
    /**
     * Constructor for objects of class TreeModel
     */
    public TreeModel() {
        
        bookManager = new BookManager();
        
        menuBar = new JMenuBar();
        
        menu = new JMenu( "Controls" );
        
        addBook = new JMenuItem( "Add Book" );
        addBook.addActionListener( new ActionListener() {
            
            public void actionPerformed( ActionEvent actionEvent ) {
                
                System.out.println( "addBook JMenuItem actionPerformed()" );
                System.out.println( "...Add new book to books in BookManager." );
                
                bookManager.addNewBook();
                
                bookManager.displayBookModel();
                
            }
            
        });
        deleteBook = new JMenuItem( "Delete Book" );
        deleteBook.addActionListener( new ActionListener() {
            
            public void actionPerformed( ActionEvent actionEvent ) {
                
                System.out.println( "deleteBook JMenuItem actionPerformed()" );
                System.out.println( "...Delete isFocus Book from books in BookManager." );
                
                bookManager.deleteBook();
                
                bookManager.displayBookModel();
                
            }
            
        });
        nextBook = new JMenuItem( "Select Next Book" );
        nextBook.addActionListener( new ActionListener() {
            
            public void actionPerformed( ActionEvent actionEvent ) {
                
                System.out.println( "nextBook JMenuItem actionPerformed()" );
                
                bookManager.nextBookIsFocus();
                
                bookManager.displayBookModel();
                
            }
            
        });
        previousBook = new JMenuItem( "Select Previous Book" );
        previousBook.addActionListener( new ActionListener() {
            
            public void actionPerformed( ActionEvent actionEvent ) {
                
                System.out.println( "previousBook JMenuItem actionPerformed()" );
                
                bookManager.previousBookIsFocus();
                
                bookManager.displayBookModel();
                
            }
            
        });
        addChapter = new JMenuItem( "Add Chapter" );
        addChapter.addActionListener( new ActionListener() {
            
            public void actionPerformed( ActionEvent actionEvent ) {
                
                System.out.println( "addChapter JMenuItem actionPerformed()" );
                
                bookManager.getIsFocusBook().addNewChapter();
                
                bookManager.displayBookModel();
                
            }
            
        });
        deleteChapter = new JMenuItem( "Delete Chapter" );
        deleteChapter.addActionListener( new ActionListener() {
            
            public void actionPerformed( ActionEvent actionEvent ) {
                
                System.out.println( "deleteChapter JMenuItem actionPerformed()" );
                
                bookManager.getIsFocusBook().deleteChapter();
                
                bookManager.displayBookModel();
                
            }
            
        });
        nextChapter = new JMenuItem( "Select Next Chapter" );
        nextChapter.addActionListener( new ActionListener() {
            
            public void actionPerformed( ActionEvent actionEvent ) {
                
                System.out.println( "nextChapter JMenuItem actionPerformed()" );
                
                bookManager.getIsFocusBook().nextChapterIsFocus();
                
                bookManager.displayBookModel();
                
            }
            
        });
        previousChapter = new JMenuItem( "Select Previous Chapter" );
        previousChapter.addActionListener( new ActionListener() {
            
            public void actionPerformed( ActionEvent actionEvent ) {
                
                System.out.println( "previousChapter JMenuItem actionPerformed()" );
                
                bookManager.getIsFocusBook().previousChapterIsFocus();
                
                bookManager.displayBookModel();
                
            }
            
        });
        addScene = new JMenuItem( "Add Scene" );
        addScene.addActionListener( new ActionListener() {
            
            public void actionPerformed( ActionEvent actionEvent ) {
                
                System.out.println( "addScene JMenuItem actionPerformed()" );
                
                bookManager.getIsFocusBook().getIsFocusChapter().addNewScene();
                
                bookManager.displayBookModel();
                
            }
            
        });
        deleteScene = new JMenuItem( "Delete Scene" );
        deleteScene.addActionListener( new ActionListener() {
            
            public void actionPerformed( ActionEvent actionEvent ) {
                
                System.out.println( "deleteScene JMenuItem actionPerformed()" );
                
                bookManager.getIsFocusBook().getIsFocusChapter().deleteScene();
                
                bookManager.displayBookModel();
                
            }
            
        });
        nextScene = new JMenuItem( "Select Next Scene" );
        nextScene.addActionListener( new ActionListener() {
            
            public void actionPerformed( ActionEvent actionEvent ) {
                
                System.out.println( "nextScene JMenuItem actionPerformed()" );
                
                bookManager.getIsFocusBook().getIsFocusChapter().nextSceneIsFocus();
                
                bookManager.displayBookModel();
                
            }
            
        });
        previousScene = new JMenuItem( "Select Previous Scene" );
        previousScene.addActionListener( new ActionListener() {
            
            public void actionPerformed( ActionEvent actionEvent ) {
                
                System.out.println( "previousScene JMenuItem actionPerformed()" );
                
                bookManager.getIsFocusBook().getIsFocusChapter().previousSceneIsFocus();
                
                bookManager.displayBookModel();
                
            }
            
        });
        menu.add( addBook );
        menu.add( deleteBook );
        menu.add( nextBook );
        menu.add( previousBook );
        menu.add( addChapter );
        menu.add( deleteChapter );
        menu.add( nextChapter );
        menu.add( previousChapter );
        menu.add( addScene );
        menu.add( deleteScene );
        menu.add( nextScene );
        menu.add( previousScene );
        
        menuBar.add( menu );
        
        setJMenuBar( menuBar );
        
        treePanel = new JPanel();
        treePanel.setLayout( new BorderLayout() );
        treePanel.setPreferredSize( new Dimension( 200, 200 ) );
        tree = new JTree();
        treeScroll = new JScrollPane( tree );
        treePanel.add( treeScroll );
        
        textPanel = new JPanel();
        textPanel.setLayout( new BorderLayout() );
        textPanel.setPreferredSize( new Dimension( 200, 200 ) );
        textArea = new JTextArea();
        textScroll = new JScrollPane( textArea );
        textPanel.add( textScroll );
        
        topPanel = new JPanel();
        bookList = new JSpinner();
        
        topPanel.add( bookList );
        
        bottomPanel = new JPanel();
        bottomPanel.setLayout( new GridLayout( 1, 2 ) );
        bottomPanel.add( treePanel );
        bottomPanel.add( textPanel );
        
        mainPanel = new JPanel();
        mainPanel.setLayout( new BorderLayout() );
        mainPanel.add( topPanel, BorderLayout.NORTH );
        mainPanel.add( bottomPanel, BorderLayout.CENTER );
        
        getContentPane().add( mainPanel );
        pack();
        setVisible( true );
 
    }
 
    // End of constructors ************************ //
    // ******************************************** //
    // Public Methods ***************************** //
    // Getters and Setters ************************ //
    
    
 
    // End of getters and setters ***************** //
    // ******************************************** //
    // Other Public Methods *********************** //
    
    
    
    // End of other public methods **************** //
    // End of public methods ********************** //
    // ******************************************** //
    // Private Methods **************************** //
    
    
    
    // End of private methods ********************* //
    // ******************************************** //
 
}
 
import java.util.*;
import javax.swing.*;
import javax.swing.event.*;
 
/**
 * Write a description of class BookManager here.
 * 
 * @author (your name) 
 * @version (a version number or a date)
 */
public class BookManager {
 
    // ******************************************** //
    // Fields ************************************* //
    
    private ArrayList books;
    private Book book;
 
    // End of fields ****************************** //
    // ******************************************** //
    // Constructors ******************************* //
 
    /**
     * Constructor for objects of class BookManager
     */
    public BookManager() {
 
        // Initialise fields.
        books = new ArrayList();
        book = null;
 
    }
 
    // End of constructors ************************ //
    // ******************************************** //
    // Public Methods ***************************** //
    // Getters and Setters ************************ //
    
    
 
    // End of getters and setters ***************** //
    // ******************************************** //
    // Other Public Methods *********************** //
    
    public void nextBookIsFocus() {
        
        if ( getIsFocusBook() == null ) {
            
            System.out.println( "No Books stored in BookManager!" );
            
        } else if ( books.indexOf( getIsFocusBook() ) == books.size() - 1 ) {
            
            setIsFocusBook( ( Book ) books.get( 0 ) );
            
        } else {
            
            setIsFocusBook( ( Book ) books.get( books.indexOf( getIsFocusBook() ) + 1 ) );
            
        }
        
    }
    
    public void previousBookIsFocus() {
        
        if ( getIsFocusBook() == null ) {
            
            System.out.println( "No Books stored in BookManager!" );
            
        } else if ( books.indexOf( getIsFocusBook() ) == 0 ) {
            
            setIsFocusBook( ( Book ) books.get( books.size() - 1 ) );
            
        } else {
            
            setIsFocusBook( ( Book ) books.get( books.indexOf( getIsFocusBook() ) - 1 ) );
            
        }
        
    }
    
    public void addNewBook() {
        
        System.out.println( "BookManager.addNewBook()" );
        
        book = new Book();
        
        books.add( book );
        
        setIsFocusBook( book );
        
        System.out.println( "... The spinner should now show the new book's title." );
        
    }
    
    public void addBook( Book book ) {
        
        books.add( book );
        
    }
    
    public void deleteBook() {
        
        books.remove( getIsFocusBook() );
        
        if ( books.size() != 0 ) {
            
            setIsFocusBook( ( Book ) books.get( 0 ) );
            
        }
        
    }
    
    public void displayBookModel() {
        
        System.out.println( "BookManager.displayBookModel()" );
        
        Iterator i = books.iterator();
        
        while ( i.hasNext() ) {
            
            Book book = ( Book ) i.next();
            
            if ( book.getIsFocus() ) {
                
                book.printMe();
                
            } else {
                
                System.out.println( book.getBookTitle() );
 
            }
            
        }
        
    }
    
    public Book getIsFocusBook() {
        
        Iterator i = books.iterator();
        
        Book book = null;
        
        while ( i.hasNext() ) {
            
            Book tempBook = ( Book ) i.next();
            
            if ( tempBook.getIsFocus() ) {
                
                book = tempBook;
                
            }
            
        }
        
        return book;
        
    }
    
    // End of other public methods **************** //
    // End of public methods ********************** //
    // ******************************************** //
    // Private Methods **************************** //
    
    private void setIsFocusBook( Book book ) {
        
        Iterator i = books.iterator();
        
        while ( i.hasNext() ) {
            
            Book tempBook = ( Book ) i.next();
            tempBook.setIsFocus( false );
            
        }
        
        book.setIsFocus( true );
        
    }
    
    // End of private methods ********************* //
    // ******************************************** //
    
}
 
import java.util.*;
 
/**
 * Write a description of class Book here.
 * 
 * @author (your name) 
 * @version (a version number or a date)
 */
public class Book {
 
    // ******************************************** //
    // Fields ************************************* //
    
    private ArrayList chapters;
    private String bookTitle;
    private boolean isFocus;
    private Chapter chapter;
 
    // End of fields ****************************** //
    // ******************************************** //
    // Constructors ******************************* //
 
    /**
     * Constructor for objects of class Book
     */
    public Book() {
 
        // Initialise fields.
        chapters = new ArrayList();
        bookTitle = new String( "Untitled Book" );
        isFocus = false;
        chapter = null;
 
    }
 
    // End of constructors ************************ //
    // ******************************************** //
    // Public Methods ***************************** //
    // Getters and Setters ************************ //
    
    public String getBookTitle() {
        
        return bookTitle;
        
    }
 
    public void setBookTitle( String bookTitle ) {
        
        this.bookTitle = bookTitle;
        
    }
    
    public boolean getIsFocus() {
        
        return isFocus;
        
    }
    
    public void setIsFocus( boolean isFocus ) {
        
        this.isFocus = isFocus;
        
    }
    
    // End of getters and setters ***************** //
    // ******************************************** //
    // Other Public Methods *********************** //
    
    public void nextChapterIsFocus() {
        
        if ( getIsFocusChapter() == null ) {
            
            System.out.println( "Book has no chapters!" );
            
        } else if ( chapters.indexOf( getIsFocusChapter() ) == chapters.size() - 1 ) {
            
            setIsFocusChapter( ( Chapter ) chapters.get( 0 ) );
            
        } else {
            
            setIsFocusChapter( ( Chapter ) chapters.get( chapters.indexOf( getIsFocusChapter() ) + 1 ) );
            
        }
        
    }
    
    public void previousChapterIsFocus() {
        
        if ( getIsFocusChapter() == null ) {
            
            System.out.println( "Book has no chapters!" );
            
        } else if ( chapters.indexOf( getIsFocusChapter() ) == 0 ) {
            
            setIsFocusChapter( ( Chapter ) chapters.get( chapters.size() - 1 ) );
            
        } else {
            
            setIsFocusChapter( ( Chapter ) chapters.get( chapters.indexOf( getIsFocusChapter() ) - 1 ) );
            
        }
        
    }
    
    public void addNewChapter() {
        
        System.out.println( "Book.addNewChapter()" );
        
        chapter = new Chapter();
        
        chapters.add( chapter );
        
        setIsFocusChapter( chapter );
        
    }
    
    public void addChapter( Chapter chapter ) {
        
        chapters.add( chapter );
        
    }
    
    public void deleteChapter() {
        
        chapters.remove( getIsFocusChapter() );
        
        if ( chapters.size() != 0 ) {
            
            setIsFocusChapter( ( Chapter ) chapters.get( 0 ) );
            
        }
        
    }
    
    public void printMe() {
        
        if ( isFocus ) {
        
            System.out.println( bookTitle + " *" );
            
        } else {
            
            System.out.println( bookTitle );
            
        }
        
        Iterator i = chapters.iterator();
        
        while ( i.hasNext() ) {
            
            Chapter chapter = ( Chapter ) i.next();
            chapter.printMe();
            
        }
        
    }
    
    public Chapter getIsFocusChapter() {
        
        Iterator i = chapters.iterator();
        
        Chapter chapter = null;
        
        while ( i.hasNext() ) {
            
            Chapter tempChapter = ( Chapter ) i.next();
            
            if ( tempChapter.getIsFocus() ) {
                
                chapter = tempChapter;
                
            }
            
        }
        
        return chapter;
        
    }
    
    // End of other public methods **************** //
    // End of public methods ********************** //
    // ******************************************** //
    // Private Methods **************************** //
    
    private void setIsFocusChapter( Chapter chapter ) {
        
        Iterator i = chapters.iterator();
        
        while ( i.hasNext() ) {
            
            Chapter tempChapter = ( Chapter ) i.next();
            tempChapter.setIsFocus( false );
            
        }
        
        chapter.setIsFocus( true );
        
    }
    
    // End of private methods ********************* //
    // ******************************************** //
    
}
import java.util.*;
 
/**
 * Write a description of class Chapter here.
 * 
 * @author (your name) 
 * @version (a version number or a date)
 */
public class Chapter {
 
    // ******************************************** //
    // Fields ************************************* //
    
    private ArrayList scenes;
    private String chapterTitle;
    private boolean isFocus;
    private Scene scene;
    
    // End of fields ****************************** //
    // ******************************************** //
    // Constructors ******************************* //
 
    /**
     * Constructor for objects of class Chapter
     */
    public Chapter() {
 
        // Initialise fields.
        scenes = new ArrayList();
        chapterTitle = new String( "Untitled Chapter" );
        isFocus = false;
        scene = null;
        
    }
 
    // End of constructors ************************ //
    // ******************************************** //
    // Public Methods ***************************** //
    // Getters and Setters ************************ //
    
    public String getChapterTitle() {
        
        return chapterTitle;
        
    }
    
    public void setChapterTitle( String chapterTitle ) {
        
        this.chapterTitle = chapterTitle;
        
    }
    
    public boolean getIsFocus() {
        
        return isFocus;
        
    }
    
    public void setIsFocus( boolean isFocus ) {
        
        this.isFocus = isFocus;
        
    }
 
    // End of getters and setters ***************** //
    // ******************************************** //
    // Other Public Methods *********************** //
    
    public void nextSceneIsFocus() {
        
        if ( getIsFocusScene() == null ) {
            
            System.out.println( "Chapter has no scenes!" );
            
        } else if ( scenes.indexOf( getIsFocusScene() ) == scenes.size() - 1 ) {
            
            setIsFocusScene( ( Scene ) scenes.get( 0 ) );
            
        } else {
            
            setIsFocusScene( ( Scene ) scenes.get( scenes.indexOf( getIsFocusScene() ) + 1 ) );
            
        }
        
    }
    
    public void previousSceneIsFocus() {
        
        if ( getIsFocusScene() == null ) {
            
            System.out.println( "Chapter has no scenes!" );
            
        } else if ( scenes.indexOf( getIsFocusScene() ) == 0 ) {
            
            setIsFocusScene( ( Scene ) scenes.get( scenes.size() - 1 ) );
            
        } else {
            
            setIsFocusScene( ( Scene ) scenes.get( scenes.indexOf( getIsFocusScene() ) - 1 ) );
            
        }
        
    }
    
    public void addNewScene() {
        
        System.out.println( "Chapter.addNewScene()" );
        
        scene = new Scene();
        
        scenes.add( scene );
        
        setIsFocusScene( scene );
        
    }
    
    public void addScene( Scene scene ) {
        
        scenes.add( scene );
        
    }
    
    public void deleteScene() {
        
        scenes.remove( getIsFocusScene() );
        
        if ( scenes.size() != 0 ) {
        
            setIsFocusScene( ( Scene ) scenes.get( 0 ) );
            
        }
        
    }
    
    public void printMe() {
        
        if ( isFocus ) {
            
            System.out.println( "\t" + chapterTitle + " *" );
            
        } else {
            
            System.out.println( "\t" + chapterTitle );
            
        }
        
        Iterator i = scenes.iterator();
        
        while ( i.hasNext() ) {
            
            Scene scene = ( Scene ) i.next();
            scene.printMe();
            
        }
        
    }
    
    public Scene getIsFocusScene() {
        
        Iterator i = scenes.iterator();
        
        Scene scene = null;
        
        while ( i.hasNext() ) {
            
            Scene tempScene = ( Scene ) i.next();
            
            if ( tempScene.getIsFocus() ) {
                
                scene = tempScene;
                
            }
            
        }
        
        return scene;
        
    }
    
    // End of other public methods **************** //
    // End of public methods ********************** //
    // ******************************************** //
    // Private Methods **************************** //
    
    private void setIsFocusScene( Scene scene ) {
        
        Iterator i = scenes.iterator();
        
        while ( i.hasNext() ) {
            
            Scene tempScene = ( Scene ) i.next();
            tempScene.setIsFocus( false );
            
        }
        
        scene.setIsFocus( true );
        
    }
    
    // End of private methods ********************* //
    // ******************************************** //
 
}
/**
 * Write a description of class Scene here.
 * 
 * @author (your name) 
 * @version (a version number or a date)
 */
public class Scene {
 
    // ******************************************** //
    // Fields ************************************* //
    
    private String sceneContent;
    private String sceneTitle;
    private boolean isFocus;
    
    // End of fields ****************************** //
    // ******************************************** //
    // Constructors ******************************* //
 
    /**
     * Constructor for objects of class Scene
     */
    public Scene() {
 
        // Initialise fields.
        sceneContent = new String();
        sceneTitle = new String( "Untitled Scene" );
        isFocus = false;
 
    }
 
    // End of constructors ************************ //
    // ******************************************** //
    // Public Methods ***************************** //
    // Getters and Setters ************************ //
    
    public String getSceneContent() {
        
        return sceneContent;
        
    }
    
    public void setSceneContent( String sceneContent ) {
        
        this.sceneContent = sceneContent;
        
    }
    
    public String getSceneTitle() {
        
        return sceneTitle;
        
    }
    
    public void setSceneTitle( String sceneTitle ) {
        
        this.sceneTitle = sceneTitle;
        
    }
    
    public boolean getIsFocus() {
        
        return isFocus;
        
    }
    
    public void setIsFocus( boolean isFocus ) {
        
        this.isFocus = isFocus;
        
    }
 
    // End of getters and setters ***************** //
    // ******************************************** //
    // Other Public Methods *********************** //
    
    public void printMe() {
        
        if ( isFocus ) {
            
            System.out.println( "\t\t" + sceneTitle + " *" );
            
        } else {
            
            System.out.println( "\t\t" + sceneTitle );
            
        }
        
    }
    
    // End of other public methods **************** //
    // End of public methods ********************** //
    // ******************************************** //
    // Private Methods **************************** //
    
    
    
    // End of private methods ********************* //
    // ******************************************** //
 
}
 

[ October 21, 2005: Message edited by: D R Wilkinson ]

[Craig Wood]

Here's one way you could do it.
Notes:
1 — I tried to use the classes you provided with minimal changes.
2 — the classes containing collections have parallel declaration/instantiations for the collections:

one for non–generic j2se 1.4- and

one for generic j2se 1.5+ versions.

It is set up for j2se 1.4-It is set up for j2se 1.4-
3 — the JTree gets the string for each tree node from the 'toString' method in each class.

import java.awt.*;
import java.awt.event.*;
import java.util.*;
import java.util.List;
import javax.swing.*;
import javax.swing.event.*;
import javax.swing.tree.*;
 
public class TMT implements TreeSelectionListener {
    JSpinner spinner;
    Books books;
    BookTree tree;
    JTextArea textArea;
 
    public void valueChanged(TreeSelectionEvent e) {
        TreePath path = e.getNewLeadSelectionPath();
        if(path != null) {
            Object o = path.getLastPathComponent();
            if(o instanceof ModScene)
                textArea.setText(((ModScene)o).getSceneContent());
        }
    }
 
    private BookTree getTree() {
        String[] bookTitles = {
            "The Java Tutorial",
            "The Java Tutorial Continued: The Rest of the JDK",
            "Java Swing, Second Edition",
            "Effective Java"
        };
        String[][] chapterTitles = {
            { "Getting Started", "Object-Oriented Programming Concepts" },
            { "Collections", "Internationalization", "Graphics" },
            { "Introducing Swing" },
            { "Introduction", "Creating and Destroying Objects",
              "Methods Common to All Objects", "Classes and Interfaces" } 
        };
        int[] chapterScenes = {      // access with 'csi' in loop statements
            1, 2, 1, 3, 4, 3, 1, 1, 1, 1
        };
        ModBook[] modBooks = new ModBook[bookTitles.length];
        for(int j = 0, csi = 0; j < bookTitles.length; j++) {
            modBooks[j] = new ModBook();
            modBooks[j].setBookTitle(bookTitles[j]);
            for(int k = 0; k < chapterTitles[j].length; k++, csi++) {
                ModChapter chapter = new ModChapter();
                chapter.setChapterTitle(chapterTitles[j][k]);
                modBooks[j].addChapter(chapter);
                for(int m = 0; m < chapterScenes[csi]; m++) {
                    ModScene scene = new ModScene();
                    scene.setSceneTitle("scene " + (m+1));
                    scene.setSceneContent("content for scene " + (m+1) + "\n" +
                                           chapterTitles[j][k] + "\n" +
                                           bookTitles[j]);
                    chapter.addScene(scene);
                }
            }
        }
        books = new Books(modBooks);
        SpinnerListModel model = new SpinnerListModel(books.getBookNames());
        spinner.setModel(model);
        BookTree tree = new BookTree(modBooks[0]);
        tree.addTreeSelectionListener(this);
        return tree;
    }
 
    private JPanel getNorthPanel() {
        spinner = new JSpinner();
        spinner.addChangeListener(new ChangeListener() {
            public void stateChanged(ChangeEvent e) {
                String title = (String)spinner.getValue();
                ModBook book = books.getBook(title);
                tree.getModel().setRoot(book);
            }
        });
        JPanel panel = new JPanel(new GridBagLayout());
        GridBagConstraints gbc = new GridBagConstraints();
        gbc.insets = new Insets(2,2,2,2);
        panel.add(new JLabel("select a book"), gbc);
        gbc.weightx = 1.0;
        gbc.fill = gbc.HORIZONTAL;
        panel.add(spinner, gbc);
        return panel;
    }
 
    private JPanel getCenterPanel() {
        tree = getTree();
        textArea = new JTextArea();
        textArea.setLineWrap(true);
        textArea.setWrapStyleWord(true);
        textArea.setMargin(new Insets(5,5,5,5));
        JPanel panel = new JPanel(new GridLayout(1,0));
        panel.add(new JScrollPane(tree));
        panel.add(new JScrollPane(textArea));
        return panel;
    }
 
    public static void main(String[] args) {
        TMT test = new TMT();
        JFrame f = new JFrame();
        f.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        f.getContentPane().add(test.getNorthPanel(), "North");
        f.getContentPane().add(test.getCenterPanel());
        f.setSize(500,400);
        f.setLocation(200,200);
        f.setVisible(true);
    }
}
 
class BookTree extends JTree {
    transient protected BookTreeModel model;
 
    public BookTree(ModBook book) {
        super(new BookTreeModel(book));
        getSelectionModel().setSelectionMode(
                                    TreeSelectionModel.SINGLE_TREE_SELECTION);
    }
 
    public BookTreeModel getModel() {
        return (BookTreeModel)super.getModel();
    }
 
    public boolean isEditable() {
        return false;
    }
}
 
class BookTreeModel implements TreeModel {
    protected ModBook rootBook;
    protected EventListenerList listenerList;
 
    public BookTreeModel(ModBook root) {
        rootBook = root;
        listenerList = new EventListenerList();
    }
 
    public Object getChild(Object parent, int index) {
        Object retVal = null;
        if(parent == rootBook) {
            ModBook book = (ModBook)parent;
            retVal = (ModChapter)book.getChapter(index);
        } else {  // ModChapter
            ModChapter chapter = (ModChapter)parent;
            retVal = (ModScene)chapter.getScene(index);
        }
        return retVal;
    }
 
    public int getChildCount(Object parent) {
        int count = -1;
        if(parent == rootBook) {
            ModBook book = (ModBook)parent;
            count = book.getChapterCount();
        } else {  // ModChapter
            ModChapter chapter = (ModChapter)parent;
            count = chapter.getSceneCount();
        }
        return count;
    }
 
    public int getIndexOfChild(Object parent, Object child) {
        int index = -1;
        if(parent == rootBook) {
            ModBook book = (ModBook)parent;
            index = book.getChapterIndex((ModChapter)child);
        } else {  // ModChapter
            ModChapter chapter = (ModChapter)parent;
            index = chapter.getSceneIndex((ModScene)child);
        }
        return index;
    }
 
    public Object getRoot() {
        return rootBook;
    }
 
    public boolean isLeaf(Object node) {
        if(node instanceof ModScene)
            return true;
        if(node instanceof ModChapter)
            return ((ModChapter)node).getSceneCount() == 0;
        return false;
    }
 
    public void addTreeModelListener(TreeModelListener l) {
        listenerList.add(TreeModelListener.class, l);
    }
 
    public void removeTreeModelListener(TreeModelListener l) {
        listenerList.remove(TreeModelListener.class, l);
    }
 
    public void valueForPathChanged(TreePath path, Object newValue) {
        // tree is not editable
    }
 
    public void setRoot(ModBook root) {
        Object oldRoot = this.rootBook;
        this.rootBook = root;
        if(root == null && oldRoot != null)
            fireTreeStructureChanged(this, null);
        else
            fireTreeStructureChanged(this, new Object[] { root }, null, null);
    }
 
    protected void fireTreeStructureChanged(Object source, Object[] path, 
                                            int[] childIndices, 
                                            Object[] children) {
        // Guaranteed to return a non-null array
        Object[] listeners = listenerList.getListenerList();
        TreeModelEvent e = null;
        // Process the listeners last to first, notifying
        // those that are interested in this event
        for (int i = listeners.length-2; i>=0; i-=2) {
            if (listeners[i]==TreeModelListener.class) {
                // Lazily create the event:
                if (e == null)
                    e = new TreeModelEvent(source, path, 
                                           childIndices, children);
                ((TreeModelListener)listeners[i+1]).treeStructureChanged(e);
            }          
        }
    }
 
    private void fireTreeStructureChanged(Object source, TreePath path) {
        // Guaranteed to return a non-null array
        Object[] listeners = listenerList.getListenerList();
        TreeModelEvent e = null;
        // Process the listeners last to first, notifying
        // those that are interested in this event
        for (int i = listeners.length-2; i>=0; i-=2) {
            if (listeners[i]==TreeModelListener.class) {
                // Lazily create the event:
                if (e == null)
                    e = new TreeModelEvent(source, path);
                ((TreeModelListener)listeners[i+1]).treeStructureChanged(e);
            }
        }
    }
}
 
class Books {
    //List<ModBook> books;
    List books;
 
    public Books(ModBook[] b) {
        //books = new ArrayList<ModBook>(Arrays.asList(b));
        books = new ArrayList(Arrays.asList(b));
    }
 
    public ModBook getBook(String name) {
        for(int j = 0; j < books.size(); j++) {
            ModBook book = (ModBook)books.get(j);
            if(book.getBookTitle().equals(name))
                return book;
        }
        return null;
    }
 
    public ModBook getBook(int index) {
        return (ModBook)books.get(index);
    }
 
    public String[] getBookNames() {
        String[] names = new String[books.size()];
        for(int j = 0; j < names.length; j++)
            names[j] = ((ModBook)books.get(j)).getBookTitle();
        return names;
    }
}

import java.util.*;
 
public class ModBook {
    //private ArrayList<ModChapter> chapters;
    private ArrayList chapters;
    private String bookTitle;
    private ModChapter chapter;
 
    public ModBook() {
        //chapters = new ArrayList<ModChapter>();
        chapters = new ArrayList();
        bookTitle = new String( "Untitled Book" );
        chapter = null;
    }
 
    public ModChapter getChapter(int index) {
        return (ModChapter)chapters.get(index);
    }
 
    public int getChapterCount() {
        return chapters.size();
    }
 
    public int getChapterIndex(ModChapter chapter) {
        return chapters.indexOf(chapter);
    }
 
    public String toString() {
        return getBookTitle();
    }
 
    public String getBookTitle() {
        return bookTitle;
    }
 
    public void setBookTitle( String bookTitle ) {
        this.bookTitle = bookTitle;
    }
 
    public void addChapter( ModChapter chapter ) {
        chapters.add( chapter );
    }
}

import java.util.*;
 
public class ModChapter {
    //private ArrayList<ModScene> scenes;
    private ArrayList scenes;
    private String chapterTitle;
    private ModScene scene;
 
    public ModChapter() {
        //scenes = new ArrayList<ModScene>();
        scenes = new ArrayList();
        chapterTitle = new String( "Untitled Chapter" );
        scene = null;
    }
 
    public ModScene getScene(int index) {
        return (ModScene)scenes.get(index);
    }
 
    public int getSceneCount() {
        return scenes.size();
    }
 
    public int getSceneIndex(ModScene scene) {
        return scenes.indexOf(scene);
    }
 
    public String toString() {
        return getChapterTitle();
    }
 
    public String getChapterTitle() {
        return chapterTitle;
    }
 
    public void setChapterTitle( String chapterTitle ) {
        this.chapterTitle = chapterTitle;
    }
 
    public void addScene( ModScene scene ) {
        scenes.add( scene );
    }
}

public class ModScene {
    private String sceneContent;
    private String sceneTitle;
 
    public ModScene() {
        sceneContent = new String();
        sceneTitle = new String( "Untitled Scene" );
    }
 
    public String getSceneContent() {
        return sceneContent;
    }
 
    public void setSceneContent( String sceneContent ) {
        this.sceneContent = sceneContent;
    }
 
    public String toString() {
        return getSceneTitle();
    }
 
    public String getSceneTitle() {
        return sceneTitle;
    }
 
    public void setSceneTitle( String sceneTitle ) {
        this.sceneTitle = sceneTitle;
    }
}

[ October 22, 2005: Message edited by: Craig Wood ]

[D R Wilkinson]

Firstly - thank you Craig for writing the example. I really appreciate your effort.

I have been slowly working my way through it and I have some questions.

I have added a "Add Book" menu item which calls a new method addNewBook() that I added to the Books class. This method simply adds a new ModBook to Books List of ModBook objects.

This works fine - a new ModBook is added to the List.

Somehow, the JSpinner must now display this new book.

What I don't understand is how?

By my ( mis ) understanding of how things work..,

Books now stores 2 ModBooks so the data model of the application has changed. The method that made the change ( ie addNewBook() ) should fire some event saying "My state has changed. I have one more new book than before" and the JSpinner ( which is listening for such events ) should go "I hear you Books object, give me your list of ModBooks and I will display them."

When I try to make this happen, I get confused and it doesn't work.

If you could kindly explain how to do this I would be very grateful.

Darren

[D R Wilkinson]

I have got it to work - very crudely

in the actionPerformed method for the addNewBookMenuItem I put the following

 
 
                books.addNewBook();
                
                spinner.setModel( new SpinnerListModel( books.getBookNames() ) );
                
                spinner.setValue( books.getBookNames()[ books.getBookNames().length - 1 ] );
                
                tree.getModel().setRoot( books.getBook( ( String ) spinner.getValue() ) );

so I am...

1. Updating the data model
2. Updating the spinners data model
3. Updating the tree model

which must be wrong as the spinner and tree all ultimately are supposed to be views of the data model, so shouldn't the data model be firing events saying the data has changed and the spinner and tree receiving them and displaying the newly changed data in the data model?

I am finding this to be very confusing
[ October 25, 2005: Message edited by: D R Wilkinson ]

[Craig Wood]

the spinner and tree all ultimately are supposed to be views of the data model
The JTree is a view of its TreeModel. The JSpinner reflects the state of the the class
Books and really has nothing to do with the state of the TreeModel (at least for now). The
spinner is used to select ModBooks from the Books class and to then reset the TreeModel
(which fires events to reset the tree view) with the new ModBook. You wanted the tree to
show only one Book at a time so we have to have a way to bridge the Books class and its
client JSpinner with the TreeModel. Let's think about this...

If you change your design to have the TreeModel and JTree have all the ModBooks in Books,
as nodes of the root node, then you could easily control everything from within the
TreeModel; it would have access to all the ModBooks. You could (dispense with the Books
class, let the TreeModel use it or move it into the TreeModel and) let the TreeModel
handle the details of the ModBook collection including updates to the JSpinners
SpinnerListModel. Or you could let the TreeModel keep the ModBook collection, continue to
change the tree root as needed and update the JSpinner.

shouldn't the data model be firing events saying the data has changed and the spinner
and tree receiving them and displaying the newly changed data in the data model?
In the typical scenario of a JTree whos TreeModel has access to all the data it needs for
the tree, yes. With the data model you have elected, not necessarily, possibly. The Books
class and its client JSpinner work together to control/change the root of the JTree via
its TreeModel. This could be considered as a bit on the radical side but still manageable.
The challenge is to find an elegant way to connect the ModBook collection (Books), the
selector (spinner) and the TreeModel class. The way it is set up/put together/designed now
the TreeModel doesn't care about where the ModBook root comes from. Its only concern is to
show the contents of one book at a time. If the TreeModel had access to or contained the
collection of ModBooks it could easily change the state of the JSpinner as well as the
JTree. Then your JMenuItem action could tell the TreeModel to make the changes in one
method call.

If you decide to keep the TreeModel and Books class separate you can make a method to
coordinate the changes or leave the code inside the ActionListener as you have it. I
wonder if changing the selection state of the JSpinner will automatically message the
TreeModel on its own...

About changes to the JSpinner: it works okay to reset the SpinnerListModel of the spinner.
A more light–handed approach might be to get its List and add/remove items to/from
it. You might then have to call 'fireStateChanged' on the list to get the update sent to
the listeners.