Automated update from Qt3

1 files changed, 20 insertions, 20 deletions

diff --git a/doc/object.doc b/doc/object.doc
index b5d6180c..79e75c50 100644
--- a/doc/object.doc
+++ b/doc/object.doc
@@ -1,10 +1,10 @@
 /****************************************************************************
 **
-** Explanation of the Qt object model
+** Explanation of the TQt object model
 **
 ** Copyright (C) 2000-2008 Trolltech ASA.  All rights reserved.
 **
-** This file is part of the Qt GUI Toolkit.
+** This file is part of the TQt GUI Toolkit.
 **
 ** This file may be used under the terms of the GNU General
 ** Public License versions 2.0 or 3.0 as published by the Free
@@ -13,7 +13,7 @@
 ** Alternatively you may (at your option) use any later version
 ** of the GNU General Public License if such license has been
 ** publicly approved by Trolltech ASA (or its successors, if any)
-** and the KDE Free Qt Foundation.
+** and the KDE Free TQt Foundation.
 **
 ** Please review the following information to ensure GNU General
 ** Public Licensing requirements will be met:
@@ -39,14 +39,14 @@
 /*!
 \page object.html
 
-\title Qt Object Model
+\title TQt Object Model
 
 The standard C++ Object Model provides very efficient runtime support
 for the object paradigm. But the C++ Object Model's static nature is
 inflexibile in certain problem domains. Graphical User Interface
 programming is a domain that requires both runtime efficiency and a
-high level of flexibility. Qt provides this, by combining the speed of
-C++ with the flexibility of the Qt Object Model.
+high level of flexibility. TQt provides this, by combining the speed of
+C++ with the flexibility of the TQt Object Model.
 
 Qt adds these features to C++:
 
@@ -68,7 +68,7 @@ Qt adds these features to C++:
   pointers which become "dangling pointers" when their objects are destroyed.
 \endlist
 
-Many of these Qt features are implemented with standard C++
+Many of these TQt features are implemented with standard C++
 techniques, based on inheritance from \l QObject. Others, like the
 object communication mechanism and the dynamic property system,
 require the \link metaobjects.html Meta Object System \endlink provided
@@ -78,7 +78,7 @@ The Meta Object System is a C++ extension that makes the language
 better suited to true component GUI programming. Although templates can
 be used to extend C++, the Meta Object System provides benefits using
 standard C++ that cannot be achieved with templates; see \link
-templates.html Why doesn't Qt use templates for signals and
+templates.html Why doesn't TQt use templates for signals and
 slots? \endlink.
 
 */
@@ -91,7 +91,7 @@ slots? \endlink.
 
 \title Timers
 
-\l QObject, the base class of all Qt objects, provides the basic timer
+\l QObject, the base class of all TQt objects, provides the basic timer
 support in Qt. With \l QObject::startTimer(), you start a timer with
 an \e interval in milliseconds as argument. The function returns a
 unique integer timer id. The timer will now "fire" every \e interval
@@ -217,7 +217,7 @@ single-threaded application without blocking the user interface.
 
 Qt provides a sophisticated property system similar to those supplied
 by some compiler vendors. However, as a compiler- and
-platform-independent library, Qt cannot rely on non-standard compiler
+platform-independent library, TQt cannot rely on non-standard compiler
 features like \c __property or \c [property]. Our solution works with
 \e any standard C++ compiler on every platform we support. It's based
 on the meta-object system that also provides object communication
@@ -251,7 +251,7 @@ the context specific font'.
 
 \i An attribute "designable" that indicates whether it makes sense to
 make the property available in a GUI builder (e.g. \link
-designer-manual.book Qt Designer\endlink). For most properties this 
+designer-manual.book TQt Designer\endlink). For most properties this 
 makes sense, but not for all, e.g. \l QButton::isDown(). The user can
 press buttons, and the application programmer can make the program
 press its own buttons, but a GUI design tool can't press buttons.
@@ -449,7 +449,7 @@ work.
 
 Some events come from the window system, e.g. \l QMouseEvent, some
 from other sources, e.g. \l QTimerEvent, and some come from the
-application program. Qt is symmetric, as usual, so you can send
+application program. TQt is symmetric, as usual, so you can send
 events in exactly the same ways as Qt's own event loop does.
 
 Most events types have special classes, most commonly \l QResizeEvent,
@@ -613,15 +613,15 @@ acts strangely.
 /*!
 \page templates.html
 
-\title Why doesn't Qt use templates for signals and slots?
+\title Why doesn't TQt use templates for signals and slots?
 
-A simple answer is that when Qt was designed, it was not possible to
+A simple answer is that when TQt was designed, it was not possible to
 fully exploit the template mechanism in multi-platform applications due
 to the inadequacies of various compilers. Even today, many widely used
 C++ compilers have problems with advanced templates. For example, you
 cannot safely rely on partial template instantiation, which is essential
 for some non-trivial problem domains. Thus Qt's usage of templates has
-to be rather conservative. Keep in mind that Qt is a multi-platform
+to be rather conservative. Keep in mind that TQt is a multi-platform
 toolkit, and progress on the Linux/g++ platform does not necessarily
 improve the situation elsewhere.
 
@@ -637,7 +637,7 @@ Syntax isn't just sugar: the syntax we use to express our algorithms can
 significantly affect the readability and maintainability of our code.
 The syntax used for Qt's signals and slots has proved very successful in
 practice. The syntax is intuitive, simple to use and easy to read.
-People learning Qt find the syntax helps them understand and utilize the
+People learning TQt find the syntax helps them understand and utilize the
 signals and slots concept -- despite its highly abstract and generic
 nature. Furthermore, declaring signals in class definitions ensures that
 the signals are protected in the sense of protected C++ member
@@ -705,7 +705,7 @@ runtime. We can establish connections using type-safe call-by-name,
 without having to know the exact types of the objects we are connecting.
 This is impossible with a template based solution. This kind of runtime
 introspection opens up new possibilities, for example GUIs that are
-generated and connected from Qt Designer's XML <tt>ui</tt> files. 
+generated and connected from TQt Designer's XML <tt>ui</tt> files. 
 
 <h3>4. Calling performance is not everything</h3>
 
@@ -713,7 +713,7 @@ Qt's signals and slots implementation is not as fast as a template-based
 solution. While emitting a signal is approximately the cost of four
 ordinary function calls with common template implementations, Qt
 requires effort comparable to about ten function calls. This is not
-surprising since the Qt mechanism includes a generic marshaller,
+surprising since the TQt mechanism includes a generic marshaller,
 introspection and ultimately scriptability. It does not rely on
 excessive inlining and code expansion and it provides unmatched runtime
 safety. Qt's iterators are safe while those of faster template-based
@@ -723,7 +723,7 @@ crashing. Without this safety, your application would eventually crash
 with a difficult to debug free'd memory read or write error.
 
 Nonetheless, couldn't a template-based solution improve the performance
-of an application using signals and slots? While it is true that Qt adds
+of an application using signals and slots? While it is true that TQt adds
 a small overhead to the cost of calling a slot through a signal, the
 cost of the call is only a small proportion of the entire cost of a
 slot. Benchmarking against Qt's signals and slots system is typically
@@ -758,6 +758,6 @@ powerful and introspective property system.
 C++ with the <tt>moc</tt> preprocessor essentially gives us the
 flexibility of Objective-C or of a Java Runtime Environment, while
 maintaining C++'s unique performance and scalability advantages. It is
-what makes Qt the flexible and comfortable tool we have today.
+what makes TQt the flexible and comfortable tool we have today.
 
 */