Replace various Q_* and QT_* defines with TQ_* and TQT_*

Signed-off-by: Michele Calgaro <michele.calgaro@yahoo.it>
pull/90/head
Michele Calgaro 1 year ago
parent e0a3cab446
commit 926102a455
Signed by: MicheleC
GPG Key ID: 2A75B7CA8ADED5CF

@ -11,9 +11,9 @@ $translator='FULLNAME <EMAIL@ADDRESS>';
$revision_date='YYYY-MM-DD'; $revision_date='YYYY-MM-DD';
$real_mark = "tr"; $real_mark = "tr";
$noop_mark = "QT_TR_NOOP"; $noop_mark = "TQT_TR_NOOP";
$scoped_mark = "qApp->translate"; $scoped_mark = "qApp->translate";
$noop_scoped_mark = "QT_TRANSLATE_NOOP"; $noop_scoped_mark = "TQT_TRANSLATE_NOOP";
$header= $header=
'# This is a TQt message file in .po format. Each msgid starts with '# This is a TQt message file in .po format. Each msgid starts with

20
configure vendored

@ -398,9 +398,9 @@ while [ "$#" -gt 0 ]; do
;; ;;
endian) endian)
if [ "$VAL" = "little" ]; then if [ "$VAL" = "little" ]; then
CFG_ENDIAN="Q_LITTLE_ENDIAN" CFG_ENDIAN="TQ_LITTLE_ENDIAN"
elif [ "$VAL" = "big" ]; then elif [ "$VAL" = "big" ]; then
CFG_ENDIAN="Q_BIG_ENDIAN" CFG_ENDIAN="TQ_BIG_ENDIAN"
else else
UNKNOWN_OPT=yes UNKNOWN_OPT=yes
fi fi
@ -2406,9 +2406,9 @@ if [ "$CFG_ENDIAN" = "auto" ]; then
if [ "$PLATFORM_MAC" = "yes" ]; then if [ "$PLATFORM_MAC" = "yes" ]; then
true true
elif $unixtests/endian.test $XQMAKESPEC $OPT_VERBOSE $relpath $outpath; then elif $unixtests/endian.test $XQMAKESPEC $OPT_VERBOSE $relpath $outpath; then
CFG_ENDIAN="Q_LITTLE_ENDIAN" CFG_ENDIAN="TQ_LITTLE_ENDIAN"
else else
CFG_ENDIAN="Q_BIG_ENDIAN" CFG_ENDIAN="TQ_BIG_ENDIAN"
fi fi
fi fi
@ -2989,28 +2989,28 @@ esac
cat >> $outpath/include/ntqconfig.h.new <<EOF cat >> $outpath/include/ntqconfig.h.new <<EOF
/* License information */ /* License information */
#define QT_PRODUCT_LICENSEE "$Licensee" #define TQT_PRODUCT_LICENSEE "$Licensee"
#define QT_PRODUCT_LICENSE "$Products" #define QT_PRODUCT_LICENSE "$Products"
/* Build key */ /* Build key */
#define TQT_BUILD_KEY "$TQT_BUILD_KEY" #define TQT_BUILD_KEY "$TQT_BUILD_KEY"
/* Machine byte-order */ /* Machine byte-order */
#define Q_BIG_ENDIAN 4321 #define TQ_BIG_ENDIAN 4321
#define Q_LITTLE_ENDIAN 1234 #define TQ_LITTLE_ENDIAN 1234
EOF EOF
if [ "$CFG_ENDIAN" = "auto" ]; then if [ "$CFG_ENDIAN" = "auto" ]; then
cat >> $outpath/include/ntqconfig.h.new << EOF cat >> $outpath/include/ntqconfig.h.new << EOF
#if defined(__BIG_ENDIAN__) #if defined(__BIG_ENDIAN__)
# define Q_BYTE_ORDER Q_BIG_ENDIAN # define TQ_BYTE_ORDER TQ_BIG_ENDIAN
#elif defined(__LITTLE_ENDIAN__) #elif defined(__LITTLE_ENDIAN__)
# define Q_BYTE_ORDER Q_LITTLE_ENDIAN # define TQ_BYTE_ORDER TQ_LITTLE_ENDIAN
#else #else
# message "Unable to determine byte order!" # message "Unable to determine byte order!"
#endif #endif
EOF EOF
else else
echo "#define Q_BYTE_ORDER $CFG_ENDIAN" >> $outpath/include/ntqconfig.h.new echo "#define TQ_BYTE_ORDER $CFG_ENDIAN" >> $outpath/include/ntqconfig.h.new
fi fi
cat >> $outpath/include/ntqconfig.h.new << EOF cat >> $outpath/include/ntqconfig.h.new << EOF

@ -125,7 +125,7 @@ public:
#ifdef TQ_FULL_TEMPLATE_INSTANTIATION #ifdef TQ_FULL_TEMPLATE_INSTANTIATION
// xlC 3.x workaround // xlC 3.x workaround
Q_DUMMY_COMPARISON_OPERATOR(Element) TQ_DUMMY_COMPARISON_OPERATOR(Element)
bool operator!=( const Element&amp; e) const { bool operator!=( const Element&amp; e) const {
return ( !(e == *this) ); return ( !(e == *this) );
} }

@ -93,7 +93,7 @@ public:
#ifdef TQ_FULL_TEMPLATE_INSTANTIATION #ifdef TQ_FULL_TEMPLATE_INSTANTIATION
// xlC 3.x workaround // xlC 3.x workaround
Q_DUMMY_COMPARISON_OPERATOR(Element) TQ_DUMMY_COMPARISON_OPERATOR(Element)
bool operator!=( const Element&amp; e) const { bool operator!=( const Element&amp; e) const {
return ( !(e == *this) ); return ( !(e == *this) );
} }

@ -71,7 +71,7 @@ a little-endian machine (e.g. x86) for a big-endian processor
(e.g. PowerPC) will use the host's endianness instead of the (e.g. PowerPC) will use the host's endianness instead of the
target's. Workaround: after running configure, and before running target's. Workaround: after running configure, and before running
make, edit <tt>$TQTDIR/include/ntqconfig.h</tt> and change the definition of make, edit <tt>$TQTDIR/include/ntqconfig.h</tt> and change the definition of
<tt>Q_BYTE_ORDER</tt>. <tt>TQ_BYTE_ORDER</tt>.
<p> <li> Enable framebuffer support. <p> <li> Enable framebuffer support.
<p> You may need to recompile your kernel to enable the framebuffer. <p> You may need to recompile your kernel to enable the framebuffer.
This document does not describe how to do this; the This document does not describe how to do this; the

@ -133,9 +133,9 @@ private:
} }
static const char* choices[] = { static const char* choices[] = {
QT_TRANSLATE_NOOP( "MyWidget", "First" ), TQT_TRANSLATE_NOOP( "MyWidget", "First" ),
QT_TRANSLATE_NOOP( "MyWidget", "Second" ), TQT_TRANSLATE_NOOP( "MyWidget", "Second" ),
QT_TRANSLATE_NOOP( "MyWidget", "Third" ), TQT_TRANSLATE_NOOP( "MyWidget", "Third" ),
0 0
}; };

@ -210,27 +210,27 @@ directly:
</pre> </pre>
<p> If you need to have translatable text completely <p> If you need to have translatable text completely
outside a function, there are two macros to help: QT_TR_NOOP() outside a function, there are two macros to help: TQT_TR_NOOP()
and QT_TRANSLATE_NOOP(). They merely mark the text for and TQT_TRANSLATE_NOOP(). They merely mark the text for
extraction by the <em>lupdate</em> utility described below. extraction by the <em>lupdate</em> utility described below.
The macros expand to just the text (without the context). The macros expand to just the text (without the context).
<p> Example of QT_TR_NOOP(): <p> Example of TQT_TR_NOOP():
<pre> <pre>
TQString FriendlyConversation::greeting( int greet_type ) TQString FriendlyConversation::greeting( int greet_type )
{ {
static const char* greeting_strings[] = { static const char* greeting_strings[] = {
QT_TR_NOOP( "Hello" ), TQT_TR_NOOP( "Hello" ),
QT_TR_NOOP( "Goodbye" ) TQT_TR_NOOP( "Goodbye" )
}; };
return tr( greeting_strings[greet_type] ); return tr( greeting_strings[greet_type] );
} }
</pre> </pre>
<p> Example of QT_TRANSLATE_NOOP(): <p> Example of TQT_TRANSLATE_NOOP():
<pre> <pre>
static const char* greeting_strings[] = { static const char* greeting_strings[] = {
QT_TRANSLATE_NOOP( "FriendlyConversation", "Hello" ), TQT_TRANSLATE_NOOP( "FriendlyConversation", "Hello" ),
QT_TRANSLATE_NOOP( "FriendlyConversation", "Goodbye" ) TQT_TRANSLATE_NOOP( "FriendlyConversation", "Goodbye" )
}; };
TQString FriendlyConversation::greeting( int greet_type ) TQString FriendlyConversation::greeting( int greet_type )

@ -140,24 +140,24 @@ body { background: #ffffff; color: black; }
logwid ); logwid );
} }
</pre> </pre>
<h5><a name="1-7-2"></a>Using QT_TR_NOOP() and QT_TRANSLATE_NOOP()</h5> <h5><a name="1-7-2"></a>Using TQT_TR_NOOP() and TQT_TRANSLATE_NOOP()</h5>
<p>If you need to have translatable text completely outside a function, there are two macros to help: QT_TR_NOOP() and QT_TRANSLATE_NOOP(). These macros merely mark the text for extraction by <a href="linguist-manual-2.html#2">lupdate</a>. The macros expand to just the text (without the context).</p> <p>If you need to have translatable text completely outside a function, there are two macros to help: TQT_TR_NOOP() and TQT_TRANSLATE_NOOP(). These macros merely mark the text for extraction by <a href="linguist-manual-2.html#2">lupdate</a>. The macros expand to just the text (without the context).</p>
<p>Example of QT_TR_NOOP():</p> <p>Example of TQT_TR_NOOP():</p>
<pre> <pre>
TQString FriendlyConversation::greeting( int greet_type ) TQString FriendlyConversation::greeting( int greet_type )
{ {
static const char* greeting_strings[] = { static const char* greeting_strings[] = {
QT_TR_NOOP( "Hello" ), TQT_TR_NOOP( "Hello" ),
QT_TR_NOOP( "Goodbye" ) TQT_TR_NOOP( "Goodbye" )
}; };
return tr( greeting_strings[greet_type] ); return tr( greeting_strings[greet_type] );
} }
</pre> </pre>
<p>Example of QT_TRANSLATE_NOOP():</p> <p>Example of TQT_TRANSLATE_NOOP():</p>
<pre> <pre>
static const char* greeting_strings[] = { static const char* greeting_strings[] = {
QT_TRANSLATE_NOOP( "FriendlyConversation", "Hello" ), TQT_TRANSLATE_NOOP( "FriendlyConversation", "Hello" ),
QT_TRANSLATE_NOOP( "FriendlyConversation", "Goodbye" ) TQT_TRANSLATE_NOOP( "FriendlyConversation", "Goodbye" )
}; };
TQString FriendlyConversation::greeting( int greet_type ) TQString FriendlyConversation::greeting( int greet_type )

@ -313,7 +313,7 @@ public:
virtual ~TQAccessibleObject(); virtual ~TQAccessibleObject();
TQRESULT queryInterface( const TQUuid &amp;, TQUnknownInterface** ); TQRESULT queryInterface( const TQUuid &amp;, TQUnknownInterface** );
Q_REFCOUNT TQ_REFCOUNT
bool isValid() const; bool isValid() const;

@ -113,7 +113,7 @@ class TQAxFactory : public TQAxFactoryInterface
public: public:
TQAxFactory( const TQUuid &amp;, const TQUuid &amp;); TQAxFactory( const TQUuid &amp;, const TQUuid &amp;);
virtual ~TQAxFactory(); virtual ~TQAxFactory();
Q_REFCOUNT; TQ_REFCOUNT;
TQRESULT queryInterface( const TQUuid &amp;iid, TQUnknownInterface **iface ); TQRESULT queryInterface( const TQUuid &amp;iid, TQUnknownInterface **iface );

@ -133,7 +133,7 @@ public:
:name(n), priority(p) {} :name(n), priority(p) {}
TQString name; TQString name;
TQ_UINT16 priority; TQ_UINT16 priority;
Q_DUMMY_COMPARISON_OPERATOR(MailServer) TQ_DUMMY_COMPARISON_OPERATOR(MailServer)
}; };
TQValueList&lt;MailServer&gt; mailServers() const; TQValueList&lt;MailServer&gt; mailServers() const;
@ -145,7 +145,7 @@ public:
TQ_UINT16 priority; TQ_UINT16 priority;
TQ_UINT16 weight; TQ_UINT16 weight;
TQ_UINT16 port; TQ_UINT16 port;
Q_DUMMY_COMPARISON_OPERATOR(Server) TQ_DUMMY_COMPARISON_OPERATOR(Server)
}; };
TQValueList&lt;Server&gt; servers() const; TQValueList&lt;Server&gt; servers() const;

@ -282,12 +282,12 @@ body { background: #ffffff; color: black; }
# define Q_CC_MSVC # define Q_CC_MSVC
/* proper support of bool for _MSC_VER &gt;= 1100 */ /* proper support of bool for _MSC_VER &gt;= 1100 */
# define Q_CANNOT_DELETE_CONSTANT # define Q_CANNOT_DELETE_CONSTANT
# define Q_INLINE_TEMPLATES inline # define TQ_INLINE_TEMPLATES inline
/* Visual C++.Net issues for _MSC_VER &gt;= 1300 */ /* Visual C++.Net issues for _MSC_VER &gt;= 1300 */
# if _MSC_VER &gt;= 1300 # if _MSC_VER &gt;= 1300
# define Q_CC_MSVC_NET # define Q_CC_MSVC_NET
# if _MSC_VER &lt; 1310 || (defined(Q_OS_WIN64) &amp;&amp; defined(_M_IA64)) # if _MSC_VER &lt; 1310 || (defined(Q_OS_WIN64) &amp;&amp; defined(_M_IA64))
# define Q_TYPENAME # define TQ_TYPENAME
# endif # endif
# endif # endif
/* Intel C++ disguising as Visual C++: the `using' keyword avoids warnings */ /* Intel C++ disguising as Visual C++: the `using' keyword avoids warnings */
@ -312,7 +312,7 @@ body { background: #ffffff; color: black; }
# define Q_CC_WAT # define Q_CC_WAT
# if defined(Q_OS_QNX4) # if defined(Q_OS_QNX4)
/* compiler flags */ /* compiler flags */
# define Q_TYPENAME # define TQ_TYPENAME
# define Q_NO_BOOL_TYPE # define Q_NO_BOOL_TYPE
# define Q_CANNOT_DELETE_CONSTANT # define Q_CANNOT_DELETE_CONSTANT
# define mutable # define mutable
@ -391,8 +391,8 @@ body { background: #ffffff; color: black; }
# define Q_NO_BOOL_TYPE # define Q_NO_BOOL_TYPE
# define Q_NO_EXPLICIT_KEYWORD # define Q_NO_EXPLICIT_KEYWORD
# define Q_NO_USING_KEYWORD # define Q_NO_USING_KEYWORD
# define Q_TYPENAME # define TQ_TYPENAME
# define Q_INLINE_TEMPLATES inline # define TQ_INLINE_TEMPLATES inline
# define Q_BROKEN_TEMPLATE_SPECIALIZATION # define Q_BROKEN_TEMPLATE_SPECIALIZATION
# define Q_CANNOT_DELETE_CONSTANT # define Q_CANNOT_DELETE_CONSTANT
# endif # endif
@ -420,12 +420,12 @@ body { background: #ffffff; color: black; }
/* Apply to all versions prior to Compaq C++ V6.0-000 - observed on /* Apply to all versions prior to Compaq C++ V6.0-000 - observed on
DEC C++ V5.5-004. */ DEC C++ V5.5-004. */
# if __DECCXX_VER &lt; 60060000 # if __DECCXX_VER &lt; 60060000
# define Q_TYPENAME # define TQ_TYPENAME
# define Q_BROKEN_TEMPLATE_SPECIALIZATION # define Q_BROKEN_TEMPLATE_SPECIALIZATION
# define Q_CANNOT_DELETE_CONSTANT # define Q_CANNOT_DELETE_CONSTANT
# endif # endif
/* avoid undefined symbol problems with out-of-line template members */ /* avoid undefined symbol problems with out-of-line template members */
# define Q_INLINE_TEMPLATES inline # define TQ_INLINE_TEMPLATES inline
/* Compilers with EDG front end are similar. To detect them we test: /* Compilers with EDG front end are similar. To detect them we test:
__EDG documented by SGI, observed on MIPSpro 7.3.1.1 and KAI C++ 4.0b __EDG documented by SGI, observed on MIPSpro 7.3.1.1 and KAI C++ 4.0b
@ -482,7 +482,7 @@ body { background: #ffffff; color: black; }
# define Q_CC_USLC # define Q_CC_USLC
/* The latest UDK 7.1.1b does not need this, but previous versions do */ /* The latest UDK 7.1.1b does not need this, but previous versions do */
# if !defined(__SCO_VERSION__) || (__SCO_VERSION__ &lt; 302200010) # if !defined(__SCO_VERSION__) || (__SCO_VERSION__ &lt; 302200010)
# define Q_INLINE_TEMPLATES inline # define TQ_INLINE_TEMPLATES inline
# endif # endif
# define Q_NO_USING_KEYWORD /* ### check "using" status */ # define Q_NO_USING_KEYWORD /* ### check "using" status */
@ -505,12 +505,12 @@ body { background: #ffffff; color: black; }
# elif defined(__sgi) # elif defined(__sgi)
# define Q_CC_MIPS # define Q_CC_MIPS
# if defined(_MIPS_SIM) &amp;&amp; (_MIPS_SIM == _ABIO32) /* o32 ABI */ # if defined(_MIPS_SIM) &amp;&amp; (_MIPS_SIM == _ABIO32) /* o32 ABI */
# define Q_TYPENAME # define TQ_TYPENAME
# define Q_BROKEN_TEMPLATE_SPECIALIZATION # define Q_BROKEN_TEMPLATE_SPECIALIZATION
# define Q_NO_EXPLICIT_KEYWORD # define Q_NO_EXPLICIT_KEYWORD
# define Q_INLINE_TEMPLATES inline # define TQ_INLINE_TEMPLATES inline
# elif defined(_COMPILER_VERSION) &amp;&amp; (_COMPILER_VERSION &lt; 730) /* 7.2 */ # elif defined(_COMPILER_VERSION) &amp;&amp; (_COMPILER_VERSION &lt; 730) /* 7.2 */
# define Q_TYPENAME # define TQ_TYPENAME
# define Q_BROKEN_TEMPLATE_SPECIALIZATION # define Q_BROKEN_TEMPLATE_SPECIALIZATION
# endif # endif
# define Q_NO_USING_KEYWORD /* ### check "using" status */ # define Q_NO_USING_KEYWORD /* ### check "using" status */
@ -522,11 +522,11 @@ body { background: #ffffff; color: black; }
/* The older UnixWare 2.X compiler? */ /* The older UnixWare 2.X compiler? */
#elif defined(__USLC__) #elif defined(__USLC__)
# define Q_CC_USLC # define Q_CC_USLC
# define Q_TYPENAME # define TQ_TYPENAME
# define Q_NO_BOOL_TYPE # define Q_NO_BOOL_TYPE
# define Q_NO_EXPLICIT_KEYWORD # define Q_NO_EXPLICIT_KEYWORD
# define Q_NO_USING_KEYWORD # define Q_NO_USING_KEYWORD
# define Q_INLINE_TEMPLATES inline # define TQ_INLINE_TEMPLATES inline
/* Never tested! */ /* Never tested! */
#elif defined(__HIGHC__) #elif defined(__HIGHC__)
@ -954,12 +954,12 @@ Q_EXPORT int qWinVersion();
#define QT_WA_INLINE( uni, ansi ) ( uni ) #define QT_WA_INLINE( uni, ansi ) ( uni )
#endif #endif
#ifndef Q_INLINE_TEMPLATES #ifndef TQ_INLINE_TEMPLATES
# define Q_INLINE_TEMPLATES # define TQ_INLINE_TEMPLATES
#endif #endif
#ifndef Q_TYPENAME #ifndef TQ_TYPENAME
# define Q_TYPENAME typename # define TQ_TYPENAME typename
#endif #endif
// //
@ -1082,13 +1082,13 @@ Q_EXPORT const char *tqInstallPathSysconf();
mandating a real implementation. mandating a real implementation.
*/ */
#ifdef TQ_FULL_TEMPLATE_INSTANTIATION #ifdef TQ_FULL_TEMPLATE_INSTANTIATION
# define Q_DUMMY_COMPARISON_OPERATOR(C) \ # define TQ_DUMMY_COMPARISON_OPERATOR(C) \
bool operator==( const C&amp; ) const { \ bool operator==( const C&amp; ) const { \
tqWarning( #C"::operator==( const "#C"&amp; ) got called." ); \ tqWarning( #C"::operator==( const "#C"&amp; ) got called." ); \
return FALSE; \ return FALSE; \
} }
#else #else
# define Q_DUMMY_COMPARISON_OPERATOR(C) # define TQ_DUMMY_COMPARISON_OPERATOR(C)
#endif #endif
#endif /* TQGLOBAL_H */ #endif /* TQGLOBAL_H */

@ -126,7 +126,7 @@ public:
static const TQSize&amp; iconSize( Size which ); static const TQSize&amp; iconSize( Size which );
#ifndef Q_QDOC #ifndef Q_QDOC
Q_DUMMY_COMPARISON_OPERATOR(TQIconSet) TQ_DUMMY_COMPARISON_OPERATOR(TQIconSet)
#endif #endif
private: private:

@ -202,7 +202,7 @@ public:
}; };
template &lt;class K, class T&gt; template &lt;class K, class T&gt;
Q_INLINE_TEMPLATES int TQMapIterator&lt;K,T&gt;::inc() TQ_INLINE_TEMPLATES int TQMapIterator&lt;K,T&gt;::inc()
{ {
TQMapNodeBase* tmp = node; TQMapNodeBase* tmp = node;
if ( tmp-&gt;right ) { if ( tmp-&gt;right ) {
@ -223,7 +223,7 @@ Q_INLINE_TEMPLATES int TQMapIterator&lt;K,T&gt;::inc()
} }
template &lt;class K, class T&gt; template &lt;class K, class T&gt;
Q_INLINE_TEMPLATES int TQMapIterator&lt;K,T&gt;::dec() TQ_INLINE_TEMPLATES int TQMapIterator&lt;K,T&gt;::dec()
{ {
TQMapNodeBase* tmp = node; TQMapNodeBase* tmp = node;
if (tmp-&gt;color == TQMapNodeBase::Red &amp;&amp; if (tmp-&gt;color == TQMapNodeBase::Red &amp;&amp;
@ -318,7 +318,7 @@ public:
}; };
template &lt;class K, class T&gt; template &lt;class K, class T&gt;
Q_INLINE_TEMPLATES int TQMapConstIterator&lt;K,T&gt;::inc() TQ_INLINE_TEMPLATES int TQMapConstIterator&lt;K,T&gt;::inc()
{ {
TQMapNodeBase* tmp = node; TQMapNodeBase* tmp = node;
if ( tmp-&gt;right ) { if ( tmp-&gt;right ) {
@ -339,7 +339,7 @@ Q_INLINE_TEMPLATES int TQMapConstIterator&lt;K,T&gt;::inc()
} }
template &lt;class K, class T&gt; template &lt;class K, class T&gt;
Q_INLINE_TEMPLATES int TQMapConstIterator&lt;K,T&gt;::dec() TQ_INLINE_TEMPLATES int TQMapConstIterator&lt;K,T&gt;::dec()
{ {
TQMapNodeBase* tmp = node; TQMapNodeBase* tmp = node;
if (tmp-&gt;color == TQMapNodeBase::Red &amp;&amp; if (tmp-&gt;color == TQMapNodeBase::Red &amp;&amp;
@ -467,14 +467,14 @@ protected:
template &lt;class Key, class T&gt; template &lt;class Key, class T&gt;
Q_INLINE_TEMPLATES TQMapPrivate&lt;Key,T&gt;::TQMapPrivate() { TQ_INLINE_TEMPLATES TQMapPrivate&lt;Key,T&gt;::TQMapPrivate() {
header = new Node; header = new Node;
header-&gt;color = TQMapNodeBase::Red; // Mark the header header-&gt;color = TQMapNodeBase::Red; // Mark the header
header-&gt;parent = 0; header-&gt;parent = 0;
header-&gt;left = header-&gt;right = header; header-&gt;left = header-&gt;right = header;
} }
template &lt;class Key, class T&gt; template &lt;class Key, class T&gt;
Q_INLINE_TEMPLATES TQMapPrivate&lt;Key,T&gt;::TQMapPrivate( const TQMapPrivate&lt; Key, T &gt;* _map ) : TQMapPrivateBase( _map ) { TQ_INLINE_TEMPLATES TQMapPrivate&lt;Key,T&gt;::TQMapPrivate( const TQMapPrivate&lt; Key, T &gt;* _map ) : TQMapPrivateBase( _map ) {
header = new Node; header = new Node;
header-&gt;color = TQMapNodeBase::Red; // Mark the header header-&gt;color = TQMapNodeBase::Red; // Mark the header
if ( _map-&gt;header-&gt;parent == 0 ) { if ( _map-&gt;header-&gt;parent == 0 ) {
@ -489,7 +489,7 @@ Q_INLINE_TEMPLATES TQMapPrivate&lt;Key,T&gt;::TQMapPrivate( const TQMapPrivate&l
} }
template &lt;class Key, class T&gt; template &lt;class Key, class T&gt;
Q_INLINE_TEMPLATES Q_TYPENAME TQMapPrivate&lt;Key,T&gt;::NodePtr TQMapPrivate&lt;Key,T&gt;::copy( Q_TYPENAME TQMapPrivate&lt;Key,T&gt;::NodePtr p ) TQ_INLINE_TEMPLATES TQ_TYPENAME TQMapPrivate&lt;Key,T&gt;::NodePtr TQMapPrivate&lt;Key,T&gt;::copy( TQ_TYPENAME TQMapPrivate&lt;Key,T&gt;::NodePtr p )
{ {
if ( !p ) if ( !p )
return 0; return 0;
@ -511,7 +511,7 @@ Q_INLINE_TEMPLATES Q_TYPENAME TQMapPrivate&lt;Key,T&gt;::NodePtr TQMapPrivate&lt
} }
template &lt;class Key, class T&gt; template &lt;class Key, class T&gt;
Q_INLINE_TEMPLATES void TQMapPrivate&lt;Key,T&gt;::clear() TQ_INLINE_TEMPLATES void TQMapPrivate&lt;Key,T&gt;::clear()
{ {
clear( (NodePtr)(header-&gt;parent) ); clear( (NodePtr)(header-&gt;parent) );
header-&gt;color = TQMapNodeBase::Red; header-&gt;color = TQMapNodeBase::Red;
@ -521,7 +521,7 @@ Q_INLINE_TEMPLATES void TQMapPrivate&lt;Key,T&gt;::clear()
} }
template &lt;class Key, class T&gt; template &lt;class Key, class T&gt;
Q_INLINE_TEMPLATES void TQMapPrivate&lt;Key,T&gt;::clear( Q_TYPENAME TQMapPrivate&lt;Key,T&gt;::NodePtr p ) TQ_INLINE_TEMPLATES void TQMapPrivate&lt;Key,T&gt;::clear( TQ_TYPENAME TQMapPrivate&lt;Key,T&gt;::NodePtr p )
{ {
while ( p != 0 ) { while ( p != 0 ) {
clear( (NodePtr)p-&gt;right ); clear( (NodePtr)p-&gt;right );
@ -532,7 +532,7 @@ Q_INLINE_TEMPLATES void TQMapPrivate&lt;Key,T&gt;::clear( Q_TYPENAME TQMapPrivat
} }
template &lt;class Key, class T&gt; template &lt;class Key, class T&gt;
Q_INLINE_TEMPLATES Q_TYPENAME TQMapPrivate&lt;Key,T&gt;::ConstIterator TQMapPrivate&lt;Key,T&gt;::find(const Key&amp; k) const TQ_INLINE_TEMPLATES TQ_TYPENAME TQMapPrivate&lt;Key,T&gt;::ConstIterator TQMapPrivate&lt;Key,T&gt;::find(const Key&amp; k) const
{ {
TQMapNodeBase* y = header; // Last node TQMapNodeBase* y = header; // Last node
TQMapNodeBase* x = header-&gt;parent; // Root node. TQMapNodeBase* x = header-&gt;parent; // Root node.
@ -555,7 +555,7 @@ Q_INLINE_TEMPLATES Q_TYPENAME TQMapPrivate&lt;Key,T&gt;::ConstIterator TQMapPriv
} }
template &lt;class Key, class T&gt; template &lt;class Key, class T&gt;
Q_INLINE_TEMPLATES Q_TYPENAME TQMapPrivate&lt;Key,T&gt;::Iterator TQMapPrivate&lt;Key,T&gt;::insertSingle( const Key&amp; k ) TQ_INLINE_TEMPLATES TQ_TYPENAME TQMapPrivate&lt;Key,T&gt;::Iterator TQMapPrivate&lt;Key,T&gt;::insertSingle( const Key&amp; k )
{ {
// Search correct position in the tree // Search correct position in the tree
TQMapNodeBase* y = header; TQMapNodeBase* y = header;
@ -586,7 +586,7 @@ Q_INLINE_TEMPLATES Q_TYPENAME TQMapPrivate&lt;Key,T&gt;::Iterator TQMapPrivate&l
template &lt;class Key, class T&gt; template &lt;class Key, class T&gt;
Q_INLINE_TEMPLATES Q_TYPENAME TQMapPrivate&lt;Key,T&gt;::Iterator TQMapPrivate&lt;Key,T&gt;::insert( TQMapNodeBase* x, TQMapNodeBase* y, const Key&amp; k ) TQ_INLINE_TEMPLATES TQ_TYPENAME TQMapPrivate&lt;Key,T&gt;::Iterator TQMapPrivate&lt;Key,T&gt;::insert( TQMapNodeBase* x, TQMapNodeBase* y, const Key&amp; k )
{ {
NodePtr z = new Node( k ); NodePtr z = new Node( k );
if (y == header || x != 0 || k &lt; key(y) ) { if (y == header || x != 0 || k &lt; key(y) ) {
@ -612,15 +612,15 @@ Q_INLINE_TEMPLATES Q_TYPENAME TQMapPrivate&lt;Key,T&gt;::Iterator TQMapPrivate&l
#ifdef QT_CHECK_RANGE #ifdef QT_CHECK_RANGE
# if !defined( TQT_NO_DEBUG ) &amp;&amp; defined( QT_CHECK_MAP_RANGE ) # if !defined( TQT_NO_DEBUG ) &amp;&amp; defined( QT_CHECK_MAP_RANGE )
# define QT_CHECK_INVALID_MAP_ELEMENT if ( empty() ) tqWarning( "TQMap: Warning invalid element" ) # define TQT_CHECK_INVALID_MAP_ELEMENT if ( empty() ) tqWarning( "TQMap: Warning invalid element" )
# define QT_CHECK_INVALID_MAP_ELEMENT_FATAL Q_ASSERT( !empty() ); # define TQT_CHECK_INVALID_MAP_ELEMENT_FATAL Q_ASSERT( !empty() );
# else # else
# define QT_CHECK_INVALID_MAP_ELEMENT # define TQT_CHECK_INVALID_MAP_ELEMENT
# define QT_CHECK_INVALID_MAP_ELEMENT_FATAL # define TQT_CHECK_INVALID_MAP_ELEMENT_FATAL
# endif # endif
#else #else
# define QT_CHECK_INVALID_MAP_ELEMENT # define TQT_CHECK_INVALID_MAP_ELEMENT
# define QT_CHECK_INVALID_MAP_ELEMENT_FATAL # define TQT_CHECK_INVALID_MAP_ELEMENT_FATAL
#endif #endif
template &lt;class T&gt; class TQDeepCopy; template &lt;class T&gt; class TQDeepCopy;
@ -670,7 +670,7 @@ public:
TQMap( const std::map&lt;Key,T&gt;&amp; m ) TQMap( const std::map&lt;Key,T&gt;&amp; m )
{ {
sh = new TQMapPrivate&lt;Key,T&gt;; sh = new TQMapPrivate&lt;Key,T&gt;;
Q_TYPENAME std::map&lt;Key,T&gt;::const_iterator it = m.begin(); TQ_TYPENAME std::map&lt;Key,T&gt;::const_iterator it = m.begin();
for ( ; it != m.end(); ++it ) { for ( ; it != m.end(); ++it ) {
value_type p( (*it).first, (*it).second ); value_type p( (*it).first, (*it).second );
insert( p ); insert( p );
@ -687,7 +687,7 @@ public:
TQMap&lt;Key,T&gt;&amp; operator= ( const std::map&lt;Key,T&gt;&amp; m ) TQMap&lt;Key,T&gt;&amp; operator= ( const std::map&lt;Key,T&gt;&amp; m )
{ {
clear(); clear();
Q_TYPENAME std::map&lt;Key,T&gt;::const_iterator it = m.begin(); TQ_TYPENAME std::map&lt;Key,T&gt;::const_iterator it = m.begin();
for ( ; it != m.end(); ++it ) { for ( ; it != m.end(); ++it ) {
value_type p( (*it).first, (*it).second ); value_type p( (*it).first, (*it).second );
insert( p ); insert( p );
@ -737,7 +737,7 @@ public:
const_iterator find ( const Key&amp; k ) const { return sh-&gt;find( k ); } const_iterator find ( const Key&amp; k ) const { return sh-&gt;find( k ); }
const T&amp; operator[] ( const Key&amp; k ) const const T&amp; operator[] ( const Key&amp; k ) const
{ QT_CHECK_INVALID_MAP_ELEMENT; return sh-&gt;find( k ).data(); } { TQT_CHECK_INVALID_MAP_ELEMENT; return sh-&gt;find( k ).data(); }
bool contains ( const Key&amp; k ) const bool contains ( const Key&amp; k ) const
{ return find( k ) != end(); } { return find( k ) != end(); }
//{ return sh-&gt;find( k ) != ((const Priv*)sh)-&gt;end(); } //{ return sh-&gt;find( k ) != ((const Priv*)sh)-&gt;end(); }
@ -785,7 +785,7 @@ private:
}; };
template&lt;class Key, class T&gt; template&lt;class Key, class T&gt;
Q_INLINE_TEMPLATES TQMap&lt;Key,T&gt;&amp; TQMap&lt;Key,T&gt;::operator= ( const TQMap&lt;Key,T&gt;&amp; m ) TQ_INLINE_TEMPLATES TQMap&lt;Key,T&gt;&amp; TQMap&lt;Key,T&gt;::operator= ( const TQMap&lt;Key,T&gt;&amp; m )
{ {
m.sh-&gt;ref(); m.sh-&gt;ref();
if ( sh-&gt;deref() ) if ( sh-&gt;deref() )
@ -795,7 +795,7 @@ Q_INLINE_TEMPLATES TQMap&lt;Key,T&gt;&amp; TQMap&lt;Key,T&gt;::operator= ( const
} }
template&lt;class Key, class T&gt; template&lt;class Key, class T&gt;
Q_INLINE_TEMPLATES Q_TYPENAME TQMap&lt;Key,T&gt;::insert_pair TQMap&lt;Key,T&gt;::insert( const Q_TYPENAME TQMap&lt;Key,T&gt;::value_type&amp; x ) TQ_INLINE_TEMPLATES TQ_TYPENAME TQMap&lt;Key,T&gt;::insert_pair TQMap&lt;Key,T&gt;::insert( const TQ_TYPENAME TQMap&lt;Key,T&gt;::value_type&amp; x )
{ {
detach(); detach();
size_type n = size(); size_type n = size();
@ -809,7 +809,7 @@ Q_INLINE_TEMPLATES Q_TYPENAME TQMap&lt;Key,T&gt;::insert_pair TQMap&lt;Key,T&gt;
} }
template&lt;class Key, class T&gt; template&lt;class Key, class T&gt;
Q_INLINE_TEMPLATES void TQMap&lt;Key,T&gt;::erase( const Key&amp; k ) TQ_INLINE_TEMPLATES void TQMap&lt;Key,T&gt;::erase( const Key&amp; k )
{ {
detach(); detach();
iterator it( sh-&gt;find( k ).node ); iterator it( sh-&gt;find( k ).node );
@ -818,7 +818,7 @@ Q_INLINE_TEMPLATES void TQMap&lt;Key,T&gt;::erase( const Key&amp; k )
} }
template&lt;class Key, class T&gt; template&lt;class Key, class T&gt;
Q_INLINE_TEMPLATES Q_TYPENAME TQMap&lt;Key,T&gt;::size_type TQMap&lt;Key,T&gt;::count( const Key&amp; k ) const TQ_INLINE_TEMPLATES TQ_TYPENAME TQMap&lt;Key,T&gt;::size_type TQMap&lt;Key,T&gt;::count( const Key&amp; k ) const
{ {
const_iterator it( sh-&gt;find( k ).node ); const_iterator it( sh-&gt;find( k ).node );
if ( it != end() ) { if ( it != end() ) {
@ -833,7 +833,7 @@ Q_INLINE_TEMPLATES Q_TYPENAME TQMap&lt;Key,T&gt;::size_type TQMap&lt;Key,T&gt;::
} }
template&lt;class Key, class T&gt; template&lt;class Key, class T&gt;
Q_INLINE_TEMPLATES T&amp; TQMap&lt;Key,T&gt;::operator[] ( const Key&amp; k ) TQ_INLINE_TEMPLATES T&amp; TQMap&lt;Key,T&gt;::operator[] ( const Key&amp; k )
{ {
detach(); detach();
TQMapNode&lt;Key,T&gt;* p = sh-&gt;find( k ).node; TQMapNode&lt;Key,T&gt;* p = sh-&gt;find( k ).node;
@ -843,7 +843,7 @@ Q_INLINE_TEMPLATES T&amp; TQMap&lt;Key,T&gt;::operator[] ( const Key&amp; k )
} }
template&lt;class Key, class T&gt; template&lt;class Key, class T&gt;
Q_INLINE_TEMPLATES void TQMap&lt;Key,T&gt;::clear() TQ_INLINE_TEMPLATES void TQMap&lt;Key,T&gt;::clear()
{ {
if ( sh-&gt;count == 1 ) if ( sh-&gt;count == 1 )
sh-&gt;clear(); sh-&gt;clear();
@ -854,7 +854,7 @@ Q_INLINE_TEMPLATES void TQMap&lt;Key,T&gt;::clear()
} }
template&lt;class Key, class T&gt; template&lt;class Key, class T&gt;
Q_INLINE_TEMPLATES Q_TYPENAME TQMap&lt;Key,T&gt;::iterator TQMap&lt;Key,T&gt;::insert( const Key&amp; key, const T&amp; value, bool overwrite ) TQ_INLINE_TEMPLATES TQ_TYPENAME TQMap&lt;Key,T&gt;::iterator TQMap&lt;Key,T&gt;::insert( const Key&amp; key, const T&amp; value, bool overwrite )
{ {
detach(); detach();
size_type n = size(); size_type n = size();
@ -865,7 +865,7 @@ Q_INLINE_TEMPLATES Q_TYPENAME TQMap&lt;Key,T&gt;::iterator TQMap&lt;Key,T&gt;::i
} }
template&lt;class Key, class T&gt; template&lt;class Key, class T&gt;
Q_INLINE_TEMPLATES void TQMap&lt;Key,T&gt;::remove( const Key&amp; k ) TQ_INLINE_TEMPLATES void TQMap&lt;Key,T&gt;::remove( const Key&amp; k )
{ {
detach(); detach();
iterator it( sh-&gt;find( k ).node ); iterator it( sh-&gt;find( k ).node );
@ -874,7 +874,7 @@ Q_INLINE_TEMPLATES void TQMap&lt;Key,T&gt;::remove( const Key&amp; k )
} }
template&lt;class Key, class T&gt; template&lt;class Key, class T&gt;
Q_INLINE_TEMPLATES void TQMap&lt;Key,T&gt;::detachInternal() TQ_INLINE_TEMPLATES void TQMap&lt;Key,T&gt;::detachInternal()
{ {
sh-&gt;deref(); sh = new TQMapPrivate&lt;Key,T&gt;( sh ); sh-&gt;deref(); sh = new TQMapPrivate&lt;Key,T&gt;( sh );
} }
@ -882,7 +882,7 @@ Q_INLINE_TEMPLATES void TQMap&lt;Key,T&gt;::detachInternal()
#ifndef TQT_NO_DATASTREAM #ifndef TQT_NO_DATASTREAM
template&lt;class Key, class T&gt; template&lt;class Key, class T&gt;
Q_INLINE_TEMPLATES TQDataStream&amp; operator&gt;&gt;( TQDataStream&amp; s, TQMap&lt;Key,T&gt;&amp; m ) { TQ_INLINE_TEMPLATES TQDataStream&amp; operator&gt;&gt;( TQDataStream&amp; s, TQMap&lt;Key,T&gt;&amp; m ) {
m.clear(); m.clear();
TQ_UINT32 c; TQ_UINT32 c;
s &gt;&gt; c; s &gt;&gt; c;
@ -898,7 +898,7 @@ Q_INLINE_TEMPLATES TQDataStream&amp; operator&gt;&gt;( TQDataStream&amp; s, TQMa
template&lt;class Key, class T&gt; template&lt;class Key, class T&gt;
Q_INLINE_TEMPLATES TQDataStream&amp; operator&lt;&lt;( TQDataStream&amp; s, const TQMap&lt;Key,T&gt;&amp; m ) { TQ_INLINE_TEMPLATES TQDataStream&amp; operator&lt;&lt;( TQDataStream&amp; s, const TQMap&lt;Key,T&gt;&amp; m ) {
s &lt;&lt; (TQ_UINT32)m.size(); s &lt;&lt; (TQ_UINT32)m.size();
TQMapConstIterator&lt;Key,T&gt; it = m.begin(); TQMapConstIterator&lt;Key,T&gt; it = m.begin();
for( ; it != m.end(); ++it ) for( ; it != m.end(); ++it )

@ -85,8 +85,8 @@ body { background: #ffffff; color: black; }
#include "ntqnamespace.h" #include "ntqnamespace.h"
#endif // QT_H #endif // QT_H
#define QT_TR_NOOP(x) (x) #define TQT_TR_NOOP(x) (x)
#define QT_TRANSLATE_NOOP(scope,x) (x) #define TQT_TRANSLATE_NOOP(scope,x) (x)
class TQMetaObject; class TQMetaObject;
class TQVariant; class TQVariant;

@ -107,20 +107,20 @@ struct TQPair
}; };
template &lt;class T1, class T2&gt; template &lt;class T1, class T2&gt;
Q_INLINE_TEMPLATES bool operator==( const TQPair&lt;T1, T2&gt;&amp; x, const TQPair&lt;T1, T2&gt;&amp; y ) TQ_INLINE_TEMPLATES bool operator==( const TQPair&lt;T1, T2&gt;&amp; x, const TQPair&lt;T1, T2&gt;&amp; y )
{ {
return x.first == y.first &amp;&amp; x.second == y.second; return x.first == y.first &amp;&amp; x.second == y.second;
} }
template &lt;class T1, class T2&gt; template &lt;class T1, class T2&gt;
Q_INLINE_TEMPLATES bool operator&lt;( const TQPair&lt;T1, T2&gt;&amp; x, const TQPair&lt;T1, T2&gt;&amp; y ) TQ_INLINE_TEMPLATES bool operator&lt;( const TQPair&lt;T1, T2&gt;&amp; x, const TQPair&lt;T1, T2&gt;&amp; y )
{ {
return x.first &lt; y.first || return x.first &lt; y.first ||
( !( y.first &lt; x.first ) &amp;&amp; x.second &lt; y.second ); ( !( y.first &lt; x.first ) &amp;&amp; x.second &lt; y.second );
} }
template &lt;class T1, class T2&gt; template &lt;class T1, class T2&gt;
Q_INLINE_TEMPLATES TQPair&lt;T1, T2&gt; qMakePair( const T1&amp; x, const T2&amp; y ) TQ_INLINE_TEMPLATES TQPair&lt;T1, T2&gt; qMakePair( const T1&amp; x, const T2&amp; y )
{ {
return TQPair&lt;T1, T2&gt;( x, y ); return TQPair&lt;T1, T2&gt;( x, y );
} }

@ -212,7 +212,7 @@ public:
#endif #endif
#ifndef Q_QDOC #ifndef Q_QDOC
Q_DUMMY_COMPARISON_OPERATOR(TQPixmap) TQ_DUMMY_COMPARISON_OPERATOR(TQPixmap)
#endif #endif
protected: protected:

@ -65,7 +65,7 @@ public:
void setSalary( int salary ) { s = salary; } void setSalary( int salary ) { s = salary; }
// this is here to support very old compilers // this is here to support very old compilers
Q_DUMMY_COMPARISON_OPERATOR( Employee ) TQ_DUMMY_COMPARISON_OPERATOR( Employee )
private: private:
<a href="ntqstring.html">TQString</a> n; <a href="ntqstring.html">TQString</a> n;

@ -294,13 +294,13 @@ public:
}; };
template &lt;class T&gt; template &lt;class T&gt;
Q_INLINE_TEMPLATES TQValueListPrivate&lt;T&gt;::TQValueListPrivate() TQ_INLINE_TEMPLATES TQValueListPrivate&lt;T&gt;::TQValueListPrivate()
{ {
node = new Node; node-&gt;next = node-&gt;prev = node; nodes = 0; node = new Node; node-&gt;next = node-&gt;prev = node; nodes = 0;
} }
template &lt;class T&gt; template &lt;class T&gt;
Q_INLINE_TEMPLATES TQValueListPrivate&lt;T&gt;::TQValueListPrivate( const TQValueListPrivate&lt;T&gt;&amp; _p ) TQ_INLINE_TEMPLATES TQValueListPrivate&lt;T&gt;::TQValueListPrivate( const TQValueListPrivate&lt;T&gt;&amp; _p )
: TQShared() : TQShared()
{ {
node = new Node; node-&gt;next = node-&gt;prev = node; nodes = 0; node = new Node; node-&gt;next = node-&gt;prev = node; nodes = 0;
@ -312,7 +312,7 @@ Q_INLINE_TEMPLATES TQValueListPrivate&lt;T&gt;::TQValueListPrivate( const TQValu
} }
template &lt;class T&gt; template &lt;class T&gt;
Q_INLINE_TEMPLATES TQValueListPrivate&lt;T&gt;::~TQValueListPrivate() { TQ_INLINE_TEMPLATES TQValueListPrivate&lt;T&gt;::~TQValueListPrivate() {
NodePtr p = node-&gt;next; NodePtr p = node-&gt;next;
while( p != node ) { while( p != node ) {
NodePtr x = p-&gt;next; NodePtr x = p-&gt;next;
@ -323,7 +323,7 @@ Q_INLINE_TEMPLATES TQValueListPrivate&lt;T&gt;::~TQValueListPrivate() {
} }
template &lt;class T&gt; template &lt;class T&gt;
Q_INLINE_TEMPLATES Q_TYPENAME TQValueListPrivate&lt;T&gt;::Iterator TQValueListPrivate&lt;T&gt;::insert( Q_TYPENAME TQValueListPrivate&lt;T&gt;::Iterator it, const T&amp; x ) TQ_INLINE_TEMPLATES TQ_TYPENAME TQValueListPrivate&lt;T&gt;::Iterator TQValueListPrivate&lt;T&gt;::insert( TQ_TYPENAME TQValueListPrivate&lt;T&gt;::Iterator it, const T&amp; x )
{ {
NodePtr p = new Node( x ); NodePtr p = new Node( x );
p-&gt;next = it.node; p-&gt;next = it.node;
@ -335,7 +335,7 @@ Q_INLINE_TEMPLATES Q_TYPENAME TQValueListPrivate&lt;T&gt;::Iterator TQValueListP
} }
template &lt;class T&gt; template &lt;class T&gt;
Q_INLINE_TEMPLATES Q_TYPENAME TQValueListPrivate&lt;T&gt;::Iterator TQValueListPrivate&lt;T&gt;::remove( Q_TYPENAME TQValueListPrivate&lt;T&gt;::Iterator it ) TQ_INLINE_TEMPLATES TQ_TYPENAME TQValueListPrivate&lt;T&gt;::Iterator TQValueListPrivate&lt;T&gt;::remove( TQ_TYPENAME TQValueListPrivate&lt;T&gt;::Iterator it )
{ {
Q_ASSERT ( it.node != node ); Q_ASSERT ( it.node != node );
NodePtr next = it.node-&gt;next; NodePtr next = it.node-&gt;next;
@ -348,7 +348,7 @@ Q_INLINE_TEMPLATES Q_TYPENAME TQValueListPrivate&lt;T&gt;::Iterator TQValueListP
} }
template &lt;class T&gt; template &lt;class T&gt;
Q_INLINE_TEMPLATES Q_TYPENAME TQValueListPrivate&lt;T&gt;::NodePtr TQValueListPrivate&lt;T&gt;::find( Q_TYPENAME TQValueListPrivate&lt;T&gt;::NodePtr start, const T&amp; x ) const TQ_INLINE_TEMPLATES TQ_TYPENAME TQValueListPrivate&lt;T&gt;::NodePtr TQValueListPrivate&lt;T&gt;::find( TQ_TYPENAME TQValueListPrivate&lt;T&gt;::NodePtr start, const T&amp; x ) const
{ {
ConstIterator first( start ); ConstIterator first( start );
ConstIterator last( node ); ConstIterator last( node );
@ -361,7 +361,7 @@ Q_INLINE_TEMPLATES Q_TYPENAME TQValueListPrivate&lt;T&gt;::NodePtr TQValueListPr
} }
template &lt;class T&gt; template &lt;class T&gt;
Q_INLINE_TEMPLATES int TQValueListPrivate&lt;T&gt;::findIndex( Q_TYPENAME TQValueListPrivate&lt;T&gt;::NodePtr start, const T&amp; x ) const TQ_INLINE_TEMPLATES int TQValueListPrivate&lt;T&gt;::findIndex( TQ_TYPENAME TQValueListPrivate&lt;T&gt;::NodePtr start, const T&amp; x ) const
{ {
ConstIterator first( start ); ConstIterator first( start );
ConstIterator last( node ); ConstIterator last( node );
@ -376,7 +376,7 @@ Q_INLINE_TEMPLATES int TQValueListPrivate&lt;T&gt;::findIndex( Q_TYPENAME TQValu
} }
template &lt;class T&gt; template &lt;class T&gt;
Q_INLINE_TEMPLATES uint TQValueListPrivate&lt;T&gt;::contains( const T&amp; x ) const TQ_INLINE_TEMPLATES uint TQValueListPrivate&lt;T&gt;::contains( const T&amp; x ) const
{ {
uint result = 0; uint result = 0;
Iterator first = Iterator( node-&gt;next ); Iterator first = Iterator( node-&gt;next );
@ -390,7 +390,7 @@ Q_INLINE_TEMPLATES uint TQValueListPrivate&lt;T&gt;::contains( const T&amp; x )
} }
template &lt;class T&gt; template &lt;class T&gt;
Q_INLINE_TEMPLATES uint TQValueListPrivate&lt;T&gt;::remove( const T&amp; _x ) TQ_INLINE_TEMPLATES uint TQValueListPrivate&lt;T&gt;::remove( const T&amp; _x )
{ {
const T x = _x; const T x = _x;
uint result = 0; uint result = 0;
@ -407,7 +407,7 @@ Q_INLINE_TEMPLATES uint TQValueListPrivate&lt;T&gt;::remove( const T&amp; _x )
} }
template &lt;class T&gt; template &lt;class T&gt;
Q_INLINE_TEMPLATES Q_TYPENAME TQValueListPrivate&lt;T&gt;::NodePtr TQValueListPrivate&lt;T&gt;::at( size_type i ) const TQ_INLINE_TEMPLATES TQ_TYPENAME TQValueListPrivate&lt;T&gt;::NodePtr TQValueListPrivate&lt;T&gt;::at( size_type i ) const
{ {
Q_ASSERT( i &lt;= nodes ); Q_ASSERT( i &lt;= nodes );
NodePtr p = node-&gt;next; NodePtr p = node-&gt;next;
@ -417,7 +417,7 @@ Q_INLINE_TEMPLATES Q_TYPENAME TQValueListPrivate&lt;T&gt;::NodePtr TQValueListPr
} }
template &lt;class T&gt; template &lt;class T&gt;
Q_INLINE_TEMPLATES void TQValueListPrivate&lt;T&gt;::clear() TQ_INLINE_TEMPLATES void TQValueListPrivate&lt;T&gt;::clear()
{ {
nodes = 0; nodes = 0;
NodePtr p = node-&gt;next; NodePtr p = node-&gt;next;
@ -612,7 +612,7 @@ private:
}; };
template &lt;class T&gt; template &lt;class T&gt;
Q_INLINE_TEMPLATES bool TQValueList&lt;T&gt;::operator== ( const TQValueList&lt;T&gt;&amp; l ) const TQ_INLINE_TEMPLATES bool TQValueList&lt;T&gt;::operator== ( const TQValueList&lt;T&gt;&amp; l ) const
{ {
if ( size() != l.size() ) if ( size() != l.size() )
return FALSE; return FALSE;
@ -625,13 +625,13 @@ Q_INLINE_TEMPLATES bool TQValueList&lt;T&gt;::operator== ( const TQValueList&lt;
} }
template &lt;class T&gt; template &lt;class T&gt;
Q_INLINE_TEMPLATES void TQValueList&lt;T&gt;::clear() TQ_INLINE_TEMPLATES void TQValueList&lt;T&gt;::clear()
{ {
if ( sh-&gt;count == 1 ) sh-&gt;clear(); else { sh-&gt;deref(); sh = new TQValueListPrivate&lt;T&gt;; } if ( sh-&gt;count == 1 ) sh-&gt;clear(); else { sh-&gt;deref(); sh = new TQValueListPrivate&lt;T&gt;; }
} }
template &lt;class T&gt; template &lt;class T&gt;
Q_INLINE_TEMPLATES Q_TYPENAME TQValueList&lt;T&gt;::iterator TQValueList&lt;T&gt;::erase( Q_TYPENAME TQValueList&lt;T&gt;::iterator first, Q_TYPENAME TQValueList&lt;T&gt;::iterator last ) TQ_INLINE_TEMPLATES TQ_TYPENAME TQValueList&lt;T&gt;::iterator TQValueList&lt;T&gt;::erase( TQ_TYPENAME TQValueList&lt;T&gt;::iterator first, TQ_TYPENAME TQValueList&lt;T&gt;::iterator last )
{ {
while ( first != last ) while ( first != last )
erase( first++ ); erase( first++ );
@ -640,14 +640,14 @@ Q_INLINE_TEMPLATES Q_TYPENAME TQValueList&lt;T&gt;::iterator TQValueList&lt;T&gt
template &lt;class T&gt; template &lt;class T&gt;
Q_INLINE_TEMPLATES void TQValueList&lt;T&gt;::insert( Q_TYPENAME TQValueList&lt;T&gt;::iterator pos, size_type n, const T&amp; x ) TQ_INLINE_TEMPLATES void TQValueList&lt;T&gt;::insert( TQ_TYPENAME TQValueList&lt;T&gt;::iterator pos, size_type n, const T&amp; x )
{ {
for ( ; n &gt; 0; --n ) for ( ; n &gt; 0; --n )
insert( pos, x ); insert( pos, x );
} }
template &lt;class T&gt; template &lt;class T&gt;
Q_INLINE_TEMPLATES TQValueList&lt;T&gt; TQValueList&lt;T&gt;::operator+ ( const TQValueList&lt;T&gt;&amp; l ) const TQ_INLINE_TEMPLATES TQValueList&lt;T&gt; TQValueList&lt;T&gt;::operator+ ( const TQValueList&lt;T&gt;&amp; l ) const
{ {
TQValueList&lt;T&gt; l2( *this ); TQValueList&lt;T&gt; l2( *this );
for( const_iterator it = l.begin(); it != l.end(); ++it ) for( const_iterator it = l.begin(); it != l.end(); ++it )
@ -656,7 +656,7 @@ Q_INLINE_TEMPLATES TQValueList&lt;T&gt; TQValueList&lt;T&gt;::operator+ ( const
} }
template &lt;class T&gt; template &lt;class T&gt;
Q_INLINE_TEMPLATES TQValueList&lt;T&gt;&amp; TQValueList&lt;T&gt;::operator+= ( const TQValueList&lt;T&gt;&amp; l ) TQ_INLINE_TEMPLATES TQValueList&lt;T&gt;&amp; TQValueList&lt;T&gt;::operator+= ( const TQValueList&lt;T&gt;&amp; l )
{ {
TQValueList&lt;T&gt; copy = l; TQValueList&lt;T&gt; copy = l;
for( const_iterator it = copy.begin(); it != copy.end(); ++it ) for( const_iterator it = copy.begin(); it != copy.end(); ++it )
@ -665,14 +665,14 @@ Q_INLINE_TEMPLATES TQValueList&lt;T&gt;&amp; TQValueList&lt;T&gt;::operator+= (
} }
template &lt;class T&gt; template &lt;class T&gt;
Q_INLINE_TEMPLATES void TQValueList&lt;T&gt;::detachInternal() TQ_INLINE_TEMPLATES void TQValueList&lt;T&gt;::detachInternal()
{ {
sh-&gt;deref(); sh = new TQValueListPrivate&lt;T&gt;( *sh ); sh-&gt;deref(); sh = new TQValueListPrivate&lt;T&gt;( *sh );
} }
#ifndef TQT_NO_DATASTREAM #ifndef TQT_NO_DATASTREAM
template &lt;class T&gt; template &lt;class T&gt;
Q_INLINE_TEMPLATES TQDataStream&amp; operator&gt;&gt;( TQDataStream&amp; s, TQValueList&lt;T&gt;&amp; l ) TQ_INLINE_TEMPLATES TQDataStream&amp; operator&gt;&gt;( TQDataStream&amp; s, TQValueList&lt;T&gt;&amp; l )
{ {
l.clear(); l.clear();
TQ_UINT32 c; TQ_UINT32 c;
@ -689,7 +689,7 @@ Q_INLINE_TEMPLATES TQDataStream&amp; operator&gt;&gt;( TQDataStream&amp; s, TQVa
} }
template &lt;class T&gt; template &lt;class T&gt;
Q_INLINE_TEMPLATES TQDataStream&amp; operator&lt;&lt;( TQDataStream&amp; s, const TQValueList&lt;T&gt;&amp; l ) TQ_INLINE_TEMPLATES TQDataStream&amp; operator&lt;&lt;( TQDataStream&amp; s, const TQValueList&lt;T&gt;&amp; l )
{ {
s &lt;&lt; (TQ_UINT32)l.size(); s &lt;&lt; (TQ_UINT32)l.size();
TQValueListConstIterator&lt;T&gt; it = l.begin(); TQValueListConstIterator&lt;T&gt; it = l.begin();

@ -155,7 +155,7 @@ private:
}; };
template &lt;class T&gt; template &lt;class T&gt;
Q_INLINE_TEMPLATES TQValueVectorPrivate&lt;T&gt;::TQValueVectorPrivate( const TQValueVectorPrivate&lt;T&gt;&amp; x ) TQ_INLINE_TEMPLATES TQValueVectorPrivate&lt;T&gt;::TQValueVectorPrivate( const TQValueVectorPrivate&lt;T&gt;&amp; x )
: TQShared() : TQShared()
{ {
size_t i = x.size(); size_t i = x.size();
@ -176,7 +176,7 @@ Q_INLINE_TEMPLATES TQValueVectorPrivate&lt;T&gt;::TQValueVectorPrivate( const TQ
} }
template &lt;class T&gt; template &lt;class T&gt;
Q_INLINE_TEMPLATES TQValueVectorPrivate&lt;T&gt;::TQValueVectorPrivate( size_t size ) TQ_INLINE_TEMPLATES TQValueVectorPrivate&lt;T&gt;::TQValueVectorPrivate( size_t size )
{ {
if ( size &gt; 0 ) { if ( size &gt; 0 ) {
start = new T[size]; start = new T[size];
@ -190,7 +190,7 @@ Q_INLINE_TEMPLATES TQValueVectorPrivate&lt;T&gt;::TQValueVectorPrivate( size_t s
} }
template &lt;class T&gt; template &lt;class T&gt;
Q_INLINE_TEMPLATES void TQValueVectorPrivate&lt;T&gt;::insert( pointer pos, const T&amp; x ) TQ_INLINE_TEMPLATES void TQValueVectorPrivate&lt;T&gt;::insert( pointer pos, const T&amp; x )
{ {
const size_t lastSize = size(); const size_t lastSize = size();
const size_t n = lastSize !=0 ? 2*lastSize : 1; const size_t n = lastSize !=0 ? 2*lastSize : 1;
@ -207,7 +207,7 @@ Q_INLINE_TEMPLATES void TQValueVectorPrivate&lt;T&gt;::insert( pointer pos, cons
} }
template &lt;class T&gt; template &lt;class T&gt;
Q_INLINE_TEMPLATES void TQValueVectorPrivate&lt;T&gt;::insert( pointer pos, size_t n, const T&amp; x ) TQ_INLINE_TEMPLATES void TQValueVectorPrivate&lt;T&gt;::insert( pointer pos, size_t n, const T&amp; x )
{ {
if ( size_t( end - finish ) &gt;= n ) { if ( size_t( end - finish ) &gt;= n ) {
// enough room // enough room
@ -247,7 +247,7 @@ Q_INLINE_TEMPLATES void TQValueVectorPrivate&lt;T&gt;::insert( pointer pos, size
} }
template &lt;class T&gt; template &lt;class T&gt;
Q_INLINE_TEMPLATES void TQValueVectorPrivate&lt;T&gt;::reserve( size_t n ) TQ_INLINE_TEMPLATES void TQValueVectorPrivate&lt;T&gt;::reserve( size_t n )
{ {
const size_t lastSize = size(); const size_t lastSize = size();
pointer tmp = growAndCopy( n, start, finish ); pointer tmp = growAndCopy( n, start, finish );
@ -257,7 +257,7 @@ Q_INLINE_TEMPLATES void TQValueVectorPrivate&lt;T&gt;::reserve( size_t n )
} }
template &lt;class T&gt; template &lt;class T&gt;
Q_INLINE_TEMPLATES Q_TYPENAME TQValueVectorPrivate&lt;T&gt;::pointer TQValueVectorPrivate&lt;T&gt;::growAndCopy( size_t n, pointer s, pointer f ) TQ_INLINE_TEMPLATES TQ_TYPENAME TQValueVectorPrivate&lt;T&gt;::pointer TQValueVectorPrivate&lt;T&gt;::growAndCopy( size_t n, pointer s, pointer f )
{ {
pointer newStart = new T[n]; pointer newStart = new T[n];
tqCopy( s, f, newStart ); tqCopy( s, f, newStart );
@ -525,21 +525,21 @@ private:
}; };
template &lt;class T&gt; template &lt;class T&gt;
Q_INLINE_TEMPLATES TQValueVector&lt;T&gt;::TQValueVector( size_type n, const T&amp; val ) TQ_INLINE_TEMPLATES TQValueVector&lt;T&gt;::TQValueVector( size_type n, const T&amp; val )
{ {
sh = new TQValueVectorPrivate&lt;T&gt;( n ); sh = new TQValueVectorPrivate&lt;T&gt;( n );
tqFill( begin(), end(), val ); tqFill( begin(), end(), val );
} }
template &lt;class T&gt; template &lt;class T&gt;
Q_INLINE_TEMPLATES void TQValueVector&lt;T&gt;::detachInternal() TQ_INLINE_TEMPLATES void TQValueVector&lt;T&gt;::detachInternal()
{ {
sh-&gt;deref(); sh-&gt;deref();
sh = new TQValueVectorPrivate&lt;T&gt;( *sh ); sh = new TQValueVectorPrivate&lt;T&gt;( *sh );
} }
template &lt;class T&gt; template &lt;class T&gt;
Q_INLINE_TEMPLATES Q_TYPENAME TQValueVector&lt;T&gt;::iterator TQValueVector&lt;T&gt;::insert( iterator pos, const T&amp; x ) TQ_INLINE_TEMPLATES TQ_TYPENAME TQValueVector&lt;T&gt;::iterator TQValueVector&lt;T&gt;::insert( iterator pos, const T&amp; x )
{ {
size_type offset = pos - sh-&gt;start; size_type offset = pos - sh-&gt;start;
detach(); detach();
@ -564,7 +564,7 @@ Q_INLINE_TEMPLATES Q_TYPENAME TQValueVector&lt;T&gt;::iterator TQValueVector&lt;
} }
template &lt;class T&gt; template &lt;class T&gt;
Q_INLINE_TEMPLATES Q_TYPENAME TQValueVector&lt;T&gt;::iterator TQValueVector&lt;T&gt;::insert( iterator pos, size_type n, const T&amp; x ) TQ_INLINE_TEMPLATES TQ_TYPENAME TQValueVector&lt;T&gt;::iterator TQValueVector&lt;T&gt;::insert( iterator pos, size_type n, const T&amp; x )
{ {
if ( n != 0 ) { if ( n != 0 ) {
size_type offset = pos - sh-&gt;start; size_type offset = pos - sh-&gt;start;
@ -578,7 +578,7 @@ Q_INLINE_TEMPLATES Q_TYPENAME TQValueVector&lt;T&gt;::iterator TQValueVector&lt;
#ifndef TQT_NO_DATASTREAM #ifndef TQT_NO_DATASTREAM
template&lt;class T&gt; template&lt;class T&gt;
Q_INLINE_TEMPLATES TQDataStream&amp; operator&gt;&gt;( TQDataStream&amp; s, TQValueVector&lt;T&gt;&amp; v ) TQ_INLINE_TEMPLATES TQDataStream&amp; operator&gt;&gt;( TQDataStream&amp; s, TQValueVector&lt;T&gt;&amp; v )
{ {
v.clear(); v.clear();
TQ_UINT32 c; TQ_UINT32 c;
@ -594,7 +594,7 @@ Q_INLINE_TEMPLATES TQDataStream&amp; operator&gt;&gt;( TQDataStream&amp; s, TQVa
} }
template&lt;class T&gt; template&lt;class T&gt;
Q_INLINE_TEMPLATES TQDataStream&amp; operator&lt;&lt;( TQDataStream&amp; s, const TQValueVector&lt;T&gt;&amp; v ) TQ_INLINE_TEMPLATES TQDataStream&amp; operator&lt;&lt;( TQDataStream&amp; s, const TQValueVector&lt;T&gt;&amp; v )
{ {
s &lt;&lt; (TQ_UINT32)v.size(); s &lt;&lt; (TQ_UINT32)v.size();
// ### use typename TQValueVector&lt;T&gt;::const_iterator once all supported // ### use typename TQValueVector&lt;T&gt;::const_iterator once all supported

@ -187,7 +187,7 @@ private:
TQString name; TQString name;
TQPixmap pix; TQPixmap pix;
TQString field; TQString field;
Q_DUMMY_COMPARISON_OPERATOR( Field ) TQ_DUMMY_COMPARISON_OPERATOR( Field )
}; };
struct SqlWidgetConnection struct SqlWidgetConnection
@ -198,7 +198,7 @@ private:
TQString conn; TQString conn;
TQString table; TQString table;
TQMap&lt;TQString, TQString&gt; *dbControls; TQMap&lt;TQString, TQString&gt; *dbControls;
Q_DUMMY_COMPARISON_OPERATOR( SqlWidgetConnection ) TQ_DUMMY_COMPARISON_OPERATOR( SqlWidgetConnection )
}; };
TQValueList&lt;Image&gt; images; TQValueList&lt;Image&gt; images;

@ -214,28 +214,28 @@ directly:
\endcode \endcode
If you need to have translatable text completely If you need to have translatable text completely
outside a function, there are two macros to help: QT_TR_NOOP() outside a function, there are two macros to help: TQT_TR_NOOP()
and QT_TRANSLATE_NOOP(). They merely mark the text for and TQT_TRANSLATE_NOOP(). They merely mark the text for
extraction by the \e lupdate utility described below. extraction by the \e lupdate utility described below.
The macros expand to just the text (without the context). The macros expand to just the text (without the context).
Example of QT_TR_NOOP(): Example of TQT_TR_NOOP():
\code \code
QString FriendlyConversation::greeting( int greet_type ) QString FriendlyConversation::greeting( int greet_type )
{ {
static const char* greeting_strings[] = { static const char* greeting_strings[] = {
QT_TR_NOOP( "Hello" ), TQT_TR_NOOP( "Hello" ),
QT_TR_NOOP( "Goodbye" ) TQT_TR_NOOP( "Goodbye" )
}; };
return tr( greeting_strings[greet_type] ); return tr( greeting_strings[greet_type] );
} }
\endcode \endcode
Example of QT_TRANSLATE_NOOP(): Example of TQT_TRANSLATE_NOOP():
\code \code
static const char* greeting_strings[] = { static const char* greeting_strings[] = {
QT_TRANSLATE_NOOP( "FriendlyConversation", "Hello" ), TQT_TRANSLATE_NOOP( "FriendlyConversation", "Hello" ),
QT_TRANSLATE_NOOP( "FriendlyConversation", "Goodbye" ) TQT_TRANSLATE_NOOP( "FriendlyConversation", "Goodbye" )
}; };
QString FriendlyConversation::greeting( int greet_type ) QString FriendlyConversation::greeting( int greet_type )

@ -83,7 +83,7 @@ a little-endian machine (e.g. x86) for a big-endian processor
(e.g. PowerPC) will use the host's endianness instead of the (e.g. PowerPC) will use the host's endianness instead of the
target's. Workaround: after running configure, and before running target's. Workaround: after running configure, and before running
make, edit \c $TQTDIR/include/ntqconfig.h and change the definition of make, edit \c $TQTDIR/include/ntqconfig.h and change the definition of
\c Q_BYTE_ORDER. \c TQ_BYTE_ORDER.
\i Enable framebuffer support. \i Enable framebuffer support.

@ -59,7 +59,7 @@ public:
#ifdef TQ_FULL_TEMPLATE_INSTANTIATION #ifdef TQ_FULL_TEMPLATE_INSTANTIATION
// xlC 3.x workaround // xlC 3.x workaround
Q_DUMMY_COMPARISON_OPERATOR(Element) TQ_DUMMY_COMPARISON_OPERATOR(Element)
bool operator!=( const Element& e) const { bool operator!=( const Element& e) const {
return ( !(e == *this) ); return ( !(e == *this) );
} }

@ -13,7 +13,7 @@ public:
TQString name() { return _name; } TQString name() { return _name; }
TQPixmap *pixmap() { return &_pixmap; } TQPixmap *pixmap() { return &_pixmap; }
Q_DUMMY_COMPARISON_OPERATOR( IconItem ) TQ_DUMMY_COMPARISON_OPERATOR( IconItem )
protected: protected:
TQPixmap loadPixmap( const TQString& name ); TQPixmap loadPixmap( const TQString& name );

@ -53,9 +53,9 @@ MyWidget::MyWidget( TQWidget* parent, const char* name )
} }
static const char* choices[] = { static const char* choices[] = {
QT_TRANSLATE_NOOP( "MyWidget", "First" ), TQT_TRANSLATE_NOOP( "MyWidget", "First" ),
QT_TRANSLATE_NOOP( "MyWidget", "Second" ), TQT_TRANSLATE_NOOP( "MyWidget", "Second" ),
QT_TRANSLATE_NOOP( "MyWidget", "Third" ), TQT_TRANSLATE_NOOP( "MyWidget", "Third" ),
0 0
}; };

@ -26,7 +26,7 @@ public:
void setSalary( int salary ) { s = salary; } void setSalary( int salary ) { s = salary; }
// this is here to support very old compilers // this is here to support very old compilers
Q_DUMMY_COMPARISON_OPERATOR( Employee ) TQ_DUMMY_COMPARISON_OPERATOR( Employee )
private: private:
TQString n; TQString n;

@ -11,7 +11,7 @@ public:
AccessibleFactory(); AccessibleFactory();
TQRESULT queryInterface( const TQUuid &, TQUnknownInterface **iface ); TQRESULT queryInterface( const TQUuid &, TQUnknownInterface **iface );
Q_REFCOUNT TQ_REFCOUNT
TQStringList featureList() const; TQStringList featureList() const;
TQRESULT createAccessibleInterface( const TQString &classname, TQObject *object, TQAccessibleInterface **iface ); TQRESULT createAccessibleInterface( const TQString &classname, TQObject *object, TQAccessibleInterface **iface );

@ -112,7 +112,7 @@ public:
virtual ~TQTextCodecPluginPrivate(); virtual ~TQTextCodecPluginPrivate();
TQRESULT queryInterface( const TQUuid &iid, TQUnknownInterface **iface ); TQRESULT queryInterface( const TQUuid &iid, TQUnknownInterface **iface );
Q_REFCOUNT; TQ_REFCOUNT;
TQStringList featureList() const; TQStringList featureList() const;
TQTextCodec *createForMib( int mib ); TQTextCodec *createForMib( int mib );

@ -458,15 +458,15 @@ static const char * const mb_texts[] = {
const char * mb_texts[] = { const char * mb_texts[] = {
#endif #endif
0, 0,
QT_TRANSLATE_NOOP("TQMessageBox","OK"), TQT_TRANSLATE_NOOP("TQMessageBox","OK"),
QT_TRANSLATE_NOOP("TQMessageBox","Cancel"), TQT_TRANSLATE_NOOP("TQMessageBox","Cancel"),
QT_TRANSLATE_NOOP("TQMessageBox","&Yes"), TQT_TRANSLATE_NOOP("TQMessageBox","&Yes"),
QT_TRANSLATE_NOOP("TQMessageBox","&No"), TQT_TRANSLATE_NOOP("TQMessageBox","&No"),
QT_TRANSLATE_NOOP("TQMessageBox","&Abort"), TQT_TRANSLATE_NOOP("TQMessageBox","&Abort"),
QT_TRANSLATE_NOOP("TQMessageBox","&Retry"), TQT_TRANSLATE_NOOP("TQMessageBox","&Retry"),
QT_TRANSLATE_NOOP("TQMessageBox","&Ignore"), TQT_TRANSLATE_NOOP("TQMessageBox","&Ignore"),
QT_TRANSLATE_NOOP("TQMessageBox","Yes to &All"), TQT_TRANSLATE_NOOP("TQMessageBox","Yes to &All"),
QT_TRANSLATE_NOOP("TQMessageBox","N&o to All"), TQT_TRANSLATE_NOOP("TQMessageBox","N&o to All"),
0 0
}; };

@ -147,7 +147,7 @@ public:
virtual ~TQInputContextPluginPrivate(); virtual ~TQInputContextPluginPrivate();
TQRESULT queryInterface( const TQUuid &iid, TQUnknownInterface **iface ); TQRESULT queryInterface( const TQUuid &iid, TQUnknownInterface **iface );
Q_REFCOUNT; TQ_REFCOUNT;
TQStringList featureList() const; TQStringList featureList() const;
TQInputContext *create( const TQString &key ); TQInputContext *create( const TQString &key );

@ -277,7 +277,7 @@ public:
virtual ~TQAccessibleObject(); virtual ~TQAccessibleObject();
TQRESULT queryInterface( const TQUuid &, TQUnknownInterface** ); TQRESULT queryInterface( const TQUuid &, TQUnknownInterface** );
Q_REFCOUNT TQ_REFCOUNT
bool isValid() const; bool isValid() const;

@ -90,7 +90,7 @@ public:
static const TQSize& iconSize( Size which ); static const TQSize& iconSize( Size which );
#ifndef Q_QDOC #ifndef Q_QDOC
Q_DUMMY_COMPARISON_OPERATOR(TQIconSet) TQ_DUMMY_COMPARISON_OPERATOR(TQIconSet)
#endif #endif
private: private:

@ -50,8 +50,8 @@
#include "ntqnamespace.h" #include "ntqnamespace.h"
#endif // QT_H #endif // QT_H
#define QT_TR_NOOP(x) (x) #define TQT_TR_NOOP(x) (x)
#define QT_TRANSLATE_NOOP(scope,x) (x) #define TQT_TRANSLATE_NOOP(scope,x) (x)
class TQMetaObject; class TQMetaObject;
class TQVariant; class TQVariant;

@ -169,6 +169,6 @@ Q_EXPORT void *tqt_find_obj_child( TQObject *, const char *, const char * );
Q_EXPORT void *tqt_inheritedBy( TQMetaObject *super, const TQObject *cls ); Q_EXPORT void *tqt_inheritedBy( TQMetaObject *super, const TQObject *cls );
template <typename T> template <typename T>
Q_INLINE_TEMPLATES T tqt_cast(const TQObject *object) TQ_INLINE_TEMPLATES T tqt_cast(const TQObject *object)
{ return (T)tqt_inheritedBy( ((T)0)->staticMetaObject(), object ); } { return (T)tqt_inheritedBy( ((T)0)->staticMetaObject(), object ); }
#endif // TQOBJECTDEFS_H #endif // TQOBJECTDEFS_H

@ -176,7 +176,7 @@ public:
#endif #endif
#ifndef Q_QDOC #ifndef Q_QDOC
Q_DUMMY_COMPARISON_OPERATOR(TQPixmap) TQ_DUMMY_COMPARISON_OPERATOR(TQPixmap)
#endif #endif
protected: protected:

@ -1975,198 +1975,198 @@ TQString TQFontDatabase::scriptName(TQFont::Script script)
switch (script) { switch (script) {
case TQFont::Latin: case TQFont::Latin:
name = QT_TRANSLATE_NOOP("TQFont", "Latin"); name = TQT_TRANSLATE_NOOP("TQFont", "Latin");
break; break;
case TQFont::Greek: case TQFont::Greek:
name = QT_TRANSLATE_NOOP("TQFont", "Greek" ); name = TQT_TRANSLATE_NOOP("TQFont", "Greek" );
break; break;
case TQFont::Cyrillic: case TQFont::Cyrillic:
name = QT_TRANSLATE_NOOP("TQFont", "Cyrillic" ); name = TQT_TRANSLATE_NOOP("TQFont", "Cyrillic" );
break; break;
case TQFont::Armenian: case TQFont::Armenian:
name = QT_TRANSLATE_NOOP("TQFont", "Armenian" ); name = TQT_TRANSLATE_NOOP("TQFont", "Armenian" );
break; break;
case TQFont::Georgian: case TQFont::Georgian:
name = QT_TRANSLATE_NOOP("TQFont", "Georgian" ); name = TQT_TRANSLATE_NOOP("TQFont", "Georgian" );
break; break;
case TQFont::Runic: case TQFont::Runic:
name = QT_TRANSLATE_NOOP("TQFont", "Runic" ); name = TQT_TRANSLATE_NOOP("TQFont", "Runic" );
break; break;
case TQFont::Ogham: case TQFont::Ogham:
name = QT_TRANSLATE_NOOP("TQFont", "Ogham" ); name = TQT_TRANSLATE_NOOP("TQFont", "Ogham" );
break; break;
case TQFont::SpacingModifiers: case TQFont::SpacingModifiers:
name = QT_TRANSLATE_NOOP("TQFont", "SpacingModifiers" ); name = TQT_TRANSLATE_NOOP("TQFont", "SpacingModifiers" );
break; break;
case TQFont::CombiningMarks: case TQFont::CombiningMarks:
name = QT_TRANSLATE_NOOP("TQFont", "CombiningMarks" ); name = TQT_TRANSLATE_NOOP("TQFont", "CombiningMarks" );
break; break;
case TQFont::Hebrew: case TQFont::Hebrew:
name = QT_TRANSLATE_NOOP("TQFont", "Hebrew" ); name = TQT_TRANSLATE_NOOP("TQFont", "Hebrew" );
break; break;
case TQFont::Arabic: case TQFont::Arabic:
name = QT_TRANSLATE_NOOP("TQFont", "Arabic" ); name = TQT_TRANSLATE_NOOP("TQFont", "Arabic" );
break; break;
case TQFont::Syriac: case TQFont::Syriac:
name = QT_TRANSLATE_NOOP("TQFont", "Syriac" ); name = TQT_TRANSLATE_NOOP("TQFont", "Syriac" );
break; break;
case TQFont::Thaana: case TQFont::Thaana:
name = QT_TRANSLATE_NOOP("TQFont", "Thaana" ); name = TQT_TRANSLATE_NOOP("TQFont", "Thaana" );
break; break;
case TQFont::Devanagari: case TQFont::Devanagari:
name = QT_TRANSLATE_NOOP("TQFont", "Devanagari" ); name = TQT_TRANSLATE_NOOP("TQFont", "Devanagari" );
break; break;
case TQFont::Bengali: case TQFont::Bengali:
name = QT_TRANSLATE_NOOP("TQFont", "Bengali" ); name = TQT_TRANSLATE_NOOP("TQFont", "Bengali" );
break; break;
case TQFont::Gurmukhi: case TQFont::Gurmukhi:
name = QT_TRANSLATE_NOOP("TQFont", "Gurmukhi" ); name = TQT_TRANSLATE_NOOP("TQFont", "Gurmukhi" );
break; break;
case TQFont::Gujarati: case TQFont::Gujarati:
name = QT_TRANSLATE_NOOP("TQFont", "Gujarati" ); name = TQT_TRANSLATE_NOOP("TQFont", "Gujarati" );
break; break;
case TQFont::Oriya: case TQFont::Oriya:
name = QT_TRANSLATE_NOOP("TQFont", "Oriya" ); name = TQT_TRANSLATE_NOOP("TQFont", "Oriya" );
break; break;
case TQFont::Tamil: case TQFont::Tamil:
name = QT_TRANSLATE_NOOP("TQFont", "Tamil" ); name = TQT_TRANSLATE_NOOP("TQFont", "Tamil" );
break; break;
case TQFont::Telugu: case TQFont::Telugu:
name = QT_TRANSLATE_NOOP("TQFont", "Telugu" ); name = TQT_TRANSLATE_NOOP("TQFont", "Telugu" );
break; break;
case TQFont::Kannada: case TQFont::Kannada:
name = QT_TRANSLATE_NOOP("TQFont", "Kannada" ); name = TQT_TRANSLATE_NOOP("TQFont", "Kannada" );
break; break;
case TQFont::Malayalam: case TQFont::Malayalam:
name = QT_TRANSLATE_NOOP("TQFont", "Malayalam" ); name = TQT_TRANSLATE_NOOP("TQFont", "Malayalam" );
break; break;
case TQFont::Sinhala: case TQFont::Sinhala:
name = QT_TRANSLATE_NOOP("TQFont", "Sinhala" ); name = TQT_TRANSLATE_NOOP("TQFont", "Sinhala" );
break; break;
case TQFont::Thai: case TQFont::Thai:
name = QT_TRANSLATE_NOOP("TQFont", "Thai" ); name = TQT_TRANSLATE_NOOP("TQFont", "Thai" );
break; break;
case TQFont::Lao: case TQFont::Lao:
name = QT_TRANSLATE_NOOP("TQFont", "Lao" ); name = TQT_TRANSLATE_NOOP("TQFont", "Lao" );
break; break;
case TQFont::Tibetan: case TQFont::Tibetan:
name = QT_TRANSLATE_NOOP("TQFont", "Tibetan" ); name = TQT_TRANSLATE_NOOP("TQFont", "Tibetan" );
break; break;
case TQFont::Myanmar: case TQFont::Myanmar:
name = QT_TRANSLATE_NOOP("TQFont", "Myanmar" ); name = TQT_TRANSLATE_NOOP("TQFont", "Myanmar" );
break; break;
case TQFont::Khmer: case TQFont::Khmer:
name = QT_TRANSLATE_NOOP("TQFont", "Khmer" ); name = TQT_TRANSLATE_NOOP("TQFont", "Khmer" );
break; break;
case TQFont::Han: case TQFont::Han:
name = QT_TRANSLATE_NOOP("TQFont", "Han" ); name = TQT_TRANSLATE_NOOP("TQFont", "Han" );
break; break;
case TQFont::Hiragana: case TQFont::Hiragana:
name = QT_TRANSLATE_NOOP("TQFont", "Hiragana" ); name = TQT_TRANSLATE_NOOP("TQFont", "Hiragana" );
break; break;
case TQFont::Katakana: case TQFont::Katakana:
name = QT_TRANSLATE_NOOP("TQFont", "Katakana" ); name = TQT_TRANSLATE_NOOP("TQFont", "Katakana" );
break; break;
case TQFont::Hangul: case TQFont::Hangul:
name = QT_TRANSLATE_NOOP("TQFont", "Hangul" ); name = TQT_TRANSLATE_NOOP("TQFont", "Hangul" );
break; break;
case TQFont::Bopomofo: case TQFont::Bopomofo:
name = QT_TRANSLATE_NOOP("TQFont", "Bopomofo" ); name = TQT_TRANSLATE_NOOP("TQFont", "Bopomofo" );
break; break;
case TQFont::Yi: case TQFont::Yi:
name = QT_TRANSLATE_NOOP("TQFont", "Yi" ); name = TQT_TRANSLATE_NOOP("TQFont", "Yi" );
break; break;
case TQFont::Ethiopic: case TQFont::Ethiopic:
name = QT_TRANSLATE_NOOP("TQFont", "Ethiopic" ); name = TQT_TRANSLATE_NOOP("TQFont", "Ethiopic" );
break; break;
case TQFont::Cherokee: case TQFont::Cherokee:
name = QT_TRANSLATE_NOOP("TQFont", "Cherokee" ); name = TQT_TRANSLATE_NOOP("TQFont", "Cherokee" );
break; break;
case TQFont::CanadianAboriginal: case TQFont::CanadianAboriginal:
name = QT_TRANSLATE_NOOP("TQFont", "Canadian Aboriginal" ); name = TQT_TRANSLATE_NOOP("TQFont", "Canadian Aboriginal" );
break; break;
case TQFont::Mongolian: case TQFont::Mongolian:
name = QT_TRANSLATE_NOOP("TQFont", "Mongolian" ); name = TQT_TRANSLATE_NOOP("TQFont", "Mongolian" );
break; break;
case TQFont::CurrencySymbols: case TQFont::CurrencySymbols:
name = QT_TRANSLATE_NOOP("TQFont", "Currency Symbols" ); name = TQT_TRANSLATE_NOOP("TQFont", "Currency Symbols" );
break; break;
case TQFont::LetterlikeSymbols: case TQFont::LetterlikeSymbols:
name = QT_TRANSLATE_NOOP("TQFont", "Letterlike Symbols" ); name = TQT_TRANSLATE_NOOP("TQFont", "Letterlike Symbols" );
break; break;
case TQFont::NumberForms: case TQFont::NumberForms:
name = QT_TRANSLATE_NOOP("TQFont", "Number Forms" ); name = TQT_TRANSLATE_NOOP("TQFont", "Number Forms" );
break; break;
case TQFont::MathematicalOperators: case TQFont::MathematicalOperators:
name = QT_TRANSLATE_NOOP("TQFont", "Mathematical Operators" ); name = TQT_TRANSLATE_NOOP("TQFont", "Mathematical Operators" );
break; break;
case TQFont::TechnicalSymbols: case TQFont::TechnicalSymbols:
name = QT_TRANSLATE_NOOP("TQFont", "Technical Symbols" ); name = TQT_TRANSLATE_NOOP("TQFont", "Technical Symbols" );
break; break;
case TQFont::GeometricSymbols: case TQFont::GeometricSymbols:
name = QT_TRANSLATE_NOOP("TQFont", "Geometric Symbols" ); name = TQT_TRANSLATE_NOOP("TQFont", "Geometric Symbols" );
break; break;
case TQFont::MiscellaneousSymbols: case TQFont::MiscellaneousSymbols:
name = QT_TRANSLATE_NOOP("TQFont", "Miscellaneous Symbols" ); name = TQT_TRANSLATE_NOOP("TQFont", "Miscellaneous Symbols" );
break; break;
case TQFont::EnclosedAndSquare: case TQFont::EnclosedAndSquare:
name = QT_TRANSLATE_NOOP("TQFont", "Enclosed and Square" ); name = TQT_TRANSLATE_NOOP("TQFont", "Enclosed and Square" );
break; break;
case TQFont::Braille: case TQFont::Braille:
name = QT_TRANSLATE_NOOP("TQFont", "Braille" ); name = TQT_TRANSLATE_NOOP("TQFont", "Braille" );
break; break;
case TQFont::Unicode: case TQFont::Unicode:
name = QT_TRANSLATE_NOOP("TQFont", "Unicode" ); name = TQT_TRANSLATE_NOOP("TQFont", "Unicode" );
break; break;
case TQFont::Tagalog: case TQFont::Tagalog:
name = QT_TRANSLATE_NOOP( "TQFont", "Tagalog" ); name = TQT_TRANSLATE_NOOP( "TQFont", "Tagalog" );
break; break;
case TQFont::Hanunoo: case TQFont::Hanunoo:
name = QT_TRANSLATE_NOOP( "TQFont", "Hanunoo" ); name = TQT_TRANSLATE_NOOP( "TQFont", "Hanunoo" );
break; break;
case TQFont::Buhid: case TQFont::Buhid:
name = QT_TRANSLATE_NOOP( "TQFont", "Buhid" ); name = TQT_TRANSLATE_NOOP( "TQFont", "Buhid" );
break; break;
case TQFont::Tagbanwa: case TQFont::Tagbanwa:
name = QT_TRANSLATE_NOOP( "TQFont", "Tagbanwa" ); name = TQT_TRANSLATE_NOOP( "TQFont", "Tagbanwa" );
break; break;
case TQFont::KatakanaHalfWidth: case TQFont::KatakanaHalfWidth:
name = QT_TRANSLATE_NOOP( "TQFont", "Katakana Half-Width Forms" ); name = TQT_TRANSLATE_NOOP( "TQFont", "Katakana Half-Width Forms" );
break; break;
case TQFont::Han_Japanese: case TQFont::Han_Japanese:
name = QT_TRANSLATE_NOOP( "TQFont", "Han (Japanese)" ); name = TQT_TRANSLATE_NOOP( "TQFont", "Han (Japanese)" );
break; break;
case TQFont::Han_SimplifiedChinese: case TQFont::Han_SimplifiedChinese:
name = QT_TRANSLATE_NOOP( "TQFont", "Han (Simplified Chinese)" ); name = TQT_TRANSLATE_NOOP( "TQFont", "Han (Simplified Chinese)" );
break; break;
case TQFont::Han_TraditionalChinese: case TQFont::Han_TraditionalChinese:
name = QT_TRANSLATE_NOOP( "TQFont", "Han (Traditional Chinese)" ); name = TQT_TRANSLATE_NOOP( "TQFont", "Han (Traditional Chinese)" );
break; break;
case TQFont::Han_Korean: case TQFont::Han_Korean:
name = QT_TRANSLATE_NOOP( "TQFont", "Han (Korean)" ); name = TQT_TRANSLATE_NOOP( "TQFont", "Han (Korean)" );
break; break;
default: default:
name = QT_TRANSLATE_NOOP( "TQFont", "Unknown Script" ); name = TQT_TRANSLATE_NOOP( "TQFont", "Unknown Script" );
break; break;
} }

@ -157,7 +157,7 @@ public:
factory = newFactory; factory = newFactory;
} }
Q_DUMMY_COMPARISON_OPERATOR( TQIconSetPrivate ) TQ_DUMMY_COMPARISON_OPERATOR( TQIconSetPrivate )
}; };
TQIconSetIcon *TQIconSetPrivate::icon( const TQIconSet *iconSet, TQIconSetIcon *TQIconSetPrivate::icon( const TQIconSet *iconSet,

@ -86,7 +86,7 @@ public:
virtual ~TQImageFormatPluginPrivate(); virtual ~TQImageFormatPluginPrivate();
TQRESULT queryInterface( const TQUuid &iid, TQUnknownInterface **iface ); TQRESULT queryInterface( const TQUuid &iid, TQUnknownInterface **iface );
Q_REFCOUNT; TQ_REFCOUNT;
TQStringList featureList() const; TQStringList featureList() const;

@ -93,92 +93,92 @@ static struct {
int key; int key;
const char* name; const char* name;
} keyname[] = { } keyname[] = {
{ TQt::Key_Space, QT_TRANSLATE_NOOP( "TQAccel", "Space" ) }, { TQt::Key_Space, TQT_TRANSLATE_NOOP( "TQAccel", "Space" ) },
{ TQt::Key_Escape, QT_TRANSLATE_NOOP( "TQAccel", "Esc" ) }, { TQt::Key_Escape, TQT_TRANSLATE_NOOP( "TQAccel", "Esc" ) },
{ TQt::Key_Tab, QT_TRANSLATE_NOOP( "TQAccel", "Tab" ) }, { TQt::Key_Tab, TQT_TRANSLATE_NOOP( "TQAccel", "Tab" ) },
{ TQt::Key_Backtab, QT_TRANSLATE_NOOP( "TQAccel", "Backtab" ) }, { TQt::Key_Backtab, TQT_TRANSLATE_NOOP( "TQAccel", "Backtab" ) },
{ TQt::Key_Backspace, QT_TRANSLATE_NOOP( "TQAccel", "Backspace" ) }, { TQt::Key_Backspace, TQT_TRANSLATE_NOOP( "TQAccel", "Backspace" ) },
{ TQt::Key_Return, QT_TRANSLATE_NOOP( "TQAccel", "Return" ) }, { TQt::Key_Return, TQT_TRANSLATE_NOOP( "TQAccel", "Return" ) },
{ TQt::Key_Enter, QT_TRANSLATE_NOOP( "TQAccel", "Enter" ) }, { TQt::Key_Enter, TQT_TRANSLATE_NOOP( "TQAccel", "Enter" ) },
{ TQt::Key_Insert, QT_TRANSLATE_NOOP( "TQAccel", "Ins" ) }, { TQt::Key_Insert, TQT_TRANSLATE_NOOP( "TQAccel", "Ins" ) },
{ TQt::Key_Delete, QT_TRANSLATE_NOOP( "TQAccel", "Del" ) }, { TQt::Key_Delete, TQT_TRANSLATE_NOOP( "TQAccel", "Del" ) },
{ TQt::Key_Pause, QT_TRANSLATE_NOOP( "TQAccel", "Pause" ) }, { TQt::Key_Pause, TQT_TRANSLATE_NOOP( "TQAccel", "Pause" ) },
{ TQt::Key_Print, QT_TRANSLATE_NOOP( "TQAccel", "Print" ) }, { TQt::Key_Print, TQT_TRANSLATE_NOOP( "TQAccel", "Print" ) },
{ TQt::Key_SysReq, QT_TRANSLATE_NOOP( "TQAccel", "SysReq" ) }, { TQt::Key_SysReq, TQT_TRANSLATE_NOOP( "TQAccel", "SysReq" ) },
{ TQt::Key_Home, QT_TRANSLATE_NOOP( "TQAccel", "Home" ) }, { TQt::Key_Home, TQT_TRANSLATE_NOOP( "TQAccel", "Home" ) },
{ TQt::Key_End, QT_TRANSLATE_NOOP( "TQAccel", "End" ) }, { TQt::Key_End, TQT_TRANSLATE_NOOP( "TQAccel", "End" ) },
{ TQt::Key_Left, QT_TRANSLATE_NOOP( "TQAccel", "Left" ) }, { TQt::Key_Left, TQT_TRANSLATE_NOOP( "TQAccel", "Left" ) },
{ TQt::Key_Up, QT_TRANSLATE_NOOP( "TQAccel", "Up" ) }, { TQt::Key_Up, TQT_TRANSLATE_NOOP( "TQAccel", "Up" ) },
{ TQt::Key_Right, QT_TRANSLATE_NOOP( "TQAccel", "Right" ) }, { TQt::Key_Right, TQT_TRANSLATE_NOOP( "TQAccel", "Right" ) },
{ TQt::Key_Down, QT_TRANSLATE_NOOP( "TQAccel", "Down" ) }, { TQt::Key_Down, TQT_TRANSLATE_NOOP( "TQAccel", "Down" ) },
{ TQt::Key_Prior, QT_TRANSLATE_NOOP( "TQAccel", "PgUp" ) }, { TQt::Key_Prior, TQT_TRANSLATE_NOOP( "TQAccel", "PgUp" ) },
{ TQt::Key_Next, QT_TRANSLATE_NOOP( "TQAccel", "PgDown" ) }, { TQt::Key_Next, TQT_TRANSLATE_NOOP( "TQAccel", "PgDown" ) },
{ TQt::Key_CapsLock, QT_TRANSLATE_NOOP( "TQAccel", "CapsLock" ) }, { TQt::Key_CapsLock, TQT_TRANSLATE_NOOP( "TQAccel", "CapsLock" ) },
{ TQt::Key_NumLock, QT_TRANSLATE_NOOP( "TQAccel", "NumLock" ) }, { TQt::Key_NumLock, TQT_TRANSLATE_NOOP( "TQAccel", "NumLock" ) },
{ TQt::Key_ScrollLock, QT_TRANSLATE_NOOP( "TQAccel", "ScrollLock" ) }, { TQt::Key_ScrollLock, TQT_TRANSLATE_NOOP( "TQAccel", "ScrollLock" ) },
{ TQt::Key_Menu, QT_TRANSLATE_NOOP( "TQAccel", "Menu" ) }, { TQt::Key_Menu, TQT_TRANSLATE_NOOP( "TQAccel", "Menu" ) },
{ TQt::Key_Help, QT_TRANSLATE_NOOP( "TQAccel", "Help" ) }, { TQt::Key_Help, TQT_TRANSLATE_NOOP( "TQAccel", "Help" ) },
// Multimedia keys // Multimedia keys
{ TQt::Key_Back, QT_TRANSLATE_NOOP( "TQAccel", "Back" ) }, { TQt::Key_Back, TQT_TRANSLATE_NOOP( "TQAccel", "Back" ) },
{ TQt::Key_Forward, QT_TRANSLATE_NOOP( "TQAccel", "Forward" ) }, { TQt::Key_Forward, TQT_TRANSLATE_NOOP( "TQAccel", "Forward" ) },
{ TQt::Key_Stop, QT_TRANSLATE_NOOP( "TQAccel", "Stop" ) }, { TQt::Key_Stop, TQT_TRANSLATE_NOOP( "TQAccel", "Stop" ) },
{ TQt::Key_Refresh, QT_TRANSLATE_NOOP( "TQAccel", "Refresh" ) }, { TQt::Key_Refresh, TQT_TRANSLATE_NOOP( "TQAccel", "Refresh" ) },
{ TQt::Key_VolumeDown, QT_TRANSLATE_NOOP( "TQAccel", "Volume Down" ) }, { TQt::Key_VolumeDown, TQT_TRANSLATE_NOOP( "TQAccel", "Volume Down" ) },
{ TQt::Key_VolumeMute, QT_TRANSLATE_NOOP( "TQAccel", "Volume Mute" ) }, { TQt::Key_VolumeMute, TQT_TRANSLATE_NOOP( "TQAccel", "Volume Mute" ) },
{ TQt::Key_VolumeUp, QT_TRANSLATE_NOOP( "TQAccel", "Volume Up" ) }, { TQt::Key_VolumeUp, TQT_TRANSLATE_NOOP( "TQAccel", "Volume Up" ) },
{ TQt::Key_BassBoost, QT_TRANSLATE_NOOP( "TQAccel", "Bass Boost" ) }, { TQt::Key_BassBoost, TQT_TRANSLATE_NOOP( "TQAccel", "Bass Boost" ) },
{ TQt::Key_BassUp, QT_TRANSLATE_NOOP( "TQAccel", "Bass Up" ) }, { TQt::Key_BassUp, TQT_TRANSLATE_NOOP( "TQAccel", "Bass Up" ) },
{ TQt::Key_BassDown, QT_TRANSLATE_NOOP( "TQAccel", "Bass Down" ) }, { TQt::Key_BassDown, TQT_TRANSLATE_NOOP( "TQAccel", "Bass Down" ) },
{ TQt::Key_TrebleUp, QT_TRANSLATE_NOOP( "TQAccel", "Treble Up" ) }, { TQt::Key_TrebleUp, TQT_TRANSLATE_NOOP( "TQAccel", "Treble Up" ) },
{ TQt::Key_TrebleDown, QT_TRANSLATE_NOOP( "TQAccel", "Treble Down" ) }, { TQt::Key_TrebleDown, TQT_TRANSLATE_NOOP( "TQAccel", "Treble Down" ) },
{ TQt::Key_MediaPlay, QT_TRANSLATE_NOOP( "TQAccel", "Media Play" ) }, { TQt::Key_MediaPlay, TQT_TRANSLATE_NOOP( "TQAccel", "Media Play" ) },
{ TQt::Key_MediaStop, QT_TRANSLATE_NOOP( "TQAccel", "Media Stop" ) }, { TQt::Key_MediaStop, TQT_TRANSLATE_NOOP( "TQAccel", "Media Stop" ) },
{ TQt::Key_MediaPrev, QT_TRANSLATE_NOOP( "TQAccel", "Media Previous" ) }, { TQt::Key_MediaPrev, TQT_TRANSLATE_NOOP( "TQAccel", "Media Previous" ) },
{ TQt::Key_MediaNext, QT_TRANSLATE_NOOP( "TQAccel", "Media Next" ) }, { TQt::Key_MediaNext, TQT_TRANSLATE_NOOP( "TQAccel", "Media Next" ) },
{ TQt::Key_MediaRecord, QT_TRANSLATE_NOOP( "TQAccel", "Media Record" ) }, { TQt::Key_MediaRecord, TQT_TRANSLATE_NOOP( "TQAccel", "Media Record" ) },
{ TQt::Key_HomePage, QT_TRANSLATE_NOOP( "TQAccel", "Home" ) }, { TQt::Key_HomePage, TQT_TRANSLATE_NOOP( "TQAccel", "Home" ) },
{ TQt::Key_Favorites, QT_TRANSLATE_NOOP( "TQAccel", "Favorites" ) }, { TQt::Key_Favorites, TQT_TRANSLATE_NOOP( "TQAccel", "Favorites" ) },
{ TQt::Key_Search, QT_TRANSLATE_NOOP( "TQAccel", "Search" ) }, { TQt::Key_Search, TQT_TRANSLATE_NOOP( "TQAccel", "Search" ) },
{ TQt::Key_Standby, QT_TRANSLATE_NOOP( "TQAccel", "Standby" ) }, { TQt::Key_Standby, TQT_TRANSLATE_NOOP( "TQAccel", "Standby" ) },
{ TQt::Key_OpenUrl, QT_TRANSLATE_NOOP( "TQAccel", "Open URL" ) }, { TQt::Key_OpenUrl, TQT_TRANSLATE_NOOP( "TQAccel", "Open URL" ) },
{ TQt::Key_LaunchMail, QT_TRANSLATE_NOOP( "TQAccel", "Launch Mail" ) }, { TQt::Key_LaunchMail, TQT_TRANSLATE_NOOP( "TQAccel", "Launch Mail" ) },
{ TQt::Key_LaunchMedia, QT_TRANSLATE_NOOP( "TQAccel", "Launch Media" ) }, { TQt::Key_LaunchMedia, TQT_TRANSLATE_NOOP( "TQAccel", "Launch Media" ) },
{ TQt::Key_Launch0, QT_TRANSLATE_NOOP( "TQAccel", "Launch (0)" ) }, { TQt::Key_Launch0, TQT_TRANSLATE_NOOP( "TQAccel", "Launch (0)" ) },
{ TQt::Key_Launch1, QT_TRANSLATE_NOOP( "TQAccel", "Launch (1)" ) }, { TQt::Key_Launch1, TQT_TRANSLATE_NOOP( "TQAccel", "Launch (1)" ) },
{ TQt::Key_Launch2, QT_TRANSLATE_NOOP( "TQAccel", "Launch (2)" ) }, { TQt::Key_Launch2, TQT_TRANSLATE_NOOP( "TQAccel", "Launch (2)" ) },
{ TQt::Key_Launch3, QT_TRANSLATE_NOOP( "TQAccel", "Launch (3)" ) }, { TQt::Key_Launch3, TQT_TRANSLATE_NOOP( "TQAccel", "Launch (3)" ) },
{ TQt::Key_Launch4, QT_TRANSLATE_NOOP( "TQAccel", "Launch (4)" ) }, { TQt::Key_Launch4, TQT_TRANSLATE_NOOP( "TQAccel", "Launch (4)" ) },
{ TQt::Key_Launch5, QT_TRANSLATE_NOOP( "TQAccel", "Launch (5)" ) }, { TQt::Key_Launch5, TQT_TRANSLATE_NOOP( "TQAccel", "Launch (5)" ) },
{ TQt::Key_Launch6, QT_TRANSLATE_NOOP( "TQAccel", "Launch (6)" ) }, { TQt::Key_Launch6, TQT_TRANSLATE_NOOP( "TQAccel", "Launch (6)" ) },
{ TQt::Key_Launch7, QT_TRANSLATE_NOOP( "TQAccel", "Launch (7)" ) }, { TQt::Key_Launch7, TQT_TRANSLATE_NOOP( "TQAccel", "Launch (7)" ) },
{ TQt::Key_Launch8, QT_TRANSLATE_NOOP( "TQAccel", "Launch (8)" ) }, { TQt::Key_Launch8, TQT_TRANSLATE_NOOP( "TQAccel", "Launch (8)" ) },
{ TQt::Key_Launch9, QT_TRANSLATE_NOOP( "TQAccel", "Launch (9)" ) }, { TQt::Key_Launch9, TQT_TRANSLATE_NOOP( "TQAccel", "Launch (9)" ) },
{ TQt::Key_LaunchA, QT_TRANSLATE_NOOP( "TQAccel", "Launch (A)" ) }, { TQt::Key_LaunchA, TQT_TRANSLATE_NOOP( "TQAccel", "Launch (A)" ) },
{ TQt::Key_LaunchB, QT_TRANSLATE_NOOP( "TQAccel", "Launch (B)" ) }, { TQt::Key_LaunchB, TQT_TRANSLATE_NOOP( "TQAccel", "Launch (B)" ) },
{ TQt::Key_LaunchC, QT_TRANSLATE_NOOP( "TQAccel", "Launch (C)" ) }, { TQt::Key_LaunchC, TQT_TRANSLATE_NOOP( "TQAccel", "Launch (C)" ) },
{ TQt::Key_LaunchD, QT_TRANSLATE_NOOP( "TQAccel", "Launch (D)" ) }, { TQt::Key_LaunchD, TQT_TRANSLATE_NOOP( "TQAccel", "Launch (D)" ) },
{ TQt::Key_LaunchE, QT_TRANSLATE_NOOP( "TQAccel", "Launch (E)" ) }, { TQt::Key_LaunchE, TQT_TRANSLATE_NOOP( "TQAccel", "Launch (E)" ) },
{ TQt::Key_LaunchF, QT_TRANSLATE_NOOP( "TQAccel", "Launch (F)" ) }, { TQt::Key_LaunchF, TQT_TRANSLATE_NOOP( "TQAccel", "Launch (F)" ) },
{ TQt::Key_MonBrightnessUp, QT_TRANSLATE_NOOP( "TQAccel", "Monitor Brightness Up" ) }, { TQt::Key_MonBrightnessUp, TQT_TRANSLATE_NOOP( "TQAccel", "Monitor Brightness Up" ) },
{ TQt::Key_MonBrightnessDown, QT_TRANSLATE_NOOP( "TQAccel", "Monitor Brightness Down" ) }, { TQt::Key_MonBrightnessDown, TQT_TRANSLATE_NOOP( "TQAccel", "Monitor Brightness Down" ) },
{ TQt::Key_KeyboardLightOnOff, QT_TRANSLATE_NOOP( "TQAccel", "Keyboard Light On Off" ) }, { TQt::Key_KeyboardLightOnOff, TQT_TRANSLATE_NOOP( "TQAccel", "Keyboard Light On Off" ) },
{ TQt::Key_KeyboardBrightnessUp,QT_TRANSLATE_NOOP( "TQAccel", "Keyboard Brightness Up" ) }, { TQt::Key_KeyboardBrightnessUp, TQT_TRANSLATE_NOOP( "TQAccel", "Keyboard Brightness Up" ) },
{ TQt::Key_KeyboardBrightnessDown, QT_TRANSLATE_NOOP( "TQAccel", "Keyboard Brightness Down" ) }, { TQt::Key_KeyboardBrightnessDown, TQT_TRANSLATE_NOOP( "TQAccel", "Keyboard Brightness Down" ) },
// -------------------------------------------------------------- // --------------------------------------------------------------
// More consistent namings // More consistent namings
{ TQt::Key_Print, QT_TRANSLATE_NOOP( "TQAccel", "Print Screen" ) }, { TQt::Key_Print, TQT_TRANSLATE_NOOP( "TQAccel", "Print Screen" ) },
{ TQt::Key_Prior, QT_TRANSLATE_NOOP( "TQAccel", "Page Up" ) }, { TQt::Key_Prior, TQT_TRANSLATE_NOOP( "TQAccel", "Page Up" ) },
{ TQt::Key_Next, QT_TRANSLATE_NOOP( "TQAccel", "Page Down" ) }, { TQt::Key_Next, TQT_TRANSLATE_NOOP( "TQAccel", "Page Down" ) },
{ TQt::Key_CapsLock, QT_TRANSLATE_NOOP( "TQAccel", "Caps Lock" ) }, { TQt::Key_CapsLock, TQT_TRANSLATE_NOOP( "TQAccel", "Caps Lock" ) },
{ TQt::Key_NumLock, QT_TRANSLATE_NOOP( "TQAccel", "Num Lock" ) }, { TQt::Key_NumLock, TQT_TRANSLATE_NOOP( "TQAccel", "Num Lock" ) },
{ TQt::Key_NumLock, QT_TRANSLATE_NOOP( "TQAccel", "Number Lock" ) }, { TQt::Key_NumLock, TQT_TRANSLATE_NOOP( "TQAccel", "Number Lock" ) },
{ TQt::Key_ScrollLock, QT_TRANSLATE_NOOP( "TQAccel", "Scroll Lock" ) }, { TQt::Key_ScrollLock, TQT_TRANSLATE_NOOP( "TQAccel", "Scroll Lock" ) },
{ TQt::Key_Insert, QT_TRANSLATE_NOOP( "TQAccel", "Insert" ) }, { TQt::Key_Insert, TQT_TRANSLATE_NOOP( "TQAccel", "Insert" ) },
{ TQt::Key_Delete, QT_TRANSLATE_NOOP( "TQAccel", "Delete" ) }, { TQt::Key_Delete, TQT_TRANSLATE_NOOP( "TQAccel", "Delete" ) },
{ TQt::Key_Escape, QT_TRANSLATE_NOOP( "TQAccel", "Escape" ) }, { TQt::Key_Escape, TQT_TRANSLATE_NOOP( "TQAccel", "Escape" ) },
{ TQt::Key_SysReq, QT_TRANSLATE_NOOP( "TQAccel", "System Request" ) }, { TQt::Key_SysReq, TQT_TRANSLATE_NOOP( "TQAccel", "System Request" ) },
{ 0, 0 } { 0, 0 }
}; };

@ -1555,7 +1555,7 @@ struct Q_EXPORT TQTextDocumentTag {
return *this; return *this;
} }
Q_DUMMY_COMPARISON_OPERATOR(TQTextDocumentTag) TQ_DUMMY_COMPARISON_OPERATOR(TQTextDocumentTag)
}; };
@ -6563,7 +6563,7 @@ struct TQPixmapInt
TQPixmapInt() : ref( 0 ) {} TQPixmapInt() : ref( 0 ) {}
TQPixmap pm; TQPixmap pm;
int ref; int ref;
Q_DUMMY_COMPARISON_OPERATOR(TQPixmapInt) TQ_DUMMY_COMPARISON_OPERATOR(TQPixmapInt)
}; };
static TQMap<TQString, TQPixmapInt> *pixmap_map = 0; static TQMap<TQString, TQPixmapInt> *pixmap_map = 0;

@ -760,7 +760,7 @@ struct Q_EXPORT TQTextDocumentSelection
{ {
TQTextCursor startCursor, endCursor; TQTextCursor startCursor, endCursor;
bool swapped; bool swapped;
Q_DUMMY_COMPARISON_OPERATOR(TQTextDocumentSelection) TQ_DUMMY_COMPARISON_OPERATOR(TQTextDocumentSelection)
}; };
#if defined(Q_TEMPLATEDLL) #if defined(Q_TEMPLATEDLL)
@ -1128,7 +1128,7 @@ struct Q_EXPORT TQTextParagraphSelection
{ {
TQTextParagraphSelection() : start(0), end(0) { } TQTextParagraphSelection() : start(0), end(0) { }
int start, end; int start, end;
Q_DUMMY_COMPARISON_OPERATOR(TQTextParagraphSelection) TQ_DUMMY_COMPARISON_OPERATOR(TQTextParagraphSelection)
}; };
struct Q_EXPORT TQTextLineStart struct Q_EXPORT TQTextLineStart

@ -98,7 +98,7 @@ private:
}; };
template <class T> template <class T>
Q_INLINE_TEMPLATES TQVarLengthArray<T>::TQVarLengthArray(int asize) TQ_INLINE_TEMPLATES TQVarLengthArray<T>::TQVarLengthArray(int asize)
: s(asize) { : s(asize) {
if (s > Prealloc) { if (s > Prealloc) {
ptr = reinterpret_cast<T *>(malloc(s * sizeof(T))); ptr = reinterpret_cast<T *>(malloc(s * sizeof(T)));

@ -182,7 +182,7 @@ public:
bool operator<( const Offset&k ) const { bool operator<( const Offset&k ) const {
return ( h != k.h ) ? h < k.h : o < k.o; return ( h != k.h ) ? h < k.h : o < k.o;
} }
Q_DUMMY_COMPARISON_OPERATOR(TQTranslatorPrivate::Offset) TQ_DUMMY_COMPARISON_OPERATOR(TQTranslatorPrivate::Offset)
uint h; uint h;
uint o; uint o;
}; };

@ -97,7 +97,7 @@ public:
:name(n), priority(p) {} :name(n), priority(p) {}
TQString name; TQString name;
TQ_UINT16 priority; TQ_UINT16 priority;
Q_DUMMY_COMPARISON_OPERATOR(MailServer) TQ_DUMMY_COMPARISON_OPERATOR(MailServer)
}; };
TQValueList<MailServer> mailServers() const; TQValueList<MailServer> mailServers() const;
@ -109,7 +109,7 @@ public:
TQ_UINT16 priority; TQ_UINT16 priority;
TQ_UINT16 weight; TQ_UINT16 weight;
TQ_UINT16 port; TQ_UINT16 port;
Q_DUMMY_COMPARISON_OPERATOR(Server) TQ_DUMMY_COMPARISON_OPERATOR(Server)
}; };
TQValueList<Server> servers() const; TQValueList<Server> servers() const;

@ -95,7 +95,7 @@ public:
virtual ~TQSqlDriverPluginPrivate(); virtual ~TQSqlDriverPluginPrivate();
TQRESULT queryInterface( const TQUuid &iid, TQUnknownInterface **iface ); TQRESULT queryInterface( const TQUuid &iid, TQUnknownInterface **iface );
Q_REFCOUNT; TQ_REFCOUNT;
TQStringList featureList() const; TQStringList featureList() const;
TQSqlDriver *create( const TQString &key ); TQSqlDriver *create( const TQString &key );

@ -75,7 +75,7 @@ struct TQSqlParam {
TQSqlParam( const TQVariant& v = TQVariant(), TQSql::ParameterType t = TQSql::In ): value( v ), typ( t ) {} TQSqlParam( const TQVariant& v = TQVariant(), TQSql::ParameterType t = TQSql::In ): value( v ), typ( t ) {}
TQVariant value; TQVariant value;
TQSql::ParameterType typ; TQSql::ParameterType typ;
Q_DUMMY_COMPARISON_OPERATOR(TQSqlParam) TQ_DUMMY_COMPARISON_OPERATOR(TQSqlParam)
}; };
struct Holder { struct Holder {

@ -68,7 +68,7 @@ public:
{ {
return !field.name().isNull(); return !field.name().isNull();
} }
Q_DUMMY_COMPARISON_OPERATOR(info) TQ_DUMMY_COMPARISON_OPERATOR(info)
TQSqlField field; TQSqlField field;
bool nogen; bool nogen;
}; };

@ -95,7 +95,7 @@ public:
virtual ~TQStylePluginPrivate(); virtual ~TQStylePluginPrivate();
TQRESULT queryInterface( const TQUuid &iid, TQUnknownInterface **iface ); TQRESULT queryInterface( const TQUuid &iid, TQUnknownInterface **iface );
Q_REFCOUNT; TQ_REFCOUNT;
TQStringList featureList() const; TQStringList featureList() const;
TQStyle *create( const TQString &key ); TQStyle *create( const TQString &key );

@ -248,12 +248,12 @@
# define Q_CC_MSVC # define Q_CC_MSVC
/* proper support of bool for _MSC_VER >= 1100 */ /* proper support of bool for _MSC_VER >= 1100 */
# define Q_CANNOT_DELETE_CONSTANT # define Q_CANNOT_DELETE_CONSTANT
# define Q_INLINE_TEMPLATES inline # define TQ_INLINE_TEMPLATES inline
/* Visual C++.Net issues for _MSC_VER >= 1300 */ /* Visual C++.Net issues for _MSC_VER >= 1300 */
# if _MSC_VER >= 1300 # if _MSC_VER >= 1300
# define Q_CC_MSVC_NET # define Q_CC_MSVC_NET
# if _MSC_VER < 1310 || (defined(Q_OS_WIN64) && defined(_M_IA64)) # if _MSC_VER < 1310 || (defined(Q_OS_WIN64) && defined(_M_IA64))
# define Q_TYPENAME # define TQ_TYPENAME
# endif # endif
# endif # endif
/* Intel C++ disguising as Visual C++: the `using' keyword avoids warnings */ /* Intel C++ disguising as Visual C++: the `using' keyword avoids warnings */
@ -278,7 +278,7 @@
# define Q_CC_WAT # define Q_CC_WAT
# if defined(Q_OS_QNX4) # if defined(Q_OS_QNX4)
/* compiler flags */ /* compiler flags */
# define Q_TYPENAME # define TQ_TYPENAME
# define Q_NO_BOOL_TYPE # define Q_NO_BOOL_TYPE
# define Q_CANNOT_DELETE_CONSTANT # define Q_CANNOT_DELETE_CONSTANT
# define mutable # define mutable
@ -357,8 +357,8 @@
# define Q_NO_BOOL_TYPE # define Q_NO_BOOL_TYPE
# define Q_NO_EXPLICIT_KEYWORD # define Q_NO_EXPLICIT_KEYWORD
# define Q_NO_USING_KEYWORD # define Q_NO_USING_KEYWORD
# define Q_TYPENAME # define TQ_TYPENAME
# define Q_INLINE_TEMPLATES inline # define TQ_INLINE_TEMPLATES inline
# define Q_BROKEN_TEMPLATE_SPECIALIZATION # define Q_BROKEN_TEMPLATE_SPECIALIZATION
# define Q_CANNOT_DELETE_CONSTANT # define Q_CANNOT_DELETE_CONSTANT
# endif # endif
@ -386,12 +386,12 @@
/* Apply to all versions prior to Compaq C++ V6.0-000 - observed on /* Apply to all versions prior to Compaq C++ V6.0-000 - observed on
DEC C++ V5.5-004. */ DEC C++ V5.5-004. */
# if __DECCXX_VER < 60060000 # if __DECCXX_VER < 60060000
# define Q_TYPENAME # define TQ_TYPENAME
# define Q_BROKEN_TEMPLATE_SPECIALIZATION # define Q_BROKEN_TEMPLATE_SPECIALIZATION
# define Q_CANNOT_DELETE_CONSTANT # define Q_CANNOT_DELETE_CONSTANT
# endif # endif
/* avoid undefined symbol problems with out-of-line template members */ /* avoid undefined symbol problems with out-of-line template members */
# define Q_INLINE_TEMPLATES inline # define TQ_INLINE_TEMPLATES inline
/* Compilers with EDG front end are similar. To detect them we test: /* Compilers with EDG front end are similar. To detect them we test:
__EDG documented by SGI, observed on MIPSpro 7.3.1.1 and KAI C++ 4.0b __EDG documented by SGI, observed on MIPSpro 7.3.1.1 and KAI C++ 4.0b
@ -448,7 +448,7 @@
# define Q_CC_USLC # define Q_CC_USLC
/* The latest UDK 7.1.1b does not need this, but previous versions do */ /* The latest UDK 7.1.1b does not need this, but previous versions do */
# if !defined(__SCO_VERSION__) || (__SCO_VERSION__ < 302200010) # if !defined(__SCO_VERSION__) || (__SCO_VERSION__ < 302200010)
# define Q_INLINE_TEMPLATES inline # define TQ_INLINE_TEMPLATES inline
# endif # endif
# define Q_NO_USING_KEYWORD /* ### check "using" status */ # define Q_NO_USING_KEYWORD /* ### check "using" status */
@ -471,12 +471,12 @@
# elif defined(__sgi) # elif defined(__sgi)
# define Q_CC_MIPS # define Q_CC_MIPS
# if defined(_MIPS_SIM) && (_MIPS_SIM == _ABIO32) /* o32 ABI */ # if defined(_MIPS_SIM) && (_MIPS_SIM == _ABIO32) /* o32 ABI */
# define Q_TYPENAME # define TQ_TYPENAME
# define Q_BROKEN_TEMPLATE_SPECIALIZATION # define Q_BROKEN_TEMPLATE_SPECIALIZATION
# define Q_NO_EXPLICIT_KEYWORD # define Q_NO_EXPLICIT_KEYWORD
# define Q_INLINE_TEMPLATES inline # define TQ_INLINE_TEMPLATES inline
# elif defined(_COMPILER_VERSION) && (_COMPILER_VERSION < 730) /* 7.2 */ # elif defined(_COMPILER_VERSION) && (_COMPILER_VERSION < 730) /* 7.2 */
# define Q_TYPENAME # define TQ_TYPENAME
# define Q_BROKEN_TEMPLATE_SPECIALIZATION # define Q_BROKEN_TEMPLATE_SPECIALIZATION
# endif # endif
# define Q_NO_USING_KEYWORD /* ### check "using" status */ # define Q_NO_USING_KEYWORD /* ### check "using" status */
@ -488,11 +488,11 @@
/* The older UnixWare 2.X compiler? */ /* The older UnixWare 2.X compiler? */
#elif defined(__USLC__) #elif defined(__USLC__)
# define Q_CC_USLC # define Q_CC_USLC
# define Q_TYPENAME # define TQ_TYPENAME
# define Q_NO_BOOL_TYPE # define Q_NO_BOOL_TYPE
# define Q_NO_EXPLICIT_KEYWORD # define Q_NO_EXPLICIT_KEYWORD
# define Q_NO_USING_KEYWORD # define Q_NO_USING_KEYWORD
# define Q_INLINE_TEMPLATES inline # define TQ_INLINE_TEMPLATES inline
/* Never tested! */ /* Never tested! */
#elif defined(__HIGHC__) #elif defined(__HIGHC__)
@ -925,12 +925,12 @@ Q_EXPORT int qWinVersion();
#define QT_WA_INLINE( uni, ansi ) ( uni ) #define QT_WA_INLINE( uni, ansi ) ( uni )
#endif #endif
#ifndef Q_INLINE_TEMPLATES #ifndef TQ_INLINE_TEMPLATES
# define Q_INLINE_TEMPLATES # define TQ_INLINE_TEMPLATES
#endif #endif
#ifndef Q_TYPENAME #ifndef TQ_TYPENAME
# define Q_TYPENAME typename # define TQ_TYPENAME typename
#endif #endif
// //
@ -1060,13 +1060,13 @@ Q_EXPORT const char *tqInstallPathShare();
mandating a real implementation. mandating a real implementation.
*/ */
#ifdef TQ_FULL_TEMPLATE_INSTANTIATION #ifdef TQ_FULL_TEMPLATE_INSTANTIATION
# define Q_DUMMY_COMPARISON_OPERATOR(C) \ # define TQ_DUMMY_COMPARISON_OPERATOR(C) \
bool operator==( const C& ) const { \ bool operator==( const C& ) const { \
tqWarning( #C"::operator==( const "#C"& ) got called." ); \ tqWarning( #C"::operator==( const "#C"& ) got called." ); \
return FALSE; \ return FALSE; \
} }
#else #else
# define Q_DUMMY_COMPARISON_OPERATOR(C) # define TQ_DUMMY_COMPARISON_OPERATOR(C)
#endif #endif
#endif /* TQGLOBAL_H */ #endif /* TQGLOBAL_H */

@ -167,7 +167,7 @@ public:
}; };
template <class K, class T> template <class K, class T>
Q_INLINE_TEMPLATES int TQMapIterator<K,T>::inc() TQ_INLINE_TEMPLATES int TQMapIterator<K,T>::inc()
{ {
TQMapNodeBase* tmp = node; TQMapNodeBase* tmp = node;
if ( tmp->right ) { if ( tmp->right ) {
@ -188,7 +188,7 @@ Q_INLINE_TEMPLATES int TQMapIterator<K,T>::inc()
} }
template <class K, class T> template <class K, class T>
Q_INLINE_TEMPLATES int TQMapIterator<K,T>::dec() TQ_INLINE_TEMPLATES int TQMapIterator<K,T>::dec()
{ {
TQMapNodeBase* tmp = node; TQMapNodeBase* tmp = node;
if (tmp->color == TQMapNodeBase::Red && if (tmp->color == TQMapNodeBase::Red &&
@ -283,7 +283,7 @@ public:
}; };
template <class K, class T> template <class K, class T>
Q_INLINE_TEMPLATES int TQMapConstIterator<K,T>::inc() TQ_INLINE_TEMPLATES int TQMapConstIterator<K,T>::inc()
{ {
TQMapNodeBase* tmp = node; TQMapNodeBase* tmp = node;
if ( tmp->right ) { if ( tmp->right ) {
@ -304,7 +304,7 @@ Q_INLINE_TEMPLATES int TQMapConstIterator<K,T>::inc()
} }
template <class K, class T> template <class K, class T>
Q_INLINE_TEMPLATES int TQMapConstIterator<K,T>::dec() TQ_INLINE_TEMPLATES int TQMapConstIterator<K,T>::dec()
{ {
TQMapNodeBase* tmp = node; TQMapNodeBase* tmp = node;
if (tmp->color == TQMapNodeBase::Red && if (tmp->color == TQMapNodeBase::Red &&
@ -432,14 +432,14 @@ protected:
template <class Key, class T> template <class Key, class T>
Q_INLINE_TEMPLATES TQMapPrivate<Key,T>::TQMapPrivate() { TQ_INLINE_TEMPLATES TQMapPrivate<Key,T>::TQMapPrivate() {
header = new Node; header = new Node;
header->color = TQMapNodeBase::Red; // Mark the header header->color = TQMapNodeBase::Red; // Mark the header
header->parent = 0; header->parent = 0;
header->left = header->right = header; header->left = header->right = header;
} }
template <class Key, class T> template <class Key, class T>
Q_INLINE_TEMPLATES TQMapPrivate<Key,T>::TQMapPrivate( const TQMapPrivate< Key, T >* _map ) : TQMapPrivateBase( _map ) { TQ_INLINE_TEMPLATES TQMapPrivate<Key,T>::TQMapPrivate( const TQMapPrivate< Key, T >* _map ) : TQMapPrivateBase( _map ) {
header = new Node; header = new Node;
header->color = TQMapNodeBase::Red; // Mark the header header->color = TQMapNodeBase::Red; // Mark the header
if ( _map->header->parent == 0 ) { if ( _map->header->parent == 0 ) {
@ -454,7 +454,7 @@ Q_INLINE_TEMPLATES TQMapPrivate<Key,T>::TQMapPrivate( const TQMapPrivate< Key, T
} }
template <class Key, class T> template <class Key, class T>
Q_INLINE_TEMPLATES Q_TYPENAME TQMapPrivate<Key,T>::NodePtr TQMapPrivate<Key,T>::copy( Q_TYPENAME TQMapPrivate<Key,T>::NodePtr p ) TQ_INLINE_TEMPLATES TQ_TYPENAME TQMapPrivate<Key,T>::NodePtr TQMapPrivate<Key,T>::copy( TQ_TYPENAME TQMapPrivate<Key,T>::NodePtr p )
{ {
if ( !p ) if ( !p )
return 0; return 0;
@ -476,7 +476,7 @@ Q_INLINE_TEMPLATES Q_TYPENAME TQMapPrivate<Key,T>::NodePtr TQMapPrivate<Key,T>::
} }
template <class Key, class T> template <class Key, class T>
Q_INLINE_TEMPLATES void TQMapPrivate<Key,T>::clear() TQ_INLINE_TEMPLATES void TQMapPrivate<Key,T>::clear()
{ {
clear( (NodePtr)(header->parent) ); clear( (NodePtr)(header->parent) );
header->color = TQMapNodeBase::Red; header->color = TQMapNodeBase::Red;
@ -486,7 +486,7 @@ Q_INLINE_TEMPLATES void TQMapPrivate<Key,T>::clear()
} }
template <class Key, class T> template <class Key, class T>
Q_INLINE_TEMPLATES void TQMapPrivate<Key,T>::clear( Q_TYPENAME TQMapPrivate<Key,T>::NodePtr p ) TQ_INLINE_TEMPLATES void TQMapPrivate<Key,T>::clear( TQ_TYPENAME TQMapPrivate<Key,T>::NodePtr p )
{ {
while ( p != 0 ) { while ( p != 0 ) {
clear( (NodePtr)p->right ); clear( (NodePtr)p->right );
@ -497,7 +497,7 @@ Q_INLINE_TEMPLATES void TQMapPrivate<Key,T>::clear( Q_TYPENAME TQMapPrivate<Key,
} }
template <class Key, class T> template <class Key, class T>
Q_INLINE_TEMPLATES Q_TYPENAME TQMapPrivate<Key,T>::ConstIterator TQMapPrivate<Key,T>::find(const Key& k) const TQ_INLINE_TEMPLATES TQ_TYPENAME TQMapPrivate<Key,T>::ConstIterator TQMapPrivate<Key,T>::find(const Key& k) const
{ {
TQMapNodeBase* y = header; // Last node TQMapNodeBase* y = header; // Last node
TQMapNodeBase* x = header->parent; // Root node. TQMapNodeBase* x = header->parent; // Root node.
@ -520,7 +520,7 @@ Q_INLINE_TEMPLATES Q_TYPENAME TQMapPrivate<Key,T>::ConstIterator TQMapPrivate<Ke
} }
template <class Key, class T> template <class Key, class T>
Q_INLINE_TEMPLATES Q_TYPENAME TQMapPrivate<Key,T>::Iterator TQMapPrivate<Key,T>::insertSingle( const Key& k ) TQ_INLINE_TEMPLATES TQ_TYPENAME TQMapPrivate<Key,T>::Iterator TQMapPrivate<Key,T>::insertSingle( const Key& k )
{ {
// Search correct position in the tree // Search correct position in the tree
TQMapNodeBase* y = header; TQMapNodeBase* y = header;
@ -551,7 +551,7 @@ Q_INLINE_TEMPLATES Q_TYPENAME TQMapPrivate<Key,T>::Iterator TQMapPrivate<Key,T>:
template <class Key, class T> template <class Key, class T>
Q_INLINE_TEMPLATES Q_TYPENAME TQMapPrivate<Key,T>::Iterator TQMapPrivate<Key,T>::insert( TQMapNodeBase* x, TQMapNodeBase* y, const Key& k ) TQ_INLINE_TEMPLATES TQ_TYPENAME TQMapPrivate<Key,T>::Iterator TQMapPrivate<Key,T>::insert( TQMapNodeBase* x, TQMapNodeBase* y, const Key& k )
{ {
NodePtr z = new Node( k ); NodePtr z = new Node( k );
if (y == header || x != 0 || k < key(y) ) { if (y == header || x != 0 || k < key(y) ) {
@ -577,15 +577,15 @@ Q_INLINE_TEMPLATES Q_TYPENAME TQMapPrivate<Key,T>::Iterator TQMapPrivate<Key,T>:
#ifdef QT_CHECK_RANGE #ifdef QT_CHECK_RANGE
# if !defined( TQT_NO_DEBUG ) && defined( QT_CHECK_MAP_RANGE ) # if !defined( TQT_NO_DEBUG ) && defined( QT_CHECK_MAP_RANGE )
# define QT_CHECK_INVALID_MAP_ELEMENT if ( empty() ) tqWarning( "TQMap: Warning invalid element" ) # define TQT_CHECK_INVALID_MAP_ELEMENT if ( empty() ) tqWarning( "TQMap: Warning invalid element" )
# define QT_CHECK_INVALID_MAP_ELEMENT_FATAL Q_ASSERT( !empty() ); # define TQT_CHECK_INVALID_MAP_ELEMENT_FATAL Q_ASSERT( !empty() );
# else # else
# define QT_CHECK_INVALID_MAP_ELEMENT # define TQT_CHECK_INVALID_MAP_ELEMENT
# define QT_CHECK_INVALID_MAP_ELEMENT_FATAL # define TQT_CHECK_INVALID_MAP_ELEMENT_FATAL
# endif # endif
#else #else
# define QT_CHECK_INVALID_MAP_ELEMENT # define TQT_CHECK_INVALID_MAP_ELEMENT
# define QT_CHECK_INVALID_MAP_ELEMENT_FATAL # define TQT_CHECK_INVALID_MAP_ELEMENT_FATAL
#endif #endif
template <class T> class TQDeepCopy; template <class T> class TQDeepCopy;
@ -635,7 +635,7 @@ public:
TQMap( const std::map<Key,T>& m ) TQMap( const std::map<Key,T>& m )
{ {
sh = new TQMapPrivate<Key,T>; sh = new TQMapPrivate<Key,T>;
Q_TYPENAME std::map<Key,T>::const_iterator it = m.begin(); TQ_TYPENAME std::map<Key,T>::const_iterator it = m.begin();
for ( ; it != m.end(); ++it ) { for ( ; it != m.end(); ++it ) {
value_type p( (*it).first, (*it).second ); value_type p( (*it).first, (*it).second );
insert( p ); insert( p );
@ -656,7 +656,7 @@ public:
TQMap<Key,T>& operator= ( const std::map<Key,T>& m ) TQMap<Key,T>& operator= ( const std::map<Key,T>& m )
{ {
clear(); clear();
Q_TYPENAME std::map<Key,T>::const_iterator it = m.begin(); TQ_TYPENAME std::map<Key,T>::const_iterator it = m.begin();
for ( ; it != m.end(); ++it ) { for ( ; it != m.end(); ++it ) {
value_type p( (*it).first, (*it).second ); value_type p( (*it).first, (*it).second );
insert( p ); insert( p );
@ -706,7 +706,7 @@ public:
const_iterator find ( const Key& k ) const { return sh->find( k ); } const_iterator find ( const Key& k ) const { return sh->find( k ); }
const T& operator[] ( const Key& k ) const const T& operator[] ( const Key& k ) const
{ QT_CHECK_INVALID_MAP_ELEMENT; return sh->find( k ).data(); } { TQT_CHECK_INVALID_MAP_ELEMENT; return sh->find( k ).data(); }
bool contains ( const Key& k ) const bool contains ( const Key& k ) const
{ return find( k ) != end(); } { return find( k ) != end(); }
//{ return sh->find( k ) != ((const Priv*)sh)->end(); } //{ return sh->find( k ) != ((const Priv*)sh)->end(); }
@ -754,7 +754,7 @@ private:
}; };
template<class Key, class T> template<class Key, class T>
Q_INLINE_TEMPLATES TQMap<Key,T>& TQMap<Key,T>::operator= ( const TQMap<Key,T>& m ) TQ_INLINE_TEMPLATES TQMap<Key,T>& TQMap<Key,T>::operator= ( const TQMap<Key,T>& m )
{ {
m.sh->ref(); m.sh->ref();
if ( sh->deref() ) if ( sh->deref() )
@ -764,7 +764,7 @@ Q_INLINE_TEMPLATES TQMap<Key,T>& TQMap<Key,T>::operator= ( const TQMap<Key,T>& m
} }
template<class Key, class T> template<class Key, class T>
Q_INLINE_TEMPLATES Q_TYPENAME TQMap<Key,T>::insert_pair TQMap<Key,T>::insert( const Q_TYPENAME TQMap<Key,T>::value_type& x ) TQ_INLINE_TEMPLATES TQ_TYPENAME TQMap<Key,T>::insert_pair TQMap<Key,T>::insert( const TQ_TYPENAME TQMap<Key,T>::value_type& x )
{ {
detach(); detach();
size_type n = size(); size_type n = size();
@ -778,7 +778,7 @@ Q_INLINE_TEMPLATES Q_TYPENAME TQMap<Key,T>::insert_pair TQMap<Key,T>::insert( co
} }
template<class Key, class T> template<class Key, class T>
Q_INLINE_TEMPLATES void TQMap<Key,T>::erase( const Key& k ) TQ_INLINE_TEMPLATES void TQMap<Key,T>::erase( const Key& k )
{ {
detach(); detach();
iterator it( sh->find( k ).node ); iterator it( sh->find( k ).node );
@ -787,7 +787,7 @@ Q_INLINE_TEMPLATES void TQMap<Key,T>::erase( const Key& k )
} }
template<class Key, class T> template<class Key, class T>
Q_INLINE_TEMPLATES Q_TYPENAME TQMap<Key,T>::size_type TQMap<Key,T>::count( const Key& k ) const TQ_INLINE_TEMPLATES TQ_TYPENAME TQMap<Key,T>::size_type TQMap<Key,T>::count( const Key& k ) const
{ {
const_iterator it( sh->find( k ).node ); const_iterator it( sh->find( k ).node );
if ( it != end() ) { if ( it != end() ) {
@ -802,7 +802,7 @@ Q_INLINE_TEMPLATES Q_TYPENAME TQMap<Key,T>::size_type TQMap<Key,T>::count( const
} }
template<class Key, class T> template<class Key, class T>
Q_INLINE_TEMPLATES T& TQMap<Key,T>::operator[] ( const Key& k ) TQ_INLINE_TEMPLATES T& TQMap<Key,T>::operator[] ( const Key& k )
{ {
detach(); detach();
TQMapNode<Key,T>* p = sh->find( k ).node; TQMapNode<Key,T>* p = sh->find( k ).node;
@ -812,7 +812,7 @@ Q_INLINE_TEMPLATES T& TQMap<Key,T>::operator[] ( const Key& k )
} }
template<class Key, class T> template<class Key, class T>
Q_INLINE_TEMPLATES void TQMap<Key,T>::clear() TQ_INLINE_TEMPLATES void TQMap<Key,T>::clear()
{ {
if ( sh->count == 1 ) if ( sh->count == 1 )
sh->clear(); sh->clear();
@ -823,7 +823,7 @@ Q_INLINE_TEMPLATES void TQMap<Key,T>::clear()
} }
template<class Key, class T> template<class Key, class T>
Q_INLINE_TEMPLATES Q_TYPENAME TQMap<Key,T>::iterator TQMap<Key,T>::insert( const Key& key, const T& value, bool overwrite ) TQ_INLINE_TEMPLATES TQ_TYPENAME TQMap<Key,T>::iterator TQMap<Key,T>::insert( const Key& key, const T& value, bool overwrite )
{ {
detach(); detach();
size_type n = size(); size_type n = size();
@ -834,7 +834,7 @@ Q_INLINE_TEMPLATES Q_TYPENAME TQMap<Key,T>::iterator TQMap<Key,T>::insert( const
} }
template<class Key, class T> template<class Key, class T>
Q_INLINE_TEMPLATES void TQMap<Key,T>::remove( const Key& k ) TQ_INLINE_TEMPLATES void TQMap<Key,T>::remove( const Key& k )
{ {
detach(); detach();
iterator it( sh->find( k ).node ); iterator it( sh->find( k ).node );
@ -843,7 +843,7 @@ Q_INLINE_TEMPLATES void TQMap<Key,T>::remove( const Key& k )
} }
template<class Key, class T> template<class Key, class T>
Q_INLINE_TEMPLATES void TQMap<Key,T>::detachInternal() TQ_INLINE_TEMPLATES void TQMap<Key,T>::detachInternal()
{ {
sh->deref(); sh = new TQMapPrivate<Key,T>( sh ); sh->deref(); sh = new TQMapPrivate<Key,T>( sh );
} }
@ -851,7 +851,7 @@ Q_INLINE_TEMPLATES void TQMap<Key,T>::detachInternal()
#ifndef TQT_NO_DATASTREAM #ifndef TQT_NO_DATASTREAM
template<class Key, class T> template<class Key, class T>
Q_INLINE_TEMPLATES TQDataStream& operator>>( TQDataStream& s, TQMap<Key,T>& m ) { TQ_INLINE_TEMPLATES TQDataStream& operator>>( TQDataStream& s, TQMap<Key,T>& m ) {
m.clear(); m.clear();
TQ_UINT32 c; TQ_UINT32 c;
s >> c; s >> c;
@ -867,7 +867,7 @@ Q_INLINE_TEMPLATES TQDataStream& operator>>( TQDataStream& s, TQMap<Key,T>& m )
template<class Key, class T> template<class Key, class T>
Q_INLINE_TEMPLATES TQDataStream& operator<<( TQDataStream& s, const TQMap<Key,T>& m ) { TQ_INLINE_TEMPLATES TQDataStream& operator<<( TQDataStream& s, const TQMap<Key,T>& m ) {
s << (TQ_UINT32)m.size(); s << (TQ_UINT32)m.size();
TQMapConstIterator<Key,T> it = m.begin(); TQMapConstIterator<Key,T> it = m.begin();
for( ; it != m.end(); ++it ) for( ; it != m.end(); ++it )

@ -72,20 +72,20 @@ struct TQPair
}; };
template <class T1, class T2> template <class T1, class T2>
Q_INLINE_TEMPLATES bool operator==( const TQPair<T1, T2>& x, const TQPair<T1, T2>& y ) TQ_INLINE_TEMPLATES bool operator==( const TQPair<T1, T2>& x, const TQPair<T1, T2>& y )
{ {
return x.first == y.first && x.second == y.second; return x.first == y.first && x.second == y.second;
} }
template <class T1, class T2> template <class T1, class T2>
Q_INLINE_TEMPLATES bool operator<( const TQPair<T1, T2>& x, const TQPair<T1, T2>& y ) TQ_INLINE_TEMPLATES bool operator<( const TQPair<T1, T2>& x, const TQPair<T1, T2>& y )
{ {
return x.first < y.first || return x.first < y.first ||
( !( y.first < x.first ) && x.second < y.second ); ( !( y.first < x.first ) && x.second < y.second );
} }
template <class T1, class T2> template <class T1, class T2>
Q_INLINE_TEMPLATES TQPair<T1, T2> qMakePair( const T1& x, const T2& y ) TQ_INLINE_TEMPLATES TQPair<T1, T2> qMakePair( const T1& x, const T2& y )
{ {
return TQPair<T1, T2>( x, y ); return TQPair<T1, T2>( x, y );
} }

@ -149,7 +149,7 @@ inline void tqSwap( T& _value1, T& _value2 )
template <class InputIterator> template <class InputIterator>
Q_INLINE_TEMPLATES void qBubbleSort( InputIterator b, InputIterator e ) TQ_INLINE_TEMPLATES void qBubbleSort( InputIterator b, InputIterator e )
{ {
// Goto last element; // Goto last element;
InputIterator last = e; InputIterator last = e;
@ -190,7 +190,7 @@ inline void qBubbleSort( Container &c )
template <class Value> template <class Value>
Q_INLINE_TEMPLATES void qHeapSortPushDown( Value* heap, int first, int last ) TQ_INLINE_TEMPLATES void qHeapSortPushDown( Value* heap, int first, int last )
{ {
int r = first; int r = first;
while ( r <= last / 2 ) { while ( r <= last / 2 ) {
@ -219,7 +219,7 @@ Q_INLINE_TEMPLATES void qHeapSortPushDown( Value* heap, int first, int last )
template <class InputIterator, class Value> template <class InputIterator, class Value>
Q_INLINE_TEMPLATES void qHeapSortHelper( InputIterator b, InputIterator e, Value, uint n ) TQ_INLINE_TEMPLATES void qHeapSortHelper( InputIterator b, InputIterator e, Value, uint n )
{ {
// Create the heap // Create the heap
InputIterator insert = b; InputIterator insert = b;
@ -250,7 +250,7 @@ Q_INLINE_TEMPLATES void qHeapSortHelper( InputIterator b, InputIterator e, Value
template <class InputIterator> template <class InputIterator>
Q_INLINE_TEMPLATES void qHeapSort( InputIterator b, InputIterator e ) TQ_INLINE_TEMPLATES void qHeapSort( InputIterator b, InputIterator e )
{ {
// Empty ? // Empty ?
if ( b == e ) if ( b == e )
@ -271,7 +271,7 @@ Q_INLINE_TEMPLATES void qHeapSort( InputIterator b, InputIterator e )
template <class Container> template <class Container>
Q_INLINE_TEMPLATES void qHeapSort( Container &c ) TQ_INLINE_TEMPLATES void qHeapSort( Container &c )
{ {
if ( c.begin() == c.end() ) if ( c.begin() == c.end() )
return; return;
@ -291,7 +291,7 @@ public:
} }
TQBackInsertIterator<Container>& TQBackInsertIterator<Container>&
operator=( const Q_TYPENAME Container::value_type &value ) operator=( const TQ_TYPENAME Container::value_type &value )
{ {
container->push_back( value ); container->push_back( value );
return *this; return *this;

@ -250,13 +250,13 @@ public:
}; };
template <class T> template <class T>
Q_INLINE_TEMPLATES TQValueListPrivate<T>::TQValueListPrivate() TQ_INLINE_TEMPLATES TQValueListPrivate<T>::TQValueListPrivate()
{ {
node = new Node(); node->next = node->prev = node; nodes = 0; node = new Node(); node->next = node->prev = node; nodes = 0;
} }
template <class T> template <class T>
Q_INLINE_TEMPLATES TQValueListPrivate<T>::TQValueListPrivate( const TQValueListPrivate<T>& _p ) TQ_INLINE_TEMPLATES TQValueListPrivate<T>::TQValueListPrivate( const TQValueListPrivate<T>& _p )
: TQShared() : TQShared()
{ {
node = new Node(); node->next = node->prev = node; nodes = 0; node = new Node(); node->next = node->prev = node; nodes = 0;
@ -268,7 +268,7 @@ Q_INLINE_TEMPLATES TQValueListPrivate<T>::TQValueListPrivate( const TQValueListP
} }
template <class T> template <class T>
Q_INLINE_TEMPLATES TQValueListPrivate<T>::~TQValueListPrivate() { TQ_INLINE_TEMPLATES TQValueListPrivate<T>::~TQValueListPrivate() {
NodePtr p = node->next; NodePtr p = node->next;
while( p != node ) { while( p != node ) {
NodePtr x = p->next; NodePtr x = p->next;
@ -279,7 +279,7 @@ Q_INLINE_TEMPLATES TQValueListPrivate<T>::~TQValueListPrivate() {
} }
template <class T> template <class T>
Q_INLINE_TEMPLATES Q_TYPENAME TQValueListPrivate<T>::Iterator TQValueListPrivate<T>::insert( Q_TYPENAME TQValueListPrivate<T>::Iterator it, const T& x ) TQ_INLINE_TEMPLATES TQ_TYPENAME TQValueListPrivate<T>::Iterator TQValueListPrivate<T>::insert( TQ_TYPENAME TQValueListPrivate<T>::Iterator it, const T& x )
{ {
NodePtr p = new Node( x ); NodePtr p = new Node( x );
p->next = it.node; p->next = it.node;
@ -291,7 +291,7 @@ Q_INLINE_TEMPLATES Q_TYPENAME TQValueListPrivate<T>::Iterator TQValueListPrivate
} }
template <class T> template <class T>
Q_INLINE_TEMPLATES Q_TYPENAME TQValueListPrivate<T>::Iterator TQValueListPrivate<T>::remove( Q_TYPENAME TQValueListPrivate<T>::Iterator it ) TQ_INLINE_TEMPLATES TQ_TYPENAME TQValueListPrivate<T>::Iterator TQValueListPrivate<T>::remove( TQ_TYPENAME TQValueListPrivate<T>::Iterator it )
{ {
Q_ASSERT ( it.node != node ); Q_ASSERT ( it.node != node );
NodePtr next = it.node->next; NodePtr next = it.node->next;
@ -304,7 +304,7 @@ Q_INLINE_TEMPLATES Q_TYPENAME TQValueListPrivate<T>::Iterator TQValueListPrivate
} }
template <class T> template <class T>
Q_INLINE_TEMPLATES Q_TYPENAME TQValueListPrivate<T>::NodePtr TQValueListPrivate<T>::find( Q_TYPENAME TQValueListPrivate<T>::NodePtr start, const T& x ) const TQ_INLINE_TEMPLATES TQ_TYPENAME TQValueListPrivate<T>::NodePtr TQValueListPrivate<T>::find( TQ_TYPENAME TQValueListPrivate<T>::NodePtr start, const T& x ) const
{ {
ConstIterator first( start ); ConstIterator first( start );
ConstIterator last( node ); ConstIterator last( node );
@ -317,7 +317,7 @@ Q_INLINE_TEMPLATES Q_TYPENAME TQValueListPrivate<T>::NodePtr TQValueListPrivate<
} }
template <class T> template <class T>
Q_INLINE_TEMPLATES int TQValueListPrivate<T>::findIndex( Q_TYPENAME TQValueListPrivate<T>::NodePtr start, const T& x ) const TQ_INLINE_TEMPLATES int TQValueListPrivate<T>::findIndex( TQ_TYPENAME TQValueListPrivate<T>::NodePtr start, const T& x ) const
{ {
ConstIterator first( start ); ConstIterator first( start );
ConstIterator last( node ); ConstIterator last( node );
@ -332,7 +332,7 @@ Q_INLINE_TEMPLATES int TQValueListPrivate<T>::findIndex( Q_TYPENAME TQValueListP
} }
template <class T> template <class T>
Q_INLINE_TEMPLATES uint TQValueListPrivate<T>::contains( const T& x ) const TQ_INLINE_TEMPLATES uint TQValueListPrivate<T>::contains( const T& x ) const
{ {
uint result = 0; uint result = 0;
Iterator first = Iterator( node->next ); Iterator first = Iterator( node->next );
@ -346,7 +346,7 @@ Q_INLINE_TEMPLATES uint TQValueListPrivate<T>::contains( const T& x ) const
} }
template <class T> template <class T>
Q_INLINE_TEMPLATES bool TQValueListPrivate<T>::containsYesNo( const T& x ) const TQ_INLINE_TEMPLATES bool TQValueListPrivate<T>::containsYesNo( const T& x ) const
{ {
Iterator first = Iterator( node->next ); Iterator first = Iterator( node->next );
Iterator last = Iterator( node ); Iterator last = Iterator( node );
@ -359,7 +359,7 @@ Q_INLINE_TEMPLATES bool TQValueListPrivate<T>::containsYesNo( const T& x ) const
} }
template <class T> template <class T>
Q_INLINE_TEMPLATES uint TQValueListPrivate<T>::remove( const T& _x ) TQ_INLINE_TEMPLATES uint TQValueListPrivate<T>::remove( const T& _x )
{ {
const T x = _x; const T x = _x;
uint result = 0; uint result = 0;
@ -376,7 +376,7 @@ Q_INLINE_TEMPLATES uint TQValueListPrivate<T>::remove( const T& _x )
} }
template <class T> template <class T>
Q_INLINE_TEMPLATES Q_TYPENAME TQValueListPrivate<T>::NodePtr TQValueListPrivate<T>::at( size_type i ) const TQ_INLINE_TEMPLATES TQ_TYPENAME TQValueListPrivate<T>::NodePtr TQValueListPrivate<T>::at( size_type i ) const
{ {
Q_ASSERT( i <= nodes ); Q_ASSERT( i <= nodes );
NodePtr p = node->next; NodePtr p = node->next;
@ -386,7 +386,7 @@ Q_INLINE_TEMPLATES Q_TYPENAME TQValueListPrivate<T>::NodePtr TQValueListPrivate<
} }
template <class T> template <class T>
Q_INLINE_TEMPLATES void TQValueListPrivate<T>::clear() TQ_INLINE_TEMPLATES void TQValueListPrivate<T>::clear()
{ {
nodes = 0; nodes = 0;
NodePtr p = node->next; NodePtr p = node->next;
@ -596,7 +596,7 @@ private:
}; };
template <class T> template <class T>
Q_INLINE_TEMPLATES bool TQValueList<T>::operator== ( const TQValueList<T>& l ) const TQ_INLINE_TEMPLATES bool TQValueList<T>::operator== ( const TQValueList<T>& l ) const
{ {
if ( size() != l.size() ) if ( size() != l.size() )
return FALSE; return FALSE;
@ -609,13 +609,13 @@ Q_INLINE_TEMPLATES bool TQValueList<T>::operator== ( const TQValueList<T>& l ) c
} }
template <class T> template <class T>
Q_INLINE_TEMPLATES void TQValueList<T>::clear() TQ_INLINE_TEMPLATES void TQValueList<T>::clear()
{ {
if ( sh->count == 1 ) sh->clear(); else { sh->deref(); sh = new TQValueListPrivate<T>(); } if ( sh->count == 1 ) sh->clear(); else { sh->deref(); sh = new TQValueListPrivate<T>(); }
} }
template <class T> template <class T>
Q_INLINE_TEMPLATES Q_TYPENAME TQValueList<T>::iterator TQValueList<T>::erase( Q_TYPENAME TQValueList<T>::iterator first, Q_TYPENAME TQValueList<T>::iterator last ) TQ_INLINE_TEMPLATES TQ_TYPENAME TQValueList<T>::iterator TQValueList<T>::erase( TQ_TYPENAME TQValueList<T>::iterator first, TQ_TYPENAME TQValueList<T>::iterator last )
{ {
while ( first != last ) while ( first != last )
erase( first++ ); erase( first++ );
@ -624,14 +624,14 @@ Q_INLINE_TEMPLATES Q_TYPENAME TQValueList<T>::iterator TQValueList<T>::erase( Q_
template <class T> template <class T>
Q_INLINE_TEMPLATES void TQValueList<T>::insert( Q_TYPENAME TQValueList<T>::iterator pos, size_type n, const T& x ) TQ_INLINE_TEMPLATES void TQValueList<T>::insert( TQ_TYPENAME TQValueList<T>::iterator pos, size_type n, const T& x )
{ {
for ( ; n > 0; --n ) for ( ; n > 0; --n )
insert( pos, x ); insert( pos, x );
} }
template <class T> template <class T>
Q_INLINE_TEMPLATES TQValueList<T> TQValueList<T>::operator+ ( const TQValueList<T>& l ) const TQ_INLINE_TEMPLATES TQValueList<T> TQValueList<T>::operator+ ( const TQValueList<T>& l ) const
{ {
TQValueList<T> l2( *this ); TQValueList<T> l2( *this );
for( const_iterator it = l.begin(); it != l.end(); ++it ) for( const_iterator it = l.begin(); it != l.end(); ++it )
@ -640,7 +640,7 @@ Q_INLINE_TEMPLATES TQValueList<T> TQValueList<T>::operator+ ( const TQValueList<
} }
template <class T> template <class T>
Q_INLINE_TEMPLATES TQValueList<T>& TQValueList<T>::operator+= ( const TQValueList<T>& l ) TQ_INLINE_TEMPLATES TQValueList<T>& TQValueList<T>::operator+= ( const TQValueList<T>& l )
{ {
TQValueList<T> copy = l; TQValueList<T> copy = l;
for( const_iterator it = copy.begin(); it != copy.end(); ++it ) for( const_iterator it = copy.begin(); it != copy.end(); ++it )
@ -650,7 +650,7 @@ Q_INLINE_TEMPLATES TQValueList<T>& TQValueList<T>::operator+= ( const TQValueLis
#ifndef TQT_NO_DATASTREAM #ifndef TQT_NO_DATASTREAM
template <class T> template <class T>
Q_INLINE_TEMPLATES TQDataStream& operator>>( TQDataStream& s, TQValueList<T>& l ) TQ_INLINE_TEMPLATES TQDataStream& operator>>( TQDataStream& s, TQValueList<T>& l )
{ {
l.clear(); l.clear();
TQ_UINT32 c; TQ_UINT32 c;
@ -665,7 +665,7 @@ Q_INLINE_TEMPLATES TQDataStream& operator>>( TQDataStream& s, TQValueList<T>& l
} }
template <class T> template <class T>
Q_INLINE_TEMPLATES TQDataStream& operator<<( TQDataStream& s, const TQValueList<T>& l ) TQ_INLINE_TEMPLATES TQDataStream& operator<<( TQDataStream& s, const TQValueList<T>& l )
{ {
s << (TQ_UINT32)l.size(); s << (TQ_UINT32)l.size();
TQValueListConstIterator<T> it = l.begin(); TQValueListConstIterator<T> it = l.begin();

@ -121,7 +121,7 @@ private:
}; };
template <class T> template <class T>
Q_INLINE_TEMPLATES TQValueVectorPrivate<T>::TQValueVectorPrivate( const TQValueVectorPrivate<T>& x ) TQ_INLINE_TEMPLATES TQValueVectorPrivate<T>::TQValueVectorPrivate( const TQValueVectorPrivate<T>& x )
: TQShared() : TQShared()
{ {
size_t i = x.size(); size_t i = x.size();
@ -142,7 +142,7 @@ Q_INLINE_TEMPLATES TQValueVectorPrivate<T>::TQValueVectorPrivate( const TQValueV
} }
template <class T> template <class T>
Q_INLINE_TEMPLATES TQValueVectorPrivate<T>::TQValueVectorPrivate( size_t size ) TQ_INLINE_TEMPLATES TQValueVectorPrivate<T>::TQValueVectorPrivate( size_t size )
{ {
if ( size > 0 ) { if ( size > 0 ) {
start = new T[size]; start = new T[size];
@ -156,7 +156,7 @@ Q_INLINE_TEMPLATES TQValueVectorPrivate<T>::TQValueVectorPrivate( size_t size )
} }
template <class T> template <class T>
Q_INLINE_TEMPLATES void TQValueVectorPrivate<T>::insert( pointer pos, const T& x ) TQ_INLINE_TEMPLATES void TQValueVectorPrivate<T>::insert( pointer pos, const T& x )
{ {
const size_t lastSize = size(); const size_t lastSize = size();
const size_t n = lastSize !=0 ? 2*lastSize : 1; const size_t n = lastSize !=0 ? 2*lastSize : 1;
@ -173,7 +173,7 @@ Q_INLINE_TEMPLATES void TQValueVectorPrivate<T>::insert( pointer pos, const T& x
} }
template <class T> template <class T>
Q_INLINE_TEMPLATES void TQValueVectorPrivate<T>::insert( pointer pos, size_t n, const T& x ) TQ_INLINE_TEMPLATES void TQValueVectorPrivate<T>::insert( pointer pos, size_t n, const T& x )
{ {
if ( size_t( end - finish ) >= n ) { if ( size_t( end - finish ) >= n ) {
// enough room // enough room
@ -213,7 +213,7 @@ Q_INLINE_TEMPLATES void TQValueVectorPrivate<T>::insert( pointer pos, size_t n,
} }
template <class T> template <class T>
Q_INLINE_TEMPLATES void TQValueVectorPrivate<T>::reserve( size_t n ) TQ_INLINE_TEMPLATES void TQValueVectorPrivate<T>::reserve( size_t n )
{ {
const size_t lastSize = size(); const size_t lastSize = size();
pointer tmp = growAndCopy( n, start, finish ); pointer tmp = growAndCopy( n, start, finish );
@ -223,7 +223,7 @@ Q_INLINE_TEMPLATES void TQValueVectorPrivate<T>::reserve( size_t n )
} }
template <class T> template <class T>
Q_INLINE_TEMPLATES Q_TYPENAME TQValueVectorPrivate<T>::pointer TQValueVectorPrivate<T>::growAndCopy( size_t n, pointer s, pointer f ) TQ_INLINE_TEMPLATES TQ_TYPENAME TQValueVectorPrivate<T>::pointer TQValueVectorPrivate<T>::growAndCopy( size_t n, pointer s, pointer f )
{ {
pointer newStart = new T[n]; pointer newStart = new T[n];
tqCopy( s, f, newStart ); tqCopy( s, f, newStart );
@ -491,21 +491,21 @@ private:
}; };
template <class T> template <class T>
Q_INLINE_TEMPLATES TQValueVector<T>::TQValueVector( size_type n, const T& val ) TQ_INLINE_TEMPLATES TQValueVector<T>::TQValueVector( size_type n, const T& val )
{ {
sh = new TQValueVectorPrivate<T>( n ); sh = new TQValueVectorPrivate<T>( n );
tqFill( begin(), end(), val ); tqFill( begin(), end(), val );
} }
template <class T> template <class T>
Q_INLINE_TEMPLATES void TQValueVector<T>::detachInternal() TQ_INLINE_TEMPLATES void TQValueVector<T>::detachInternal()
{ {
sh->deref(); sh->deref();
sh = new TQValueVectorPrivate<T>( *sh ); sh = new TQValueVectorPrivate<T>( *sh );
} }
template <class T> template <class T>
Q_INLINE_TEMPLATES Q_TYPENAME TQValueVector<T>::iterator TQValueVector<T>::insert( iterator pos, const T& x ) TQ_INLINE_TEMPLATES TQ_TYPENAME TQValueVector<T>::iterator TQValueVector<T>::insert( iterator pos, const T& x )
{ {
size_type offset = pos - sh->start; size_type offset = pos - sh->start;
detach(); detach();
@ -530,7 +530,7 @@ Q_INLINE_TEMPLATES Q_TYPENAME TQValueVector<T>::iterator TQValueVector<T>::inser
} }
template <class T> template <class T>
Q_INLINE_TEMPLATES Q_TYPENAME TQValueVector<T>::iterator TQValueVector<T>::insert( iterator pos, size_type n, const T& x ) TQ_INLINE_TEMPLATES TQ_TYPENAME TQValueVector<T>::iterator TQValueVector<T>::insert( iterator pos, size_type n, const T& x )
{ {
if ( n != 0 ) { if ( n != 0 ) {
size_type offset = pos - sh->start; size_type offset = pos - sh->start;
@ -544,7 +544,7 @@ Q_INLINE_TEMPLATES Q_TYPENAME TQValueVector<T>::iterator TQValueVector<T>::inser
#ifndef TQT_NO_DATASTREAM #ifndef TQT_NO_DATASTREAM
template<class T> template<class T>
Q_INLINE_TEMPLATES TQDataStream& operator>>( TQDataStream& s, TQValueVector<T>& v ) TQ_INLINE_TEMPLATES TQDataStream& operator>>( TQDataStream& s, TQValueVector<T>& v )
{ {
v.clear(); v.clear();
TQ_UINT32 c; TQ_UINT32 c;
@ -560,7 +560,7 @@ Q_INLINE_TEMPLATES TQDataStream& operator>>( TQDataStream& s, TQValueVector<T>&
} }
template<class T> template<class T>
Q_INLINE_TEMPLATES TQDataStream& operator<<( TQDataStream& s, const TQValueVector<T>& v ) TQ_INLINE_TEMPLATES TQDataStream& operator<<( TQDataStream& s, const TQValueVector<T>& v )
{ {
s << (TQ_UINT32)v.size(); s << (TQ_UINT32)v.size();
// ### use typename TQValueVector<T>::const_iterator once all supported // ### use typename TQValueVector<T>::const_iterator once all supported

@ -265,7 +265,7 @@ struct Q_EXPORT TQtULong
// default implementation of ref counting. A variable "ulong ref" has to be a member // default implementation of ref counting. A variable "ulong ref" has to be a member
#define Q_REFCOUNT \ #define TQ_REFCOUNT \
private: \ private: \
TQtULong qtrefcount; \ TQtULong qtrefcount; \
public: \ public: \

@ -58,16 +58,16 @@
// Duplicated from ntqobject.h, but we cannot include ntqobject.h here since // Duplicated from ntqobject.h, but we cannot include ntqobject.h here since
// it causes qmake to not build on irix g++ // it causes qmake to not build on irix g++
#define QT_TRANSLATE_NOOP(scope,x) (x) #define TQT_TRANSLATE_NOOP(scope,x) (x)
const char* qt_fileerr_unknown = QT_TRANSLATE_NOOP( "TQFile", "Unknown error" ); const char* qt_fileerr_unknown = TQT_TRANSLATE_NOOP( "TQFile", "Unknown error" );
const char* qt_fileerr_read = QT_TRANSLATE_NOOP( "TQFile", "Could not read from the file" ); const char* qt_fileerr_read = TQT_TRANSLATE_NOOP( "TQFile", "Could not read from the file" );
const char* qt_fileerr_write = QT_TRANSLATE_NOOP( "TQFile", "Could not write to the file" ); const char* qt_fileerr_write = TQT_TRANSLATE_NOOP( "TQFile", "Could not write to the file" );
#define TQFILEERR_EACCES QT_TRANSLATE_NOOP( "TQFile", "Permission denied" ) #define TQFILEERR_EACCES TQT_TRANSLATE_NOOP( "TQFile", "Permission denied" )
#define TQFILEERR_EMFILE QT_TRANSLATE_NOOP( "TQFile", "Too many open files" ) #define TQFILEERR_EMFILE TQT_TRANSLATE_NOOP( "TQFile", "Too many open files" )
#define TQFILEERR_ENOENT QT_TRANSLATE_NOOP( "TQFile", "No such file or directory" ) #define TQFILEERR_ENOENT TQT_TRANSLATE_NOOP( "TQFile", "No such file or directory" )
#define TQFILEERR_ENOSPC QT_TRANSLATE_NOOP( "TQFile", "No space left on device" ) #define TQFILEERR_ENOSPC TQT_TRANSLATE_NOOP( "TQFile", "No space left on device" )
class TQFilePrivate class TQFilePrivate
{ {

@ -85,10 +85,10 @@ enum {
LittleEndian, LittleEndian,
BigEndian BigEndian
#ifdef Q_BYTE_ORDER #ifdef TQ_BYTE_ORDER
# if Q_BYTE_ORDER == Q_BIG_ENDIAN # if TQ_BYTE_ORDER == TQ_BIG_ENDIAN
, ByteOrder = BigEndian , ByteOrder = BigEndian
# elif Q_BYTE_ORDER == Q_LITTLE_ENDIAN # elif TQ_BYTE_ORDER == TQ_LITTLE_ENDIAN
, ByteOrder = LittleEndian , ByteOrder = LittleEndian
# else # else
# error "undefined byte order" # error "undefined byte order"

@ -57,21 +57,21 @@
#include <private/qthreadinstance_p.h> #include <private/qthreadinstance_p.h>
#endif // TQT_THREAD_SUPPORT #endif // TQT_THREAD_SUPPORT
#undef QT_TRANSLATE_NOOP #undef TQT_TRANSLATE_NOOP
#define QT_TRANSLATE_NOOP( context, sourceText ) sourceText #define TQT_TRANSLATE_NOOP( context, sourceText ) sourceText
#include <limits.h> #include <limits.h>
// error strings for the regexp parser // error strings for the regexp parser
#define RXERR_OK QT_TRANSLATE_NOOP( "TQRegExp", "no error occurred" ) #define RXERR_OK TQT_TRANSLATE_NOOP( "TQRegExp", "no error occurred" )
#define RXERR_DISABLED QT_TRANSLATE_NOOP( "TQRegExp", "disabled feature used" ) #define RXERR_DISABLED TQT_TRANSLATE_NOOP( "TQRegExp", "disabled feature used" )
#define RXERR_CHARCLASS QT_TRANSLATE_NOOP( "TQRegExp", "bad char class syntax" ) #define RXERR_CHARCLASS TQT_TRANSLATE_NOOP( "TQRegExp", "bad char class syntax" )
#define RXERR_LOOKAHEAD QT_TRANSLATE_NOOP( "TQRegExp", "bad lookahead syntax" ) #define RXERR_LOOKAHEAD TQT_TRANSLATE_NOOP( "TQRegExp", "bad lookahead syntax" )
#define RXERR_REPETITION QT_TRANSLATE_NOOP( "TQRegExp", "bad repetition syntax" ) #define RXERR_REPETITION TQT_TRANSLATE_NOOP( "TQRegExp", "bad repetition syntax" )
#define RXERR_OCTAL QT_TRANSLATE_NOOP( "TQRegExp", "invalid octal value" ) #define RXERR_OCTAL TQT_TRANSLATE_NOOP( "TQRegExp", "invalid octal value" )
#define RXERR_LEFTDELIM QT_TRANSLATE_NOOP( "TQRegExp", "missing left delim" ) #define RXERR_LEFTDELIM TQT_TRANSLATE_NOOP( "TQRegExp", "missing left delim" )
#define RXERR_END QT_TRANSLATE_NOOP( "TQRegExp", "unexpected end" ) #define RXERR_END TQT_TRANSLATE_NOOP( "TQRegExp", "unexpected end" )
#define RXERR_LIMIT QT_TRANSLATE_NOOP( "TQRegExp", "met internal limit" ) #define RXERR_LIMIT TQT_TRANSLATE_NOOP( "TQRegExp", "met internal limit" )
/* /*
WARNING! Be sure to read qregexp.tex before modifying this file. WARNING! Be sure to read qregexp.tex before modifying this file.

@ -71,7 +71,7 @@ public:
int width() const { return selend - selstart; } int width() const { return selend - selstart; }
int index() const { return act; } int index() const { return act; }
bool separator() const { return sep; } bool separator() const { return sep; }
Q_DUMMY_COMPARISON_OPERATOR( TQNumberSection ) TQ_DUMMY_COMPARISON_OPERATOR( TQNumberSection )
private: private:
int selstart :12; int selstart :12;
int selend :12; int selend :12;

@ -59,7 +59,7 @@ struct Q_EXPORT DockData
TQDockWindow *w; TQDockWindow *w;
TQRect rect; TQRect rect;
Q_DUMMY_COMPARISON_OPERATOR( DockData ) TQ_DUMMY_COMPARISON_OPERATOR( DockData )
}; };
static int fix_x( TQDockWindow* w, int width = -1 ) { static int fix_x( TQDockWindow* w, int width = -1 ) {

@ -88,7 +88,7 @@ public:
virtual ~TQWidgetPluginPrivate(); virtual ~TQWidgetPluginPrivate();
TQRESULT queryInterface( const TQUuid &iid, TQUnknownInterface **iface ); TQRESULT queryInterface( const TQUuid &iid, TQUnknownInterface **iface );
Q_REFCOUNT; TQ_REFCOUNT;
TQStringList featureList() const; TQStringList featureList() const;
TQWidget *create( const TQString &key, TQWidget *parent, const char *name ); TQWidget *create( const TQString &key, TQWidget *parent, const char *name );

@ -60,19 +60,19 @@ const char systemId[] = "http://www.w3.org/TR/2000/CR-SVG-20001102/DTD/svg-20001
struct TQM_EXPORT_SVG ImgElement { struct TQM_EXPORT_SVG ImgElement {
TQDomElement element; TQDomElement element;
TQImage image; TQImage image;
Q_DUMMY_COMPARISON_OPERATOR( ImgElement ) TQ_DUMMY_COMPARISON_OPERATOR( ImgElement )
}; };
struct TQM_EXPORT_SVG PixElement { struct TQM_EXPORT_SVG PixElement {
TQDomElement element; TQDomElement element;
TQPixmap pixmap; TQPixmap pixmap;
Q_DUMMY_COMPARISON_OPERATOR( PixElement ) TQ_DUMMY_COMPARISON_OPERATOR( PixElement )
}; };
struct TQSvgDeviceState { struct TQSvgDeviceState {
int textx, texty; // current text position int textx, texty; // current text position
int textalign; // text alignment int textalign; // text alignment
Q_DUMMY_COMPARISON_OPERATOR( TQSvgDeviceState ) TQ_DUMMY_COMPARISON_OPERATOR( TQSvgDeviceState )
}; };
typedef TQValueList<ImgElement> ImageList; typedef TQValueList<ImgElement> ImageList;

@ -46,7 +46,7 @@
#include "ntqmap.h" #include "ntqmap.h"
#include "ntqvaluestack.h" #include "ntqvaluestack.h"
// needed for QT_TRANSLATE_NOOP: // needed for TQT_TRANSLATE_NOOP:
#include "ntqobject.h" #include "ntqobject.h"
#ifndef TQT_NO_XML #ifndef TQT_NO_XML
@ -54,29 +54,29 @@
//#define QT_QXML_DEBUG //#define QT_QXML_DEBUG
// Error strings for the XML reader // Error strings for the XML reader
#define XMLERR_OK QT_TRANSLATE_NOOP( "TQXml", "no error occurred" ) #define XMLERR_OK TQT_TRANSLATE_NOOP( "TQXml", "no error occurred" )
#define XMLERR_ERRORBYCONSUMER QT_TRANSLATE_NOOP( "TQXml", "error triggered by consumer" ) #define XMLERR_ERRORBYCONSUMER TQT_TRANSLATE_NOOP( "TQXml", "error triggered by consumer" )
#define XMLERR_UNEXPECTEDEOF QT_TRANSLATE_NOOP( "TQXml", "unexpected end of file" ) #define XMLERR_UNEXPECTEDEOF TQT_TRANSLATE_NOOP( "TQXml", "unexpected end of file" )
#define XMLERR_MORETHANONEDOCTYPE QT_TRANSLATE_NOOP( "TQXml", "more than one document type definition" ) #define XMLERR_MORETHANONEDOCTYPE TQT_TRANSLATE_NOOP( "TQXml", "more than one document type definition" )
#define XMLERR_ERRORPARSINGELEMENT QT_TRANSLATE_NOOP( "TQXml", "error occurred while parsing element" ) #define XMLERR_ERRORPARSINGELEMENT TQT_TRANSLATE_NOOP( "TQXml", "error occurred while parsing element" )
#define XMLERR_TAGMISMATCH QT_TRANSLATE_NOOP( "TQXml", "tag mismatch" ) #define XMLERR_TAGMISMATCH TQT_TRANSLATE_NOOP( "TQXml", "tag mismatch" )
#define XMLERR_ERRORPARSINGCONTENT QT_TRANSLATE_NOOP( "TQXml", "error occurred while parsing content" ) #define XMLERR_ERRORPARSINGCONTENT TQT_TRANSLATE_NOOP( "TQXml", "error occurred while parsing content" )
#define XMLERR_UNEXPECTEDCHARACTER QT_TRANSLATE_NOOP( "TQXml", "unexpected character" ) #define XMLERR_UNEXPECTEDCHARACTER TQT_TRANSLATE_NOOP( "TQXml", "unexpected character" )
#define XMLERR_INVALIDNAMEFORPI QT_TRANSLATE_NOOP( "TQXml", "invalid name for processing instruction" ) #define XMLERR_INVALIDNAMEFORPI TQT_TRANSLATE_NOOP( "TQXml", "invalid name for processing instruction" )
#define XMLERR_VERSIONEXPECTED QT_TRANSLATE_NOOP( "TQXml", "version expected while reading the XML declaration" ) #define XMLERR_VERSIONEXPECTED TQT_TRANSLATE_NOOP( "TQXml", "version expected while reading the XML declaration" )
#define XMLERR_WRONGVALUEFORSDECL QT_TRANSLATE_NOOP( "TQXml", "wrong value for standalone declaration" ) #define XMLERR_WRONGVALUEFORSDECL TQT_TRANSLATE_NOOP( "TQXml", "wrong value for standalone declaration" )
#define XMLERR_EDECLORSDDECLEXPECTED QT_TRANSLATE_NOOP( "TQXml", "encoding declaration or standalone declaration expected while reading the XML declaration" ) #define XMLERR_EDECLORSDDECLEXPECTED TQT_TRANSLATE_NOOP( "TQXml", "encoding declaration or standalone declaration expected while reading the XML declaration" )
#define XMLERR_SDDECLEXPECTED QT_TRANSLATE_NOOP( "TQXml", "standalone declaration expected while reading the XML declaration" ) #define XMLERR_SDDECLEXPECTED TQT_TRANSLATE_NOOP( "TQXml", "standalone declaration expected while reading the XML declaration" )
#define XMLERR_ERRORPARSINGDOCTYPE QT_TRANSLATE_NOOP( "TQXml", "error occurred while parsing document type definition" ) #define XMLERR_ERRORPARSINGDOCTYPE TQT_TRANSLATE_NOOP( "TQXml", "error occurred while parsing document type definition" )
#define XMLERR_LETTEREXPECTED QT_TRANSLATE_NOOP( "TQXml", "letter is expected" ) #define XMLERR_LETTEREXPECTED TQT_TRANSLATE_NOOP( "TQXml", "letter is expected" )
#define XMLERR_ERRORPARSINGCOMMENT QT_TRANSLATE_NOOP( "TQXml", "error occurred while parsing comment" ) #define XMLERR_ERRORPARSINGCOMMENT TQT_TRANSLATE_NOOP( "TQXml", "error occurred while parsing comment" )
#define XMLERR_ERRORPARSINGREFERENCE QT_TRANSLATE_NOOP( "TQXml", "error occurred while parsing reference" ) #define XMLERR_ERRORPARSINGREFERENCE TQT_TRANSLATE_NOOP( "TQXml", "error occurred while parsing reference" )
#define XMLERR_INTERNALGENERALENTITYINDTD QT_TRANSLATE_NOOP( "TQXml", "internal general entity reference not allowed in DTD" ) #define XMLERR_INTERNALGENERALENTITYINDTD TQT_TRANSLATE_NOOP( "TQXml", "internal general entity reference not allowed in DTD" )
#define XMLERR_EXTERNALGENERALENTITYINAV QT_TRANSLATE_NOOP( "TQXml", "external parsed general entity reference not allowed in attribute value" ) #define XMLERR_EXTERNALGENERALENTITYINAV TQT_TRANSLATE_NOOP( "TQXml", "external parsed general entity reference not allowed in attribute value" )
#define XMLERR_EXTERNALGENERALENTITYINDTD QT_TRANSLATE_NOOP( "TQXml", "external parsed general entity reference not allowed in DTD" ) #define XMLERR_EXTERNALGENERALENTITYINDTD TQT_TRANSLATE_NOOP( "TQXml", "external parsed general entity reference not allowed in DTD" )
#define XMLERR_UNPARSEDENTITYREFERENCE QT_TRANSLATE_NOOP( "TQXml", "unparsed entity reference in wrong context" ) #define XMLERR_UNPARSEDENTITYREFERENCE TQT_TRANSLATE_NOOP( "TQXml", "unparsed entity reference in wrong context" )
#define XMLERR_RECURSIVEENTITIES QT_TRANSLATE_NOOP( "TQXml", "recursive entities" ) #define XMLERR_RECURSIVEENTITIES TQT_TRANSLATE_NOOP( "TQXml", "recursive entities" )
#define XMLERR_ERRORINTEXTDECL QT_TRANSLATE_NOOP( "TQXml", "error in the text declaration of an external entity" ) #define XMLERR_ERRORINTEXTDECL TQT_TRANSLATE_NOOP( "TQXml", "error in the text declaration of an external entity" )
// the constants for the lookup table // the constants for the lookup table
static const signed char cltWS = 0; // white space static const signed char cltWS = 0; // white space
@ -2249,7 +2249,7 @@ private:
TQString publicId; TQString publicId;
TQString systemId; TQString systemId;
Q_DUMMY_COMPARISON_OPERATOR(ExternParameterEntity) TQ_DUMMY_COMPARISON_OPERATOR(ExternParameterEntity)
}; };
struct ExternEntity struct ExternEntity
{ {
@ -2259,7 +2259,7 @@ private:
TQString publicId; TQString publicId;
TQString systemId; TQString systemId;
TQString notation; TQString notation;
Q_DUMMY_COMPARISON_OPERATOR(ExternEntity) TQ_DUMMY_COMPARISON_OPERATOR(ExternEntity)
}; };
TQMap<TQString,ExternParameterEntity> externParameterEntities; TQMap<TQString,ExternParameterEntity> externParameterEntities;
TQMap<TQString,TQString> parameterEntities; TQMap<TQString,TQString> parameterEntities;

@ -48,7 +48,7 @@ struct ContentItem {
TQString title; TQString title;
TQString reference; TQString reference;
int depth; int depth;
Q_DUMMY_COMPARISON_OPERATOR(ContentItem) TQ_DUMMY_COMPARISON_OPERATOR(ContentItem)
}; };
TQDataStream &operator>>( TQDataStream &s, ContentItem &ci ); TQDataStream &operator>>( TQDataStream &s, ContentItem &ci );

@ -100,7 +100,7 @@ struct IndexKeyword {
bool operator>( const IndexKeyword &ik ) const { bool operator>( const IndexKeyword &ik ) const {
return keyword.lower() > ik.keyword.lower(); return keyword.lower() > ik.keyword.lower();
} }
Q_DUMMY_COMPARISON_OPERATOR( IndexKeyword ) TQ_DUMMY_COMPARISON_OPERATOR( IndexKeyword )
TQString keyword; TQString keyword;
TQString link; TQString link;
}; };

@ -781,7 +781,7 @@ public:
{ {
TQString text; TQString text;
TQPixmap pix; TQPixmap pix;
Q_DUMMY_COMPARISON_OPERATOR( Item ) TQ_DUMMY_COMPARISON_OPERATOR( Item )
}; };
PopulateListBoxCommand( const TQString &n, FormWindow *fw, PopulateListBoxCommand( const TQString &n, FormWindow *fw,
@ -805,7 +805,7 @@ public:
{ {
TQString text; TQString text;
TQPixmap pix; TQPixmap pix;
Q_DUMMY_COMPARISON_OPERATOR( Item ) TQ_DUMMY_COMPARISON_OPERATOR( Item )
}; };
PopulateIconViewCommand( const TQString &n, FormWindow *fw, PopulateIconViewCommand( const TQString &n, FormWindow *fw,
@ -863,7 +863,7 @@ public:
{ {
TQString text; TQString text;
TQPixmap pix; TQPixmap pix;
Q_DUMMY_COMPARISON_OPERATOR( Row ) TQ_DUMMY_COMPARISON_OPERATOR( Row )
}; };
struct Column struct Column
@ -871,7 +871,7 @@ public:
TQString text; TQString text;
TQPixmap pix; TQPixmap pix;
TQString field; TQString field;
Q_DUMMY_COMPARISON_OPERATOR( Column ) TQ_DUMMY_COMPARISON_OPERATOR( Column )
}; };
PopulateTableCommand( const TQString &n, FormWindow *fw, TQTable *t, PopulateTableCommand( const TQString &n, FormWindow *fw, TQTable *t,

@ -53,7 +53,7 @@ void set_splash_status( const TQString &txt )
if ( !splash ) if ( !splash )
return; return;
TQString splashText = "Licensed to " TQString splashText = "Licensed to "
+ TQString::fromLatin1( QT_PRODUCT_LICENSEE ) + "\n" + TQString::fromLatin1( TQT_PRODUCT_LICENSEE ) + "\n"
+ txt; + txt;
splash->message( splashText, TQt::AlignRight|TQt::AlignTop ); splash->message( splashText, TQt::AlignRight|TQt::AlignTop );
} }

@ -72,7 +72,7 @@ public:
TQRESULT queryInterface( const TQUuid &uuid, TQUnknownInterface** iface ); TQRESULT queryInterface( const TQUuid &uuid, TQUnknownInterface** iface );
Q_REFCOUNT TQ_REFCOUNT
private: private:
MainWindow *mainWindow; MainWindow *mainWindow;

@ -84,7 +84,7 @@ private:
TQString type; TQString type;
TQString oldType; TQString oldType;
Q_DUMMY_COMPARISON_OPERATOR( FunctItem ) TQ_DUMMY_COMPARISON_OPERATOR( FunctItem )
}; };
void changeItem( TQListViewItem *item, Attribute a, const TQString &nV ); void changeItem( TQListViewItem *item, Attribute a, const TQString &nV );

@ -236,7 +236,7 @@ private:
TQListView *lv; TQListView *lv;
TQInterfacePtr<ClassBrowserInterface> iface; TQInterfacePtr<ClassBrowserInterface> iface;
Q_DUMMY_COMPARISON_OPERATOR( ClassBrowser ) TQ_DUMMY_COMPARISON_OPERATOR( ClassBrowser )
}; };
FormWindow *formwindow; FormWindow *formwindow;
HierarchyList *listview; HierarchyList *listview;

@ -185,7 +185,7 @@ public:
int column; int column;
int rowspan; int rowspan;
int colspan; int colspan;
Q_DUMMY_COMPARISON_OPERATOR( Item ) TQ_DUMMY_COMPARISON_OPERATOR( Item )
}; };
TQMap<TQWidget*, Item> items; TQMap<TQWidget*, Item> items;

@ -87,7 +87,7 @@ private:
TQString text; TQString text;
TQPixmap pixmap; TQPixmap pixmap;
bool clickable, resizable; bool clickable, resizable;
Q_DUMMY_COMPARISON_OPERATOR( Column ) TQ_DUMMY_COMPARISON_OPERATOR( Column )
}; };
private: private:

@ -373,7 +373,7 @@ private:
TQString title; TQString title;
TQObject *receiver; TQObject *receiver;
const char *init_slot, *accept_slot; const char *init_slot, *accept_slot;
Q_DUMMY_COMPARISON_OPERATOR( Tab ) TQ_DUMMY_COMPARISON_OPERATOR( Tab )
}; };
private: private:

@ -50,7 +50,7 @@ public:
TQPixmap pix; TQPixmap pix;
TQString name; TQString name;
TQString absname; TQString absname;
Q_DUMMY_COMPARISON_OPERATOR( Pixmap ) TQ_DUMMY_COMPARISON_OPERATOR( Pixmap )
}; };
PixmapCollection( Project *pro ); PixmapCollection( Project *pro );

@ -113,92 +113,92 @@ static struct {
int key; int key;
const char* name; const char* name;
} keyname[] = { } keyname[] = {
{ TQt::Key_Space, QT_TRANSLATE_NOOP( "TQAccel", "Space" ) }, { TQt::Key_Space, TQT_TRANSLATE_NOOP( "TQAccel", "Space" ) },
{ TQt::Key_Escape, QT_TRANSLATE_NOOP( "TQAccel", "Esc" ) }, { TQt::Key_Escape, TQT_TRANSLATE_NOOP( "TQAccel", "Esc" ) },
{ TQt::Key_Tab, QT_TRANSLATE_NOOP( "TQAccel", "Tab" ) }, { TQt::Key_Tab, TQT_TRANSLATE_NOOP( "TQAccel", "Tab" ) },
{ TQt::Key_Backtab, QT_TRANSLATE_NOOP( "TQAccel", "Backtab" ) }, { TQt::Key_Backtab, TQT_TRANSLATE_NOOP( "TQAccel", "Backtab" ) },
{ TQt::Key_Backspace, QT_TRANSLATE_NOOP( "TQAccel", "Backspace" ) }, { TQt::Key_Backspace, TQT_TRANSLATE_NOOP( "TQAccel", "Backspace" ) },
{ TQt::Key_Return, QT_TRANSLATE_NOOP( "TQAccel", "Return" ) }, { TQt::Key_Return, TQT_TRANSLATE_NOOP( "TQAccel", "Return" ) },
{ TQt::Key_Enter, QT_TRANSLATE_NOOP( "TQAccel", "Enter" ) }, { TQt::Key_Enter, TQT_TRANSLATE_NOOP( "TQAccel", "Enter" ) },
{ TQt::Key_Insert, QT_TRANSLATE_NOOP( "TQAccel", "Ins" ) }, { TQt::Key_Insert, TQT_TRANSLATE_NOOP( "TQAccel", "Ins" ) },
{ TQt::Key_Delete, QT_TRANSLATE_NOOP( "TQAccel", "Del" ) }, { TQt::Key_Delete, TQT_TRANSLATE_NOOP( "TQAccel", "Del" ) },
{ TQt::Key_Pause, QT_TRANSLATE_NOOP( "TQAccel", "Pause" ) }, { TQt::Key_Pause, TQT_TRANSLATE_NOOP( "TQAccel", "Pause" ) },
{ TQt::Key_Print, QT_TRANSLATE_NOOP( "TQAccel", "Print" ) }, { TQt::Key_Print, TQT_TRANSLATE_NOOP( "TQAccel", "Print" ) },
{ TQt::Key_SysReq, QT_TRANSLATE_NOOP( "TQAccel", "SysReq" ) }, { TQt::Key_SysReq, TQT_TRANSLATE_NOOP( "TQAccel", "SysReq" ) },
{ TQt::Key_Home, QT_TRANSLATE_NOOP( "TQAccel", "Home" ) }, { TQt::Key_Home, TQT_TRANSLATE_NOOP( "TQAccel", "Home" ) },
{ TQt::Key_End, QT_TRANSLATE_NOOP( "TQAccel", "End" ) }, { TQt::Key_End, TQT_TRANSLATE_NOOP( "TQAccel", "End" ) },
{ TQt::Key_Left, QT_TRANSLATE_NOOP( "TQAccel", "Left" ) }, { TQt::Key_Left, TQT_TRANSLATE_NOOP( "TQAccel", "Left" ) },
{ TQt::Key_Up, QT_TRANSLATE_NOOP( "TQAccel", "Up" ) }, { TQt::Key_Up, TQT_TRANSLATE_NOOP( "TQAccel", "Up" ) },
{ TQt::Key_Right, QT_TRANSLATE_NOOP( "TQAccel", "Right" ) }, { TQt::Key_Right, TQT_TRANSLATE_NOOP( "TQAccel", "Right" ) },
{ TQt::Key_Down, QT_TRANSLATE_NOOP( "TQAccel", "Down" ) }, { TQt::Key_Down, TQT_TRANSLATE_NOOP( "TQAccel", "Down" ) },
{ TQt::Key_Prior, QT_TRANSLATE_NOOP( "TQAccel", "PgUp" ) }, { TQt::Key_Prior, TQT_TRANSLATE_NOOP( "TQAccel", "PgUp" ) },
{ TQt::Key_Next, QT_TRANSLATE_NOOP( "TQAccel", "PgDown" ) }, { TQt::Key_Next, TQT_TRANSLATE_NOOP( "TQAccel", "PgDown" ) },
{ TQt::Key_CapsLock, QT_TRANSLATE_NOOP( "TQAccel", "CapsLock" ) }, { TQt::Key_CapsLock, TQT_TRANSLATE_NOOP( "TQAccel", "CapsLock" ) },
{ TQt::Key_NumLock, QT_TRANSLATE_NOOP( "TQAccel", "NumLock" ) }, { TQt::Key_NumLock, TQT_TRANSLATE_NOOP( "TQAccel", "NumLock" ) },
{ TQt::Key_ScrollLock, QT_TRANSLATE_NOOP( "TQAccel", "ScrollLock" ) }, { TQt::Key_ScrollLock, TQT_TRANSLATE_NOOP( "TQAccel", "ScrollLock" ) },
{ TQt::Key_Menu, QT_TRANSLATE_NOOP( "TQAccel", "Menu" ) }, { TQt::Key_Menu, TQT_TRANSLATE_NOOP( "TQAccel", "Menu" ) },
{ TQt::Key_Help, QT_TRANSLATE_NOOP( "TQAccel", "Help" ) }, { TQt::Key_Help, TQT_TRANSLATE_NOOP( "TQAccel", "Help" ) },
// Multimedia keys // Multimedia keys
{ TQt::Key_Back, QT_TRANSLATE_NOOP( "TQAccel", "Back" ) }, { TQt::Key_Back, TQT_TRANSLATE_NOOP( "TQAccel", "Back" ) },
{ TQt::Key_Forward, QT_TRANSLATE_NOOP( "TQAccel", "Forward" ) }, { TQt::Key_Forward, TQT_TRANSLATE_NOOP( "TQAccel", "Forward" ) },
{ TQt::Key_Stop, QT_TRANSLATE_NOOP( "TQAccel", "Stop" ) }, { TQt::Key_Stop, TQT_TRANSLATE_NOOP( "TQAccel", "Stop" ) },
{ TQt::Key_Refresh, QT_TRANSLATE_NOOP( "TQAccel", "Refresh" ) }, { TQt::Key_Refresh, TQT_TRANSLATE_NOOP( "TQAccel", "Refresh" ) },
{ TQt::Key_VolumeDown, QT_TRANSLATE_NOOP( "TQAccel", "Volume Down" ) }, { TQt::Key_VolumeDown, TQT_TRANSLATE_NOOP( "TQAccel", "Volume Down" ) },
{ TQt::Key_VolumeMute, QT_TRANSLATE_NOOP( "TQAccel", "Volume Mute" ) }, { TQt::Key_VolumeMute, TQT_TRANSLATE_NOOP( "TQAccel", "Volume Mute" ) },
{ TQt::Key_VolumeUp, QT_TRANSLATE_NOOP( "TQAccel", "Volume Up" ) }, { TQt::Key_VolumeUp, TQT_TRANSLATE_NOOP( "TQAccel", "Volume Up" ) },
{ TQt::Key_BassBoost, QT_TRANSLATE_NOOP( "TQAccel", "Bass Boost" ) }, { TQt::Key_BassBoost, TQT_TRANSLATE_NOOP( "TQAccel", "Bass Boost" ) },
{ TQt::Key_BassUp, QT_TRANSLATE_NOOP( "TQAccel", "Bass Up" ) }, { TQt::Key_BassUp, TQT_TRANSLATE_NOOP( "TQAccel", "Bass Up" ) },
{ TQt::Key_BassDown, QT_TRANSLATE_NOOP( "TQAccel", "Bass Down" ) }, { TQt::Key_BassDown, TQT_TRANSLATE_NOOP( "TQAccel", "Bass Down" ) },
{ TQt::Key_TrebleUp, QT_TRANSLATE_NOOP( "TQAccel", "Treble Up" ) }, { TQt::Key_TrebleUp, TQT_TRANSLATE_NOOP( "TQAccel", "Treble Up" ) },
{ TQt::Key_TrebleDown, QT_TRANSLATE_NOOP( "TQAccel", "Treble Down" ) }, { TQt::Key_TrebleDown, TQT_TRANSLATE_NOOP( "TQAccel", "Treble Down" ) },
{ TQt::Key_MediaPlay, QT_TRANSLATE_NOOP( "TQAccel", "Media Play" ) }, { TQt::Key_MediaPlay, TQT_TRANSLATE_NOOP( "TQAccel", "Media Play" ) },
{ TQt::Key_MediaStop, QT_TRANSLATE_NOOP( "TQAccel", "Media Stop" ) }, { TQt::Key_MediaStop, TQT_TRANSLATE_NOOP( "TQAccel", "Media Stop" ) },
{ TQt::Key_MediaPrev, QT_TRANSLATE_NOOP( "TQAccel", "Media Previous" ) }, { TQt::Key_MediaPrev, TQT_TRANSLATE_NOOP( "TQAccel", "Media Previous" ) },
{ TQt::Key_MediaNext, QT_TRANSLATE_NOOP( "TQAccel", "Media Next" ) }, { TQt::Key_MediaNext, TQT_TRANSLATE_NOOP( "TQAccel", "Media Next" ) },
{ TQt::Key_MediaRecord, QT_TRANSLATE_NOOP( "TQAccel", "Media Record" ) }, { TQt::Key_MediaRecord, TQT_TRANSLATE_NOOP( "TQAccel", "Media Record" ) },
{ TQt::Key_HomePage, QT_TRANSLATE_NOOP( "TQAccel", "Home" ) }, { TQt::Key_HomePage, TQT_TRANSLATE_NOOP( "TQAccel", "Home" ) },
{ TQt::Key_Favorites, QT_TRANSLATE_NOOP( "TQAccel", "Favorites" ) }, { TQt::Key_Favorites, TQT_TRANSLATE_NOOP( "TQAccel", "Favorites" ) },
{ TQt::Key_Search, QT_TRANSLATE_NOOP( "TQAccel", "Search" ) }, { TQt::Key_Search, TQT_TRANSLATE_NOOP( "TQAccel", "Search" ) },
{ TQt::Key_Standby, QT_TRANSLATE_NOOP( "TQAccel", "Standby" ) }, { TQt::Key_Standby, TQT_TRANSLATE_NOOP( "TQAccel", "Standby" ) },
{ TQt::Key_OpenUrl, QT_TRANSLATE_NOOP( "TQAccel", "Open URL" ) }, { TQt::Key_OpenUrl, TQT_TRANSLATE_NOOP( "TQAccel", "Open URL" ) },
{ TQt::Key_LaunchMail, QT_TRANSLATE_NOOP( "TQAccel", "Launch Mail" ) }, { TQt::Key_LaunchMail, TQT_TRANSLATE_NOOP( "TQAccel", "Launch Mail" ) },
{ TQt::Key_LaunchMedia, QT_TRANSLATE_NOOP( "TQAccel", "Launch Media" ) }, { TQt::Key_LaunchMedia, TQT_TRANSLATE_NOOP( "TQAccel", "Launch Media" ) },
{ TQt::Key_Launch0, QT_TRANSLATE_NOOP( "TQAccel", "Launch (0)" ) }, { TQt::Key_Launch0, TQT_TRANSLATE_NOOP( "TQAccel", "Launch (0)" ) },
{ TQt::Key_Launch1, QT_TRANSLATE_NOOP( "TQAccel", "Launch (1)" ) }, { TQt::Key_Launch1, TQT_TRANSLATE_NOOP( "TQAccel", "Launch (1)" ) },
{ TQt::Key_Launch2, QT_TRANSLATE_NOOP( "TQAccel", "Launch (2)" ) }, { TQt::Key_Launch2, TQT_TRANSLATE_NOOP( "TQAccel", "Launch (2)" ) },
{ TQt::Key_Launch3, QT_TRANSLATE_NOOP( "TQAccel", "Launch (3)" ) }, { TQt::Key_Launch3, TQT_TRANSLATE_NOOP( "TQAccel", "Launch (3)" ) },
{ TQt::Key_Launch4, QT_TRANSLATE_NOOP( "TQAccel", "Launch (4)" ) }, { TQt::Key_Launch4, TQT_TRANSLATE_NOOP( "TQAccel", "Launch (4)" ) },
{ TQt::Key_Launch5, QT_TRANSLATE_NOOP( "TQAccel", "Launch (5)" ) }, { TQt::Key_Launch5, TQT_TRANSLATE_NOOP( "TQAccel", "Launch (5)" ) },
{ TQt::Key_Launch6, QT_TRANSLATE_NOOP( "TQAccel", "Launch (6)" ) }, { TQt::Key_Launch6, TQT_TRANSLATE_NOOP( "TQAccel", "Launch (6)" ) },
{ TQt::Key_Launch7, QT_TRANSLATE_NOOP( "TQAccel", "Launch (7)" ) }, { TQt::Key_Launch7, TQT_TRANSLATE_NOOP( "TQAccel", "Launch (7)" ) },
{ TQt::Key_Launch8, QT_TRANSLATE_NOOP( "TQAccel", "Launch (8)" ) }, { TQt::Key_Launch8, TQT_TRANSLATE_NOOP( "TQAccel", "Launch (8)" ) },
{ TQt::Key_Launch9, QT_TRANSLATE_NOOP( "TQAccel", "Launch (9)" ) }, { TQt::Key_Launch9, TQT_TRANSLATE_NOOP( "TQAccel", "Launch (9)" ) },
{ TQt::Key_LaunchA, QT_TRANSLATE_NOOP( "TQAccel", "Launch (A)" ) }, { TQt::Key_LaunchA, TQT_TRANSLATE_NOOP( "TQAccel", "Launch (A)" ) },
{ TQt::Key_LaunchB, QT_TRANSLATE_NOOP( "TQAccel", "Launch (B)" ) }, { TQt::Key_LaunchB, TQT_TRANSLATE_NOOP( "TQAccel", "Launch (B)" ) },
{ TQt::Key_LaunchC, QT_TRANSLATE_NOOP( "TQAccel", "Launch (C)" ) }, { TQt::Key_LaunchC, TQT_TRANSLATE_NOOP( "TQAccel", "Launch (C)" ) },
{ TQt::Key_LaunchD, QT_TRANSLATE_NOOP( "TQAccel", "Launch (D)" ) }, { TQt::Key_LaunchD, TQT_TRANSLATE_NOOP( "TQAccel", "Launch (D)" ) },
{ TQt::Key_LaunchE, QT_TRANSLATE_NOOP( "TQAccel", "Launch (E)" ) }, { TQt::Key_LaunchE, TQT_TRANSLATE_NOOP( "TQAccel", "Launch (E)" ) },
{ TQt::Key_LaunchF, QT_TRANSLATE_NOOP( "TQAccel", "Launch (F)" ) }, { TQt::Key_LaunchF, TQT_TRANSLATE_NOOP( "TQAccel", "Launch (F)" ) },
{ TQt::Key_MonBrightnessUp, QT_TRANSLATE_NOOP( "TQAccel", "Monitor Brightness Up" ) }, { TQt::Key_MonBrightnessUp, TQT_TRANSLATE_NOOP( "TQAccel", "Monitor Brightness Up" ) },
{ TQt::Key_MonBrightnessDown, QT_TRANSLATE_NOOP( "TQAccel", "Monitor Brightness Down" ) }, { TQt::Key_MonBrightnessDown, TQT_TRANSLATE_NOOP( "TQAccel", "Monitor Brightness Down" ) },
{ TQt::Key_KeyboardLightOnOff, QT_TRANSLATE_NOOP( "TQAccel", "Keyboard Light On Off" ) }, { TQt::Key_KeyboardLightOnOff, TQT_TRANSLATE_NOOP( "TQAccel", "Keyboard Light On Off" ) },
{ TQt::Key_KeyboardBrightnessUp, QT_TRANSLATE_NOOP( "TQAccel", "Keyboard Brightness Up" ) }, { TQt::Key_KeyboardBrightnessUp, TQT_TRANSLATE_NOOP( "TQAccel", "Keyboard Brightness Up" ) },
{ TQt::Key_KeyboardBrightnessDown, QT_TRANSLATE_NOOP( "TQAccel", "Keyboard Brightness Down" ) }, { TQt::Key_KeyboardBrightnessDown, TQT_TRANSLATE_NOOP( "TQAccel", "Keyboard Brightness Down" ) },
// -------------------------------------------------------------- // --------------------------------------------------------------
// More consistent namings // More consistent namings
{ TQt::Key_Print, QT_TRANSLATE_NOOP( "TQAccel", "Print Screen" ) }, { TQt::Key_Print, TQT_TRANSLATE_NOOP( "TQAccel", "Print Screen" ) },
{ TQt::Key_Prior, QT_TRANSLATE_NOOP( "TQAccel", "Page Up" ) }, { TQt::Key_Prior, TQT_TRANSLATE_NOOP( "TQAccel", "Page Up" ) },
{ TQt::Key_Next, QT_TRANSLATE_NOOP( "TQAccel", "Page Down" ) }, { TQt::Key_Next, TQT_TRANSLATE_NOOP( "TQAccel", "Page Down" ) },
{ TQt::Key_CapsLock, QT_TRANSLATE_NOOP( "TQAccel", "Caps Lock" ) }, { TQt::Key_CapsLock, TQT_TRANSLATE_NOOP( "TQAccel", "Caps Lock" ) },
{ TQt::Key_NumLock, QT_TRANSLATE_NOOP( "TQAccel", "Num Lock" ) }, { TQt::Key_NumLock, TQT_TRANSLATE_NOOP( "TQAccel", "Num Lock" ) },
{ TQt::Key_NumLock, QT_TRANSLATE_NOOP( "TQAccel", "Number Lock" ) }, { TQt::Key_NumLock, TQT_TRANSLATE_NOOP( "TQAccel", "Number Lock" ) },
{ TQt::Key_ScrollLock, QT_TRANSLATE_NOOP( "TQAccel", "Scroll Lock" ) }, { TQt::Key_ScrollLock, TQT_TRANSLATE_NOOP( "TQAccel", "Scroll Lock" ) },
{ TQt::Key_Insert, QT_TRANSLATE_NOOP( "TQAccel", "Insert" ) }, { TQt::Key_Insert, TQT_TRANSLATE_NOOP( "TQAccel", "Insert" ) },
{ TQt::Key_Delete, QT_TRANSLATE_NOOP( "TQAccel", "Delete" ) }, { TQt::Key_Delete, TQT_TRANSLATE_NOOP( "TQAccel", "Delete" ) },
{ TQt::Key_Escape, QT_TRANSLATE_NOOP( "TQAccel", "Escape" ) }, { TQt::Key_Escape, TQT_TRANSLATE_NOOP( "TQAccel", "Escape" ) },
{ TQt::Key_SysReq, QT_TRANSLATE_NOOP( "TQAccel", "System Request" ) }, { TQt::Key_SysReq, TQT_TRANSLATE_NOOP( "TQAccel", "System Request" ) },
{ 0, 0 } { 0, 0 }
}; };

@ -43,7 +43,7 @@ struct ConfigStyle
TQFont font; TQFont font;
TQColor color; TQColor color;
Q_DUMMY_COMPARISON_OPERATOR( ConfigStyle ) TQ_DUMMY_COMPARISON_OPERATOR( ConfigStyle )
}; };
struct Config struct Config

@ -48,7 +48,7 @@ struct Paren
TQChar chr; TQChar chr;
int pos; int pos;
Q_DUMMY_COMPARISON_OPERATOR( Paren ) TQ_DUMMY_COMPARISON_OPERATOR( Paren )
}; };
typedef TQValueList<Paren> ParenList; typedef TQValueList<Paren> ParenList;

@ -202,7 +202,7 @@ public:
OpenGLWidgetInterface(); OpenGLWidgetInterface();
TQRESULT queryInterface( const TQUuid&, TQUnknownInterface ** ); TQRESULT queryInterface( const TQUuid&, TQUnknownInterface ** );
Q_REFCOUNT; TQ_REFCOUNT;
TQStringList featureList() const; TQStringList featureList() const;
@ -266,7 +266,7 @@ TQString OpenGLWidgetInterface::includeFile( const TQString &description ) const
TQString OpenGLWidgetInterface::toolTip( const TQString &description ) const TQString OpenGLWidgetInterface::toolTip( const TQString &description ) const
{ {
if ( description == "GLWidget" ) if ( description == "GLWidget" )
return QT_TR_NOOP("OpenGL Widget"); return TQT_TR_NOOP("OpenGL Widget");
return TQString::null; return TQString::null;
} }

@ -45,7 +45,7 @@ public:
virtual ~CommonInterface(); virtual ~CommonInterface();
TQRESULT queryInterface( const TQUuid&, TQUnknownInterface** ); TQRESULT queryInterface( const TQUuid&, TQUnknownInterface** );
Q_REFCOUNT; TQ_REFCOUNT;
TQString name() const { return "C++"; } TQString name() const { return "C++"; }
TQString description() const { return "C++ Integration"; } TQString description() const { return "C++ Integration"; }

@ -52,7 +52,7 @@ public:
virtual ~EditorInterfaceImpl(); virtual ~EditorInterfaceImpl();
TQRESULT queryInterface( const TQUuid&, TQUnknownInterface** ); TQRESULT queryInterface( const TQUuid&, TQUnknownInterface** );
Q_REFCOUNT; TQ_REFCOUNT;
TQWidget *editor( bool readonly, TQWidget *parent, TQUnknownInterface *designerIface ); TQWidget *editor( bool readonly, TQWidget *parent, TQUnknownInterface *designerIface );

@ -47,7 +47,7 @@ public:
Source create( const TQString &templ, TQUnknownInterface *appIface ); Source create( const TQString &templ, TQUnknownInterface *appIface );
TQString language( const TQString &templ ) const; TQString language( const TQString &templ ) const;
Q_REFCOUNT TQ_REFCOUNT
}; };

@ -43,7 +43,7 @@ public:
DlgFilter(); DlgFilter();
TQRESULT queryInterface( const TQUuid&, TQUnknownInterface **iface ); TQRESULT queryInterface( const TQUuid&, TQUnknownInterface **iface );
Q_REFCOUNT; TQ_REFCOUNT;
TQStringList featureList() const; TQStringList featureList() const;
TQStringList import( const TQString& filter, const TQString& filename ); TQStringList import( const TQString& filter, const TQString& filename );

@ -43,7 +43,7 @@ public:
GladeFilter(); GladeFilter();
TQRESULT queryInterface( const TQUuid&, TQUnknownInterface **iface ); TQRESULT queryInterface( const TQUuid&, TQUnknownInterface **iface );
Q_REFCOUNT; TQ_REFCOUNT;
TQStringList featureList() const; TQStringList featureList() const;
TQStringList import( const TQString& filter, const TQString& filename ); TQStringList import( const TQString& filter, const TQString& filename );

@ -46,7 +46,7 @@ public:
KDevDlgFilter(); KDevDlgFilter();
TQRESULT queryInterface( const TQUuid&, TQUnknownInterface **iface ); TQRESULT queryInterface( const TQUuid&, TQUnknownInterface **iface );
Q_REFCOUNT; TQ_REFCOUNT;
TQStringList featureList() const; TQStringList featureList() const;
TQStringList import( const TQString& filter, const TQString& filename ); TQStringList import( const TQString& filter, const TQString& filename );

@ -44,7 +44,7 @@ public:
RCFilter(); RCFilter();
TQRESULT queryInterface( const TQUuid&, TQUnknownInterface **iface ); TQRESULT queryInterface( const TQUuid&, TQUnknownInterface **iface );
Q_REFCOUNT; TQ_REFCOUNT;
TQStringList featureList() const; TQStringList featureList() const;
TQStringList import( const TQString& filter, const TQString& filename ); TQStringList import( const TQString& filter, const TQString& filename );

@ -814,7 +814,7 @@ bool RC2UI::makeIcon()
/*! /*!
Writes a stringtable from the input stream to a c++ header file. Writes a stringtable from the input stream to a c++ header file.
All strings are assigned using QT_TR_NOOP to enable easy translation. All strings are assigned using TQT_TR_NOOP to enable easy translation.
*/ */
bool RC2UI::makeStringTable() bool RC2UI::makeStringTable()
@ -859,7 +859,7 @@ bool RC2UI::makeStringTable()
ID = parseNext(line, ' '); ID = parseNext(line, ' ');
value = parseNext(line).stripWhiteSpace(); value = parseNext(line).stripWhiteSpace();
*out << "static const TQString " << ID << "= QT_TR_NOOP(" << value << ");" << endl; *out << "static const TQString " << ID << "= TQT_TR_NOOP(" << value << ");" << endl;
} while ( line != "END" ); } while ( line != "END" );

@ -48,7 +48,7 @@ public:
virtual ~StandardTemplateWizardInterface(); virtual ~StandardTemplateWizardInterface();
TQRESULT queryInterface( const TQUuid&, TQUnknownInterface** ); TQRESULT queryInterface( const TQUuid&, TQUnknownInterface** );
Q_REFCOUNT; TQ_REFCOUNT;
TQStringList featureList() const; TQStringList featureList() const;

@ -128,7 +128,7 @@ private:
{ {
TQString header; TQString header;
TQString location; TQString location;
Q_DUMMY_COMPARISON_OPERATOR(CustomInclude) TQ_DUMMY_COMPARISON_OPERATOR(CustomInclude)
}; };
TQValueList<Buddy> buddies; TQValueList<Buddy> buddies;

@ -152,7 +152,7 @@ private:
TQString name; TQString name;
TQPixmap pix; TQPixmap pix;
TQString field; TQString field;
Q_DUMMY_COMPARISON_OPERATOR( Field ) TQ_DUMMY_COMPARISON_OPERATOR( Field )
}; };
struct SqlWidgetConnection struct SqlWidgetConnection
@ -163,7 +163,7 @@ private:
TQString conn; TQString conn;
TQString table; TQString table;
TQMap<TQString, TQString> *dbControls; TQMap<TQString, TQString> *dbControls;
Q_DUMMY_COMPARISON_OPERATOR( SqlWidgetConnection ) TQ_DUMMY_COMPARISON_OPERATOR( SqlWidgetConnection )
}; };
TQValueList<Image> images; TQValueList<Image> images;

@ -241,7 +241,7 @@ understood as meaning \c MyNamespace::MyClass::tr().
If the quoted text is not in a member function of a QObject subclass, If the quoted text is not in a member function of a QObject subclass,
use either the tr() function of an appropriate class, or the use either the tr() function of an appropriate class, or the
QApplication::translate() function directly: QApplication::translate() function directly:
\code \code
void some_global_function( LoginWidget *logwid ) void some_global_function( LoginWidget *logwid )
@ -258,30 +258,30 @@ QApplication::translate() function directly:
} }
\endcode \endcode
\section3 Using QT_TR_NOOP() and QT_TRANSLATE_NOOP() \section3 Using TQT_TR_NOOP() and TQT_TRANSLATE_NOOP()
If you need to have translatable text completely outside a function, If you need to have translatable text completely outside a function,
there are two macros to help: QT_TR_NOOP() and QT_TRANSLATE_NOOP(). there are two macros to help: TQT_TR_NOOP() and TQT_TRANSLATE_NOOP().
These macros merely mark the text for extraction by \l{lupdate}. These macros merely mark the text for extraction by \l{lupdate}.
The macros expand to just the text (without the context). The macros expand to just the text (without the context).
Example of QT_TR_NOOP(): Example of TQT_TR_NOOP():
\code \code
QString FriendlyConversation::greeting( int greet_type ) QString FriendlyConversation::greeting( int greet_type )
{ {
static const char* greeting_strings[] = { static const char* greeting_strings[] = {
QT_TR_NOOP( "Hello" ), TQT_TR_NOOP( "Hello" ),
QT_TR_NOOP( "Goodbye" ) TQT_TR_NOOP( "Goodbye" )
}; };
return tr( greeting_strings[greet_type] ); return tr( greeting_strings[greet_type] );
} }
\endcode \endcode
Example of QT_TRANSLATE_NOOP(): Example of TQT_TRANSLATE_NOOP():
\code \code
static const char* greeting_strings[] = { static const char* greeting_strings[] = {
QT_TRANSLATE_NOOP( "FriendlyConversation", "Hello" ), TQT_TRANSLATE_NOOP( "FriendlyConversation", "Hello" ),
QT_TRANSLATE_NOOP( "FriendlyConversation", "Goodbye" ) TQT_TRANSLATE_NOOP( "FriendlyConversation", "Goodbye" )
}; };
QString FriendlyConversation::greeting( int greet_type ) QString FriendlyConversation::greeting( int greet_type )
@ -337,7 +337,7 @@ English version}, above, shows the English version.
\index QTranslator \index QTranslator
This line includes the definition of the \l QTranslator class. This line includes the definition of the \l QTranslator class.
Objects of this class provide translations for user-visible text. Objects of this class provide translations for user-visible text.
\skipto QTranslator \skipto QTranslator
@ -590,7 +590,7 @@ version}, above, the central widget with the four buttons is an
When \l lupdate is run it not only extracts the source texts but it When \l lupdate is run it not only extracts the source texts but it
also groups them into contexts. A context is the name of the class in also groups them into contexts. A context is the name of the class in
which the source text appears. Thus, in this example, "ArrowPad" is a which the source text appears. Thus, in this example, "ArrowPad" is a
context: it is the context of the texts in the \c ArrowPad class. context: it is the context of the texts in the \c ArrowPad class.
The \c TQ_OBJECT macro defines \c tr(x) in \c ArrowPad like this The \c TQ_OBJECT macro defines \c tr(x) in \c ArrowPad like this
\index QApplication!translate() \index QApplication!translate()
@ -796,7 +796,7 @@ then the example. What effect did this change have?
\index Canada \index Canada
\index French Canada \index French Canada
Set \c LANG=fr_CA (French Canada) and run the example program again. Set \c LANG=fr_CA (French Canada) and run the example program again.
Explain why the result is the same as with \c LANG=fr. Explain why the result is the same as with \c LANG=fr.
Change one of the accelerators in the Dutch translation to eliminate the Change one of the accelerators in the Dutch translation to eliminate the
@ -926,7 +926,7 @@ translation file based on the current locale.
We will use the translations in the \c tt3_pt.ts file that is provided. We will use the translations in the \c tt3_pt.ts file that is provided.
Set the \c LANG environment variable to \c pt, and then run \c tt3. Set the \c LANG environment variable to \c pt, and then run \c tt3.
You should still see the English version, as shown in the \e You should still see the English version, as shown in the \e
{Tutorial 3 Screenshot, "Troll Print 1.0", English version}, above. {Tutorial 3 Screenshot, "Troll Print 1.0", English version}, above.
Now run \l lrelease, e.g. \c {lrelease tt3.pro}, and then run the Now run \l lrelease, e.g. \c {lrelease tt3.pro}, and then run the
@ -1031,7 +1031,7 @@ Try adding these comments to some source files, particularly to
dialog classes, describing the navigation necessary to reach the dialog classes, describing the navigation necessary to reach the
dialogs. You could also add them to the example files, e.g. \c dialogs. You could also add them to the example files, e.g. \c
mainwindow.cpp and \c printpanel.cpp are appropriate files. Run \l mainwindow.cpp and \c printpanel.cpp are appropriate files. Run \l
lupdate and then start \e {Qt Linguist} and load in \c tt3_pt.ts. lupdate and then start \e {Qt Linguist} and load in \c tt3_pt.ts.
You should see the comments in the \e {Source text and comments} area You should see the comments in the \e {Source text and comments} area
as you browse through the list of source texts. as you browse through the list of source texts.

@ -88,12 +88,12 @@ TQString richText( const TQString& text )
{ {
const char backTab[] = "\a\b\f\n\r\t"; const char backTab[] = "\a\b\f\n\r\t";
const char * const friendlyBackTab[] = { const char * const friendlyBackTab[] = {
QT_TRANSLATE_NOOP( "MessageEditor", "bell" ), TQT_TRANSLATE_NOOP( "MessageEditor", "bell" ),
QT_TRANSLATE_NOOP( "MessageEditor", "backspace" ), TQT_TRANSLATE_NOOP( "MessageEditor", "backspace" ),
QT_TRANSLATE_NOOP( "MessageEditor", "new page" ), TQT_TRANSLATE_NOOP( "MessageEditor", "new page" ),
QT_TRANSLATE_NOOP( "MessageEditor", "new line" ), TQT_TRANSLATE_NOOP( "MessageEditor", "new line" ),
QT_TRANSLATE_NOOP( "MessageEditor", "carriage return" ), TQT_TRANSLATE_NOOP( "MessageEditor", "carriage return" ),
QT_TRANSLATE_NOOP( "MessageEditor", "tab" ) TQT_TRANSLATE_NOOP( "MessageEditor", "tab" )
}; };
TQString rich; TQString rich;

@ -388,7 +388,7 @@ template <class K, class D>
TQValueList<K> keys(TQMap<K,D> map) TQValueList<K> keys(TQMap<K,D> map)
{ {
TQValueList<K> result; TQValueList<K> result;
for (Q_TYPENAME TQMap<K,D>::ConstIterator it = map.begin(); it!=map.end(); ++it) for (TQ_TYPENAME TQMap<K,D>::ConstIterator it = map.begin(); it!=map.end(); ++it)
result.append(it.key()); result.append(it.key());
return result; return result;
} }

Loading…
Cancel
Save