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