Source Code (Use browser search to find items of interest.)

caitoo'KMainWidget (./kdenetwork/caitoo/kmainwidget.h:143)

class KMainWidget : public KTMainWindow {

    Q_OBJECT

public:

  enum StatusbarFields { ID_TOTAL_TRANSFERS = 1, ID_TOTAL_FILES, ID_TOTAL_SIZE,
			 ID_TOTAL_TIME, ID_TOTAL_SPEED };

  KMainWidget();
  ~KMainWidget();

  void addTransfer( QString src, QString dest = QString::null );
  void addDropTransfers( QStrList *list );

  void setWindowStyle();
  void checkQueue();

  void setListFont();
  void setAutoSave();
  void setAutoDisconnect();

  LogWindow* logwin() { return logWindow; }

  friend class Settings;

  KToggleAction *m_paShowLog, *m_paPreferences;

public slots:
  void slotPasteTransfer();
  void slotToggleLogWindow();
  void slotTogglePreferences();

  void slotToggleExpertMode();
  void slotToggleOfflineMode();
  void slotToggleUseLastDir();
  void slotToggleAutoDisconnect();
  void slotToggleAutoShutdown();
  void slotToggleAutoPaste();

  void slotToggleAnimation();
  void slotToggleSound();

protected slots:
  void slotQuit();

  void slotOpenTransfer();
  void slotExportTransfers();
  void slotImportTransfers();
  void slotImportTextFile();

  void slotSaveYourself();
  void slotCheckConnection();
  void slotUpdateToolBar();

  void slotStatusChanged( Transfer *item, int _operation );

  void slotDock();
  void slotDropTarget();

  void slotResumeCurrent();
  void slotPauseCurrent();
  void slotDeleteCurrent();
  void slotRestartCurrent();

  void slotQueueCurrent();
  void slotTimerCurrent();
  void slotDelayCurrent();

  void slotConfigCurrent();
  void slotOpenConfigDialog();

  void slotToggleStatusbar();

  void slotAnimTimeout();
  void slotTransferTimeout();
  void slotAutosaveTimeout();

  void slotOpenDownloadWindow();
  void slotMoveToBegin();
  void slotMoveToEnd();

  void slotCopyToClipboard();
  void slotCheckClipboard();

  void slotConfigureKeys();
  void slotConfigureToolbars();

  void slotPopupMenu( Transfer *item );

protected:

  void closeEvent( QCloseEvent * );

  void writeLog();

  // drag and drop
  void dragEnterEvent( QDragEnterEvent * );
  void dropEvent( QDropEvent * );

  void readTransfers( bool ask_for_name = false );
  void writeTransfers( bool ask_for_name = false );

  void setupTransferList();

  void setupGUI();
  void setupWhatsThis();

  void updateStatusBar();

  // some flags
  bool b_online;
  bool b_viewLogWindow;
  bool b_viewPreferences;

  // utility functions
  void disconnect();
  void checkOnline();
  void pauseAll();
  void log( const char *message, bool statusbar = true );

  // various timers
  QTimer *animTimer;         // animation timer
  QTimer *connectionTimer;   // timer that checks whether we are online
  QTimer *transferTimer;     // timer for scheduled transfers
  QTimer *autosaveTimer;     // timer for autosaving transfer list
  QTimer *clipboardTimer;    // timer for checking clipboard - autopaste function

  QString logFileName;

private:

  TransferList *myTransferList;
  KHelpMenu *menuHelp;

  LogWindow *logWindow;
  PreferencesDlg* prefDlg;

  QString lastClipboard;

  // Actions
  KAction *m_paOpenTransfer, *m_paPasteTransfer, *m_paExportTransfers, *m_paImportTransfers;
  KAction *m_paImportText, *m_paQuit;

  KAction *m_paMoveToBegin, *m_paMoveToEnd, *m_paCopy, *m_paConfigure, *m_paProgress;
  KAction *m_paResume, *m_paPause, *m_paDelete, *m_paRestart;
  KRadioAction *m_paQueue, *m_paTimer, *m_paDelay;

  KToggleAction *m_paUseAnimation, *m_paUseSound;
  KToggleAction *m_paExpertMode, *m_paUseLastDir, *m_paOfflineMode;
  KToggleAction *m_paAutoDisconnect, *m_paAutoShutdown, *m_paAutoPaste;

  KToggleAction *m_paShowStatusbar;
  KToggleAction *m_paDropTarget, *m_paDockWindow;

  QString currentDirectory;

  uint animCounter;

  int _sock;

};

caitoo'KMainWidget::KMainWidget() (./kdenetwork/caitoo/kmainwidget.cpp:111)

KMainWidget::KMainWidget() : KTMainWindow( "" ) {
  b_online = TRUE;
  b_viewLogWindow = FALSE;
  b_viewPreferences = FALSE;

  kmain = this;

  // Set log time, needed for the name of log file
  QDate date = QDateTime::currentDateTime().date();
  QTime time = QDateTime::currentDateTime().time();
  QString tmp;
  tmp.sprintf( "log%d:%d:%d-%d:%d:%d", date.day(), date.month(), date.year(),
	       time.hour(), time.minute(), time.second() );

  logFileName = locateLocal("appdata", "logs/");
  logFileName += tmp;

  // Clear clipboard
  kapp->clipboard()->setText("");

  // Load all settings from KConfig
  ksettings.load();

  // Setup log window
  logWindow = new LogWindow();

  setCaption( CAITOOVERSION );

  setupGUI();
  setupWhatsThis();

  log( i18n("Welcome to Caitoo") );

  setView( myTransferList );

  connect( kapp, SIGNAL( saveYourself() ), SLOT( slotSaveYourself() ) );

  // Enable dropping
  setAcceptDrops( true );

  // Setup connection timer
  connectionTimer = new QTimer( this );
  connect( connectionTimer, SIGNAL( timeout() ), SLOT( slotCheckConnection() ) );

  // setup socket for checking connection
  if ((_sock = sockets_open()) < 0) {
    log( i18n("Couldn't create valid socket"), false );
  } else {
    connectionTimer->start( 5000 );  // 5 second interval for checking connection
  }

  checkOnline(); 
  if ( ! b_online ) {
    log( i18n("Starting offline") );
  }

  // Setup animation timer
  animTimer = new QTimer( this );
  animCounter = 0;
  connect( animTimer, SIGNAL( timeout() ), SLOT( slotAnimTimeout() ) );

  if ( ksettings.b_useAnimation ) {
    animTimer->start( 400 );
  } else {
    animTimer->start( 1000 );
  }

  // Setup transfer timer for scheduled downloads and checkQueue()
  transferTimer = new QTimer( this );
  connect( transferTimer, SIGNAL( timeout() ), SLOT( slotTransferTimeout() ) );
  transferTimer->start( 10000 ); // 10 secs time interval 

  // Setup autosave timer
  autosaveTimer = new QTimer( this );
  connect( autosaveTimer, SIGNAL( timeout() ), SLOT( slotAutosaveTimeout() ) );
  setAutoSave();

  // Setup clipboard timer
  clipboardTimer = new QTimer( this );
  connect( clipboardTimer, SIGNAL( timeout() ), SLOT( slotCheckClipboard() ) );
  if ( ksettings.b_autoPaste ) {
    clipboardTimer->start( 1000 );
  }

  currentDirectory = "file:" + QDir::currentDirPath();
  readTransfers();

  // Setup special windows
  kdrop = new DropTarget();
  kdock = new DockWidget( this );
  // Set geometry
//   if ( ksettings.mainProperties != "" ) {
//     setGeometry(KWM::setProperties(winId(), ksettings.mainProperties));
//   } else {
//     resize( 650, 180 );
//   }
  resize( 650, 180 ); // TODO : remove

  // update actions
  m_paUseAnimation->setChecked( ksettings.b_useAnimation );
  m_paUseSound->setChecked( ksettings.b_useSound );
  m_paExpertMode->setChecked( ksettings.b_expertMode );
  m_paUseLastDir->setChecked( ksettings.b_useLastDir );
  if ( ksettings.connectionType != PERMANENT ) {
    m_paAutoDisconnect->setChecked(ksettings.b_autoDisconnect);
  }
  setAutoDisconnect();

  m_paAutoShutdown->setChecked( ksettings.b_autoShutdown );
  m_paOfflineMode->setChecked( ksettings.b_offlineMode );
  m_paAutoPaste->setChecked( ksettings.b_autoPaste );
  m_paShowStatusbar->setChecked( ksettings.b_showStatusbar );
  m_paShowLog->setChecked( b_viewLogWindow );

  switch ( ksettings.windowStyle ) {

  case DROP_TARGET:
    m_paDropTarget->setChecked(true);
    break;

  case DOCKED:
    m_paDockWindow->setChecked(true);
    break;

  default:
    setWindowStyle();
    break;
  }

}

caitoo'KMainWidget::~KMainWidget() (./kdenetwork/caitoo/kmainwidget.cpp:243)

KMainWidget::~KMainWidget () {
  if ( animTimer ) {
    animTimer->stop();
    delete animTimer;
  }
  
  delete (DropTarget *) kdrop;

  writeTransfers();

  writeLog();
}

caitoo'KMainWidget::log() (./kdenetwork/caitoo/kmainwidget.cpp:257)

void KMainWidget::log( const char *message, bool statusbar ) {
  kDebugInfo( 5001, message );
  logWindow->logGeneral( message );

  if ( statusbar ) {
    statusBar()->message( message, 1000);
  }
}

caitoo'KMainWidget::slotSaveYourself() (./kdenetwork/caitoo/kmainwidget.cpp:267)

void KMainWidget::slotSaveYourself() {
  writeTransfers();
  ksettings.save();
}

caitoo'KMainWidget::setupGUI() (./kdenetwork/caitoo/kmainwidget.cpp:273)

void KMainWidget::setupGUI() {

  // setup transfer list
  myTransferList = new TransferList(this, "transferList");

  setListFont();

  connect( myTransferList, SIGNAL( selectionChanged() ),
	   this, SLOT( slotUpdateToolBar() ) );
  connect( myTransferList, SIGNAL( transferSelected( Transfer* ) ), 
	   this, SLOT( slotOpenDownloadWindow() ) );
  connect( myTransferList, SIGNAL( popupMenu( Transfer* ) ), 
	   this, SLOT( slotPopupMenu( Transfer* ) ) );

  // file actions
  m_paOpenTransfer = KStdAction::open( this, SLOT( slotOpenTransfer() ), actionCollection(), "open_transfer" );
  m_paPasteTransfer = KStdAction::paste( this, SLOT( slotPasteTransfer() ), actionCollection(), "paste_transfer" );

  m_paExportTransfers = new KAction( i18n("&Export Transfer List"), 0, this,
				     SLOT( slotExportTransfers()), actionCollection(), "export_transfers" );
  m_paImportTransfers = new KAction( i18n("&Import Transfer List"), 0, this,
				     SLOT( slotImportTransfers()), actionCollection(), "import_transfers" );

  m_paImportText = new KAction( i18n("Import Text &File"), 0, this,
				SLOT( slotImportTextFile()), actionCollection(), "import_text" );

  m_paQuit = KStdAction::quit( this, SLOT( slotQuit() ), actionCollection(), "quit" );


  // transfer actions
  m_paCopy = new KAction( i18n("&Copy URL to clipboard"), 0, this,
			  SLOT( slotCopyToClipboard()), actionCollection(), "copy_url" );
  m_paConfigure = new KAction( i18n("Co&nfigure transfer"), 0, this,
			       SLOT( slotConfigCurrent()), actionCollection(), "configure_transfer" );
  m_paProgress = new KAction( i18n("&Open download window"), 0, this,
			      SLOT( slotOpenDownloadWindow()), actionCollection(), "open_progress" );

  m_paMoveToBegin = new KAction( i18n("Move to &beginning"), 0, this,
				 SLOT( slotMoveToBegin()), actionCollection(), "move_begin" );

  m_paMoveToEnd = new KAction( i18n("Move to &end"), 0, this,
			       SLOT( slotMoveToEnd()), actionCollection(), "move_end" );

  m_paResume = new KAction( i18n("&Resume"), QIconSet(BarIcon("tool_resume")), 0, this,
			    SLOT( slotResumeCurrent()), actionCollection(), "resume" );
  m_paPause = new KAction( i18n("&Pause"), QIconSet(BarIcon("tool_pause")), 0, this,
			   SLOT( slotPauseCurrent()), actionCollection(), "pause" );
  m_paDelete = new KAction( i18n("&Delete"), QIconSet(BarIcon("tool_delete")), 0, this,
			    SLOT( slotDeleteCurrent()), actionCollection(), "delete" );
  m_paRestart = new KAction( i18n("Re&start"), QIconSet(BarIcon("tool_restart")), 0, this,
			     SLOT( slotRestartCurrent()), actionCollection(), "restart" );

  m_paQueue = new KRadioAction( i18n("&Queue"), QIconSet(BarIcon("tool_queue")), 0, this,
				SLOT( slotQueueCurrent()), actionCollection(), "queue" );
  m_paTimer = new KRadioAction( i18n("&Timer"), QIconSet(BarIcon("tool_timer")), 0, this,
				SLOT( slotTimerCurrent()), actionCollection(), "timer" );
  m_paDelay = new KRadioAction( i18n("De&lay"), QIconSet(BarIcon("tool_delay")), 0, this,
				SLOT( slotDelayCurrent()), actionCollection(), "delay" );

  m_paQueue->setExclusiveGroup( "TransferMode" );
  m_paTimer->setExclusiveGroup( "TransferMode" );
  m_paDelay->setExclusiveGroup( "TransferMode" );
  
  // options actions
  m_paUseAnimation = new KToggleAction( i18n("Use &Animation"), 0, this,
					SLOT( slotToggleAnimation()), actionCollection(), "toggle_animation" );

  m_paUseSound = new KToggleAction( i18n("Use &Sound"), 0, this,
				    SLOT( slotToggleSound()), actionCollection(), "toggle_sound" );

  m_paPreferences = new KToggleAction( i18n("P&references"), QIconSet(BarIcon("tool_preferences")), 0, this,
				       SLOT( slotTogglePreferences()), actionCollection(), "preferences" );

  m_paExpertMode = new KToggleAction( i18n("&Expert mode"), QIconSet(BarIcon("tool_expert")), 0, this,
				      SLOT( slotToggleExpertMode()), actionCollection(), "expert_mode" );

  m_paUseLastDir = new KToggleAction( i18n("&Use-last-directory mode"), QIconSet(BarIcon("tool_uselastdir")), 0, this,
				      SLOT( slotToggleUseLastDir()), actionCollection(), "use_last_dir" );

  m_paAutoDisconnect = new KToggleAction( i18n("Auto-&disconnect mode"), QIconSet(BarIcon("tool_disconnect")), 0, this,
					  SLOT( slotToggleAutoDisconnect()), actionCollection(), "auto_disconnect" );

  m_paAutoShutdown = new KToggleAction( i18n("Auto-s&hutdown mode"), QIconSet(BarIcon("tool_shutdown")), 0, this,
				    SLOT( slotToggleAutoShutdown()), actionCollection(), "auto_shutdown" );

  m_paOfflineMode = new KToggleAction( i18n("&Offline mode"), QIconSet(BarIcon("tool_offline_mode")), 0, this,
				       SLOT( slotToggleOfflineMode()), actionCollection(), "offline_mode" );

  m_paAutoPaste = new KToggleAction( i18n("Auto-pas&te mode"), QIconSet(BarIcon("tool_clipboard")), 0, this,
				     SLOT( slotToggleAutoPaste()), actionCollection(), "auto_paste" );

  KStdAction::keyBindings( this, SLOT( slotConfigureKeys() ), actionCollection(), "configure_keybinding" );

  KStdAction::configureToolbars( this, SLOT( slotConfigureToolbars() ), actionCollection(), "configure_toolbars" );

  // view actions
  m_paShowStatusbar = KStdAction::showStatusbar( this, SLOT( slotToggleStatusbar() ), actionCollection(), "show_statusbar" );

  m_paShowLog = new KToggleAction( i18n("Show &Log Window"), QIconSet(BarIcon("tool_logwindow")), 0, this,
				   SLOT( slotToggleLogWindow()), actionCollection(), "toggle_log" );

  m_paDropTarget = new KRadioAction( i18n("Drop &target"), QIconSet(BarIcon("tool_drop_target")), 0, this,
				     SLOT( slotDropTarget()), actionCollection(), "drop_target" );

  m_paDockWindow = new KRadioAction( i18n("&Dock window"), QIconSet(BarIcon("tool_dock")), 0, this,
				     SLOT( slotDock()), actionCollection(), "dock_window" );
  
  m_paDropTarget->setExclusiveGroup( "WindowMode" );
  m_paDockWindow->setExclusiveGroup( "WindowMode" );

  menuHelp = new KHelpMenu( this, KGlobal::instance()->aboutData() );
  KStdAction::whatsThis( menuHelp, SLOT( contextHelpActivated() ), actionCollection(), "whats_this" );

  createGUI("caitooui.rc");

  toolBar()->setBarPos( ksettings.toolbarPosition );

  // setup statusbar
  statusBar()->insertFixedItem( i18n(" Transfers : %1 ").arg( 99 ), ID_TOTAL_TRANSFERS);
  statusBar()->insertFixedItem( i18n(" Files : %1 ").arg( 555 ), ID_TOTAL_FILES);
  statusBar()->insertFixedItem( i18n(" Size : %1 kB ").arg( "134.56" ), ID_TOTAL_SIZE);
  statusBar()->insertFixedItem( i18n(" Time : 00:00:00 "), ID_TOTAL_TIME);
  statusBar()->insertFixedItem( i18n(" %1 kB/s ").arg("123.34"), ID_TOTAL_SPEED);

  if ( !ksettings.b_showStatusbar ) {
    enableStatusBar( KStatusBar::Hide );
  } else {
    enableStatusBar( KStatusBar::Show );
  }

  updateStatusBar();
}

caitoo'KMainWidget::setupWhatsThis() (./kdenetwork/caitoo/kmainwidget.cpp:407)

void KMainWidget::setupWhatsThis() {
  QString tmp;

  tmp = i18n( "<b>Resume</b> button starts selected transfers\n"
	      "and sets their mode to <i>queued</i>." );
  m_paResume->setWhatsThis( tmp );

  tmp = i18n( "<b>Pause</b> button stops selected transfers\n"
	      "and sets their mode to <i>delayed</i>." );
  m_paPause->setWhatsThis( tmp );

  tmp = i18n( "<b>Delete</b> button removes selected transfers\n"
	      "from the list." );
  m_paDelete->setWhatsThis( tmp );

  tmp = i18n( "<b>Restart</b> button is a convenience button\n"
	      "that simply does Pause and Resume." );
  m_paRestart->setWhatsThis( tmp );

  tmp = i18n( "<b>Queued</b> button sets the mode of selected\n"
	      "transfers to <i>queued</i>.\n"
	      "\n"
	      "It is a radio button, you can select between\n"
	      "three modes." );
  m_paQueue->setWhatsThis( tmp );

  tmp = i18n( "<b>Scheduled</b> button sets the mode of selected\n"
	      "transfers to <i>scheduled</i>.\n"
	      "\n"
	      "It is a radio button, you can select between\n"
	      "three modes." );
  m_paTimer->setWhatsThis( tmp );

  tmp = i18n( "<b>Delayed</b> button sets the mode of selected\n"
	      "transfers to <i>delayed</i>."
	      "This also causes the selected transfers to stop.\n"
	      "\n"
	      "It is a radio button, you can select between\n"
	      "three modes." );
  m_paDelay->setWhatsThis( tmp );

  tmp = i18n( "<b>Preferences</b> button opens a preferences dialog\n"
	      "where you can set various options.\n"
	      "\n"
	      "Some of these options can be more easily set with toolbar.");
  m_paPreferences->setWhatsThis( tmp );

  tmp = i18n( "<b>Log window</b> button opens a log window.\n"
	      "Log window records all program events that occur\n"
	      "during the run of Caitoo." );
  m_paShowLog->setWhatsThis( tmp );

  tmp = i18n( "<b>Paste transfer</b> button adds an URL from\n"
	      "the clipboard as a new transfer.\n"
	      "\n"
	      "This way you can easily copy&paste URL's between\n"
	      "applications." );
  m_paPasteTransfer->setWhatsThis( tmp );

  tmp = i18n( "<b>Expert mode</b> button toggles the expert mode\n"
	      "on and off.\n"
	      "\n"
	      "Expert mode is recommended for experienced users.\n"
	      "When set, you will not be \"bothered\" by confirmation\n"
	      "messages.\n"
	      "<b>Important !</b>\n"
	      "Turn it on if you are using auto-disconnect or\n"
	      "auto-shutdown features and you want Caitoo to disconnect\n"
	      "without asking." );
  m_paExpertMode->setWhatsThis( tmp );

  tmp = i18n( "<b>Use last directory</b> button toggles the\n"
	      "use-last-directory feature on and off.\n"
	      "\n"
	      "When set, Caitoo will ignore the directory settings\n"
	      "and put all new added transfers into the directory\n"
	      "where ther last transfer was put.");
  m_paUseLastDir->setWhatsThis( tmp );

  tmp = i18n( "<b>Auto disconnect</b> button toggles the auto-disconnect\n"
	      "mode on and off.\n"
	      "\n"
	      "When set, Caitoo will disconnect automatically\n"
	      "after all queued transfers are finished.\n"
	      "\n"
	      "<b>Important !</b>\n"
	      "Turn on also the expert mode when you want Caitoo\n"
	      "to disconnect without asking." );
  m_paAutoDisconnect->setWhatsThis( tmp );

  tmp = i18n( "<b>Auto shutdown</b> button toggles the auto-shutdown\n"
	      "mode on and off.\n"
	      "\n"
	      "When set, Caitoo will quit automatically\n"
	      "after all queued transfers are finished.\n"
	      "<b>Important !</b>\n"
	      "Turn on also the expert mode when you want Caitoo\n"
	      "to quit without asking." );
  m_paAutoShutdown->setWhatsThis( tmp );

  tmp = i18n( "<b>Offline mode</b> button toggles the offline mode\n"
	      "on and off.\n"
	      "\n"
	      "When set, Caitoo will act as it was not connected\n"
	      "to the Internet.\n"
	      "\n"
	      "You can browse offline, while still being able to add\n"
	      "new transfers as queued." );
  m_paOfflineMode->setWhatsThis( tmp );

  tmp = i18n( "<b>Auto paste</b> button toggles the auto-paste mode\n"
	      "on and off.\n"
	      "\n"
	      "When set, Caitoo will periodically scan the clipboard\n"
	      "for URL's and paste them automatically." );
  m_paAutoPaste->setWhatsThis( tmp );

  tmp = i18n( "<b>Drop target</b> button toggles the window style\n"
	      "between a normal window and a drop target.\n"
	      "\n"
	      "When set, the main window will be hidden and\n"
	      "instead a small shaped window will appear.\n"
	      "\n"
	      "You can show/hide a normal window with a simple click\n"
	      "on a shaped window." );
  m_paDropTarget->setWhatsThis( tmp );

  tmp = i18n( "<b>Dock widget</b> button toggles the window style\n"
	      "between a normal window and a dock widget.\n"
	      "\n"
	      "When set, the main window will be hidden and\n"
	      "instead a dock widget will appear on a panel.\n"
	      "\n"
	      "You can show/hide a normal window with a simple click\n"
	      "on a dock widget." );
  m_paDockWindow->setWhatsThis( tmp );
}

caitoo'KMainWidget::setupTransferList() (./kdenetwork/caitoo/kmainwidget.cpp:546)

void KMainWidget::setupTransferList() {
}

caitoo'KMainWidget::slotConfigureKeys() (./kdenetwork/caitoo/kmainwidget.cpp:550)

void KMainWidget::slotConfigureKeys()
{
  KKeyDialog::configureKeys(actionCollection(), xmlFile());
}

caitoo'KMainWidget::slotConfigureToolbars() (./kdenetwork/caitoo/kmainwidget.cpp:557)

void KMainWidget::slotConfigureToolbars()
{
  KEditToolbar edit(factory());
  edit.exec();
}

caitoo'KMainWidget::slotImportTextFile() (./kdenetwork/caitoo/kmainwidget.cpp:564)

void KMainWidget::slotImportTextFile() {
  QString filename;
  QString list;
  int i, j;

  filename = KFileDialog::getOpenURL( currentDirectory ).path();
  if ( filename.isEmpty() ) {
    return;
  }

  list = kFileToString( filename );

  i = 0;
  while ( ( j = list.find('\n', i) ) != -1 ) {
    QString newtransfer = list.mid(i,j-i);
    addTransfer( newtransfer );
    i = j + 1;
  }
}

caitoo'KMainWidget::slotImportTransfers() (./kdenetwork/caitoo/kmainwidget.cpp:585)

void KMainWidget::slotImportTransfers() {
  readTransfers( true );
}

caitoo'KMainWidget::readTransfers() (./kdenetwork/caitoo/kmainwidget.cpp:590)

void KMainWidget::readTransfers( bool ask_for_name ) {
  kDebugInfo( 5001, "Reading transfers" );

  QString txt;
  if ( ask_for_name ) {
    txt = KFileDialog::getOpenURL( currentDirectory).path();
  } else {
    txt = locateLocal("appdata", "transfers");
  }

  if ( txt.isEmpty() ) {
    return;
  }

  myTransferList->readTransfers( txt );

  checkQueue();
  slotTransferTimeout();

  myTransferList->clearSelection();
}

caitoo'KMainWidget::slotExportTransfers() (./kdenetwork/caitoo/kmainwidget.cpp:613)

void KMainWidget::slotExportTransfers() {
  writeTransfers( true );
}

caitoo'KMainWidget::writeTransfers() (./kdenetwork/caitoo/kmainwidget.cpp:618)

void KMainWidget::writeTransfers( bool ask_for_name ) {
  kDebugInfo( 5001, "Writing transfers" );

  QString str;

  QString txt;
  if ( ask_for_name ) {
    txt = KFileDialog::getSaveURL( currentDirectory).path();
  } else {
    txt = locateLocal("appdata", "transfers");
  }

  myTransferList->writeTransfers( txt );
}

caitoo'KMainWidget::writeLog() (./kdenetwork/caitoo/kmainwidget.cpp:634)

void KMainWidget::writeLog() {
  //   kDebugInfo( 5001, "Writing log to file : %s", logFileName.ascii() );

  kCStringToFile( logWindow->getText().ascii(), logFileName.ascii(), false, false );
}

caitoo'KMainWidget::slotQuit() (./kdenetwork/caitoo/kmainwidget.cpp:641)

void KMainWidget::slotQuit() {
  Transfer *item;
  TransferIterator it( myTransferList );

  for ( ; it.current(); ++it ) {
    item = it.current();
    if ( item->getStatus() == Transfer::ST_RUNNING && !ksettings.b_expertMode ) {
      if ( KMessageBox::warningYesNo( this, i18n("Some transfers are still running.\nAre you sure you want to close Caitoo ?"),
				      i18n("Warning") ) != KMessageBox::Yes ) {
	return;
      }
    }
  }

  ksettings.save();

  kapp->quit();
}

caitoo'KMainWidget::slotResumeCurrent() (./kdenetwork/caitoo/kmainwidget.cpp:661)

void KMainWidget::slotResumeCurrent() {
  TransferIterator it( myTransferList );

  for ( ; it.current(); ++it ) {
    if ( it.current()->isSelected() ) {
      it.current()->resume();
    }
  }

  myTransferList->clearSelection();
}

caitoo'KMainWidget::slotPauseCurrent() (./kdenetwork/caitoo/kmainwidget.cpp:674)

void KMainWidget::slotPauseCurrent() {
  TransferIterator it( myTransferList );

  for ( ; it.current(); ++it ) {
    if ( it.current()->isSelected() ) {
      it.current()->pause();
    }
  }

  myTransferList->clearSelection();
}

caitoo'KMainWidget::slotRestartCurrent() (./kdenetwork/caitoo/kmainwidget.cpp:687)

void KMainWidget::slotRestartCurrent() {
  TransferIterator it( myTransferList );

  for ( ; it.current(); ++it ) {
    if ( it.current()->isSelected() ) {
      it.current()->restart();
    }
  }

  myTransferList->clearSelection();
}

caitoo'KMainWidget::slotDeleteCurrent() (./kdenetwork/caitoo/kmainwidget.cpp:700)

void KMainWidget::slotDeleteCurrent() {
  TransferIterator it( myTransferList );

  while ( it.current() ) {
    if ( it.current()->isSelected() ) {
      if ( !ksettings.b_expertMode ) {
	if ( KMessageBox::questionYesNo(this, i18n("Are you sure you want to delete this transfer ?"),
					i18n("Question") ) != KMessageBox::Yes ) {
	  return;
	}
      }
      it.current()->remove();

      // don't need to update counts - they are updated automatically when
      // calling remove()

    } else {
      it++; // update counts
    }
  }

  checkQueue(); // needed !
}

caitoo'KMainWidget::pauseAll() (./kdenetwork/caitoo/kmainwidget.cpp:725)

void KMainWidget::pauseAll() {
  log( i18n("Pausing all jobs"), false );

  TransferIterator it( myTransferList );

  for ( ; it.current(); ++it ) {
    it.current()->pause( true );
  }
}

caitoo'KMainWidget::slotQueueCurrent() (./kdenetwork/caitoo/kmainwidget.cpp:736)

void KMainWidget::slotQueueCurrent() {
  TransferIterator it( myTransferList );

  for ( ; it.current(); ++it ) {
    if ( it.current()->isSelected() ) {
      it.current()->queue();
    }
  }

  myTransferList->clearSelection();
}

caitoo'KMainWidget::slotTimerCurrent() (./kdenetwork/caitoo/kmainwidget.cpp:749)

void KMainWidget::slotTimerCurrent() {
  TransferIterator it( myTransferList );

  for ( ; it.current(); ++it ) {
    if ( it.current()->isSelected() ) {
      it.current()->schedule();
    }
  }

  myTransferList->clearSelection();
}

caitoo'KMainWidget::slotDelayCurrent() (./kdenetwork/caitoo/kmainwidget.cpp:762)

void KMainWidget::slotDelayCurrent() {
  TransferIterator it( myTransferList );

  for ( ; it.current(); ++it ) {
    if ( it.current()->isSelected() ) {
      it.current()->delay();
    }
  }

  myTransferList->clearSelection();
}

caitoo'KMainWidget::slotOpenTransfer() (./kdenetwork/caitoo/kmainwidget.cpp:775)

void KMainWidget::slotOpenTransfer() {
  KLineEditDlg *box = new KLineEditDlg( i18n("Open transfer :"), "", this);
  box->show();

  if (!box->result()) {   // cancelled
    return;
  }

  QString newtransfer = box->text();
  delete box;

  if ( ! newtransfer.isEmpty() ) {
    addTransfer( newtransfer );
  }
}

caitoo'KMainWidget::slotCheckClipboard() (./kdenetwork/caitoo/kmainwidget.cpp:793)

void KMainWidget::slotCheckClipboard() {
  QString clipData = kapp->clipboard()->text();
  if ( clipData != lastClipboard ) {
    kDebugInfo( 5001, "New clipboard event");

    lastClipboard = clipData.copy();
    if ( clipData.isEmpty() || clipData.stripWhiteSpace().isEmpty() ) {
      return;
    }

    KURL url( lastClipboard.stripWhiteSpace() );
    if ( ! url.isMalformed() && ksettings.b_autoPaste ) {
      slotPasteTransfer();
    }
  }
}

caitoo'KMainWidget::slotPasteTransfer() (./kdenetwork/caitoo/kmainwidget.cpp:811)

void KMainWidget::slotPasteTransfer() {
  QString newtransfer;

  newtransfer = kapp->clipboard()->text();
  newtransfer = newtransfer.stripWhiteSpace();

  if ( ! ksettings.b_expertMode ) {
    KLineEditDlg *box = new KLineEditDlg( i18n("Open transfer :"),
					  newtransfer, this );
    box->show();
    
    if (!box->result()) {   // cancelled
      return;
    }
    
    newtransfer = box->text();
    delete box;
  }

  if ( ! newtransfer.isEmpty() ) {
    addTransfer( newtransfer );
  }
}

caitoo'KMainWidget::addTransfer() (./kdenetwork/caitoo/kmainwidget.cpp:836)

void KMainWidget::addTransfer( QString s, QString d ) {
  KURL url( s );

  // don't download file URL's TODO : uncomment
//   if ( ! strcmp( url.protocol(), "file" ) ) {
//     kDebugInfo( 5001, "File protocol not accepted !" );
//     return;
//   }

  if ( url.isMalformed() ) {
    if ( ! ksettings.b_expertMode ) {
      KMessageBox::error( this, i18n("Malformed URL :\n") + s,
			  i18n( "Error" ) );
    }
    return;
  }

  // if we find this URL in the list
  if ( myTransferList->find( s ) ) {
    if ( ! ksettings.b_expertMode ) {
      KMessageBox::error( this, i18n( "Already saving URL \n" ) + s,
			  i18n( "Error" ) );
    }
    return;
  }

  // Setup destination

  // first set destination directory to current directory ( which is also last used )
  QString destDir = currentDirectory;

  if ( ! ksettings.b_useLastDir ) {
    // check wildcards for default directory
    DirList::Iterator it;
    for ( it = ksettings.defaultDirList.begin(); it != ksettings.defaultDirList.end(); ++it ) {
      QRegExp rexp( (*it).extRegexp );
      rexp.setWildcard( true );
      
      if ( ( rexp.match( url.filename() ) ) != -1 ) {
	destDir = (*it).defaultDir;
	break;
      }
    }
  }

  KURL dest;

  if ( d.isNull() ) {  // if we didn't provide destination
    if (!ksettings.b_expertMode ) { // open the filedialog for confirmation
      KFileDialog *dlg = new KFileDialog( destDir, "*",
					  0L , "filedialog", true );
      dlg->setSelection( destDir + "/" + url.filename() );
      
      int res = dlg->exec();
      
      if ( !res ) {
	delete dlg;
	return;
      } else {
	dest = dlg->selectedURL();
	currentDirectory = dest.path();  // TODO : path() or filename() or what ?
	delete dlg;
      }
    } else {  // in expert mode don't open the filedialog
      dest = destDir + "/" + url.filename();
    }
  } else {
    dest = d;
  }

  QString file = url.filename();

  Transfer *item = myTransferList->addTransfer();

  item->setSrc( s );
  item->setDest( dest );

  item->updateAll();

  myTransferList->clearSelection();

  if ( ksettings.b_useSound ) {
    KAudioPlayer::play( ksettings.audioAdded );
  }

  checkQueue();
}

caitoo'KMainWidget::checkQueue() (./kdenetwork/caitoo/kmainwidget.cpp:925)

void KMainWidget::checkQueue() {
  uint numRun = 0;
  int status;

  kDebugInfo( 5001,"Checking queue");

  Transfer *item;

  if ( !ksettings.b_offlineMode && b_online ) {

    TransferIterator it( myTransferList );
    // count running transfers
    for ( ; it.current(); ++it ) {
      status = it.current()->getStatus();
      if ( status == Transfer::ST_RUNNING ||
	   status == Transfer::ST_TRYING ||
	   status == Transfer::ST_SIZE_CHECK ||
	   status == Transfer::ST_SEARCH )
	numRun++;
    }

    it.reset();
    for ( ; it.current() && numRun < ksettings.maxSimultaneousConnections; ++it ) {
      item = it.current();
      status = item->getStatus();
      if ( ( status == Transfer::ST_STOPPED ||
	     status == Transfer::ST_RETRYING ||
	     status == Transfer::ST_SIZE_CHECK ||
	     status == Transfer::ST_SEARCH ) &&
	   item->getMode() == Transfer::MD_QUEUED ) {
	log( i18n("Starting another queued job.") );
	
	if ( status == Transfer::ST_SEARCH ) {
	  item->search();
	} else if ( status == Transfer::ST_SIZE_CHECK ) {
	  item->getSize();
	} else {
	  item->resume();
	  numRun++;
	}
      }
    }
  }

  int stat = myTransferList->downloadStatus();
  
  if ( stat != TransferList::STATUS_LOADING) { // disconnect only when we are not downloading
    if ( ksettings.b_autoDisconnect ) {
      disconnect();
    }
    
    // shutdown only when there are no scheduled downloads
    if ( stat != TransferList::STATUS_SCHEDULED && ksettings.b_autoShutdown ) {
      log( i18n("Quitting ...") );
      slotQuit();
    }
  }

  slotUpdateToolBar();
  updateStatusBar();
}

caitoo'KMainWidget::slotAnimTimeout() (./kdenetwork/caitoo/kmainwidget.cpp:988)

void KMainWidget::slotAnimTimeout(){
  bool isTransfer;

  animCounter++;
  if ( animCounter == myTransferList->getPhasesNum() ) {
    animCounter = 0;
  }

  // update status of all items of transferList
  isTransfer = myTransferList->updateStatus( animCounter );

  if ( this->isVisible() ) {
    updateStatusBar();
  }

  // update dock widget or drop target
  if ( ksettings.windowStyle == DOCKED || ksettings.windowStyle == DROP_TARGET ) {
    int count = 0;
    int progindex[4];

    for ( int i = 0; i < 4; i++ ) {
      progindex[i] = 0;
    }

    if ( isTransfer ) {
      TransferIterator it( myTransferList );
      Transfer *item;
      while ( count < 4 &&  it.current() ) {
	item = it.current();
	if ( ( item->getStatus() == Transfer::ST_RUNNING ||
	       item->getStatus() == Transfer::ST_TRYING )
	     && item->getMode() == Transfer::MD_QUEUED ) {
	  progindex[count] = item->getPercent();
	  count++;
	}
	it++;
      }

      if ( progindex[0] == 0 ) {  // this is a hack, so that dock widget and drop target show
	progindex[0]++;        // transfer in progress, even if percent is = 0
      }
    }

    if ( ksettings.windowStyle == DOCKED ) {
      kdock->setAnim( progindex[0], progindex[1], progindex[2], b_online );
    } else {
      kdrop->setAnim( progindex[0], progindex[1], progindex[2], progindex[3], b_online );
    }
  }

}

caitoo'KMainWidget::slotTransferTimeout() (./kdenetwork/caitoo/kmainwidget.cpp:1041)

void KMainWidget::slotTransferTimeout() {

  Transfer *item;
  TransferIterator it( myTransferList );

  bool flag = false;

  for ( ; it.current(); ++it ) {
    item = it.current();
    if ( item->getMode() == Transfer::MD_SCHEDULED &&
	 item->getStartTime() <= QDateTime::currentDateTime() ) {
      item->setMode( Transfer::MD_QUEUED );
      flag = true;
    }
  }

  if ( flag ) {
      checkQueue();
  }

  if ( ksettings.b_autoDisconnect && ksettings.b_timedDisconnect &&
       ksettings.disconnectTime <= QTime::currentTime() &&
       ksettings.disconnectDate == QDate::currentDate() ) {
    disconnect();
  }
}

caitoo'KMainWidget::slotAutosaveTimeout() (./kdenetwork/caitoo/kmainwidget.cpp:1069)

void KMainWidget::slotAutosaveTimeout() {
  writeTransfers();
}

caitoo'KMainWidget::slotStatusChanged() (./kdenetwork/caitoo/kmainwidget.cpp:1074)

void KMainWidget::slotStatusChanged( Transfer *item, int _operation ) {
  kDebugInfo( 5001, "slotStatusChanged" );

  switch ( _operation ) {
  case Transfer::OP_FINISHED:
    delete item;  // falling through
    
  case Transfer::OP_FINISHED_KEEP:
    if ( ksettings.b_useSound ) {
      if ( myTransferList->downloadStatus() == TransferList::STATUS_EMPTY ) {
	KAudioPlayer::play( ksettings.audioFinishedAll );
      } else {
	KAudioPlayer::play( ksettings.audioFinished );
      }
      break;
    }
    
  case Transfer::OP_RESUMED:
    if ( ksettings.b_useSound ) {
      KAudioPlayer::play( ksettings.audioStarted );
    }
    break;
    
  case Transfer::OP_CANCELED:
  case Transfer::OP_REMOVED:
    delete item;
    return;  // checkQueue() will be called only once after all deletions

  case Transfer::OP_SCHEDULED:
    slotTransferTimeout();  // this will check schedule times
    return;  // checkQueue() is called from slotTransferTimeout()

  case Transfer::OP_SIZE_CHECKED:
  case Transfer::OP_QUEUED:
  case Transfer::OP_DELAYED:
    break;
  }

  checkQueue();
}

caitoo'KMainWidget::dragEnterEvent() (./kdenetwork/caitoo/kmainwidget.cpp:1116)

void KMainWidget::dragEnterEvent(QDragEnterEvent* event) {
  event->accept( QUriDrag::canDecode(event) || QTextDrag::canDecode(event) );
}

caitoo'KMainWidget::dropEvent() (./kdenetwork/caitoo/kmainwidget.cpp:1121)

void KMainWidget::dropEvent( QDropEvent* event ) {
  QStrList list;
  QString str;
  if ( QUriDrag::decode(event, list) ) {
    addDropTransfers( &list );
  } else if ( QTextDrag::decode(event, str) ) {
    addTransfer( str );
  }
}

caitoo'KMainWidget::addDropTransfers() (./kdenetwork/caitoo/kmainwidget.cpp:1132)

void KMainWidget::addDropTransfers( QStrList *list ) {
  QString s;

  for ( s = list->first(); s != 0L; s = list->next() ) {
    addTransfer( s );
  }

  myTransferList->clearSelection();
}

caitoo'KMainWidget::slotCopyToClipboard() (./kdenetwork/caitoo/kmainwidget.cpp:1143)

void KMainWidget::slotCopyToClipboard() {
  Transfer *item = (Transfer*) myTransferList->currentItem();

  if ( item ) {
    QClipboard *cb = QApplication::clipboard();
    cb->setText( item->getSrc().path() ); // TODO : path() or filename()
    myTransferList->clearSelection();
  }
}

caitoo'KMainWidget::slotMoveToBegin() (./kdenetwork/caitoo/kmainwidget.cpp:1154)

void KMainWidget::slotMoveToBegin() {
  myTransferList->moveToBegin( (Transfer*) myTransferList->currentItem() );
}

caitoo'KMainWidget::slotMoveToEnd() (./kdenetwork/caitoo/kmainwidget.cpp:1159)

void KMainWidget::slotMoveToEnd() {
  myTransferList->moveToEnd( (Transfer*) myTransferList->currentItem() );
}

caitoo'KMainWidget::slotConfigCurrent() (./kdenetwork/caitoo/kmainwidget.cpp:1164)

void KMainWidget::slotConfigCurrent() {
  slotOpenConfigDialog();
  checkQueue();
}

caitoo'KMainWidget::slotOpenConfigDialog() (./kdenetwork/caitoo/kmainwidget.cpp:1170)

void KMainWidget::slotOpenConfigDialog() {
  Transfer *item = (Transfer*) myTransferList->currentItem();

  if ( item ) {
    new ConfigDlg( item );
  }
}

caitoo'KMainWidget::slotOpenDownloadWindow() (./kdenetwork/caitoo/kmainwidget.cpp:1179)

void KMainWidget::slotOpenDownloadWindow() {
  Transfer *item = (Transfer*) myTransferList->currentItem();

  if ( item ) {
    item->showProgressWindow();
  }
}

caitoo'KMainWidget::closeEvent() (./kdenetwork/caitoo/kmainwidget.cpp:1188)

void KMainWidget::closeEvent( QCloseEvent * ){
  slotQuit();
}

caitoo'KMainWidget::setAutoSave() (./kdenetwork/caitoo/kmainwidget.cpp:1193)

void KMainWidget::setAutoSave() {
  autosaveTimer->stop();
  if ( ksettings.b_autoSave ) {
    autosaveTimer->start( ksettings.autoSaveInterval*60000 );
  }
}

caitoo'KMainWidget::setAutoDisconnect() (./kdenetwork/caitoo/kmainwidget.cpp:1201)

void KMainWidget::setAutoDisconnect() {
  // disable action when we are connected permanently
  m_paAutoDisconnect->setEnabled( ksettings.connectionType != PERMANENT );
}

caitoo'KMainWidget::slotToggleStatusbar() (./kdenetwork/caitoo/kmainwidget.cpp:1207)

void KMainWidget::slotToggleStatusbar() {
  ksettings.b_showStatusbar = !ksettings.b_showStatusbar;

  if ( !ksettings.b_showStatusbar ) {
    statusBar()->hide();
  } else {
    statusBar()->show();
  }

  resizeEvent( 0L );
}

caitoo'KMainWidget::slotTogglePreferences() (./kdenetwork/caitoo/kmainwidget.cpp:1220)

void KMainWidget::slotTogglePreferences() {
  b_viewPreferences = !b_viewPreferences;

  if ( b_viewPreferences ) {
    prefDlg = new PreferencesDlg( 0L );
  } else {
    delete prefDlg;
  }
}

caitoo'KMainWidget::slotToggleLogWindow() (./kdenetwork/caitoo/kmainwidget.cpp:1231)

void KMainWidget::slotToggleLogWindow() {
  b_viewLogWindow = !b_viewLogWindow;

  if ( b_viewLogWindow ) {
    logWindow->show();
  } else {
    logWindow->hide();
  }
}

caitoo'KMainWidget::slotToggleAnimation() (./kdenetwork/caitoo/kmainwidget.cpp:1242)

void KMainWidget::slotToggleAnimation() {
  ksettings.b_useAnimation = !ksettings.b_useAnimation;

  if ( !ksettings.b_useAnimation && animTimer->isActive() ) {
    animTimer->stop();
    animTimer->start( 1000 );
    animCounter = 0;
  } else {
    animTimer->stop();
    animTimer->start( 400 );
  }
}

caitoo'KMainWidget::slotToggleSound() (./kdenetwork/caitoo/kmainwidget.cpp:1256)

void KMainWidget::slotToggleSound() {
  ksettings.b_useSound = !ksettings.b_useSound;
}

caitoo'KMainWidget::slotToggleOfflineMode() (./kdenetwork/caitoo/kmainwidget.cpp:1261)

void KMainWidget::slotToggleOfflineMode() {
  ksettings.b_offlineMode = !ksettings.b_offlineMode;

  if ( ksettings.b_offlineMode ) {
    log( i18n("Offline mode on.") );
    pauseAll();
  } else {
    log( i18n("Offline mode off.") );
  }

  checkQueue();
}

caitoo'KMainWidget::slotToggleExpertMode() (./kdenetwork/caitoo/kmainwidget.cpp:1275)

void KMainWidget::slotToggleExpertMode() {
  ksettings.b_expertMode = !ksettings.b_expertMode;

  if ( ksettings.b_expertMode ) {
    log( i18n("Expert mode on.") );
  } else {
    log( i18n("Expert mode off.") );
  }
}

caitoo'KMainWidget::slotToggleUseLastDir() (./kdenetwork/caitoo/kmainwidget.cpp:1286)

void KMainWidget::slotToggleUseLastDir() {
  ksettings.b_useLastDir = !ksettings.b_useLastDir;

  if ( ksettings.b_useLastDir ) {
    log( i18n("Use last directory on.") );
  } else {
    log( i18n("Use last directory off.") );
  }
}

caitoo'KMainWidget::slotToggleAutoDisconnect() (./kdenetwork/caitoo/kmainwidget.cpp:1297)

void KMainWidget::slotToggleAutoDisconnect() {
  ksettings.b_autoDisconnect = !ksettings.b_autoDisconnect;

  if ( ksettings.b_autoDisconnect ) {
    log( i18n("Auto disconnect on.") );
  } else {
    log( i18n("Auto disconnect off.") );
  }
}

caitoo'KMainWidget::slotToggleAutoShutdown() (./kdenetwork/caitoo/kmainwidget.cpp:1308)

void KMainWidget::slotToggleAutoShutdown() {
  ksettings.b_autoShutdown = !ksettings.b_autoShutdown;

  if ( ksettings.b_autoShutdown ) {
    log( i18n("Auto shutdown on.") );
  } else {
    log( i18n("Auto shutdown off.") );
  }
}

caitoo'KMainWidget::slotToggleAutoPaste() (./kdenetwork/caitoo/kmainwidget.cpp:1319)

void KMainWidget::slotToggleAutoPaste() {
  ksettings.b_autoPaste = !ksettings.b_autoPaste;

  if ( ksettings.b_autoPaste ) {
    log( i18n("Auto paste on.") );
  } else {
    log( i18n("Auto paste off.") );
  }
}

caitoo'KMainWidget::slotDock() (./kdenetwork/caitoo/kmainwidget.cpp:1330)

void KMainWidget::slotDock() {
  if ( ksettings.windowStyle == DOCKED ) {
    ksettings.windowStyle = NORMAL;
  } else {
    ksettings.windowStyle = DOCKED;
  }
  setWindowStyle();
}

caitoo'KMainWidget::slotDropTarget() (./kdenetwork/caitoo/kmainwidget.cpp:1340)

void KMainWidget::slotDropTarget() {
  if ( ksettings.windowStyle == DROP_TARGET ) {
    ksettings.windowStyle = NORMAL;
  } else {
    ksettings.windowStyle = DROP_TARGET;
  }
  setWindowStyle();
}

caitoo'KMainWidget::slotPopupMenu() (./kdenetwork/caitoo/kmainwidget.cpp:1350)

void KMainWidget::slotPopupMenu( Transfer *item ) {
  myTransferList->clearSelection();
  myTransferList->setSelected( item, true );

  // select current item
  myTransferList->setCurrentItem( item );

  // set action properties only for this item
  slotUpdateToolBar();

  // popup transfer menu at the position
  QWidget *menu = guiFactory()->container( "transfer", this );
  ((QPopupMenu*)menu)->popup(QCursor::pos() );
}

caitoo'KMainWidget::setListFont() (./kdenetwork/caitoo/kmainwidget.cpp:1366)

void KMainWidget::setListFont() {
  myTransferList->setFont( ksettings.listViewFont );
}

caitoo'KMainWidget::setWindowStyle() (./kdenetwork/caitoo/kmainwidget.cpp:1371)

void KMainWidget::setWindowStyle(){
  switch ( ksettings.windowStyle ) {
  case NORMAL:
    this->show();
    kdock->hide();
    kdrop->hide();
    //    KWM::switchToDesktop( KWM::desktop( winId() ) );
    break;
   
  case DOCKED:
    this->hide();
    kdock->show();
    kdrop->hide();
    break;

  case DROP_TARGET:
    this->hide();
    kdock->hide();
    kdrop->show();
    break;
  }
}

caitoo'KMainWidget::slotUpdateToolBar() (./kdenetwork/caitoo/kmainwidget.cpp:1395)

void KMainWidget::slotUpdateToolBar() {

  // disable all signals
  m_paQueue->blockSignals( true );
  m_paTimer->blockSignals( true );
  m_paDelay->blockSignals( true );

  // at first turn off all buttons like when nothing is selected
  m_paQueue->setChecked( false );
  m_paTimer->setChecked( false );
  m_paDelay->setChecked( false );

  m_paQueue->setEnabled( false );
  m_paTimer->setEnabled( false );
  m_paDelay->setEnabled( false );

  m_paDelete->setEnabled( false );
  m_paResume->setEnabled( false );
  m_paPause->setEnabled( false );
  m_paRestart->setEnabled( false );

  Transfer *item;
  Transfer *first_item = 0L;
  TransferIterator it( myTransferList );
  int index = 0;

  for ( ; it.current(); ++it ) {
    if ( it.current()->isSelected() ) {
      item = it.current();

      index++; // counting number of selected items
      if ( index == 1 ) {
	first_item = item; // store first selected item
      }

      m_paDelete->setEnabled( true );

      // enable PAUSE, RESUME and RESTART only when we are online and not in offline mode
      if ( ! ksettings.b_offlineMode && b_online ) {
	if ( item == first_item ) {
	  switch ( item->getStatus() ) {
	  case Transfer::ST_RUNNING :
	  case Transfer::ST_TRYING :
	    m_paResume->setEnabled( false );
	    m_paPause->setEnabled( true );
	    m_paRestart->setEnabled( true );
	    break;
	  case Transfer::ST_STOPPED :
	    m_paResume->setEnabled( true );
	    m_paPause->setEnabled( false );
	    m_paRestart->setEnabled( false );
	    break;
	  }
	} else if ( item->getStatus() != first_item->getStatus() ) {
	  // disable all when all selected items don't have the same status
	  m_paResume->setEnabled( false );
	  m_paPause->setEnabled( false );
	  m_paRestart->setEnabled( false );
	}
      }

      if ( item == first_item ) {
	if ( item->getStatus() != Transfer::ST_FINISHED ) {
	  m_paQueue->setEnabled( true );
	  m_paTimer->setEnabled( true );
	  m_paDelay->setEnabled( true );

	  switch ( item->getMode() ) {
	  case Transfer::MD_QUEUED :
	    m_paQueue->setChecked( true );
	    break;
	  case Transfer::MD_SCHEDULED :
	    m_paTimer->setChecked( true );
	    break;
	  case Transfer::MD_DELAYED :
	    m_paDelay->setChecked( true );
	    break;
	  }
	}
      } else if ( item->getMode() != first_item->getMode() ) {
	// unset all when all selected items don't have the same mode
	m_paQueue->setChecked( false );
	m_paTimer->setChecked( false );
	m_paDelay->setChecked( false );

	m_paQueue->setEnabled( false );
	m_paTimer->setEnabled( false );
	m_paDelay->setEnabled( false );
      }

    }  // when item is selected
  } // loop

  // disable all signals
  m_paQueue->blockSignals( false );
  m_paTimer->blockSignals( false );
  m_paDelay->blockSignals( false );
}

caitoo'KMainWidget::updateStatusBar() (./kdenetwork/caitoo/kmainwidget.cpp:1495)

void KMainWidget::updateStatusBar() {
  Transfer *item;
  QString tmpstr;

  int totalFiles = 0;
  int totalSize = 0;
  int totalSpeed = 0;
  QTime remTime;

  TransferIterator it( myTransferList );

  for ( ; it.current(); ++it ) {
    item = it.current();
    if ( item->getTotalSize() != 0 ) {
      totalSize += ( item->getTotalSize() - item->getProcessedSize() );
    }
    totalFiles += ( item->getTotalFiles() - item->getProcessedFiles() );
    totalSpeed += item->getSpeed();
    
    if ( item->getRemainingTime() > remTime ) {
      remTime = item->getRemainingTime();
    }
  }

  statusBar()->changeItem( i18n( " Transfers : %1 ").arg( myTransferList->childCount() ),
			   ID_TOTAL_TRANSFERS);
  statusBar()->changeItem( i18n( " Files : %1 ").arg( totalFiles ), ID_TOTAL_FILES);
  statusBar()->changeItem( i18n( " Size : %1 ").arg( KIO::convertSize( totalSize ) ),
			   ID_TOTAL_SIZE);
  statusBar()->changeItem( i18n( " Time : %1 ").arg( remTime.toString() ), ID_TOTAL_TIME);
  statusBar()->changeItem( i18n( " %1/s ").arg( KIO::convertSize( totalSpeed ) ),
			   ID_TOTAL_SPEED);
}

caitoo'KMainWidget::disconnect() (./kdenetwork/caitoo/kmainwidget.cpp:1530)

void KMainWidget::disconnect() {
  if ( !b_online ) {
      return;
  }

  if ( !ksettings.b_expertMode ) {
    if ( KMessageBox::questionYesNo(this, i18n("Do you really want to disconnect ?"),
				    i18n("Question") ) != KMessageBox::Yes ) {
      return;
    }
  }
  log( i18n("Disconnecting ...") );
  system( ksettings.disconnectCommand.ascii() );
}

caitoo'KMainWidget::slotCheckConnection() (./kdenetwork/caitoo/kmainwidget.cpp:1546)

void KMainWidget::slotCheckConnection() {
  checkOnline();
}

caitoo'KMainWidget::checkOnline() (./kdenetwork/caitoo/kmainwidget.cpp:1551)

void KMainWidget::checkOnline() {
  bool old = b_online;

  struct ifreq ifr;
  memset( & ifr, 0, sizeof (ifreq) );

  // setup the device name according to the type of connection and link number
  sprintf ( ifr.ifr_name, "%s%d",
	    ConnectionDevices[ksettings.connectionType].ascii(), ksettings.linkNumber );

  bool flag = false;
  if ( ksettings.connectionType != PERMANENT ) {
    // get the flags for particular device
    if (ioctl(_sock, SIOCGIFFLAGS, &ifr) < 0) {
      flag = true;
      b_online = false;
    } else if (ifr.ifr_flags == 0) {
      kDebugInfo( 5001, "Can't get flags from interface %s", ifr.ifr_name );
      b_online = false;
    } else if (ifr.ifr_flags & IFF_UP) { //   if (ifr.ifr_flags & IFF_RUNNING)
      b_online = true;
    } else {
      b_online = false;
    }
  } else {
    b_online = true; // PERMANENT connection
  }

  m_paOfflineMode->setEnabled( b_online );

  if ( b_online != old ) {
    if ( flag ) { // so that we write this only once when connection is changed
      kDebugInfo( 5001, "Unknown interface %s", ifr.ifr_name );
    }

    if ( b_online ) {
      log( i18n("We are online !") );
      checkQueue();
    } else {
      log( i18n("We are offline !") );
      pauseAll();
    }
  }
}


// Helper method for opening device socket