Commit 883b8458 authored by Dimitri van Heesch's avatar Dimitri van Heesch

Release-1.2.11-20011021

parent 3c05bde5
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)
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)
1.2.11-20011014
1.2.11-20011021
......@@ -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
......
......@@ -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
......
......@@ -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.
......
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
......
......@@ -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
#---------------------------------------------------------------------------
......
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
/****************************************************************************
** $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.
*/
/****************************************************************************
** $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()
*/
/****************************************************************************
** $Id$
*****************************************************************************/
//typedef QListIterator<char> QStrListIterator;
/****************************************************************************
** $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.
*/
This diff is collapsed.
/****************************************************************************
** $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
*/
......@@ -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();
}
......
......@@ -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;
......
......@@ -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]*)?
......
......@@ -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,20 +5016,24 @@ 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
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
)
) // skip external references, anonymous compounds and
// template instances and nested classes
{
// 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);
}
}
}
//----------------------------------------------------------------------------
......@@ -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");
......
......@@ -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);
......
......@@ -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;
......
......@@ -3051,7 +3051,7 @@ CHARLIT (("'"\\[0-7]{1,3}"'")|("'"\\."'")|("'"[^'\\\n]{1,4}"'"))
);
yyLineNr++;
}
<PackageDocArg1>{SCOPENAME} {
<PackageDocArg1>{ID}("."{ID})* {
current->name = yytext;
newDocState();
}
......
This diff is collapsed.
......@@ -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 */
......
This diff is collapsed.
......@@ -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);
......
This diff is collapsed.
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment