Release-1.2.11-20011021

INSTALL

-DOXYGEN Version 1.2.11-20011014
+DOXYGEN Version 1.2.11-20011021
 
 Please read the installation section of the manual for instructions.
 
 --------
-Dimitri van Heesch (14 October 2001)
+Dimitri van Heesch (21 October 2001)

README

-DOXYGEN Version 1.2.11_20011014
+DOXYGEN Version 1.2.11_20011021
 
 Please read INSTALL for compilation instructions.
 
@@ -17,4 +17,4 @@ to subscribe to the lists or to visit the archives.
 
 Enjoy,
 
-Dimitri van Heesch (dimitri@stack.nl) (14 October 2001)
+Dimitri van Heesch (dimitri@stack.nl) (21 October 2001)

VERSION

-1.2.11-20011014
+1.2.11-20011021

doc/install.doc

@@ -520,7 +520,7 @@ the <code>bin</code> directory of the distribution to the path.
 
 For running doxywizard you need to install the non-commercial version of
 the Qt library first. This library can be downloaded from 
-http://www.trolltech.com/products/download/freelicense/noncommercial-dl.html
+http://www.trolltech.com/products/download/qt-win-noncomm.html
 
 \subsection build_tools Tools used to develop doxygen
 

doc/maintainers.txt

@@ -5,6 +5,7 @@ Brazilian
 Fabio "FJTC" Jun Takada Chino: chino@grad.icmc.sc.usp.br
 
 Chinese
+Wei Liu: liuwei@asiainfo.com
 Wang Weihan: wangweihan@capinfo.com.cn
 
 Croatian

doc/translator.pl

@@ -77,6 +77,11 @@
 #    the simplified language.doc from the template was moved to 
 #    the separate function CopyTemplateToLanguageDoc().
 #
+# 2001/10/17
+#  - Minor update of GetInfoFrom() to ignore spaces between the
+#    method identifier and the opening parenthesis to match better
+#    the method prototype with the one in the translator.h.
+#
 ################################################################
 
 use 5.005;
@@ -316,6 +321,7 @@ sub GetInfoFrom  ##{{{
     $cont =~ s{^\s+}{}s;
     $cont =~ s{\s+$}{}s;
     
+    $cont =~ s{\s+\(}{(}g;
     $cont =~ s{\)\s*}{)\n}g;
     
     # Split the string and add it to the ouptut list.

packages/rpm/doxygen.spec

 Name: doxygen
-Version: 1.2.11_20011014
+Version: 1.2.11_20011021
 Summary: documentation system for C, C++ and IDL
 Release: 4
 Source: doxygen-%{version}.src.tar.gz

qtools/Doxyfile

@@ -51,21 +51,10 @@ WARN_LOGFILE           =
 #---------------------------------------------------------------------------
 # configuration options related to the input files
 #---------------------------------------------------------------------------
-INPUT                  = . \
-                         $(QTDIR)/src/doc/qarray.doc \
-                         $(QTDIR)/src/doc/qdict.doc \
-                         $(QTDIR)/src/doc/qintdict.doc \
-                         $(QTDIR)/src/doc/qlist.doc \
-                         $(QTDIR)/src/doc/qptrdict.doc \
-                         $(QTDIR)/src/doc/qsortedlist.doc \
-                         $(QTDIR)/src/doc/qstack.doc \
-                         $(QTDIR)/src/doc/qstrlist.doc \
-                         $(QTDIR)/src/doc/qvector.doc \
-                         $(QTDIR)/src/doc/qvaluelist.doc \
-                         $(QTDIR)/src/doc/qtl.doc
+INPUT                  = .
 FILE_PATTERNS          = *.h \
                          *.cpp \
-                         q*.doc
+                         *.doc
 RECURSIVE              = NO
 EXCLUDE_PATTERNS       = 
 EXAMPLE_PATH           = 
@@ -77,8 +66,8 @@ FILTER_SOURCE_FILES    = NO
 # configuration options related to the alphabetical class index
 #---------------------------------------------------------------------------
 ALPHABETICAL_INDEX     = YES
-COLS_IN_ALPHA_INDEX    = 5
-IGNORE_PREFIX          = 
+COLS_IN_ALPHA_INDEX    = 4
+IGNORE_PREFIX          = Q
 #---------------------------------------------------------------------------
 # configuration options related to the HTML output
 #---------------------------------------------------------------------------

qtools/qsortedlist.doc

+/****************************************************************************
+** $Id$
+**
+** QSortedList documentation
+**
+** Copyright (C) 1992-2000 Trolltech AS.  All rights reserved.
+**
+** This file is part of the Qt GUI Toolkit.
+**
+** This file may be distributed under the terms of the Q Public License
+** as defined by Trolltech AS of Norway and appearing in the file
+** LICENSE.QPL included in the packaging of this file.
+**
+** This file may be distributed and/or modified under the terms of the
+** GNU General Public License version 2 as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL included in the
+** packaging of this file.
+**
+** Licensees holding valid Qt Enterprise Edition or Qt Professional Edition
+** licenses may use this file in accordance with the Qt Commercial License
+** Agreement provided with the Software.
+**
+** This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
+** WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
+**
+** See http://www.trolltech.com/pricing.html or email sales@trolltech.com for
+**   information about Qt Commercial License Agreements.
+** See http://www.trolltech.com/qpl/ for QPL licensing information.
+** See http://www.trolltech.com/gpl/ for GPL licensing information.
+**
+** Contact info@trolltech.com if any conditions of this licensing are
+** not clear to you.
+**
+**********************************************************************/
+
+
+/*****************************************************************************
+  QSortedList documentation
+ *****************************************************************************/
+
+/*!
+  \class QSortedList qsortedlist.h
+  \brief The QSortedList class provides a list sorted by operator< and operator==
+
+  \ingroup collection
+  \ingroup tools
+
+  If you want to sort a QList you have to reimplement the
+  QGList::compareItems() method.  If the elements of your list support
+  operator<() and operator==() then you can use QSortedList instead.
+  Its compareItems() calls operator<() and operator==() and returns an
+  appropriate result.
+
+  Otherwise, this is as QList.
+
+  \sa QList, \link collection.html Collection Classes\endlink
+*/
+
+
+/*!
+  \fn QSortedList::QSortedList()
+  Constructs an empty list.
+*/
+
+/*!
+  \fn QSortedList::QSortedList( const QSortedList<type> &list )
+  Constructs a copy of \e list.
+
+  Each item in \e list is copied to this new list.
+*/
+
+/*!
+  \fn QSortedList::~QSortedList()
+  Removes all items from the list and destroys the list.
+
+  All list iterators that access this list will be reset.
+*/
+
+/*!
+  \fn QSortedList<type>& QSortedList::operator=(const QSortedList<type>& list)
+  Assigns \e list to this list and returns a reference to this list.
+
+  This list is first cleared, then each item in \e list is
+  appended to this list.  Only the pointers are copied
+  (shallow copy), unless newItem() has been reimplemented().
+*/
+
+/*!
+   \fn int QSortedList::compareItems( QCollection::Item s1, QCollection::Item s2 )
+
+   \reimp
+
+   This reimplementation uses operator< and operator== to compare.
+*/

qtools/qstack.doc

+/****************************************************************************
+** $Id$
+**
+** QStack class documentation
+**
+** Copyright (C) 1992-2000 Trolltech AS.  All rights reserved.
+**
+** This file is part of the Qt GUI Toolkit.
+**
+** This file may be distributed under the terms of the Q Public License
+** as defined by Trolltech AS of Norway and appearing in the file
+** LICENSE.QPL included in the packaging of this file.
+**
+** This file may be distributed and/or modified under the terms of the
+** GNU General Public License version 2 as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL included in the
+** packaging of this file.
+**
+** Licensees holding valid Qt Enterprise Edition or Qt Professional Edition
+** licenses may use this file in accordance with the Qt Commercial License
+** Agreement provided with the Software.
+**
+** This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
+** WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
+**
+** See http://www.trolltech.com/pricing.html or email sales@trolltech.com for
+**   information about Qt Commercial License Agreements.
+** See http://www.trolltech.com/qpl/ for QPL licensing information.
+** See http://www.trolltech.com/gpl/ for GPL licensing information.
+**
+** Contact info@trolltech.com if any conditions of this licensing are
+** not clear to you.
+**
+**********************************************************************/
+
+
+/*****************************************************************************
+  QStack documentation
+ *****************************************************************************/
+
+/*!
+  \class QStack qstack.h
+  \brief The QStack class is a template class that provides a stack.
+
+  \ingroup collection
+  \ingroup tools
+
+  QStack is implemented as a template class. Define a template
+  instance QStack\<X\> to create a stack that operates on pointers to
+  X, or X*.
+
+  A stack is a Last In, First Out (LIFO) structure. Items are added to
+  the top of the stack with push() and retrieved from the top
+  with pop().
+
+  \sa \link collection.html Collection Classes\endlink
+*/
+
+/*! \fn QStack::QStack () 
+  Creates and empty stack.
+*/
+
+/*! \fn QStack::QStack (const QStack<type>& s) 
+  Creates a stack by making a shallow copy of another stack.
+*/
+
+/*! \fn QStack::~QStack () 
+  Destroys the stack.  All items will be deleted if autoDelete() is TRUE.
+*/
+
+/*! \fn QStack<type>& QStack::operator= (const QStack<type>& s) 
+  Sets the contents of this stack by making a shallow copy of another stack.
+  Elements currently in this stack will be deleted if autoDelete() is TRUE.
+*/
+
+/*! \fn bool QStack::isEmpty () const 
+  Returns TRUE is the stack contains no elements to be \link pop() popped\endlink.
+*/
+
+/*! \fn void QStack::push (const type* d) 
+  Adds an element to the top of the stack.  Last in, first out.
+*/
+
+/*! \fn type* QStack::pop () 
+  Removes the top item from the stack and returns it.
+*/
+
+/*! \fn bool QStack::remove () 
+  Removes the top item from the stack and deletes it if
+  autoDelete() is TRUE.  Returns TRUE if there was an item to pop.
+
+  \sa clear()
+*/
+
+/*! \fn void QStack::clear()
+  Removes all items from the stack, deleting them if
+  autoDelete() is TRUE.
+
+  \sa remove()
+*/
+
+/*! \fn uint QStack::count() const
+  Returns the number of items in the stack.
+
+  \sa isEmpty()
+*/
+
+/*! \fn type* QStack::top () const 
+  Returns a reference to the top item on the stack (most recently pushed).
+  The stack is not changed.
+*/
+
+/*! \fn QStack::operator type* ()const 
+  Returns a reference to the top item on the stack (most recently pushed).
+  The stack is not changed.
+*/
+
+/*! \fn type* QStack::current () const 
+  Returns a reference to the top item on the stack (most recently pushed).
+  The stack is not changed.
+*/
+
+/*! \fn bool QStack::autoDelete() const
+
+  The same as QCollection::autoDelete().
+
+  \sa setAutoDelete()
+*/
+
+/*! \fn void QStack::setAutoDelete( bool enable ) 
+
+  The same as QCollection::setAutoDelete().
+ 
+  \sa autoDelete()
+*/

qtools/qstrlist.doc

+/****************************************************************************
+** $Id$
+*****************************************************************************/
+
+//typedef QListIterator<char> QStrListIterator;

qtools/qtl.doc

+/****************************************************************************
+** $Id$
+**
+** Qt template library classes documentation
+**
+** Copyright (C) 1992-2000 Trolltech AS.  All rights reserved.
+**
+** This file is part of the Qt GUI Toolkit.
+**
+** This file may be distributed under the terms of the Q Public License
+** as defined by Trolltech AS of Norway and appearing in the file
+** LICENSE.QPL included in the packaging of this file.
+**
+** This file may be distributed and/or modified under the terms of the
+** GNU General Public License version 2 as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL included in the
+** packaging of this file.
+**
+** Licensees holding valid Qt Enterprise Edition or Qt Professional Edition
+** licenses may use this file in accordance with the Qt Commercial License
+** Agreement provided with the Software.
+**
+** This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
+** WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
+**
+** See http://www.trolltech.com/pricing.html or email sales@trolltech.com for
+**   information about Qt Commercial License Agreements.
+** See http://www.trolltech.com/qpl/ for QPL licensing information.
+** See http://www.trolltech.com/gpl/ for GPL licensing information.
+**
+** Contact info@trolltech.com if any conditions of this licensing are
+** not clear to you.
+**
+**********************************************************************/
+
+/*!
+\page qtl.html
+
+\title Qt Template library
+
+Thq Qt Template Library is a set of templates within Qt dealing with
+containers of objects.  It provides a list of objects, a stack of
+objects, a map (or dictionary) from one type to another, and
+associated iterators and algorithms.
+
+Qt also contains similar classes that deal with pointers to objects;
+\l QValueList vs. \l QList, etc.  Compared to the pointer-based
+templates, the QTL offers easy copying of the container, real support
+for classes that e.g. require constructors, expand to much more object
+code, can often be a bit faster, require that the objects stored can
+be copied, and finally, have a worse record of compiler problems.
+
+Compared to the STL, the QTL contains only the most important features
+of the STL, has more regular function naming, has no platform
+differences, is often a little slower and often expands to less object
+code.
+
+
+If you can not make copies of the objects you want to store you are
+better off with QCollection and friends. They were designed to handle
+exactly that kind of pointer semantics. This applies for example to
+all classes derived from \l QObject. A QObject does not have a copy
+constructor, so using it as value is impossible. You may choose be
+store pointers to QObjects in a QValueList, but using QList directly
+seems to be the better choice for this kind of application
+domain. QList, like all other QCollection based containers, provides
+far more sanity checking than a speed-optimized value
+based container.
+
+If you have objects that implement value semantics, use the Qt
+template library.  Value semantics require at least
+<ul>
+<li>a copy constructor,
+<li>an assignment operator and
+<li> a default constructor, i.e. a constructor that does not take
+any arguments.
+</ul>
+Note that a fast copy constructor is absolutely crucial for a good
+overall performance of the container, since many copy operations are
+going to happen.
+
+Examples for value based classes are QRect, QPoint, QSize and all
+simple C++ types like int, bool or double.
+
+The Qt template library is designed for speed. Especially iterators
+are extremely fast. On the drawback side, less error checking is done
+than in the QCollection based containers. A template library container
+for example does not track associated iterators. This makes certain
+validity checks, like on removing items, impossible to perform
+automatically.
+
+<h2> Iterators </h2>
+
+The Qt template library deals with value objects, not with pointers.
+For that reason, there is no other way of iterating over containers
+than using iterators. This is no disadvantage as the size of an
+iterator matches the size of a normal pointer - 32 or 64 bits
+depending on your CPU architecture.
+
+To iterate over a container, use a loop like this:
+
+\code
+	typedef QValueList<int> List;
+	List l;
+	for( List::Iterator it = l.begin(); it != l.end(); ++it )
+		printf("Number is %i\n",*it);
+\endcode
+
+begin() returns the iterator pointing at the first element, while
+end() returns an iterator that points \e after the last
+element. end() marks an invalid position, it can never be
+dereferenced. It's the break condition in any iteration, may it be
+from begin() or fromLast(). For maximum speed, use increment or
+decrement iterators with the prefix operator (++it, --it) instead of the the
+postfix one (it++, it--), since the former is slightly faster.
+
+The same concept applies to the other container classes:
+
+\code
+	typedef QMap<QString,QString> Map;
+	Map map;
+	for( Map::Iterator it = map.begin(); it != map.end(); ++it )
+		printf("Key=%s Data=%s\n", it.key().ascii(), it.data().ascii() );
+
+	typedef QArray<int> Array;
+	Array array;
+	for( Array::Iterator it = array.begin(); it != array.end(); ++it )
+		printf("Data=%i\n", *it );
+\endcode
+
+There are two kind of iterators, the volatile iterator shown in the
+examples above and a version that returns a const reference to its
+current object, the ConstIterator. Const iterators are required
+whenever the container itself is const, such as a member variable
+inside a const function. Assigning a ConstIterator to a normal
+Iterator is not allowed as it would violate const semantics.
+
+<h2> Algorithms </h2>
+
+The template library defines a number of algorithms that operate on
+its containers: qHeapSort(), qBubbleSort(), qSwap() and
+qCopy(). These algorithms are implemented as template functions.
+
+qHeapSort() and qBubbleSort() provide the well known sorting
+algorithms. You can use them like this:
+
+\code
+	typedef QValueList<int> List;
+	List l;
+	l << 42 << 100 << 1234 << 12 << 8;
+	qHeapSort( l );
+	
+	List l2;
+	l2 << 42 << 100 << 1234 << 12 << 8;
+	List::Iterator b = l2.find( 100 );
+	List::Iterator e = l2.find( 8 );
+	qHeapSort( b, e );
+
+	double arr[] = { 3.2, 5.6, 8.9 };
+	qHeapSort( arr, arr + 3 );
+\endcode
+
+The first example sorts the entire list. The second one sorts all
+elements enclosed in the two iterators, namely 100, 1234 and 12.  The
+third example shows that iterators act like pointers and can be
+treated as such.
+
+Naturally, the sorting templates won't work with const iterators.
+
+Another utility is qSwap(). It exchanges the values of two variables:
+
+\code
+	QString second( "Einstein" );
+	QString name( "Albert" );
+	qSwap( second, name );
+\endcode
+
+Another template function is qCopy(). It copies a container or a slice
+of it to an OutputIterator, in this case a QTextOStreamIterator:
+
+\code
+	typedef QValueList<int> List;
+	List l;
+	l << 100 << 200 << 300;
+	QTextOStream str( stdout );
+	qCopy( l, QTextOStreamIterator( str ) );
+\endcode
+
+In addition, you can use any Qt template library iterator as the
+OutputIterator. Just make sure that the right hand of the iterator has
+as many elements present as you want to insert. The following example
+illustrates this:
+
+\code
+	QStringList l1, l2;
+	l1 << "Weis" << "Ettrich" << "Arnt" << "Sue";
+	l2 << "Torben" << "Matthias";
+	qCopy( l2, l1.begin();
+\endcode
+
+At the end of this code fragment, the List l1 contains "Torben",
+"Matthias", "Arnt" and "Sue", with the prior contents being
+overwritten. Another flavor of qCopy() takes three arguments to make
+it possible to copy a slice of a container:
+
+\code
+	typedef QValueList<int> List;
+	List l;
+	l << 42 << 100 << 1234 << 12 << 8;
+	List::Iterator b = l.find( 100 );
+	List::Iterator e = l.find( 8 );
+	QTextOStream str( stdout );
+	qCopy( b, e, QTextOStreamIterator( str ) );
+\endcode
+
+If you write new algorithms, consider writing them as template
+functions in order to make them usable with as many containers
+possible.  In the above example, you could just as easily print out a
+standard C++ array with qCopy():
+
+\code
+	int arr[] = { 100, 200, 300 };
+	QTextOStream str( stdout );
+	qCopy( arr, arr + 3, QTextOStreamIterator( str ) );	
+\endcode
+
+
+<h2> Streaming </h2>
+
+All mentioned containers can be serialized with the respective
+streaming operators. Here is an example.
+
+\code
+	QDataStream str(...);
+	QValueList<QRect> l;
+	// ... fill the list here
+	str << l;
+\endcode
+
+The container can be read in again with:
+
+\code
+	QValueList<QRect> l;
+	str >> l;
+\endcode
+
+The same applies to QStringList, QValueStack and QMap.
+
+*/

qtools/qvector.doc

+/****************************************************************************
+** $Id$
+**
+** QVector class documentation
+**
+** Copyright (C) 1992-2000 Trolltech AS.  All rights reserved.
+**
+** This file is part of the Qt GUI Toolkit.
+**
+** This file may be distributed under the terms of the Q Public License
+** as defined by Trolltech AS of Norway and appearing in the file
+** LICENSE.QPL included in the packaging of this file.
+**
+** This file may be distributed and/or modified under the terms of the
+** GNU General Public License version 2 as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL included in the
+** packaging of this file.
+**
+** Licensees holding valid Qt Enterprise Edition or Qt Professional Edition
+** licenses may use this file in accordance with the Qt Commercial License
+** Agreement provided with the Software.
+**
+** This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
+** WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
+**
+** See http://www.trolltech.com/pricing.html or email sales@trolltech.com for
+**   information about Qt Commercial License Agreements.
+** See http://www.trolltech.com/qpl/ for QPL licensing information.
+** See http://www.trolltech.com/gpl/ for GPL licensing information.
+**
+** Contact info@trolltech.com if any conditions of this licensing are
+** not clear to you.
+**
+**********************************************************************/
+
+
+/*****************************************************************************
+  QVector documentation
+ *****************************************************************************/
+
+// BEING REVISED: ettrich
+/*!
+  \class QVector qvector.h
+
+  \brief The QVector class is a template collection class that
+  provides a vector (array).
+
+  \ingroup tools
+
+  QVector is implemented as a template class. Define a template
+  instance QVector\<X\> to create a vector that contains pointers to
+  X, or X*.
+
+  A vector is the same as an array. The main difference between
+  QVector and QArray is that QVector stores pointers to the elements,
+  while QArray stores the elements themselves (i.e. QArray is
+  value-based).
+
+  Unless where otherwise stated, all functions that remove items from
+  the vector will also delete the element pointed to if auto-deletion
+  is enabled - see setAutoDelete(). By default, auto-deletion is
+  disabled. This behaviour can be changed in a subclass by
+  reimplementing the virtual method deleteItem().
+
+  Functions that compares items, e.g. find() and sort(), will do so
+  using the virtual function compareItems(). The default
+  implementation of this function will only compare the absolute
+  pointer values. Reimplement compareItems() in a subclass to get
+  searching and sorting based on the item contents.
+
+  \sa \link collection.html Collection Classes\endlink, QArray
+*/
+
+/*!
+  \fn QVector::QVector()
+
+  Constructs a null vector.
+
+  \sa isNull()
+*/
+
+/*!
+  \fn QVector::QVector( uint size )
+
+  Constructs an vector with room for \a size items.  Makes a null
+  vector if \a size == 0.
+
+  All \a size positions in the vector are initialized to 0.
+
+  \sa size(), resize(), isNull()
+*/
+
+/*!
+  \fn QVector::QVector( const QVector<type> &v )
+
+  Constructs a copy of \a v. Only the pointers are copied (i.e. shallow copy).
+*/
+
+/*!
+  \fn QVector::~QVector()
+
+  Removes all items from the vector, and destroys the vector itself.
+
+  \sa clear()
+*/
+
+/*!
+  \fn QVector<type> &QVector::operator=( const QVector<type> &v )
+
+  Assigns \a v to this vector and returns a reference to this vector.
+
+  This vector is first cleared, then all the items from \a v is copied
+  into this vector. Only the pointers are copied (i.e. shallow copy).
+
+  \sa clear()
+*/
+
+/*!
+  \fn type **QVector::data() const
+  Returns a pointer to the actual vector data, which is an array of type*.
+
+  The vector is a null vector if data() == 0 (null pointer).
+
+  \sa isNull()
+*/
+
+/*!
+  \fn uint QVector::size() const
+
+  Returns the size of the vector, i.e. the number of vector
+  positions. This is also the maximum number of items the vector can
+  hold.
+
+  The vector is a null vector if size() == 0.
+
+  \sa isNull(), resize(), count()
+*/
+
+/*!
+  \fn uint QVector::count() const 
+
+  Returns the number of items in the vector. The vector is empty if
+  count() == 0.
+
+  \sa isEmpty(), size()
+*/
+
+/*!
+  \fn bool QVector::isEmpty() const
+
+  Returns TRUE if the vector is empty, i.e. count() == 0, otherwise FALSE.
+
+  \sa count()
+*/
+
+/*!
+  \fn bool QVector::isNull() const
+
+  Returns TRUE if the vector is null, otherwise FALSE.
+
+  A null vector has size() == 0 and data() == 0.
+
+  \sa size()
+*/
+
+/*!
+  \fn bool QVector::resize( uint size )
+  Resizes (expands or shrinks) the vector to \a size elements. The array
+  becomes a null array if \a size == 0.
+
+  Any items in position \a size or beyond in the vector are removed.
+  New positions are initialized 0.
+
+  Returns TRUE if successful, or FALSE if the memory cannot be allocated.
+
+  \sa size(), isNull()
+*/
+
+/*!
+  \fn bool QVector::insert( uint i, const type *d )
+
+  Sets position \a i in the vector to contain the item \a d. \a i must
+  be less than size(). Any previous element in position \a i is removed.
+
+  \sa at()
+*/
+
+/*!
+  \fn bool QVector::remove( uint i )
+
+  Removes the item at position \a i in the vector, if there is one.
+  \a i must be less than size().
+
+  Returns TRUE unless \a i is out of range.
+
+  \sa take(), at()
+*/
+
+/*!
+  \fn type* QVector::take( uint i )
+
+  Returns the item at position \a i in the vector, and removes that
+  item from the vector. \a i must be less than size(). If there is no
+  item at position \a i, 0 is returned.
+
+  In contrast to remove(), this function does \e not call deleteItem()
+  for the removed item.
+
+  \sa remove(), at()
+*/
+
+/*!
+  \fn void QVector::clear()
+
+  Removes all items from the vector, and destroys the vector
+  itself.
+
+  The vector becomes a null vector.
+
+  \sa isNull()
+*/
+
+/*!
+  \fn bool QVector::fill( const type *d, int size )
+
+  Inserts item \a d in all positions in the vector. Any existing items
+  are removed. If \a d is 0, the vector becomes empty.
+
+  If \a size >= 0, the vector is first resized to \a size. By default,
+  \a size is -1.
+
+  Returns TRUE if successful, or FALSE if the memory cannot be allocated
+  (only if a resize has been requested).
+
+  \sa resize(), insert(), isEmpty()
+*/
+
+/*!
+  \fn void QVector::sort()
+
+  Sorts the items in ascending order. Any empty positions will be put
+  last.
+
+  Compares items using the virtual function compareItems().
+
+  \sa bsearch()
+*/
+
+/*!
+  \fn int QVector::bsearch( const type* d ) const
+
+  In a sorted array, finds the first occurrence of \a d using binary
+  search. For a sorted array, this is generally much faster than
+  find(), which does a linear search.
+
+  Returns the position of \a d, or -1 if \a d could not be found. \a d
+  may not be 0.
+
+  Compares items using the virtual function compareItems().
+
+  \sa sort(), find()
+*/
+
+
+/*!
+  \fn int QVector::findRef( const type *d, uint i ) const
+
+  Finds the first occurrence of the item pointer \a d in the vector,
+  using linear search. The search starts at position \a i, which must
+  be less than size(). \a i is by default 0; i.e. the search starts at
+  the start of the vector.
+
+  Returns the position of \a d, or -1 if \a d could not be found.
+
+  This function does \e not use compareItems() to compare items.
+
+  \sa find(), bsearch()
+*/
+
+/*!
+  \fn int QVector::find( const type *d, uint i ) const
+
+  Finds the first occurrence of item \a d in the vector, using linear
+  search. The search starts at position \a i, which must be less than
+  size(). \a i is by default 0; i.e. the search starts at the start of
+  the vector.
+
+  Returns the position of \e v, or -1 if \e v could not be found.
+
+  Compares items using the virtual function compareItems().
+
+  \sa findRef(), bsearch()
+*/
+
+
+/*!
+  \fn uint QVector::containsRef( const type *d ) const
+
+  Returns the number of occurrences of the item pointer \a d in the
+  vector.
+
+  This function does \e not use compareItems() to compare items.
+
+  \sa findRef()
+*/
+
+/*!
+  \fn uint QVector::contains( const type *d ) const
+
+  Returns the number of occurrences of item \a d in the vector.
+
+  Compares items using the virtual function compareItems().
+
+  \sa containsRef()
+*/
+
+/*!
+  \fn type *QVector::operator[]( int i ) const
+
+  Returns the item at position \a i, or 0 if there is no item at
+  that position. \a i must be less than size().
+
+  Equivalent to at( \a i ).
+
+  \sa at()
+*/
+
+/*!
+  \fn type *QVector::at( uint i ) const
+
+  Returns the item at position \a i, or 0 if there is no item at
+  that position. \a i must be less than size().
+*/
+
+
+/*!
+  \fn void QVector::toList( QGList *list ) const
+
+  Copies all items in this vector to the list \a list. First, \a list
+  is cleared, then all items are appended to \a list.
+
+  \sa QList, QStack, QQueue
+*/
+

src/classdef.cpp

@@ -1232,7 +1232,8 @@ void ClassDef::writeMemberList(OutputList &ol)
   ol.writeObjectLink(getReference(),getOutputFileBase(),0,name());
   parseText(ol,theTranslator->trIncludingInheritedMembers());
   
-  ol.startItemList();
+  //ol.startItemList();
+  ol.writeString("<table>\n");
   
   //MemberNameInfo *mni=m_allMemberNameInfoList->first();
   MemberNameInfoSDict::Iterator mnii(*m_allMemberNameInfoSDict); 
@@ -1244,17 +1245,6 @@ void ClassDef::writeMemberList(OutputList &ol)
     {
       MemberDef *md=mi->memberDef;
       ClassDef  *cd=md->getClassDef();
-      
-      // compute the protection level for this member
-      //Protection prot=md->protection();
-      //if (mi->prot==Protected) // inherited protection: Protected
-      //{
-      //  if (prot==Public) prot=Protected;
-      //}
-      //else if (mi->prot==Private) // inherited protection: Private
-      //{
-      //  prot=Private;
-      //}
       Protection prot = mi->prot;
       
       //printf("%s: Member %s of class %s md->protection()=%d mi->prot=%d prot=%d inherited=%d\n",
@@ -1268,23 +1258,15 @@ void ClassDef::writeMemberList(OutputList &ol)
         rmd  = rmd->reimplements();
       }
 
-      if (cd && !md->name().isEmpty() && md->name()[0]!='@' 
-          // && 
-          //(
-          // md->isFriend() 
-           // || 
-           //(/*mi->prot!=Private &&*/ 
-           // (prot!=Private || Config_getBool("EXTRACT_PRIVATE"))
-           //)
-          //)
-         )
+      if (cd && !md->name().isEmpty() && md->name()[0]!='@')
       {
         bool memberWritten=FALSE;
         if (cd->isLinkable() && md->isLinkable()) 
           // create a link to the documentation
         {
           QCString name=mi->ambiguityResolutionScope+md->name();
-          ol.writeListItem();
+          //ol.writeListItem();
+          ol.writeString("  <tr bgcolor=\"#f0f0f0\"><td>");
           ol.writeObjectLink(cd->getReference(),cd->getOutputFileBase(),
               md->anchor(),name);
           if ( md->isFunction() || md->isSignal() || md->isSlot() ||
@@ -1298,13 +1280,15 @@ void ClassDef::writeMemberList(OutputList &ol)
             ol.docify(" typedef");
           else if (md->isFriend() && !strcmp(md->typeString(),"friend class"))
             ol.docify(" class");
-          ol.writeString("\n");
+          //ol.writeString("\n");
+          ol.writeString("</td>");
           memberWritten=TRUE;
         }
         else if (!Config_getBool("HIDE_UNDOC_MEMBERS")) // no documentation, 
                                   // generate link to the class instead.
         {
-          ol.writeListItem();
+          //ol.writeListItem();
+          ol.writeString("  <tr bgcolor=\"#f0f0f0\"><td>");
           ol.startBold();
           ol.docify(md->name());
           ol.endBold();
@@ -1329,8 +1313,17 @@ void ClassDef::writeMemberList(OutputList &ol)
             ol.endBold();
           }
           ol.writeString(")");
+          ol.writeString("</td>");
           memberWritten=TRUE;
         }
+        if (memberWritten)
+        {
+          ol.writeString("<td>");
+          ol.writeObjectLink(cd->getReference(),cd->getOutputFileBase(),
+                             0,cd->name());
+          ol.writeString("</td>");
+          ol.writeString("<td>");
+        }
         if ((prot!=Public || virt!=Normal || 
              md->isFriend() || md->isRelated() || md->isExplicit() ||
              md->isMutable() || (md->isInline() && Config_getBool("INLINE_INFO")) ||
@@ -1368,11 +1361,19 @@ void ClassDef::writeMemberList(OutputList &ol)
           ol.docify("]");
           ol.endTypewriter();
         }
+        if (memberWritten)
+        {
+          ol.writeString("</td>");
+          ol.writeString("</tr>\n");
+        }
       }
       mi=mni->next();
     }
   }
-  ol.endItemList();
+  //ol.endItemList();
+
+  ol.writeString("</table>");
+  
   endFile(ol);
   ol.popGeneratorState();
 }

src/code.l

@@ -77,7 +77,6 @@ class CodeVarDef
     QCString classScope;
 };
 
-typedef QList<CodeClassDef> CodeClassList; 
 typedef QDict<CodeClassDef> CodeClassDict;
 typedef QList<CodeVarDef>   CodeVarList; 
 
@@ -86,7 +85,6 @@ typedef QList<CodeVarDef>   CodeVarList;
  */
   
 static OutputDocInterface * g_code;
-//static CodeClassList g_codeClassList;
 static CodeClassDict g_codeClassDict(1009);
 static CodeVarList   g_codeVarList;
 static CodeVarList   g_codeParmList;

src/doc.l

@@ -864,7 +864,7 @@ FILE      ({FILESCHAR}*{FILEECHAR}+("."{FILESCHAR}*{FILEECHAR}+)*)|("\""[^\n\"]+
 ID        [a-z_A-Z][a-z_A-Z0-9]*
 SCOPENAME (({ID}?{BN}*"::"{BN}*)*)((~{BN}*)?{ID})
 SCOPEMASK {ID}?(("::"|"#")?(~)?{ID})+
-URLMASK   [a-z_A-Z0-9\~\:\?\@\&\%\#\.\-\+\/\=]+
+URLMASK   ([^\>\"\n]+)|([a-z_A-Z0-9\~\:\?\@\&\%\#\.\-\+\/\=]+)
 NONTERM   [\{\}\[\]\`\~\@\|\-\+\#\$\/\\\!\%\^\&\*()a-z_A-Z<>0-9\x80-\xff]
 WORD      ({NONTERM}+([^\n\t ]*{NONTERM}+)?)|("\""[^\n\"]"\"")
 ATTR      ({B}+[^>\n]*)?

src/doxygen.cpp

@@ -2421,6 +2421,10 @@ static void findUsedClassesForClass(Entry *root,
           ClassDef *usedCd = Doxygen::hiddenClasses.find(type);
           if (usedCd==0 && !Config_getBool("HIDE_UNDOC_RELATIONS"))
           {
+             if (type.right(2)=="(*") // type is a function pointer
+             {
+               type+=md->argsString();
+             }
              Debug::print(Debug::Classes,0,"  New undocumented used class `%s'\n", type.data());
              usedCd = new ClassDef(
                masterCd->getDefFileName(),masterCd->getDefLine(),
@@ -5012,19 +5016,23 @@ static void generateClassDocs()
   for ( ; cli.current() ; ++cli )
   {
     ClassDef *cd=cli.current();
-    if ( cd->isLinkableInProject() && cd->templateMaster()==0 &&
-        (cd->getOuterScope()==0 || // <-- should not happen
-         cd->getOuterScope()==Doxygen::globalScope
-        )
-       ) // skip external references, anonymous compounds and 
-         // template instances and nested classes
+   
+    if (cd->getOuterScope()==0 || // <-- should not happen, but can if we read an old tag file
+        cd->getOuterScope()==Doxygen::globalScope // only look at global classes
+       ) 
     {
-      msg("Generating docs for compound %s...\n",cd->name().data());
-      
-      cd->writeDocumentation(*outputList);
-      cd->writeMemberList(*outputList);
+      // skip external references, anonymous compounds and 
+      // template instances 
+      if ( cd->isLinkableInProject() && cd->templateMaster()==0)
+      {
+        msg("Generating docs for compound %s...\n",cd->name().data());
+
+        cd->writeDocumentation(*outputList);
+        cd->writeMemberList(*outputList);
+      }
+      // even for undocumented classes, the inner classes can be documented.
+      cd->writeDocumentationForInnerClasses(*outputList);
     }
-    cd->writeDocumentationForInnerClasses(*outputList);
   }
 }
 
@@ -5607,6 +5615,7 @@ static void generateNamespaceDocs()
   
   NamespaceSDict::Iterator nli(Doxygen::namespaceSDict);
   NamespaceDef *nd;
+  // for each namespace...
   for (;(nd=nli.current());++nli)
   {
     if (nd->isLinkableInProject())
@@ -5614,12 +5623,12 @@ static void generateNamespaceDocs()
       msg("Generating docs for namespace %s\n",nd->name().data());
       nd->writeDocumentation(*outputList);
     }
-    ClassSDict::Iterator cli(Doxygen::classSDict);
+    // for each class in the namespace...
+    ClassSDict::Iterator cli(*nd->classSDict);
     for ( ; cli.current() ; ++cli )
     {
       ClassDef *cd=cli.current();
-      if ( cd->getOuterScope()==nd &&
-           cd->isLinkableInProject() && 
+      if ( cd->isLinkableInProject() && 
            cd->templateMaster()==0
          ) // skip external references, anonymous compounds and 
            // template instances and nested classes
@@ -6965,7 +6974,7 @@ void parseInput()
   msg("Building page list...\n");
   buildPageList(root);
 
-  msg("Buidling package list...\n");
+  msg("Building package list...\n");
   buildPackageList(root);
 
   msg("Search for main page...\n");

src/doxytag.l

@@ -391,6 +391,7 @@ QCString unhtmlify(const char *str)
 <ReadArgs>"&amp;"		   { memberArgs+="&"; }
 <ReadArgs>"&lt;"		   { memberArgs+="<"; }
 <ReadArgs>"&gt;"		   { memberArgs+=">"; }
+<ReadArgs>"&nbsp;"		   { memberArgs+=" "; }
   /*
 <ReadArgs>[{}]			   { // handle enums
   				     memberArgs.resize(0);

src/latexgen.cpp

@@ -1265,6 +1265,7 @@ void LatexGenerator::docify(const char *str)
   static bool isKorean    = theTranslator->idLanguage()=="korean";
   static bool isRussian   = theTranslator->idLanguage()=="russian";
   static bool isUkrainian = theTranslator->idLanguage()=="ukrainian";
+  static bool isChinese   = theTranslator->idLanguage()=="chinese";
   if (str)
   {
     const unsigned char *p=(const unsigned char *)str;
@@ -1329,9 +1330,9 @@ void LatexGenerator::docify(const char *str)
                      break;
 
           default:   
-
-             if (isJapanese || isKorean)
-             { // Japanese language uses wide characters
+             // Some languages uses wide characters
+             if (isJapanese || isKorean || isChinese)
+             { 
                if (c>=128) 
                {
                  t << (char)c;

src/scanner.l

@@ -3051,7 +3051,7 @@ CHARLIT   (("'"\\[0-7]{1,3}"'")|("'"\\."'")|("'"[^'\\\n]{1,4}"'"))
                                               );
   					  yyLineNr++;
   					}
-<PackageDocArg1>{SCOPENAME}		{
+<PackageDocArg1>{ID}("."{ID})*		{
   					  current->name = yytext;
 					  newDocState();
   					}

src/translator_ru.h

@@ -1069,6 +1069,8 @@ class TranslatorRussian : public Translator
         "class Undocumented { };\n\n"
         "/*!   */\n"
         "class PublicBase : public Truncated { };\n\n"
+        "/*!   */\n"
+        "template<class T> class Templ {};\n\n"
         "/*!   */\n"
         "class ProtectedBase { };\n\n"
         "/*!   */\n"
@@ -1079,25 +1081,26 @@ class TranslatorRussian : public Translator
         "class Inherited : public PublicBase,\n"
         "                  protected ProtectedBase,\n"
         "                  private PrivateBase,\n"
-        "                  public Undocumented\n"
+        "                  public Undocumented,\n"
+        "                  public Templ<int>\n"
         "{\n"
         "  private:\n"
         "    Used *m_usedClass;\n"
         "};\n"
         "\\endcode\n"
         " \\c MAX_DOT_GRAPH_HEIGHT    "
-        "  200,   :"
+        "  240,   :"
         "<p><center><img src=\"graph_legend.gif\"></center>\n"
         "<p>\n"
         "      :\n"
         "<ul>\n"
-        "<li>      , "
+        "<li>      , "
         "   .\n"
         "<li>        .\n"
         "<li>        .\n"
         "<li>        ,  \n"
         "    / .  , "
-        "      ."
+        "      .\n"
         "</ul>\n"
         "   :\n"
         "<ul>\n"
@@ -1109,6 +1112,9 @@ class TranslatorRussian : public Translator
         "     ."
         "   , "
         "      . \n"
+        "<li>        "
+        ",      .  "
+        "  .\n"
         "</ul>\n");
     }
     /*! text for the link to the legend page */

src/util.cpp

@@ -2638,12 +2638,15 @@ bool generateLink(OutputDocInterface &od,const char *clName,
   }
   else if ((gd=Doxygen::groupSDict[linkRef])) // link to a group
   {
-    od.startTextLink(gd->getOutputFileBase(),0);
-    if (lt)
-      od.docify(lt);
-    else
-      od.docify(gd->groupTitle());
-    od.endTextLink();
+    //od.startTextLink(gd->getOutputFileBase(),0);
+    //if (lt)
+    //  od.docify(lt);
+    //else
+    //  od.docify(gd->groupTitle());
+    //od.endTextLink();
+    QCString title;
+    if (lt) title=lt; else title=gd->groupTitle();
+    od.writeObjectLink(gd->getReference(),gd->getOutputFileBase(),0,title);  
     if (gd->isLinkableInProject())
     {
       writePageRef(od,gd->getOutputFileBase(),0);
@@ -3436,8 +3439,8 @@ found:
 void addRelatedPage(const char *name,const QCString &ptitle,
                            const QCString &doc,QList<QCString> *anchors,
                            const char *fileName,int startLine,
-                           int todoId,int testId,int bugId,GroupDef *gd=0,
-                           TagInfo *tagInfo=0
+                           int todoId,int testId,int bugId,GroupDef *gd,
+                           TagInfo *tagInfo
                           )
 {
   PageInfo *pi=0;
@@ -3509,7 +3512,7 @@ void addRelatedPage(const char *name,const QCString &ptitle,
 //----------------------------------------------------------------------------
 
 void addRefItem(int todoId,int testId,int bugId,const char *prefix,
-                        const char *name,const char *title,const char *args=0)
+                        const char *name,const char *title,const char *args)
 {
 
   //printf("addRefItem(%s) todoId=%d testId=%d bugId=%d\n",name,todoId,testId,bugId);