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-es/docs/tdevelop/kdearch/index.docbook | 122 ++++++++++++------------ 1 file changed, 61 insertions(+), 61 deletions(-) (limited to 'tde-i18n-es/docs/tdevelop/kdearch/index.docbook') diff --git a/tde-i18n-es/docs/tdevelop/kdearch/index.docbook b/tde-i18n-es/docs/tdevelop/kdearch/index.docbook index 283f0ccf455..c4b1116a9f7 100644 --- a/tde-i18n-es/docs/tdevelop/kdearch/index.docbook +++ b/tde-i18n-es/docs/tdevelop/kdearch/index.docbook @@ -202,8 +202,8 @@ <ulink url="kdeapi:tdecore/KConfig" ->KConfig</ulink +><ulink url="kdeapi:tdecore/TDEConfig" +>TDEConfig</ulink > Proporciona acceso a la base de datos de configuración de KDE. @@ -2687,7 +2687,7 @@ else KURL url("http://developer.kde.org/favicon.ico"); -QString type = KIO::NetAccess::mimetype(url); +QString type = TDEIO::NetAccess::mimetype(url); if (type == KMimeType::defaultMimeType()) cout << "No se puede encontrar el tipo" << endl; else @@ -2708,17 +2708,17 @@ else >void FooClass::findType() { KURL url("http://developer.kde.org/favicon.ico"); - KIO::MimetypeJob *job = KIO::mimetype(url); - connect( job, SIGNAL(result(KIO::Job*)), - this, SLOT(mimeResult(KIO::Job*)) ); + TDEIO::MimetypeJob *job = TDEIO::mimetype(url); + connect( job, SIGNAL(result(TDEIO::Job*)), + this, SLOT(mimeResult(TDEIO::Job*)) ); } -void FooClass::mimeResult(KIO::Job *job) +void FooClass::mimeResult(TDEIO::Job *job) { if (job->error()) job->showErrorDialog(); else - cout << "Tipo MIME: " << ((KIO::MimetypeJob *)job)->mimetype() << endl; + cout << "Tipo MIME: " << ((TDEIO::MimetypeJob *)job)->mimetype() << endl; } @@ -2874,18 +2874,18 @@ new KRun(url); En muchos casos, las tareas se crean llamando a funciones del nombre de espacios KIO. Estas funciones tienen una o dos URL como argumento, además de otros parámetros posiblemente necesarios. Cuando la tarea termina, emite la señal result(KIO::Job*)result(TDEIO::Job*). Tras emitir esta señal, la tarea se borra a sí misma. De este modo, un caso de uso típico podría ser: void FooClass::makeDirectory() { - SimpleJob *job = KIO::mkdir(KURL("file:/home/bernd/kiodir")); - connect( job, SIGNAL(result(KIO::Job*)), - this, SLOT(mkdirResult(KIO::Job*)) ); + SimpleJob *job = TDEIO::mkdir(KURL("file:/home/bernd/kiodir")); + connect( job, SIGNAL(result(TDEIO::Job*)), + this, SLOT(mkdirResult(TDEIO::Job*)) ); } -void FooClass::mkdirResult(KIO::Job *job) +void FooClass::mkdirResult(TDEIO::Job *job) { if (job->error()) job->showErrorDialog(); @@ -2904,7 +2904,7 @@ void FooClass::mkdirResult(KIO::Job *job) KIO::mkdir(const KURL &url, int permission) +>TDEIO::mkdir(const KURL &url, int permission) Crea un directorio, opcionalmente con ciertos permisos. KIO::rmdir(const KURL &url) +>TDEIO::rmdir(const KURL &url) Elimina un directorio. KIO::chmod(const KURL &url, int permissions) +>TDEIO::chmod(const KURL &url, int permissions) Cambia los permisos de un archivo. KIO::rename(const KURL &src, const KURL &dest, bool overwrite) +>TDEIO::rename(const KURL &src, const KURL &dest, bool overwrite) Renombra un archivo. KIO::symlink(const QString &target, const KURL &dest, bool overwrite, bool showProgressInfo) +>TDEIO::symlink(const QString &target, const KURL &dest, bool overwrite, bool showProgressInfo) Crea un enlace simbólico. KIO::stat(const KURL &url, bool showProgressInfo) +>TDEIO::stat(const KURL &url, bool showProgressInfo) Obtiene cierta información sobre el archivo, como su tamaño, hora de modificación y permisos. La información puede obtenerse de KIO::StatJob::statResult() una vez que el trabajo haya finalizado. Obtiene cierta información sobre el archivo, como su tamaño, hora de modificación y permisos. La información puede obtenerse de TDEIO::StatJob::statResult() una vez que el trabajo haya finalizado. KIO::get(const KURL &url, bool reload, bool showProgressInfo) +>TDEIO::get(const KURL &url, bool reload, bool showProgressInfo) Transfiere datos desde un URL. KIO::put(const KURL &url, int permissions, bool overwrite, bool resume, bool showProgressInfo) +>TDEIO::put(const KURL &url, int permissions, bool overwrite, bool resume, bool showProgressInfo) Transfiere datos a un URL. KIO::http_post(const KURL &url, const QByteArray &data, bool showProgressInfo) +>TDEIO::http_post(const KURL &url, const QByteArray &data, bool showProgressInfo) Envía datos. Específica de HTTP. KIO::mimetype(const KURL &url, bool showProgressInfo) +>TDEIO::mimetype(const KURL &url, bool showProgressInfo) Intenta encontrar el tipo MIME de un URL. El tipo se puede obtener de KIO::MimetypeJob::mimetype() una vez que el trabajo haya finalizado. Intenta encontrar el tipo MIME de un URL. El tipo se puede obtener de TDEIO::MimetypeJob::mimetype() una vez que el trabajo haya finalizado. KIO::file_copy(const KURL &src, const KURL &dest, int permissions, bool overwrite, bool resume, bool showProgressInfo) +>TDEIO::file_copy(const KURL &src, const KURL &dest, int permissions, bool overwrite, bool resume, bool showProgressInfo) Copia un único archivo. KIO::file_move(const KURL &src, const KURL &dest, int permissions, bool overwrite, bool resume, bool showProgressInfo) +>TDEIO::file_move(const KURL &src, const KURL &dest, int permissions, bool overwrite, bool resume, bool showProgressInfo) Renombra o mueve un único archivo. KIO::file_delete(const KURL &url, bool showProgressInfo) +>TDEIO::file_delete(const KURL &url, bool showProgressInfo) Elimina un único archivo. KIO::listDir(const KURL &url, bool showProgressInfo) +>TDEIO::listDir(const KURL &url, bool showProgressInfo) Lista el contenido de un directorio. Cada vez que se conozcan nuevas entradas será emitida la señal KIO::ListJob::entries(). Lista el contenido de un directorio. Cada vez que se conozcan nuevas entradas será emitida la señal TDEIO::ListJob::entries(). KIO::listRecursive(const KURL &url, bool showProgressInfo) +>TDEIO::listRecursive(const KURL &url, bool showProgressInfo) Similar a la función listDir(), aunque esta es recursiva. KIO::copy(const KURL &src, const KURL &dest, bool showProgressInfo) +>TDEIO::copy(const KURL &src, const KURL &dest, bool showProgressInfo) Copia un archivo o un directorio. Los directorios se copian recursivamente. KIO::move(const KURL &src, const KURL &dest, bool showProgressInfo) +>TDEIO::move(const KURL &src, const KURL &dest, bool showProgressInfo) Mueve o renombra un archivo o un directorio. KIO::del(const KURL &src, bool shred, bool showProgressInfo) +>TDEIO::del(const KURL &src, bool shred, bool showProgressInfo) Elimina un archivo o un directorio. Entradas de directorio La tarea KIO::stat() y la tarea KIO::listDir() devuelven un resultado de tipo UDSEntry y UDSEntryList, respectivamente. Esta última está definida como QValueList<UDSEntry>. El acrónimo de UDS significa «servicio de directorio universal», en inglés. El principio subyacente consiste en que una entrada de directorio solo contiene la información que puede proporcionar un «ioslave», pero no más. Por ejemplo, el esclavo http no proporciona ninguna información sobre permisos de acceso o propietarios del archivo. En lugar de ello, una USDEntry consiste en una lista de UDSAtoms, cada uno de los cuales proporciona una pieza de información específica (que consiste en un tipo almacenado en «m_uds», y en un valor entero en «m_long» o en una cadena de texto en «m_str», dependiendo del tipo). +>La tarea TDEIO::stat() y la tarea TDEIO::listDir() devuelven un resultado de tipo UDSEntry y UDSEntryList, respectivamente. Esta última está definida como QValueList<UDSEntry>. El acrónimo de UDS significa «servicio de directorio universal», en inglés. El principio subyacente consiste en que una entrada de directorio solo contiene la información que puede proporcionar un «ioslave», pero no más. Por ejemplo, el esclavo http no proporciona ninguna información sobre permisos de acceso o propietarios del archivo. En lugar de ello, una USDEntry consiste en una lista de UDSAtoms, cada uno de los cuales proporciona una pieza de información específica (que consiste en un tipo almacenado en «m_uds», y en un valor entero en «m_long» o en una cadena de texto en «m_str», dependiendo del tipo). Actualmente están definidos los siguientes tipos: @@ -3167,13 +3167,13 @@ void FooClass::mkdirResult(KIO::Job *job) >Utilización síncrona A menudo, la API asíncrona de KIO resulta demasiado compleja de usar, por lo que la implementación de asincronismo total no es una prioridad. Por ejemplo, en un programa que solo puede manejar un archivo de documento a la vez, realmente hay pocas cosas que se puedan hacer mientras el programa descarga el archivo. Para estos casos simples, existe una API mucho más simple bajo la forma de funciones estáticas en KIO::NetAccess. Por ejemplo, para copiar un archivo, utilice +>A menudo, la API asíncrona de KIO resulta demasiado compleja de usar, por lo que la implementación de asincronismo total no es una prioridad. Por ejemplo, en un programa que solo puede manejar un archivo de documento a la vez, realmente hay pocas cosas que se puedan hacer mientras el programa descarga el archivo. Para estos casos simples, existe una API mucho más simple bajo la forma de funciones estáticas en TDEIO::NetAccess. Por ejemplo, para copiar un archivo, utilice KURL origen, destino; origen = ...; destino = ... -KIO::NetAccess::copy(origen, destino); +TDEIO::NetAccess::copy(origen, destino); KURL url; url = ...; QString tempFile; -if (KIO::NetAccess::download(url, tempFile) { +if (TDEIO::NetAccess::download(url, tempFile) { // cargar el archivo de nombre tempFile - KIO::NetAccess::removeTempFile(tempFile); + TDEIO::NetAccess::removeTempFile(tempFile); } @@ -3214,7 +3214,7 @@ if (KIO::NetAccess::download(url, tempFile) { >void FooClass::reloadPage() { KURL url("http://www.tdevelop.org/index.html"); - KIO::TransferJob *job = KIO::get(url, true, false); + TDEIO::TransferJob *job = TDEIO::get(url, true, false); job->addMetaData("cache", "reload"); ... } @@ -3231,18 +3231,18 @@ if (KIO::NetAccess::download(url, tempFile) { >void FooClass::printModifiedDate() { KURL url("http://developer.kde.org/documentation/kde2arch/index.html"); - KIO::TransferJob *job = KIO::get(url, true, false); - connect( job, SIGNAL(result(KIO::Job*)), - this, SLOT(transferResult(KIO::Job*)) ); + TDEIO::TransferJob *job = TDEIO::get(url, true, false); + connect( job, SIGNAL(result(TDEIO::Job*)), + this, SLOT(transferResult(TDEIO::Job*)) ); } -void FooClass::transferResult(KIO::Job *job) +void FooClass::transferResult(TDEIO::Job *job) { QString mimetype; if (job->error()) job->showErrorDialog(); else { - KIO::TransferJob *transferJob = (KIO::TransferJob*) job; + TDEIO::TransferJob *transferJob = (TDEIO::TransferJob*) job; QString modified = transferJob->queryMetaData("modified"); cout << "Última modificación: " << modified << endl; } @@ -3273,28 +3273,28 @@ void FooClass::transferResult(KIO::Job *job) KURL url("http://developer.kde.org/documentation/kde2arch/index.html"); -KIO::TransferJob *job = KIO::get(url, true, false); -KIO::Scheduler::scheduleJob(job); +TDEIO::TransferJob *job = TDEIO::get(url, true, false); +TDEIO::Scheduler::scheduleJob(job); Existe una tercera posibilidad orientada a conexiones. Por ejemplo, para el esclavo IMAP, no tiene sentido iniciar múltiples procesos para el mismo servidor: solo se debe forzar una conexión IMAP a la vez. En este caso, la aplicación debe tratar explícitamente con la noción de esclavo. Debe desasignar un esclavo de cierta conexión y luego asignar todas las tareas que pueda realizar la misma conexión con el mismo esclavo. De nuevo, esto se puede conseguir fácilmente usando KIO::Scheduler: +>. Por ejemplo, para el esclavo IMAP, no tiene sentido iniciar múltiples procesos para el mismo servidor: solo se debe forzar una conexión IMAP a la vez. En este caso, la aplicación debe tratar explícitamente con la noción de esclavo. Debe desasignar un esclavo de cierta conexión y luego asignar todas las tareas que pueda realizar la misma conexión con el mismo esclavo. De nuevo, esto se puede conseguir fácilmente usando TDEIO::Scheduler: KURL baseUrl("imap://bernd@albert.physik.hu-berlin.de"); -KIO::Slave *slave = KIO::Scheduler::getConnectedSlave(baseUrl); +TDEIO::Slave *slave = TDEIO::Scheduler::getConnectedSlave(baseUrl); -KIO::TransferJob *job1 = KIO::get(KURL(baseUrl, "/INBOX;UID=79374")); -KIO::Scheduler::assignJobToSlave(slave, job1); +TDEIO::TransferJob *job1 = TDEIO::get(KURL(baseUrl, "/INBOX;UID=79374")); +TDEIO::Scheduler::assignJobToSlave(slave, job1); -KIO::TransferJob *job2 = KIO::get(KURL(baseUrl, "/INBOX;UID=86793")); -KIO::Scheduler::assignJobToSlave(slave, job2); +TDEIO::TransferJob *job2 = TDEIO::get(KURL(baseUrl, "/INBOX;UID=86793")); +TDEIO::Scheduler::assignJobToSlave(slave, job2); ... -KIO::Scheduler::disconnectSlave(slave); +TDEIO::Scheduler::disconnectSlave(slave); Los esclavos se implementan como subclases de KIO::SlaveBaseTDEIO::SlaveBase (FtpSlave en el ejemplo anterior). De este modo, las acciones que se listan en el archivo .protocol corresponden a ciertas funciones virtuales de KIO::SlaveBaseTDEIO::SlaveBase que la implementación del esclavo debe reimplementar. Estas son algunas de las posibles acciones y sus correspondientes funciones virtuales: @@ -3514,9 +3514,9 @@ int kdemain(int argc, char **argv) >; si ocurrió un error, error() debería ser llamada con un código de error como primer argumento y una cadena de texto como segundo. Los códigos de error posibles se listan como enumeraciones de tipo KIO::ErrorTDEIO::Error. El segundo argumento suele ser la URL en cuestión. Se usa, por ejemplo, en la función KIO::Kob::showErrorDialgog()TDEIO::Kob::showErrorDialgog() para parametizar el mensaje de error legible por el usuario. devuelve información sobre las entradas de un directorio. Para este propósito, llame a listEntries() con una KIO::UDSEntryListTDEIO::UDSEntryList como argumento. Del mismo modo que ocurría con data(), puede llamar a esta función varias veces. Cuando haya terminado, llame a stat() devuelve información sobre el archivo, como su tamaño, tipo MIME, etc. Esta información está empaquetada en una KIO::UDSEntryTDEIO::UDSEntry, que se describirá más adelante. Use statEntry() para enviar este tipo de elementos a la aplicación. infoMessage() - Se usa para propósitos informativos, tales como el mensaje «Obteniendo datos de <host>» del esclavo http, que se muestra a menudo en la barra de estado del programa. En el lado de la aplicación, este método se corresponde a la señal KIO::Job::infoMessage()TDEIO::Job::infoMessage(). -- cgit v1.2.1