From 542a9e5e840b905c97d21bc5b83bda95a4a71582 Mon Sep 17 00:00:00 2001 From: Timothy Pearson Date: Fri, 25 Jan 2013 00:27:31 -0600 Subject: Rename KCModule, KConfig, KIO, KServer, and KSocket to avoid conflicts with KDE4 --- tde-i18n-pt/docs/tdevelop/kdearch/index.docbook | 122 ++++++++++++------------ 1 file changed, 61 insertions(+), 61 deletions(-) (limited to 'tde-i18n-pt/docs/tdevelop') 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 @@ <ulink url="kdeapi:tdecore/KConfig" ->KConfig</ulink +><ulink url="kdeapi:tdecore/TDEConfig" +>TDEConfig</ulink > Fornece o acesso à base de dados de configuração do KDE. @@ -2714,7 +2714,7 @@ else 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 << "Não foi possível descobrir o tipo" << 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 << "Tipo MIME: " << ((KIO::MimetypeJob *)tarefa)->mimetype() << endl; + cout << "Tipo MIME: " << ((TDEIO::MimetypeJob *)tarefa)->mimetype() << endl; } @@ -2901,18 +2901,18 @@ new KRun(url); 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' result(KIO::Job*)result(TDEIO::Job*). 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: 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) KIO::mkdir(const KURL &url, int permissao) +>TDEIO::mkdir(const KURL &url, int permissao) Criar uma directoria, com algumas permissões opcionais. KIO::rmdir(const KURL &url) +>TDEIO::rmdir(const KURL &url) Remove uma directoria. KIO::chmod(const KURL &url, int permissoes) +>TDEIO::chmod(const KURL &url, int permissoes) Muda as permissões de um ficheiro. KIO::rename(const KURL &origem, const KURL &destino, bool sobrepor) +>TDEIO::rename(const KURL &origem, const KURL &destino, bool sobrepor) Muda o nome de um ficheiro. KIO::symlink(const QString &alvo, const KURL &destino, bool sobrepor, bool mostrarProgresso) +>TDEIO::symlink(const QString &alvo, const KURL &destino, bool sobrepor, bool mostrarProgresso) Cria uma ligação simbólica. KIO::stat(const KURL &url, bool mostrarProgresso) +>TDEIO::stat(const KURL &url, bool mostrarProgresso) 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. 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. KIO::get(const KURL &url, bool reler, bool mostrarProgresso) +>TDEIO::get(const KURL &url, bool reler, bool mostrarProgresso) Transfere os dados de um dado URL. KIO::put(const KURL &url, int permissoes, bool sobrepor, bool continuar, bool mostrarProgresso) +>TDEIO::put(const KURL &url, int permissoes, bool sobrepor, bool continuar, bool mostrarProgresso) Transfere os dados para um dado URL. KIO::http_post(const KURL &url, const QByteArray &dados, bool mostrarProgresso) +>TDEIO::http_post(const KURL &url, const QByteArray &dados, bool mostrarProgresso) Envia os dados. É específico do HTTP. KIO::mimetype(const KURL &url, bool mostrarProgresso) +>TDEIO::mimetype(const KURL &url, bool mostrarProgresso) Tenta descobrir o tipo MIME do URL. O tipo poderá ser obtido a partir do KIO::MimetypeJob::mimetype() depois de a tarefa terminar. Tenta descobrir o tipo MIME do URL. O tipo poderá ser obtido a partir do TDEIO::MimetypeJob::mimetype() depois de a tarefa terminar. KIO::file_copy(const KURL &origem, const KURL &destino, int permissoes, bool sobrepor, bool continuar, bool mostrarProgresso) +>TDEIO::file_copy(const KURL &origem, const KURL &destino, int permissoes, bool sobrepor, bool continuar, bool mostrarProgresso) Copia um único ficheiro. KIO::file_move(const KURL &origem, const KURL &destino, int permissoes, bool sobrepor, bool continuar, bool mostrarProgresso) +>TDEIO::file_move(const KURL &origem, const KURL &destino, int permissoes, bool sobrepor, bool continuar, bool mostrarProgresso) Muda o nome ou move um único ficheiro. KIO::file_delete(const KURL &url, bool mostrarProgresso) +>TDEIO::file_delete(const KURL &url, bool mostrarProgresso) Apaga um único ficheiro. KIO::listDir(const KURL &url, bool mostrarProgresso) +>TDEIO::listDir(const KURL &url, bool mostrarProgresso) Lista o conteúdo de uma dada directoria. De cada vez que alguns itens passam a ser conhecidos, o 'signal' KIO::ListJob::entries() é emitido. Lista o conteúdo de uma dada directoria. De cada vez que alguns itens passam a ser conhecidos, o 'signal' TDEIO::ListJob::entries() é emitido. KIO::listRecursive(const KURL &url, bool mostrarProgresso) +>TDEIO::listRecursive(const KURL &url, bool mostrarProgresso) Semelhante à função listDir(), só que esta função é recursiva. KIO::copy(const KURL &origem, const KURL &destino, bool mostrarProgresso) +>TDEIO::copy(const KURL &origem, const KURL &destino, bool mostrarProgresso) Copia um ficheiro ou directoria. As directorias são copiadas de forma recursiva. KIO::move(const KURL &origem, const KURL &destino, bool mostrarProgresso) +>TDEIO::move(const KURL &origem, const KURL &destino, bool mostrarProgresso) Move ou muda o nome de um ficheiro ou directoria. KIO::del(const KURL &src, bool shred, bool showProgressInfo) +>TDEIO::del(const KURL &src, bool shred, bool showProgressInfo) Apaga um ficheiro ou directoria. Itens da directoria 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<UDSEntry>. 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. +>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<UDSEntry>. 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. Os seguintes tipos estão actualmente definidos: @@ -3194,13 +3194,13 @@ void ClasseXpto::resultadoMkdir(KIO::Job *tarefa) >Utilização síncrona 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 +>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 KURL origem, destino; source = ...; target = ... -KIO::NetAccess::copy(origem, destino); +TDEIO::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); } @@ -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 << "Última modificação: " << modificado << endl; } @@ -3300,28 +3300,28 @@ void ClasseXpto::transferirResultado(KIO::Job *tarefa) 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); Uma terceira possibilidade é orientar à ligação. 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: +>. 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: KURL urlBase("imap://bernd@albert.physik.hu-berlin.de"); -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); Os 'slaves' são implementados como sub-classes da KIO::SlaveBaseTDEIO::SlaveBase (a FtpSlave no exemplo acima). Como tal, as acções listadas no ficheiro .protocol correspondem a certas funções virtuais no KIO::SlaveBaseTDEIO::SlaveBase que a implementação do 'slave' precisa de reimplementar. Aqui está uma lista das acções possíveis e das funções virtuais correspondentes: @@ -3541,9 +3541,9 @@ int kdemain(int argc, char **argv) >. Se ocorreu um erro, o error() 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 KIO::ErrorTDEIO::Error. O segundo argumento é normalmente o URL em questão. É usado, p.ex., no KIO::Job::showErrorDialog()TDEIO::Job::showErrorDialog() para parametrizar a mensagem de erro para o utilizador. devolve informações sobre os itens de uma directoria. Para esse fim, chame o listEntries() com um KIO::UDSEntryListTDEIO::UDSEntryList como argumento. De forma análoga à do data(), você poderá invocá-lo várias vezes. Quando terminar, invoque o O stat() devolve informações acerca de um ficheiro como o seu tamanho, o tipo MIME, etc. Essa informação está contida num KIO::UDSEntryTDEIO::UDSEntry, o qual será discutido em baixo. Use o statEntry() para enviar um desses itens para a aplicação. infoMessage() - Isto é para fins de informação, como a mensagem "A obter dados de <máquina>" 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' KIO::Job::infoMessage()TDEIO::Job::infoMessage(). -- cgit v1.2.1