Replace QObject, QWidget, QImage, QPair, QRgb, QColor, QChar, QString, QIODevice with TQ* version

Signed-off-by: Michele Calgaro <michele.calgaro@yahoo.it>
(cherry picked from commit 241e0082f7b9ccadaeed0ef43a1c9ebb9b4fe840)

2 files changed, 45 insertions, 45 deletions

diff --git a/tde-i18n-es/docs/tdevelop/kde_app_devel/index.docbook b/tde-i18n-es/docs/tdevelop/kde_app_devel/index.docbook
index f39709f31c2..6c881b6997b 100644
--- a/tde-i18n-es/docs/tdevelop/kde_app_devel/index.docbook
+++ b/tde-i18n-es/docs/tdevelop/kde_app_devel/index.docbook
@@ -160,15 +160,15 @@ return a.exec();
 </orderedlist> 
 </para>
 <para>El segundo objeto de nuestro programa es el botón pulsable, una instancia de la clase <classname>QPushButton</classname>. Hemos usado el segundo de los dos constructores que se nos ofrecen para crear una instancia de este objeto. Este constructor acepta como parámetro un texto, que será la etiqueta que mostrará el botón (aquí es la cadena «¡Hola mundo!»). Luego hemos llamado al método <methodname>resize()</methodname> para cambiar el tamaño del botón en relación a su contenido (el botón debe ser más ancho para que la cadena aparezca completamente). </para>
-<para>Pero, ¿qué hay del método <methodname>show()</methodname>? Ahora veremos que, al igual que la mayor parte de de widgetds, <classname>QPushButton</classname> se basa en la herencia simple. La documentación dice que esta clase hereda de <classname>QButton</classname>. Siga el enlace de la clase <classname>QButton</classname> y verá más widgets que han sido heredados por <classname>QPushButton</classname> (y que usaremos más adelante para explicar el mecanismo señal/slot). No obstante, el método <methodname>show()</methodname> no aparece listado, por lo que también tiene que haber sido proporcionado mediante herencia. La clase de la que hereda <classname>QButton</classname> es <classname>QWidget</classname>. Vuelva a seguir el enlace y verá el gran número de métodos que proporciona <classname>QWidget</classname>, incluido el método <methodname>show()</methodname>. Ahora entendemos lo que se ha hecho con el botón en el ejemplo: <orderedlist>
+<para>Pero, ¿qué hay del método <methodname>show()</methodname>? Ahora veremos que, al igual que la mayor parte de de widgetds, <classname>QPushButton</classname> se basa en la herencia simple. La documentación dice que esta clase hereda de <classname>QButton</classname>. Siga el enlace de la clase <classname>QButton</classname> y verá más widgets que han sido heredados por <classname>QPushButton</classname> (y que usaremos más adelante para explicar el mecanismo señal/slot). No obstante, el método <methodname>show()</methodname> no aparece listado, por lo que también tiene que haber sido proporcionado mediante herencia. La clase de la que hereda <classname>QButton</classname> es <classname>TQWidget</classname>. Vuelva a seguir el enlace y verá el gran número de métodos que proporciona <classname>TQWidget</classname>, incluido el método <methodname>show()</methodname>. Ahora entendemos lo que se ha hecho con el botón en el ejemplo: <orderedlist>
 <listitem><para>Crear una instancia de <classname>QPushButton</classname>, usar el segundo constructor para establecer el texto del botón</para></listitem>
 <listitem><para>Modificar el tamaño del widget según su contenido</para></listitem>
 <listitem><para>Establecer el widget como widget principal de la instancia «a» de <classname>QApplication</classname></para></listitem>
-<listitem><para>Indicarle al widget que se muestre a sí mismo en la pantalla llamando a <methodname>show()</methodname>, un método heredado de <classname>QWidget</classname></para></listitem>
+<listitem><para>Indicarle al widget que se muestre a sí mismo en la pantalla llamando a <methodname>show()</methodname>, un método heredado de <classname>TQWidget</classname></para></listitem>
 </orderedlist>
 </para>
 <para>Tras llamar al método <methodname>exec()</methodname> la aplicación se hace visible al usuario, mostrando una ventana con el botón, que muestra el texto «¡Hola mundo!». Tenga en cuenta que los programas gráficos se comportan de un modo algo distinto al de las aplicaciones basadas en procedimientos. El punto principal es que aquí la aplicación entra en lo que se denomina un «bucle principal de eventos». Esto significa que el programa debe esperar las acciones del usuario y luego reaccionar a ellas. Además, para una aplicación Qt, el programa tiene que estar en el bucle principal de eventos para comenzar a manejar los eventos. La siguiente sección le enseñará brevemente lo que significa esto para el programador y qué ofrece Qt para procesar los eventos del usuario. </para>
-<note><para>Para los usuarios avanzados: El botón no tiene un padre declarado en el constructor, por lo que es un widget aislado de nivel superior que se ejecuta en un bucle de eventos locales que no necesita esperar al bucle de eventos principal. Consulte la documentación de la clase QWidget y la «Guía de referencia de la biblioteca KDE».</para>
+<note><para>Para los usuarios avanzados: El botón no tiene un padre declarado en el constructor, por lo que es un widget aislado de nivel superior que se ejecuta en un bucle de eventos locales que no necesita esperar al bucle de eventos principal. Consulte la documentación de la clase TQWidget y la «Guía de referencia de la biblioteca KDE».</para>
 </note> 
 
 </sect3>
@@ -183,7 +183,7 @@ return a.exec();
 </itemizedlist> 
 </para>
 <para>Ahora le daremos «vida» a la aplicación procesando los eventos del usuario. Generalmente, el usuario tiene dos formas de interactuar con un programa: el ratón y el teclado. Para ambas, una interfaz gráfica de usuario debe proporcionar métodos que detecten acciones y métodos que hagan algo como respuesta a estas acciones. </para> 
-<para>Para ello, el sistema de ventanas envía todos los eventos de interacción a la aplicación correspondiente. El objeto <classname>QApplication</classname> los envía luego a la ventana activa como objetos <classname>QEvent</classname>, y los widgets deben decidir por sí mismos qué hacer con ellos. Cuando un widget recibe el evento, procesa el método <methodname>QWidget::event(QEvent*)</methodname>, que se encarga de decidir qué evento ha sido ejecutado y cómo reaccionar a él. Por lo tanto, <methodname>event()</methodname> es el manejador principal de eventos. A continuación, el método <methodname>event()</methodname> pasa el evento a los llamados «filtros de eventos» para determinar qué ha ocurrido y qué se debe hacer con el evento. Si no existe ningún filtro que se haga responsable para dicho evento, se llama a los manejadores de eventos especializados. Mediante ellos podemos decidir entre: <itemizedlist>
+<para>Para ello, el sistema de ventanas envía todos los eventos de interacción a la aplicación correspondiente. El objeto <classname>QApplication</classname> los envía luego a la ventana activa como objetos <classname>QEvent</classname>, y los widgets deben decidir por sí mismos qué hacer con ellos. Cuando un widget recibe el evento, procesa el método <methodname>TQWidget::event(QEvent*)</methodname>, que se encarga de decidir qué evento ha sido ejecutado y cómo reaccionar a él. Por lo tanto, <methodname>event()</methodname> es el manejador principal de eventos. A continuación, el método <methodname>event()</methodname> pasa el evento a los llamados «filtros de eventos» para determinar qué ha ocurrido y qué se debe hacer con el evento. Si no existe ningún filtro que se haga responsable para dicho evento, se llama a los manejadores de eventos especializados. Mediante ellos podemos decidir entre: <itemizedlist>
 <listitem><para>Eventos del teclado -- Teclas «Tabulador» y «Mayúsculas-Tabulador»:</para>
 <itemizedlist>
 <listitem><para><methodname>virtual void focusInEvent(QFocusEvent *)</methodname></para></listitem>
@@ -224,12 +224,12 @@ return a.exec();
 
 </itemizedlist>
 </para>
-<para>Note que todas las funciones de eventos son virtuales y protegidas, por lo que puede reimplementar los métodos encargados de manejar eventos que necesite en sus propios widgets y especificar cómo deben reaccionar. <classname>QWidget</classname> también contiene varios métodos virtuales más que pueden resultar de utilidad en sus programas. De ahí que sea recomendable conocer bien la clase <classname>QWidget</classname>. </para>
+<para>Note que todas las funciones de eventos son virtuales y protegidas, por lo que puede reimplementar los métodos encargados de manejar eventos que necesite en sus propios widgets y especificar cómo deben reaccionar. <classname>TQWidget</classname> también contiene varios métodos virtuales más que pueden resultar de utilidad en sus programas. De ahí que sea recomendable conocer bien la clase <classname>TQWidget</classname>. </para>
 </sect2>
 <sect2 id="c1s2s4">
 <title>Interacción entre objetos mediantes señales y slots</title>
 <para>Estamos llegando a una de las ventajas más obvias del juego de herramientas Qt: el mecanismo señal/objeto, que ofrece una solución útil y provechosa para la interacción de objetos (que normalmente se resuelve mediante funciones «callback» de las herramientas del sistema X-Window). Como esta comunicación requiere una programación estricta y a menudo dificulta la creación de interfaces de usuario (como se dice en la documentación de Qt y se explica en «Programando con Qt», de K. Dalheimer), Trolltech creó un nuevo sistema en el que los objetos pueden emitir señales que se pueden conectar a métodos declarados como «slots». Desde el punto de vista del programador de C++, solo es necesario saber ciertas cosas sobre este mecanismo: <itemizedlist>
-<listitem><para>la declaración de una clase que use señales y slots debe contener la macro TQ_OBJECT al principio (sin punto y coma); también debe derivar de la clase <classname>QObject</classname> </para></listitem>
+<listitem><para>la declaración de una clase que use señales y slots debe contener la macro TQ_OBJECT al principio (sin punto y coma); también debe derivar de la clase <classname>TQObject</classname> </para></listitem>
 <listitem><para>se puede emitir una señal mediante la palabra clave «emit»; por ejemplo, «emit señal(parámetros);», desde dentro de cualquier función miembro de una clase que permita señales y slots </para></listitem>
 
 <listitem><para>todas las señales usadas por las clases que no sean heredadas deben ser añadidas a la declaración de la clase mediante una sección «signals» </para></listitem>
@@ -237,9 +237,9 @@ return a.exec();
 <listitem><para>el compilador de metaobjetos «moc» debe ejecutarse con el archivo de cabecera para expandir las macros y generar la implementación (que no es necesario conocer). Los archivos de salida de «moc» también son compilados por el compilador de C++. </para></listitem>
 </itemizedlist>
 </para>
-<para>Otra forma de usar señales sin derivar de <classname>QObject</classname> consiste en usar la clase <classname>QSignal</classname> (consulte la documentación de referencia para obtener más información y un ejemplo de uso). En lo sucesivo asumiremos que está derivando de <classname>QObject</classname>. </para>
+<para>Otra forma de usar señales sin derivar de <classname>TQObject</classname> consiste en usar la clase <classname>QSignal</classname> (consulte la documentación de referencia para obtener más información y un ejemplo de uso). En lo sucesivo asumiremos que está derivando de <classname>TQObject</classname>. </para>
 <para>De este modo, su clase será capaz de enviar señales a cualquier otro sitio y de proporcionar «slots» a los que se puedan conectar señales. Gracias al uso de estas señales no tendrá que preocuparse de quién va a recibirlas: solo tiene que emitir la señal, y cualquier «slot» al que quiera conectarla reaccionará a la emisión. Los «slots» también pueden ser usados como métodos normales en la implementación. </para>
-<para>Ahora, para conectar una señal a un «slot», tendrá que usar los métodos <methodname>connect()</methodname> proporcionados por la clase <classname>QObject</classname> o, cuando estén disponibles, otros métodos especiales proporcionados por diversos objetos para establecer la conexión con ciertas señales. </para>
+<para>Ahora, para conectar una señal a un «slot», tendrá que usar los métodos <methodname>connect()</methodname> proporcionados por la clase <classname>TQObject</classname> o, cuando estén disponibles, otros métodos especiales proporcionados por diversos objetos para establecer la conexión con ciertas señales. </para>
 
 <sect3 id="c1s2s4s1">
 <title>Ejemplo de uso</title>
@@ -255,16 +255,16 @@ hello.resize( 100, 30 );
 
 a.setMainWidget( &amp;hello );
 
-QObject::connect(&amp;hello, SIGNAL( clicked() ), &amp;a, SLOT( quit() ));
+TQObject::connect(&amp;hello, SIGNAL( clicked() ), &amp;a, SLOT( quit() ));
 
 hello.show();
 return a.exec();
 }
 </programlisting>
 </para>
-<para>Como puede comprobar, la única adición para dar más interacción al botón consiste en usar un método <methodname>connect()</methodname>: <methodname>connect(&amp;hello, SIGNAL( clicked() ), &amp;a, SLOT( quit() ));</methodname> es todo cuanto tiene que añadir. ¿Cuál es su significado? La declaración de la clase QObject dice lo siguiente sobre el método <methodname>connect()</methodname>: </para>
-<para><methodname>bool connect ( const QObject * emisor, const char * señal, const QObject * receptor, const char * miembro ) </methodname></para>
-<para>Esto significa que debe especificar como primer parámetro un puntero de una instancia de la clase <classname>QObject</classname>, que es el emisor de la señal (lo que significa que puede emitir esta señal); a continuación debe especificar la señal que desea conectar. Los dos últimos parámetros son, en primer lugar, el objeto receptor que proporciona un «slot», y, finalmente, la función miembro de dicho objeto que va a actuar como «slot» (y que será ejecutada tras la emisión de la señal). </para>
+<para>Como puede comprobar, la única adición para dar más interacción al botón consiste en usar un método <methodname>connect()</methodname>: <methodname>connect(&amp;hello, SIGNAL( clicked() ), &amp;a, SLOT( quit() ));</methodname> es todo cuanto tiene que añadir. ¿Cuál es su significado? La declaración de la clase TQObject dice lo siguiente sobre el método <methodname>connect()</methodname>: </para>
+<para><methodname>bool connect ( const TQObject * emisor, const char * señal, const TQObject * receptor, const char * miembro ) </methodname></para>
+<para>Esto significa que debe especificar como primer parámetro un puntero de una instancia de la clase <classname>TQObject</classname>, que es el emisor de la señal (lo que significa que puede emitir esta señal); a continuación debe especificar la señal que desea conectar. Los dos últimos parámetros son, en primer lugar, el objeto receptor que proporciona un «slot», y, finalmente, la función miembro de dicho objeto que va a actuar como «slot» (y que será ejecutada tras la emisión de la señal). </para>
 <para>Mediante el uso de señales y «slots», los objetos de su programa pueden interactuar con otros fácilmente sin depender explícitamente del tipo de objeto receptor. Aprenderá más sobre el uso de este mecanismo para usos productivos en sucesivas secciones de este manual. También puede encontrar más información sobre el mecanismo de señales y «slots» en la <ulink url="developer.kde.org/documentation/library/libraryref.html">Guía de referencia de la biblioteca KDE</ulink> y la <ulink url="doc.trolltech.com">referencia en línea de Qt</ulink>. </para>
 </sect3>
 </sect2>
@@ -304,7 +304,7 @@ hello.resize( 100, 30 );
 
 a.setTopWidget( &amp;hello );
 
-QObject::connect(&amp;hello, SIGNAL( clicked() ), &amp;a, SLOT( quit() ));
+TQObject::connect(&amp;hello, SIGNAL( clicked() ), &amp;a, SLOT( quit() ));
 
 hello.show();
 return a.exec();
@@ -313,7 +313,7 @@ return a.exec();
 </para> 
 <para>Vea que en primer lugar hemos cambiado de <classname>QApplication</classname> a <classname>TDEApplication </classname>. Además, hemos tenido que cambiar elmétodo <methodname>setMainWidget()</methodname> anteriormente usado por <methodname>setTopWidget</methodname>, que utiliza <classname>TDEApplication</classname> para establecer el «widget» principal. ¡Y ya está! Su primera aplicación de KDE ya está terminada. Ahora solo le falta indicarle al compilador la ruta de inclusión de KDE, y al enlazador que utilice la biblioteca tdecore mediante el parámetro -ltdecore. </para>
 <para>Como ahora ya sabe qué suele proporcionar como mínimo la función <function>main()</function>, cómo se hace visible una aplicación y cómo permite la interacción entre usuario y objetos, seguiremos con el siguiente capítulo, donde nuestra primera aplicación se construirá con &tdevelop;. Ahí tambień podrá probar todo lo que se ha dicho hasta ahora y comprobar sus efectos. </para>
-<para>Adicionalmente, hasta ahora ha consultado la documentación de referencia de Qt, especialmente las clases <classname>QApplication</classname>, <classname>QWidget</classname> y <classname>QObject</classname>, y la documentación de la biblioteca «tdecore» sobre la clase <classname>TDEApplication</classname>. El <ulink url="developer.kde.org/documentation/library/libraryref.html"> Manual d referencia de la biblioteca KDE</ulink> también contiene una completa descripción sobre cómo llamar a los constructores de <classname>QApplication</classname> y de <classname>TDEApplication</classname>, incluido el procesamiento de los argumentos pasados como parámetros en la línea de comando. </para>
+<para>Adicionalmente, hasta ahora ha consultado la documentación de referencia de Qt, especialmente las clases <classname>QApplication</classname>, <classname>TQWidget</classname> y <classname>TQObject</classname>, y la documentación de la biblioteca «tdecore» sobre la clase <classname>TDEApplication</classname>. El <ulink url="developer.kde.org/documentation/library/libraryref.html"> Manual d referencia de la biblioteca KDE</ulink> también contiene una completa descripción sobre cómo llamar a los constructores de <classname>QApplication</classname> y de <classname>TDEApplication</classname>, incluido el procesamiento de los argumentos pasados como parámetros en la línea de comando. </para>
 </sect2>
 </sect1>
 
@@ -549,10 +549,10 @@ return a.exec();
 16     statusBar()->show();
 17 
 18     // permitir que la vista pueda cambiar la barra de estado y el título
-19     connect(m_view, SIGNAL(signalChangeStatusbar(const QString&amp;)),
-20             this,   SLOT(changeStatusbar(const QString&amp;)));
-21     connect(m_view, SIGNAL(signalChangeCaption(const QString&amp;)),
-22             this,   SLOT(changeCaption(const QString&amp;)));
+19     connect(m_view, SIGNAL(signalChangeStatusbar(const TQString&amp;)),
+20             this,   SLOT(changeStatusbar(const TQString&amp;)));
+21     connect(m_view, SIGNAL(signalChangeCaption(const TQString&amp;)),
+22             this,   SLOT(changeCaption(const TQString&amp;)));
 23
 24  }
 </programlisting>
@@ -584,7 +584,7 @@ return a.exec();
 </itemizedlist>
 </para>
 <para>Tampoco es necesario decir que la estabilidad es uno de los principales objetivos del diseño. Nadie puede evitar los errores, pero se puede conseguir bastante mediante objetivos diseñados inteligentemente y el amplio uso de diseños orientados a objetos. C++ hace que la programación sea un juego si sabe cómo explotar sus capacidades: herencia, ocultación de información y reusabilidad del código existente. </para>
-<para>Cuando cree un proyecto KDE o Qt, siempre tendrá una vista que herede de QWidget, ya sea por herencia directa o porque el widget de la biblioteca que desea usar hereda de QWidget. De ahí que el asistente para aplicaciones haya construido una vista que es una instancia de una clase «aplicaciónView», que hereda de QWidget. </para>
+<para>Cuando cree un proyecto KDE o Qt, siempre tendrá una vista que herede de TQWidget, ya sea por herencia directa o porque el widget de la biblioteca que desea usar hereda de TQWidget. De ahí que el asistente para aplicaciones haya construido una vista que es una instancia de una clase «aplicaciónView», que hereda de TQWidget. </para>
 <para>Este capítulo describe cómo usar widgets de bibliotecas para crear vistas para aplicaciones de KDE o Qt que han sido generadas con &tdevelop;. Luego veremos las bibliotecas y qué tipo de vistas nos ofrecen. </para>
 </sect1>
 <sect1 id="c4s2">
@@ -601,7 +601,7 @@ return a.exec();
 <para>Si observa la primera página de la documentación en línea de Qt encontrará un enlace a «capturas de pantalla de los widgets», donde podrá ver cómo son los widgets que contiene Qt. Estos widgets están listos para usar y pueden ser combinados entre sí para formar widgets más complicados que le permitirán crear vistas y diálogos para su aplicación. A continuación describiremos algunos de estos widgets que le resultarán de utilidad para crear vistas de aplicaciones, pero recuerde que las bibliotecas de KDE suelen contener otros widgets para el mismo propósito. Veremos esto en la próxima sección. </para>
 <para>A continuación le damos una lista de pistas sobre para qué propósito puede usar cada componente de Qt: <orderedlist>
 <listitem><para>Si el área de su vista no es lo suficientemente amplia para mostrar todos sus datos, el usuario debería poder desplazarse por el documento con barras situadas a la derecha y en la parte inferior de la vista. Para ello, Qt proporciona la clase <classname>QScrollView</classname>, que ofrece un área hija que se puede desplazar. Como se ha explicado, puede derivar su propio widget de la clase <classname>QScrollView</classname> o usar una instancia de ella para gestionar el widget que contendrá la vista de su documento. </para></listitem> 
-<listitem><para>Para crear una vista propia que se pueda deslazar, derive su widget de vista de la clase <classname>QWidget</classname> y añada un <classname>QScrollBar</classname> horizontal y otro vertical (esto es lo que hace, por ejemplo, el widget TDEHTMLView de KDE). </para></listitem> 
+<listitem><para>Para crear una vista propia que se pueda deslazar, derive su widget de vista de la clase <classname>TQWidget</classname> y añada un <classname>QScrollBar</classname> horizontal y otro vertical (esto es lo que hace, por ejemplo, el widget TDEHTMLView de KDE). </para></listitem> 
 <listitem><para>Para procesar texto, utilice <classname>QTextEdit</classname>. Esta clase proporciona un widget con un completo editor de texto que es capaz de cortar, copiar y pegar texto, y está gestionado por una vista que se puede desplazar. </para></listitem> 
 <listitem><para>Use <classname>QTable</classname> para mostrar datos organizados en forma de tabla. Como <classname>QTable</classname> también está dotada de barras de desplazamiento, ofrece una buena solución para aplicaciones de cálculo de tablas. </para></listitem> 
 <listitem><para>Para mostrar dos widgets diferentes o dos instancias del mismo widget a la vez, utilice <classname>QSplitter</classname>. Esta clase le permite distribuir las vistas mediante divisores horizontales o verticales. KMail es un buen ejemplo de la apariencia de esta clase (la vista principal está dividida verticalmente por un «splitter» o divisor, y la ventana de la derecha también está dividida horizontalmente). </para></listitem> 
@@ -653,7 +653,7 @@ return a.exec();
 <title>Configuración de los accesos rápidos de teclado</title>
 <para>Los accesos rápidos de teclado son algo muy profesional que siempre debería añadir a sus aplicaciones. Son usados principalmente por usuarios avanzados que desean trabajar más rápido con sus aplicaciones. Para implementarlos, las bibliotecas de KDE ofrecen la clase <classname>TDEAction</classname>, que proporciona las teclas de acceso rápido y también brinda acceso a los aceleradores de teclado estándares configurados globalmente. </para>
 <para>De forma predeterminada, las aplicaciones generadas con &tdevelop; solo utilizan accesos rápidos de teclado estándares, como «F1» para acceder a la ayuda en línea, «Ctrl+N» para «Nuevo archivo», etc. </para>
-<para>Si su aplicación contiene gran número de aceleradores, debería hacer que se pudieran configurar desde el menú de «Opciones», ya sea combinados con la configuración de otras aplicaciones en un QWidget o bien de modo aislado. La biblioteca de KDE proporciona una clase <classname>KKeyChooser</classname> para usar en diálogos que contienen pestañas, para los que <classname>KKeyDialog</classname> proporciona un diálogo de configuración de teclas listo para usar. </para>
+<para>Si su aplicación contiene gran número de aceleradores, debería hacer que se pudieran configurar desde el menú de «Opciones», ya sea combinados con la configuración de otras aplicaciones en un TQWidget o bien de modo aislado. La biblioteca de KDE proporciona una clase <classname>KKeyChooser</classname> para usar en diálogos que contienen pestañas, para los que <classname>KKeyDialog</classname> proporciona un diálogo de configuración de teclas listo para usar. </para>
 
 </sect1>
 </chapter>
@@ -696,7 +696,7 @@ return a.exec();
 <sect1 id="c8s4">
 <title>El botón <guibutton>¿Qué es esto?</guibutton></title>
 <para>El botón <guibutton>¿Qué es esto?</guibutton> proporciona ventanas de ayuda con la idea de que el usuario necesita ayuda sobre cierto widget de la vista activa o de un elemento de una barra de herramientas. Se suele colocar en la misma barra de herramientas y se activa cuando el usuario pulsa su botón. El cursor cambia a una flecha con un signo de interrogación (con el mismo aspecto que muestra el botón). A partir de ese momento, el usuario puede pulsar sobre cualquier widget visible y obtener una ventana de ayuda. Como ejercicio, pruebe el comportamiento del botón <guibutton>¿Qué es esto?</guibutton> de &tdevelop;. </para>
-<para>Para añadir ayudas «¿Qué es esto?» a cualquiera de sus widgets, utilice el método estático <methodname>QWhatsThis::add(QWidget *widget, const QString &amp;texto)</methodname> </para>
+<para>Para añadir ayudas «¿Qué es esto?» a cualquiera de sus widgets, utilice el método estático <methodname>QWhatsThis::add(TQWidget *widget, const TQString &amp;texto)</methodname> </para>
 </sect1>
 </chapter>
 
diff --git a/tde-i18n-es/docs/tdevelop/kdearch/index.docbook b/tde-i18n-es/docs/tdevelop/kdearch/index.docbook
index 6166b21acea..2fe426c1f14 100644
--- a/tde-i18n-es/docs/tdevelop/kdearch/index.docbook
+++ b/tde-i18n-es/docs/tdevelop/kdearch/index.docbook
@@ -238,7 +238,7 @@
 </formalpara></listitem>
 
 <listitem><formalpara><title><ulink url="kdeapi:tdeui/KPixmapIO">KPixmapIO</ulink></title>
-<para>Conversión rápida de <classname>QImage</classname> a <classname>QPixmap</classname>. </para>
+<para>Conversión rápida de <classname>TQImage</classname> a <classname>QPixmap</classname>. </para>
 </formalpara></listitem>
 
 </itemizedlist>
@@ -473,7 +473,7 @@ url="kdeapi:tdeui/KAnimWidget">KAnimWidget</ulink></title>
 
 <para>El model de gráficos de bajo nivel de Qt se basa en las capacidades proporcionadas por X11 y otros sitemas de ventanas para los que existen versiones de Qt. Pero también extiende las opciones mencionadas implementando características adicionales como transformaciones de tamaño arbitrario para textos y mapas de pixels. </para>
 
-<para>La clase central para la realización de gráficos 2D en Qt es <ulink url="kdeapi:qt/QPainter">QPainter</ulink>. Puede dibujar en un <ulink url="kdeapi:qt/QPaintDevice">QPaintDevice</ulink>. Hay implementados tres dispositivos de pintura posibles: uno es <ulink url="kdeapi:qt/QWidget">QWidget</ulink>, que representa un widget de la pantalla. El segundo es <ulink url="kdeapi:qt/QPrinter">QPrinter</ulink> que representa una impresora y produce salida PostScript. El tercero es la clase <ulink url="kdeapi:qt/QPicture">QPicture</ulink>, que almacena comandos de dibujo y puede guardarlos en el disco para reproducirlos posteriormente. Un formato de almacenamiento posible para los comandos de dibujo es el estándar de W3C denominado SVG. </para>
+<para>La clase central para la realización de gráficos 2D en Qt es <ulink url="kdeapi:qt/QPainter">QPainter</ulink>. Puede dibujar en un <ulink url="kdeapi:qt/QPaintDevice">QPaintDevice</ulink>. Hay implementados tres dispositivos de pintura posibles: uno es <ulink url="kdeapi:qt/TQWidget">TQWidget</ulink>, que representa un widget de la pantalla. El segundo es <ulink url="kdeapi:qt/QPrinter">QPrinter</ulink> que representa una impresora y produce salida PostScript. El tercero es la clase <ulink url="kdeapi:qt/QPicture">QPicture</ulink>, que almacena comandos de dibujo y puede guardarlos en el disco para reproducirlos posteriormente. Un formato de almacenamiento posible para los comandos de dibujo es el estándar de W3C denominado SVG. </para>
 
 <para>Por lo tanto, es posible reutilizar el código de procesado que se utiliza para mostrar un widget en su impresión posterior, con las mismas características soportadas. Obviamente, en la práctica, el código se utiliza en un contexto ligeramente distinto. El dibujo en un widget se realiza casi exclusivamente en el método paintEvent() de la clase del widget. </para>
 
@@ -664,10 +664,10 @@ url="kdeapi:tdeui/KAnimWidget">KAnimWidget</ulink></title>
 <para>QBrush::QBrush(BrushStyle) - Crea una brocha negra con uno de los siguientes patrones mostrados a continuación.</para>
 </listitem>
 <listitem>
-<para>QBrush::QBrush(const QColor &amp;, BrushStyle) - Crea una brocha de color con uno de los patrones mostrados a continuación.</para>
+<para>QBrush::QBrush(const TQColor &amp;, BrushStyle) - Crea una brocha de color con uno de los patrones mostrados a continuación.</para>
 </listitem>
 <listitem>
-<para>QBrush::QBrush(const QColor &amp;, const QPixmap) - Crea una brocha de color con el patrón personalizado que se proporcione como segundo parámetro.</para>
+<para>QBrush::QBrush(const TQColor &amp;, const QPixmap) - Crea una brocha de color con el patrón personalizado que se proporcione como segundo parámetro.</para>
 </listitem>
 </itemizedlist>
 
@@ -685,7 +685,7 @@ url="kdeapi:tdeui/KAnimWidget">KAnimWidget</ulink></title>
 <simplesect id="qpainter-color">
 <title>Color</title>
 
-<para>Los colores juegan un papel tanto al ajustar curvas como al rellenar figuras. En Qt, los colores están representados por la clase <ulink url="kdeapi:qt/QColor">QColor</ulink>. Qt no soporta características gráficas avanzadas como perfiles de color ICC y corrección de color. Los colores se construyen normalmente especificando sus componentes rojo, verde y azul, siguiendo el modelo RGB que utilizan los monitores para dibujar los pixels. </para>
+<para>Los colores juegan un papel tanto al ajustar curvas como al rellenar figuras. En Qt, los colores están representados por la clase <ulink url="kdeapi:qt/TQColor">TQColor</ulink>. Qt no soporta características gráficas avanzadas como perfiles de color ICC y corrección de color. Los colores se construyen normalmente especificando sus componentes rojo, verde y azul, siguiendo el modelo RGB que utilizan los monitores para dibujar los pixels. </para>
 
 <para>También es posible utilizar tono, saturación y valor. Esta representación (HSV) es la que se utiliza en el diálogo de color de Gtk, por ejemplo en GIMP. En este caso, el tono corresponde al ángulo en la rueda de color, mientras que la saturación corresponde a la distancia desde el centro de círuclo. El valor se puede elegir con un selector independiente. </para>
 
@@ -738,7 +738,7 @@ url="kdeapi:tdeui/KAnimWidget">KAnimWidget</ulink></title>
 
 <para><ulink url="kdeapi:qt/QPixmap">QPixmap</ulink> corresponde directamente a los objetos de mapas de pixels de X11. Los mapas de pixels son objetos del lado del servidor y pueden (en la mayoría de las tarjetas gráficas modernas) ser almacenadas directamente en la memoria de la tarjeta. Esto hace que sean <emphasis>muy</emphasis> eficientes para tranferir mapas de pixels a la pantalla. Los mapas de pixels también funcionan como los equivales de fuera de la pantalla de los widgets; la clase QPixmap es una subclase de QPaintDevice, por lo que es posible dibujarla con un QPainter. Las operaciones elementales de dibujo normalmente se ven aceleradas por los adaptadores gráficos modernos. Por lo tanto, una conducta muy habitual es la de utilizar mapas de pixels para trabajar con doble buffer. Esto significa, en vez de dibujar directamente sobre un widget, que sea crea un objeto de mapa de pixels temporal y se utiliza la función <ulink url="kdeapi:qt/QPaintDevice#bitBlt-1">bitBlt</ulink> para tranferir el mapa de pixels al widget. En casos de redibujados complejos, esto ayuda a evitar el efecto de parpadeo. </para>
 
-<para>Por contra, el objeto <ulink url="kdeapi:qt/QImage">QImage</ulink> permanece en el lado del cliente. Su ventaja está en que proporciona acceso directo a los pixels de la imagen. Esto lo hace útil para la manipulación de imágenes, y operaciones como la carga y almacenamiento en disco (el método load() de QPixmap utiliza QImage en un paso intermedio). Por otro lado, dibujar una imagen en un widget es una operación con un consumo de recursos relativamente alto, ya que implica una transferencia al servidor X, lo que puede llevar algún tiempo, especialmente en imágenes grandes y servidores remotos. Dependiendo de la profundidad de color, la conversión de QImage a QPixmap puede requerir también un proceso de reducción del número de colores. </para>
+<para>Por contra, el objeto <ulink url="kdeapi:qt/TQImage">TQImage</ulink> permanece en el lado del cliente. Su ventaja está en que proporciona acceso directo a los pixels de la imagen. Esto lo hace útil para la manipulación de imágenes, y operaciones como la carga y almacenamiento en disco (el método load() de QPixmap utiliza TQImage en un paso intermedio). Por otro lado, dibujar una imagen en un widget es una operación con un consumo de recursos relativamente alto, ya que implica una transferencia al servidor X, lo que puede llevar algún tiempo, especialmente en imágenes grandes y servidores remotos. Dependiendo de la profundidad de color, la conversión de TQImage a QPixmap puede requerir también un proceso de reducción del número de colores. </para>
 
 </simplesect>
 
@@ -746,7 +746,7 @@ url="kdeapi:tdeui/KAnimWidget">KAnimWidget</ulink></title>
 <simplesect id="qpainter-drawingtext">
 <title>Dibujo de texto</title>
 
-<para>Es posible dibujar texto con una de las variantes sobrecargadas del método QPainter::drawText(). De esta forma se dibuja una QString en un punto o en un rectángulo dado, utilizando la fuente establecida por QPainter::setFont(). También hay un parámetro que admite una combinación OR de algunos parámetros obtenidos de las enumeraciones <ulink url="kdeapi:qt/Qt#AlignmentFlags-enum">Qt::AlignmentFlags</ulink> y <ulink url="kdeapi:qt/Qt#TextFlags-enum">Qt::TextFlags</ulink> </para>
+<para>Es posible dibujar texto con una de las variantes sobrecargadas del método QPainter::drawText(). De esta forma se dibuja una TQString en un punto o en un rectángulo dado, utilizando la fuente establecida por QPainter::setFont(). También hay un parámetro que admite una combinación OR de algunos parámetros obtenidos de las enumeraciones <ulink url="kdeapi:qt/Qt#AlignmentFlags-enum">Qt::AlignmentFlags</ulink> y <ulink url="kdeapi:qt/Qt#TextFlags-enum">Qt::TextFlags</ulink> </para>
 
 <para>A partir de la versión 3.0, Qt se encarga completamente de la disposición del texto incluso en los idiomas escritos de derecha a izquierda. </para>
 
@@ -1002,7 +1002,7 @@ rc_DATA = kviewui.rc
 
 <programlisting>void MainWindow::popupRequested()
 {
-    QWidget *w = factory()->container("context_popup", this);
+    TQWidget *w = factory()->container("context_popup", this);
     QPopupMenu *popup = static_cast&lt;QPopupMenu *&gt;(w);
     popup->exec(QCursor::pos());
 }
@@ -1138,13 +1138,13 @@ X-TDE-ServiceType=KDevelop/Part
 Name=KDevelop Part
 
 [PropertyDef::X-KDevelop-Scope]
-Type=QString
+Type=TQString
 
 [PropertyDef::X-KDevelop-ProgrammingLanguages]
 Type=QStringList
 
 [PropertyDef::X-KDevelop-Args]
-Type=QString
+Type=TQString
 </programlisting>
 
 <para>Además de las entradas usuales, este ejemplo demuestra cómo declarar que un servicio posee algunas propiedades. Cada definición de propiedad corresponde a un grupo <literal>[PropertyDef::name]</literal> en el archivo de configuración. En este grupo, la entrada <literal>Type</literal> declara el tipo de la propiedad. Los tipos posibles son cualquier cosa que se pueda almacenar en un <ulink url="kdeapi:qt/QVariant">QVariant</ulink>. </para>
@@ -1196,11 +1196,11 @@ X-KDevelop-Scope=Project
 <para>Una vez que disponga de un objeto <classname>KService</classname>, solo necesita cargar la biblioteca y obtener un puntero a su objeto fábrica: </para>
 
 <programlisting>KService *service = ...
-QString libName = QFile::encodeName(service->library());
+TQString libName = QFile::encodeName(service->library());
 KLibFactory *factory = KLibLoader::self()->factory(libName);
 if (!factory) {
-    QString name = service->name();
-    QString errorMessage = KLibLoader::self()->lastErrorMessage();
+    TQString name = service->name();
+    TQString errorMessage = KLibLoader::self()->lastErrorMessage();
     KMessageBox::error(0, i18n("There was an error loading service %1.\n"
                                "The diagnostics from libtool is:\n%2")
                           .arg(name).arg(errorMessage);
@@ -1211,7 +1211,7 @@ if (!factory) {
 
 <programlisting>if (factory->inherits("KParts::Factory")) {
     KParts::Factory *partFactory = static_cast&lt;KParts::Factory*&gt;(factory);
-    QObject *obj = partFactory->createPart(parentWidget, widgetName, 
+    TQObject *obj = partFactory->createPart(parentWidget, widgetName, 
                                            parent, name, "KParts::ReadOnlyPart");
     ...
 } else {
@@ -1256,7 +1256,7 @@ X-TDE-StartupNotify=false
 <programlisting>DCOPClient *client = kapp->dcopClient();
 client->attach();
 if (!client->isApplicationRegistered("tdeio_uiserver")) {
-    QString error;
+    TQString error;
     if (TDEApplication::startServiceByName("tdeio_uiserver", QStringList(), &amp;error))
         cout &lt;&lt; "El inicio de kioserver ha fallado con el mensaje " &lt;&lt; error &lt;&lt; endl;
 }
@@ -1275,7 +1275,7 @@ if (!client->call("tdeio_uiserver", "UIServer", "setListMode(bool)",
 
 <para>En el ejemplo propuesto, el servicio se inició «por nombre»; es decir, el primer argumento de <function>TDEApplication::startServiceByName()</function> es el nombre que aparece en la línea <literal>Name</literal> del archivo «desktop». Una alternativa consiste en usar <function>TDEApplication::startServiceByDesktopName()</function>, que toma el nombre del archivo «desktop» como argumento (en este caso, <literal>«tdeio_uiserver.desktop»</literal>). </para>
 
-<para>Todas estas llamadas tienen una lista de URL como segundo parámetro, que se proporciona al servicio en la línea de comando. El tercer argumento es un puntero a una clase <classname>QString</classname>. Si el inicio del servicio falla, este argumento contendrá un mensaje de error traducido. </para>
+<para>Todas estas llamadas tienen una lista de URL como segundo parámetro, que se proporciona al servicio en la línea de comando. El tercer argumento es un puntero a una clase <classname>TQString</classname>. Si el inicio del servicio falla, este argumento contendrá un mensaje de error traducido. </para>
 
 </simplesect>
 
@@ -1385,7 +1385,7 @@ else
 <para>Por supuesto, incluso KMimeMagic sólo es capaz de determinar un tipo de archivo a partir del contenido de un archivo local. Para los archivos remotos existe otra posibilidad adicional: </para>
 
 <programlisting>KURL url("http://developer.kde.org/favicon.ico");
-QString type = TDEIO::NetAccess::mimetype(url);
+TQString type = TDEIO::NetAccess::mimetype(url);
 if (type == KMimeType::defaultMimeType())
     cout &lt;&lt; "No se puede encontrar el tipo" &lt;&lt; endl;
 else
@@ -1463,7 +1463,7 @@ KRun::run(offer.service(), urlList);
 <para>Obtener un icono para una URL. Esto busca el tipo de URL y devuelve el icono asociado. </para>
 
 <programlisting>KURL url("ftp://ftp.kde.org/pub/incoming/wibble.c");
-QString icon = KMimeType::iconForURL(url);
+TQString icon = KMimeType::iconForURL(url);
 </programlisting>
 
 <para>Ejecutar una URL. Esto busca el tipo de URL y ejecuta el programa preferente del usuario que está asociado a este tipo. </para>
@@ -1542,7 +1542,7 @@ void FooClass::mkdirResult(TDEIO::Job *job)
 <listitem><para>Renombra un archivo. </para></listitem>
 </varlistentry>
 
-<varlistentry><term>TDEIO::symlink(const QString &amp;target, const KURL &amp;dest, bool overwrite, bool showProgressInfo)</term>
+<varlistentry><term>TDEIO::symlink(const TQString &amp;target, const KURL &amp;dest, bool overwrite, bool showProgressInfo)</term>
 <listitem><para>Crea un enlace simbólico. </para></listitem>
 </varlistentry>
 
@@ -1662,7 +1662,7 @@ TDEIO::NetAccess::copy(origen, destino);
 
 <programlisting>KURL url;
 url = ...;
-QString tempFile;
+TQString tempFile;
 if (TDEIO::NetAccess::download(url, tempFile) {
     // cargar el archivo de nombre tempFile
     TDEIO::NetAccess::removeTempFile(tempFile);
@@ -1698,12 +1698,12 @@ if (TDEIO::NetAccess::download(url, tempFile) {
 
 void FooClass::transferResult(TDEIO::Job *job)
 {
-    QString mimetype;
+    TQString mimetype;
     if (job->error())
         job->showErrorDialog();
     else {
         TDEIO::TransferJob *transferJob = (TDEIO::TransferJob*) job;
-        QString modified = transferJob->queryMetaData("modified");
+        TQString modified = transferJob->queryMetaData("modified");
         cout &lt;&lt; "Última modificación: " &lt;&lt; modified &lt;&lt; endl;
 }
 </programlisting>
@@ -1848,7 +1848,7 @@ int kdemain(int argc, char **argv)
 <listitem><para>copy(const KURL &amp;url, const KURL &amp;dest, int permissions, bool overwrite)</para></listitem></varlistentry>
 
 <varlistentry><term>Crea un enlace simbólico.</term>
-<listitem><para>void symlink(const QString &amp;target, const KURL &amp;dest, bool overwrite)</para></listitem></varlistentry>
+<listitem><para>void symlink(const TQString &amp;target, const KURL &amp;dest, bool overwrite)</para></listitem></varlistentry>
 
 </variablelist>