00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021
00022
00023
00024
00025
00026
00027
00028
00029 static const char *pilotdaemon_id =
00030 "$Id: pilotDaemon.cc,v 1.94 2003/10/13 21:33:27 goossens Exp $";
00031
00032
00033 #define ENABLE_KROUPWARE
00034
00035 #ifndef _KPILOT_OPTIONS_H
00036 #include "options.h"
00037 #endif
00038
00039 #include <time.h>
00040
00041 #ifdef TIME_WITH_SYS_TIME
00042 #include <sys/time.h>
00043 #endif
00044
00045 #include <sys/types.h>
00046 #include <sys/stat.h>
00047 #include <dirent.h>
00048 #include <fcntl.h>
00049 #include <unistd.h>
00050 #include <stdio.h>
00051 #include <stdlib.h>
00052 #include <signal.h>
00053 #include <errno.h>
00054
00055 #include <qdir.h>
00056 #include <qptrlist.h>
00057 #include <qcursor.h>
00058 #include <qptrstack.h>
00059 #include <qtimer.h>
00060 #include <qtooltip.h>
00061
00062 #include <kuniqueapplication.h>
00063 #include <kaboutdata.h>
00064 #include <kaboutapplication.h>
00065 #include <kcmdlineargs.h>
00066 #include <kwin.h>
00067 #include <ksimpleconfig.h>
00068 #include <kurl.h>
00069 #include <ksock.h>
00070 #include <kmessagebox.h>
00071 #include <kstandarddirs.h>
00072 #include <kpopupmenu.h>
00073 #include <kiconloader.h>
00074 #include <kio/netaccess.h>
00075 #include <kdebug.h>
00076 #include <ktempfile.h>
00077 #include <kprocess.h>
00078 #include <dcopclient.h>
00079 #include <kurldrag.h>
00080
00081 #include "pilotAppCategory.h"
00082
00083 #include "fileInstaller.h"
00084 #include "kpilotConfig.h"
00085 #include "pilotUser.h"
00086
00087 #include "hotSync.h"
00088 #include "interactiveSync.h"
00089 #include "syncStack.h"
00090 #include "internalEditorAction.h"
00091
00092 #ifdef ENABLE_KROUPWARE
00093 #include "kroupware.h"
00094 #endif
00095
00096 #include "kpilotDCOP_stub.h"
00097 #include "kpilotDCOP.h"
00098 #include "logWidgetDCOP_stub.h"
00099
00100 #include "pilotDaemon.moc"
00101
00102
00103 PilotDaemonTray::PilotDaemonTray(PilotDaemon * p) :
00104 KSystemTray(0, "pilotDaemon"),
00105 daemon(p),
00106 kap(0L)
00107 {
00108 FUNCTIONSETUP;
00109 setupWidget();
00110 setAcceptDrops(true);
00111
00112
00113
00114 (void) pilotdaemon_id;
00115 }
00116
00117 void PilotDaemonTray::dragEnterEvent(QDragEnterEvent * e)
00118 {
00119 FUNCTIONSETUP;
00120 e->accept(KURLDrag::canDecode(e));
00121 }
00122
00123 void PilotDaemonTray::dropEvent(QDropEvent * e)
00124 {
00125 FUNCTIONSETUP;
00126
00127 KURL::List list;
00128
00129 KURLDrag::decode(e, list);
00130
00131 QStringList files;
00132 for(KURL::List::ConstIterator it = list.begin(); it != list.end(); ++it)
00133 {
00134 if ((*it).isLocalFile())
00135 files << (*it).path();
00136 }
00137
00138 daemon->addInstallFiles(files);
00139 }
00140
00141 void PilotDaemonTray::mousePressEvent(QMouseEvent * e)
00142 {
00143 FUNCTIONSETUP;
00144
00145 switch (e->button())
00146 {
00147 case RightButton:
00148 {
00149 KPopupMenu *menu = contextMenu();
00150 contextMenuAboutToShow(menu);
00151 menu->popup(e->globalPos());
00152 }
00153 break;
00154 case LeftButton:
00155 if (daemon) daemon->slotRunKPilot();
00156 break;
00157 default:
00158 KSystemTray::mousePressEvent(e);
00159 }
00160 }
00161
00162 void PilotDaemonTray::closeEvent(QCloseEvent *)
00163 {
00164 FUNCTIONSETUP;
00165 daemon->quitNow();
00166 }
00167
00168 void PilotDaemonTray::setupWidget()
00169 {
00170 FUNCTIONSETUP;
00171
00172 KGlobal::iconLoader()->addAppDir(CSL1("kpilot"));
00173 icon = SmallIcon(CSL1("hotsync"));
00174 busyicon = SmallIcon(CSL1("busysync"));
00175
00176 slotShowBusy();
00177 QTimer::singleShot(2000,this,SLOT(slotShowNormal()));
00178
00179 KPopupMenu *menu = contextMenu();
00180
00181 menu->insertItem(i18n("&About"), this, SLOT(slotShowAbout()));
00182 menuKPilotItem = menu->insertItem(i18n("Start &KPilot"), daemon,
00183 SLOT(slotRunKPilot()));
00184
00185 menuConfigureConduitsItem = menu->insertItem(i18n("&Configure Conduits..."),
00186 daemon, SLOT(slotRunConduitConfig()));
00187
00188 #ifdef DEBUG
00189 DEBUGDAEMON << fname << ": Finished getting icons" << endl;
00190 #endif
00191 }
00192
00193 void PilotDaemonTray::slotShowAbout()
00194 {
00195 FUNCTIONSETUP;
00196
00197 if (!kap)
00198 {
00199 kap = new KAboutApplication(0, "kpdab", false);
00200 }
00201
00202 kap->show();
00203 }
00204
00205
00206 void PilotDaemonTray::enableRunKPilot(bool b)
00207 {
00208 FUNCTIONSETUP;
00209 contextMenu()->setItemEnabled(menuKPilotItem, b);
00210 contextMenu()->setItemEnabled(menuConfigureConduitsItem, b);
00211 }
00212
00213
00214 void PilotDaemonTray::changeIcon(IconShape i)
00215 {
00216 FUNCTIONSETUP;
00217
00218 switch (i)
00219 {
00220 case Normal:
00221 if (icon.isNull())
00222 {
00223 kdWarning() << k_funcinfo
00224 << ": Regular icon is NULL!" << endl;
00225 }
00226 setPixmap(icon);
00227 break;
00228 case Busy:
00229 if (busyicon.isNull())
00230 {
00231 kdWarning() << k_funcinfo
00232 << ": Busy icon is NULL!" << endl;
00233 }
00234 setPixmap(busyicon);
00235 break;
00236 default:
00237 kdWarning() << k_funcinfo
00238 << ": Bad icon number " << (int) i << endl;
00239 }
00240 }
00241
00242 void PilotDaemonTray::slotShowNormal()
00243 {
00244 FUNCTIONSETUP;
00245 changeIcon(Normal);
00246 }
00247
00248 void PilotDaemonTray::slotShowBusy()
00249 {
00250 FUNCTIONSETUP;
00251 changeIcon(Busy);
00252 }
00253
00254
00255
00256 PilotDaemon::PilotDaemon() :
00257 DCOPObject("KPilotDaemonIface"),
00258 fStatus(INIT),
00259 fPostSyncAction(None),
00260 fPilotLink(0L),
00261 fPilotDevice(QString::null),
00262 fNextSyncType(PilotDaemonDCOP::HotSync),
00263 fSyncStack(0L),
00264 fTray(0L),
00265 fInstaller(0L),
00266 fLogStub(new LoggerDCOP_stub("kpilot", "LogIface")),
00267 fKPilotStub(new KPilotDCOP_stub("kpilot", "KPilotIface"))
00268 {
00269 FUNCTIONSETUP;
00270
00271 setupPilotLink();
00272 reloadSettings();
00273
00274 if (fStatus == ERROR)
00275 {
00276 kdWarning() << k_funcinfo
00277 << ": Connecting to device failed." << endl;
00278 return;
00279 }
00280
00281 fInstaller = new FileInstaller;
00282 connect(fInstaller, SIGNAL(filesChanged()),
00283 this, SLOT(slotFilesChanged()));
00284
00285
00286 #ifdef DEBUG
00287 DEBUGDAEMON << fname
00288 << ": The daemon is ready with status "
00289 << statusString() << " (" << (int) fStatus << ")" << endl;
00290 #endif
00291 }
00292
00293 PilotDaemon::~PilotDaemon()
00294 {
00295 FUNCTIONSETUP;
00296
00297 KPILOT_DELETE(fPilotLink);
00298 KPILOT_DELETE(fSyncStack);
00299 KPILOT_DELETE(fInstaller);
00300 }
00301
00302 void PilotDaemon::addInstallFiles(const QStringList &l)
00303 {
00304 FUNCTIONSETUP;
00305
00306 fInstaller->addFiles( l, fTray );
00307 }
00308
00309 int PilotDaemon::getPilotSpeed(KPilotConfigSettings & config)
00310 {
00311 FUNCTIONSETUP;
00312
00313 int speed = config.getPilotSpeed();
00314
00315
00316
00317
00318
00319
00320 const char *speedname = 0L;
00321
00322 switch (speed)
00323 {
00324 case 0:
00325 speedname = "PILOTRATE=9600";
00326 break;
00327 case 1:
00328 speedname = "PILOTRATE=19200";
00329 break;
00330 case 2:
00331 speedname = "PILOTRATE=38400";
00332 break;
00333 case 3:
00334 speedname = "PILOTRATE=57600";
00335 break;
00336 case 4:
00337 speedname = "PILOTRATE=115200";
00338 break;
00339 default:
00340 speedname = "PILOTRATE=9600";
00341 }
00342
00343 #ifdef DEBUG
00344 DEBUGDAEMON << fname
00345 << ": Speed set to "
00346 << speedname << " (" << speed << ")" << endl;
00347 #endif
00348
00349 putenv((char *) speedname);
00350
00351 return speed;
00352 }
00353
00354
00355 void PilotDaemon::showTray()
00356 {
00357 FUNCTIONSETUP;
00358
00359 if (!fTray)
00360 {
00361 #ifdef DEBUG
00362 DEBUGDAEMON << fname << ": No tray icon to display!" << endl;
00363 #endif
00364
00365 return;
00366 }
00367
00368
00369 KWin::setSystemTrayWindowFor(fTray->winId(), 0);
00370 fTray->setGeometry(-100, -100, 42, 42);
00371 fTray->show();
00372
00373 #ifdef DEBUG
00374 DEBUGDAEMON << fname << ": Tray icon displayed." << endl;
00375 #endif
00376
00377 updateTrayStatus();
00378 }
00379
00380 void PilotDaemon::reloadSettings()
00381 {
00382 FUNCTIONSETUP;
00383
00384 switch (fStatus)
00385 {
00386 case INIT:
00387 case HOTSYNC_END:
00388 case ERROR:
00389 case READY:
00390
00391 break;
00392 case HOTSYNC_START:
00393 case FILE_INSTALL_REQ:
00394
00395 fPostSyncAction |= ReloadSettings;
00396 return;
00397 break;
00398 }
00399
00400 KPilotConfigSettings & config = KPilotConfig::getConfig();
00401 config.reparseConfiguration();
00402
00403 getPilotSpeed(config);
00404
00405 fPilotDevice = config.getPilotDevice();
00406 fPilotType = KPilotDeviceLink::None;
00407
00408 (void) PilotAppCategory::setupPilotCodec(config.getEncoding());
00409
00410 #ifdef DEBUG
00411 DEBUGDAEMON << fname
00412 << ": Got configuration "
00413 << fPilotDevice
00414 << " ("
00415 << fPilotType
00416 << ")"
00417 << endl;
00418 #endif
00419
00420
00421
00422
00423
00424
00425
00426 fPilotType = KPilotDeviceLink::OldStyleUSB;
00427
00428 if (fPilotLink)
00429 {
00430 #ifdef DEBUG
00431 DEBUGDAEMON << fname
00432 << ": Resetting with device "
00433 << fPilotDevice
00434 << " and type "
00435 << fPilotLink->deviceTypeString(fPilotType) << endl;
00436 #endif
00437
00438 fPilotLink->reset(fPilotType, fPilotDevice);
00439 }
00440
00441 if (config.getDockDaemon())
00442 {
00443 if (!fTray)
00444 {
00445 fTray = new PilotDaemonTray(this);
00446 fTray->show();
00447 }
00448 else
00449 {
00450 fTray->show();
00451 }
00452 }
00453 else
00454 {
00455 if (fTray)
00456 {
00457 fTray->hide();
00458 delete fTray;
00459
00460 fTray = 0L;
00461 }
00462 }
00463
00464 updateTrayStatus();
00465 }
00466
00467 QString PilotDaemon::statusString()
00468 {
00469 FUNCTIONSETUP;
00470
00471 QString s = CSL1("PilotDaemon=");
00472
00473 switch (status())
00474 {
00475 case INIT:
00476 s.append(QString(CSL1("Initializing")));
00477 break;
00478 case READY:
00479 s.append(QString(CSL1("Found device")));
00480 break;
00481 case ERROR:
00482 s.append(QString(CSL1("Error")));
00483 break;
00484 case FILE_INSTALL_REQ:
00485 s.append(QString(CSL1("Installing File")));
00486 break;
00487 case HOTSYNC_END:
00488 s.append(QString(CSL1("End of Hotsync")));
00489 break;
00490 case HOTSYNC_START:
00491 s.append(QString(CSL1("Syncing")));
00492 break;
00493 }
00494
00495 s.append(CSL1(" NextSync="));
00496 s.append(syncTypeString(fNextSyncType));
00497
00498 s.append(CSL1(" ("));
00499 if (fPilotLink)
00500 {
00501 s.append(fPilotLink->statusString());
00502 }
00503 s.append(CSL1(")"));
00504
00505 return s;
00506 }
00507
00508
00509
00510 bool PilotDaemon::setupPilotLink()
00511 {
00512 FUNCTIONSETUP;
00513
00514 if (fPilotLink)
00515 {
00516 delete fPilotLink;
00517
00518 fPilotLink = 0;
00519 }
00520
00521 fPilotLink = KPilotDeviceLink::init();
00522 if (!fPilotLink)
00523 {
00524 kdWarning() << k_funcinfo
00525 << ": Can't get pilot link." << endl;
00526 return false;
00527 }
00528
00529 QObject::connect(fPilotLink, SIGNAL(deviceReady()),
00530 this, SLOT(startHotSync()));
00531
00532 QObject::connect(fPilotLink, SIGNAL(logError(const QString &)),
00533 this, SLOT(logError(const QString &)));
00534 QObject::connect(fPilotLink, SIGNAL(logMessage(const QString &)),
00535 this, SLOT(logMessage(const QString &)));
00536 QObject::connect(fPilotLink,
00537 SIGNAL(logProgress(const QString &,int)),
00538 this, SLOT(logProgress(const QString &,int)));
00539
00540
00541 return true;
00542 }
00543
00544
00545 void PilotDaemon::quitNow()
00546 {
00547 FUNCTIONSETUP;
00548
00549
00550
00551 switch (fStatus)
00552 {
00553 case INIT:
00554 case HOTSYNC_END:
00555 case ERROR:
00556 getKPilot().daemonStatus(KPilotDCOP::DaemonQuit);
00557 kapp->quit();
00558 break;
00559 case READY:
00560 case HOTSYNC_START:
00561 case FILE_INSTALL_REQ:
00562 fPostSyncAction |= Quit;
00563 break;
00564 }
00565 }
00566
00567 void PilotDaemon::requestRegularSyncNext()
00568 {
00569 requestSync(PilotDaemonDCOP::HotSync);
00570 }
00571
00572 void PilotDaemon::requestFastSyncNext()
00573 {
00574 requestSync(PilotDaemonDCOP::FastSync);
00575 }
00576
00577
00578 void PilotDaemon::requestSync(int mode)
00579 {
00580 FUNCTIONSETUP;
00581
00582 #ifdef DEBUG
00583 DEBUGDAEMON << fname
00584 << ": Next sync is: "
00585 << syncTypeString(mode)
00586 << endl ;
00587 #endif
00588
00589 fNextSyncType = mode;
00590
00591 updateTrayStatus();
00592 }
00593
00594 int PilotDaemon::nextSyncType() const
00595 {
00596 return fNextSyncType;
00597 }
00598
00599 QString PilotDaemon::syncTypeString(int i) const
00600 {
00601 FUNCTIONSETUP;
00602 switch (i)
00603 {
00604 case PilotDaemonDCOP::Test:
00605 return QString(CSL1("Test"));
00606 case PilotDaemonDCOP::HotSync:
00607 return QString(CSL1("HotSync"));
00608 case PilotDaemonDCOP::FastSync:
00609 return QString(CSL1("FastSync"));
00610 case PilotDaemonDCOP::Backup:
00611 return QString(CSL1("Backup"));
00612 case PilotDaemonDCOP::Restore:
00613 return QString(CSL1("Restore"));
00614 default:
00615 return QString(CSL1("<unknown>"));
00616 }
00617 }
00618
00619 void PilotDaemon::startHotSync()
00620 {
00621 FUNCTIONSETUP;
00622
00623
00624 if (fTray)
00625 {
00626 #ifdef DEBUG
00627 DEBUGKPILOT << fname << ": Changing tray icon." << endl;
00628 #endif
00629
00630 fTray->changeIcon(PilotDaemonTray::Busy);
00631 }
00632
00633
00634 getKPilot().daemonStatus(KPilotDCOP::StartOfHotSync);
00635
00636 fStatus = HOTSYNC_START ;
00637 int mode=0;
00638 bool pcchanged=false;
00639
00640 #ifdef DEBUG
00641 DEBUGDAEMON << fname
00642 << ": Starting Sync with type "
00643 << syncTypeString(fNextSyncType)
00644 << " (" << fNextSyncType << ")" << endl;
00645 #endif
00646
00647 KPilotConfigSettings &c = KPilotConfig::getConfig();
00648 QStringList conduits( c.getInstalledConduits() );
00649 if ( (conduits.findIndex( CSL1("internal_fileinstall") ) >= 0) &&
00650 fInstaller) mode |= ActionQueue::WithInstaller;
00651
00652
00653 fSyncStack = new ActionQueue(fPilotLink);
00654
00655 #ifdef ENABLE_KROUPWARE
00656 bool _syncWithKMail = false;
00657 int _kroupwareParts = 0;
00658 #endif
00659
00666 int kpilotstatus = getKPilot().kpilotStatus();
00667 DCOPStub::Status callstatus = getKPilot().status();
00668
00669 #ifdef DEBUG
00670 if (callstatus != DCOPStub::CallSucceeded)
00671 {
00672 DEBUGDAEMON << fname <<
00673 ": Could not call KPilot for status." << endl;
00674 }
00675 else
00676 {
00677 DEBUGDAEMON << fname << ": KPilot status " << kpilotstatus << endl;
00678 }
00679 #endif
00680
00684 if ((callstatus == DCOPStub::CallSucceeded) &&
00685 (kpilotstatus != KPilotDCOP::WaitingForDaemon))
00686 {
00687 kdWarning() << k_funcinfo <<
00688 ": KPilot returned status " << kpilotstatus << endl;
00689
00690 fSyncStack->queueInit();
00691 fSyncStack->addAction(new SorryAction(fPilotLink));
00692
00693
00694 goto launch;
00695 }
00696 else
00697 {
00698 fSyncStack->queueInit(ActionQueue::WithUserCheck);
00699 }
00700
00701 #ifdef ENABLE_KROUPWARE
00702 if ( conduits.findIndex( CSL1("internal_kroupware") ) >= 0 )
00703 {
00704 logMessage( i18n("Kroupware syncing is enabled.") );
00705
00706 QString errmsg;
00707 if (!KroupwareSync::startKMail(&errmsg))
00708 {
00709 logMessage( i18n("Could not start KMail. The "
00710 "error message was: %1.").arg(errmsg));
00711 }
00712
00713 _syncWithKMail = true;
00714
00715 if (conduits.findIndex( CSL1("vcal-conduit") ) >= 0 )
00716 _kroupwareParts |= KroupwareSync::Cal ;
00717 if (conduits.findIndex( CSL1("todo-conduit") ) >= 0 )
00718 _kroupwareParts |= KroupwareSync::Todo ;
00719 if (conduits.findIndex( CSL1("knotes-conduit") ) >= 0 )
00720 _kroupwareParts |= KroupwareSync::Notes ;
00721 if (conduits.findIndex( CSL1("abbrowser_conduit") ) >= 0 )
00722 _kroupwareParts |= KroupwareSync::Address ;
00723 }
00724
00725 if (_syncWithKMail)
00726 {
00727 fSyncStack->addAction(new KroupwareSync(true ,
00728 _kroupwareParts,fPilotLink));
00729 }
00730 #endif
00731
00732 switch (fNextSyncType)
00733 {
00734 case PilotDaemonDCOP::Test:
00735 fSyncStack->addAction(new TestLink(fPilotLink));
00736
00737 break;
00738 case PilotDaemonDCOP::Backup:
00739 mode |= ActionQueue::BackupMode | ActionQueue::FlagFull;
00740 if (conduits.count() > 0)
00741 {
00742 fSyncStack->queueConduits(&KPilotConfig::getConfig(),
00743 conduits, mode);
00744 }
00745 fSyncStack->addAction(new BackupAction(fPilotLink, mode));
00746 break;
00747 case PilotDaemonDCOP::Restore:
00748 mode |= ActionQueue::RestoreMode | ActionQueue::FlagFull;
00749 fSyncStack->addAction(new RestoreAction(fPilotLink));
00750 if (mode & ActionQueue::WithInstaller)
00751 {
00752 fSyncStack->queueInstaller(fInstaller->dir(),
00753 fInstaller->fileNames());
00754 }
00755 break;
00756 case PilotDaemonDCOP::HotSync:
00757
00758
00759 mode |= ActionQueue::HotSyncMode;
00760 if (mode & ActionQueue::WithInstaller)
00761 {
00762 fSyncStack->queueInstaller(fInstaller->dir(),
00763 fInstaller->fileNames());
00764 }
00765 switch (c.getSyncType())
00766 {
00767 case SyncAction::eFastSync:
00768 break;
00769 case SyncAction::eHotSync:
00770 mode |= ActionQueue::WithBackup;
00771 break;
00772 case SyncAction::eFullSync:
00773 mode |= ActionQueue::WithBackup | ActionQueue::FlagFull;
00774 break;
00775 case SyncAction::eCopyPCToHH:
00776 mode |= ActionQueue::FlagPCToHH;
00777 break;
00778 case SyncAction::eCopyHHToPC:
00779 mode |= ActionQueue::FlagHHToPC;
00780 break;
00781 }
00782 if (c.getInternalEditors() && !(mode & ActionQueue::FlagHHToPC) )
00783 {
00784 fSyncStack->addAction(new InternalEditorAction(fPilotLink, mode));
00785 }
00786
00787 {
00788 KPilotUser *usr = fPilotLink->getPilotUser();
00789
00790
00791
00792 pcchanged = usr->getLastSyncPC() !=(unsigned long) gethostid();
00793 }
00794
00795 if (conduits.count() > 0)
00796 {
00797 fSyncStack->queueConduits(&KPilotConfig::getConfig(),
00798 conduits, pcchanged?(mode|ActionQueue::FlagFull):mode);
00799 }
00800 if (pcchanged && c.getFullSyncOnPCChange())
00801 mode |= (ActionQueue::WithBackup | ActionQueue::FlagFull);
00802 #ifdef DEBUG
00803 DEBUGDAEMON << fname
00804 << ": Sync Mode="
00805 << mode << ", Sync Type="<<c.getSyncType()<<endl;
00806 #endif
00807 if (mode & ActionQueue::WithBackup)
00808 fSyncStack->addAction(new BackupAction(fPilotLink, mode));
00809 break;
00810 default:
00811 #ifdef DEBUG
00812 DEBUGDAEMON << fname
00813 << ": Can't handle sync type "
00814 << syncTypeString(fNextSyncType) << endl;
00815 #endif
00816 break;
00817 }
00818
00819 #ifdef ENABLE_KROUPWARE
00820 if (_syncWithKMail)
00821 {
00822 fSyncStack->addAction(new KroupwareSync(false ,
00823 _kroupwareParts,fPilotLink));
00824 }
00825 #endif
00826
00827
00828
00829 launch:
00830 fSyncStack->queueCleanup();
00831
00832 QObject::connect(fSyncStack, SIGNAL(logError(const QString &)),
00833 this, SLOT(logError(const QString &)));
00834 QObject::connect(fSyncStack, SIGNAL(logMessage(const QString &)),
00835 this, SLOT(logMessage(const QString &)));
00836 QObject::connect(fSyncStack,
00837 SIGNAL(logProgress(const QString &,int)),
00838 this, SLOT(logProgress(const QString &,int)));
00839
00840 QObject::connect(fSyncStack, SIGNAL(syncDone(SyncAction *)),
00841 this, SLOT(endHotSync()));
00842
00843 QTimer::singleShot(0,fSyncStack,SLOT(execConduit()));
00844
00845 updateTrayStatus();
00846 }
00847
00848 void PilotDaemon::logMessage(const QString & s)
00849 {
00850 FUNCTIONSETUPL(2);
00851
00852 getLogger().logMessage(s);
00853 updateTrayStatus(s);
00854 }
00855
00856 void PilotDaemon::logError(const QString & s)
00857 {
00858 FUNCTIONSETUP;
00859
00860 getLogger().logError(s);
00861 updateTrayStatus(s);
00862 }
00863
00864 void PilotDaemon::logProgress(const QString & s, int i)
00865 {
00866 FUNCTIONSETUPL(2);
00867
00868 getLogger().logProgress(s, i);
00869 if (!s.isEmpty()) updateTrayStatus(s);
00870 }
00871
00872 void PilotDaemon::endHotSync()
00873 {
00874 FUNCTIONSETUP;
00875
00876 if (fTray)
00877 {
00878 QTimer::singleShot(2000,fTray,SLOT(slotShowNormal()));
00879 }
00880
00881 KPILOT_DELETE(fSyncStack);
00882 fPilotLink->close();
00883
00884 getLogger().logProgress(i18n("HotSync Completed.<br>"), 100);
00885 getKPilot().daemonStatus(KPilotDCOP::EndOfHotSync);
00886
00887 fStatus = HOTSYNC_END;
00888
00889 if (fPostSyncAction & Quit)
00890 {
00891 getKPilot().daemonStatus(KPilotDCOP::DaemonQuit);
00892 kapp->quit();
00893 }
00894 if (fPostSyncAction & ReloadSettings)
00895 {
00896 reloadSettings();
00897 }
00898 else
00899 {
00900 QTimer::singleShot(2000,fPilotLink,SLOT(reset()));
00901 }
00902
00903 fPostSyncAction = None;
00904
00905 updateTrayStatus();
00906 }
00907
00908
00909 void PilotDaemon::slotFilesChanged()
00910 {
00911 FUNCTIONSETUP;
00912 }
00913
00914 void PilotDaemon::slotRunKPilot()
00915 {
00916 FUNCTIONSETUP;
00917
00918 QString kpilotError;
00919 QCString kpilotDCOP;
00920 int kpilotPID;
00921
00922 if (KApplication::startServiceByDesktopName(CSL1("kpilot"),
00923 QString::null, &kpilotError, &kpilotDCOP, &kpilotPID
00924 #if (KDE_VERSION >= 220)
00925
00926 , ""
00927 #endif
00928 ))
00929 {
00930 kdWarning() << k_funcinfo
00931 << ": Couldn't start KPilot! " << kpilotError << endl;
00932 }
00933 else
00934 {
00935 #ifdef DEBUG
00936 DEBUGDAEMON << fname
00937 << ": Started KPilot with DCOP name "
00938 << kpilotDCOP << " (pid " << kpilotPID << ")" << endl;
00939 #endif
00940 }
00941 }
00942
00943 void PilotDaemon::slotRunConduitConfig()
00944 {
00945 FUNCTIONSETUP;
00946
00947
00948
00949
00950
00951
00952
00953
00954
00955
00956
00957
00958
00959 DCOPClient *client = kapp->dcopClient();
00960
00961
00962
00963
00964 if (client->send("kpilot", "kpilot-mainwindow#1", "raise()",
00965 QString::null))
00966 {
00967 client->send("kpilot", "KPilotIface", "configureConduits()",
00968 QString::null);
00969 }
00970 else
00971 {
00972 KProcess *p = new KProcess;
00973 *p << "kpilot" << "-c";
00974
00975 p->start();
00976 }
00977 }
00978
00979 void PilotDaemon::updateTrayStatus(const QString &s)
00980 {
00981 if (!fTray) return;
00982
00983 QToolTip::remove(fTray);
00984 QToolTip::add(fTray,
00985 i18n("<qt>%1<br/>%2</qt>")
00986 .arg(statusString())
00987 .arg(s)
00988 );
00989 }
00990
00991 static KCmdLineOptions daemonoptions[] = {
00992 { "dummy", I18N_NOOP("Dummy command line argument."), 0},
00993 #ifdef DEBUG
00994 {"debug <level>", I18N_NOOP("Set debugging level"), "0"},
00995 #endif
00996 KCmdLineLastOption
00997 } ;
00998
00999
01000 int main(int argc, char **argv)
01001 {
01002 FUNCTIONSETUP;
01003
01004 KAboutData about("kpilotDaemon",
01005 I18N_NOOP("KPilot Daemon"),
01006 KPILOT_VERSION,
01007 "KPilot - HotSync software for KDE\n\n",
01008 KAboutData::License_GPL, "(c) 1998-2001, Dan Pilone");
01009 about.addAuthor("Dan Pilone",
01010 I18N_NOOP("Project Leader"),
01011 "pilone@slac.com", "http://www.slac.com/pilone/kpilot_home/");
01012 about.addAuthor("Adriaan de Groot",
01013 I18N_NOOP("Maintainer"),
01014 "groot@kde.org", "http://www.cs.kun.nl/~adridg/kpilot/");
01015
01016 KCmdLineArgs::init(argc, argv, &about);
01017 KCmdLineArgs::addCmdLineOptions(daemonoptions,"kpilotconfig");
01018 KUniqueApplication::addCmdLineOptions();
01019 KCmdLineArgs *p = KCmdLineArgs::parsedArgs();
01020
01021 #ifdef DEBUG
01022 KPilotConfig::getDebugLevel(p);
01023 #endif
01024
01025 if (!KUniqueApplication::start())
01026 {
01027 return 0;
01028 }
01029 KUniqueApplication a(true, true);
01030
01031
01032
01033
01034 {
01035 KPilotConfigSettings & c = KPilotConfig::getConfig();
01036 c.setReadOnly(false);
01037
01038 if (c.getVersion() < KPilotConfig::ConfigurationVersion)
01039 {
01040 kdError() << k_funcinfo
01041 << ": Is still not configured for use."
01042 << endl;
01043 KPilotConfig::sorryVersionOutdated(c.getVersion());
01044 return 1;
01045 }
01046
01047 #ifdef DEBUG
01048 DEBUGDAEMON << fname
01049 << ": Configuration version "
01050 << c.getVersion() << endl;
01051 #endif
01052 }
01053
01054
01055 PilotDaemon *gPilotDaemon = new PilotDaemon();
01056
01057 if (gPilotDaemon->status() == PilotDaemon::ERROR)
01058 {
01059 delete gPilotDaemon;
01060
01061 gPilotDaemon = 0;
01062 kdError() << k_funcinfo
01063 << ": **\n"
01064 ": Failed to start up daemon\n"
01065 ": due to errors constructing it.\n" ": **" << endl;
01066 return 2;
01067 }
01068
01069 gPilotDaemon->showTray();
01070
01071 return a.exec();
01072
01073
01074 (void) pilotdaemon_id;
01075 }
01076
01077
01078