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-it/docs/tdevelop/kdearch/index.docbook | 124 ++++++++++++------------ 1 file changed, 62 insertions(+), 62 deletions(-) (limited to 'tde-i18n-it/docs/tdevelop') diff --git a/tde-i18n-it/docs/tdevelop/kdearch/index.docbook b/tde-i18n-it/docs/tdevelop/kdearch/index.docbook index 8d7a296cb80..b1dfa2c7f05 100644 --- a/tde-i18n-it/docs/tdevelop/kdearch/index.docbook +++ b/tde-i18n-it/docs/tdevelop/kdearch/index.docbook @@ -202,8 +202,8 @@ <ulink url="kdeapi:tdecore/KConfig" ->KConfig</ulink +><ulink url="kdeapi:tdecore/TDEConfig" +>TDEConfig</ulink > Fornisce accesso al database di configurazione di KDE. @@ -2681,7 +2681,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 << "Could not find out type" << endl; else @@ -2702,17 +2702,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 << "MIME type: " << ((KIO::MimetypeJob *)job)->mimetype() << endl; + cout << "MIME type: " << ((TDEIO::MimetypeJob *)job)->mimetype() << endl; } @@ -2867,19 +2867,19 @@ new KRun(url); >Usare KIO I job in molti casi sono creati chiamando le funzioni contenute nel namespace KIO. Esse ricevono uno o due URL come argomenti ed eventualmente altri parametri. Quando un job è concluso, emette il segnale result(KIO::Job*)I job in molti casi sono creati chiamando le funzioni contenute nel namespace TDEIO. Esse ricevono uno o due URL come argomenti ed eventualmente altri parametri. Quando un job è concluso, emette il segnale result(TDEIO::Job*). Dopo che questo segnale è stato emesso, il job si cancella. Quindi un caso d'uso tipico sarà simile a questo: 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(); @@ -2898,7 +2898,7 @@ void FooClass::mkdirResult(KIO::Job *job) KIO::mkdir(const KURL &url, int permission) +>TDEIO::mkdir(const KURL &url, int permission) Crea una directory, eventualmente con alcuni permessi. KIO::rmdir(const KURL &url) +>TDEIO::rmdir(const KURL &url) Rimuove una directory KIO::chmod(const KURL &url, int permissions) +>TDEIO::chmod(const KURL &url, int permissions) Cambia i permessi di un file. KIO::rename(const KURL &src, const KURL &dest, bool overwrite) +>TDEIO::rename(const KURL &src, const KURL &dest, bool overwrite) Rinomina un file. 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 collegamento simbolico. KIO::stat(const KURL &url, bool showProgressInfo) +>TDEIO::stat(const KURL &url, bool showProgressInfo) Cerca alcune informazioni sul file, come dimensione, data di modifica e permessi. L'informazione può essere ottenuta da KIO::StatJob::statResult() dopo che il job è concluso. Cerca alcune informazioni sul file, come dimensione, data di modifica e permessi. L'informazione può essere ottenuta da TDEIO::StatJob::statResult() dopo che il job è concluso. KIO::get(const KURL &url, bool reload, bool showProgressInfo) +>TDEIO::get(const KURL &url, bool reload, bool showProgressInfo) Trasferisce i dati da 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) Trasferisce i dati ad un URL KIO::http_post(const KURL &url, const QByteArray &data, bool showProgressInfo) +>TDEIO::http_post(const KURL &url, const QByteArray &data, bool showProgressInfo) Invia dati. Comando speciale per HTTP. KIO::mimetype(const KURL &url, bool showProgressInfo) +>TDEIO::mimetype(const KURL &url, bool showProgressInfo) Tenta di trovare il tipo MIME dell'URL. Il tipo può essere ottenuto con KIO::MimetypeJob::mimetype() al termine del job. Tenta di trovare il tipo MIME dell'URL. Il tipo può essere ottenuto con TDEIO::MimetypeJob::mimetype() al termine del job. 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 singolo file. 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) Rinomina o muove un singolo file. KIO::file_delete(const KURL &url, bool showProgressInfo) +>TDEIO::file_delete(const KURL &url, bool showProgressInfo) Cancella un singolo file. KIO::listDir(const KURL &url, bool showProgressInfo) +>TDEIO::listDir(const KURL &url, bool showProgressInfo) Elenca i contenuti di una directory. Ogni volta che vengono scoperti nuovi elementi viene emesso il segnale KIO::ListJob::entries(). Elenca i contenuti di una directory. Ogni volta che vengono scoperti nuovi elementi viene emesso il segnale TDEIO::ListJob::entries(). KIO::listRecursive(const KURL &url, bool showProgressInfo) +>TDEIO::listRecursive(const KURL &url, bool showProgressInfo) Simile alla funzione listDir(), ma questa è ricorsiva. KIO::copy(const KURL &src, const KURL &dest, bool showProgressInfo) +>TDEIO::copy(const KURL &src, const KURL &dest, bool showProgressInfo) Copia un file o una directory. Queste ultime vengono copiate ricorsivamente. KIO::move(const KURL &src, const KURL &dest, bool showProgressInfo) +>TDEIO::move(const KURL &src, const KURL &dest, bool showProgressInfo) Muove o rinomina un file o una directory. KIO::del(const KURL &src, bool shred, bool showProgressInfo) +>TDEIO::del(const KURL &src, bool shred, bool showProgressInfo) Cancella un file o una directory. Elementi di una directory I job di KIO::stat() e di KIO::listDir() restituiscono i loro risultati rispettivamente come tipi UDSEntry e USDEntryList. Quest'ultimo è definito come QValueList<UDSEntry>. L'acronimo UDS significa "Universal Directory Service". Il principio di base è che una voce della directory contiene le informazioni che possono essere fornite da uno slave, e nient'altro. Per esempio, lo slave http non fornisce nessuna informazione sui permessi di accesso o sui proprietari del file. Invece un UDSEntry è un elenco di UDSAtoms. Ogni atom fornisce una porzione specifica di informazione e consiste di un tipo memorizzato in m_uds e di un valore intero m_long o di una stringa m_str a seconda del tipo. +>I job di TDEIO::stat() e di TDEIO::listDir() restituiscono i loro risultati rispettivamente come tipi UDSEntry e USDEntryList. Quest'ultimo è definito come QValueList<UDSEntry>. L'acronimo UDS significa "Universal Directory Service". Il principio di base è che una voce della directory contiene le informazioni che possono essere fornite da uno slave, e nient'altro. Per esempio, lo slave http non fornisce nessuna informazione sui permessi di accesso o sui proprietari del file. Invece un UDSEntry è un elenco di UDSAtoms. Ogni atom fornisce una porzione specifica di informazione e consiste di un tipo memorizzato in m_uds e di un valore intero m_long o di una stringa m_str a seconda del tipo. Attualmente sono definiti i seguenti tipi: @@ -3161,13 +3161,13 @@ void FooClass::mkdirResult(KIO::Job *job) >Uso sincrono Spesso l'API asincrona di KIO è troppo complessa da usare e quindi l'implementazione asincrona non costituisce una priorità. Per esempio, in un programma che può gestire un solo documento alla volta c'è poco da fare quando un programma sta scaricando un file. Per questi semplici casi, esiste un'API molto più facile costituita da un insieme di funzioni statiche in KIO::NetAccess. Per esempio, per copiare un file si può usare +>Spesso l'API asincrona di KIO è troppo complessa da usare e quindi l'implementazione asincrona non costituisce una priorità. Per esempio, in un programma che può gestire un solo documento alla volta c'è poco da fare quando un programma sta scaricando un file. Per questi semplici casi, esiste un'API molto più facile costituita da un insieme di funzioni statiche in TDEIO::NetAccess. Per esempio, per copiare un file si può usare KURL source, target; source = ...; target = ... -KIO::NetAccess::copy(source, target); +TDEIO::NetAccess::copy(source, target); KURL url; url = ...; QString tempFile; -if (KIO::NetAccess::download(url, tempFile) { +if (TDEIO::NetAccess::download(url, tempFile) { // load the file with the name tempFile - KIO::NetAccess::removeTempFile(tempFile); + TDEIO::NetAccess::removeTempFile(tempFile); } @@ -3208,7 +3208,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"); ... } @@ -3225,18 +3225,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 << "Last modified: " << modified << endl; } @@ -3267,28 +3267,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); Una terza possibilità è quella orientata alla connessione. Per esempio, per lo slave IMAP non ha senso avviare processi multipli per lo stesso server. Dovrebbe essere rinforzata solo una connessione IMAP alla volta. In questo caso l'applicazione deve occuparsi direttamente con la nozione di slave. Deve deallocare uno slave per alcune connessioni e in seguito assegnare tutti i job che dovrebbero utilizzare la stessa connessione allo stesso slave. Questo può essere fatto semplicemente usando KIO::Scheduler: +>. Per esempio, per lo slave IMAP non ha senso avviare processi multipli per lo stesso server. Dovrebbe essere rinforzata solo una connessione IMAP alla volta. In questo caso l'applicazione deve occuparsi direttamente con la nozione di slave. Deve deallocare uno slave per alcune connessioni e in seguito assegnare tutti i job che dovrebbero utilizzare la stessa connessione allo stesso slave. Questo può essere fatto semplicemente 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); Gli slave sono implementati come sottoclassi di KIO::SlaveBaseTDEIO::SlaveBase (nell'esempio sopra FtpSlave). Quindi le azioni elencate nel file .protocol corrispondono ad alcune funzioni virtuali di KIO::SlaveBaseTDEIO::SlaveBase che devono essere reimplementate dall'implementazione dello slave. Ecco una lista di azioni possibili e le funzioni virtuali corrispondenti: @@ -3508,9 +3508,9 @@ int kdemain(int argc, char **argv) >. Se accade un errore, dovrebbe essere chiamata la funzione error() con un codice di errore come primo argomento e una stringa come secondo. I codici di errore possibili sono elencati come enumerazioni di KIO::ErrorTDEIO::Error. Il secondo argomento è normalmente l'URL in questione. È usato ad esempio nella funzione KIO::Job::showErrorDialog()TDEIO::Job::showErrorDialog() per parametrizzare il messaggio di errore in forma leggibile. riporta le informazioni sugli elementi di una directory. Per questo scopo chiama listEntries() con un argomento di tipo KIO::UDSEntryListTDEIO::UDSEntryList. Analogamente alla funzione data() può essere chiamata diverse volte. Quando termina, chiamare stat() riferisce le informazioni su un file come la dimensione, il tipo MIME, ecc. Tali informazioni sono impacchettate in un KIO::UDSEntryTDEIO::UDSEntry che sarà discusso più avanti. Usare statEntry() per inviare un tale oggetto all'applicazione. infoMessage() - usato per avere un feedback, come ad esempio per un messaggio del tipo "Scaricamento dati dall'<host>" dallo slave http, che viene visualizzato spesso nella barra di stato dei programmi. Dalla parte dell'applicazione questo metodo corrisponde al segnale KIO::Job::infoMessage()TDEIO::Job::infoMessage(). -- cgit v1.2.3