--- a/Plugins/Samples/Common/OrthancPluginCppWrapper.h	Mon Dec 03 17:14:55 2018 +0100
+++ b/Plugins/Samples/Common/OrthancPluginCppWrapper.h	Tue Dec 04 16:31:29 2018 +0100
@@ -79,13 +79,20 @@
                                 const char* url,
                                 const OrthancPluginHttpRequest* request);
 
+
+  void SetGlobalContext(OrthancPluginContext* context);
+
+  bool HasGlobalContext();
+
+  OrthancPluginContext* GetGlobalContext();
+
+  
   class OrthancImage;
 
 
   class MemoryBuffer : public boost::noncopyable
   {
   private:
-    OrthancPluginContext*      context_;
     OrthancPluginMemoryBuffer  buffer_;
 
     void Check(OrthancPluginErrorCode code);
@@ -93,7 +100,7 @@
     bool CheckHttp(OrthancPluginErrorCode code);
 
   public:
-    MemoryBuffer(OrthancPluginContext* context);
+    MemoryBuffer();
 
     ~MemoryBuffer()
     {
@@ -205,14 +212,12 @@
   class OrthancString : public boost::noncopyable
   {
   private:
-    OrthancPluginContext*  context_;
-    char*                  str_;
+    char*   str_;
 
     void Clear();
 
   public:
-    OrthancString(OrthancPluginContext* context) :
-      context_(context),
+    OrthancString() :
       str_(NULL)
     {
     }
@@ -240,20 +245,13 @@
   class OrthancConfiguration : public boost::noncopyable
   {
   private:
-    OrthancPluginContext*  context_;
-    Json::Value            configuration_;  // Necessarily a Json::objectValue
-    std::string            path_;
+    Json::Value  configuration_;  // Necessarily a Json::objectValue
+    std::string  path_;
 
     std::string GetPath(const std::string& key) const;
 
   public:
-    OrthancConfiguration() : context_(NULL)
-    {
-    }
-
-    OrthancConfiguration(OrthancPluginContext* context);
-
-    OrthancPluginContext* GetContext() const;
+    OrthancConfiguration();
 
     const Json::Value& GetJson() const
     {
@@ -310,7 +308,6 @@
   class OrthancImage : public boost::noncopyable
   {
   private:
-    OrthancPluginContext*  context_;
     OrthancPluginImage*    image_;
 
     void Clear();
@@ -318,18 +315,15 @@
     void CheckImageAvailable();
 
   public:
-    OrthancImage(OrthancPluginContext*  context);
+    OrthancImage();
 
-    OrthancImage(OrthancPluginContext*  context,
-                 OrthancPluginImage*    image);
+    OrthancImage(OrthancPluginImage*    image);
 
-    OrthancImage(OrthancPluginContext*     context,
-                 OrthancPluginPixelFormat  format,
+    OrthancImage(OrthancPluginPixelFormat  format,
                  uint32_t                  width,
                  uint32_t                  height);
 
-    OrthancImage(OrthancPluginContext*     context,
-                 OrthancPluginPixelFormat  format,
+    OrthancImage(OrthancPluginPixelFormat  format,
                  uint32_t                  width,
                  uint32_t                  height,
                  uint32_t                  pitch,
@@ -382,29 +376,24 @@
   class FindMatcher : public boost::noncopyable
   {
   private:
-    OrthancPluginContext*              context_;
     OrthancPluginFindMatcher*          matcher_;
     const OrthancPluginWorklistQuery*  worklist_;
 
-    void SetupDicom(OrthancPluginContext*  context,
-                    const void*            query,
+    void SetupDicom(const void*            query,
                     uint32_t               size);
 
   public:
-    FindMatcher(OrthancPluginContext*              context,
-                const OrthancPluginWorklistQuery*  worklist);
+    FindMatcher(const OrthancPluginWorklistQuery*  worklist);
 
-    FindMatcher(OrthancPluginContext*  context,
-                const void*            query,
+    FindMatcher(const void*            query,
                 uint32_t               size)
     {
-      SetupDicom(context, query, size);
+      SetupDicom(query, size);
     }
 
-    FindMatcher(OrthancPluginContext*  context,
-                const MemoryBuffer&    dicom)
+    FindMatcher(const MemoryBuffer&    dicom)
     {
-      SetupDicom(context, dicom.GetData(), dicom.GetSize());
+      SetupDicom(dicom.GetData(), dicom.GetSize());
     }
 
     ~FindMatcher();
@@ -421,99 +410,67 @@
 
 
   bool RestApiGet(Json::Value& result,
-                  OrthancPluginContext* context,
                   const std::string& uri,
                   bool applyPlugins);
 
   bool RestApiPost(Json::Value& result,
-                   OrthancPluginContext* context,
                    const std::string& uri,
                    const char* body,
                    size_t bodySize,
                    bool applyPlugins);
 
   bool RestApiPost(Json::Value& result,
-                   OrthancPluginContext* context,
                    const std::string& uri,
                    const Json::Value& body,
                    bool applyPlugins);
 
   inline bool RestApiPost(Json::Value& result,
-                          OrthancPluginContext* context,
                           const std::string& uri,
                           const std::string& body,
                           bool applyPlugins)
   {
-    return RestApiPost(result, context, uri, body.empty() ? NULL : body.c_str(), 
+    return RestApiPost(result, uri, body.empty() ? NULL : body.c_str(), 
                        body.size(), applyPlugins);
   }
 
   bool RestApiPut(Json::Value& result,
-                  OrthancPluginContext* context,
                   const std::string& uri,
                   const char* body,
                   size_t bodySize,
                   bool applyPlugins);
 
   bool RestApiPut(Json::Value& result,
-                  OrthancPluginContext* context,
                   const std::string& uri,
                   const Json::Value& body,
                   bool applyPlugins);
 
   inline bool RestApiPut(Json::Value& result,
-                         OrthancPluginContext* context,
                          const std::string& uri,
                          const std::string& body,
                          bool applyPlugins)
   {
-    return RestApiPut(result, context, uri, body.empty() ? NULL : body.c_str(), 
+    return RestApiPut(result, uri, body.empty() ? NULL : body.c_str(), 
                       body.size(), applyPlugins);
   }
 
-  bool RestApiDelete(OrthancPluginContext* context,
-                     const std::string& uri,
+  bool RestApiDelete(const std::string& uri,
                      bool applyPlugins);
 
-  bool HttpDelete(OrthancPluginContext* context,
-                  const std::string& url,
+  bool HttpDelete(const std::string& url,
                   const std::string& username,
                   const std::string& password);
 
-  inline void LogError(OrthancPluginContext* context,
-                       const std::string& message)
-  {
-    if (context != NULL)
-    {
-      OrthancPluginLogError(context, message.c_str());
-    }
-  }
+  void LogError(const std::string& message);
+
+  void LogWarning(const std::string& message);
 
-  inline void LogWarning(OrthancPluginContext* context,
-                         const std::string& message)
-  {
-    if (context != NULL)
-    {
-      OrthancPluginLogWarning(context, message.c_str());
-    }
-  }
+  void LogInfo(const std::string& message);
 
-  inline void LogInfo(OrthancPluginContext* context,
-                      const std::string& message)
-  {
-    if (context != NULL)
-    {
-      OrthancPluginLogInfo(context, message.c_str());
-    }
-  }
-
-  void ReportMinimalOrthancVersion(OrthancPluginContext* context,
-                                   unsigned int major,
+  void ReportMinimalOrthancVersion(unsigned int major,
                                    unsigned int minor,
                                    unsigned int revision);
   
-  bool CheckMinimalOrthancVersion(OrthancPluginContext* context,
-                                  unsigned int major,
+  bool CheckMinimalOrthancVersion(unsigned int major,
                                   unsigned int minor,
                                   unsigned int revision);
 
@@ -532,6 +489,14 @@
       }
       catch (ORTHANC_PLUGINS_EXCEPTION_CLASS& e)
       {
+#if HAS_ORTHANC_EXCEPTION == 1
+        if (HasGlobalContext() &&
+            e.HasDetails())
+        {
+          OrthancPluginSetHttpErrorDetails(GetGlobalContext(), output, e.GetDetails());
+        }
+#endif
+
         return static_cast<OrthancPluginErrorCode>(e.GetErrorCode());
       }
       catch (boost::bad_lexical_cast&)
@@ -547,17 +512,18 @@
 
   
   template <RestCallback Callback>
-  void RegisterRestCallback(OrthancPluginContext* context,
-                            const std::string& uri,
+  void RegisterRestCallback(const std::string& uri,
                             bool isThreadSafe)
   {
     if (isThreadSafe)
     {
-      OrthancPluginRegisterRestCallbackNoLock(context, uri.c_str(), Internals::Protect<Callback>);
+      OrthancPluginRegisterRestCallbackNoLock
+        (GetGlobalContext(), uri.c_str(), Internals::Protect<Callback>);
     }
     else
     {
-      OrthancPluginRegisterRestCallback(context, uri.c_str(), Internals::Protect<Callback>);
+      OrthancPluginRegisterRestCallback
+        (GetGlobalContext(), uri.c_str(), Internals::Protect<Callback>);
     }
   }
 
@@ -568,7 +534,6 @@
   private:
     typedef std::map<std::string, uint32_t>   Index;
 
-    OrthancPluginContext *context_;
     OrthancPluginPeers   *peers_;
     Index                 index_;
     uint32_t              timeout_;
@@ -576,7 +541,7 @@
     size_t GetPeerIndex(const std::string& name) const;
 
   public:
-    OrthancPeers(OrthancPluginContext* context);
+    OrthancPeers();
 
     ~OrthancPeers();
 
@@ -715,11 +680,9 @@
     
     virtual void Reset() = 0;
 
-    static OrthancPluginJob* Create(OrthancPluginContext* context,
-                                    OrthancJob* job /* takes ownership */);
+    static OrthancPluginJob* Create(OrthancJob* job /* takes ownership */);
 
-    static std::string Submit(OrthancPluginContext* context,
-                              OrthancJob* job /* takes ownership */,
+    static std::string Submit(OrthancJob* job /* takes ownership */,
                               int priority);
   };
 #endif