You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
412 lines
11 KiB
412 lines
11 KiB
#ifndef _KPILOT_SYNCACTION_H
|
|
#define _KPILOT_SYNCACTION_H
|
|
/* KPilot
|
|
**
|
|
** Copyright (C) 1998-2001 by Dan Pilone
|
|
** Copyright (C) 2003-2004 Reinhold Kainhofer <reinhold@kainhofer.com>
|
|
** Copyright (C) 2006 Adriaan de Groot <groot@kde.org>
|
|
**
|
|
*/
|
|
|
|
/*
|
|
** This program is free software; you can redistribute it and/or modify
|
|
** it under the terms of the GNU Lesser General Public License as published by
|
|
** the Free Software Foundation; either version 2.1 of the License, or
|
|
** (at your option) any later version.
|
|
**
|
|
** This program is distributed in the hope that it will be useful,
|
|
** but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
** GNU Lesser General Public License for more details.
|
|
**
|
|
** You should have received a copy of the GNU Lesser General Public License
|
|
** along with this program in a file called COPYING; if not, write to
|
|
** the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
|
|
** MA 02110-1301, USA.
|
|
*/
|
|
|
|
/*
|
|
** Bug reports and questions can be sent to kde-pim@kde.org
|
|
*/
|
|
|
|
#include <time.h>
|
|
|
|
#include <pi-dlp.h>
|
|
|
|
#include <tqobject.h>
|
|
#include <tqstring.h>
|
|
#include <tqstringlist.h>
|
|
|
|
#include "kpilotlink.h"
|
|
|
|
/** @file
|
|
* SyncAction
|
|
*/
|
|
|
|
class TQTimer;
|
|
class KPilotUser;
|
|
class SyncAction;
|
|
|
|
class TDE_EXPORT SyncAction : public TQObject
|
|
{
|
|
TQ_OBJECT
|
|
|
|
|
|
public:
|
|
SyncAction(KPilotLink *p,
|
|
const char *name=0L);
|
|
SyncAction(KPilotLink *p,
|
|
TQWidget *visibleparent,
|
|
const char *name=0L);
|
|
~SyncAction();
|
|
|
|
typedef enum { Error=-1 } Status;
|
|
|
|
/** A syncaction has a status, which can be expressed as an
|
|
* integer. Subclasses are expected to define their own status
|
|
* values as needed.
|
|
*/
|
|
int status() const
|
|
{
|
|
return fActionStatus;
|
|
}
|
|
/** Return a human-readable representation of the status. */
|
|
virtual TQString statusString() const;
|
|
|
|
protected:
|
|
/**
|
|
* This function starts the actual processing done
|
|
* by the conduit. It should return false if the
|
|
* processing cannot be initiated, f.ex. because
|
|
* some parameters were not set or a needed library
|
|
* is missing. This will be reported to the user.
|
|
* It should return true if processing is started
|
|
* normally. If processing starts normally, it is
|
|
* the _conduit's_ responsibility to eventually
|
|
* emit syncDone(); if processing does not start
|
|
* normally (ie. exec() returns false) then the
|
|
* environment will deal with syncDone().
|
|
*/
|
|
virtual bool exec() = 0;
|
|
|
|
public slots:
|
|
/**
|
|
* This just calls exec() and deals with the
|
|
* return code.
|
|
*/
|
|
void execConduit();
|
|
|
|
signals:
|
|
void syncDone(SyncAction *);
|
|
void logMessage(const TQString &);
|
|
void logError(const TQString &);
|
|
void logProgress(const TQString &,int);
|
|
|
|
protected slots:
|
|
/** This slot emits syncDone(), and does nothing else. This
|
|
* is safe, since the method returns immediately after the
|
|
* emit -- even if syncDone() causes the SyncAction to be deleted.
|
|
*/
|
|
void delayedDoneSlot();
|
|
|
|
protected:
|
|
/**
|
|
* It might not be safe to emit syncDone() from exec().
|
|
* So instead, call delayDone() to wait for the main event
|
|
* loop to return if you manage to do all processing
|
|
* immediately.
|
|
*
|
|
* delayDone() returns true, so that return delayDone();
|
|
* is a sensible final statement in exec().
|
|
*/
|
|
bool delayDone();
|
|
|
|
public:
|
|
/** Public API for adding a sync log entry, see the implementation
|
|
* in KPilotLink::addSyncLogEntry().
|
|
* @param e Message to add to the sync log
|
|
* @param log If @c true, also add the entry to the log in KPilot
|
|
* @note Having messages appear on the handheld but not in KPilot
|
|
* should be a @em very rare occurrence.
|
|
*/
|
|
void addSyncLogEntry(const TQString &e,bool log=true)
|
|
{
|
|
if (deviceLink())
|
|
{
|
|
deviceLink()->addSyncLogEntry(e,log);
|
|
}
|
|
}
|
|
/** Public API for adding a message to the log in KPilot.
|
|
* Adds @p msg to the synclog maintained on the PC.
|
|
*/
|
|
void addLogMessage( const TQString &msg )
|
|
{
|
|
emit logMessage( msg );
|
|
}
|
|
/** Log an error message in KPilot (the PC side of things). */
|
|
void addLogError( const TQString &msg )
|
|
{
|
|
emit logError( msg );
|
|
}
|
|
/** Log progress in KPilot (the PC side of things). */
|
|
void addLogProgress( const TQString &msg, int prog )
|
|
{
|
|
emit logProgress( msg, prog );
|
|
}
|
|
protected:
|
|
/** Connection to the device. @todo make private. */
|
|
KPilotLink *fHandle;
|
|
int fActionStatus;
|
|
|
|
/** Returns a pointer to the connection to the device. */
|
|
inline KPilotLink *deviceLink() const
|
|
{
|
|
return fHandle;
|
|
}
|
|
|
|
/** Returns the file descriptor for the device link -- that is,
|
|
* the raw handle to the OS's connection to the device. Use with care.
|
|
* May return -1 if there is no device.
|
|
*/
|
|
int pilotSocket() const
|
|
{
|
|
return deviceLink() ? deviceLink()->pilotSocket() : -1 ;
|
|
}
|
|
|
|
/** Tells the handheld device that someone is talking to it now.
|
|
* Useful (repeatedly) to inform the user of what is going on.
|
|
* May return < 0 on error (or if there is no device attached).
|
|
*/
|
|
int openConduit()
|
|
{
|
|
return deviceLink() ? deviceLink()->openConduit() : -1;
|
|
}
|
|
public:
|
|
/**
|
|
* This class encapsulates the different sync modes that
|
|
* can be used, and enforces a little discipline in changing
|
|
* the mode and messing around in general. It replaces a
|
|
* simple enum by not much more, but it makes things like
|
|
* local test backups less likely to happen.
|
|
*
|
|
* Note that this could all be packed into a bitfield (5 bits needed)
|
|
* but that makes for messy code in the end.
|
|
*/
|
|
class SyncMode
|
|
{
|
|
public:
|
|
/** Available modes for the sync. */
|
|
enum Mode {
|
|
eHotSync=1,
|
|
eFullSync=2,
|
|
eCopyPCToHH=3,
|
|
eCopyHHToPC=4,
|
|
eBackup=5,
|
|
eRestore=6
|
|
} ;
|
|
|
|
/** Create a mode with the given Mode @p m and
|
|
* the mix-ins @p test and @p local, which
|
|
* determine whether the sync should actually change
|
|
* anything at all (test mode) and whether the HH is
|
|
* to be simulated by local databases.
|
|
*/
|
|
SyncMode(Mode m, bool test=false, bool local=false);
|
|
|
|
/** Create a mode by parsing the string list. This
|
|
* is used mostly by the conduit proxies, which use
|
|
* a string list to pass aparameters to the shared
|
|
* library loader.
|
|
*/
|
|
SyncMode(const TQStringList &l);
|
|
|
|
/** Returns the kind of sync; this is just incomplete
|
|
* information, since a test hot sync is very different from
|
|
* a non-test one. */
|
|
Mode mode() const
|
|
{
|
|
return fMode;
|
|
}
|
|
|
|
/** Sets a mode from an integer @p mode, if possible.
|
|
* If the @p mode is illegal, return false and set the
|
|
* mode to Hot Sync. As a side effect, options test and local
|
|
* are reset to false.
|
|
*/
|
|
bool setMode(int);
|
|
|
|
/** Sets a mode from a @p mode, if possible. This leaves
|
|
* the options unchanged, so as to reward properly-typed programming.
|
|
*/
|
|
bool setMode(Mode m);
|
|
|
|
/** Sets options. Returns false if the combination of mode
|
|
* and the options is impossible. */
|
|
bool setOptions(bool test, bool local)
|
|
{
|
|
fTest=test;
|
|
fLocal=local;
|
|
return true;
|
|
}
|
|
|
|
/** Shorthand to test for a specific mode enum. This disregards
|
|
* the mixings local and test.
|
|
*/
|
|
bool operator ==(const Mode &m) const
|
|
{
|
|
return mode() == m;
|
|
}
|
|
/** Longhand comparison. Compares two modes for the same
|
|
* mode enum and mixins local and test.
|
|
*/
|
|
bool operator ==(const SyncMode &m) const
|
|
{
|
|
return ( mode() == m.mode() ) &&
|
|
( isTest() == m.isTest() ) &&
|
|
( isLocal() == m.isLocal() );
|
|
} ;
|
|
|
|
/** Accessor for the test part of the mode. Test syncs should
|
|
* never actually modify data anywhere.
|
|
*/
|
|
bool isTest() const
|
|
{
|
|
return fTest;
|
|
}
|
|
|
|
/** Accessor for the local part of the mode. Local syncs use a
|
|
* local database instead of one on the device link.
|
|
*/
|
|
bool isLocal() const
|
|
{
|
|
return fLocal;
|
|
}
|
|
|
|
bool isFullSync() const
|
|
{
|
|
return ( fMode==eFullSync ) ||
|
|
( fMode==eCopyPCToHH) ||
|
|
( fMode==eCopyHHToPC) ;
|
|
} ;
|
|
bool isFirstSync() const
|
|
{
|
|
return ( fMode==eCopyHHToPC ) || ( fMode==eCopyPCToHH ) ;
|
|
};
|
|
|
|
/** Classify every mode as either a sync (two-way) or copy (one-way) mode. */
|
|
bool isSync() const
|
|
{
|
|
return ( fMode==eFullSync ) ||
|
|
( fMode == eHotSync );
|
|
} ;
|
|
|
|
/** Classify every mode as either a sync (two-way) or copy (one-way) mode. */
|
|
bool isCopy() const
|
|
{
|
|
return ( fMode==eBackup ) ||
|
|
( fMode==eRestore ) ||
|
|
( fMode==eCopyPCToHH ) ||
|
|
( fMode==eCopyHHToPC );
|
|
} ;
|
|
|
|
/**
|
|
* Returns a standard name for each of the sync modes.
|
|
*/
|
|
static TQString name(Mode);
|
|
|
|
/**
|
|
* Returns a (human readable) name for this particular mode,
|
|
* including extra information about test and local mode.
|
|
*/
|
|
TQString name() const;
|
|
|
|
/**
|
|
* Returns a TQStringList that, when passed to the constructor
|
|
* of SyncMode, will re-create it. Used to pass modes into
|
|
* shared library factories.
|
|
*/
|
|
TQStringList list() const;
|
|
|
|
private:
|
|
Mode fMode;
|
|
bool fTest;
|
|
bool fLocal;
|
|
};
|
|
|
|
|
|
enum ConflictResolution
|
|
{
|
|
eUseGlobalSetting=-1,
|
|
eAskUser=0,
|
|
eDoNothing,
|
|
eHHOverrides,
|
|
ePCOverrides,
|
|
ePreviousSyncOverrides,
|
|
eDuplicate,
|
|
eDelete,
|
|
eCROffset=-1
|
|
};
|
|
|
|
/**
|
|
* This MUST stay in sync with the combobox in
|
|
* kpilotConfigDialog_backup.ui. If it does not, you need to
|
|
* either change this enum or the combobox.
|
|
*/
|
|
enum BackupFrequency
|
|
{
|
|
eEveryHotSync=0,
|
|
eOnRequestOnly
|
|
};
|
|
|
|
protected:
|
|
/**
|
|
* Call startTickle() some time before showing a dialog to the
|
|
* user (we're assuming a local event loop here) so that while
|
|
* the dialog is up and the user is thinking, the pilot stays
|
|
* awake. Afterwards, call stopTickle().
|
|
*
|
|
* The parameter to startTickle indicates the timeout, in
|
|
* seconds, before signal timeout is emitted. You can connect
|
|
* to that, again, to take down the user interface part if the
|
|
* user isn't reacting.
|
|
*/
|
|
void startTickle(unsigned count=0);
|
|
void stopTickle();
|
|
signals:
|
|
void timeout();
|
|
|
|
|
|
|
|
|
|
protected:
|
|
TQWidget *fParent;
|
|
|
|
/**
|
|
* Ask a yes-no question of the user. This has a timeout so that
|
|
* you don't wait forever for inattentive users. It's much like
|
|
* KMessageBox::questionYesNo(), but with this extra timeout-on-
|
|
* no-answer feature. Returns a KDialogBase::ButtonCode value - Yes,No or
|
|
* Cancel on timeout. If there is a key set and the user indicates not to ask again,
|
|
* the selected answer (Yes or No) is remembered for future reference.
|
|
*
|
|
* @p caption Message Box caption, uses "Question" if null.
|
|
* @p key Key for the "Don't ask again" code.
|
|
* @p timeout Timeout, in seconds.
|
|
*/
|
|
int questionYesNo(const TQString &question ,
|
|
const TQString &caption = TQString(),
|
|
const TQString &key = TQString(),
|
|
unsigned timeout = 20,
|
|
const TQString &yes = TQString(),
|
|
const TQString &no = TQString() );
|
|
int questionYesNoCancel(const TQString &question ,
|
|
const TQString &caption = TQString(),
|
|
const TQString &key = TQString(),
|
|
unsigned timeout = 20,
|
|
const TQString &yes = TQString(),
|
|
const TQString &no = TQString() ) ;
|
|
};
|
|
|
|
|
|
#endif
|