Added doxygen groups and fixed some formatting issues.

Libs/XNAT/Core/CMakeLists.txt

@@ -13,6 +13,7 @@ set(KIT_SRCS
   ctkXnatException.cpp
   ctkXnatExperiment.cpp
   ctkXnatFile.cpp
+  ctkXnatListModel.cpp
   ctkXnatLoginProfile.cpp
   ctkXnatObject.cpp
   ctkXnatObjectPrivate.cpp
@@ -26,12 +27,17 @@ set(KIT_SRCS
   ctkXnatSession.cpp
   ctkXnatSettings.cpp
   ctkXnatSubject.cpp
+  ctkXnatTreeItem.cpp
+  ctkXnatTreeItem_p.h
+  ctkXnatTreeModel.cpp
 )
 
 # Files which should be processed by Qts moc
 set(KIT_MOC_SRCS
   ctkXnatAPI_p.h
   ctkXnatSession.h
+  ctkXnatListModel.h
+  ctkXnatTreeModel.h
 )
 
 

Libs/XNAT/Core/ctkXnatAPI.cpp

@@ -1,6 +1,6 @@
 /*=============================================================================
 
-  Plugin: org.commontk.xnat
+  Library: XNAT/Core
 
   Copyright (c) University College London,
     Centre for Medical Image Computing

Libs/XNAT/Core/ctkXnatAPI_p.h

@@ -1,6 +1,6 @@
 /*=============================================================================
 
-  Plugin: org.commontk.xnat
+  Library: XNAT/Core
 
   Copyright (c) University College London,
     Centre for Medical Image Computing
@@ -28,8 +28,10 @@
 #include <QScriptEngine>
 #include <QScriptValue>
 
-/// ctkXnatAPI is a simple interface class to communicate with an XNAT
-/// server through its REST API.
+/**
+ * ctkXnatAPI is a simple interface class to communicate with an XNAT
+ * server through its REST API.
+ */
 class ctkXnatAPI : public qRestAPI
 {
   Q_OBJECT
@@ -56,7 +58,7 @@ private:
 
   QScriptEngine ScriptEngine;
 
-  Q_DISABLE_COPY(ctkXnatAPI);
+  Q_DISABLE_COPY(ctkXnatAPI)
 };
 
 #endif

Libs/XNAT/Core/ctkXnatDataModel.cpp

@@ -1,6 +1,6 @@
 /*=============================================================================
 
-  Plugin: org.commontk.xnat
+  Library: XNAT/Core
 
   Copyright (c) University College London,
     Centre for Medical Image Computing
@@ -28,6 +28,7 @@
 
 #include <QDebug>
 
+// --------------------------------------------------------------------------
 class ctkXnatDataModelPrivate : public ctkXnatObjectPrivate
 {
   explicit ctkXnatDataModelPrivate(ctkXnatSession* session);
@@ -39,21 +40,25 @@ private:
   ctkXnatSession* session;
 };
 
+// --------------------------------------------------------------------------
 ctkXnatDataModelPrivate::ctkXnatDataModelPrivate(ctkXnatSession* connection)
 : ctkXnatObjectPrivate()
 , session(connection)
 {
 }
 
+// --------------------------------------------------------------------------
 ctkXnatDataModelPrivate::~ctkXnatDataModelPrivate()
 {
 }
 
+// --------------------------------------------------------------------------
 ctkXnatDataModel::ctkXnatDataModel(ctkXnatSession* session)
 : ctkXnatObject(*new ctkXnatDataModelPrivate(session))
 {
 }
 
+// --------------------------------------------------------------------------
 QList<ctkXnatProject*> ctkXnatDataModel::projects() const
 {
   QList<ctkXnatProject*> result;
@@ -64,16 +69,19 @@ QList<ctkXnatProject*> ctkXnatDataModel::projects() const
   return result;
 }
 
+// --------------------------------------------------------------------------
 QString ctkXnatDataModel::resourceUri() const
 {
   return "";
 }
 
+// --------------------------------------------------------------------------
 QString ctkXnatDataModel::childDataType() const
 {
   return "Projects";
 }
 
+// --------------------------------------------------------------------------
 void ctkXnatDataModel::fetchImpl()
 {
   Q_D(ctkXnatDataModel);
@@ -92,6 +100,7 @@ void ctkXnatDataModel::fetchImpl()
   }
 }
 
+// --------------------------------------------------------------------------
 ctkXnatSession* ctkXnatDataModel::session() const
 {
   Q_D(const ctkXnatDataModel);

Libs/XNAT/Core/ctkXnatDataModel.h

@@ -1,6 +1,6 @@
 /*=============================================================================
 
-  Plugin: org.commontk.xnat
+  Library: XNAT/Core
 
   Copyright (c) University College London,
     Centre for Medical Image Computing
@@ -30,12 +30,18 @@ class ctkXnatDataModelPrivate;
 class ctkXnatProject;
 class ctkXnatSession;
 
+/**
+ * @ingroup XNAT_Core
+ *
+ * @brief The ctkXnatDataModel class reprents the root object in a
+ * XNAT data hierarchy.
+ */
 class ctkXnatDataModel : public ctkXnatObject
 {
 
 public:
 
-  ctkXnatDataModel(ctkXnatSession* connection);
+  explicit ctkXnatDataModel(ctkXnatSession* connection);
 
   QList<ctkXnatProject*> projects() const;
 

Libs/XNAT/Core/ctkXnatDefaultSchemaTypes.h

@@ -26,6 +26,9 @@
 
 #include <QString>
 
+/**
+ * @ingroup XNAT_Core
+ */
 struct CTK_XNAT_CORE_EXPORT ctkXnatDefaultSchemaTypes
 {
   static QString XSI_EXPERIMENT; // = "xnat:experimentData"

Libs/XNAT/Core/ctkXnatException.h

@@ -26,10 +26,13 @@
 
 #include "ctkException.h"
 
+/// @ingroup XNAT_Core
+/// @{
 CTK_DECLARE_EXCEPTION(CTK_XNAT_CORE_EXPORT, ctkXnatException, ctkRuntimeException)
 CTK_DECLARE_EXCEPTION(CTK_XNAT_CORE_EXPORT, ctkXnatTimeoutException, ctkXnatException)
 CTK_DECLARE_EXCEPTION(CTK_XNAT_CORE_EXPORT, ctkXnatInvalidSessionException, ctkXnatException)
 CTK_DECLARE_EXCEPTION(CTK_XNAT_CORE_EXPORT, ctkXnatAuthenticationException, ctkXnatException)
 CTK_DECLARE_EXCEPTION(CTK_XNAT_CORE_EXPORT, ctkXnatProtocolFailureException, ctkXnatException)
+/// @}
 
 #endif

Libs/XNAT/Core/ctkXnatExperiment.cpp

@@ -1,6 +1,6 @@
 /*=============================================================================
 
-  Plugin: org.commontk.xnat
+  Library: XNAT/Core
 
   Copyright (c) University College London,
     Centre for Medical Image Computing
@@ -30,6 +30,7 @@
 #include "ctkXnatReconstructionFolder.h"
 #include "ctkXnatDefaultSchemaTypes.h"
 
+//----------------------------------------------------------------------------
 class ctkXnatExperimentPrivate : public ctkXnatObjectPrivate
 {
 public:
@@ -48,25 +49,30 @@ public:
 };
 
 
+//----------------------------------------------------------------------------
 ctkXnatExperiment::ctkXnatExperiment(ctkXnatObject* parent, const QString& schemaType)
 : ctkXnatObject(*new ctkXnatExperimentPrivate(), parent, schemaType)
 {
 }
 
+//----------------------------------------------------------------------------
 ctkXnatExperiment::~ctkXnatExperiment()
 {
 }
 
+//----------------------------------------------------------------------------
 QString ctkXnatExperiment::resourceUri() const
 {
   return QString("%1/experiments/%2").arg(parent()->resourceUri(), this->id());
 }
 
+//----------------------------------------------------------------------------
 void ctkXnatExperiment::reset()
 {
   ctkXnatObject::reset();
 }
 
+//----------------------------------------------------------------------------
 void ctkXnatExperiment::fetchImpl()
 {
   QString scansUri = this->resourceUri() + "/scans";

Libs/XNAT/Core/ctkXnatExperiment.h

@@ -1,6 +1,6 @@
 /*=============================================================================
 
-  Plugin: org.commontk.xnat
+  Library: XNAT/Core
 
   Copyright (c) University College London,
     Centre for Medical Image Computing
@@ -31,6 +31,9 @@ class ctkXnatConnection;
 class ctkXnatExperimentPrivate;
 class ctkXnatSubject;
 
+/**
+ * @ingroup XNAT_Core
+ */
 class CTK_XNAT_CORE_EXPORT ctkXnatExperiment : public ctkXnatObject
 {
 

Libs/XNAT/Core/ctkXnatFile.cpp

@@ -1,6 +1,6 @@
 /*=============================================================================
 
-  Plugin: org.commontk.xnat
+  Library: XNAT/Core
 
   Copyright (c) University College London,
     Centre for Medical Image Computing
@@ -25,6 +25,7 @@
 #include "ctkXnatObjectPrivate.h"
 
 
+//----------------------------------------------------------------------------
 class ctkXnatFilePrivate : public ctkXnatObjectPrivate
 {
 public:
@@ -42,35 +43,42 @@ public:
 //  QString uri;
 };
 
+
+//----------------------------------------------------------------------------
 ctkXnatFile::ctkXnatFile(ctkXnatObject* parent, const QString& schemaType)
 : ctkXnatObject(*new ctkXnatFilePrivate(), parent, schemaType)
 {
 }
 
+//----------------------------------------------------------------------------
 ctkXnatFile::~ctkXnatFile()
 {
 }
 
+//----------------------------------------------------------------------------
 QString ctkXnatFile::resourceUri() const
 {
   return QString("%1/files/%2").arg(parent()->resourceUri(), this->id());
 }
 
+//----------------------------------------------------------------------------
 void ctkXnatFile::download(const QString& filename)
 {
   this->session()->download(this, filename);
 }
 
+//----------------------------------------------------------------------------
 void ctkXnatFile::upload(const QString& /*filename*/)
 {
 }
 
-
+//----------------------------------------------------------------------------
 void ctkXnatFile::reset()
 {
   ctkXnatObject::reset();
 }
 
+//----------------------------------------------------------------------------
 void ctkXnatFile::fetchImpl()
 {
 }

Libs/XNAT/Core/ctkXnatFile.h

@@ -1,6 +1,6 @@
 /*=============================================================================
 
-  Plugin: org.commontk.xnat
+  Library: XNAT/Core
 
   Copyright (c) University College London,
     Centre for Medical Image Computing
@@ -30,6 +30,9 @@
 class ctkXnatConnection;
 class ctkXnatFilePrivate;
 
+/**
+ * @ingroup XNAT_Core
+ */
 class CTK_XNAT_CORE_EXPORT ctkXnatFile : public ctkXnatObject
 {
 

Libs/XNAT/Widgets/ctkXnatListModel.cpp

@@ -1,6 +1,6 @@
 /*=============================================================================
 
-  Library: CTK
+  Library: XNAT/Core
 
   Copyright (c) German Cancer Research Center,
     Division of Medical and Biological Informatics
@@ -33,27 +33,33 @@
 
 #include <QDebug>
 
+
+//----------------------------------------------------------------------------
 ctkXnatListModel::ctkXnatListModel()
   : RootObject(0)
 {
 }
 
+//----------------------------------------------------------------------------
 void ctkXnatListModel::setRootObject(ctkXnatObject* root)
 {
   RootObject = root;
 }
 
+//----------------------------------------------------------------------------
 ctkXnatObject* ctkXnatListModel::rootObject()
 {
   return RootObject;
 }
 
+//----------------------------------------------------------------------------
 int ctkXnatListModel::rowCount(const QModelIndex& /*parent*/) const
 {
   if (!RootObject) return 0;
   return RootObject->children().size();
 }
 
+//----------------------------------------------------------------------------
 QVariant ctkXnatListModel::data(const QModelIndex& index, int role) const
 {
   if (!RootObject) return QVariant();
@@ -82,6 +88,7 @@ QVariant ctkXnatListModel::data(const QModelIndex& index, int role) const
   return QVariant();
 }
 
+//----------------------------------------------------------------------------
 QVariant ctkXnatListModel::headerData(int /*section*/, Qt::Orientation /*orientation*/, int role) const
 {
   if (role == Qt::DisplayRole)

Libs/XNAT/Widgets/ctkXnatListModel.h

@@ -1,6 +1,6 @@
 /*=============================================================================
 
-  Library: CTK
+  Library: XNAT/Core
 
   Copyright (c) German Cancer Research Center,
     Division of Medical and Biological Informatics
@@ -24,11 +24,14 @@
 
 #include "QAbstractListModel"
 
-#include "ctkXNATWidgetsExport.h"
+#include "ctkXNATCoreExport.h"
 
 class ctkXnatObject;
 
-class CTK_XNAT_WIDGETS_EXPORT ctkXnatListModel : public QAbstractListModel
+/**
+ * @ingroup XNAT_Core
+ */
+class CTK_XNAT_CORE_EXPORT ctkXnatListModel : public QAbstractListModel
 {
   Q_OBJECT
 

Libs/XNAT/Core/ctkXnatLoginProfile.cpp

@@ -1,6 +1,6 @@
 /*=============================================================================
 
-  Library: CTK
+  Library: XNAT/Core
 
   Copyright (c) University College London,
     Centre for Medical Image Computing
@@ -21,6 +21,7 @@
 
 #include "ctkXnatLoginProfile.h"
 
+//----------------------------------------------------------------------------
 class ctkXnatLoginProfilePrivate
 {
 public:
@@ -33,10 +34,13 @@ public:
   bool Default;
 };
 
+//----------------------------------------------------------------------------
 ctkXnatLoginProfilePrivate::ctkXnatLoginProfilePrivate()
 {
 }
 
+
+//----------------------------------------------------------------------------
 ctkXnatLoginProfile::ctkXnatLoginProfile()
   : d_ptr(new ctkXnatLoginProfilePrivate())
 {
@@ -45,15 +49,18 @@ ctkXnatLoginProfile::ctkXnatLoginProfile()
   d->Default = false;
 }
 
+//----------------------------------------------------------------------------
 ctkXnatLoginProfile::ctkXnatLoginProfile(const ctkXnatLoginProfile& otherLoginProfile)
   : d_ptr(new ctkXnatLoginProfilePrivate(*otherLoginProfile.d_ptr.data()))
 {
 }
 
+//----------------------------------------------------------------------------
 ctkXnatLoginProfile::~ctkXnatLoginProfile()
 {
 }
 
+//----------------------------------------------------------------------------
 QString ctkXnatLoginProfile::name() const
 {
   Q_D(const ctkXnatLoginProfile);
@@ -61,6 +68,7 @@ QString ctkXnatLoginProfile::name() const
   return d->Name;
 }
 
+//----------------------------------------------------------------------------
 void ctkXnatLoginProfile::setName(const QString& name)
 {
   Q_D(ctkXnatLoginProfile);
@@ -68,6 +76,7 @@ void ctkXnatLoginProfile::setName(const QString& name)
   d->Name = name;
 }
 
+//----------------------------------------------------------------------------
 QUrl ctkXnatLoginProfile::serverUrl() const
 {
   Q_D(const ctkXnatLoginProfile);
@@ -75,6 +84,7 @@ QUrl ctkXnatLoginProfile::serverUrl() const
   return d->ServerUrl;
 }
 
+//----------------------------------------------------------------------------
 void ctkXnatLoginProfile::setServerUrl(const QUrl& serverUrl)
 {
   Q_D(ctkXnatLoginProfile);
@@ -82,6 +92,7 @@ void ctkXnatLoginProfile::setServerUrl(const QUrl& serverUrl)
   d->ServerUrl = serverUrl;
 }
 
+//----------------------------------------------------------------------------
 QString ctkXnatLoginProfile::userName() const
 {
   Q_D(const ctkXnatLoginProfile);
@@ -89,6 +100,7 @@ QString ctkXnatLoginProfile::userName() const
   return d->UserName;
 }
 
+//----------------------------------------------------------------------------
 void ctkXnatLoginProfile::setUserName(const QString& userName)
 {
   Q_D(ctkXnatLoginProfile);
@@ -96,6 +108,7 @@ void ctkXnatLoginProfile::setUserName(const QString& userName)
   d->UserName = userName;
 }
 
+//----------------------------------------------------------------------------
 QString ctkXnatLoginProfile::password() const
 {
   Q_D(const ctkXnatLoginProfile);
@@ -103,6 +116,7 @@ QString ctkXnatLoginProfile::password() const
   return d->Password;
 }
 
+//----------------------------------------------------------------------------
 void ctkXnatLoginProfile::setPassword(const QString& password)
 {
   Q_D(ctkXnatLoginProfile);
@@ -110,6 +124,7 @@ void ctkXnatLoginProfile::setPassword(const QString& password)
   d->Password = password;
 }
 
+//----------------------------------------------------------------------------
 bool ctkXnatLoginProfile::isDefault() const
 {
   Q_D(const ctkXnatLoginProfile);
@@ -117,6 +132,7 @@ bool ctkXnatLoginProfile::isDefault() const
   return d->Default;
 }
 
+//----------------------------------------------------------------------------
 void ctkXnatLoginProfile::setDefault(bool default_)
 {
   Q_D(ctkXnatLoginProfile);

Libs/XNAT/Core/ctkXnatLoginProfile.h

@@ -1,6 +1,6 @@
 /*=============================================================================
 
-  Library: CTK
+  Library: XNAT/Core
 
   Copyright (c) University College London,
     Centre for Medical Image Computing
@@ -30,6 +30,8 @@
 class ctkXnatLoginProfilePrivate;
 
 /**
+ * @ingroup XNAT_Core
+ *
  * @brief A login profile for XNAT sessions
  */
 class CTK_XNAT_CORE_EXPORT ctkXnatLoginProfile

Libs/XNAT/Core/ctkXnatObject.cpp

@@ -1,6 +1,6 @@
 /*=============================================================================
 
-  Plugin: org.commontk.xnat
+  Library: XNAT/Core
 
   Copyright (c) University College London,
     Centre for Medical Image Computing
@@ -28,11 +28,14 @@
 #include <QDebug>
 #include <QVariant>
 
+
+//----------------------------------------------------------------------------
 ctkXnatObject::ctkXnatObject(const ctkXnatObject&)
 {
   throw ctkRuntimeException("Copy constructor not implemented");
 }
 
+//----------------------------------------------------------------------------
 ctkXnatObject::ctkXnatObject(ctkXnatObject* parent, const QString& schemaType)
 : d_ptr(new ctkXnatObjectPrivate())
 {
@@ -40,6 +43,7 @@ ctkXnatObject::ctkXnatObject(ctkXnatObject* parent, const QString& schemaType)
   this->setSchemaType(schemaType);
 }
 
+//----------------------------------------------------------------------------
 ctkXnatObject::ctkXnatObject(ctkXnatObjectPrivate& dd, ctkXnatObject* parent, const QString& schemaType)
 : d_ptr(&dd)
 {
@@ -47,6 +51,7 @@ ctkXnatObject::ctkXnatObject(ctkXnatObjectPrivate& dd, ctkXnatObject* parent, co
   this->setSchemaType(schemaType);
 }
 
+//----------------------------------------------------------------------------
 ctkXnatObject::~ctkXnatObject()
 {
   Q_D(ctkXnatObject);
@@ -56,41 +61,49 @@ ctkXnatObject::~ctkXnatObject()
   }
 }
 
+//----------------------------------------------------------------------------
 QString ctkXnatObject::id() const
 {
   return property("ID");
 }
 
+//----------------------------------------------------------------------------
 void ctkXnatObject::setId(const QString& id)
 {
   setProperty("ID", id);
 }
 
+//----------------------------------------------------------------------------
 QString ctkXnatObject::name() const
 {
   return property("name");
 }
 
+//----------------------------------------------------------------------------
 void ctkXnatObject::setName(const QString& name)
 {
   setProperty("name", name);
 }
 
+//----------------------------------------------------------------------------
 QString ctkXnatObject::description() const
 {
   return property("description");
 }
 
+//----------------------------------------------------------------------------
 void ctkXnatObject::setDescription(const QString& description)
 {
   setProperty("description", description);
 }
 
+//----------------------------------------------------------------------------
 QString ctkXnatObject::childDataType() const
 {
   return "Resources";
 }
 
+//----------------------------------------------------------------------------
 QString ctkXnatObject::property(const QString& name) const
 {
   Q_D(const ctkXnatObject);
@@ -102,24 +115,28 @@ QString ctkXnatObject::property(const QString& name) const
   return QString::null;
 }
 
+//----------------------------------------------------------------------------
 void ctkXnatObject::setProperty(const QString& name, const QVariant& value)
 {
   Q_D(ctkXnatObject);
   d->properties.insert(name, value.toString());
 }
 
+//----------------------------------------------------------------------------
 const QMap<QString, QString>& ctkXnatObject::properties() const
 {
   Q_D(const ctkXnatObject);
   return d->properties;
 }
 
+//----------------------------------------------------------------------------
 ctkXnatObject* ctkXnatObject::parent() const
 {
   Q_D(const ctkXnatObject);
   return d->parent;
 }
 
+//----------------------------------------------------------------------------
 void ctkXnatObject::setParent(ctkXnatObject* parent)
 {
   Q_D(ctkXnatObject);
@@ -136,12 +153,14 @@ void ctkXnatObject::setParent(ctkXnatObject* parent)
   }
 }
 
+//----------------------------------------------------------------------------
 QList<ctkXnatObject*> ctkXnatObject::children() const
 {
   Q_D(const ctkXnatObject);
   return d->children;
 }
 
+//----------------------------------------------------------------------------
 void ctkXnatObject::add(ctkXnatObject* child)
 {
   Q_D(ctkXnatObject);
@@ -159,6 +178,7 @@ void ctkXnatObject::add(ctkXnatObject* child)
   }
 }
 
+//----------------------------------------------------------------------------
 void ctkXnatObject::remove(ctkXnatObject* child)
 {
   Q_D(ctkXnatObject);
@@ -168,6 +188,7 @@ void ctkXnatObject::remove(ctkXnatObject* child)
   }
 }
 
+//----------------------------------------------------------------------------
 void ctkXnatObject::reset()
 {
   Q_D(ctkXnatObject);
@@ -176,17 +197,20 @@ void ctkXnatObject::reset()
   d->fetched = false;
 }
 
+//----------------------------------------------------------------------------
 bool ctkXnatObject::isFetched() const
 {
   Q_D(const ctkXnatObject);
   return d->fetched;
 }
 
+//----------------------------------------------------------------------------
 QString ctkXnatObject::schemaType() const
 {
   return this->property("xsiType");
 }
 
+//----------------------------------------------------------------------------
 void ctkXnatObject::fetch()
 {
   Q_D(ctkXnatObject);
@@ -197,6 +221,7 @@ void ctkXnatObject::fetch()
   }
 }
 
+//----------------------------------------------------------------------------
 ctkXnatSession* ctkXnatObject::session() const
 {
   const ctkXnatObject* xnatObject = this;
@@ -208,29 +233,35 @@ ctkXnatSession* ctkXnatObject::session() const
   return dataModel ? dataModel->session() : NULL;
 }
 
+//----------------------------------------------------------------------------
 void ctkXnatObject::setSchemaType(const QString& schemaType)
 {
   this->setProperty("xsiType", schemaType);
 }
 
+//----------------------------------------------------------------------------
 void ctkXnatObject::download(const QString& /*zipFilename*/)
 {
 }
 
+//----------------------------------------------------------------------------
 void ctkXnatObject::upload(const QString& /*zipFilename*/)
 {
 }
 
+//----------------------------------------------------------------------------
 bool ctkXnatObject::exists() const
 {
   return this->session()->exists(this);
 }
 
+//----------------------------------------------------------------------------
 void ctkXnatObject::save()
 {
   this->session()->save(this);
 }
 
+//----------------------------------------------------------------------------
 void ctkXnatObject::erase()
 {
   this->session()->remove(this);

Libs/XNAT/Core/ctkXnatObject.h

@@ -1,6 +1,6 @@
 /*=============================================================================
 
-  Plugin: org.commontk.xnat
+  Library: XNAT/Core
 
   Copyright (c) University College London,
     Centre for Medical Image Computing
@@ -34,10 +34,12 @@
 class ctkXnatSession;
 class ctkXnatObjectPrivate;
 
-//----------------------------------------------------------------------------
-/// \ingroup XNATCore
-/// ctkXnatObject is the base class of the objects that represent the nodes in
-/// the XNAT data hierarchy.
+/**
+ * @ingroup XNAT_Core
+ *
+ * ctkXnatObject is the base class of the objects that represent the nodes in
+ * the XNAT data hierarchy.
+ */
 class CTK_XNAT_CORE_EXPORT ctkXnatObject
 {
 

Libs/XNAT/Core/ctkXnatObjectPrivate.cpp

@@ -1,6 +1,6 @@
 /*=============================================================================
 
-  Library: CTK
+  Library: XNAT/Core
 
   Copyright (c) German Cancer Research Center,
     Division of Medical and Biological Informatics
@@ -23,12 +23,15 @@
 
 #include <QString>
 
+
+//----------------------------------------------------------------------------
 ctkXnatObjectPrivate::ctkXnatObjectPrivate()
 : fetched(false)
 , parent(0)
 {
 }
 
+//----------------------------------------------------------------------------
 ctkXnatObjectPrivate::~ctkXnatObjectPrivate()
 {
 }

Libs/XNAT/Core/ctkXnatObjectPrivate.h

@@ -1,6 +1,6 @@
 /*=============================================================================
 
-  Library: CTK
+  Library: XNAT/Core
 
   Copyright (c) German Cancer Research Center,
     Division of Medical and Biological Informatics

Libs/XNAT/Core/ctkXnatProject.cpp

@@ -1,6 +1,6 @@
 /*=============================================================================
 
-  Plugin: org.commontk.xnat
+  Library: XNAT/Core
 
   Copyright (c) University College London,
     Centre for Medical Image Computing
@@ -27,6 +27,8 @@
 #include "ctkXnatObjectPrivate.h"
 #include "ctkXnatDefaultSchemaTypes.h"
 
+
+//----------------------------------------------------------------------------
 class ctkXnatProjectPrivate : public ctkXnatObjectPrivate
 {
 public:
@@ -50,78 +52,93 @@ public:
 //  QString uri;
 };
 
+
+//----------------------------------------------------------------------------
 ctkXnatProject::ctkXnatProject(ctkXnatObject* parent, const QString& schemaType)
 : ctkXnatObject(*new ctkXnatProjectPrivate(), parent, schemaType)
 {
 }
 
+//----------------------------------------------------------------------------
 ctkXnatProject::~ctkXnatProject()
 {
 }
 
+//----------------------------------------------------------------------------
 QString ctkXnatProject::resourceUri() const
 {
   return QString("%1/data/archive/projects/%2").arg(parent()->resourceUri(), this->id());
 }
 
+//----------------------------------------------------------------------------
 QString ctkXnatProject::childDataType() const
 {
   return "Subjects";
 }
 
+//----------------------------------------------------------------------------
 const QString& ctkXnatProject::secondaryId() const
 {
   Q_D(const ctkXnatProject);
   return d->secondaryId;
 }
 
+//----------------------------------------------------------------------------
 void ctkXnatProject::setSecondaryId(const QString& secondaryId)
 {
   Q_D(ctkXnatProject);
   d->secondaryId = secondaryId;
 }
 
+//----------------------------------------------------------------------------
 const QString& ctkXnatProject::piFirstName() const
 {
   Q_D(const ctkXnatProject);
   return d->piFirstName;
 }
 
+//----------------------------------------------------------------------------
 void ctkXnatProject::setPiFirstName(const QString& piFirstName)
 {
   Q_D(ctkXnatProject);
   d->piFirstName = piFirstName;
 }
 
+//----------------------------------------------------------------------------
 const QString& ctkXnatProject::piLastName() const
 {
   Q_D(const ctkXnatProject);
   return d->piLastName;
 }
 
+//----------------------------------------------------------------------------
 void ctkXnatProject::setPiLastName(const QString& piLastName)
 {
   Q_D(ctkXnatProject);
   d->piLastName = piLastName;
 }
 
+//----------------------------------------------------------------------------
 //const QString& ctkXnatProject::uri() const
 //{
 //  Q_D(const ctkXnatProject);
 //  return d->uri;
 //}
 
+//----------------------------------------------------------------------------
 //void ctkXnatProject::setUri(const QString& uri)
 //{
 //  Q_D(ctkXnatProject);
 //  d->uri = uri;
 //}
 
+//----------------------------------------------------------------------------
 void ctkXnatProject::reset()
 {
   ctkXnatObject::reset();
 }
 
+//----------------------------------------------------------------------------
 void ctkXnatProject::fetchImpl()
 {
   QString subjectsUri = this->resourceUri() + "/subjects";

Libs/XNAT/Core/ctkXnatProject.h

@@ -1,6 +1,6 @@
 /*=============================================================================
 
-  Plugin: org.commontk.xnat
+  Library: XNAT/Core
 
   Copyright (c) University College London,
     Centre for Medical Image Computing
@@ -30,6 +30,9 @@
 class ctkXnatDataModel;
 class ctkXnatProjectPrivate;
 
+/**
+ * @ingroup XNAT_Core
+ */
 class CTK_XNAT_CORE_EXPORT ctkXnatProject : public ctkXnatObject
 {
 

Libs/XNAT/Core/ctkXnatReconstruction.cpp

@@ -1,6 +1,6 @@
 /*=============================================================================
 
-  Plugin: org.commontk.xnat
+  Library: XNAT/Core
 
   Copyright (c) University College London,
     Centre for Medical Image Computing
@@ -27,6 +27,8 @@
 #include "ctkXnatReconstructionResource.h"
 #include "ctkXnatDefaultSchemaTypes.h"
 
+
+//----------------------------------------------------------------------------
 class ctkXnatReconstructionPrivate : public ctkXnatObjectPrivate
 {
 public:
@@ -45,25 +47,30 @@ public:
 };
 
 
+//----------------------------------------------------------------------------
 ctkXnatReconstruction::ctkXnatReconstruction(ctkXnatObject* parent, const QString& schemaType)
 : ctkXnatObject(*new ctkXnatReconstructionPrivate(), parent, schemaType)
 {
 }
 
+//----------------------------------------------------------------------------
 ctkXnatReconstruction::~ctkXnatReconstruction()
 {
 }
 
+//----------------------------------------------------------------------------
 QString ctkXnatReconstruction::resourceUri() const
 {
   return QString("%1/reconstructions/%2").arg(parent()->resourceUri(), this->id());
 }
 
+//----------------------------------------------------------------------------
 void ctkXnatReconstruction::reset()
 {
   ctkXnatObject::reset();
 }
 
+//----------------------------------------------------------------------------
 void ctkXnatReconstruction::fetchImpl()
 {
   QString reconstructionResourcesUri = this->resourceUri() + "/resources";

Libs/XNAT/Core/ctkXnatReconstruction.h

@@ -1,6 +1,6 @@
 /*=============================================================================
 
-  Plugin: org.commontk.xnat
+  Library: XNAT/Core
 
   Copyright (c) University College London,
     Centre for Medical Image Computing
@@ -31,6 +31,9 @@ class ctkXnatConnection;
 class ctkXnatReconstructionFolder;
 class ctkXnatReconstructionPrivate;
 
+/**
+ * @ingroup XNAT_Core
+ */
 class CTK_XNAT_CORE_EXPORT ctkXnatReconstruction : public ctkXnatObject
 {
 

Libs/XNAT/Core/ctkXnatReconstructionFolder.cpp

@@ -1,6 +1,6 @@
 /*=============================================================================
 
-  Plugin: org.commontk.xnat
+  Library: XNAT/Core
 
   Copyright (c) University College London,
     Centre for Medical Image Computing
@@ -27,6 +27,8 @@
 #include "ctkXnatReconstruction.h"
 #include "ctkXnatDefaultSchemaTypes.h"
 
+
+//----------------------------------------------------------------------------
 class ctkXnatReconstructionFolderPrivate : public ctkXnatObjectPrivate
 {
 public:
@@ -45,26 +47,31 @@ public:
 };
 
 
+//----------------------------------------------------------------------------
 ctkXnatReconstructionFolder::ctkXnatReconstructionFolder(ctkXnatObject* parent)
   : ctkXnatObject(*new ctkXnatReconstructionFolderPrivate(), parent, QString::null)
 {
   this->setProperty("ID", "reconstructions");
 }
 
+//----------------------------------------------------------------------------
 ctkXnatReconstructionFolder::~ctkXnatReconstructionFolder()
 {
 }
 
+//----------------------------------------------------------------------------
 QString ctkXnatReconstructionFolder::resourceUri() const
 {
   return QString("%1/%2").arg(parent()->resourceUri(), this->id());
 }
 
+//----------------------------------------------------------------------------
 void ctkXnatReconstructionFolder::reset()
 {
   ctkXnatObject::reset();
 }
 
+//----------------------------------------------------------------------------
 void ctkXnatReconstructionFolder::fetchImpl()
 {
   QString reconstructionsUri = this->resourceUri();

Libs/XNAT/Core/ctkXnatReconstructionFolder.h

@@ -1,6 +1,6 @@
 /*=============================================================================
 
-  Plugin: org.commontk.xnat
+  Library: XNAT/Core
 
   Copyright (c) University College London,
     Centre for Medical Image Computing
@@ -30,6 +30,9 @@ class ctkXnatConnection;
 class ctkXnatExperiment;
 class ctkXnatReconstructionFolderPrivate;
 
+/**
+ * @ingroup XNAT_Core
+ */
 class CTK_XNAT_CORE_EXPORT ctkXnatReconstructionFolder : public ctkXnatObject
 {
 

Libs/XNAT/Core/ctkXnatReconstructionResource.cpp

@@ -1,6 +1,6 @@
 /*=============================================================================
 
-  Plugin: org.commontk.xnat
+  Library: XNAT/Core
 
   Copyright (c) University College London,
     Centre for Medical Image Computing
@@ -27,6 +27,8 @@
 #include "ctkXnatReconstruction.h"
 #include "ctkXnatDefaultSchemaTypes.h"
 
+
+//----------------------------------------------------------------------------
 class ctkXnatReconstructionResourcePrivate : public ctkXnatObjectPrivate
 {
 public:
@@ -45,25 +47,30 @@ public:
 };
 
 
+//----------------------------------------------------------------------------
 ctkXnatReconstructionResource::ctkXnatReconstructionResource(ctkXnatObject* parent, const QString& schemaType)
 : ctkXnatObject(*new ctkXnatReconstructionResourcePrivate(), parent, schemaType)
 {
 }
 
+//----------------------------------------------------------------------------
 ctkXnatReconstructionResource::~ctkXnatReconstructionResource()
 {
 }
 
+//----------------------------------------------------------------------------
 QString ctkXnatReconstructionResource::resourceUri() const
 {
   return QString("%1/resources/%2").arg(parent()->resourceUri(), this->property("label"));
 }
 
+//----------------------------------------------------------------------------
 void ctkXnatReconstructionResource::reset()
 {
   ctkXnatObject::reset();
 }
 
+//----------------------------------------------------------------------------
 void ctkXnatReconstructionResource::fetchImpl()
 {
   QString reconstructionResourceFilesUri = this->resourceUri() + "/files";
@@ -85,6 +92,7 @@ void ctkXnatReconstructionResource::fetchImpl()
   }
 }
 
+//----------------------------------------------------------------------------
 void ctkXnatReconstructionResource::download(const QString& filename)
 {
   this->session()->download(this, filename);

Libs/XNAT/Core/ctkXnatReconstructionResource.h

@@ -1,6 +1,6 @@
 /*=============================================================================
 
-  Plugin: org.commontk.xnat
+  Library: XNAT/Core
 
   Copyright (c) University College London,
     Centre for Medical Image Computing
@@ -31,6 +31,9 @@ class ctkXnatConnection;
 class ctkXnatReconstructionResourcePrivate;
 class ctkXnatReconstruction;
 
+/**
+ * @ingroup XNAT_Core
+ */
 class CTK_XNAT_CORE_EXPORT ctkXnatReconstructionResource : public ctkXnatObject
 {
 

Libs/XNAT/Core/ctkXnatScan.cpp

@@ -1,6 +1,6 @@
 /*=============================================================================
 
-  Plugin: org.commontk.xnat
+  Library: XNAT/Core
 
   Copyright (c) University College London,
     Centre for Medical Image Computing
@@ -28,6 +28,8 @@
 #include "ctkXnatObjectPrivate.h"
 #include "ctkXnatDefaultSchemaTypes.h"
 
+
+//----------------------------------------------------------------------------
 class ctkXnatScanPrivate : public ctkXnatObjectPrivate
 {
 public:
@@ -46,25 +48,30 @@ public:
 };
 
 
+//----------------------------------------------------------------------------
 ctkXnatScan::ctkXnatScan(ctkXnatObject* parent, const QString& schemaType)
 : ctkXnatObject(*new ctkXnatScanPrivate(), parent, schemaType)
 {
 }
 
+//----------------------------------------------------------------------------
 ctkXnatScan::~ctkXnatScan()
 {
 }
 
+//----------------------------------------------------------------------------
 QString ctkXnatScan::resourceUri() const
 {
   return QString("%1/%2").arg(parent()->resourceUri(), this->id());
 }
 
+//----------------------------------------------------------------------------
 void ctkXnatScan::reset()
 {
   ctkXnatObject::reset();
 }
 
+//----------------------------------------------------------------------------
 void ctkXnatScan::fetchImpl()
 {
   QString scanResourcesUri = this->resourceUri() + "/resources";

Libs/XNAT/Core/ctkXnatScan.h

@@ -1,6 +1,6 @@
 /*=============================================================================
 
-  Plugin: org.commontk.xnat
+  Library: XNAT/Core
 
   Copyright (c) University College London,
     Centre for Medical Image Computing
@@ -31,6 +31,9 @@ class ctkXnatConnection;
 class ctkXnatScanFolder;
 class ctkXnatScanPrivate;
 
+/**
+ * @ingroup XNAT_Core
+ */
 class CTK_XNAT_CORE_EXPORT ctkXnatScan : public ctkXnatObject
 {
 

Libs/XNAT/Core/ctkXnatScanFolder.cpp

@@ -1,6 +1,6 @@
 /*=============================================================================
 
-  Plugin: org.commontk.xnat
+  Library: XNAT/Core
 
   Copyright (c) University College London,
     Centre for Medical Image Computing
@@ -27,6 +27,8 @@
 #include "ctkXnatScan.h"
 #include "ctkXnatDefaultSchemaTypes.h"
 
+
+//----------------------------------------------------------------------------
 class ctkXnatScanFolderPrivate : public ctkXnatObjectPrivate
 {
 public:
@@ -45,26 +47,31 @@ public:
 };
 
 
+//----------------------------------------------------------------------------
 ctkXnatScanFolder::ctkXnatScanFolder(ctkXnatObject* parent)
   : ctkXnatObject(*new ctkXnatScanFolderPrivate(), parent, QString::null)
 {
   this->setProperty("ID", "scans");
 }
 
+//----------------------------------------------------------------------------
 ctkXnatScanFolder::~ctkXnatScanFolder()
 {
 }
 
+//----------------------------------------------------------------------------
 QString ctkXnatScanFolder::resourceUri() const
 {
   return QString("%1/%2").arg(parent()->resourceUri(), this->id());
 }
 
+//----------------------------------------------------------------------------
 void ctkXnatScanFolder::reset()
 {
   ctkXnatObject::reset();
 }
 
+//----------------------------------------------------------------------------
 void ctkXnatScanFolder::fetchImpl()
 {
   QString scansUri = this->resourceUri();

Libs/XNAT/Core/ctkXnatScanFolder.h

@@ -1,6 +1,6 @@
 /*=============================================================================
 
-  Plugin: org.commontk.xnat
+  Library: XNAT/Core
 
   Copyright (c) University College London,
     Centre for Medical Image Computing
@@ -30,6 +30,9 @@ class ctkXnatConnection;
 class ctkXnatExperiment;
 class ctkXnatScanFolderPrivate;
 
+/**
+ * @ingroup XNAT_Core
+ */
 class CTK_XNAT_CORE_EXPORT ctkXnatScanFolder : public ctkXnatObject
 {
 

Libs/XNAT/Core/ctkXnatScanResource.cpp

@@ -1,6 +1,6 @@
 /*=============================================================================
 
-  Plugin: org.commontk.xnat
+  Library: XNAT/Core
 
   Copyright (c) University College London,
     Centre for Medical Image Computing
@@ -27,6 +27,8 @@
 #include "ctkXnatFile.h"
 #include "ctkXnatDefaultSchemaTypes.h"
 
+
+//----------------------------------------------------------------------------
 class ctkXnatScanResourcePrivate : public ctkXnatObjectPrivate
 {
 public:
@@ -45,25 +47,30 @@ public:
 };
 
 
+//----------------------------------------------------------------------------
 ctkXnatScanResource::ctkXnatScanResource(ctkXnatObject* parent, const QString& schemaType)
 : ctkXnatObject(*new ctkXnatScanResourcePrivate(), parent, schemaType)
 {
 }
 
+//----------------------------------------------------------------------------
 ctkXnatScanResource::~ctkXnatScanResource()
 {
 }
 
+//----------------------------------------------------------------------------
 QString ctkXnatScanResource::resourceUri() const
 {
   return QString("%1/resources/%2").arg(parent()->resourceUri(), this->property("label"));
 }
 
+//----------------------------------------------------------------------------
 void ctkXnatScanResource::reset()
 {
   ctkXnatObject::reset();
 }
 
+//----------------------------------------------------------------------------
 void ctkXnatScanResource::fetchImpl()
 {
   QString scanResourceFilesUri = this->resourceUri() + "/files";
@@ -84,6 +91,7 @@ void ctkXnatScanResource::fetchImpl()
   }
 }
 
+//----------------------------------------------------------------------------
 void ctkXnatScanResource::download(const QString& filename)
 {
   this->session()->download(this, filename);

Libs/XNAT/Core/ctkXnatScanResource.h

@@ -1,6 +1,6 @@
 /*=============================================================================
 
-  Plugin: org.commontk.xnat
+  Library: XNAT/Core
 
   Copyright (c) University College London,
     Centre for Medical Image Computing
@@ -31,6 +31,9 @@ class ctkXnatConnection;
 class ctkXnatScan;
 class ctkXnatScanResourcePrivate;
 
+/**
+ * @ingroup XNAT_Core
+ */
 class CTK_XNAT_CORE_EXPORT ctkXnatScanResource : public ctkXnatObject
 {
 

Libs/XNAT/Core/ctkXnatSession.cpp

@@ -1,6 +1,6 @@
 /*=============================================================================
 
-  Plugin: org.commontk.xnat
+  Library: XNAT/Core
 
   Copyright (c) University College London,
     Centre for Medical Image Computing
@@ -46,6 +46,7 @@
 #include <ctkXnatAPI_p.h>
 #include <qRestResult.h>
 
+//----------------------------------------------------------------------------
 static const char* HEADER_AUTHORIZATION = "Authorization";
 static const char* HEADER_USER_AGENT = "User-Agent";
 static const char* HEADER_COOKIE = "Cookie";
@@ -53,6 +54,7 @@ static const char* HEADER_COOKIE = "Cookie";
 static QString SERVER_VERSION = "version";
 static QString SESSION_EXPIRATION_DATE = "expires";
 
+//----------------------------------------------------------------------------
 class ctkXnatSessionPrivate
 {
 public:
@@ -82,6 +84,7 @@ public:
   static QList<ctkXnatObject*> results(qRestResult* restResult, QString schemaType);
 };
 
+//----------------------------------------------------------------------------
 ctkXnatSessionPrivate::ctkXnatSessionPrivate(const ctkXnatLoginProfile& loginProfile,
                                              ctkXnatSession* q)
   : loginProfile(loginProfile)
@@ -95,10 +98,12 @@ ctkXnatSessionPrivate::ctkXnatSessionPrivate(const ctkXnatLoginProfile& loginPro
   createConnections();
 }
 
+//----------------------------------------------------------------------------
 ctkXnatSessionPrivate::~ctkXnatSessionPrivate()
 {
 }
 
+//----------------------------------------------------------------------------
 void ctkXnatSessionPrivate::throwXnatException(const QString& msg)
 {
   QString errorMsg = msg.trimmed();
@@ -126,6 +131,7 @@ void ctkXnatSessionPrivate::throwXnatException(const QString& msg)
   }
 }
 
+//----------------------------------------------------------------------------
 void ctkXnatSessionPrivate::createConnections()
 {
 //  Q_D(ctkXnatSession);
@@ -135,6 +141,7 @@ void ctkXnatSessionPrivate::createConnections()
   //           this, SLOT(progress(QUuid,double)));
 }
 
+//----------------------------------------------------------------------------
 void ctkXnatSessionPrivate::setDefaultHttpHeaders()
 {
   ctkXnatAPI::RawHeaders rawHeaders;
@@ -151,6 +158,7 @@ void ctkXnatSessionPrivate::setDefaultHttpHeaders()
   xnat->setDefaultRawHeaders(rawHeaders);
 }
 
+//----------------------------------------------------------------------------
 void ctkXnatSessionPrivate::checkSession() const
 {
   if (sessionId.isEmpty())
@@ -159,6 +167,7 @@ void ctkXnatSessionPrivate::checkSession() const
   }
 }
 
+//----------------------------------------------------------------------------
 void ctkXnatSessionPrivate::setSessionProperties()
 {
   sessionProperties.clear();
@@ -179,6 +188,7 @@ void ctkXnatSessionPrivate::setSessionProperties()
   }
 }
 
+//----------------------------------------------------------------------------
 QDateTime ctkXnatSessionPrivate::updateExpirationDate(qRestResult* restResult)
 {
   QByteArray cookieHeader = restResult->rawHeader("Set-Cookie");
@@ -210,6 +220,7 @@ QDateTime ctkXnatSessionPrivate::updateExpirationDate(qRestResult* restResult)
   return expirationDate;
 }
 
+//----------------------------------------------------------------------------
 void ctkXnatSessionPrivate::close()
 {
   sessionProperties.clear();
@@ -219,6 +230,7 @@ void ctkXnatSessionPrivate::close()
   dataModel.reset();
 }
 
+//----------------------------------------------------------------------------
 QList<ctkXnatObject*> ctkXnatSessionPrivate::results(qRestResult* restResult, QString schemaType)
 {
   QList<ctkXnatObject*> results;
@@ -274,8 +286,11 @@ QList<ctkXnatObject*> ctkXnatSessionPrivate::results(qRestResult* restResult, QS
   return results;
 }
 
+
+//----------------------------------------------------------------------------
 // ctkXnatSession class
 
+//----------------------------------------------------------------------------
 ctkXnatSession::ctkXnatSession(const ctkXnatLoginProfile& loginProfile)
 : d_ptr(new ctkXnatSessionPrivate(loginProfile, this))
 {
@@ -296,11 +311,13 @@ ctkXnatSession::ctkXnatSession(const ctkXnatLoginProfile& loginProfile)
   d->setDefaultHttpHeaders();
 }
 
+//----------------------------------------------------------------------------
 ctkXnatSession::~ctkXnatSession()
 {
   this->close();
 }
 
+//----------------------------------------------------------------------------
 void ctkXnatSession::open()
 {
   Q_D(ctkXnatSession);
@@ -330,6 +347,7 @@ void ctkXnatSession::open()
   d->dataModel->setProperty("ID", this->url().toString());
 }
 
+//----------------------------------------------------------------------------
 void ctkXnatSession::close()
 {
   Q_D(ctkXnatSession);
@@ -339,12 +357,14 @@ void ctkXnatSession::close()
   d->close();
 }
 
+//----------------------------------------------------------------------------
 bool ctkXnatSession::isOpen() const
 {
   Q_D(const ctkXnatSession);
   return !d->sessionId.isEmpty();
 }
 
+//----------------------------------------------------------------------------
 QString ctkXnatSession::version() const
 {
   Q_D(const ctkXnatSession);
@@ -358,6 +378,7 @@ QString ctkXnatSession::version() const
   }
 }
 
+//----------------------------------------------------------------------------
 QDateTime ctkXnatSession::expirationDate() const
 {
   Q_D(const ctkXnatSession);
@@ -365,6 +386,7 @@ QDateTime ctkXnatSession::expirationDate() const
   return QDateTime::fromString(d->sessionProperties[SESSION_EXPIRATION_DATE], Qt::ISODate);
 }
 
+//----------------------------------------------------------------------------
 QDateTime ctkXnatSession::renew()
 {
   Q_D(ctkXnatSession);
@@ -379,12 +401,14 @@ QDateTime ctkXnatSession::renew()
   return d->updateExpirationDate(restResult.data());
 }
 
+//----------------------------------------------------------------------------
 ctkXnatLoginProfile ctkXnatSession::loginProfile() const
 {
   Q_D(const ctkXnatSession);
   return d->loginProfile;
 }
 
+//----------------------------------------------------------------------------
 void ctkXnatSession::progress(QUuid /*queryId*/, double /*progress*/)
 {
 //  qDebug() << "ctkXnatSession::progress(QUuid queryId, double progress)";
@@ -392,24 +416,28 @@ void ctkXnatSession::progress(QUuid /*queryId*/, double /*progress*/)
 //  qDebug() << "progress:" << (progress * 100.0) << "%";
 }
 
+//----------------------------------------------------------------------------
 QUrl ctkXnatSession::url() const
 {
   Q_D(const ctkXnatSession);
   return d->loginProfile.serverUrl();
 }
 
+//----------------------------------------------------------------------------
 QString ctkXnatSession::userName() const
 {
   Q_D(const ctkXnatSession);
   return d->loginProfile.userName();
 }
 
+//----------------------------------------------------------------------------
 QString ctkXnatSession::password() const
 {
   Q_D(const ctkXnatSession);
   return d->loginProfile.password();
 }
 
+//----------------------------------------------------------------------------
 ctkXnatDataModel* ctkXnatSession::dataModel() const
 {
   Q_D(const ctkXnatSession);
@@ -417,6 +445,7 @@ ctkXnatDataModel* ctkXnatSession::dataModel() const
   return d->dataModel.data();
 }
 
+//----------------------------------------------------------------------------
 QUuid ctkXnatSession::httpGet(const QString& resource, const ctkXnatSession::UrlParameters& parameters, const ctkXnatSession::HttpRawHeaders& rawHeaders)
 {
   Q_D(ctkXnatSession);
@@ -424,6 +453,7 @@ QUuid ctkXnatSession::httpGet(const QString& resource, const ctkXnatSession::Url
   return d->xnat->get(resource, parameters, rawHeaders);
 }
 
+//----------------------------------------------------------------------------
 QList<ctkXnatObject*> ctkXnatSession::httpResults(const QUuid& uuid, const QString& schemaType)
 {
   Q_D(ctkXnatSession);
@@ -437,6 +467,7 @@ QList<ctkXnatObject*> ctkXnatSession::httpResults(const QUuid& uuid, const QStri
   return d->results(restResult.data(), schemaType);
 }
 
+//----------------------------------------------------------------------------
 QList<QVariantMap> ctkXnatSession::httpSync(const QUuid& uuid)
 {
   Q_D(ctkXnatSession);
@@ -456,6 +487,7 @@ QList<QVariantMap> ctkXnatSession::httpSync(const QUuid& uuid)
   return result;
 }
 
+//----------------------------------------------------------------------------
 bool ctkXnatSession::exists(const ctkXnatObject* object)
 {
   Q_D(ctkXnatSession);
@@ -466,6 +498,7 @@ bool ctkXnatSession::exists(const ctkXnatObject* object)
   return success;
 }
 
+//----------------------------------------------------------------------------
 void ctkXnatSession::save(ctkXnatObject* object)
 {
   Q_D(ctkXnatSession);
@@ -500,6 +533,7 @@ void ctkXnatSession::save(ctkXnatObject* object)
   }
 }
 
+//----------------------------------------------------------------------------
 void ctkXnatSession::remove(ctkXnatObject* object)
 {
   Q_D(ctkXnatSession);
@@ -513,6 +547,7 @@ void ctkXnatSession::remove(ctkXnatObject* object)
   }
 }
 
+//----------------------------------------------------------------------------
 //void ctkXnatSession::create(ctkXnatSubject* subject)
 //{
 //  const QString& subjectName = subject->getName();
@@ -530,6 +565,7 @@ void ctkXnatSession::remove(ctkXnatObject* object)
 //  }
 //}
 
+//----------------------------------------------------------------------------
 //void ctkXnatSession::downloadScanFiles(ctkXnatExperiment* experiment, const QString& fileName)
 //{
 //  const QString& experimentName = experiment->getName();
@@ -547,6 +583,7 @@ void ctkXnatSession::remove(ctkXnatObject* object)
 //  d->xnat->sync(queryId);
 //}
 
+//----------------------------------------------------------------------------
 //void ctkXnatSession::downloadReconstructionFiles(ctkXnatExperiment* experiment, const QString& fileName)
 //{
 //  const QString& experimentName = experiment->getName();
@@ -564,6 +601,7 @@ void ctkXnatSession::remove(ctkXnatObject* object)
 //  d->xnat->sync(queryId);
 //}
 
+//----------------------------------------------------------------------------
 //void ctkXnatSession::downloadReconstruction(ctkXnatReconstruction* reconstruction, const QString& fileName)
 //{
 //  const QString& reconstructionName = reconstruction->getName();
@@ -583,6 +621,7 @@ void ctkXnatSession::remove(ctkXnatObject* object)
 //  d->xnat->sync(queryId);
 //}
 
+//----------------------------------------------------------------------------
 //void ctkXnatSession::downloadReconstructionResourceFiles(ctkXnatReconstructionResource* reconstructionResource, const QString& fileName)
 //{
 //  const QString& reconstructionResourceName = reconstructionResource->getName();
@@ -604,6 +643,7 @@ void ctkXnatSession::remove(ctkXnatObject* object)
 //  d->xnat->sync(queryId);
 //}
 
+//----------------------------------------------------------------------------
 //void ctkXnatSession::download(ctkXnatReconstructionResourceFile* reconstructionResourceFile, const QString& fileName)
 //{
 //  const QString& reconstructionResourceFileName = reconstructionResourceFile->getName();
@@ -627,6 +667,7 @@ void ctkXnatSession::remove(ctkXnatObject* object)
 //  d->xnat->sync(queryId);
 //}
 
+//----------------------------------------------------------------------------
 //void ctkXnatSession::download(ctkXnatScan* scan, const QString& fileName)
 //{
 //  const QString& scanName = scan->getName();
@@ -646,6 +687,7 @@ void ctkXnatSession::remove(ctkXnatObject* object)
 //  d->xnat->sync(queryId);
 //}
 
+//----------------------------------------------------------------------------
 void ctkXnatSession::download(ctkXnatFile* file, const QString& fileName)
 {
   Q_D(ctkXnatSession);
@@ -655,6 +697,7 @@ void ctkXnatSession::download(ctkXnatFile* file, const QString& fileName)
   d->xnat->sync(queryId);
 }
 
+//----------------------------------------------------------------------------
 void ctkXnatSession::download(ctkXnatScanResource* scanResource, const QString& fileName)
 {
   Q_D(ctkXnatSession);
@@ -666,6 +709,7 @@ void ctkXnatSession::download(ctkXnatScanResource* scanResource, const QString&
   d->xnat->sync(queryId);
 }
 
+//----------------------------------------------------------------------------
 void ctkXnatSession::download(ctkXnatReconstructionResource* reconstructionResource, const QString& fileName)
 {
   Q_D(ctkXnatSession);
@@ -677,6 +721,7 @@ void ctkXnatSession::download(ctkXnatReconstructionResource* reconstructionResou
   d->xnat->sync(queryId);
 }
 
+//----------------------------------------------------------------------------
 void ctkXnatSession::processResult(QUuid queryId, QList<QVariantMap> parameters)
 {
   Q_UNUSED(queryId)

Libs/XNAT/Core/ctkXnatSession.h

@@ -1,6 +1,6 @@
 /*=============================================================================
 
-  Plugin: org.commontk.xnat
+  Library: XNAT/Core
 
   Copyright (c) University College London,
     Centre for Medical Image Computing
@@ -42,6 +42,12 @@ class ctkXnatObject;
 class ctkXnatScanResource;
 class ctkXnatReconstructionResource;
 
+/**
+ * @ingroup XNAT_Core
+ *
+ * @brief The ctkXnatSession class reprents a session object associated
+ * with a specific XNAT connection.
+ */
 class CTK_XNAT_CORE_EXPORT ctkXnatSession : public QObject
 {
   Q_OBJECT

Libs/XNAT/Core/ctkXnatSettings.cpp

@@ -1,6 +1,6 @@
 /*=============================================================================
 
-  Plugin: org.commontk.xnat
+  Library: XNAT/Core
 
   Copyright (c) University College London,
     Centre for Medical Image Computing

Libs/XNAT/Core/ctkXnatSettings.h

@@ -1,6 +1,6 @@
 /*=============================================================================
 
-  Plugin: org.commontk.xnat
+  Library: XNAT/Core
 
   Copyright (c) University College London,
     Centre for Medical Image Computing
@@ -29,6 +29,9 @@
 
 class ctkXnatLoginProfile;
 
+/**
+ * @ingroup XNAT_Core
+ */
 class CTK_XNAT_CORE_EXPORT ctkXnatSettings
 {
 public:

Libs/XNAT/Core/ctkXnatSubject.cpp

@@ -1,6 +1,6 @@
 /*=============================================================================
 
-  Plugin: org.commontk.xnat
+  Library: XNAT/Core
 
   Copyright (c) University College London,
     Centre for Medical Image Computing
@@ -29,6 +29,8 @@
 #include "ctkXnatProject.h"
 #include "ctkXnatDefaultSchemaTypes.h"
 
+
+//----------------------------------------------------------------------------
 class ctkXnatSubjectPrivate : public ctkXnatObjectPrivate
 {
 public:
@@ -53,50 +55,60 @@ public:
   QList<ctkXnatProject*> projects;
 };
 
+
+//----------------------------------------------------------------------------
 ctkXnatSubject::ctkXnatSubject(ctkXnatObject* parent, const QString& schemaType)
 : ctkXnatObject(*new ctkXnatSubjectPrivate(), parent, schemaType)
 {
 }
 
+//----------------------------------------------------------------------------
 ctkXnatSubject::~ctkXnatSubject()
 {
 }
 
+//----------------------------------------------------------------------------
 const QString& ctkXnatSubject::insertDate() const
 {
   Q_D(const ctkXnatSubject);
   return d->insertDate;
 }
 
+//----------------------------------------------------------------------------
 void ctkXnatSubject::setInsertDate(const QString& insertDate)
 {
   Q_D(ctkXnatSubject);
   d->insertDate = insertDate;
 }
 
+//----------------------------------------------------------------------------
 const QString& ctkXnatSubject::insertUser() const
 {
   Q_D(const ctkXnatSubject);
   return d->insertUser;
 }
 
+//----------------------------------------------------------------------------
 void ctkXnatSubject::setInsertUser(const QString& insertUser)
 {
   Q_D(ctkXnatSubject);
   d->insertUser = insertUser;
 }
 
+//----------------------------------------------------------------------------
 QString ctkXnatSubject::resourceUri() const
 {
   return QString("%1/subjects/%2").arg(parent()->resourceUri(), this->id());
 }
 
+//----------------------------------------------------------------------------
 void ctkXnatSubject::reset()
 {
   Q_D(ctkXnatSubject);
   d->reset();
 }
 
+//----------------------------------------------------------------------------
 void ctkXnatSubject::fetchImpl()
 {
   QString experimentsUri = this->resourceUri() + "/experiments";

Libs/XNAT/Core/ctkXnatSubject.h

@@ -1,6 +1,6 @@
 /*=============================================================================
 
-  Plugin: org.commontk.xnat
+  Library: XNAT/Core
 
   Copyright (c) University College London,
     Centre for Medical Image Computing
@@ -30,6 +30,9 @@
 class ctkXnatProject;
 class ctkXnatSubjectPrivate;
 
+/**
+ * @ingroup XNAT_Core
+ */
 class CTK_XNAT_CORE_EXPORT ctkXnatSubject : public ctkXnatObject
 {
 

Libs/XNAT/Widgets/ctkXnatTreeItem.cpp

@@ -1,6 +1,6 @@
 /*=============================================================================
 
-  Plugin: org.commontk.xnat
+  Library: XNAT/Core
 
   Copyright (c) University College London,
     Centre for Medical Image Computing
@@ -19,70 +19,82 @@
 
 =============================================================================*/
 
-#include "ctkXnatTreeItem.h"
+#include "ctkXnatTreeItem_p.h"
 
 #include "ctkXnatObject.h"
-#include "ctkXnatTreeItem.h"
 
+
+//----------------------------------------------------------------------------
 ctkXnatTreeItem::ctkXnatTreeItem()
 : m_XnatObject(0)
 , m_ParentItem(0)
 {
 }
 
+//----------------------------------------------------------------------------
 ctkXnatTreeItem::ctkXnatTreeItem(ctkXnatObject* xnatObject, ctkXnatTreeItem* parentItem)
 : m_XnatObject(xnatObject)
 , m_ParentItem(parentItem)
 {
 }
 
+//----------------------------------------------------------------------------
 ctkXnatTreeItem::~ctkXnatTreeItem()
 {
   qDeleteAll(m_ChildItems);
 }
 
+//----------------------------------------------------------------------------
 ctkXnatObject* ctkXnatTreeItem::xnatObject() const
 {
   return m_XnatObject;
 }
 
+//----------------------------------------------------------------------------
 void ctkXnatTreeItem::appendChild(ctkXnatTreeItem* item)
 {
   m_ChildItems.append(item);
   item->m_ParentItem = this;
 }
 
+//----------------------------------------------------------------------------
 void ctkXnatTreeItem::removeChildren()
 {
   qDeleteAll(m_ChildItems);
 }
 
+//----------------------------------------------------------------------------
 ctkXnatTreeItem* ctkXnatTreeItem::child(int row)
 {
   return m_ChildItems.value(row);
 }
 
+//----------------------------------------------------------------------------
 int ctkXnatTreeItem::childCount() const
 {
   return m_ChildItems.count();
 }
 
+//----------------------------------------------------------------------------
 int ctkXnatTreeItem::row() const
 {
   return m_ParentItem->m_ChildItems.indexOf(const_cast<ctkXnatTreeItem*>(this));
 }
 
+//----------------------------------------------------------------------------
 int ctkXnatTreeItem::columnCount() const
 {
   return 1;
 }
 
+//----------------------------------------------------------------------------
 QVariant ctkXnatTreeItem::data(int column) const
 {
   Q_UNUSED(column);
   return m_XnatObject->name();
 }
 
+//----------------------------------------------------------------------------
 ctkXnatTreeItem* ctkXnatTreeItem::parent()
 {
   return m_ParentItem;

Libs/XNAT/Widgets/ctkXnatTreeItem.h

@@ -1,6 +1,6 @@
 /*=============================================================================
 
-  Plugin: org.commontk.xnat
+  Library: XNAT/Core
 
   Copyright (c) University College London,
     Centre for Medical Image Computing
@@ -27,7 +27,6 @@
 #include <QList>
 #include <QVariant>
 
-class ctkXnatTreeItem;
 
 class ctkXnatTreeItem
 {

Libs/XNAT/Widgets/ctkXnatTreeModel.cpp

@@ -1,6 +1,6 @@
 /*=============================================================================
 
-  Plugin: org.commontk.xnat
+  Library: XNAT/Core
 
   Copyright (c) University College London,
     Centre for Medical Image Computing
@@ -21,19 +21,41 @@
 
 #include "ctkXnatTreeModel.h"
 #include "ctkXnatObject.h"
+#include "ctkXnatTreeItem_p.h"
+#include "ctkXnatDataModel.h"
 
 #include <QList>
 
+class ctkXnatTreeModelPrivate
+{
+public:
+
+  ctkXnatTreeModelPrivate()
+    : m_RootItem(new ctkXnatTreeItem())
+  {
+  }
+
+  ctkXnatTreeItem* itemAt(const QModelIndex& index) const
+  {
+    return static_cast<ctkXnatTreeItem*>(index.internalPointer());
+  }
+
+  QScopedPointer<ctkXnatTreeItem> m_RootItem;
+
+};
+
+//----------------------------------------------------------------------------
 ctkXnatTreeModel::ctkXnatTreeModel()
-: m_RootItem(new ctkXnatTreeItem())
+: d_ptr(new ctkXnatTreeModelPrivate())
 {
 }
 
+//----------------------------------------------------------------------------
 ctkXnatTreeModel::~ctkXnatTreeModel()
 {
-  delete m_RootItem;
 }
 
+//----------------------------------------------------------------------------
 // returns name (project, subject, etc.) for row and column of
 //   parent in index if role is Qt::DisplayRole
 QVariant ctkXnatTreeModel::data(const QModelIndex& index, int role) const
@@ -70,6 +92,7 @@ QVariant ctkXnatTreeModel::data(const QModelIndex& index, int role) const
   return QVariant();
 }
 
+//----------------------------------------------------------------------------
 QModelIndex ctkXnatTreeModel::index(int row, int column, const QModelIndex& index) const
 {
   if (!this->hasIndex(row, column, index))
@@ -77,14 +100,15 @@ QModelIndex ctkXnatTreeModel::index(int row, int column, const QModelIndex& inde
     return QModelIndex();
   }
 
+  Q_D(const ctkXnatTreeModel);
   ctkXnatTreeItem* item;
   if (!index.isValid())
   {
-    item = m_RootItem;
+    item = d->m_RootItem.data();
   }
   else
   {
-    item = this->itemAt(index);
+    item = d->itemAt(index);
   }
 
   ctkXnatTreeItem* childItem = item->child(row);
@@ -97,6 +121,7 @@ QModelIndex ctkXnatTreeModel::index(int row, int column, const QModelIndex& inde
   return QModelIndex();
 }
 
+//----------------------------------------------------------------------------
 QModelIndex ctkXnatTreeModel::parent(const QModelIndex& index) const
 {
   if (!index.isValid())
@@ -104,10 +129,11 @@ QModelIndex ctkXnatTreeModel::parent(const QModelIndex& index) const
     return QModelIndex();
   }
 
-  ctkXnatTreeItem* item = this->itemAt(index);
+  Q_D(const ctkXnatTreeModel);
+  ctkXnatTreeItem* item = d->itemAt(index);
   ctkXnatTreeItem* parentItem = item->parent();
 
-  if (parentItem == m_RootItem)
+  if (parentItem == d->m_RootItem.data())
   {
     return QModelIndex();
   }
@@ -115,6 +141,7 @@ QModelIndex ctkXnatTreeModel::parent(const QModelIndex& index) const
   return this->createIndex(parentItem->row(), 0, parentItem);
 }
 
+//----------------------------------------------------------------------------
 int ctkXnatTreeModel::rowCount(const QModelIndex& index) const
 {
   if (index.column() > 0)
@@ -122,47 +149,55 @@ int ctkXnatTreeModel::rowCount(const QModelIndex& index) const
     return 0;
   }
 
+  Q_D(const ctkXnatTreeModel);
   ctkXnatTreeItem* item;
   if (!index.isValid())
   {
-    item = m_RootItem;
+    item = d->m_RootItem.data();
   }
   else
   {
-    item = this->itemAt(index);
+    item = d->itemAt(index);
   }
 
   return item->childCount();
 }
 
+//----------------------------------------------------------------------------
 int ctkXnatTreeModel::columnCount(const QModelIndex& index) const
 {
   Q_UNUSED(index);
   return 1;
 }
 
+//----------------------------------------------------------------------------
 // defer request for children until actually needed by QTreeView object
 bool ctkXnatTreeModel::hasChildren(const QModelIndex& index) const
 {
+  Q_D(const ctkXnatTreeModel);
   if (!index.isValid())
   {
-    return m_RootItem->childCount() > 0;
+    return d->m_RootItem->childCount() > 0;
   }
 
-  ctkXnatTreeItem* item = this->itemAt(index);
+  ctkXnatTreeItem* item = d->itemAt(index);
   return !item->xnatObject()->isFetched() || !item->xnatObject()->children().isEmpty();
 }
 
+//----------------------------------------------------------------------------
 bool ctkXnatTreeModel::canFetchMore(const QModelIndex& index) const
 {
   if (!index.isValid())
   {
     return false;
   }
-  ctkXnatTreeItem* item = this->itemAt(index);
+
+  Q_D(const ctkXnatTreeModel);
+  ctkXnatTreeItem* item = d->itemAt(index);
   return !(item->childCount() > 0);
 }
 
+//----------------------------------------------------------------------------
 void ctkXnatTreeModel::fetchMore(const QModelIndex& index)
 {
   if (!index.isValid())
@@ -170,7 +205,8 @@ void ctkXnatTreeModel::fetchMore(const QModelIndex& index)
     return;
   }
 
-  ctkXnatTreeItem* item = this->itemAt(index);
+  Q_D(const ctkXnatTreeModel);
+  ctkXnatTreeItem* item = d->itemAt(index);
 
   ctkXnatObject* xnatObject = item->xnatObject();
 
@@ -188,22 +224,21 @@ void ctkXnatTreeModel::fetchMore(const QModelIndex& index)
   }
 }
 
+//----------------------------------------------------------------------------
 ctkXnatObject* ctkXnatTreeModel::xnatObject(const QModelIndex& index) const
 {
-  return this->itemAt(index)->xnatObject();
+  Q_D(const ctkXnatTreeModel);
+  return d->itemAt(index)->xnatObject();
 }
 
+//----------------------------------------------------------------------------
 void ctkXnatTreeModel::addDataModel(ctkXnatDataModel* dataModel)
 {
-  m_RootItem->appendChild(new ctkXnatTreeItem(dataModel, m_RootItem));
+  Q_D(ctkXnatTreeModel);
+  d->m_RootItem->appendChild(new ctkXnatTreeItem(dataModel, d->m_RootItem.data()));
 }
 
-ctkXnatTreeItem* ctkXnatTreeModel::itemAt(const QModelIndex& index) const
-{
-  return static_cast<ctkXnatTreeItem*>(index.internalPointer());
-}
-
-
+//----------------------------------------------------------------------------
 bool ctkXnatTreeModel::removeAllRows(const QModelIndex& parent)
 {
   // do nothing for the root
@@ -241,6 +276,7 @@ bool ctkXnatTreeModel::removeAllRows(const QModelIndex& parent)
   return true;
 }
 
+//----------------------------------------------------------------------------
 void ctkXnatTreeModel::downloadFile(const QModelIndex& index, const QString& zipFileName)
 {
   if (!index.isValid())
@@ -253,6 +289,7 @@ void ctkXnatTreeModel::downloadFile(const QModelIndex& index, const QString& zip
   return;
 }
 
+//----------------------------------------------------------------------------
 void ctkXnatTreeModel::uploadFile(const QModelIndex& index, const QString& zipFileName)
 {
   if (!index.isValid())

Libs/XNAT/Widgets/ctkXnatTreeModel.h

@@ -1,6 +1,6 @@
 /*=============================================================================
 
-  Plugin: org.commontk.xnat
+  Library: XNAT/Core
 
   Copyright (c) University College London,
     Centre for Medical Image Computing
@@ -22,15 +22,18 @@
 #ifndef ctkXnatTreeModel_h
 #define ctkXnatTreeModel_h
 
-#include "ctkXNATWidgetsExport.h"
+#include "ctkXNATCoreExport.h"
 
 #include <QAbstractItemModel>
 
-#include "ctkXnatTreeItem.h"
-#include "ctkXnatDataModel.h"
+class ctkXnatObject;
+class ctkXnatDataModel;
+class ctkXnatTreeModelPrivate;
 
-
-class CTK_XNAT_WIDGETS_EXPORT ctkXnatTreeModel : public QAbstractItemModel
+/**
+ * @ingroup XNAT_Core
+ */
+class CTK_XNAT_CORE_EXPORT ctkXnatTreeModel : public QAbstractItemModel
 {
   Q_OBJECT
 
@@ -58,9 +61,9 @@ public:
 
 private:
 
-  ctkXnatTreeItem* itemAt(const QModelIndex& index) const;
+  const QScopedPointer<ctkXnatTreeModelPrivate> d_ptr;
 
-  ctkXnatTreeItem* m_RootItem;
+  Q_DECLARE_PRIVATE(ctkXnatTreeModel)
 
 };
 

Libs/XNAT/Documentation/CTKXNAT.dox

@@ -0,0 +1,10 @@
+/**
+
+\defgroup XNAT_Core XNAT Core
+\ingroup Libs
+
+\defgroup XNAT_Widgets XNAT Widgets
+\ingroup Libs
+\ingroup Project_Widgets
+
+*/

Libs/XNAT/Widgets/CMakeLists.txt

@@ -8,17 +8,11 @@ set(KIT_export_directive "CTK_XNAT_WIDGETS_EXPORT")
 
 set(KIT_SRCS
   ctkXnatLoginDialog.cpp
-  ctkXnatTreeItem.cpp
-  ctkXnatTreeModel.cpp
-  ctkXnatSettings.cpp
-  ctkXnatListModel.cpp
 )
 
 # Files which should be processed by Qts moc
 set(KIT_MOC_SRCS
   ctkXnatLoginDialog.h
-  ctkXnatTreeModel.h
-  ctkXnatListModel.h
 )
 
 
@@ -31,8 +25,6 @@ set(KIT_UI_FORMS
 set(KIT_resources
 )
 
-set(QT_USE_QTSCRIPT 1)
-
 # Target libraries - See CMake/ctkFunctionGetTargetLibraries.cmake
 # The following macro will read the target libraries from the file 'target_libraries.cmake'
 set(KIT_target_libraries)

Libs/XNAT/Widgets/ctkXnatLoginDialog.cpp

@@ -1,6 +1,6 @@
 /*=============================================================================
 
-  Library: CTK
+  Library: XNAT/Widgets
 
   Copyright (c) University College London,
     Centre for Medical Image Computing
@@ -32,6 +32,8 @@
 #include "ctkXnatLoginProfile.h"
 #include "ctkXnatSettings.h"
 
+
+//----------------------------------------------------------------------------
 class ctkXnatLoginDialogPrivate
 {
 public:
@@ -53,6 +55,7 @@ public:
   bool Dirty;
 };
 
+//----------------------------------------------------------------------------
 ctkXnatLoginDialog::ctkXnatLoginDialog(ctkXnatSessionFactory* f, QWidget* parent, Qt::WindowFlags flags)
 : QDialog(parent, flags)
 , ui(0)
@@ -84,6 +87,7 @@ ctkXnatLoginDialog::ctkXnatLoginDialog(ctkXnatSessionFactory* f, QWidget* parent
     }
 }
 
+//----------------------------------------------------------------------------
 ctkXnatLoginDialog::~ctkXnatLoginDialog()
 {
   Q_D(ctkXnatLoginDialog);
@@ -99,6 +103,7 @@ ctkXnatLoginDialog::~ctkXnatLoginDialog()
     }
 }
 
+//----------------------------------------------------------------------------
 void ctkXnatLoginDialog::createConnections()
 {
   connect(ui->edtProfileName, SIGNAL(textChanged(const QString&)), this, SLOT(onFieldChanged()));
@@ -111,6 +116,7 @@ void ctkXnatLoginDialog::createConnections()
       this, SLOT(onCurrentProfileChanged(const QModelIndex&)));
 }
 
+//----------------------------------------------------------------------------
 ctkXnatSettings* ctkXnatLoginDialog::settings() const
 {
   Q_D(const ctkXnatLoginDialog);
@@ -118,6 +124,7 @@ ctkXnatSettings* ctkXnatLoginDialog::settings() const
   return d->Settings;
 }
 
+//----------------------------------------------------------------------------
 void ctkXnatLoginDialog::setSettings(ctkXnatSettings* settings)
 {
   Q_D(ctkXnatLoginDialog);
@@ -146,12 +153,14 @@ void ctkXnatLoginDialog::setSettings(ctkXnatSettings* settings)
     }
 }
 
+//----------------------------------------------------------------------------
 ctkXnatSession* ctkXnatLoginDialog::session() const
 {
   Q_D(const ctkXnatLoginDialog);
   return d->Session;
 }
 
+//----------------------------------------------------------------------------
 void ctkXnatLoginDialog::accept()
 {
   Q_D(ctkXnatLoginDialog);
@@ -209,6 +218,7 @@ void ctkXnatLoginDialog::accept()
   QDialog::accept();
 }
 
+//----------------------------------------------------------------------------
 void ctkXnatLoginDialog::onCurrentProfileChanged(const QModelIndex& currentIndex)
 {
   Q_D(ctkXnatLoginDialog);
@@ -250,12 +260,14 @@ void ctkXnatLoginDialog::onCurrentProfileChanged(const QModelIndex& currentIndex
     }
 }
 
+//----------------------------------------------------------------------------
 void ctkXnatLoginDialog::resetLstProfilesCurrentIndex()
 {
   // Yes, this is really needed. See the comment above.
   ui->lstProfiles->setCurrentIndex(ui->lstProfiles->currentIndex());
 }
 
+//----------------------------------------------------------------------------
 bool ctkXnatLoginDialog::askToSaveProfile(const QString& profileName)
 {
   QString question = QString(
@@ -267,6 +279,7 @@ bool ctkXnatLoginDialog::askToSaveProfile(const QString& profileName)
   return answer == QMessageBox::Yes;
 }
 
+//----------------------------------------------------------------------------
 void ctkXnatLoginDialog::saveProfile(const QString& profileName)
 {
   Q_D(ctkXnatLoginDialog);
@@ -318,6 +331,7 @@ void ctkXnatLoginDialog::saveProfile(const QString& profileName)
   ui->btnSave->setEnabled(false);
 }
 
+//----------------------------------------------------------------------------
 void ctkXnatLoginDialog::on_btnSave_clicked()
 {
   Q_D(ctkXnatLoginDialog);
@@ -345,6 +359,7 @@ void ctkXnatLoginDialog::on_btnSave_clicked()
     }
 }
 
+//----------------------------------------------------------------------------
 void ctkXnatLoginDialog::blockSignalsOfFields(bool value)
 {
   ui->edtProfileName->blockSignals(value);
@@ -354,6 +369,7 @@ void ctkXnatLoginDialog::blockSignalsOfFields(bool value)
   ui->cbxDefaultProfile->blockSignals(value);
 }
 
+//----------------------------------------------------------------------------
 void ctkXnatLoginDialog::loadProfile(const ctkXnatLoginProfile& profile)
 {
   this->blockSignalsOfFields(true);
@@ -367,6 +383,7 @@ void ctkXnatLoginDialog::loadProfile(const ctkXnatLoginProfile& profile)
   this->blockSignalsOfFields(false);
 }
 
+//----------------------------------------------------------------------------
 void ctkXnatLoginDialog::storeProfile(ctkXnatLoginProfile& profile)
 {
   profile.setName(ui->edtProfileName->text());
@@ -376,6 +393,7 @@ void ctkXnatLoginDialog::storeProfile(ctkXnatLoginProfile& profile)
   profile.setDefault(ui->cbxDefaultProfile->isChecked());
 }
 
+//----------------------------------------------------------------------------
 void ctkXnatLoginDialog::on_btnDelete_clicked()
 {
   Q_D(ctkXnatLoginDialog);
@@ -399,12 +417,14 @@ void ctkXnatLoginDialog::on_btnDelete_clicked()
     }
 }
 
+//----------------------------------------------------------------------------
 void ctkXnatLoginDialog::on_edtProfileName_textChanged(const QString& /*text*/)
 {
   ui->lstProfiles->clearSelection();
   ui->btnDelete->setEnabled(false);
 }
 
+//----------------------------------------------------------------------------
 void ctkXnatLoginDialog::onFieldChanged()
 {
   Q_D(ctkXnatLoginDialog);

Libs/XNAT/Widgets/ctkXnatLoginDialog.h

@@ -1,6 +1,6 @@
 /*=============================================================================
 
-  Library: CTK
+  Library: XNAT/Widgets
 
   Copyright (c) University College London,
     Centre for Medical Image Computing
@@ -35,6 +35,9 @@ class ctkXnatSessionFactory;
 class ctkXnatLoginDialogPrivate;
 class ctkXnatSettings;
 
+/**
+ * @ingroup XNAT_Widgets
+ */
 class CTK_XNAT_WIDGETS_EXPORT ctkXnatLoginDialog : public QDialog
 {
   Q_OBJECT
@@ -74,8 +77,8 @@ private:
   /// \brief d pointer of the pimpl pattern
   QScopedPointer<ctkXnatLoginDialogPrivate> d_ptr;
 
-  Q_DECLARE_PRIVATE(ctkXnatLoginDialog);
-  Q_DISABLE_COPY(ctkXnatLoginDialog);
+  Q_DECLARE_PRIVATE(ctkXnatLoginDialog)
+  Q_DISABLE_COPY(ctkXnatLoginDialog)
 };
 
 #endif

Libs/XNAT/Widgets/ctkXnatSettings.cpp

@@ -1,63 +0,0 @@
-/*=============================================================================
-
-  Library: CTK
-
-  Copyright (c) University College London,
-    Centre for Medical Image Computing
-
-  Licensed under the Apache License, Version 2.0 (the "License");
-  you may not use this file except in compliance with the License.
-  You may obtain a copy of the License at
-
-    http://www.apache.org/licenses/LICENSE-2.0
-
-  Unless required by applicable law or agreed to in writing, software
-  distributed under the License is distributed on an "AS IS" BASIS,
-  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-  See the License for the specific language governing permissions and
-  limitations under the License.
-
-=============================================================================*/
-
-#include "ctkXnatSettings.h"
-
-#include <QDir>
-#include <QFileInfo>
-#include <QUuid>
-
-#include "ctkXnatLoginProfile.h"
-
-ctkXnatSettings::ctkXnatSettings()
-{
-}
-
-ctkXnatSettings::~ctkXnatSettings()
-{
-}
-
-QString ctkXnatSettings::getWorkSubdirectory() const
-{
-  // set work directory name
-  QDir workDir;
-  QString workDirName = getDefaultWorkDirectory();
-  if ( !workDirName.isEmpty() )
-    {
-    workDir = QDir(workDirName);
-    }
-
-  // generate random name for subdirectory
-  QString subdir = QUuid::createUuid().toString();
-
-  // create subdirectory in work directory
-  bool subdirCreated = workDir.mkdir(subdir);
-
-  // check whether subdirectory was created
-  if ( !subdirCreated )
-    {
-    // display error message
-    return QString();
-    }
-
-  // return full path of subdirectory
-  return QFileInfo(workDir, subdir).absoluteFilePath();
-}

Libs/XNAT/Widgets/ctkXnatSettings.h

@@ -1,58 +0,0 @@
-/*=============================================================================
-
-  Library: CTK
-
-  Copyright (c) University College London,
-    Centre for Medical Image Computing
-
-  Licensed under the Apache License, Version 2.0 (the "License");
-  you may not use this file except in compliance with the License.
-  You may obtain a copy of the License at
-
-    http://www.apache.org/licenses/LICENSE-2.0
-
-  Unless required by applicable law or agreed to in writing, software
-  distributed under the License is distributed on an "AS IS" BASIS,
-  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-  See the License for the specific language governing permissions and
-  limitations under the License.
-
-=============================================================================*/
-
-#ifndef ctkXnatSettings_h
-#define ctkXnatSettings_h
-
-#include <QMap>
-#include <QString>
-
-#include "ctkXNATWidgetsExport.h"
-
-class ctkXnatLoginProfile;
-
-class CTK_XNAT_WIDGETS_EXPORT ctkXnatSettings
-{
-public:
-  virtual QString getDefaultDirectory() const = 0;
-  virtual void setDefaultDirectory(const QString& dir) = 0;
-
-  virtual QString getDefaultWorkDirectory() const = 0;
-  virtual void setDefaultWorkDirectory(const QString& workDir) = 0;
-
-  virtual QString getWorkSubdirectory() const;
-
-  virtual QMap<QString, ctkXnatLoginProfile*> getLoginProfiles() const = 0;
-  virtual void setLoginProfiles(QMap<QString, ctkXnatLoginProfile*> loginProfiles) = 0;
-
-  virtual ctkXnatLoginProfile* getLoginProfile(QString profileName) const = 0;
-  virtual void setLoginProfile(QString profileName, ctkXnatLoginProfile*) = 0;
-
-  virtual void removeLoginProfile(QString profileName) = 0;
-
-  virtual ctkXnatLoginProfile* getDefaultLoginProfile() const = 0;
-
-protected:
-  explicit ctkXnatSettings();
-  virtual ~ctkXnatSettings();
-};
-
-#endif