Problem with Java Class-Hierarchy

Please can someone help me with this... it's causing me much stress!

I am running two different versions of Doxygen (1.2.8.1 at work and
1.2.16 at home) on a moderate-sized Java project.  I'm getting very
frustrated with the class-hierarchy generation on the 1.2.16 version.

Let me demonstrate:

At work I get the following class hierarchy built from my sources:

-------------------
* Iterator                                                                                       
     * BackpropNetwork::LayerIterator                                                            
* JDialog                                                                                        
     * ListDialog                                                                                
     * NetworkParametersDialog                                                                   
* JFrame                                                                                         
     * MainWindow                                                                                
* JInternalFrame                                                                                 
     * MessageFrame                                                                              
* JPanel                                                                                         
     * ParameterPanel                                                                            
* Observable                                                                                     
     * AbstractNeuralNetwork                                                                     
          * BackpropNetwork                                                                      
          * SymmetricHopfieldNetwork                                                             
               * SymmetricDeltaHopfieldNetwork                                                   
                    * AsymmetricDeltaHopfieldNetwork                                             
     * AbstractNeuron                                                                            
          * DummyNeuron                                                                          
          * SigmoidNeuron                                                                        
          * ThresholdNeuron                                                                      
* Serializable                                                                                   
     * Connection                                                                                
     * NetworkModel                                                                              
     * NeuralNetwork                                                                             
          * AbstractNeuralNetwork                                                                
     * Neuron                                                                                    
          * AbstractNeuron                                                                       
     * Parameter                                                                                 
* SupervisedLearning                                                                             
     * BackpropNetwork                                                                           
* UnsupervisedLearning                                                                           
     * SymmetricHopfieldNetwork
------------------------------------------

This is what I want to see... It has all of my own classes and *only*
the classes from the Java libraries that I inherit from.  When I run
Doxygen at home however,  I get not only these classes, but dozens of
other classes from the libraries that I use, but don't inherit from.
Like this:

------------------------------------------
          * Connection                                                                             
          * NeuralNetwork                                                                          
               * AbstractNeuralNetwork                                                             
                    * BackpropNetwork                                                              
                    * SymmetricHopfieldNetwork                                                     
                         * SymmetricDeltaHopfieldNetwork                                           
                              * AsymmetricDeltaHopfieldNetwork                                     
          * Neuron                                                                                 
               * AbstractNeuron                                                                    
                    * DummyNeuron                                                                  
                    * SigmoidNeuron                                                                
                    * ThresholdNeuron                                                              
          * Parameter                                                                              
          * ui::NetworkModel                                                                       
     * SupervisedLearning                                                                          
          * BackpropNetwork                                                                        
     * UnsupervisedLearning                                                                        
          * SymmetricHopfieldNetwork                                                               
     * AbstractAction                                                                              
     * AbstractAction                                                                              
     * AbstractAction                                                                              
     * Action                                                                                      
     * Action                                                                                      
     * Action                                                                                      
     * ActionEvent                                                                                 
     * ActionEvent                                                                                 
     * ActionEvent                                                                                 
     * ArrayList                                                                                   
     * ArrayList                                                                                   
     * ArrayList                                                                                   
     * ArrayList                                                                                   
     * ArrayList                                                                                   
     * ArrayList                                                                                   
     * ArrayList                                                                                   
     * BorderFactory                                                                               
     * BorderLayout                                                                                
     * BorderLayout                                                                                
     * BoxLayout                                                                                   
     * BufferedWriter                                                                              
     * Constructor                                                                                 
     * Constructor                                                                                 
     * File                                                                                        
     * File
     .....
	......
-----------------------------------

The hierarchy goes on for about 5 more pages... but you see my problem!
I really don't want all that stuff showing in my documentation like
that.  I want a graph like I get with 1.2.8.1, but I don't think I
should have to downgrade from 1.2.16.

I can get a graph *like* the one I want by using HIDE_UNDOC_CLASSES=YES,
but when I do this I no longer get to see the classes from the library
that my classes inherit from.

There must be something I'm missing here... I'm pretty new to Doxygen,
but I've found it invaluable, and come to depend on it greatly.  Please
can someone help me with this problem?

Thanks in advance,
	
	Tom

--

-- 
Tom Eastman <teastman <at> cs.otago.ac.nz>       

GnuPG Key:   12834220 
Fingerprint: AF47 70FA 03B5 0EE7 E9B5 
             B91F 3636 C516 1283 4220

This message is transmitted using 100% recycled electrons.

-------------------------------------------------------
This sf.net email is sponsored by:ThinkGeek
Welcome to geek heaven.
http://thinkgeek.com/sf