Rename KCModule, KConfig, KIO, KServer, and KSocket to avoid conflicts with KDE4

1 files changed, 61 insertions, 61 deletions

diff --git a/tde-i18n-pt/docs/tdevelop/kdearch/index.docbook b/tde-i18n-pt/docs/tdevelop/kdearch/index.docbook
index 931c2fab812..67d928d8ae1 100644
--- a/tde-i18n-pt/docs/tdevelop/kdearch/index.docbook
+++ b/tde-i18n-pt/docs/tdevelop/kdearch/index.docbook
@@ -202,8 +202,8 @@
 <listitem
 ><formalpara
 ><title
-><ulink url="kdeapi:tdecore/KConfig"
->KConfig</ulink
+><ulink url="kdeapi:tdecore/TDEConfig"
+>TDEConfig</ulink
 ></title>
 <para
 >Fornece o acesso à base de dados de configuração do KDE. </para>
@@ -2714,7 +2714,7 @@ else
 
 <programlisting
 >KURL url("http://developer.kde.org/favicon.ico");
-QString tipo = KIO::NetAccess::mimetype(url);
+QString tipo = TDEIO::NetAccess::mimetype(url);
 if (tipo == KMimeType::defaultMimeType())
     cout &lt;&lt; "Não foi possível descobrir o tipo" &lt;&lt; endl;
 else
@@ -2735,17 +2735,17 @@ else
 >void ClasseXpto::descobrirTipo()
 {
     KURL url("http://developer.kde.org/favicon.ico");
-    KIO::MimetypeJob *tarefa = KIO::mimetype(url);
-    connect( tarefa, SIGNAL(result(KIO::Job*)),
-             this, SLOT(mimeResult(KIO::Job*)) );
+    TDEIO::MimetypeJob *tarefa = TDEIO::mimetype(url);
+    connect( tarefa, SIGNAL(result(TDEIO::Job*)),
+             this, SLOT(mimeResult(TDEIO::Job*)) );
 }
 
-void ClasseXpto::resultadoMime(KIO::Job *tarefa)
+void ClasseXpto::resultadoMime(TDEIO::Job *tarefa)
 {
     if (tarefa->error())
         tarefa->showErrorDialog();
     else
-        cout &lt;&lt; "Tipo MIME: " &lt;&lt; ((KIO::MimetypeJob *)tarefa)->mimetype() &lt;&lt; endl;
+        cout &lt;&lt; "Tipo MIME: " &lt;&lt; ((TDEIO::MimetypeJob *)tarefa)->mimetype() &lt;&lt; endl;
 }
 </programlisting>
 
@@ -2901,18 +2901,18 @@ new KRun(url);
 
 <para
 >Na maioria dos casos, as tarefas são criadas ao invocar as funções no espaço de nomes do KIO. Estas funções recebem um ou dois URLs como argumentos e possivelmente outros parâmetros necessários. Quando a tarefa terminar, ela emite o 'signal' <literal
->result(KIO::Job*)</literal
+>result(TDEIO::Job*)</literal
 >. Depois de este 'signal' ter sido emitido, a tarefa elimina-se a si própria. Deste modo, um caso de uso típico poderia ser semelhante ao seguinte: </para>
 
 <programlisting
 >void ClasseXpto::criarDirectoria()
 {
-    SimpleJob *tarefa = KIO::mkdir(KURL("file:/home/ze/dir_kio"));
-    connect( tarefa, SIGNAL(result(KIO::Job*)), 
-             this, SLOT(resultadoMkdir(KIO::Job*)) );
+    SimpleJob *tarefa = TDEIO::mkdir(KURL("file:/home/ze/dir_kio"));
+    connect( tarefa, SIGNAL(result(TDEIO::Job*)), 
+             this, SLOT(resultadoMkdir(TDEIO::Job*)) );
 }
 
-void ClasseXpto::resultadoMkdir(KIO::Job *tarefa)
+void ClasseXpto::resultadoMkdir(TDEIO::Job *tarefa)
 {
     if (tarefa->error())
         tarefa->showErrorDialog();
@@ -2931,7 +2931,7 @@ void ClasseXpto::resultadoMkdir(KIO::Job *tarefa)
 
 <varlistentry
 ><term
->KIO::mkdir(const KURL &amp;url, int permissao)</term>
+>TDEIO::mkdir(const KURL &amp;url, int permissao)</term>
 <listitem
 ><para
 >Criar uma directoria, com algumas permissões opcionais. </para
@@ -2940,7 +2940,7 @@ void ClasseXpto::resultadoMkdir(KIO::Job *tarefa)
 
 <varlistentry
 ><term
->KIO::rmdir(const KURL &amp;url)</term>
+>TDEIO::rmdir(const KURL &amp;url)</term>
 <listitem
 ><para
 >Remove uma directoria. </para
@@ -2949,7 +2949,7 @@ void ClasseXpto::resultadoMkdir(KIO::Job *tarefa)
 
 <varlistentry
 ><term
->KIO::chmod(const KURL &amp;url, int permissoes)</term>
+>TDEIO::chmod(const KURL &amp;url, int permissoes)</term>
 <listitem
 ><para
 >Muda as permissões de um ficheiro. </para
@@ -2958,7 +2958,7 @@ void ClasseXpto::resultadoMkdir(KIO::Job *tarefa)
 
 <varlistentry
 ><term
->KIO::rename(const KURL &amp;origem, const KURL &amp;destino, bool sobrepor)</term>
+>TDEIO::rename(const KURL &amp;origem, const KURL &amp;destino, bool sobrepor)</term>
 <listitem
 ><para
 >Muda o nome de um ficheiro. </para
@@ -2967,7 +2967,7 @@ void ClasseXpto::resultadoMkdir(KIO::Job *tarefa)
 
 <varlistentry
 ><term
->KIO::symlink(const QString &amp;alvo, const KURL &amp;destino, bool sobrepor, bool mostrarProgresso)</term>
+>TDEIO::symlink(const QString &amp;alvo, const KURL &amp;destino, bool sobrepor, bool mostrarProgresso)</term>
 <listitem
 ><para
 >Cria uma ligação simbólica. </para
@@ -2976,16 +2976,16 @@ void ClasseXpto::resultadoMkdir(KIO::Job *tarefa)
 
 <varlistentry
 ><term
->KIO::stat(const KURL &amp;url, bool mostrarProgresso)</term>
+>TDEIO::stat(const KURL &amp;url, bool mostrarProgresso)</term>
 <listitem
 ><para
->Descobre certas informações sobre o ficheiro, como o tamanho, a data de modificação e as permissões. A informação pode ser obtida a partir do KIO::StatJob::statResult() depois de a tarefa terminar. </para
+>Descobre certas informações sobre o ficheiro, como o tamanho, a data de modificação e as permissões. A informação pode ser obtida a partir do TDEIO::StatJob::statResult() depois de a tarefa terminar. </para
 ></listitem>
 </varlistentry>
 
 <varlistentry
 ><term
->KIO::get(const KURL &amp;url, bool reler, bool mostrarProgresso)</term>
+>TDEIO::get(const KURL &amp;url, bool reler, bool mostrarProgresso)</term>
 <listitem
 ><para
 >Transfere os dados de um dado URL. </para
@@ -2994,7 +2994,7 @@ void ClasseXpto::resultadoMkdir(KIO::Job *tarefa)
 
 <varlistentry
 ><term
->KIO::put(const KURL &amp;url, int permissoes, bool sobrepor, bool continuar, bool mostrarProgresso)</term>
+>TDEIO::put(const KURL &amp;url, int permissoes, bool sobrepor, bool continuar, bool mostrarProgresso)</term>
 <listitem
 ><para
 >Transfere os dados para um dado URL. </para
@@ -3003,7 +3003,7 @@ void ClasseXpto::resultadoMkdir(KIO::Job *tarefa)
 
 <varlistentry
 ><term
->KIO::http_post(const KURL &amp;url, const QByteArray &amp;dados, bool mostrarProgresso)</term>
+>TDEIO::http_post(const KURL &amp;url, const QByteArray &amp;dados, bool mostrarProgresso)</term>
 <listitem
 ><para
 >Envia os dados. É específico do HTTP. </para
@@ -3012,16 +3012,16 @@ void ClasseXpto::resultadoMkdir(KIO::Job *tarefa)
 
 <varlistentry
 ><term
->KIO::mimetype(const KURL &amp;url, bool mostrarProgresso)</term>
+>TDEIO::mimetype(const KURL &amp;url, bool mostrarProgresso)</term>
 <listitem
 ><para
->Tenta descobrir o tipo MIME do URL. O tipo poderá ser obtido a partir do KIO::MimetypeJob::mimetype() depois de a tarefa terminar. </para
+>Tenta descobrir o tipo MIME do URL. O tipo poderá ser obtido a partir do TDEIO::MimetypeJob::mimetype() depois de a tarefa terminar. </para
 ></listitem>
 </varlistentry>
 
 <varlistentry
 ><term
->KIO::file_copy(const KURL &amp;origem, const KURL &amp;destino, int permissoes, bool sobrepor, bool continuar, bool mostrarProgresso)</term>
+>TDEIO::file_copy(const KURL &amp;origem, const KURL &amp;destino, int permissoes, bool sobrepor, bool continuar, bool mostrarProgresso)</term>
 <listitem
 ><para
 >Copia um único ficheiro. </para
@@ -3030,7 +3030,7 @@ void ClasseXpto::resultadoMkdir(KIO::Job *tarefa)
 
 <varlistentry
 ><term
->KIO::file_move(const KURL &amp;origem, const KURL &amp;destino, int permissoes, bool sobrepor, bool continuar, bool mostrarProgresso)</term>
+>TDEIO::file_move(const KURL &amp;origem, const KURL &amp;destino, int permissoes, bool sobrepor, bool continuar, bool mostrarProgresso)</term>
 <listitem
 ><para
 >Muda o nome ou move um único ficheiro. </para
@@ -3039,7 +3039,7 @@ void ClasseXpto::resultadoMkdir(KIO::Job *tarefa)
 
 <varlistentry
 ><term
->KIO::file_delete(const KURL &amp;url, bool mostrarProgresso)</term>
+>TDEIO::file_delete(const KURL &amp;url, bool mostrarProgresso)</term>
 <listitem
 ><para
 >Apaga um único ficheiro. </para
@@ -3048,16 +3048,16 @@ void ClasseXpto::resultadoMkdir(KIO::Job *tarefa)
 
 <varlistentry
 ><term
->KIO::listDir(const KURL &amp;url, bool mostrarProgresso)</term>
+>TDEIO::listDir(const KURL &amp;url, bool mostrarProgresso)</term>
 <listitem
 ><para
->Lista o conteúdo de uma dada directoria. De cada vez que alguns itens passam a ser conhecidos, o 'signal' KIO::ListJob::entries() é emitido. </para
+>Lista o conteúdo de uma dada directoria. De cada vez que alguns itens passam a ser conhecidos, o 'signal' TDEIO::ListJob::entries() é emitido. </para
 ></listitem>
 </varlistentry>
 
 <varlistentry
 ><term
->KIO::listRecursive(const KURL &amp;url, bool mostrarProgresso)</term>
+>TDEIO::listRecursive(const KURL &amp;url, bool mostrarProgresso)</term>
 <listitem
 ><para
 >Semelhante à função listDir(), só que esta função é recursiva. </para
@@ -3066,7 +3066,7 @@ void ClasseXpto::resultadoMkdir(KIO::Job *tarefa)
 
 <varlistentry
 ><term
->KIO::copy(const KURL &amp;origem, const KURL &amp;destino, bool mostrarProgresso)</term>
+>TDEIO::copy(const KURL &amp;origem, const KURL &amp;destino, bool mostrarProgresso)</term>
 <listitem
 ><para
 >Copia um ficheiro ou directoria. As directorias são copiadas de forma recursiva. </para
@@ -3075,7 +3075,7 @@ void ClasseXpto::resultadoMkdir(KIO::Job *tarefa)
 
 <varlistentry
 ><term
->KIO::move(const KURL &amp;origem, const KURL &amp;destino, bool mostrarProgresso)</term>
+>TDEIO::move(const KURL &amp;origem, const KURL &amp;destino, bool mostrarProgresso)</term>
 <listitem
 ><para
 >Move ou muda o nome de um ficheiro ou directoria. </para
@@ -3084,7 +3084,7 @@ void ClasseXpto::resultadoMkdir(KIO::Job *tarefa)
 
 <varlistentry
 ><term
->KIO::del(const KURL &amp;src, bool shred, bool showProgressInfo)</term>
+>TDEIO::del(const KURL &amp;src, bool shred, bool showProgressInfo)</term>
 <listitem
 ><para
 >Apaga um ficheiro ou directoria. </para
@@ -3101,7 +3101,7 @@ void ClasseXpto::resultadoMkdir(KIO::Job *tarefa)
 >Itens da directoria</title>
 
 <para
->Tanto as tarefas KIO::stat() como a KIO::listDir() devolvem os seus resultados como um tipo UDSEntry e UDSEntryList respectivamente. A última está definida como sendo um QValueList&lt;UDSEntry&gt;. O acrónimo UDS significa "Universal directory service" (serviço de directório universal). O princípio está em que o item da directoria só contém a informação que um 'ioslave' poderá fornecer, nada mais. Por exemplo, o 'slave' de HTTP não fornece nenhuma informação sobre as permissões de acesso ou os donos dos ficheiros. Em vez disso, uma UDSEntry é uma lista de UDSAtoms. Cada átomo contém um item informativo específico. Ele consiste num tipo armazenado no 'm_uds' e num valor inteiro no 'm_long' ou um valor de texto no 'm_str', dependendo do tipo. </para>
+>Tanto as tarefas TDEIO::stat() como a TDEIO::listDir() devolvem os seus resultados como um tipo UDSEntry e UDSEntryList respectivamente. A última está definida como sendo um QValueList&lt;UDSEntry&gt;. O acrónimo UDS significa "Universal directory service" (serviço de directório universal). O princípio está em que o item da directoria só contém a informação que um 'ioslave' poderá fornecer, nada mais. Por exemplo, o 'slave' de HTTP não fornece nenhuma informação sobre as permissões de acesso ou os donos dos ficheiros. Em vez disso, uma UDSEntry é uma lista de UDSAtoms. Cada átomo contém um item informativo específico. Ele consiste num tipo armazenado no 'm_uds' e num valor inteiro no 'm_long' ou um valor de texto no 'm_str', dependendo do tipo. </para>
 
 <para
 >Os seguintes tipos estão actualmente definidos: </para>
@@ -3194,13 +3194,13 @@ void ClasseXpto::resultadoMkdir(KIO::Job *tarefa)
 >Utilização síncrona</title>
 
 <para
->Normalmente, a API síncrona do KIO é demasiado complexa de usar e, como tal, a implementação de uma assincronização completa não é uma prioridade. Por exemplo, num programa que só consiga lidar com um ficheiro de cada vez, não há muito a fazer enquanto o programa está a transferir um ficheiro, de qualquer forma. Para esses casos simples, existe uma API muito mais simples sob a forma de funções estáticas no KIO::NetAccess. Por exemplo, para poder copiar um ficheiro, use </para>
+>Normalmente, a API síncrona do KIO é demasiado complexa de usar e, como tal, a implementação de uma assincronização completa não é uma prioridade. Por exemplo, num programa que só consiga lidar com um ficheiro de cada vez, não há muito a fazer enquanto o programa está a transferir um ficheiro, de qualquer forma. Para esses casos simples, existe uma API muito mais simples sob a forma de funções estáticas no TDEIO::NetAccess. Por exemplo, para poder copiar um ficheiro, use </para>
 
 <programlisting
 >KURL origem, destino;
 source = ...;
 target = ...
-KIO::NetAccess::copy(origem, destino);
+TDEIO::NetAccess::copy(origem, destino);
 </programlisting>
 
 <para
@@ -3221,9 +3221,9 @@ KIO::NetAccess::copy(origem, destino);
 >KURL url;
 url = ...;
 QString ficheiroTemporario;
-if (KIO::NetAccess::download(url, ficheiroTemporario) {
+if (TDEIO::NetAccess::download(url, ficheiroTemporario) {
     // carregar o ficheiro com o nome 'ficheiroTemporario'
-    KIO::NetAccess::removeTempFile(ficheiroTemporario);
+    TDEIO::NetAccess::removeTempFile(ficheiroTemporario);
 }
 </programlisting>
 
@@ -3241,7 +3241,7 @@ if (KIO::NetAccess::download(url, ficheiroTemporario) {
 >void ClasseXpto::relerPagina()
 {
     KURL url("http://www.tdevelop.org/index.html");
-    KIO::TransferJob *tarefa = KIO::get(url, true, false);
+    TDEIO::TransferJob *tarefa = TDEIO::get(url, true, false);
     tarefa->addMetaData("cache", "reload");
     ...
 }
@@ -3258,18 +3258,18 @@ if (KIO::NetAccess::download(url, ficheiroTemporario) {
 >void ClasseXpto::mostrarDataModificacao()
 {
     KURL url("http://developer.kde.org/documentation/kde2arch/index.html");
-    KIO::TransferJob *tarefa = KIO::get(url, true, false);
-    connect( tarefa, SIGNAL(result(KIO::Job*)),
-             this, SLOT(transferirResultado(KIO::Job*)) );
+    TDEIO::TransferJob *tarefa = TDEIO::get(url, true, false);
+    connect( tarefa, SIGNAL(result(TDEIO::Job*)),
+             this, SLOT(transferirResultado(TDEIO::Job*)) );
 }
 
-void ClasseXpto::transferirResultado(KIO::Job *tarefa)
+void ClasseXpto::transferirResultado(TDEIO::Job *tarefa)
 {
     QString tipoMime;
     if (tarefa->error())
         tarefa->showErrorDialog();
     else {
-        KIO::TransferJob *tarefaTransferencia = (KIO::TransferJob*) tarefa;
+        TDEIO::TransferJob *tarefaTransferencia = (TDEIO::TransferJob*) tarefa;
         QString modificado = tarefaTransferencia->queryMetaData("modified");
         cout &lt;&lt; "Última modificação: " &lt;&lt; modificado &lt;&lt; endl;
 }
@@ -3300,28 +3300,28 @@ void ClasseXpto::transferirResultado(KIO::Job *tarefa)
 
 <programlisting
 >KURL url("http://developer.kde.org/documentation/kde2arch/index.html");
-KIO::TransferJob *tarefa = KIO::get(url, true, false);
-KIO::Scheduler::scheduleJob(tarefa);
+TDEIO::TransferJob *tarefa = TDEIO::get(url, true, false);
+TDEIO::Scheduler::scheduleJob(tarefa);
 </programlisting>
 
 <para
 >Uma terceira possibilidade é <emphasis
 >orientar à ligação</emphasis
->. Por exemplo, no caso do 'slave' de IMAP, não faz nenhum sentido lançar vários processos para o mesmo servidor. Só uma ligação de IMAP de cada vez é que deverá ser permitida. Neste caso, a aplicação deverá lidar explicitamente com a noção de um 'slave'. Terá de libertar um 'slave' para uma determinada ligação e então atribuir todas as tarefas que deverão ir pela mesma ligação ao mesmo 'slave'. Isto poderá ser conseguido facilmente com a utilização do KIO::Scheduler: </para>
+>. Por exemplo, no caso do 'slave' de IMAP, não faz nenhum sentido lançar vários processos para o mesmo servidor. Só uma ligação de IMAP de cada vez é que deverá ser permitida. Neste caso, a aplicação deverá lidar explicitamente com a noção de um 'slave'. Terá de libertar um 'slave' para uma determinada ligação e então atribuir todas as tarefas que deverão ir pela mesma ligação ao mesmo 'slave'. Isto poderá ser conseguido facilmente com a utilização do TDEIO::Scheduler: </para>
 
 <programlisting
 >KURL urlBase("imap://[email protected]");
-KIO::Slave *slave = KIO::Scheduler::getConnectedSlave(urlBase);
+TDEIO::Slave *slave = TDEIO::Scheduler::getConnectedSlave(urlBase);
 
-KIO::TransferJob *tarefa1 = KIO::get(KURL(urlBase, "/INBOX;UID=79374"));
-KIO::Scheduler::assignJobToSlave(slave, tarefa1);
+TDEIO::TransferJob *tarefa1 = TDEIO::get(KURL(urlBase, "/INBOX;UID=79374"));
+TDEIO::Scheduler::assignJobToSlave(slave, tarefa1);
 
-KIO::TransferJob *tarefa2 = KIO::get(KURL(urlBase, "/INBOX;UID=86793"));
-KIO::Scheduler::assignJobToSlave(slave, tarefa2);
+TDEIO::TransferJob *tarefa2 = TDEIO::get(KURL(urlBase, "/INBOX;UID=86793"));
+TDEIO::Scheduler::assignJobToSlave(slave, tarefa2);
 
 ...
 
-KIO::Scheduler::disconnectSlave(slave);
+TDEIO::Scheduler::disconnectSlave(slave);
 </programlisting>
 
 <para
@@ -3416,11 +3416,11 @@ int kdemain(int argc, char **argv)
 
 <para
 >Os 'slaves' são implementados como sub-classes da <classname
->KIO::SlaveBase</classname
+>TDEIO::SlaveBase</classname
 > (a FtpSlave no exemplo acima). Como tal, as acções listadas no ficheiro <literal
 >.protocol</literal
 > correspondem a certas funções virtuais no <classname
->KIO::SlaveBase</classname
+>TDEIO::SlaveBase</classname
 > que a implementação do 'slave' precisa de reimplementar. Aqui está uma lista das acções possíveis e das funções virtuais correspondentes: </para>
 
 <variablelist>
@@ -3541,9 +3541,9 @@ int kdemain(int argc, char **argv)
 >. Se ocorreu um erro, o <literal
 >error()</literal
 > deverá ser invocado com um código de erro como primeiro argumento e um texto no segundo. Os códigos de erro possíveis estão listados no tipo enumerado <type
->KIO::Error</type
+>TDEIO::Error</type
 >. O segundo argumento é normalmente o URL em questão. É usado, p.ex., no <function
->KIO::Job::showErrorDialog()</function
+>TDEIO::Job::showErrorDialog()</function
 > para parametrizar a mensagem de erro para o utilizador. </para>
 
 <para
@@ -3589,7 +3589,7 @@ int kdemain(int argc, char **argv)
 > devolve informações sobre os itens de uma directoria. Para esse fim, chame o <function
 >listEntries()</function
 > com um <classname
->KIO::UDSEntryList</classname
+>TDEIO::UDSEntryList</classname
 > como argumento. De forma análoga à do <function
 >data()</function
 >, você poderá invocá-lo várias vezes. Quando terminar, invoque o <function
@@ -3604,7 +3604,7 @@ int kdemain(int argc, char **argv)
 >O <function
 >stat()</function
 > devolve informações acerca de um ficheiro como o seu tamanho, o tipo MIME, etc. Essa informação está contida num <classname
->KIO::UDSEntry</classname
+>TDEIO::UDSEntry</classname
 >, o qual será discutido em baixo. Use o <function
 >statEntry()</function
 > para enviar um desses itens para a aplicação. </para
@@ -3660,7 +3660,7 @@ int kdemain(int argc, char **argv)
 ><function
 >infoMessage()</function
 > - Isto é para fins de informação, como a mensagem "A obter dados de &lt;máquina&gt;" do 'slave' de HTTP, o qual é mostrado normalmente na barra de estado do programa. Do lado da aplicação, este método corresponde ao 'signal' <function
->KIO::Job::infoMessage()</function
+>TDEIO::Job::infoMessage()</function
 >. </para
 ></listitem>