kget/transfer.cpp

   1 /***************************************************************************
   2 *                                transfer.cpp
   3 *                             -------------------
   4 *
   5 *    begin        : Tue Jan 29 2002
   6 *    copyright    : (C) 2002, 2003, 2004, 2005 by Patrick Charbonnier
   7 *                 : Based On Caitoo v.0.7.3 (c) 1998 - 2000, Matej Koss
   8 *    email        : pch@freeshell.org
   9 *
  10 ****************************************************************************/
  11
  12 /***************************************************************************
  13  *
  14  *   This program is free software; you can redistribute it and/or modify
  15  *   it under the terms of the GNU General Public Lkio/global.h:icense as published by
  16  *   the Free Software Foundation; either version 2 of the License, or
  17  *   (at your option) any later version.
  18  *
  19  *   This program is distributed in the hope that it will be useful,
  20  *   but WITHOUT ANY WARRANTY; without even the implied warranty of
  21  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  22  *   GNU General Public License for more details.
  23  *
  24  ***************************************************************************/
  25
  26 #include <qheader.h>
  27
  28 #include <kurl.h>
  29 #include <kmessagebox.h>
  30 #include <klocale.h>
  31 #include <ksimpleconfig.h>
  32 #include <kaction.h>
  33 #include <kiconloader.h>
  34 #include <kstandarddirs.h>
  35 #include <kwin.h>
  36
  37 #include <assert.h>
  38 #include "safedelete.h"
  39 #include "settings.h"
  40 #include "logwindow.h"
  41 #include "kmainwidget.h"
  42 #include "dlgIndividual.h"
  43 #include "transferlist.h"
  44 #include "transfer.h"
  45
  46 #include <kapplication.h>
  47 #include <kio/passdlg.h>
  48 #include <kio/global.h>
  49 #include <kio/netaccess.h>
  50
  51
  52 extern Settings ksettings;
  53
  54
  55 Transfer::Transfer(TransferList * _view, const KURL & _src, const KURL & _dest, const uint _id)
  56     : QObject( _view ),
  57       KListViewItem(_view),
  58       dlgIndividual( 0 )
  59 {
  60     sDebugIn << endl;
  61
  62     src = _src;
  63     dest = _dest;
  64
  65     view = _view;
  66     init(_id);
  67
  68     sDebugOut << endl;
  69 }
  70
  71
  72 Transfer::Transfer(TransferList * _view, Transfer * after, const KURL & _src, const KURL & _dest, const uint _id)
  73     : QObject( _view ),
  74       KListViewItem(_view, (QListViewItem *) after),
  75       src(_src), dest(_dest), view(_view),
  76       dlgIndividual( 0 )
  77 {
  78     sDebugIn << endl;
  79
  80     view = _view;
  81     src = _src;
  82     dest = _dest;
  83     init(_id);
  84
  85     sDebugOut << endl;
  86 }
  87
  88
  89 Transfer::~Transfer()
  90 {
  91     sDebugIn << endl;
  92
  93     synchronousAbort();
  94     delete dlgIndividual;
  95
  96     sDebugOut << endl;
  97 }
  98
  99
 100 void
 101 Transfer::init(const uint _id)
 102 {
 103     sDebugIn << endl;
 104
 105     totalSize = 0;
 106     processedSize = 0;
 107     percent = 0;
 108     id = _id;
 109     m_pSlave = new Slave(this, src, dest);
 110     canResume = false;
 111     startTime = QDateTime::currentDateTime();
 112     speed = 0;
 113     // retryCount = ksettings.reconnectRetries-1;
 114     retryCount = 0;
 115     //first off all we need to know if resume is supported...
 116
 117     status = ST_STOPPED;
 118
 119
 120     connect(this, SIGNAL(statusChanged(Transfer *, int)), kmain, SLOT(slotStatusChanged(Transfer *, int)));
 121     connect(this, SIGNAL(statusChanged(Transfer *, int)), this, SLOT(slotUpdateActions()));
 122
 123     connect(this, SIGNAL(log(uint, const QString &, const QString &)), kmain->logwin(), SLOT(logTransfer(uint, const QString &, const QString &)));
 124
 125     // setup actions
 126     m_paResume = new KAction(i18n("&Resume"), "tool_resume", 0, this, SLOT(slotResume()), this, "resume");
 127
 128     m_paPause = new KAction(i18n("&Pause"), "tool_pause", 0, this, SLOT(slotRequestPause()), this, "pause");
 129
 130     m_paDelete = new KAction(i18n("&Delete"), "editdelete", 0, this, SLOT(slotRequestRemove()), this, "delete");
 131
 132     m_paRestart = new KAction(i18n("Re&start"), "tool_restart", 0, this, SLOT(slotRequestRestart()), this, "restart");
 133
 134     m_paQueue = new KRadioAction(i18n("&Queue"), "tool_queue", 0, this, SLOT(slotQueue()), this, "queue");
 135
 136     m_paTimer = new KRadioAction(i18n("&Timer"), "tool_timer", 0, this, SLOT(slotRequestSchedule()), this, "timer");
 137
 138     m_paDelay = new KRadioAction(i18n("De&lay"), "tool_delay", 0, this, SLOT(slotRequestDelay()), this, "delay");
 139
 140     m_paQueue->setExclusiveGroup("TransferMode");
 141     m_paTimer->setExclusiveGroup("TransferMode");
 142     m_paDelay->setExclusiveGroup("TransferMode");
 143
 144     // Actions
 145
 146     // m_paDock = new KAction(i18n("&Dock"),"tool_dock", 0, this,SLOT(slotRequestDelay()), this, "dockIndividual");
 147
 148     // setup individual transfer dialog
 149
 150     mode = MD_NEW;
 151
 152     sDebugOut << endl;
 153 }
 154
 155
 156 void Transfer::synchronousAbort()
 157 {
 158     if ( m_pSlave )
 159     {
 160         if ( m_pSlave->running() )
 161         {
 162             m_pSlave->Op(Slave::KILL);
 163             m_pSlave->wait();
 164         }
 165
 166         if ( m_pSlave->running() )
 167             m_pSlave->terminate();
 168
 169         delete m_pSlave;
 170         m_pSlave = 0L;
 171
 172         status = ST_STOPPED;
 173         slotUpdateActions();
 174     }
 175
 176 }
 177
 178 void Transfer::slotUpdateActions()
 179 {
 180     sDebugIn << "the item Status is =" << status << "offline=" << ksettings.b_offline << endl;
 181      //if we are offline just disable Resume and Pause and return
 182     if (ksettings.b_offline) {
 183         m_paResume->setEnabled(false);
 184         m_paPause->setEnabled(false);
 185         m_paRestart->setEnabled(false);
 186         if(dlgIndividual)
 187                         dlgIndividual->update();
 188         return;
 189     }
 190
 191     UpdateRetry();
 192
 193     switch (status) {
 194
 195     case ST_TRYING://fall-through
 196     case ST_RUNNING:
 197         m_paResume->setEnabled(false);
 198         m_paPause->setEnabled(true);
 199         m_paRestart->setEnabled(true);
 200         break;
 201
 202     case ST_STOPPED:
 203         m_paResume->setEnabled(true);
 204         m_paPause->setEnabled(false);
 205         m_paRestart->setEnabled(false);
 206         break;
 207     case ST_FINISHED:
 208         m_paResume->setEnabled(false);
 209         m_paPause->setEnabled(false);
 210         m_paRestart->setEnabled(false);
 211         break;
 212     }
 213
 214     // disable all signals
 215     m_paQueue->blockSignals(true);
 216     m_paTimer->blockSignals(true);
 217     m_paDelay->blockSignals(true);
 218
 219     switch (mode) {
 220     case MD_QUEUED:
 221         m_paQueue->setChecked(true);
 222         break;
 223     case MD_SCHEDULED:
 224         m_paTimer->setChecked(true);
 225         break;
 226     case MD_DELAYED:
 227         m_paDelay->setChecked(true);
 228         break;
 229     case MD_NEW: //fall through
 230     case MD_NONE:
 231         m_paQueue->setChecked(false);
 232         m_paTimer->setChecked(false);
 233         m_paDelay->setChecked(false);
 234
 235         m_paQueue->setEnabled(false);
 236         m_paTimer->setEnabled(false);
 237         m_paDelay->setEnabled(false);
 238         break;
 239
 240     }
 241
 242
 243     // enable all signals
 244     m_paQueue->blockSignals(false);
 245     m_paTimer->blockSignals(false);
 246     m_paDelay->blockSignals(false);
 247
 248     if (dlgIndividual)
 249         dlgIndividual->update();
 250
 251     sDebugOut << endl;
 252 }
 253
 254
 255
 256 void Transfer::setSpeed(unsigned long _speed)
 257 {
 258     // sDebugIn <<endl;
 259     speed = _speed;
 260
 261     remainingTime = KIO::calculateRemaining(totalSize, processedSize, speed);
 262     //sDebugOut <<endl;
 263 }
 264
 265
 266
 267 void Transfer::updateAll()
 268 {
 269     sDebugIn << endl;
 270
 271     updateStatus(status);       // first phase of animation
 272
 273     logMessage(i18n("Copy file from: %1").arg(src.prettyURL()));
 274     logMessage(i18n("To: %1").arg(dest.prettyURL()));
 275
 276     // source
 277     setText(view->lv_url, src.prettyURL());
 278
 279     // destination
 280     setText(view->lv_filename, dest.fileName());
 281
 282     if(dlgIndividual)
 283                 {
 284                 dlgIndividual->setCopying(src, dest);
 285         dlgIndividual->setCanResume(canResume);
 286                 dlgIndividual->setTotalSize(totalSize);
 287                 dlgIndividual->setPercent(0);
 288                 dlgIndividual->setProcessedSize(0);
 289         }
 290
 291     if (totalSize != 0) {
 292         //logMessage(i18n("Total size is %1 bytes").arg((double)totalSize));
 293         setText(view->lv_total, KIO::convertSize(totalSize));
 294     } else {
 295         //logMessage(i18n("Total size is unknown"));
 296         setText(view->lv_total, i18n("unknown"));
 297     }
 298
 299
 300     sDebugOut << endl;
 301 }
 302
 303
 304 bool Transfer::updateStatus(int counter)
 305 {
 306     //sDebug<< ">>>>Entering"<<endl;
 307
 308     QPixmap *pix = 0L;
 309     bool isTransfer = false;
 310
 311     view->setUpdatesEnabled(false);
 312
 313     switch(status)
 314         {
 315         case ST_RUNNING:
 316             pix = view->animConn.at(counter);
 317             isTransfer = true;
 318             break;
 319         case ST_TRYING:
 320             pix = view->animTry.at(counter);
 321             isTransfer = true;
 322             break;
 323         case ST_STOPPED:
 324             if(mode == MD_QUEUED)
 325                 pix = &view->pixQueued;
 326             else if(mode == MD_SCHEDULED)
 327                 pix = &view->pixScheduled;
 328             else
 329                 pix = &view->pixDelayed;
 330             break;
 331         case ST_FINISHED:
 332             pix = &view->pixFinished;
 333     }
 334
 335     setPixmap(view->lv_pixmap, *pix);
 336     view->setUpdatesEnabled(true);
 337
 338     if(prevStatus!=status || prevMode != mode || status==ST_RUNNING || status==ST_TRYING)
 339         {
 340         QRect rect = view->header()->sectionRect(view->lv_pixmap);
 341
 342         int x = rect.x();
 343         int y = view->itemRect(this).y();
 344         int w = rect.width();
 345         int h = rect.height();
 346
 347         view->QScrollView::updateContents(x,y,w,h);
 348
 349         prevStatus = status;
 350        prevMode = mode;
 351     }
 352
 353     return isTransfer;
 354 }
 355
 356
 357 void Transfer::UpdateRetry()
 358 {
 359     QString retry;
 360     QString MaxRetry;
 361
 362     retry.setNum(retryCount);
 363     MaxRetry.setNum(ksettings.reconnectRetries);
 364     retry += " / " + MaxRetry;
 365
 366     setText(view->lv_count, retry);
 367 }
 368
 369
 370 void Transfer::slotResume()
 371 {
 372     sDebugIn << " state =" << status << endl;
 373
 374     retryCount++;
 375     if (retryCount > ksettings.reconnectRetries)
 376         retryCount = 1;
 377     UpdateRetry();
 378     assert(status == ST_STOPPED);
 379
 380     sDebug << "src: " << src.prettyURL() << endl;
 381     sDebug << "dest " << dest.prettyURL() << endl;
 382
 383     m_paResume->setEnabled(false);
 384
 385     status = ST_TRYING;
 386     mode = MD_QUEUED;
 387     logMessage(i18n("Attempt number %1").arg(retryCount));
 388
 389     sDebug << "sending Resume to slave " << endl;
 390     m_pSlave->Op(Slave::RETR);
 391
 392     sDebugOut << endl;
 393 }
 394
 395
 396  void Transfer::slotStop()
 397 {
 398     sDebugIn << endl;
 399
 400     logMessage(i18n("Stopping"));
 401
 402     assert(status <= ST_RUNNING && ksettings.b_offline);
 403
 404     m_pSlave->Op(Slave::KILL); // KILL doesn't post a Message
 405     sDebug << "Killing Slave" << endl;
 406
 407     slotSpeed(0);
 408     mode = MD_QUEUED;
 409     status=ST_STOPPED;
 410     m_paQueue->setChecked(true);
 411
 412     slotUpdateActions();
 413
 414     sDebugOut << endl;
 415 }
 416
 417
 418 void Transfer::slotRequestPause()
 419 {
 420     sDebugIn << endl;
 421
 422     logMessage(i18n("Pausing"));
 423
 424     assert(status <= ST_RUNNING);
 425
 426     //stopping the thead
 427
 428     m_paPause->setEnabled(false);
 429     m_paRestart->setEnabled(false);
 430
 431
 432     m_pSlave->Op(Slave::PAUSE);
 433     sDebug << "Requesting Pause.." << endl;
 434
 435     sDebugOut << endl;
 436 }
 437
 438
 439
 440
 441 void Transfer::slotRequestRestart()
 442 {
 443     sDebugIn << endl;
 444     m_pSlave->Op(Slave::RESTART);
 445     slotSpeed(0);
 446     sDebugOut << endl;
 447 }
 448
 449
 450 void Transfer::slotRequestRemove()
 451 {
 452     sDebugIn << endl;
 453     m_paDelete->setEnabled(false);
 454     m_paPause->setEnabled(false);
 455     if(dlgIndividual)
 456                 dlgIndividual->close();
 457
 458
 459     if ( status != ST_FINISHED )
 460     {
 461         KURL file = dest;
 462         // delete the partly downloaded file, if any
 463         file.setFileName( dest.fileName() + ".part" ); // ### get it from the job?
 464
 465         if ( KIO::NetAccess::exists( file, false, view ) ) // don't pollute user with warnings
 466         {
 467             SafeDelete::deleteFile( file ); // ### messagebox on failure?
 468         }
 469     }
 470     if (status == ST_RUNNING)
 471         m_pSlave->Op(Slave::REMOVE);
 472     else
 473         emit statusChanged(this, OP_REMOVED);
 474
 475     sDebugOut << endl;
 476 }
 477
 478
 479 void Transfer::slotQueue()
 480 {
 481     sDebug << ">>>>Entering with mode = " << mode << endl;
 482
 483     logMessage(i18n("Queueing"));
 484
 485     assert(!(mode == MD_QUEUED));
 486
 487     mode = MD_QUEUED;
 488     m_paQueue->setChecked(true);
 489     emit statusChanged(this, OP_QUEUED);
 490     sDebugOut << endl;
 491 }
 492
 493
 494 void Transfer::slotRequestSchedule()
 495 {
 496     sDebugIn << endl;
 497
 498     logMessage(i18n("Scheduling"));
 499     assert(!(mode == MD_SCHEDULED));
 500
 501     // if the time was already set somewhere in the future, keep it
 502     // otherwise set it to the current time + 60 seconds
 503     if (startTime < QDateTime::currentDateTime()) {
 504         QDateTime dt = QDateTime::currentDateTime();
 505         startTime = dt.addSecs(60);
 506     }
 507     if (status == ST_RUNNING) {
 508         m_paPause->setEnabled(false);
 509         m_paRestart->setEnabled(false);
 510         m_pSlave->Op(Slave::SCHEDULE);
 511
 512     } else
 513         slotExecSchedule();
 514     sDebugOut << endl;
 515 }
 516
 517
 518 void Transfer::slotRequestDelay()
 519 {
 520     sDebugIn << endl;
 521
 522     logMessage(i18n("Delaying"));
 523
 524     assert(!(mode == MD_DELAYED));
 525     if (status == ST_RUNNING) {
 526         m_paPause->setEnabled(false);
 527         m_paRestart->setEnabled(false);
 528         m_pSlave->Op(Slave::DELAY);
 529     } else
 530         slotExecDelay();
 531     sDebugOut << endl;
 532 }
 533
 534
 535
 536 /*
 537 void Transfer::slotCanceled(KIO::Job *)
 538 {
 539         sDebugIn  << endl;
 540
 541         logMessage(i18n("Canceled by user"));
 542         emit statusChanged(this, OP_CANCELED);
 543         sDebugOut   << endl;
 544 }
 545
 546 */
 547
 548 void Transfer::slotFinished()
 549 {
 550     sDebugIn << endl;
 551
 552     logMessage(i18n("Download finished"));
 553     mode = MD_NONE;
 554     status = ST_FINISHED;
 555     slotProcessedSize(totalSize);
 556
 557     slotSpeed(0);
 558     if(dlgIndividual)
 559                 dlgIndividual->enableOpenFile();
 560     emit statusChanged(this, OP_FINISHED);
 561     sDebugOut << endl;
 562 }
 563
 564
 565
 566
 567 /*
 568 void Transfer::slotRenaming(KIO::Job *, const KURL &, const KURL & to)
 569 {
 570         sDebugIn  << endl;
 571
 572         dest = to;
 573
 574         logMessage(i18n("Renaming to %1").arg(dest.prettyURL().ascii()));
 575
 576           // destination
 577           setText (view->lv_filename, dest.fileName ());
 578
 579           dlgIndividual->setCopying (src, dest);
 580
 581         sDebugOut   << endl;
 582 }
 583         */
 584
 585
 586
 587
 588 void Transfer::slotSpeed(unsigned long bytes_per_second)
 589 {
 590     //sDebugIn <<endl;
 591
 592     setSpeed(bytes_per_second);
 593
 594     if (speed == 0 && status == ST_RUNNING) {
 595         setText(view->lv_speed, i18n("Stalled"));
 596         setText(view->lv_remaining, i18n("Stalled"));
 597     } else if (speed == 0 && status == ST_FINISHED) {
 598
 599         setText(view->lv_progress, i18n("OK as in 'finished'","OK"));
 600         setText(view->lv_speed, i18n("0 MB/s"));
 601         setText(view->lv_remaining, i18n("00:00:00"));
 602
 603     } else if (speed == 0 && status == ST_STOPPED) {
 604
 605
 606         setText(view->lv_speed, i18n("0 MB/s"));
 607         setText(view->lv_remaining, i18n("00:00:00"));
 608
 609     } else {
 610         QString tmps = i18n("%1/s").arg(KIO::convertSize(speed));
 611         setText(view->lv_speed, tmps);
 612         setText(view->lv_remaining, remainingTime.toString());
 613     }
 614
 615         if(dlgIndividual)
 616         dlgIndividual->setSpeed(speed, remainingTime);
 617
 618     //sDebugOut<<endl;
 619 }
 620
 621
 622
 623 void Transfer::slotTotalSize(KIO::filesize_t bytes)
 624 {
 625 #ifdef _DEBUG
 626     sDebugIn<<" totalSize is = "<<totalSize << endl;
 627 #endif
 628
 629     if (totalSize == 0) {
 630         totalSize = bytes;
 631         if (totalSize != 0) {
 632             logMessage(i18n("Total size is %1 bytes").arg((double)totalSize,0,'f',0));
 633             setText(view->lv_total, KIO::convertSize(totalSize));
 634                         if(dlgIndividual)
 635                                 {
 636                                 dlgIndividual->setTotalSize(totalSize);
 637                                 dlgIndividual->setPercent(0);
 638                                 dlgIndividual->setProcessedSize(0);
 639                         }
 640         }
 641     } else {
 642
 643 #ifdef _DEBUG
 644         sDebug<<"totalSize="<<totalSize<<" bytes="<<bytes<<endl;
 645         assert(totalSize == bytes);
 646 #endif
 647         if (totalSize != bytes)
 648             logMessage(i18n("The file size does not match."));
 649         else
 650             logMessage(i18n("File Size checked"));
 651     }
 652
 653 #ifdef _DEBUG
 654     sDebugOut << endl;
 655 #endif
 656 }
 657
 658
 659
 660 void Transfer::slotProcessedSize(KIO::filesize_t bytes)
 661 {
 662     //sDebug<< ">>>>Entering"<<endl;
 663
 664     int old = percent;
 665     processedSize = bytes;
 666
 667     if (totalSize == 0)
 668     {
 669         percent = 0;
 670     }
 671     else if ( totalSize < processedSize ) // bogus totalSize value
 672     {
 673         percent = 99; // what can we say?
 674         totalSize = processedSize;
 675
 676         setText(view->lv_total, KIO::convertSize(totalSize));
 677                 if(dlgIndividual)
 678                 dlgIndividual->setTotalSize(totalSize);
 679     }
 680     else {
 681         percent = (int) (((float) processedSize / (float) totalSize) * 100.0);
 682     }
 683         if(dlgIndividual)
 684         dlgIndividual->setProcessedSize(processedSize);
 685
 686     if (percent != old) {
 687         QString tmps;
 688         if (percent == 100) {
 689             tmps = i18n("OK as in 'finished'","OK");
 690         } else {
 691             tmps.setNum(percent);
 692         }
 693
 694         setText(view->lv_progress, tmps);
 695
 696                 if(dlgIndividual)
 697                 dlgIndividual->setPercent(percent);
 698     }
 699     //sDebug<< "<<<<Leaving"<<endl;
 700 }
 701
 702
 703
 704
 705 void Transfer::showIndividual()
 706 {
 707     sDebugIn << endl;
 708
 709     //    create a DlgIndividual only if it hasn't been created yet
 710     if(!dlgIndividual)
 711     {
 712         dlgIndividual = new DlgIndividual(this);
 713         dlgIndividual->setLog(transferLog);
 714         dlgIndividual->setCopying(src, dest);
 715         dlgIndividual->setCanResume(canResume);
 716         dlgIndividual->setTotalSize(totalSize);
 717         dlgIndividual->setPercent(percent);
 718         dlgIndividual->setProcessedSize(processedSize);
 719     }
 720
 721     dlgIndividual->raise();
 722
 723
 724     if (ksettings.b_iconifyIndividual) {
 725         KWin::iconifyWindow( dlgIndividual->winId() );
 726     }
 727
 728     //      update the actions
 729     slotUpdateActions();
 730     //     then show the single dialog
 731     KWin::deIconifyWindow( dlgIndividual->winId() );
 732     dlgIndividual->show();
 733
 734     sDebugOut << endl;
 735 }
 736
 737
 738 void Transfer::logMessage(const QString & message)
 739 {
 740     sDebugIn << message << endl;
 741
 742     emit log(id, src.fileName(), message);
 743
 744     QString tmps = "<font color=\"blue\">" + QTime::currentTime().toString() + "</font> : " + message;
 745
 746     transferLog.append(tmps + '\n');
 747
 748     if(dlgIndividual)
 749         dlgIndividual->appendLog(tmps);
 750
 751     sDebugOut << endl;
 752 }
 753
 754
 755
 756 bool Transfer::read(KSimpleConfig * config, int id)
 757 {
 758     sDebugIn << endl;
 759
 760
 761     QString str;
 762     str.sprintf("Item%d", id);
 763     config->setGroup(str);
 764
 765     if (src.isEmpty() || dest.isEmpty()) {
 766         return false;
 767     }
 768
 769     if (!src.isValid() && !ksettings.b_expertMode) {
 770         KMessageBox::error(kmain, i18n("Malformed URL:\n") + src.prettyURL(), i18n("Error"));
 771         return false;
 772     }
 773
 774     mode = (TransferMode) config->readNumEntry("Mode", MD_QUEUED);
 775     status = (TransferStatus) config->readNumEntry("Status", ST_RUNNING);
 776     startTime = config->readDateTimeEntry("ScheduledTime");
 777     canResume = config->readBoolEntry("CanResume", true);
 778     totalSize = config->readUnsignedNum64Entry("TotalSize", 0);
 779     processedSize = config->readUnsignedNum64Entry("ProcessedSize", 0);
 780
 781     if (status != ST_FINISHED && totalSize != 0) {
 782         //TODO insert additional check
 783         status = ST_STOPPED;
 784     }
 785
 786     updateAll();
 787     sDebugOut << endl;
 788     return true;
 789 }
 790
 791
 792 void Transfer::write(KSimpleConfig * config, int id)
 793 {
 794     sDebugIn << endl;
 795
 796     QString str;
 797     str.sprintf("Item%d", id);
 798
 799     config->setGroup(str);
 800     config->writePathEntry("Source", src.url());
 801     config->writePathEntry("Dest", dest.url());
 802     config->writeEntry("Mode", mode);
 803     config->writeEntry("Status", status);
 804     config->writeEntry("CanResume", canResume);
 805     config->writeEntry("TotalSize", totalSize );
 806     config->writeEntry("ProcessedSize", processedSize );
 807     config->writeEntry("ScheduledTime", startTime);
 808     sDebugOut << endl;
 809 }
 810
 811
 812
 813 /** No descriptions */
 814 void Transfer::slotExecPause()
 815 {
 816     sDebugIn << endl;
 817     slotSpeed(0);
 818
 819     mode = MD_DELAYED;
 820     m_paDelay->setChecked(true);
 821     status = ST_STOPPED;
 822
 823     m_paPause->setEnabled(false);
 824     m_paRestart->setEnabled(true);
 825     m_paResume->setEnabled(true);
 826     slotUpdateActions();
 827     //TODO WE NEED TO UPDATE ACTIONS..
 828     kmain->slotUpdateActions();
 829     emit statusChanged(this, OP_PAUSED);
 830     sDebugOut << endl;
 831 }
 832
 833 void Transfer::slotExecError()
 834 {
 835     sDebugIn << endl;
 836
 837     status = ST_STOPPED;
 838     mode = MD_SCHEDULED;
 839     startTime=QDateTime::currentDateTime().addSecs(ksettings.reconnectTime * 60);
 840     emit statusChanged(this, OP_SCHEDULED);
 841
 842     sDebugOut << endl;
 843 }
 844
 845 void Transfer::slotExecBroken()
 846 {
 847     sDebugIn << endl;
 848
 849     status = ST_STOPPED;
 850     mode = MD_QUEUED;
 851     emit statusChanged(this, OP_QUEUED);
 852
 853     sDebugOut << endl;
 854 }
 855
 856
 857 void Transfer::slotExecRemove()
 858 {
 859     sDebugIn << endl;
 860
 861     m_pSlave->wait();
 862     emit statusChanged(this, OP_REMOVED);
 863     sDebugOut << endl;
 864 }
 865
 866
 867 void Transfer::slotExecResume()
 868 {
 869     sDebugIn << endl;
 870     emit statusChanged(this, OP_RESUMED);
 871     sDebugOut << endl;
 872 }
 873
 874 void Transfer::slotExecConnected()
 875 {
 876     sDebugIn << endl;
 877     if (mode == MD_NEW)
 878     {
 879         if (ksettings.b_offline)// when we're offline and arrive here, then the file is in cache
 880             return;             // Slave::slotResult will be called immediately, so we do nothing here
 881         status = ST_STOPPED;
 882         m_pSlave->Op(Slave::KILL);
 883         if (ksettings.b_addQueued)
 884         {
 885             mode = MD_QUEUED;
 886             emit statusChanged(this, OP_QUEUED);
 887         }
 888         else
 889         {
 890             mode = MD_DELAYED;
 891             emit statusChanged(this, OP_DELAYED);
 892         }
 893         return;
 894     }
 895
 896     status = ST_RUNNING;
 897     emit statusChanged(this, OP_CONNECTED);
 898     sDebugOut << endl;
 899 }
 900
 901
 902 void Transfer::slotCanResume(bool _bCanResume)
 903 {
 904     sDebugIn << endl;
 905
 906     canResume = _bCanResume;
 907
 908     if (canResume) {
 909         logMessage(i18n("Download resumed"));
 910         setText(view->lv_resume, i18n("Yes"));
 911     } else {
 912         setText(view->lv_resume, i18n("No"));
 913     }
 914
 915     //dlgIndividual->setCanResume(canResume);
 916
 917     sDebugOut << endl;
 918 }
 919
 920
 921 /** No descriptions */
 922 void Transfer::slotExecDelay()
 923 {
 924     sDebugIn << endl;
 925
 926     mode = MD_DELAYED;
 927     status = ST_STOPPED;
 928     slotSpeed(0);               //need???????
 929     m_paDelay->setChecked(true);
 930     emit statusChanged(this, OP_DELAYED);
 931
 932     sDebugOut << endl;
 933 }
 934
 935 /** No descriptions */
 936 void Transfer::slotExecSchedule()
 937 {
 938     sDebugIn << endl;
 939
 940     mode = MD_SCHEDULED;
 941     status = ST_STOPPED;
 942     m_paTimer->setChecked(true);
 943     emit statusChanged(this, OP_SCHEDULED);
 944
 945     sDebugOut << endl;
 946 }
 947
 948 /** No descriptions */
 949 void Transfer::slotStartTime(const QDateTime & _startTime)
 950 {
 951     sDebugIn << endl;
 952
 953     setStartTime(_startTime);
 954     sDebugOut << endl;
 955 }
 956
 957 /** return true if the dlgIndividual is Visible */
 958 bool Transfer::isVisible() const
 959 {
 960     return dlgIndividual ? dlgIndividual->isVisible() : false;
 961 }
 962
 963 bool Transfer::keepDialogOpen() const
 964 {
 965     return dlgIndividual ? dlgIndividual->keepDialogOpen() : false;
 966 }
 967
 968 void Transfer::maybeShow()
 969 {
 970     if ( ksettings.b_showIndividual && getStatus() != Transfer::ST_FINISHED )
 971     {
 972         if(dlgIndividual)
 973             dlgIndividual->show();
 974     }
 975 }
 976
 977 bool Transfer::retryOnError()
 978 {
 979     return (ksettings.b_reconnectOnError && (retryCount < ksettings.reconnectRetries));
 980 }
 981
 982 bool Transfer::retryOnBroken()
 983 {
 984     return (ksettings.b_reconnectOnBroken && (retryCount < ksettings.reconnectRetries));
 985 }
 986
 987 void Transfer::checkCache()
 988 {
 989     assert (mode == MD_NEW);
 990
 991     if (src.protocol()=="http")
 992     {
 993         status = ST_TRYING;
 994         m_pSlave->Op(Slave::RETR_CACHE);
 995     }
 996     else
 997         NotInCache();
 998 }
 999
1000 void Transfer::NotInCache()
1001 {
1002     logMessage(i18n("checking if file is in cache...no"));
1003     if (ksettings.b_addQueued)
1004         mode = MD_QUEUED;
1005     else
1006         mode = MD_DELAYED;
1007     status = ST_STOPPED;
1008 }
1009 #include "transfer.moc"
1010