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

Signed-off-by: Michele Calgaro <michele.calgaro@yahoo.it>

2 files changed, 44 insertions, 44 deletions

diff --git a/tde-i18n-it/docs/tdevelop/kde_app_devel/index.docbook b/tde-i18n-it/docs/tdevelop/kde_app_devel/index.docbook
index 74850d44b43..5559a514de1 100644
--- a/tde-i18n-it/docs/tdevelop/kde_app_devel/index.docbook
+++ b/tde-i18n-it/docs/tdevelop/kde_app_devel/index.docbook
@@ -160,15 +160,15 @@ return a.exec();
 </orderedlist> 
 </para>
 <para>Il secondo oggetto del nostro programma è il pulsante, una istanza della classe <classname>QPushButton</classname>. Tra i due costruttori che creano una istanza del pulsante verrà usato il secondo: esso accetta un testo, che è l'etichetta del pulsante; in questo caso è la stringa "Hello World!". Dopo si chiama il metodo <methodname>resize()</methodname> per modificare la dimensione del pulsante - il pulsante deve essere più largo per rendere la stringa completamente visibile. </para>
-<para>Qual è lo scopo del metodo <methodname>show()</methodname>? Come la maggior parte dei widget, la classe <classname>QPushButton</classname> ha una singola ereditarietà e la sua classe base è <classname>QButton</classname>. Seguire il collegamento relativo alla classe <classname>QButton</classname>; verranno visualizzati molti altri widget che ereditano da <classname>QPushButton</classname>, che saranno illustrati in seguito per spiegare il meccanismo segnale/slot. Siccome il metodo <methodname>show()</methodname> non è elencato deve essere un metodo ereditato. La classe <classname>QButton</classname> eredita da <classname>QWidget</classname>. Seguendo nuovamente il collegamento saranno mostrati un gruppo di metodi forniti da quest'ultima classe, tra cui il metodo <methodname>show()</methodname>. Ora si può capire cosa accade nell'esempio: <orderedlist>
+<para>Qual è lo scopo del metodo <methodname>show()</methodname>? Come la maggior parte dei widget, la classe <classname>QPushButton</classname> ha una singola ereditarietà e la sua classe base è <classname>QButton</classname>. Seguire il collegamento relativo alla classe <classname>QButton</classname>; verranno visualizzati molti altri widget che ereditano da <classname>QPushButton</classname>, che saranno illustrati in seguito per spiegare il meccanismo segnale/slot. Siccome il metodo <methodname>show()</methodname> non è elencato deve essere un metodo ereditato. La classe <classname>QButton</classname> eredita da <classname>TQWidget</classname>. Seguendo nuovamente il collegamento saranno mostrati un gruppo di metodi forniti da quest'ultima classe, tra cui il metodo <methodname>show()</methodname>. Ora si può capire cosa accade nell'esempio: <orderedlist>
 <listitem><para>Si crea una istanza di <classname>QPushButton</classname> usando il secondo costruttore in modo da impostare il testo del pulsante</para></listitem>
 <listitem><para>Si ridimensiona il widget in base al suo contenuto</para></listitem>
 <listitem><para>Si imposta il widget come quello principale dell'istanza a della classe <classname>QApplication </classname></para></listitem>
-<listitem><para>Si indica al widget di mostrarsi sul video chiamando <methodname>show()</methodname>, un metodo derivato dalla classe <classname>QWidget</classname></para></listitem>
+<listitem><para>Si indica al widget di mostrarsi sul video chiamando <methodname>show()</methodname>, un metodo derivato dalla classe <classname>TQWidget</classname></para></listitem>
 </orderedlist>
 </para>
 <para>Dopo aver chiamato il metodo <methodname>exec()</methodname> l'applicazione è visibile all'utente e mostra una finestra con il pulsante contente "Hello World!". Nota: I programmi GUI hanno un comportamento piuttosto diverso dalle applicazioni procedurali: l'applicazione entra nel cosiddetto "ciclo principale degli eventi" ("main event loop"), dove attende le azioni dell'utente e reagisce ad esse. Anche nelle applicazioni Qt il programma deve essere in questo ciclo per poter gestire gli eventi. La prossima sezione spiega brevemente cosa offrono le librerie Qt per la gestione degli eventi generati dell'utente. </para>
-<note><para>Per gli utenti più esperti: il pulsante non ha la dichiarazione del genitore nel costruttore, quindi è un widget top-level e viene eseguito in un ciclo di eventi locale che non ha bisogno di attendere il ciclo principale degli eventi. Vedere la documentazione della classe QWidget e la guida di riferimento della libreria KDE</para>
+<note><para>Per gli utenti più esperti: il pulsante non ha la dichiarazione del genitore nel costruttore, quindi è un widget top-level e viene eseguito in un ciclo di eventi locale che non ha bisogno di attendere il ciclo principale degli eventi. Vedere la documentazione della classe TQWidget e la guida di riferimento della libreria KDE</para>
 </note> 
 
 </sect3>
@@ -183,7 +183,7 @@ return a.exec();
 </itemizedlist> 
 </para>
 <para>Ora passiamo a dare "vita" all'applicazione elaborando gli eventi dell'utente. Generalmente l'utente ha due modi per interagire con un programma: il mouse e la tastiera. Per entrambi l'interfaccia grafica utente deve fornire metodi per intercettare le azioni e metodi che eseguono qualcosa in risposta a queste azioni. </para> 
-<para>Il sistema grafico invia tutti gli eventi di interazione all'applicazione corrispondente. La classe <classname>QApplication</classname> li invia alla finestra attiva come oggetti <classname>QEvent</classname> e i widget dovranno decidere cosa farne. Un widget riceve l'evento ed elabora <methodname>QWidget::event(QEvent*)</methodname>, il quale decide quale evento è stato eseguito e come reagire; <methodname>event()</methodname> è il gestore principale degli eventi. In seguito il metodo <methodname>event()</methodname> passa l'evento ai cosiddetti filtri di evento che determinano cosa è successo e cosa fare con l'evento. Se non esiste un filtro assegnato come responsabile per l'evento, saranno chiamati i gestori specializzati per quell'evento. Quindi possiamo decidere tra:  <itemizedlist>
+<para>Il sistema grafico invia tutti gli eventi di interazione all'applicazione corrispondente. La classe <classname>QApplication</classname> li invia alla finestra attiva come oggetti <classname>QEvent</classname> e i widget dovranno decidere cosa farne. Un widget riceve l'evento ed elabora <methodname>TQWidget::event(QEvent*)</methodname>, il quale decide quale evento è stato eseguito e come reagire; <methodname>event()</methodname> è il gestore principale degli eventi. In seguito il metodo <methodname>event()</methodname> passa l'evento ai cosiddetti filtri di evento che determinano cosa è successo e cosa fare con l'evento. Se non esiste un filtro assegnato come responsabile per l'evento, saranno chiamati i gestori specializzati per quell'evento. Quindi possiamo decidere tra:  <itemizedlist>
 <listitem><para>Eventi di tastiera -- tasti Tab e Shift-Tab:</para>
 <itemizedlist>
 <listitem><para><methodname>virtual void focusInEvent(QFocusEvent *)</methodname></para></listitem>
@@ -224,12 +224,12 @@ return a.exec();
 
 </itemizedlist>
 </para>
-<para>Notare che tutte le funzioni degli eventi sono virtuali e protette; quindi si possono reimplementare gli eventi per i propri widget e specificare come essi debbano rispondere. <classname>QWidget</classname> contiene inoltre qualche altro metodo virtuale che può essere utile nei programmi. </para>
+<para>Notare che tutte le funzioni degli eventi sono virtuali e protette; quindi si possono reimplementare gli eventi per i propri widget e specificare come essi debbano rispondere. <classname>TQWidget</classname> contiene inoltre qualche altro metodo virtuale che può essere utile nei programmi. </para>
 </sect2>
 <sect2 id="c1s2s4">
 <title>Interazione degli oggetti attraverso segnali e slot</title>
 <para>Si è giunti al più ovvio vantaggio degli strumenti Qt: il meccanismo dei segnali e degli slot. Questi offrono una comoda soluzione all'interazione tra oggetti, che in X-Window viene normalmente risolta con funzioni di callback. Siccome questa comunicazione richiede una programmazione rigorosa e a volte rende la creazione di interfacce grafiche molto difficile (come riportato della documentazione Qt e dimostrato in Programming with Qt di K.Dalheimer), Troll Tech ha inventato un nuovo sistema, dove gli oggetti emettono segnali che possono essere connessi ai metodi dichiarati come slot. Il programmatore C++ deve solamente conoscere alcune cose riguardo questo meccanismo: <itemizedlist>
-<listitem><para>la dichiarazione di una classe che usa i segnali e gli slot deve contenere la macro TQ_OBJECT all'inizio (senza il punto e virgola) e deve ereditare dalla classe <classname>QObject</classname> </para></listitem>
+<listitem><para>la dichiarazione di una classe che usa i segnali e gli slot deve contenere la macro TQ_OBJECT all'inizio (senza il punto e virgola) e deve ereditare dalla classe <classname>TQObject</classname> </para></listitem>
 <listitem><para>un segnale può essere emesso tramite la parola chiave emit, es: emit signal(parametri); dall'interno di qualunque membro di una classe che permette l'uso di segnali e slot </para></listitem>
 
 <listitem><para>tutti i segnali utilizzati dalle classi che non sono ereditati devono essere aggiunti alla dichiarazione di classe in una sezione dedicata ai segnali </para></listitem>
@@ -237,9 +237,9 @@ return a.exec();
 <listitem><para>il compilatore per i meta-oggetti moc deve essere eseguito sul file di intestazione per espandere le macro e produrre l'implementazione (che non è necessario conoscere). I file di output dal moc saranno successivamente compilati anche dal compilatore C++. </para></listitem>
 </itemizedlist>
 </para>
-<para>Un'altra strada per utilizzare i segnali senza derivare da <classname>QObject</classname> è utilizzare la classe <classname>QSignal</classname> - vedere la documentazione di riferimento per ulteriori informazioni ed esempi di utilizzo. Nel seguito si presuppone che si stia derivando dalla classe <classname>QObject</classname>. </para>
+<para>Un'altra strada per utilizzare i segnali senza derivare da <classname>TQObject</classname> è utilizzare la classe <classname>QSignal</classname> - vedere la documentazione di riferimento per ulteriori informazioni ed esempi di utilizzo. Nel seguito si presuppone che si stia derivando dalla classe <classname>TQObject</classname>. </para>
 <para>In questo modo la classe può inviare ovunque segnali ed avere degli slot a cui collegare tali segnali. Utilizzando i segnali non ci si deve preoccupare di chi li riceverà - si deve solo emettere il segnale e connettere un qualunque slot che risponderà all'evento. Inoltre gli slot possono essere utilizzati come normali metodi durante l'implementazione. </para>
-<para>Per connettere un segnale ad uno slot si devono utilizzare i metodi <methodname>connect()</methodname> messi a disposizione dalla classe <classname>QObject</classname> o, quando disponibile, metodi speciali forniti dagli oggetti per impostare la connessione ad un determinato segnale. </para>
+<para>Per connettere un segnale ad uno slot si devono utilizzare i metodi <methodname>connect()</methodname> messi a disposizione dalla classe <classname>TQObject</classname> o, quando disponibile, metodi speciali forniti dagli oggetti per impostare la connessione ad un determinato segnale. </para>
 
 <sect3 id="c1s2s4s1">
 <title>Semplice utilizzo</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>Come si può vedere, l'unica modifica richiesta per dare maggiore interazione al pulsante consiste nell'utilizzare il metodo <methodname>connect()</methodname>: tutto quello che si deve aggiungere è <methodname>connect(&amp;hello,SIGNAL( clicked() ), &amp;a,SLOT( quit() ))</methodname>. Cosa significa? La dichiarazione del metodo <methodname>connect()</methodname> nella classe QObject è: </para>
-<para><methodname>bool connect ( const QObject * sender, const char * signal, const QObject * receiver, const char * member ) </methodname></para>
-<para>Si deve specificare come primo parametro un puntatore ad una istanza di <classname>QObject</classname> che trasmette il segnale, ovvero che può emettere questo segnale; poi si specifica il segnale che si vuole connettere. Gli ultimi due parametri sono l'oggetto ricevitore che fornisce uno slot, seguito dalla funzione membro che in effetti è lo slot che sarà eseguito dopo l'emissione del segnale. </para>
+<para>Come si può vedere, l'unica modifica richiesta per dare maggiore interazione al pulsante consiste nell'utilizzare il metodo <methodname>connect()</methodname>: tutto quello che si deve aggiungere è <methodname>connect(&amp;hello,SIGNAL( clicked() ), &amp;a,SLOT( quit() ))</methodname>. Cosa significa? La dichiarazione del metodo <methodname>connect()</methodname> nella classe TQObject è: </para>
+<para><methodname>bool connect ( const TQObject * sender, const char * signal, const TQObject * receiver, const char * member ) </methodname></para>
+<para>Si deve specificare come primo parametro un puntatore ad una istanza di <classname>TQObject</classname> che trasmette il segnale, ovvero che può emettere questo segnale; poi si specifica il segnale che si vuole connettere. Gli ultimi due parametri sono l'oggetto ricevitore che fornisce uno slot, seguito dalla funzione membro che in effetti è lo slot che sarà eseguito dopo l'emissione del segnale. </para>
 <para>Utilizzando i segnali e gli slot gli oggetti dei proprio programma potranno interagire tra loro facilmente senza dipendere esplicitamente dal tipo dell'oggetto ricevente. Nei capitoli seguenti verrà spiegato come utilizzare in maniera produttiva questo meccanismo. Ulteriori informazioni sui segnali e gli slot possono essere trovati nella <ulink url="developer kde.org/documentation/library/libraryref.html">Guida di riferimento della libreria KDE</ulink> e nella <ulink url="doc.trolltech.com">documentazione Qt di riferimento</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>Per prima cosa è stata cambiata la classe <classname>QApplication</classname> con la classe <classname>TDEApplication</classname>. Inoltre è stato cambiato il metodo <methodname>setMainWidget()</methodname> usato precedentemente con il metodo <methodname>setTopWidget</methodname>, che viene usato da <classname>TDEApplication</classname> per impostare il widget principale. Ecco qua! La prima applicazione KDE è pronta - ora si deve solo indicare al compilatore il percorso di inclusione di KDE e al linker di collegare la libreria kdecode con l'opzione -ltdecore. </para>
 <para>Ora che si conosce cosa fornisce la funzione <function>main()</function>, come rendere visibile l'applicazione e come gli oggetti interagiscono con l'utente, nel prossimo capitolo verrà creata una applicazione con &tdevelop;. Potremo quindi applicare e verificare quanto detto precedentemente. </para>
-<para>Prima di proseguire si dovrebbe consultare la documentazione di riferimento di Qt, in particolare le classi <classname> QApplication</classname>, <classname>QWidget</classname> e <classname>QObject</classname>, e la documentazione della libreria tdecore per la classe <classname>TDEApplication </classname>. Il <ulink url="developer.kde.org/documentation/library/libraryref.html">manuale di riferimento delle librerie KDE</ulink> include una descrizione completa sulle chiamate ai costruttori delle classi <classname>QApplication</classname> e <classname> TDEApplication</classname> e l'elaborazione degli argomenti a linea di comando. </para>
+<para>Prima di proseguire si dovrebbe consultare la documentazione di riferimento di Qt, in particolare le classi <classname> QApplication</classname>, <classname>TQWidget</classname> e <classname>TQObject</classname>, e la documentazione della libreria tdecore per la classe <classname>TDEApplication </classname>. Il <ulink url="developer.kde.org/documentation/library/libraryref.html">manuale di riferimento delle librerie KDE</ulink> include una descrizione completa sulle chiamate ai costruttori delle classi <classname>QApplication</classname> e <classname> TDEApplication</classname> e l'elaborazione degli argomenti a linea di comando. </para>
 </sect2>
 </sect1>
 
@@ -549,10 +549,10 @@ return a.exec();
 16     statusBar()->show();
 17 
 18     // allow the view to change the statusbar and caption
-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>Non c'è bisogno di dire che la stabilità è l'obiettivo principale della progettazione. Nessuno può evitare gli errori, ma si può almeno effettuare una progettazione saggia e orientata agli oggetti. Il linguaggio C++ rende la programmazione un piacere se si sfruttano le sue capacità come ereditarietà, incapsulamento e riuso del codice già esistente. </para>
-<para>Quando si crea un progetto KDE o Qt, si dovrà avere sempre una vista che deriva da QWidget per ereditarietà diretta o perché il widget di libreria che si vuole usare deriva da QWidget. Quindi la procedura guidata per l'applicazioni crea una vista che è istanza di una classe di nome NomeApplicazioneView che deriva da QWidget. </para>
+<para>Quando si crea un progetto KDE o Qt, si dovrà avere sempre una vista che deriva da TQWidget per ereditarietà diretta o perché il widget di libreria che si vuole usare deriva da TQWidget. Quindi la procedura guidata per l'applicazioni crea una vista che è istanza di una classe di nome NomeApplicazioneView che deriva da TQWidget. </para>
 <para>Questo capitolo descrive come usare i widget delle librerie per creare viste di applicazioni KDE o Qt che sono generate con &tdevelop;, in seguito si esamineranno le librerie e i tipi di viste disponibili. </para>
 </sect1>
 <sect1 id="c4s2">
@@ -601,7 +601,7 @@ return a.exec();
 <para>Nella prima pagina della documentazione Qt in linea è presente un collegamento alle "schermate dei widget" dove si può osservare l'aspetto dei widget. Questi widget sono pronti per essere utilizzati direttamente o combinati assieme formando widget più complessi per creare viste di applicazioni o finestre di dialogo. In seguito saranno discussi alcuni di essi che sono utilizzabili per creare viste di applicazioni, ma ricordarsi che le librerie KDE contengono widget alternativi che servono agli stessi scopi; questi verranno esaminati nella prossima sezione. </para>
 <para>Ecco una serie di suggerimenti per scegliere il componente Qt da usare per un particolare scopo <orderedlist>
 <listitem><para>Se l'area di vista non è abbastanza grande per visualizzare tutti i dati, l'utente deve poter scorrere il documento con le barre poste a lato e in basso. Qt fornisce la classe <classname>QScrollView</classname> che offre un'area figlio scorrevole. Si può derivare il proprio widget da questa classe o utilizzare una sua istanza. </para></listitem> 
-<listitem><para>per creare uno ScrollView, derivare il widget per la vista da <classname>QWidget</classname> e aggiungere una barra di scorrimento orizzontale ed una verticale <classname>QScrollBars</classname>. (Questo viene fatto dal widget TDEHTMLViews di KDE.) </para></listitem> 
+<listitem><para>per creare uno ScrollView, derivare il widget per la vista da <classname>TQWidget</classname> e aggiungere una barra di scorrimento orizzontale ed una verticale <classname>QScrollBars</classname>. (Questo viene fatto dal widget TDEHTMLViews di KDE.) </para></listitem> 
 <listitem><para>Per l'elaborazione del testo, usare <classname>QTextEdit</classname>. Questa classe include un widget per il testo completo che dispone delle funzionalità per tagliare, copiare e incollare testo ed è gestito da barre di scorrimento. </para></listitem> 
 <listitem><para>Usare la classe <classname>QTable</classname> per visualizzare i dati organizzati in una tabella. Siccome questa classe è gestita da barre di scorrimento, costituisce una buona soluzione per le applicazioni di calcolo con tabelle.  </para></listitem> 
 <listitem><para>Per visualizzare due widget diversi o due istanze contemporaneamente,utilizzare la classe <classname>QSplitter</classname>. Questa permette di affiancare le viste verticalmente o orizzontalmente. Per osservare questo elemento grafico si può prendere come esempio KMail: la vista principale è separata da un divisore verticale, e la finestra a destra è a sua volta separata orizzontalmente. </para></listitem> 
@@ -696,7 +696,7 @@ return a.exec();
 <sect1 id="c8s4">
 <title>Il pulsante <guibutton>Che cos'è?</guibutton></title>
 <para>Il pulsante <guibutton>Che cos'è?</guibutton> visualizza una finestra quando l'utente vuole ricevere aiuto su un particolare widget o un elemento della barra degli strumenti. Esso è posizionato nella barra degli strumenti e viene attivato quando viene premuto. Il cursore del mouse diventa una freccia con un punto interrogativo, e quando viene fatto clic su un widget appare una finestra di aiuto. Come esercizio, si può provare usando il pulsante <guibutton>Che cos'è?</guibutton> in &tdevelop;. </para>
-<para>Per aggiungere l'aiuto Che cos'è? su un widget, usare il metodo statico <methodname>QWhatsThis::add(QWidget *widget, const QString &amp;test)</methodname> </para>
+<para>Per aggiungere l'aiuto Che cos'è? su un widget, usare il metodo statico <methodname>QWhatsThis::add(TQWidget *widget, const TQString &amp;test)</methodname> </para>
 </sect1>
 </chapter>
 
diff --git a/tde-i18n-it/docs/tdevelop/kdearch/index.docbook b/tde-i18n-it/docs/tdevelop/kdearch/index.docbook
index 4cadc6668da..34d6fabffca 100644
--- a/tde-i18n-it/docs/tdevelop/kdearch/index.docbook
+++ b/tde-i18n-it/docs/tdevelop/kdearch/index.docbook
@@ -238,7 +238,7 @@
 </formalpara></listitem>
 
 <listitem><formalpara><title><ulink url="kdeapi:tdeui/KPixmapIO">KPixmapIO</ulink></title>
-<para>Conversione veloce da <classname>QImage</classname> a <classname>QPixmap</classname>. </para>
+<para>Conversione veloce da <classname>TQImage</classname> a <classname>QPixmap</classname>. </para>
 </formalpara></listitem>
 
 </itemizedlist>
@@ -473,7 +473,7 @@ url="kdeapi:tdeui/KAnimWidget">KAnimWidget</ulink></title>
 
 <para>Il modello a basso livello di Qt per le immagini è basato sulle funzioni fornite da X11 e da altri sistemi grafici per i quali esiste il port di Qt. Tuttavia esso estende queste funzioni implementando funzionalità aggiuntive come le trasformazioni geometriche arbitrarie del testo e delle pixmap. </para>
 
-<para>La classe grafica principale per il disegno 2D è <ulink url="kdeapi:qt/QPainter">QPainter</ulink>. Essa può disegnare su un <ulink url="kdeapi:qt/QPaintDevice">QPaintDevice</ulink>. Sono stati implementati tre tipi di QPaintDevice: il primo è <ulink url="kdeapi:qt/QWidget">QWidget</ulink> che rappresenta un widget sullo schermo. Il secondo è <ulink url="kdeapi:qt/QPrinter">QPrinter</ulink> che rappresenta una stampante e produce un output PostScript. Il terzo è la classe <ulink url="kdeapi:qt/QPicture">QPicture</ulink> che registra i comandi di disegno e può salvarli sul disco per poterli riprodurre in seguito. Un possibile formato di memorizzazione per questi comandi di disegno è lo standard SVG del W3C. </para>
+<para>La classe grafica principale per il disegno 2D è <ulink url="kdeapi:qt/QPainter">QPainter</ulink>. Essa può disegnare su un <ulink url="kdeapi:qt/QPaintDevice">QPaintDevice</ulink>. Sono stati implementati tre tipi di QPaintDevice: il primo è <ulink url="kdeapi:qt/TQWidget">TQWidget</ulink> che rappresenta un widget sullo schermo. Il secondo è <ulink url="kdeapi:qt/QPrinter">QPrinter</ulink> che rappresenta una stampante e produce un output PostScript. Il terzo è la classe <ulink url="kdeapi:qt/QPicture">QPicture</ulink> che registra i comandi di disegno e può salvarli sul disco per poterli riprodurre in seguito. Un possibile formato di memorizzazione per questi comandi di disegno è lo standard SVG del W3C. </para>
 
 <para>In questo modo è possibile stampare riutilizzando il codice di disegno usato per visualizzare un widget. Naturalmente il codice viene usato in un contesto leggermente diverso: il disegno di un widget viene fatto quasi esclusivamente nel metodo paintEvent() di una classe widget. </para>
 
@@ -664,10 +664,10 @@ url="kdeapi:tdeui/KAnimWidget">KAnimWidget</ulink></title>
 <para>QBrush::QBrush(BrushStyle) - Crea un pennello nero con uno dei motivi predefiniti mostrati sotto.</para>
 </listitem>
 <listitem>
-<para>QBrush::QBrush(const QColor &amp;, BrushStyle) - Crea un pennello colorato con uno dei motivi di default mostrati sotto.</para>
+<para>QBrush::QBrush(const TQColor &amp;, BrushStyle) - Crea un pennello colorato con uno dei motivi di default mostrati sotto.</para>
 </listitem>
 <listitem>
-<para>QBrush::QBrush(const QColor &amp;, const QPixmap) - Crea un pennello colorato con un motivo personalizzato fornito come secondo parametro.</para>
+<para>QBrush::QBrush(const TQColor &amp;, const QPixmap) - Crea un pennello colorato con un motivo personalizzato fornito come secondo parametro.</para>
 </listitem>
 </itemizedlist>
 
@@ -685,7 +685,7 @@ url="kdeapi:tdeui/KAnimWidget">KAnimWidget</ulink></title>
 <simplesect id="qpainter-color">
 <title>Colore</title>
 
-<para>I colori vengono usati quando si disegnano curve e quando si riempiono forme. In Qt i colori sono rappresentati dalla classe <ulink url="kdeapi:qt/QColor">QColor</ulink>. Qt non supporta funzioni grafiche avanzate come i profili di colore ICC e la correzione del colore. I colori sono normalmente costruiti specificando i componenti rosso, verde e blu, come il modello RGB usato per i pixel di un monitor. </para>
+<para>I colori vengono usati quando si disegnano curve e quando si riempiono forme. In Qt i colori sono rappresentati dalla classe <ulink url="kdeapi:qt/TQColor">TQColor</ulink>. Qt non supporta funzioni grafiche avanzate come i profili di colore ICC e la correzione del colore. I colori sono normalmente costruiti specificando i componenti rosso, verde e blu, come il modello RGB usato per i pixel di un monitor. </para>
 
 <para>È possibile anche usare la tonalità, la saturazione e la luminosità. Questa rappresentazione HSV è quella usata nella finestra di dialogo Gtk per il colore, per es. in GIMP. Qui, la tonalità corrisponde ad un angolo sulla ruota del colore, mentre la saturazione corrisponde alla distanza dal centro del cerchio. La luminosità può essere scelta su un'indicatore separato. </para>
 
@@ -738,7 +738,7 @@ url="kdeapi:tdeui/KAnimWidget">KAnimWidget</ulink></title>
 
 <para><ulink url="kdeapi:qt/QPixmap">QPixmap</ulink> corrisponde direttamente alle pixmap di X11. Le pixmap sono oggetti server-side e possono - su schede grafiche recenti - anche essere memorizzate direttamente nella memoria della scheda. Questo rende <emphasis>molto</emphasis> efficiente trasferire pixmap sullo schermo. Queste fungono anche come un'equivalente dei widget - la classe QPixmap è una sottoclasse di QPaintDevice, quindi la si può disegnare con un QPainter. Le operazioni di disegno elementari sono normalmente accelerate dalle schede grafiche moderne, quindi è un'abitudine comune usare le pixmap per il double buffering. In questo modo, invece di disegnare direttamente su un widget, si disegna su un oggetto pixmap temporaneo e si usa la funzione <ulink url="kdeapi:qt/QPaintDevice#bitBlt-1">bitBlt</ulink> per trasferire la pixmap nel widget. Nelle operazioni di ridisegno più complesse questo può aiutare per evitare gli sfarfalii. </para>
 
-<para>Al contrario, gli oggetti <ulink url="kdeapi:qt/QImage">QImage</ulink> sono client-side. La loro caratteristica consiste nel fornire un accesso diretto ai pixel, che li rende utili per la manipolazione delle immagini e per altre cose come il caricamento e il salvataggio sul disco (il metodo load() di QPixmap riceve un oggetto QImage come fase intermedia). D'altra parte, dipingere un'immagine su un widget è un'operazione costosa, poiché implica un trasferimento nel server X, che richiede parecchio tempo specialmente con immagini grandi e su server remoti. La conversione da QImage a QPixmap può richiedere anche la retinatura, a seconda della profondità del colore. </para>
+<para>Al contrario, gli oggetti <ulink url="kdeapi:qt/TQImage">TQImage</ulink> sono client-side. La loro caratteristica consiste nel fornire un accesso diretto ai pixel, che li rende utili per la manipolazione delle immagini e per altre cose come il caricamento e il salvataggio sul disco (il metodo load() di QPixmap riceve un oggetto TQImage come fase intermedia). D'altra parte, dipingere un'immagine su un widget è un'operazione costosa, poiché implica un trasferimento nel server X, che richiede parecchio tempo specialmente con immagini grandi e su server remoti. La conversione da TQImage a QPixmap può richiedere anche la retinatura, a seconda della profondità del colore. </para>
 
 </simplesect>
 
@@ -746,7 +746,7 @@ url="kdeapi:tdeui/KAnimWidget">KAnimWidget</ulink></title>
 <simplesect id="qpainter-drawingtext">
 <title>Disegnare testo</title>
 
-<para>Il testo può essere disegnato con una delle versioni sovraccaricate del metodo QPainter::drawText(). Queste disegnano una QString in un certo punto o in un certo rettangolo, usando il font impostato con il metodo QPainter::setFont(). C'è anche un parametro che riceve una combinazione ORed di alcuni flag dell'enumerazione <ulink url="kdeapi:qt/Qt#AlignmentFlags-enum">Qt::AlignmentFlags</ulink> e <ulink url="kdeapi:qt/Qt#TextFlags-enum">Qt::TextFlags</ulink> </para>
+<para>Il testo può essere disegnato con una delle versioni sovraccaricate del metodo QPainter::drawText(). Queste disegnano una TQString in un certo punto o in un certo rettangolo, usando il font impostato con il metodo QPainter::setFont(). C'è anche un parametro che riceve una combinazione ORed di alcuni flag dell'enumerazione <ulink url="kdeapi:qt/Qt#AlignmentFlags-enum">Qt::AlignmentFlags</ulink> e <ulink url="kdeapi:qt/Qt#TextFlags-enum">Qt::TextFlags</ulink> </para>
 
 <para>Dalla versione 3.0, Qt si occupa della disposizione del testo anche per i linguaggi scritti da destra verso sinistra. </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>In aggiunta alle voci normali, questo esempio mostra come dichiarare un servizio che ha alcune proprietà. Ogni definizione di proprietà corrisponde al gruppo <literal>[PropertyDef::name]</literal> nel file di configurazione. La voce <literal>Type</literal> di questo gruppo dichiara il tipo della proprietà. I tipi possibili sono tutti quelli che possono essere memorizzati in un <ulink url="kdeapi:qt/QVariant">QVariant</ulink>. </para>
@@ -1196,11 +1196,11 @@ X-KDevelop-Scope=Project
 <para>Con un oggetto <classname>KService</classname> si può semplicemente caricare la libreria e ottenere un puntatore al suo oggetto factory: </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; "Starting kioserver failed with message " &lt;&lt; error &lt;&lt; endl;
 }
@@ -1275,7 +1275,7 @@ if (!client->call("tdeio_uiserver", "UIServer", "setListMode(bool)",
 
 <para>In questo esempio il servizio è stato avviato "con il nome", cioè il primo argomento della funzione <function>TDEApplication::startServiceByName()</function> è il nome che appare nella linea <literal>Name</literal> del file desktop. In alternativa si può usare la funzione <function>TDEApplication::startServiceByDesktopName()</function>, che accetta come argomento il nome del suo file desktop, in questo caso <literal>"tdeio_uiserver.desktop"</literal>. </para>
 
-<para>Tutte queste chiamate ricevono come secondo argomento una lista di URL, che viene passata al servizio a linea di comando. Il terzo argomento è un puntatore ad una <classname>QString</classname>. Se l'avvio del servizio non riesce questo argomento punta ad un messaggio di errore. </para>
+<para>Tutte queste chiamate ricevono come secondo argomento una lista di URL, che viene passata al servizio a linea di comando. Il terzo argomento è un puntatore ad una <classname>TQString</classname>. Se l'avvio del servizio non riesce questo argomento punta ad un messaggio di errore. </para>
 
 </simplesect>
 
@@ -1385,7 +1385,7 @@ else
 <para>Ovviamente anche KMimeMagic è in grado di determinare solo il tipo del file dai contenuti di un file locale. Per i file remoti esiste un'ulteriore possibilità: </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; "Could not find out type" &lt;&lt; endl;
 else
@@ -1463,7 +1463,7 @@ KRun::run(offer.service(), urlList);
 <para>Ottenere un'icona da un URL. Viene cercato il tipo dell'URL e viene restituita l'icona associata. </para>
 
 <programlisting>KURL url("ftp://ftp.kde.org/pub/incoming/wibble.c");
-QString icon = KMimeType::iconForURL(url);
+TQString icon = KMimeType::iconForURL(url);
 </programlisting>
 
 <para>Avviare un URL. Viene cercato il tipo dell'URL e viene avviato il programma preferito dall'utente associato a questo tipo. </para>
@@ -1542,7 +1542,7 @@ void FooClass::mkdirResult(TDEIO::Job *job)
 <listitem><para>Rinomina un file. </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 collegamento simbolico. </para></listitem>
 </varlistentry>
 
@@ -1662,7 +1662,7 @@ TDEIO::NetAccess::copy(source, target);
 
 <programlisting>KURL url;
 url = ...;
-QString tempFile;
+TQString tempFile;
 if (TDEIO::NetAccess::download(url, tempFile) {
     // load the file with the name 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; "Last modified: " &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 collegamento simbolico.</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>