--- a/memspyui/ui/hb/inc/enginewrapper.h	Fri Jun 11 16:29:34 2010 +0100
+++ b/memspyui/ui/hb/inc/enginewrapper.h	Thu Jul 22 16:33:59 2010 +0100
@@ -19,31 +19,14 @@
 #define ENGINEWRAPPER_H_
 
 #include <QObject>
+#include <QVariantList>
+#include <QSettings>
 
 #include <memspysession.h>
-#include <memspyapiprocess.h>
 
 typedef quint64 ProcessId;
 typedef quint64 ThreadId;
 
-class MemSpyProcess
-{
-public:
-	MemSpyProcess(CMemSpyApiProcess* process)
-		: mProcess(process)
-	{}
-	
-	virtual  ~MemSpyProcess() { delete mProcess;	}
-	
-	ProcessId id() const { return mProcess->Id(); }
-	
-	QString name() const { return QString((QChar*) mProcess->Name().Ptr(), mProcess->Name().Length()); }
-	
-	
-private:
-	CMemSpyApiProcess *mProcess;
-};
-
 enum ThreadPriority
 {
 	ThreadPriorityNull=(-30),
@@ -94,6 +77,105 @@
 	KernelObjectTypeCondVar
 };
 
+enum ThreadInfoType
+{
+	ThreadInfoTypeGeneral = EMemSpyThreadInfoItemTypeGeneralInfo,
+	ThreadInfoTypeHeap = EMemSpyThreadInfoItemTypeHeap,
+	ThreadInfoTypeStack = EMemSpyThreadInfoItemTypeStack,
+	ThreadInfoTypeChunk = EMemSpyThreadInfoItemTypeChunk,
+	ThreadInfoTypeCodeSeg = EMemSpyThreadInfoItemTypeCodeSeg,
+	ThreadInfoTypeOpenFiles = EMemSpyThreadInfoItemTypeOpenFiles,
+	ThreadInfoTypeActiveObjects = EMemSpyThreadInfoItemTypeActiveObject,
+	ThreadInfoTypeOwnedThreadHandles = EMemSpyThreadInfoItemTypeOwnedThreadHandles,
+	ThreadInfoTypeOwnedProcessHandles = EMemSpyThreadInfoItemTypeOwnedProcessHandles,
+	ThreadInfoTypeServer = EMemSpyThreadInfoItemTypeServer,
+	ThreadInfoTypeSession = EMemSpyThreadInfoItemTypeSession,
+	ThreadInfoTypeSemaphore = EMemSpyThreadInfoItemTypeSemaphore,
+	ThreadInfoTypeOtherThreads = EMemSpyThreadInfoItemTypeOtherThreads,
+	ThreadInfoTypeOtherProcesses = EMemSpyThreadInfoItemTypeOtherProcesses,
+	ThreadInfoTypeMutex = EMemSpyThreadInfoItemTypeMutex,
+	ThreadInfoTypeTimer = EMemSpyThreadInfoItemTypeTimer,
+	ThreadInfoTypeChannel = EMemSpyThreadInfoItemTypeLogicalChannel,
+	ThreadInfoTypeChangeNotifier = EMemSpyThreadInfoItemTypeChangeNotifier,
+	ThreadInfoTypeUndertaker = EMemSpyThreadInfoItemTypeUndertaker,
+	ThreadInfoTypeMessageQueue = EMemSpyThreadInfoItemTypeMessageQueue,
+	ThreadInfoTypeConditionalVariable = EMemSpyThreadInfoItemTypeConditionalVariable,
+	ThreadInfoTypeLDD = EMemSpyThreadInfoItemTypeLDD,
+	ThreadInfoTypePDD = EMemSpyThreadInfoItemTypePDD,
+};
+
+enum DeviceWideOperation
+{
+	OutputPhoneInfo = 0,
+	    
+	OutputDetailedPhoneInfo,
+	    
+	OutputHeapInfo,
+	    
+	OutputCompactHeapInfo,
+	    
+	OutputHeapCellListing,
+	    
+	OutputHeapData,
+	    
+	OutputStackInfo,
+	    
+	OutputCompactStackInfo,
+	    
+	OutputUserStackData,
+	    
+	OutputKernelStackData
+};
+
+enum SwmtMode
+{
+	SwmtModeBasic = 0,
+	SwmtModeFull,
+	SwmtModeCustom
+};
+
+enum HeapDumpsMode
+{
+	HeapDumpsModeKernel = 0,
+	HeapDumpsModeUser,
+	HeapDumpsModeBoth
+};
+
+enum OutputMode
+{
+	OutputModeTrace = 0,
+	OutputModeFile
+};
+
+class MemSpyProcess
+{
+public:
+	MemSpyProcess(CMemSpyApiProcess* process)
+		: mProcess(process)
+	{}
+	
+	virtual  ~MemSpyProcess() { delete mProcess; }
+	
+	ProcessId id() const { return mProcess->Id(); }
+	
+	QString name() const { return QString((QChar*) mProcess->Name().Ptr(), mProcess->Name().Length()); }
+	
+	QString exitInfo() const;
+	
+	int priority() const { return mProcess->Priority(); }
+	
+	int threadCount() const { return mProcess->ThreadCount(); }
+	
+	int sid() const { return mProcess->SID(); }
+	
+	int vid() const { return mProcess->VID(); }
+	
+	bool isDead() const { return mProcess->IsDead(); }
+	
+private:
+	CMemSpyApiProcess *mProcess;
+};
+
 class MemSpyThread
 {
 public:
@@ -127,6 +209,10 @@
 	
 	QString name() const { return QString((QChar*) mType->Name().Ptr(), mType->Name().Length()); }
 	
+	int count() const { return mType->Count(); }
+	
+	qint64 size() const { return mType->Size(); }
+	
 private:
 	CMemSpyApiKernelObject *mType;
 };
@@ -236,25 +322,208 @@
 	CMemSpyApiKernelObjectItem *mObject;
 };
 
-class EngineWrapper : public QObject
+class MemSpyThreadInfoItem 
 {
 public:
+	MemSpyThreadInfoItem(CMemSpyApiThreadInfoItem *item)
+		: mItem(item)
+	{}
+	
+	virtual  ~MemSpyThreadInfoItem() { delete mItem;	}
+	
+	QString caption() const { return QString((QChar*) mItem->Caption().Ptr(), mItem->Caption().Length()); }
+	
+	QString value() const { return QString((QChar*) mItem->Value().Ptr(), mItem->Value().Length()); }
+	
+private:
+	CMemSpyApiThreadInfoItem* mItem;
+};
+
+class MemSpyDwoProgressTracker : public QObject, public CActive
+{
+	Q_OBJECT
+
+public:
+	MemSpyDwoProgressTracker(RMemSpySession &session);
+	virtual ~MemSpyDwoProgressTracker();
+	
+public slots:
+
+	void start();
+
+	void cancel();
+	
+protected: // from CActive
+	
+	virtual void RunL();
+	 
+	virtual void DoCancel();
+	 
+	virtual TInt RunError(TInt aError);
+	
+signals:
+	void progress(int progress, const QString& processName);
+	
+private:
+	TMemSpyDeviceWideOperationProgress mProgress;
+	RMemSpySession mSession;
+};
+
+class MemSpyDwoTracker : public QObject, public CActive
+{
+	Q_OBJECT
+
+public:
+	MemSpyDwoTracker(RMemSpySession &session, DeviceWideOperation operation);
+	virtual ~MemSpyDwoTracker();
+	
+public slots:
+
+	void start();
+	
+	void cancel();
+	
+protected: // from CActive
+	
+	virtual void RunL();
+	 
+	virtual void DoCancel();
+	 
+	virtual TInt RunError(TInt aError);
+	
+signals:
+	void finished(int errorCode);
+	void progress(int progress, const QString& processName);
+	
+private:
+	RMemSpySession mSession;
+	MemSpyDwoProgressTracker *mProgressTracker;
+	DeviceWideOperation mOperation;
+};
+
+class MemSpyAsyncTracker : public QObject, public CActive
+{
+	Q_OBJECT
+	
+public:
+	
+	MemSpyAsyncTracker(RMemSpySession& session, void (RMemSpySession::*function)(TRequestStatus&));
+	
+	void start();
+	
+	virtual void RunL();
+	
+	virtual void DoCancel();
+	
+	virtual TInt RunError(TInt aError);
+	
+signals:
+	
+	void finished(int errorCode);
+	
+private:
+	void (RMemSpySession::*mFunction)(TRequestStatus&);
+	RMemSpySession& mSession;
+};
+
+class MemSpySwmtDumpTracker : public MemSpyAsyncTracker
+{
+public:
+	MemSpySwmtDumpTracker(RMemSpySession& session) : 
+		MemSpyAsyncTracker(session, &RMemSpySession::ForceSwmtUpdate)
+	{}
+};
+
+class MemSpyKernelHeapDumpTracker : public MemSpyAsyncTracker
+{
+public:
+	MemSpyKernelHeapDumpTracker(RMemSpySession& session) : 
+		MemSpyAsyncTracker(session, &RMemSpySession::OutputKernelHeapData)
+	{}
+};
+
+class MemSpySettings : private QSettings
+{
+public:
+	
+	MemSpySettings();
+	
+	OutputMode outputMode() const;
+	void setOutputMode(OutputMode mode);
+	
+	QString outputPath() const;
+	void setOutputPath(const QString& path);
+		
+	int swmtTimerPeriod() const;
+	void setSwmtTimerPeriod(int period);
+	
+	SwmtMode swmtMode() const;
+	void setSwmtMode(SwmtMode mode);
+	
+	QVariantList swmtCategories() const;
+	void setSwmtCategories(const QVariantList& categories);
+	
+	HeapDumpsMode heapDumpsMode() const;
+	void setHeapDumpsMode(HeapDumpsMode mode);
+};
+
+class EngineWrapper : public QObject
+{
+	Q_OBJECT
+	
+public:
+	EngineWrapper();
+	
 	virtual ~EngineWrapper();
+	
 	bool initialize();
 	
+	MemSpySettings& settings();
+	
+	const MemSpySettings& settings() const;
+	
+	
+	
 	QList<MemSpyProcess*> getProcesses();
 	
 	QList<MemSpyThread*> getThreads(ProcessId processId);
 	
+	QList<MemSpyThreadInfoItem*> getThreadInfo(ThreadId threadId, ThreadInfoType type);
+	
 	void setThreadPriority(ThreadId threadId, ThreadPriority priority);
 	
 	QList<MemSpyKernelObjectType*> getKernelObjectTypes();
 	
 	QList<MemSpyKernelObject*> getKernelObjects(int type);
 	
+	MemSpyDwoTracker* createDeviceWideOperation(DeviceWideOperation operation);
+	
+	MemSpyKernelHeapDumpTracker* createKernelHeapDumpTracker();
+	
+	MemSpySwmtDumpTracker* createSwmtDumpTracker();
+	
+	void setSwmtSettings(SwmtMode mode, const QVariantList& categories);
+	
+	bool isSwmtRunning();
+	
+	void startSwmt(int period);
+	
+	void stopSwmt();
+	
+	void forceSwmtDump();
+	
+	void outputKernelHeapData();
+	
+	int outputThreadHeapData(const QString& filter);
+	
+	void updateOutputSettings();
+	
 private:
 	RMemSpySession mSession;
 	
+	bool mSwmtRunning;
+	
+	MemSpySettings mSettings;
 };
 
 #endif /* ENGINEWRAPPER_H_ */