KDE pro programátory – KIO a jeho otroci

3. 3. 2011 | Dan Vrátil | Programování | 11819×

KIO je technologie, která v KDE zahrnuje téměř všechno kolem vstupně-výstupních operací a poskytuje abstrakci pro přístup ke vzdáleným úložištím. Samotnou komunikaci s úložišti pak zajišťují procesy zvané KIO Slaves.

Obsah

• KIO Jobs
• KIO Slaves
• Závěr

KIO je technologie, která zajišťuje téměř vše okolo vstupně-výstupních operací v KDE. V rámcí API sdružuje vše, co se týká práce se soubory, či adresáři. Jmenný prostor KIO ale zapouzdřuje i třídy pro práci s SSL, záložkami, různé dialogy a další.

Nad lokálním souborovým systémem umí vytvořit další virtuální vrstvu, do které se připojí i vzdálená uložiště tak, že je můžete procházet jako lokální. Nemusí se samozřejmě vždy jednat o vzdálené úložiště, díky KIO můžete procházet i archivy, manuálové stránky atd. Samotný přístup ke uložištím pak zajišťují speciální procesy, tzv. KIO Slaves.

KIO Jobs

KIO Jobs jsou nástroje určené pro kopírování, přesouvání a mazání souborů či adresářů a dokáží vcelku usnadnit práci se soubory. Nemusíte se starat vůbec o nic, stačí předat KUrl zdrojového a cílového souboru či adresáře, připojit se na signály a pak už sledovat průběh operace.

#include <KIO/CopyJob>
#include <KUrl>
...
...

KUrl source("/home/dan/Music");
KUrl destination("/mnt/backups");
KUrl link("/home/dan/Hudba");

// Zkopiruje slozku /home/dan/Music do /mnt/backups
KIO::CopyJob *copyJob = KIO::copy(source, destination, HideProgressInfo | Overwrite);
// Presune slozku /home/dan/Music do /mnt/backups
KIO::CopyJob *moveJob = KIO::move(source, destination, HideProgressInfo | Overwrite);
// Vytvori symlink z /home/dan/Music do /home/dan/Hudba
KIO::CopyJob *linkJob = KIO::link(source, link, HideProgressInfo);

Příznak HideProgressInfo skryje grafické zobrazení průběhu (tzn. že kopírování se neobjeví v notifikacích v systémové části panelu). S příznakem Overwrite kopírování neselže, pokud adresář nebo soubor existují.

KIO::CopyJob pak disponuje mnoha sloty a signály, přes které je možné ovlivňovat a sledovat průběh. Pro sledování jsou zajímavé signály totalFiles() a totalDirs(), které jsou vyvolány, když proces spočítá, kolik souborů a adresářů se bude zpracovávat. Signály processedFiles() a processedDirs() průběžně informují o počtu zpracovaných souborů, respektive adresářů. processedSize() informuje o velikosti přenesených dat v bajtech. Pokud chcete zobrazovat, jak se jmenuje aktuálně kopírovaný soubor, můžete poslouchat signál copying(). Signál je vyvolán každých 200ms, aby nedocházelo ke zbytečnému zpomalování procesu. Existují také analogické signály moving() a linking(). U KIO::link() se vytvoří buď klasický unixový symlink, nebo, pokud source a destination používají jiné protokoly nebo jsou vzdálené, se vytvoří .desktop odkaz. Když je celý Job hotový, emituje se signál result().

Pomocí metod doSuspend(), doResume() a doKill() můžete proces pozastavit, znovu spustit a nebo úplně zrušit. U prvních dvou metod je vyvolán signál suspended(), respektive resumed().

Pro ukázku v praxi vytvoříme jednoduchý program pro kopírování a přesouvání adresářů.

...
...
void MainWindow::copyDir()
{
    KFileItem src_item = src_model->itemForIndex(src_treeView->currentIndex());
    KFileItem dest_item = dest_model->itemForIndex(dest_treeView->currentIndex());

    ...
    ...
  
    if (sender() == copy_btn)
      current_job = KIO::copy(src_item.url(), dest_item.url(), KIO::HideProgressInfo);
    else
      current_job = KIO::move(src_item.url(), dest_item.url(), KIO::HideProgressInfo);

    // Informuje o celkovem poctu souboru, adresaru a bajtu, ktere se budou prenaset
    connect(current_job, SIGNAL(totalAmount(KJob*, KJob::Unit, qulonglong)),
	    this, SLOT(setTotalAmount(KJob*, KJob::Unit, qulonglong)));

    // Informuje o jiz prenesenem mnozstvi souboru, adresaru a bajtu
    connect(current_job, SIGNAL(processedAmount(KJob*, KJob::Unit, qulonglong)),
	    this, SLOT(setProcessedAmount(KJob*, KJob::Unit, qulonglong)));

    // Informuje o prave prenasenem souboru
    connect(current_job, SIGNAL(copying(KIO::Job*, KUrl, KUrl)),
	    this, SLOT(setCurrentFile(KIO::Job*, KUrl, KUrl)));

    // Informuje o procentualnim progresu
    connect(current_job, SIGNAL(percent(KJob*, ulong)),
	    this, SLOT(setPercent(KJob*, ulong)));

    // Informuje, ze prenos byl dokoncen
    connect(current_job, SIGNAL(finished(KJob*)),
	    this, SLOT(jobFinished(KJob*)));

    // Informuje, ze prenos byl pozastaven
    connect(current_job, SIGNAL(suspended(KJob*)),
	    this, SLOT(setProcessSuspended(KJob*)));

    // Informuje, ze prenos byl znovu spusten
    connect(current_job, SIGNAL(resumed(KJob*)),
	    this, SLOT(setProcessResumed(KJob*)));

    // Informuje o aktualni rychlosti prenosu (v bajtech za sekundu)
    connect(current_job, SIGNAL(speed(KJob*, ulong)),
	    this, SLOT(setSpeed(KJob*, ulong)));

    // Pri kliknuti na suspend_btn pozatavi prenos
    connect(suspend_btn, SIGNAL(clicked(bool)),
	    current_job, SLOT(suspend()));

    // Pri kliknuti na kill_btn zrusi prenos
    connect(kill_btn, SIGNAL(clicked(bool)),
	    current_job, SLOT(kill()));
    
    processed_dirs = 0;
    processed_files = 0;
    ...
    ...
    // Zobrazi dalsi prvky UI
    progress_bar->setVisible(true);
    progress_label->setVisible(true);
    suspend_btn->setVisible(true);
    kill_btn->setVisible(true);
    disableUI(true);
    
    // Nastavi titulek
    status = "Running";
}
...
...

V copyDir() vytvoříme nový KIO::CopyJob a napojíme se na některého jeho signály. Protože nás zajímá počet celkových a zpracovaných souborů, adresářů i bajtů (tedy všechno), použijeme místo signálů a slotů pro jednotlivé hodnoty trochu univerzálnější přístup: totalAmount() a processedAmount(). Druhým parametrem těchto signálů je výčtový typ KJob::Unit, který určuje, jaká hodnota se předává ve třetím parametru.

...
...
void MainWindow::setTotalAmount(KJob* job, KJob::Unit unit, qulonglong amount)
{
    switch (unit)
    {
      case KJob::Bytes:
	total_size = amount;
	break;
	
      case KJob::Files:
	total_files = amount;
	break;
	
      case KJob::Directories:
	total_dirs = amount;
	break;
    }

    updateUI();

    Q_UNUSED(job)
}

void MainWindow::setProcessedAmount(KJob* job, KJob::Unit unit, qulonglong amount)
{
    switch (unit)
    {
      case KJob::Bytes:
	processed_size = amount;
	break;
	
      case KJob::Files:
	processed_files = amount;
	break;
	
      case KJob::Directories:
	processed_dirs = amount;
	break;
    }

    updateUI();
    
    Q_UNUSED(job)
}
...
...

Obdobně můžete sbírat i další informace jako rychlost přenosu, aktuálně přenášený soubor nebo průběh přenosu v procentech:

...
...
void MainWindow::setCurrentFile(KIO::Job* job, KUrl src, KUrl dest)
{
    current_src = src;
    current_dest = dest;
    updateUI();
    
    Q_UNUSED(job)
}

void MainWindow::setSpeed(KJob* job, ulong speed)
{
    current_speed = speed;
    updateUI();
    
    Q_UNUSED(job)
}

void MainWindow::setPercent(KJob* job, ulong percentage)
{
    current_percentage = percentage;
    updateUI();
    
    Q_UNUSED(job);
}
...
...
void MainWindow::updateUI()
{

    progress_bar->setValue(current_percentage);
    
    QString str;
    
    str = "
%1

Files: %2 of %3
Dirs: %4 of %5
Size: %6 of %7 MiB
Speed: %8 MiB/s
%9 -> %10";
    str = str.arg(status, 
		  QString::number(processed_files), QString::number(total_files), 
		  QString::number(processed_dirs), QString::number(total_dirs),
		  QString::number(processed_size/1048576), QString::number(total_size/1048576), 
		  QString::number(current_speed/1048576)).arg(
		  current_src.path(), current_dest.path());
  
    progress_label->setText(str);
}

Metodou updateUI() už jen aktualizujeme uživatelské rozhraní.

Pokud proces během kopírování nebo přesunu narazí na existující složku nebo adresář, zeptá se klasickým KDE dialogem na další akci (přepsat, ignorovat, ...), stejně tak pokud se mu nepodaří přečíst nebo zapsat nějaký soubor. Všechny dialogy a okna jsou řešeny automaticky. Toto chování lze potlačít nastavením vlastností pomocí metod setAutoSkip(), setDefaultPermissions(), setWriteIntoExistingDirectories() nebo příznakem Overwrite v konstruktoru KIO::Job.

Mimo KIO::CopyJob existuje ještě například KIO::PreviewJob, který pro soubor zadaný v konstruktoru vygeneruje náhled se o zadaných rozměrech a vrátí ho jako QPixmap signálem gotPreview(), KIO::DeleteJob pro odstraňovaní souborů či adresářů, KIO::listDir() pro získání obsahu adresáře (případně KIO::listRecursive() pro rekurzivní výpis), nebo KIO::mimetype() pro získání MIME typu.

KIO Slaves

Možná jste si všimli, že pokud procházíte nějaké vzdálené úložiště, spouští se na pozadí automaticky procesy s názvy jako kio_ftp, kio_http a další. Těmto procesům se říká KIO Slaves a právě ony zajišťují komunikaci se serverem a zkrze své API zpřístupňují informace o obsahu adresářů koncovým aplikacím. Nejde vlastně o samostatné spustitelné soubory, ale o pluginy aplikace kdeinit4.

Pomocí KIO Slaves lze zobrazovat cokoliv, co lze alespoň trochu zorganizovat do stromové struktury (adresáře, soubory). Pro ukázku toho, jak to může vypadat, jsem připravil KIO Slave, který umí procházet složku Software zde na AbcLinuxu.

Každý KIO Slave musí musí mít funkci kdemain() a samotné třídy otroka, odvozené od KIO::SlaveBase nebo KIO::TCPSlave.

abcslave.h

#include <KIO/SlaveBase>
#include <kio/udsentry.h>

#include <QByteArray>
#include <QtWebKit/QWebElement>

class ABCSlave:public QObject, public KIO::SlaveBase
{
  Q_OBJECT

  public:
    ABCSlave (const QByteArray & pool, const QByteArray & app);

    void stat (const KUrl & url);
    void listDir (const KUrl & url);
  
  private:
    QWebElement getWebPage(QString path);
  
    KIO::UDSEntry dirEntry(QWebElement item);
    KIO::UDSEntry articleEntry(QWebElement item);
};

V této ukázkce jsem reimplementoval pouze metody stat() a listDir(). První zmíněná metoda slouží ke zjišťování informací o zadané URL (jedná se o soubor, nebo adresář, jaká jsou přístupová práva, MIME typ atd.). V druhé metodě se pak generuje seznam souborů či adresářů na uvedené URL. Dále existují metody copy(), move(), rename(), del(), chmod(), chown(), mkdir(), symlink(), read() a write(). Tyto metody můžete, ale nemusíte reimplementovat, záleží na tom, co všechno protokol umí, nebo jaké možnosti chcete poskytovat. Nám stačí jen procházení adresářů. Jedná se vlastně o samotné implementace stejnojmenných volání z KIO::Job.

Informace o adresáři nebo souboru se předávají pomocí objektů KIO::UDSEntry(), jak uvidíte v kódu níže. V ukázce nastavuji jen několik základních nejdůležitějších informací, no ve skutečnosti jich je mnohem více.

abcslave.cpp

...
...
// Vyexportuje funkce kdemain()
extern "C"
{
  KDE_EXPORT int kdemain (int argc, char **argv);
}

// Hlavni funkce knihovny
int kdemain (int argc, char **argv)
{
  // Vytvori novou aplikaci
  QApplication app(argc, argv);
  
  // Nahlasi se KDE jako nova instance kio_abc
  KComponentData instance ("kio_abc");

  // Vytvori novy ABCSlave
  ABCSlave *slave = new ABCSlave (argv[2], argv[3]);
  slave->dispatchLoop ();
  
  delete slave;

  return 0;
}

Důležité je funkci kdemain() nadeklarovat jako "extern". Tato funkce je ekvivalentem klasické main(). Důležité je nezapomenout spustit hlavní smyčku (KIO::SlaveBase::dispatchLoop()), a v případě, že potřebujete používat signály a sloty, tak je potřeba vytvořit objekt QApplication().

void ABCSlave::listDir(const KUrl& url)
{
    // Nacte webovou stranku 
    QWebElement webelement = getWebPage(url.path());
    
    // Najde vsechny &al;UL>
    QWebElementCollection uls = webelement.findAll("ul");
    QWebElement treemenu;
    
    // Prohleda vsechny <UL>, skonci, kdyz najde <UL id="treemenu1">
    for (int i = 0; i < uls.count(); i++)
    {
	if (uls.at(i).attribute("id", "") == "treemenu1") {
	  treemenu = uls.at(i);
	  break;
	}  
    }
   
    // Projde vsechny potomky v nalezenem <UL>
    QWebElement item = treemenu.firstChild();
    listEntry(dirEntry(item), false);
    
    while (!item.nextSibling().isNull())
    {
	item = item.nextSibling();
	// Kazdeho potomka prida do listEntry() jako adresare
	listEntry(dirEntry(item), false);
    }
    
    // Najde vsechny tabulky
    QWebElementCollection tables = webelement.findAll("table");
    QWebElement sw_table;
    // Projde vsechny tabulky, hleda <table class="sw-polozky">
    for (int i = 0; i < tables.count(); i++)
    {
	if (tables.at(i).attribute("class", "") == "sw-polozky") {
	  sw_table = tables.at(i);
	  break;
	}
    }
    
    /* V nalezene tabulce najde vsechny odkazy a vlozi je do listEntry()
       jako soubory */
    QWebElementCollection links = sw_table.findAll("a");
    for (int i = 0; i < links.count(); i++)
    {
	listEntry(articleEntry(links.at(i)), false);
    }

    // Odesle celou frontu
    listEntry(KIO::UDSEntry(), true);
    
    // Hotovo!
    finished();    
}

Metoda listDir() generuje obsah adresáře. V našem případě načte webovou stránku a potom prochází zdrojový kód a hledá určité speicifické elementy. Každý objevený prvek se do seznamu přidává metodou listEntry(), která se předá objekt KIO::UDSEntry. Druhý parametr metody indikuje, jestli už jsou všechny záznamy připraveny. Doporučuji nejdřív naakumulovat všechny záznamy a až potom zavolat listEntry() s prázdným KIO::UDSEntry() v prvním a hodnotou TRUE v druhém parametru. Při TRUE se všechna data odešlou klientovi k vizualizaci. Důležité je informovat signálem finished(), že procházení adresáře bylo dokončeno a už nic víc měnit nebudeme.

V případě selhání emitujeme signál error(), kde prvním argumentem je identifkátor chyby a druhým textový popis. Textový popis může být prázný (defaultní chyby mají vlastní popis), ale u kódů jako ERR_UNKNOWN nebo ERR_INTERNAL je vhodné krátce informovat o tom, co se pokazilo.

void ABCSlave::stat(const KUrl &url)
{
    KIO::UDSEntry entry;
    
    // O korenovem adresari vime, ze je to adresar, a ze do nej maji pristup vsichni
    if ((url == "") || (url == "/")) {
      entry.insert(KIO::UDSEntry::UDS_NAME, ".");
      entry.insert(KIO::UDSEntry::UDS_FILE_TYPE, S_IFDIR);
      entry.insert(KIO::UDSEntry::UDS_USER, "root");
      entry.insert(KIO::UDSEntry::UDS_GROUP, "root");
      entry.insert(KIO::UDSEntry::UDS_ACCESS, S_IRUSR | S_IXUSR | S_IRGRP | S_IXGRP | S_IROTH | S_IXOTH);
      statEntry(entry);
      finished();
      return;
    }

    // Pokud se nejedna o korenovy adresar, tak nacte stranku na dane adrese
    QWebElement web = getWebPage(url.path());
    QWebElementCollection uls = web.findAll("ul");
    
    // Pokud v ni najde <UL id="treeemenu1">, tak se jedna o adresar
    QWebElement treemenu;
    for (int i = 0; i < uls.count(); i++)
    {
	if (uls.at(i).attribute("id", "") == "treemenu1") {
	  entry.insert(KIO::UDSEntry::UDS_FILE_TYPE, S_IFDIR);
	  entry.insert(KIO::UDSEntry::UDS_NAME, url.directory());
	  entry.insert(KIO::UDSEntry::UDS_URL, url.path());
	  statEntry(entry);
	  finished();
	  return;
	}  
    }
   
    // Pokud je na dane strance <div class="sw"> jedna se o stranku
    // konkretniho programu, tedy je to soubor
    QWebElementCollection divs = web.findAll("div");
    for (int i = 0; i < divs.count(); i++)
    {
	if (divs.at(i).attribute("class", "") == "sw") {
	  entry.insert(KIO::UDSEntry::UDS_FILE_TYPE, S_IFREG);
	  entry.insert(KIO::UDSEntry::UDS_MIME_TYPE, "text/html");
	  entry.insert(KIO::UDSEntry::UDS_NAME, divs.at(i).findFirst("h1").toPlainText());
	  entry.insert(KIO::UDSEntry::UDS_URL, "http://www.abclinuxu.cz/"+url.url());
	  statEntry(entry);
	  finished();
	  return;
	}
    }
    
    // No a pokud nenajdeme ani slozku ani clanek, tak jsme asi neco udelali spatne
    error(KIO::ERR_DOES_NOT_EXIST, "");
}

Naše metoda stat() obsluhuje tři případy: když zadaná URL ukazuje na kořenový adresář, když obsahuje podsložky nebo soubory, či když je to už samotný článek. Pomocí této metody si klientská aplikace může zjišťovat detailnější informace o obsahu libovolného adresáře či souboru. Standardní chování je, že si klient nejprve zjistí informace o adresáři, do kterého právě vstupuje a až po jeho načtení postupně načítá informace o jednotlivých podadresářích nebo souborech.

Metodou KIO::UDSEntry::insert() se do záznamu přidávaji další a další informace. Já v této ukázce vkládám jen ty nejdůležitější: typ (soubor vs. adresář), název, cestu, u souborů pak ještě MIME typ. Po vložení informace opět nesmíme zapomenout na sigál finished(). Pokud se funkce dostane až na konec, emituje se chyba.

KIO::UDSEntry ABCSlave::dirEntry(QWebElement item)
{
     // V predanem HTML radku najde odkaz
     QWebElement link = item.findFirst("a");
     
     KIO::UDSEntry entry;
     // Precteme text z <a> </a>
     entry.insert(KIO::UDSEntry::UDS_NAME, link.toPlainText());
     // Typ: slozka
     entry.insert(KIO::UDSEntry::UDS_FILE_TYPE, S_IFDIR);
     QString url = link.attribute("href", "");
     if (url.left(10) == "/software/") 
       url.remove(0,10);
     // Adresa, na kterou slozka odkazuje
     entry.insert(KIO::UDSEntry::UDS_URL, "abc:/"+url);
     
     return entry;
}

KIO::UDSEntry ABCSlave::articleEntry(QWebElement item)
{
     KIO::UDSEntry entry;
     // Nazev clanku
     entry.insert(KIO::UDSEntry::UDS_NAME, item.toPlainText());
     // Typ: regularni soubor
     entry.insert(KIO::UDSEntry::UDS_FILE_TYPE, S_IFREG);
     QString url = item.attribute("href", "");
     if (url.left(10) == "/software/")
       url.remove(0, 10);
     // Adresa, na ktere se clanek nachazi
     entry.insert(KIO::UDSEntry::UDS_URL, "http://www.abclinuxu.cz/software/"+url);
     // MIME Type 
     entry.insert(KIO::UDSEntry::UDS_MIME_TYPE, "text/html");
     
     return entry;
}

Další ukázka vytváření vlastních KIO::UDSEntry.

Poslední částí KIO Slave je soubor .protocol, který obsahuje informace o schopnostech našeho otroka. Soubor může vypadat například takto:

[Protocol]
exec=kio_abc
protocol=abc
input=stream
output=filesystem
listing=Name,Type
deleting=false
linking=false
reading=true
writing=false
moving=false
source=false

exec je název knihovny bez přípony. protocol je název protokolu. Když do Dolphina či Konqueroru napíšete abc:/, KDE automaticky použijí našeho otroka. listing říká, jaké všechny informace v základě o položkách dodáváme. Následující direktivy informují o schopnostech otroka - ten náš umí pouze číst. Soubor .protocol se instaluje do /usr/share/kde4/services.

Když projekt přeložíte a nainstalujete, můžete ho otestovat vepsáním abc:/ do adresního řádku libovolného KDE správce souborů. Po chvíli načítání by se měl objevit seznam adresářů identický s tím v sekci Software.

Pokud se chcete podívat trochu hlouběji do KIO Slaves, podívejte se třeba do zdrojových kódu kio_ftp (kdelibs/kioslave/ftp), nebo kio_archive (kdebase-runtime/kioslave/archive).

Závěr

KIO je prostředek pro snadnou práci se vstupně-výstupními operacemi a umožňuje pohodlný přístup i ke vzdáleným úložištím. Samotný přístup je možný díky procesům zvaným KIO Slaves. V KDE je ve výchozí instalaci k dispozici na 90 různých KIO Slaves, které podporují všelijaké síťové protokoly i lokální soubory.

V příští části se dostaneme k mnohými zatracované technologii Akonadi. Úplně nakonec ještě archiv se zdrojovými kódy příkladů.

       

Komentáře

[Abcbca]

Preco mi ide KDE4 tak pomaly a fluxbox tak rychlo?

[paralen]

No lebo v KDE je o nieco viac aplikacii jak len menu a panel

[aaaaaa]

No lebo v KDE je o nieco viac ZBYTOCNYCH EYE CANDY aplikacii jak len menu a panel

[marvn]

to je jako kritizovat ntb s cenou 60k ze je moc drahy, protoze v nem je zbytecne moc pameti, moc vykonej procak a zbytecne silne graficka karta...

proto existuje vec, ktere se rika vyber...neznas?

[Ash]

Počet aplikací nehraje roli, jde jen o to že to je blbě udělaný, nic jiného.

[pavlix]

Přesně tak, když triviální aplikace zabírá desítky megabajtů ramky, tak se dá celkem očekávat, že s ostatními parametry na tom nebude lépe a výsledek bude takový, jaký je v KDE.

[Xjmeno363]

konkrétně a nějaký důkaz, nebo jenom tak blbě plácáte? co považujete za triviální? Kolik jste toho sám naprogramoval?

[pavlix]

Musím na takový připitomělý ufňukaný komentář reagovat?

[petr_p]

V první ukázce se volá pouze KIO::copy() a hned na to KIO::move(). Z toho by člověk nabyl dojmu, že se jedná o blokující funkce (až se dokončí KIO::copy(), zahájí se KIO::move()).

Jenže v následující ukázce MainWindow::copyDir() se volá KIO::copy() a teprve po té se registrují signály, dodělávají widgety a podobně. Tady to vypadá, že volání KIO::copy() pouze připraví objekt, ale nic se ještě nevykoná (kdyby ano, tak by celá úloha mohla skončit, ještě než se dotaneme k nastavení signálů). V dalším kódu se ale nikde objektu current_job neříká, aby zahájil činnost, ani se nikde nečeká na jeho ukončení.

Jak to tedy je?

[progdan]

Jedna se o neblokujici operace, KIO::neco() jen vytvori objekt KIO::Job a spusti na pozadi proces, ktery zacne provadet prislusnou operaci.

V prvni ukazce jde pouze o demonstraci API, realne pouziti je az v naslednych ukazkach. V clanku to neni jasne uvedeno, za to se omlouvam.

[petr_p]

Nechybí pak v druhém příkladu registrace signálu pro dokončení operace? Pokud se KIO::Job spustí okamžitě při vytvoření, co se stane se signály, které úloha odešle, ještě než se původní vlákno dostane k jejich registraci?

[progdan]

Nechybi: connect(current_job, SIGNAL(finished(KJob*)), this, SLOT(jobFinished(KJob*)));

Prvni signal emituje KIO::Job 200ms po spusteni, takze hlavni proces ma dost casu se na signaly KIO Jobu povesit, a o nic neprisel.

[petr_p]

Přehlédl jsem. Jen spoléhat se, že se proces do 200 ms dopracuje k registraci, mi přijde nebezpečné. Když už se pracuje souběžně, mělo by se to řešit správně.

[mirec]

Síce to moc s témou nesúvisí, ale funguje niekomu kuiserver pre KDE 4? Som používateľ KDE, ale nemám ani plasmu ani kwin, chcel by som ale úlohy KIO zoskupené do jedného okna ako to bolo v KDE 3 a zo začiatku v KDE 4.

[imploder]

Co je to kuiserver? Nepodařilo se mi to najít na webu KDE ani vygooglit.

[mirec]

Příloha:

• notify.png (15493 bytů)

Dal som link (klik) na obrázok. Bol to program, ktorý zobrazoval joby zgrupované do jedného okna, nie ako kopu okien lietajúcich po monitore. Kuiserver som mal rád, hlavne keď porovnám s notifikáciami plasmy ku ktorým by som potreboval manuál a chvíľu pozerať na notifikáciu že čo to zas po mne chce. Asi už starnem, v každom prípade plasma je na mňa moc zložitá.

[imploder]

Tak z tohohle obrázku už je mi jasné, co to dělá. Vypadá to jako dobrý nápad, škoda, že to nefunguje.

[progdan]

kuiserver mi funguje, odhadem tak od verze KDE 4.4, 4.5 s nim nebyly zadne problemy. Ve starsich verzich KDE4 to blblo.

[progdan]

Jeste doplnim, ze jinak, nez pres notifikacni panel v Plasme se to uz v KDE4 vytahnout neda, onen okenni zpusob z KDE3 uz neexistuje.

[mirec]

jinak, nez pres notifikacni panel v Plasme se to uz v KDE4 vytahnout neda

Veď práve, do 4.5 mi to išlo ešte okenným spôsobom. Asi si budem musieť kuiserver opraviť sám.

[Sten]

V první ukázce je chybka, je tam „destination“ místo „link“:

KIO::CopyJob *linkJob = KIO::link(source, link, HideProgressInfo);

[progdan]

Diky, opraveno.

[LukynZ]

kio je hlavne technologie, ktera si cas od casu zacne zrat 100% cpu a nikdo nevi proc

[Luboš Doležel (Doli)]

Ne, je to hlavně technologie, které najednou umře spojení a nedá se s tím nic dělat.

[Max]

Ne, je to hlavně technologie, která neumožňuje komunikaci mezi dvěma STEJNÝMI kio, tzn. kopírovat něco z fish:// na fish://, nebo ze smb:// na smb:// atd.
Zdar Max

[progdan]

Zkousel jsem ted schvalne fish:// to fish:// a bez problemu to kopiruje. Zadnou sambu nemam po ruce, ale verim, ze to taky bude fungovat. KIO procesy mezi sebou navzajem umi komunikovat libovolne.

[Max]

Mně to nefunguje a nejsem sám. I s čistýma konfigurákama KDE 4.6.0. Co ty máš za verzi KDE?
Zdar Max

[progdan]

4.6.41, neco mezi 4.6.0 a 4.6.1

[Max]

Hmm, takže novější verze. Teď se dívám na repo archu,že už je k dispozici 4.6.1. Hmm, že bych zkusil upgrade, zda to opravili.
Zdar Max

[Luboš Doležel (Doli)]

Tohle mi na starším KDE taky nechodí, přitom v KDE3 to chodilo dobře. Já pořád nemám pocit, že jsem přechodem na KDE4 něco získal

[progdan]

Porad je tady projekt Trinity, dokonce i s balicky pro Debian.

[Max]

V archlinuxu je k dispozici jen pro 32bit (od jednoho nadšence), navíc vývoj aplikací pro KDE3.5 se zastavil, takže tím si člověk začne také pěkně komplikovat život. Zachvíli to začne být nepoužitelné prostředí :-/.
Zdar Max

[Max]

Já ten pocit mám. Možnosti efektů přímo v kwinu jsou paráda. Dřív, když jsem potřeboval třeba průhlednost, nebo ty náhledy na všechny okna, tak jsem musel oželet kwin. Nyní mohu používat obojí.
Dalším důvodem byly aplikace pro qt4, které se hodně šířily a poté i samotné aplikace pro KDE4. Dalo by se tedy říci, že jsem byl přinucen okolnostmi. Navíc s KDE4.6.0 + xrender se u mně smazal výkonnový rozdíl mezi KDE3 a KDE4, takže já jsem spokojen. Jen v tom jobu mně sejřila ta chybka se stejnými kio. Našlo by se ještě několik much, ale myslím, že celkově to mohu hodnotit velmi kladě.
Další bonus, který jsem nikdy neřešil, bylo posílání zpráv z Netware klientům, který mi KDE4 automaticky zachycuje a ukazuje v systray. To mi KDE3.5 nedělalo (možná to šlo nějak nastavit, ale to nevím).
Stejný informační panel pro všechny je velmi zajímavý nápad, známému třeba vyhovuje, ale já jsem stále na váškách, nicméně ho úplně nezavrhuji.
A to jsem jen uživatel, z programátorského hlediska to má oproti KDE3 asi mnohem více výhod.
Zdar Max

[Max]

Tak jsem v jobu upgradnul na KDE4.6.1 a nic. Stále mi to nejede. Další možností je ještě vyčistit konfiguráky, ale nato zatím dlabu. To kdyžtak vyzkouším na jiném PC.
Zdar Max

[Luboš Doležel (Doli)]

export HOME=/tmp

Takhle testuju.

[Max]

Hmm, pěkný. To mně nenapadlo. Je to lepší, než zálohovat konfiguráky a znovu je obnovovat. Díky :).
Zdar Max

[GeBu]

Omlouvám se, že oživuji 2 roky starou diskusi, ale nemůžu k tomu nikde nic najít. Nevíte někdo, jestli v současné době KIO podporuje IPv6? Nedaří se mi připojit na druhý počítač v mé síti na lokální IPv6 adresu fish://user@fe80:...%wlan0

[GeBu]

Samozřejmě se s hranatýma závorkama jsem to zkoušel. Na ten počítač si přes IPv6 pingnu, připojím přes ssh a funguje mi i scp a sh v mc, ale v KDE mi to nejde. Bug?