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, 45 insertions, 45 deletions

diff --git a/tde-i18n-sv/docs/tdevelop/kde_app_devel/index.docbook b/tde-i18n-sv/docs/tdevelop/kde_app_devel/index.docbook
index 4b4dad3adb5..23d41f5376e 100644
--- a/tde-i18n-sv/docs/tdevelop/kde_app_devel/index.docbook
+++ b/tde-i18n-sv/docs/tdevelop/kde_app_devel/index.docbook
@@ -160,15 +160,15 @@ return a.exec();
 </orderedlist> 
 </para>
 <para>Det andra objektet i vårt program är tryckknappen, en instans av klassen <classname>QPushButton</classname>. Av de två konstruktorer som finns för att skapa klassen, använder vi den andra. Den tar en text, som är textinnehållet i knappen. Här är det strängen "Hello world!". Därefter anropar vi metoden <methodname>resize()</methodname> för att ändra storlek på knappen i enlighet med dess innehåll. Knappen måste bli större för att göra strängen fullständigt synlig. </para>
-<para>Men vad gäller för metoden <methodname>show()</methodname>? Nu märker du, att som de flesta andra grafiska komponenter, är <classname>QPushButton</classname> baserad på enkelt arv. Dokumentationen säger, ärver <classname>QButton</classname>. Följ länken till klassen <classname>QButton</classname>. Det visar många andra komponenter som ärvs av <classname>QPushButton</classname>, som vi senare använder för att förklara signal/slot-mekanismen. Hur som helst finns inte metoden <methodname>show()</methodname> listad, och därför måste den vara en metod som också tillhandahålls via arv. Klassen som <classname>QButton</classname> ärver är <classname>QWidget</classname>. Följ bara länken igen, så ser du en hel mängd metoder som klassen QWidget tillhandahåller, inklusive metoden <methodname>show()</methodname>. Nu förstår vi vad som gjordes i exemplet med knappen: <orderedlist>
+<para>Men vad gäller för metoden <methodname>show()</methodname>? Nu märker du, att som de flesta andra grafiska komponenter, är <classname>QPushButton</classname> baserad på enkelt arv. Dokumentationen säger, ärver <classname>QButton</classname>. Följ länken till klassen <classname>QButton</classname>. Det visar många andra komponenter som ärvs av <classname>QPushButton</classname>, som vi senare använder för att förklara signal/slot-mekanismen. Hur som helst finns inte metoden <methodname>show()</methodname> listad, och därför måste den vara en metod som också tillhandahålls via arv. Klassen som <classname>QButton</classname> ärver är <classname>TQWidget</classname>. Följ bara länken igen, så ser du en hel mängd metoder som klassen TQWidget tillhandahåller, inklusive metoden <methodname>show()</methodname>. Nu förstår vi vad som gjordes i exemplet med knappen: <orderedlist>
 <listitem><para>Skapa en instans av <classname>QPushButton</classname>, och använd den andra konstruktorn för att ange knappens text</para></listitem>
 <listitem><para>Ändra storlek på komponenten till dess innehåll</para></listitem>
 <listitem><para>Ange komponenten som huvudkomponent i instansen av <classname>QApplication</classname></para></listitem>
-<listitem><para>Tala om för den grafiska komponenten att den ska visas på skärmen genom att anropa <methodname>show()</methodname>, en metod som ärvts från <classname>QWidget</classname></para></listitem>
+<listitem><para>Tala om för den grafiska komponenten att den ska visas på skärmen genom att anropa <methodname>show()</methodname>, en metod som ärvts från <classname>TQWidget</classname></para></listitem>
 </orderedlist>
 </para>
 <para>Efter att ha anropat metoden <methodname>exec()</methodname>, är programmet synligt för användaren, och visar ett fönster med knappen "Hello world!". Observera att program med grafiska gränssnitt beter sig något annorlunda jämfört med procedurbaserade program. Den viktigaste saken här är att programmet går in i en så kallad "huvudhändelsesnurra". Det betyder att programmet måste vänta på användarens åtgärder och därefter reagera på dem. Det betyder också, för ett QT-program, att programmet måste vara i huvudhändelsesnurran för att starta händelsehanteringen. Nästa avsnitt beskriver kortfattat vad det betyder förprogrammeraren och vad QT erbjuder för att hantera händelser. </para>
-<note><para>För användare som redan är avancerade: Knappen har ingen överliggande komponent deklarerad i konstruktorn. Därför är den en toppnivåkomponent och kör med en lokal händelsesnurra som inte behöver vänta på huvudhändelsesnurran. Se dokumentationen för klassen QWidget och KDE:s biblioteksreferensguide.</para>
+<note><para>För användare som redan är avancerade: Knappen har ingen överliggande komponent deklarerad i konstruktorn. Därför är den en toppnivåkomponent och kör med en lokal händelsesnurra som inte behöver vänta på huvudhändelsesnurran. Se dokumentationen för klassen TQWidget och KDE:s biblioteksreferensguide.</para>
 </note> 
 
 </sect3>
@@ -183,7 +183,7 @@ return a.exec();
 </itemizedlist> 
 </para>
 <para>Nu fortsätter vi med att ge programmet "liv" genom att behandla användarhändelser. I allmänhet har användaren två sätt att kommunicera med ett program: musen och tangentbordet. Ett grafiskt användargränssnitt måste tillhandahålla metoder för båda sätten, som detekterar åtgärder och gör något som reaktion på åtgärderna. </para> 
-<para>Fönstersystemet skickar därför alla kommunikationshändelser till motsvarande program. <classname>QApplication</classname> skickar dem därefter till det aktiva fönstret som ett <classname>QEvent</classname>, och komponenterna själva måste bestämma vad som ska göras med dem. En komponent tar emot händelsen och behandlar <methodname>QWidget::event(QEvent*)</methodname>, som avgör vilken händelse som har skett och hur reaktionen ska ske. Metoden <methodname>event()</methodname> gör därför den huvudsakliga händelsehanteringen. Därefter skickar metoden <methodname>event()</methodname> händelsen till så kallade händelsefilter som avgör vad som sker och vad som ska göras med händelsen. Om inget filter signalerar att det är ansvarigt för händelsen, anropas speciell händelsehantering. Därigenom kan vi skilja mellan: <itemizedlist>
+<para>Fönstersystemet skickar därför alla kommunikationshändelser till motsvarande program. <classname>QApplication</classname> skickar dem därefter till det aktiva fönstret som ett <classname>QEvent</classname>, och komponenterna själva måste bestämma vad som ska göras med dem. En komponent tar emot händelsen och behandlar <methodname>TQWidget::event(QEvent*)</methodname>, som avgör vilken händelse som har skett och hur reaktionen ska ske. Metoden <methodname>event()</methodname> gör därför den huvudsakliga händelsehanteringen. Därefter skickar metoden <methodname>event()</methodname> händelsen till så kallade händelsefilter som avgör vad som sker och vad som ska göras med händelsen. Om inget filter signalerar att det är ansvarigt för händelsen, anropas speciell händelsehantering. Därigenom kan vi skilja mellan: <itemizedlist>
 <listitem><para>Tangentbordshändelser: Tangenterna Tabulator och Skift+Tabulator:</para>
 <itemizedlist>
 <listitem><para><methodname>virtual void focusInEvent(QFocusEvent *)</methodname></para></listitem>
@@ -224,12 +224,12 @@ return a.exec();
 
 </itemizedlist>
 </para>
-<para>Observera att alla händelsefunktioner är virtuella och protected. Därför kan du implementera om händelser som du behöver i egna komponenter och ange hur din komponent ska reagera. <classname>QWidget</classname> innehåller också några andra virtuella metoder som kan vara användbara i dina program. Hur som helst, är det nödvändigt att känna till <classname>QWidget</classname> väl. </para>
+<para>Observera att alla händelsefunktioner är virtuella och protected. Därför kan du implementera om händelser som du behöver i egna komponenter och ange hur din komponent ska reagera. <classname>TQWidget</classname> innehåller också några andra virtuella metoder som kan vara användbara i dina program. Hur som helst, är det nödvändigt att känna till <classname>TQWidget</classname> väl. </para>
 </sect2>
 <sect2 id="c1s2s4">
 <title>Interaktion mellan objekt med signaler och slots</title>
 <para>Nu kommer vi till den mest uppenbara fördelen med QT-verktygslådan: signal/slot-mekanismen. Den erbjuder en mycket bekväm och användbar lösning för kommunikation mellan objekt, som oftast löses med återanropsfunktioner i X-windows verktygslådor. Eftersom kommunikationen kräver strikt programmering och ibland gör det mycket svårt att skapa användargränssnitt (som beskrivs i QT-dokumentationen och förklaras i Programming with Qt av K. Dalheimer), uppfann TrollTech ett nytt system där objekt kan skicka signaler som kan anslutas till metoder som deklareras som slots. Som programmerare av C++, behöver man bara veta några saker om mekanismen: <itemizedlist>
-<listitem><para>klassdeklarationen av en klass som använder signaler och slots måste innehålla makrot TQ_OBJECT i början (utan ett semikolon), och måste härledas från klassen <classname>QObject</classname> </para></listitem>
+<listitem><para>klassdeklarationen av en klass som använder signaler och slots måste innehålla makrot TQ_OBJECT i början (utan ett semikolon), och måste härledas från klassen <classname>TQObject</classname> </para></listitem>
 <listitem><para>en signal kan skickas med nyckelordet emit, t.ex. emit signal(parametrar);, inne i vilken medlemsfunktion som helst i en klass som tillåter användning av signaler och slots </para></listitem>
 
 <listitem><para>alla signaler som används av klasser som inte ärvs måste läggas till i klassdeklarationen i en signalsektion </para></listitem>
@@ -237,9 +237,9 @@ return a.exec();
 <listitem><para>metaobjektkompilatorn moc har körts för deklarationsfilen för att expandera makron och skapa implementeringen (som man inte behöverkänna till). Utdatafilerna från moc kompileras också av C++ kompilatorn. </para></listitem>
 </itemizedlist>
 </para>
-<para>Ett annat sätt att använda signaler utan att härleda från <classname>QObject</classname> är att använda klassen <classname>QSignal</classname>. Se referensdokumentationen för mer information och exempel på användning. Vi antar att du härleder från <classname>QObject</classname> i det följande. </para>
+<para>Ett annat sätt att använda signaler utan att härleda från <classname>TQObject</classname> är att använda klassen <classname>QSignal</classname>. Se referensdokumentationen för mer information och exempel på användning. Vi antar att du härleder från <classname>TQObject</classname> i det följande. </para>
 <para>På detta sätt kan din klass skicka signaler vart som helst och tillhandahålla slots som signaler kan anslutas till. Genom att använda en signal, behöver du inte bry dig om vem som tar emot den. Du behöver bara skicka signalen, och vilken slot du än ansluter till den kan reagera när den skickas. Dessutom kan en slot användas som en vanlig metod i implementeringen. </para>
-<para>För att nu ansluta en signal till en slot, måste du använda metoderna <methodname>connect()</methodname> som tillhandahålls av <classname>QObject</classname> eller, om tillgängliga, speciella metoder som objekt tillhandahåller för att ange anslutningen för en viss signal. </para>
+<para>För att nu ansluta en signal till en slot, måste du använda metoderna <methodname>connect()</methodname> som tillhandahålls av <classname>TQObject</classname> eller, om tillgängliga, speciella metoder som objekt tillhandahåller för att ange anslutningen för en viss signal. </para>
 
 <sect3 id="c1s2s4s1">
 <title>Exempel på användning</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>Du märker att allt du måste lägga till för att ge knappen mer kommunikation är metoden <methodname>connect()</methodname>: <methodname>connect (&amp;hello, SIGNAL( clicked() ), &amp;a, SLOT( quit() ))</methodname>;. Vad är betydelsen nu? Klassdeklarationen av QObject säger följande om metoden <methodname>connect()</methodname>: </para>
-<para><methodname>bool connect ( const QObject * avsändare, const char * signal, const QObject * mottagare, const char * medlem ) </methodname></para>
-<para>Detta betyder att du måste ange en <classname>QObject</classname>-instanspekare som är signalens avsändare, vilket betyder att den kan skicka signalen, som första parameter. Därefter måste du ange signalen som du vill ansluta till. De två sista parametrarna är mottagarobjektet som tillhandahåller en slot, följt av medlemsfunktionen som är en verklig slot som kommer att köras när signalen skickas. </para>
+<para>Du märker att allt du måste lägga till för att ge knappen mer kommunikation är metoden <methodname>connect()</methodname>: <methodname>connect (&amp;hello, SIGNAL( clicked() ), &amp;a, SLOT( quit() ))</methodname>;. Vad är betydelsen nu? Klassdeklarationen av TQObject säger följande om metoden <methodname>connect()</methodname>: </para>
+<para><methodname>bool connect ( const TQObject * avsändare, const char * signal, const TQObject * mottagare, const char * medlem ) </methodname></para>
+<para>Detta betyder att du måste ange en <classname>TQObject</classname>-instanspekare som är signalens avsändare, vilket betyder att den kan skicka signalen, som första parameter. Därefter måste du ange signalen som du vill ansluta till. De två sista parametrarna är mottagarobjektet som tillhandahåller en slot, följt av medlemsfunktionen som är en verklig slot som kommer att köras när signalen skickas. </para>
 <para>Genom att använda signaler och slots, kan programmets objekt enkelt kommunicera med varandra utan att uttryckligen bero på typen hos mottagarobjektet. Du får lära dig mer om hur den här mekanismen används produktivt senare i handboken. Mer information om signal/slot-mekanismen finns också i <ulink url="developer.kde.org/documentation/library/libraryref.html">KDE:s biblioteksreferensguide</ulink> och <ulink url="doc.trolltech.com">QT:s direktreferens</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>Du märker att vi först har ändrat från <classname>QApplication</classname> till <classname>TDEApplication</classname>. Dessutom var vi tvungna att ändra den tidigare använda metoden <methodname>setMainWidget()</methodname> till <methodname>setTopWidget</methodname> som <classname>TDEApplication</classname> använder för att ange huvudkomponenten. Det är allt! Ditt första KDE-program är klart. Du behöver bara tala om för kompilatorn vilken deklarationssökväg KDE har, och för länkaren att den ska länka med tdecore-biblioteket med -ltdecore. </para>
 <para>Eftersom du nu åtminstone vet vad funktionen <function>main()</function> i allmänhet tillhandahåller, och hur ett program blir synligt och tillåter kommunikation mellan användare och objekt, fortsätter vi med nästa kapitel, där vårt första program med &tdevelop; skapas. Där kan du också prova allting som tidigare nämnts, och se effekterna. </para>
-<para>Vad du ytterligare bör ha tittat på hittills är QT-referensdokumentationen, särskilt klasserna <classname>QApplication</classname>, <classname>QWidget</classname> och <classname>QObject</classname> och tdecore-biblioteksdokumentationen för klassen <classname>TDEApplication</classname>. <ulink url="developer.kde.org/documentation/library/libraryref.html">KDE:s biblioteksreferensguide</ulink> har också en fullständig beskrivning av hur konstruktorerna i <classname>QApplication</classname> och <classname>TDEApplication</classname> anropas, inklusive behandling av kommandoradsväljare. </para>
+<para>Vad du ytterligare bör ha tittat på hittills är QT-referensdokumentationen, särskilt klasserna <classname>QApplication</classname>, <classname>TQWidget</classname> och <classname>TQObject</classname> och tdecore-biblioteksdokumentationen för klassen <classname>TDEApplication</classname>. <ulink url="developer.kde.org/documentation/library/libraryref.html">KDE:s biblioteksreferensguide</ulink> har också en fullständig beskrivning av hur konstruktorerna i <classname>QApplication</classname> och <classname>TDEApplication</classname> anropas, inklusive behandling av kommandoradsväljare. </para>
 </sect2>
 </sect1>
 
@@ -549,10 +549,10 @@ return a.exec();
 16     statusBar()->show();
 17 
 18     // tillåt vyn att ändra statusraden och rubriken
-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>Det behöver inte sägas att stabilitet är ett av huvudmålen med konstruktionen. Ingen kan förhindra fel, men ett minimum kan åtminstone uppnås med smarta konstruktionsmål och utbredd användning av objektorienterad konstruktion. C++ gör det till ett nöje att programmera om du vet hur man utnyttjar dess möjligheter - arv, att dölja information och återanvändning av befintlig kod. </para>
-<para>När ett KDE- eller QT-projekt skapas, måste du alltid ha en vy som ärver en QWidget, antingen med direkt arv eller eftersom en bibliotekskomponent som du vill använda ärver QWidget. Därför harProgramguiden redan skapat en vy som är en instans av klassen programnamnView, som redan ärver QWidget. </para>
+<para>När ett KDE- eller QT-projekt skapas, måste du alltid ha en vy som ärver en TQWidget, antingen med direkt arv eller eftersom en bibliotekskomponent som du vill använda ärver TQWidget. Därför harProgramguiden redan skapat en vy som är en instans av klassen programnamnView, som redan ärver TQWidget. </para>
 <para>Det här kapitlet beskriver därför hur bibliotekskomponenter används för att skapa vyer för KDE- och QT-program som skapas med &tdevelop;. Därefter tar vi en titt på biblioteken och vilka sorters vyer de redan erbjuder. </para>
 </sect1>
 <sect1 id="c4s2">
@@ -601,7 +601,7 @@ return a.exec();
 <para>När du tittar på första sidan av QT:s direktdokumentation, hittar du en länk till "Widget Screenshots", där du kan titta på hur de grafiska komponenterna som QT innehåller ser ut. De är färdiga att använda, och kan kombineras för att ge komplexa komponenter som kan skapa programvyer eller dialogrutor. I följande stycken beskriver vi några av dessa, som är mycket användbara för att skapa programvyer, men kom ihåg att KDE-biblioteken ibland innehåller andra komponenter med samma syfte. Dessa granskas i nästa avsnitt. </para>
 <para>Här är några tips om vilken Qt-komponent som kan användas för vilket ändamål: <orderedlist>
 <listitem><para>Om vyområdet inte är stort nog för att visa all data, måste användaren kunna panorera i dokumentet med lister till vänster och längst ner i vyn. QT tillhandahåller klassen <classname>QScrollView</classname> för detta, som erbjuder ett underliggande område med panoreringsmöjlighet. Som tidigare förklarats, kan du låta din egen grafiska komponent ärva <classname>QScrollView</classname>, eller använda en instans för att hantera ditt dokuments vykomponent. </para></listitem> 
-<listitem><para>För att skapa en egen ScrollView, låt komponenten View ärva från <classname>QWidget</classname> och lägg till vertikala och horisontella rullningslister med <classname>QScrollBars</classname>. (Detta görs av KDE:s komponent TDEHTMLView.) </para></listitem> 
+<listitem><para>För att skapa en egen ScrollView, låt komponenten View ärva från <classname>TQWidget</classname> och lägg till vertikala och horisontella rullningslister med <classname>QScrollBars</classname>. (Detta görs av KDE:s komponent TDEHTMLView.) </para></listitem> 
 <listitem><para>För textbehandling, använd <classname>QTextEdit</classname>. Den här klassen tillhandahåller en fullständig grafisk texteditorkomponent, som redan kan klippa ut, kopiera och klistra text och hanteras av en vy med rullningslister. </para></listitem> 
 <listitem><para>Använd <classname>QTable</classname> för att visa data som är arrangerat i en tabell. Eftersom <classname>QTable</classname> också hanteras av rullningslister, erbjuder den en bra lösning för program med tabellberäkningar. </para></listitem> 
 <listitem><para>För att visa två olika grafiska komponenter eller två instanser av samma komponent samtidigt, använd <classname>QSplitter</classname>. Den tillåter att vyer läggs sida vid sida med horisontella eller vertikala avdelare. Kmail är ett bra exempel på hur det ser ut. Huvudfönstret är delat vertikalt av en avdelare, och det högra fönstret är återigen avdelat horisontellt. </para></listitem> 
@@ -653,7 +653,7 @@ return a.exec();
 <title>Inställning av snabbtangenter</title>
 <para>Något mycket professionellt som du alltid bör lägga till i programmet är snabbtangenter. De används oftast av erfarna användare som vill arbeta snabbt med sina program och är villiga att lära sig genvägar. KDE-biblioteken erbjuder klassen <classname>TDEAction</classname> för detta, som tillhandahåller snabbtangenter och åtkomst av globalt inställda standardgenvägar. </para>
 <para>Normalt använder bara ramprogram skapade av &tdevelop; vanliga snabbtangenter som F1 för att komma åt direkthjälp, Ctrl+N för Ny fil, etc. </para>
-<para>Om programmet innehåller många snabbtangenter bör du göra dem anpassningsbara via en inställningsmeny. Antingen kan det kombineras med annan programinställning i en QWidget eller vara ensamt. KDE-biblioteket tillhandahåller redan en <classname>KKeyChooser</classname> för att använda i flikdialogrutor, medan <classname>KKeyDialog</classname> tillhandahåller en inställningsdialogruta för snabbtangenter som är färdig att använda. </para>
+<para>Om programmet innehåller många snabbtangenter bör du göra dem anpassningsbara via en inställningsmeny. Antingen kan det kombineras med annan programinställning i en TQWidget eller vara ensamt. KDE-biblioteket tillhandahåller redan en <classname>KKeyChooser</classname> för att använda i flikdialogrutor, medan <classname>KKeyDialog</classname> tillhandahåller en inställningsdialogruta för snabbtangenter som är färdig att använda. </para>
 
 </sect1>
 </chapter>
@@ -696,7 +696,7 @@ return a.exec();
 <sect1 id="c8s4">
 <title>Knappen <guibutton>Vad är det här?</guibutton></title>
 <para>Knappen <guibutton>Vad är det här...?</guibutton> tillhandahåller hjälpfönster med syftet att ge användaren hjälp med en viss komponent i vyn som används eller ett objekt i en verktygsrad. Den finns i verktygsraden och aktiveras när användaren trycker på knappen. Markören ändras till en pilmarkör med ett frågetecken, precis som knappen själv ser ut. Därefter kan användaren klicka på en synlig komponent och får då ett hjälpfönster. Som en övning kan du prova beteendet med knappen <guibutton>Vad är det här...?</guibutton> inne i &tdevelop;. </para>
-<para>För att lägga till "Vad är det här...?" hjälp i en av dina grafiska komponenter, använd den statiska metoden <methodname>QWhatsThis::add(QWidget *widget, const QString &amp;text)</methodname> </para>
+<para>För att lägga till "Vad är det här...?" hjälp i en av dina grafiska komponenter, använd den statiska metoden <methodname>QWhatsThis::add(TQWidget *widget, const TQString &amp;text)</methodname> </para>
 </sect1>
 </chapter>
 
diff --git a/tde-i18n-sv/docs/tdevelop/kdearch/index.docbook b/tde-i18n-sv/docs/tdevelop/kdearch/index.docbook
index 1407e68157c..aef23c18cc5 100644
--- a/tde-i18n-sv/docs/tdevelop/kdearch/index.docbook
+++ b/tde-i18n-sv/docs/tdevelop/kdearch/index.docbook
@@ -238,7 +238,7 @@
 </formalpara></listitem>
 
 <listitem><formalpara><title><ulink url="kdeapi:tdeui/KPixmapIO">KPixmapIO</ulink></title>
-<para>Snabb konvertering mellan <classname>QImage</classname> och <classname>QPixmap</classname>. </para>
+<para>Snabb konvertering mellan <classname>TQImage</classname> och <classname>QPixmap</classname>. </para>
 </formalpara></listitem>
 
 </itemizedlist>
@@ -473,7 +473,7 @@ url="kdeapi:tdeui/KAnimWidget">KAnimWidget</ulink></title>
 
 <para>Qt:s lågnivåritmodell är baserad på de möjligheter som erbjuds av X11 och andra fönstersystem där en version av Qt finns. Men den utökar också dem genom att implementera ytterligare funktioner som godtyckliga affina omvandlingar för text och pixmappar. </para>
 
-<para>Den centrala grafiska klassen för att rita tvådimensionellt med Qt är <ulink url="kdeapi:qt/QPainter">QPainter</ulink>. Den kan rita på en <ulink url="kdeapi:qt/QPaintDevice">QPaintDevice</ulink>. Det finns tre möjliga ritenheter implementerade: En är <ulink url="kdeapi:qt/QWidget">QWidget</ulink>, som representerar en grafisk komponent på skärmen. Den andra är <ulink url="kdeapi:qt/QPrinter">QPrinter</ulink>, som representerar en skrivare, och producerar Postskript-utmatning. Den tredje är klassen <ulink url="kdeapi:qt/QPicture">QPicture</ulink>, som spelar in ritkommandon och kan spara dem till disk, och sedan spela upp dem. Ett möjligt lagringsformat för ritkommandon är W3C-standarden SVG. </para>
+<para>Den centrala grafiska klassen för att rita tvådimensionellt med Qt är <ulink url="kdeapi:qt/QPainter">QPainter</ulink>. Den kan rita på en <ulink url="kdeapi:qt/QPaintDevice">QPaintDevice</ulink>. Det finns tre möjliga ritenheter implementerade: En är <ulink url="kdeapi:qt/TQWidget">TQWidget</ulink>, som representerar en grafisk komponent på skärmen. Den andra är <ulink url="kdeapi:qt/QPrinter">QPrinter</ulink>, som representerar en skrivare, och producerar Postskript-utmatning. Den tredje är klassen <ulink url="kdeapi:qt/QPicture">QPicture</ulink>, som spelar in ritkommandon och kan spara dem till disk, och sedan spela upp dem. Ett möjligt lagringsformat för ritkommandon är W3C-standarden SVG. </para>
 
 <para>Alltså är det möjligt att återanvända uppritningskoden som du använder för att visa en grafisk komponent för utskrift, med stöd för samma funktioner. Naturligtvis används koden i praktiken i ett något annorlunda sammanhang. Rita på en grafisk komponent görs nästan enbart i metoden paintEvent() i en komponentklass. </para>
 
@@ -664,10 +664,10 @@ url="kdeapi:tdeui/KAnimWidget">KAnimWidget</ulink></title>
 <para>QBrush::QBrush(BrushStyle): detta skapar en svart borste, med ett av de fördefinierade mönstren som visas nedan.</para>
 </listitem>
 <listitem>
-<para>QBrush::QBrush(const QColor &amp;, BrushStyle): detta skapar en färgad borste, med ett av de fördefinierade mönstren som visas nedan.</para>
+<para>QBrush::QBrush(const TQColor &amp;, BrushStyle): detta skapar en färgad borste, med ett av de fördefinierade mönstren som visas nedan.</para>
 </listitem>
 <listitem>
-<para>QBrush::QBrush(const QColor &amp;, const QPixmap): detta skapar en färgad borste, med det egna mönstret som anges som andra parameter.</para>
+<para>QBrush::QBrush(const TQColor &amp;, const QPixmap): detta skapar en färgad borste, med det egna mönstret som anges som andra parameter.</para>
 </listitem>
 </itemizedlist>
 
@@ -685,7 +685,7 @@ url="kdeapi:tdeui/KAnimWidget">KAnimWidget</ulink></title>
 <simplesect id="qpainter-color">
 <title>Färg</title>
 
-<para>Färger har betydelse både när kurvor ritas, och när former fylls i. Färger representeras av klassen <ulink url="kdeapi:qt/QColor">QColor</ulink> i Qt. Qt stöder inte avancerade grafikfunktioner som ICC-färgprofiler och färgkorrektion. Färger skapas oftast genom att ange deras röda, gröna och bläa komponenter, eftersom RGB-modellen är sättet som bildpunkter sätts samman på en bildskärm. </para>
+<para>Färger har betydelse både när kurvor ritas, och när former fylls i. Färger representeras av klassen <ulink url="kdeapi:qt/TQColor">TQColor</ulink> i Qt. Qt stöder inte avancerade grafikfunktioner som ICC-färgprofiler och färgkorrektion. Färger skapas oftast genom att ange deras röda, gröna och bläa komponenter, eftersom RGB-modellen är sättet som bildpunkter sätts samman på en bildskärm. </para>
 
 <para>Det är också möjligt att använda färgton, färgmättnad och värde. Den här HSV-representationen är den som används i GTK:s färgdialogruta, t.ex. i GIMP. Där motsvarar färgtonen en vinkel i färghjulet, medan färgmättnaden motsvarar avståndet från cirkelns mitt. Värdet väljs med ett särskilt skjutreglage. </para>
 
@@ -738,7 +738,7 @@ url="kdeapi:tdeui/KAnimWidget">KAnimWidget</ulink></title>
 
 <para><ulink url="kdeapi:qt/QPixmap">QPixmap</ulink> motsvarar direkt pixmappsobjekt i X11. En pixmapp är ett objekt på serversidan och kan, med ett modernt grafikkort, till och med lagras direkt i kortets minne. Det gör det <emphasis>mycket</emphasis> effektivt att överföra en pixmapp till skärmen. En pixmapp fungerar också som en motsvarighet till grafiska komponenter utanför skärmen. QPixmap-klassen är en delklass till QPaintDevice, så det går att rita på den med en QPainter. Elementära ritoperationer accelereras ofta av modern grafik. Därför är ett vanligt användningsmönster att använda en pixmapp för dubbelbuffring. Detta betyder att istället för att rita direkt på en grafisk komponent, ritar man på ett tillfälligt pixmappsobjekt och använder funktionen <ulink url="kdeapi:qt/QPaintDevice#bitBlt-1">bitBlt</ulink> för att överföra det till komponenten. För komplexa omritningar, hjälper detta till att undvika flimmer. </para>
 
-<para>I motsats till detta, finns <ulink url="kdeapi:qt/QImage">QImage</ulink>-objekt på klientsidan. Deras huvuduppgift är att ge direkt åtkomst till bildpunkterna i bilden. Det gör dem användbara för bildhantering, och saker som att ladda och spara till disk (Metoden load() för QPixmap använder QImage som ett mellansteg). Å andra sidan, så blir uppritning av en bild på en grafisk komponent en ganska krävande åtgärd, eftersom det innebär en överföring till X-servern, vilket kan ta en viss tid, särskilt för stora bilder och fjärrservrar. Beroende på färgdjupet, kan konvertering från QImage till QPixmap också kräva användning av gitter. </para>
+<para>I motsats till detta, finns <ulink url="kdeapi:qt/TQImage">TQImage</ulink>-objekt på klientsidan. Deras huvuduppgift är att ge direkt åtkomst till bildpunkterna i bilden. Det gör dem användbara för bildhantering, och saker som att ladda och spara till disk (Metoden load() för QPixmap använder TQImage som ett mellansteg). Å andra sidan, så blir uppritning av en bild på en grafisk komponent en ganska krävande åtgärd, eftersom det innebär en överföring till X-servern, vilket kan ta en viss tid, särskilt för stora bilder och fjärrservrar. Beroende på färgdjupet, kan konvertering från TQImage till QPixmap också kräva användning av gitter. </para>
 
 </simplesect>
 
@@ -746,7 +746,7 @@ url="kdeapi:tdeui/KAnimWidget">KAnimWidget</ulink></title>
 <simplesect id="qpainter-drawingtext">
 <title>Rita text</title>
 
-<para>Text kan ritas med en av de överlastade varianterna av metoden QPainter::drawText(). De ritar en QString, antingen vid en given punkt eller inne i en given rektangel, med teckensnittet som ställts in med QPainter::setFont(). Det finns också en parameter som tar en ELLER-kombination av vissa flaggor från uppräkningstyperna <ulink url="kdeapi:qt/Qt#AlignmentFlags-enum">Qt::AlignmentFlags</ulink> och <ulink url="kdeapi:qt/Qt#TextFlags-enum">Qt::TextFlags</ulink>. </para>
+<para>Text kan ritas med en av de överlastade varianterna av metoden QPainter::drawText(). De ritar en TQString, antingen vid en given punkt eller inne i en given rektangel, med teckensnittet som ställts in med QPainter::setFont(). Det finns också en parameter som tar en ELLER-kombination av vissa flaggor från uppräkningstyperna <ulink url="kdeapi:qt/Qt#AlignmentFlags-enum">Qt::AlignmentFlags</ulink> och <ulink url="kdeapi:qt/Qt#TextFlags-enum">Qt::TextFlags</ulink>. </para>
 
 <para>Med början i version 3.0, hanterar Qt fullständig textlayout också för språk som skrivs från höger till vänster. </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>Förutom de vanliga posterna, förevisar det här exemplet hur man anger att en tjänst har vissa egenskaper. Varje definition av en egenskap motsvarar en grupp <literal>[PropertyDef::name]</literal> i konfigurationsfilen. I gruppen, anger posten <literal>Type</literal> egenskapens typ. Möjliga typer är allt som kan lagras i en <ulink url="kdeapi:qt/QVariant">QVariant</ulink>. </para>
@@ -1196,11 +1196,11 @@ X-KDevelop-Scope=Project
 <para>Med objektet <classname>KService</classname> tillgängligt, kan du mycket lätt ladda biblioteket och få en pekare till dess tillverkningsobjekt. </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; "Start av TDEIO-server misslyckades med meddelandet " &lt;&lt; error &lt;&lt; endl;
 }
@@ -1275,7 +1275,7 @@ if (!client->call("tdeio_uiserver", "UIServer", "setListMode(bool)",
 
 <para>I exemplet som ges här, startas tjänsten "med namn", dvs. första argumentet till <function>TDEApplication::startServiceByName() </function> är namnet, som det anges på raden <literal>Name</literal> i desktop-filen. Ett alternativ är att använda <function>TDEApplication::startServiceByDesktopName()</function>, som använder namnet på desktop-filen som argument, dvs. i det här fallet <literal>"tdeio_uiserver.desktop"</literal>. </para>
 
-<para>Alla dessa anrop har en lista med webbadresser som andra argument, vilket ges till tjänsten på kommandoraden. Det tredje argumentet är en pekare till en <classname>QString</classname>. Om starten av tjänsten misslyckas, tilldelas det här argumentet det översatta felmeddelandet. </para>
+<para>Alla dessa anrop har en lista med webbadresser som andra argument, vilket ges till tjänsten på kommandoraden. Det tredje argumentet är en pekare till en <classname>TQString</classname>. Om starten av tjänsten misslyckas, tilldelas det här argumentet det översatta felmeddelandet. </para>
 
 </simplesect>
 
@@ -1385,7 +1385,7 @@ else
 <para>Till och med KMimeMagic kan förstås bara avgöra filtypen från innehållet i en lokal fil. För fjärrfiler, finns ytterligare en möjlighet: </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; "Kunde inte avgöra typen" &lt;&lt; endl;
 else
@@ -1463,7 +1463,7 @@ KRun::run(offer.service(), urlList);
 <para>Hämta en ikon för en webbadress. Det här tittar efter webbadressens typ, och returnerar motsvarande ikon. </para>
 
 <programlisting>KURL url("ftp://ftp.kde.org/pub/incoming/wibble.c");
-QString icon = KMimeType::iconForURL(url);
+TQString icon = KMimeType::iconForURL(url);
 </programlisting>
 
 <para>Kör en webbadress. Det här tittar efter webbadressens typ, och startar tillhörande program till typen som användaren föredrar. </para>
@@ -1542,7 +1542,7 @@ void FooClass::mkdirResult(TDEIO::Job *job)
 <listitem><para>Byter namn på en fil. </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>Skapar en symbolisk länk. </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) {
     // ladda filen med namnet 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; "Senaste ändring: " &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>Skapar en symbolisk länk.</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>