SignDocSDK-cpp.h

Go to the documentation of this file.

/*=============================================== -*- C++ -*- ==*
 * SOFTPRO SignDoc                                              *
 *                                                              *
 * Copyright Kofax Deutschland AG                               *
 * Wilhelmstrasse 34, D-71034 Boeblingen                        *
 * All rights reserved.                                         *
 *                                                              *
 * This software is the confidential and proprietary            *
 * information of SOFTPRO ("Confidential Information"). You     *
 * shall not disclose such Confidential Information and shall   *
 * use it only in accordance with the terms of the license      *
 * agreement you entered into with SOFTPRO.                     *
 *==============================================================*/

#ifndef SIGNDOCSDK_SIGNDOCDOCUMENT_H_INCLUDED
#define SIGNDOCSDK_SIGNDOCDOCUMENT_H_INCLUDED

#include <stddef.h>
#include <memory>
#include <string>
#include <vector>
#include <stdexcept>
#include "SignDocSDK-c.h"

#ifndef SIGNDOC_PTR

#define SIGNDOC_PTR std::auto_ptr
#endif

struct SPPDF_Document;

namespace de { namespace softpro { namespace doc {

class SignDocChange;
class SignDocSignature;
class SignDocVerificationResult;
class SignECDSA;
class SignPKCS7;
class SignRSA;

#ifdef _MSC_VER
#pragma warning(push)
// C4800: forcing value to bool 'true' or 'false' (performance warning)
#pragma warning(disable:4800)
#endif

inline void
SignDoc_throw (SIGNDOC_Exception *aEx)
{
  int type = SIGNDOC_Exception_getType (aEx);
  if (type == SIGNDOC_EXCEPTION_TYPE_BAD_ALLOC)
    throw (std::bad_alloc ());
  std::string msg;
  const char *text = SIGNDOC_Exception_getText (aEx);
  if (text != NULL)
    msg = text;
  SIGNDOC_Exception_delete (aEx);
#if defined (SPOOC_EXCEPTION_H__) || defined (SPOOC_EXCEPTION_H_INCLUDED_)
  switch (type)
    {
    case SIGNDOC_EXCEPTION_TYPE_SPOOC_IO:
      throw spooc::IOError (msg);
    case SIGNDOC_EXCEPTION_TYPE_SPOOC_ENCODING_ERROR:
      throw spooc::EncodingError (msg);
    case SIGNDOC_EXCEPTION_TYPE_SPOOC_GENERIC:
      throw spooc::Exception (msg);
    default:
      throw std::runtime_error (msg);
    }
#else
  throw std::runtime_error (msg);
#endif
}

inline void
SIGNDOC_catch (SIGNDOC_Exception **aEx, std::exception &aInput)
{
  *aEx = SIGNDOC_Exception_new (SIGNDOC_EXCEPTION_TYPE_GENERIC,
                                aInput.what ());
}

inline SignDocVerificationResult *
makeSignDocVerificationResult (SIGNDOC_VerificationResult *aP);

inline void assignArray (std::vector<unsigned char> &aDst,
                         SIGNDOC_ByteArray *aSrc)
{
  unsigned n = 0;
  if (aSrc != NULL)
    n = SIGNDOC_ByteArray_count (aSrc);
  if (n == 0)
    aDst.clear ();
  else
    {
      const unsigned char *p = SIGNDOC_ByteArray_data (aSrc);
      aDst.assign (p, p + n);
    }
}

inline void assignArray (std::vector<std::vector<unsigned char> > &aDst,
                         SIGNDOC_ByteArrayArray *aSrc)
{
  unsigned n = SIGNDOC_ByteArrayArray_count (aSrc);
  aDst.resize (n);
  for (unsigned i = 0; i < n; ++i)
    assignArray (aDst[i], SIGNDOC_ByteArrayArray_at (aSrc, i));
}

inline void assignArray (std::vector<std::string> &aDst,
                         SIGNDOC_StringArray *aSrc)
{
  unsigned n = SIGNDOC_StringArray_count (aSrc);
  aDst.resize (n);
  for (unsigned i = 0; i < n; ++i)
    aDst[i] = SIGNDOC_StringArray_at (aSrc, i);
}

//----------------------------------------------------------------------------

class InputStream
{
public:
  InputStream (SIGNDOC_InputStream *aImpl) : p (aImpl) { }

  virtual ~InputStream ()
  {
    SIGNDOC_InputStream_delete (p);
  }

  virtual int read (void *aDst, int aLen) = 0;

  virtual void close () = 0;

  virtual void seek (int aPos) = 0;

  virtual int tell () const = 0;

  virtual int getAvailable () = 0;

  SIGNDOC_InputStream *getImpl () { return p; }

protected:
  SIGNDOC_InputStream *p;

private:
  InputStream (const InputStream &);

  InputStream &operator= (const InputStream &);
};

class UserInputStream : public InputStream
{
public:
  UserInputStream ()
    : InputStream (NULL)
  {
    SIGNDOC_Exception *ex = NULL;
    p = SIGNDOC_UserInputStream_new (&ex, this,
                                     closeC, readC, seekC, tellC,
                                     getAvailableC);
    if (ex != NULL) SignDoc_throw (ex);
  }

private:
  static void SDCAPI closeC (SIGNDOC_Exception **aEx,
                             void *aClosure)
  {
    *aEx = NULL;
    try
      {
        reinterpret_cast<UserInputStream*>(aClosure)->close ();
      }
    catch (std::exception &e)
      {
        SIGNDOC_catch (aEx, e);
      }
  }

  static int SDCAPI readC (SIGNDOC_Exception **aEx,
                           void *aClosure,
                           void *aDst, int aLen)
  {
    *aEx = NULL;
    try
      {
        return reinterpret_cast<UserInputStream*>(aClosure)->read (aDst, aLen);
      }
    catch (std::exception &e)
      {
        SIGNDOC_catch (aEx, e);
        return 0;
      }
  }

  static void SDCAPI seekC (SIGNDOC_Exception **aEx,
                            void *aClosure,
                            int aPos)
  {
    *aEx = NULL;
    try
      {
        return reinterpret_cast<UserInputStream*>(aClosure)->seek (aPos);
      }
    catch (std::exception &e)
      {
        SIGNDOC_catch (aEx, e);
      }
  }

  static int SDCAPI tellC (SIGNDOC_Exception **aEx,
                           const void *aClosure)
  {
    *aEx = NULL;
    try
      {
        return reinterpret_cast<const UserInputStream*>(aClosure)->tell ();
      }
    catch (std::exception &e)
      {
        SIGNDOC_catch (aEx, e);
        return 0;
      }
  }

  static int SDCAPI getAvailableC (SIGNDOC_Exception **aEx,
                                   void *aClosure)
  {
    *aEx = NULL;
    try
      {
        return reinterpret_cast<UserInputStream*>(aClosure)->getAvailable ();
      }
    catch (std::exception &e)
      {
        SIGNDOC_catch (aEx, e);
        return 0;
      }
  }
};

class LibraryInputStream : public InputStream
{
public:
  LibraryInputStream (SIGNDOC_InputStream *aImpl)
    : InputStream (aImpl) { }

  virtual int read (void *aDst, int aLen)
  {
    SIGNDOC_Exception *ex = NULL;
    int r = SIGNDOC_InputStream_read (&ex, p, aDst, aLen);
    if (ex != NULL) SignDoc_throw (ex);
    return r;
  }

  virtual void close ()
  {
    SIGNDOC_Exception *ex = NULL;
    SIGNDOC_InputStream_close (&ex, p);
    if (ex != NULL) SignDoc_throw (ex);
  }

  virtual void seek (int aPos)
  {
    SIGNDOC_Exception *ex = NULL;
    SIGNDOC_InputStream_seek (&ex, p, aPos);
    if (ex != NULL) SignDoc_throw (ex);
  }

  virtual int tell () const
  {
    SIGNDOC_Exception *ex = NULL;
    int r = SIGNDOC_InputStream_tell (&ex, p);
    if (ex != NULL) SignDoc_throw (ex);
    return r;
  }

  virtual int getAvailable ()
  {
    SIGNDOC_Exception *ex = NULL;
    int r = SIGNDOC_InputStream_getAvailable (&ex, p);
    if (ex != NULL) SignDoc_throw (ex);
    return r;
  }
};

#if defined (SPOOC_INPUTSTREAM_H__) || defined (SPOOC_INPUTSTREAM_H_INCLUDED_)

class Spooc1InputStream : public spooc::InputStream
{
public:
  Spooc1InputStream (de::softpro::doc::InputStream &aStream)
     : mStream (aStream) { }
  virtual int read (void *aDst, int aLen) { return mStream.read (aDst, aLen); }
  virtual void close () { mStream.close (); }
  virtual void seek (int aPos) { mStream.seek (aPos); }
  virtual int tell () const { return mStream.tell (); }
  virtual int avail () { return mStream.getAvailable (); }
private:
  de::softpro::doc::InputStream &mStream;
};

class Spooc2InputStream : public UserInputStream
{
public:
  Spooc2InputStream (spooc::InputStream &aStream)
     : mStream (aStream) { }
  virtual int read (void *aDst, int aLen) { return mStream.read (aDst, aLen); }
  virtual void close () { mStream.close (); }
  virtual void seek (int aPos) { mStream.seek (aPos); }
  virtual int tell () const { return mStream.tell (); }
  virtual int getAvailable () { return mStream.avail (); }
private:
  spooc::InputStream &mStream;
};

#endif

//----------------------------------------------------------------------------

class FileInputStream : public LibraryInputStream
{
public:
  FileInputStream (FILE *aFile)
    : LibraryInputStream (NULL)
  {
    SIGNDOC_Exception *ex = NULL;
    p = SIGNDOC_FileInputStream_newWithFile (&ex, aFile);
    if (ex != NULL) SignDoc_throw (ex);
  };

  FileInputStream (FILE *aFile, const char *aPath)
    : LibraryInputStream (NULL)
  {
    SIGNDOC_Exception *ex = NULL;
    p = SIGNDOC_FileInputStream_newWithFileAndPath (&ex, aFile, aPath);
    if (ex != NULL) SignDoc_throw (ex);
  };

  FileInputStream (const char *aPath)
    : LibraryInputStream (NULL)
  {
    SIGNDOC_Exception *ex = NULL;
    p = SIGNDOC_FileInputStream_newWithPath (&ex, aPath);
    if (ex != NULL) SignDoc_throw (ex);
  };

  FileInputStream (const wchar_t *aPath)
    : LibraryInputStream (NULL)
  {
    SIGNDOC_Exception *ex = NULL;
    p = SIGNDOC_FileInputStream_newWithPathW (&ex, aPath);
    if (ex != NULL) SignDoc_throw (ex);
  };
};

//----------------------------------------------------------------------------

class MemoryInputStream : public LibraryInputStream
{
public:
  MemoryInputStream (const unsigned char *aSrc, size_t aLen)
    : LibraryInputStream (NULL)
  {
    SIGNDOC_Exception *ex = NULL;
    p = SIGNDOC_MemoryInputStream_new (&ex, aSrc, aLen);
    if (ex != NULL) SignDoc_throw (ex);
  };
};

//----------------------------------------------------------------------------

class OutputStream
{
public:
  OutputStream (SIGNDOC_OutputStream *aImpl) : p (aImpl) { }

  virtual ~OutputStream ()
  {
    SIGNDOC_OutputStream_delete (p);
  }

  virtual void close () = 0;

  virtual void flush () = 0;

  virtual void seek (int aPos) = 0;

  virtual int tell () const = 0;

  virtual void write (const void *aSrc, int aLen) = 0;

  SIGNDOC_OutputStream *getImpl () { return p; }

protected:
  SIGNDOC_OutputStream *p;

private:
  OutputStream (const OutputStream &);

  OutputStream &operator= (const OutputStream &);
};

class UserOutputStream : public OutputStream
{
public:
  UserOutputStream ()
    : OutputStream (NULL)
  {
    SIGNDOC_Exception *ex = NULL;
    p = SIGNDOC_UserOutputStream_new (&ex, this,
                                      closeC, flushC, writeC, seekC,
                                      tellC);
    if (ex != NULL) SignDoc_throw (ex);
  }

private:
  static void SDCAPI closeC (SIGNDOC_Exception **aEx,
                             void *aClosure)
  {
    *aEx = NULL;
    try
      {
        reinterpret_cast<UserOutputStream*>(aClosure)->close ();
      }
    catch (std::exception &e)
      {
        SIGNDOC_catch (aEx, e);
      }
  }

  static void SDCAPI flushC (SIGNDOC_Exception **aEx,
                             void *aClosure)
  {
    *aEx = NULL;
    try
      {
        reinterpret_cast<UserOutputStream*>(aClosure)->flush ();
      }
    catch (std::exception &e)
      {
        SIGNDOC_catch (aEx, e);
      }
  }

  static void SDCAPI writeC (SIGNDOC_Exception **aEx,
                             void *aClosure,
                             const void *aSrc, int aLen)
  {
    *aEx = NULL;
    try
      {
        reinterpret_cast<UserOutputStream*>(aClosure)->write (aSrc, aLen);
      }
    catch (std::exception &e)
      {
        SIGNDOC_catch (aEx, e);
      }
  }

  static void SDCAPI seekC (SIGNDOC_Exception **aEx,
                            void *aClosure,
                            int aPos)
  {
    *aEx = NULL;
    try
      {
        return reinterpret_cast<UserOutputStream*>(aClosure)->seek (aPos);
      }
    catch (std::exception &e)
      {
        SIGNDOC_catch (aEx, e);
      }
  }

  static int SDCAPI tellC (SIGNDOC_Exception **aEx,
                           const void *aClosure)
  {
    *aEx = NULL;
    try
      {
        return reinterpret_cast<const UserOutputStream*>(aClosure)->tell ();
      }
    catch (std::exception &e)
      {
        SIGNDOC_catch (aEx, e);
        return 0;
      }
  }
};

class LibraryOutputStream : public OutputStream
{
public:
  LibraryOutputStream (SIGNDOC_OutputStream *aImpl)
    : OutputStream (aImpl) { }

  virtual void close ()
  {
    SIGNDOC_Exception *ex = NULL;
    SIGNDOC_OutputStream_close (&ex, p);
    if (ex != NULL) SignDoc_throw (ex);
  }

  virtual void flush ()
  {
    SIGNDOC_Exception *ex = NULL;
    SIGNDOC_OutputStream_flush (&ex, p);
    if (ex != NULL) SignDoc_throw (ex);
  }

  virtual void write (const void *aSrc, int aLen)
  {
    SIGNDOC_Exception *ex = NULL;
    SIGNDOC_OutputStream_write (&ex, p, aSrc, aLen);
    if (ex != NULL) SignDoc_throw (ex);
  }

  virtual void seek (int aPos)
  {
    SIGNDOC_Exception *ex = NULL;
    SIGNDOC_OutputStream_seek (&ex, p, aPos);
    if (ex != NULL) SignDoc_throw (ex);
  }

  virtual int tell () const
  {
    SIGNDOC_Exception *ex = NULL;
    int r = SIGNDOC_OutputStream_tell (&ex, p);
    if (ex != NULL) SignDoc_throw (ex);
    return r;
  }
};

#if defined (SPOOC_OUTPUTSTREAM_H__) || defined (SPOOC_OUTPUTSTREAM_H_INCLUDED_)

class Spooc1OutputStream : public spooc::OutputStream
{
public:
  Spooc1OutputStream (de::softpro::doc::OutputStream &aStream)
    : mStream (aStream) { }
  virtual void close () { mStream.close (); }
  virtual void flush () { mStream.flush (); }
  virtual void write (const void *aSrc, int aLen) { mStream.write (aSrc, aLen); }
  virtual void seek (int aPos) { mStream.seek (aPos); }
  virtual int tell () const { return mStream.tell (); }
private:
  de::softpro::doc::OutputStream &mStream;
};

class Spooc2OutputStream : public UserOutputStream
{
public:
  Spooc2OutputStream (spooc::OutputStream &aStream)
    : mStream (aStream) { }
  ~Spooc2OutputStream () { }
  virtual void close () { mStream.close (); }
  virtual void flush () { mStream.flush (); }
  virtual void write (const void *aSrc, int aLen) { mStream.write (aSrc, aLen); }
  virtual void seek (int aPos) { mStream.seek (aPos); }
  virtual int tell () const { return mStream.tell (); }
private:
  spooc::OutputStream &mStream;
};

#endif

//----------------------------------------------------------------------------

class FileOutputStream : public LibraryOutputStream
{
public:
  FileOutputStream (FILE *aFile)
    : LibraryOutputStream (NULL)
  {
    SIGNDOC_Exception *ex = NULL;
    p = SIGNDOC_FileOutputStream_newWithFile (&ex, aFile);
    if (ex != NULL) SignDoc_throw (ex);
  };

  FileOutputStream (FILE *aFile, const char *aPath)
    : LibraryOutputStream (NULL)
  {
    SIGNDOC_Exception *ex = NULL;
    p = SIGNDOC_FileOutputStream_newWithFileAndPath (&ex, aFile, aPath);
    if (ex != NULL) SignDoc_throw (ex);
  };

  FileOutputStream (const char *aPath)
    : LibraryOutputStream (NULL)
  {
    SIGNDOC_Exception *ex = NULL;
    p = SIGNDOC_FileOutputStream_newWithPath (&ex, aPath);
    if (ex != NULL) SignDoc_throw (ex);
  };

  FileOutputStream (const wchar_t *aPath)
    : LibraryOutputStream (NULL)
  {
    SIGNDOC_Exception *ex = NULL;
    p = SIGNDOC_FileOutputStream_newWithPathW (&ex, aPath);
    if (ex != NULL) SignDoc_throw (ex);
  };
};

//----------------------------------------------------------------------------

class MemoryOutputStream : public LibraryOutputStream
{
public:
  MemoryOutputStream ()
    : LibraryOutputStream (NULL)
  {
    SIGNDOC_Exception *ex = NULL;
    p = SIGNDOC_MemoryOutputStream_new (&ex);
    if (ex != NULL) SignDoc_throw (ex);
  };

  const unsigned char *data ()
  {
    SIGNDOC_Exception *ex = NULL;
    const unsigned char *r = SIGNDOC_MemoryOutputStream_data (&ex, p);
    if (ex != NULL) SignDoc_throw (ex);
    return r;
  }

  size_t length ()
  {
    SIGNDOC_Exception *ex = NULL;
    size_t r = SIGNDOC_MemoryOutputStream_length (&ex, p);
    if (ex != NULL) SignDoc_throw (ex);
    return r;
  }

  void clear ()
  {
    SIGNDOC_Exception *ex = NULL;
    SIGNDOC_MemoryOutputStream_clear (&ex, p);
    if (ex != NULL) SignDoc_throw (ex);
  }
};
enum Encoding
{
  enc_native,      
  enc_utf_8,       
  enc_latin_1      
};

// cppcheck-suppress copyCtorAndEqOperator
class Point 
{
public:
  Point ()
    : mX (0), mY (0)
  {
  }

  Point (double aX, double aY)
    : mX (aX), mY (aY)
  {
  }

  Point (const Point &aSrc)
    : mX (aSrc.mX), mY (aSrc.mY)
  {
  }

  ~Point ()
  {
  }

  void set (double aX, double aY)
  {
    SIGNDOC_Point_setXY ((SIGNDOC_Point*)this, aX, aY);
  }

public:
  double mX;

  double mY;
};

// cppcheck-suppress copyCtorAndEqOperator
class Rect 
{
public:
  Rect ()
    : mX1 (0), mY1 (0), mX2 (0), mY2 (0)
  {
  }

  Rect (double aX1, double aY1, double aX2, double aY2)
    : mX1 (aX1), mY1 (aY1), mX2 (aX2), mY2 (aY2)
  {
  }

  Rect (const Rect &aSrc)
    : mX1 (aSrc.mX1), mY1 (aSrc.mY1), mX2 (aSrc.mX2), mY2 (aSrc.mY2)
  {
  }

  ~Rect ()
  {
  }

  void get (double &aX1, double &aY1, double &aX2, double &aY2) const
  {
    SIGNDOC_Rect_get ((const SIGNDOC_Rect*)this, &aX1, &aY1, &aX2, &aY2);
  }

  void set (double aX1, double aY1, double aX2, double aY2)
  {
    SIGNDOC_Rect_setXY ((SIGNDOC_Rect*)this, aX1, aY1, aX2, aY2);
  }

  double getWidth () const
  {
    return SIGNDOC_Rect_getWidth ((const SIGNDOC_Rect*)this);
  }

  double getHeight () const
  {
    return SIGNDOC_Rect_getHeight ((const SIGNDOC_Rect*)this);
  }

  void normalize ()
  {
    SIGNDOC_Rect_normalize ((SIGNDOC_Rect*)this);
  }

  void scale (double aFactor)
  {
    SIGNDOC_Rect_scale ((SIGNDOC_Rect*)this, aFactor);
  }

  void scale (double aFactorX, double aFactorY)
  {
    SIGNDOC_Rect_scaleXY ((SIGNDOC_Rect*)this, aFactorX, aFactorY);
  }

  double getX1 () const
  {
    return mX1;
  }

  double getY1 () const
  {
    return mY1;
  }

  double getX2 () const
  {
    return mX2;
  }

  double getY2 () const
  {
    return mY2;
  }

public:
  double mX1;

  double mY1;

  double mX2;

  double mY2;
};

class TimeStamper 
{
public:
  enum StampResult
  {
    sr_ok,

    sr_invalid_input,

    sr_timeout,

    sr_stopped,

    sr_tcp_error,

    sr_ssl_error,

    sr_http_error,

    sr_server_error,

    sr_invalid_response
  };

  enum StampFlags
  {
    sf_dont_check_revocation = 0x01,

    sf_dont_hash = 0x02
  };

public:
  const char *getHashAlgorithm () const
  {
    return SIGNDOC_TimeStamper_getHashAlgorithm (p);
  }

  const char *getFallbackHashAlgorithm () const
  {
    return SIGNDOC_TimeStamper_getFallbackHashAlgorithm (p);
  }

  StampResult stamp (const unsigned char *aHashPtr, size_t aHashSize,
                     unsigned aRandomNonceSize, int aFlags,
                     std::vector<unsigned char> &aOutput, int &aStatus,
                     unsigned &aFailureInfo)
  {
    SIGNDOC_Exception *ex = NULL;
    SIGNDOC_ByteArray *tempOutput = NULL;
    StampResult r;
    try
      {
        tempOutput = SIGNDOC_ByteArray_new (&ex);
        if (ex != NULL) SignDoc_throw (ex);
        r = (StampResult)SIGNDOC_TimeStamper_stamp (&ex, p, aHashPtr, aHashSize, aRandomNonceSize, aFlags, tempOutput, &aStatus, &aFailureInfo);
        assignArray (aOutput, tempOutput);
      }
    catch (...)
      {
        if (tempOutput != NULL)
          SIGNDOC_ByteArray_delete (tempOutput);
        throw;
      }
    if (tempOutput != NULL)
      SIGNDOC_ByteArray_delete (tempOutput);
    if (ex != NULL) SignDoc_throw (ex);
    return r;
  }

  void stop ()
  {
    SIGNDOC_TimeStamper_stop (p);
  }

  const char *getErrorMessage () const
  {
    return SIGNDOC_TimeStamper_getErrorMessage (p);
  }

protected:
public:
  ~TimeStamper ()
  {
  }
  TimeStamper (SIGNDOC_TimeStamper *aP) : p (aP) { }

  SIGNDOC_TimeStamper *getImpl () { return p; }

  const SIGNDOC_TimeStamper *getImpl () const { return p; }

private:
  SIGNDOC_TimeStamper *p;
};

class Source
{
public:
  Source (struct SIGNDOC_Source *aImpl)
    : p (aImpl) { }

  virtual ~Source () { }

  int fetch (const void *&aPtr, int aMaxSize)
  {
    struct SIGNDOC_Exception *ex = NULL;
    int r = SIGNDOC_Source_fetch (&ex, p, &aPtr, aMaxSize);
    if (ex != NULL) SignDoc_throw (ex);
    return r;
  }

private:
  SIGNDOC_Source *p;
};

class SignPKCS7
{
public:
  enum HashAlgorithm
  {
    ha_none,                    
    ha_sha1,                    
    ha_sha256,                  
    ha_md5,                     
    ha_sha384,                  
    ha_sha512,                  
    ha_ripemd160,               
    ha_sha224                   
  };

  SignPKCS7 ()
    : p (NULL), mBadAlloc (false)
  {
    struct SIGNDOC_Exception *ex = NULL;
    p = SIGNDOC_SignPKCS7_new (&ex, this, signC, getSignatureSizeC,
                               getSubjectCommonNameC, getErrorMessageC);
    if (ex != NULL) SignDoc_throw (ex);
  }

  virtual ~SignPKCS7 ()
  {
    SIGNDOC_SignPKCS7_delete (p);
  }

  virtual bool sign (Source &aSource, bool aDetached,
                     HashAlgorithm aHashAlgorithm,
                     TimeStamper *aTimeStamper,
                     std::vector<unsigned char> &aOutput) = 0;

  virtual size_t getSignatureSize (bool aDetached,
                                   HashAlgorithm aHashAlgorithm) = 0;

  virtual bool getSubjectCommonName (std::string &aOutput) const = 0;

  virtual const char *getErrorMessage () const = 0;

  SIGNDOC_SignPKCS7 *getImpl () { return p; }

private:
  static SIGNDOC_Boolean SDCAPI
  signC (void *aClosure, struct SIGNDOC_Source *aSource,
         SIGNDOC_Boolean aDetached, int aHashAlgorithm,
         struct SIGNDOC_TimeStamper *aTimeStamper,
         struct SIGNDOC_ByteArray *aOutput)
  {
    SignPKCS7 *s = static_cast<SignPKCS7*>(aClosure);
    s->mBadAlloc = false;
    try
      {
        SIGNDOC_ByteArray_clear (aOutput);
        std::vector<unsigned char> output;
        Source src (aSource);
        TimeStamper ts (aTimeStamper);
        bool ok = s->sign (src, aDetached, (HashAlgorithm)aHashAlgorithm,
                           (aTimeStamper != NULL) ? &ts : NULL,
                           output);
        if (ok)
          assignByteArray (aOutput, output);
        return ok;
      }
    catch (std::bad_alloc &)
      {
        s->mBadAlloc = true;
        return SIGNDOC_FALSE;
      }
  }

  static size_t SDCAPI
  getSignatureSizeC (void *aClosure, SIGNDOC_Boolean aDetached,
                     int aHashAlgorithm)
  {
    SignPKCS7 *s = static_cast<SignPKCS7*>(aClosure);
    s->mBadAlloc = false;
    try
      {
        return s->getSignatureSize (aDetached, (HashAlgorithm)aHashAlgorithm);
      }
    catch (std::bad_alloc &)
      {
        s->mBadAlloc = true;
        return 0;
      }
  }

  static SIGNDOC_Boolean SDCAPI
  getSubjectCommonNameC (void *aClosure, char **aOutput)
  {
    SignPKCS7 *s = static_cast<SignPKCS7*>(aClosure);
    s->mBadAlloc = false;
    try
      {
        *aOutput = NULL;
        std::string output;
        bool ok = s->getSubjectCommonName (output);
        if (ok)
          assignString (aOutput, output);
        return ok;
      }
    catch (std::bad_alloc &)
      {
        s->mBadAlloc = true;
        return SIGNDOC_FALSE;
      }
  }

  static const char * SDCAPI
  getErrorMessageC (void *aClosure)
  {
    SignPKCS7 *s = static_cast<SignPKCS7*>(aClosure);
    if (s->mBadAlloc)
      return "out of memory";
    try
      {
        return s->getErrorMessage ();
      }
    catch (std::bad_alloc &)
      {
        s->mBadAlloc = true;
        return "out of memory";
      }
  }

  static void assignByteArray (SIGNDOC_ByteArray *aOutput,
                               const std::vector<unsigned char> &aInput)
  {
    if (aInput.empty ())
      SIGNDOC_ByteArray_clear (aOutput);
    else
      {
        struct SIGNDOC_Exception *ex = NULL;
        SIGNDOC_ByteArray_set (&ex, aOutput,
                               &aInput[0], aInput.size ());
        if (ex != NULL) SignDoc_throw (ex);
      }
  }

  static void assignString (char **aOutput, const std::string &aInput)
  {
    struct SIGNDOC_Exception *ex = NULL;
    *aOutput = SIGNDOC_strdup (&ex, aInput.c_str ());
    if (ex != NULL) SignDoc_throw (ex);
  }

private:
  SIGNDOC_SignPKCS7 *p;
  bool mBadAlloc;
};

class SignRSA
{
public:
  enum Version
  {
    v_1_5,

    v_2_0_salt0,

    v_2_0_salt32,

    v_2_0 = v_2_0_salt0
  };

  enum HashAlgorithm
  {
    ha_sha1 = 1,

    ha_sha256 = 2,

    ha_sha384 = 3,

    ha_sha512 = 4,

    ha_ripemd160 = 5
  };

public:
  SignRSA ()
    : p (NULL), mBadAlloc (false)
  {
    struct SIGNDOC_Exception *ex = NULL;
    p = SIGNDOC_SignRSA_new (&ex, this, signC, getSignatureSizeC,
                             getSigningCertificateC,
                             getCertificateCountC, getCertificateC,
                             getErrorMessageC);
    if (ex != NULL) SignDoc_throw (ex);
  }

  virtual ~SignRSA ()
  {
    SIGNDOC_SignRSA_delete (p);
  }

  virtual bool sign (Source &aSource,
                     Version aVersion, HashAlgorithm aHashAlgorithm,
                     std::vector<unsigned char> &aOutput) = 0;

  virtual int getSignatureSize () = 0;

  virtual bool getSigningCertificate (std::vector<unsigned char> &aOutput) const = 0;

  virtual int getCertificateCount () const = 0;

  virtual bool getCertificate (int aIndex,
                               std::vector<unsigned char> &aOutput) const = 0;

  virtual const char *getErrorMessage () const = 0;

  SIGNDOC_SignRSA *getImpl () { return p; }

private:
  static SIGNDOC_Boolean SDCAPI
  signC (void *aClosure, struct SIGNDOC_Source *aSource,
         int aVersion, int aHashAlgorithm,
         struct SIGNDOC_ByteArray *aOutput)
  {
    SignRSA *s = static_cast<SignRSA*>(aClosure);
    s->mBadAlloc = false;
    try
      {
        std::vector<unsigned char> output;
        Source src (aSource);
        bool ok = s->sign (src, (Version)aVersion,
                           (HashAlgorithm)aHashAlgorithm, output);
        if (ok)
          assignByteArray (aOutput, output);
        return ok;
      }
    catch (std::bad_alloc &)
      {
        s->mBadAlloc = true;
        return SIGNDOC_FALSE;
      }
  }

  static int SDCAPI
  getSignatureSizeC (void *aClosure)
  {
    SignRSA *s = static_cast<SignRSA*>(aClosure);
    s->mBadAlloc = false;
    try
      {
        return s->getSignatureSize ();
      }
    catch (std::bad_alloc &)
      {
        s->mBadAlloc = true;
        return -1;
      }
  }

  static SIGNDOC_Boolean SDCAPI
  getSigningCertificateC (const void *aClosure,
                          struct SIGNDOC_ByteArray *aOutput)
  {
    const SignRSA *s = static_cast<const SignRSA*>(aClosure);
    s->mBadAlloc = false;
    try
      {
        std::vector<unsigned char> output;
        bool ok = s->getSigningCertificate (output);
        if (ok)
          assignByteArray (aOutput, output);
        return ok;
      }
    catch (std::bad_alloc &)
      {
        s->mBadAlloc = true;
        return SIGNDOC_FALSE;
      }
  }

  static int SDCAPI
  getCertificateCountC (const void *aClosure)
  {
    const SignRSA *s = static_cast<const SignRSA*>(aClosure);
    s->mBadAlloc = false;
    try
      {
        return s->getCertificateCount ();
      }
    catch (std::bad_alloc &)
      {
        s->mBadAlloc = true;
        return 0;
      }
  }

  static SIGNDOC_Boolean SDCAPI
  getCertificateC (const void *aClosure, int aIndex,
                   struct SIGNDOC_ByteArray *aOutput)
  {
    const SignRSA *s = static_cast<const SignRSA*>(aClosure);
    s->mBadAlloc = false;
    try
      {
        std::vector<unsigned char> output;
        bool ok = s->getCertificate (aIndex, output);
        if (ok)
          assignByteArray (aOutput, output);
        return ok;
      }
    catch (std::bad_alloc &)
      {
        s->mBadAlloc = true;
        return SIGNDOC_FALSE;
      }
  }

  static const char * SDCAPI
  getErrorMessageC (const void *aClosure)
  {
    const SignRSA *s = static_cast<const SignRSA*>(aClosure);
    if (s->mBadAlloc)
      return "out of memory";
    try
      {
        return s->getErrorMessage ();
      }
    catch (std::bad_alloc &)
      {
        s->mBadAlloc = true;
        return "out of memory";
      }
  }

  static void assignByteArray (SIGNDOC_ByteArray *aOutput,
                               const std::vector<unsigned char> &aInput)
  {
    if (aInput.empty ())
      SIGNDOC_ByteArray_clear (aOutput);
    else
      {
        struct SIGNDOC_Exception *ex = NULL;
        SIGNDOC_ByteArray_set (&ex, aOutput,
                               &aInput[0], aInput.size ());
        if (ex != NULL) SignDoc_throw (ex);
      }
  }

private:
  SIGNDOC_SignRSA *p;
  mutable bool mBadAlloc;
};

class SignECDSA
{
public:
  enum HashAlgorithm
  {
    ha_sha1 = 1,

    ha_sha256 = 2,

    ha_sha384 = 3,

    ha_sha512 = 4,

    ha_sha224 = 7
  };

public:
  SignECDSA ()
    : p (NULL), mBadAlloc (false)
  {
    struct SIGNDOC_Exception *ex = NULL;
    p = SIGNDOC_SignECDSA_new (&ex, this, signC, getSignatureSizeC,
                               getSigningCertificateC,
                               getCertificateCountC, getCertificateC,
                               getErrorMessageC);
    if (ex != NULL) SignDoc_throw (ex);
  }

  virtual ~SignECDSA ()
  {
    SIGNDOC_SignECDSA_delete (p);
  }

  virtual bool sign (Source &aSource, HashAlgorithm aHashAlgorithm,
                     std::vector<unsigned char> &aOutput) = 0;

  virtual int getSignatureSize () = 0;

  virtual bool getSigningCertificate (std::vector<unsigned char> &aOutput) const = 0;

  virtual int getCertificateCount () const = 0;

  virtual bool getCertificate (int aIndex,
                               std::vector<unsigned char> &aOutput) const = 0;

  virtual const char *getErrorMessage () const = 0;

  SIGNDOC_SignECDSA *getImpl () { return p; }

private:
  static SIGNDOC_Boolean SDCAPI
  signC (void *aClosure, struct SIGNDOC_Source *aSource, int aHashAlgorithm,
         struct SIGNDOC_ByteArray *aOutput)
  {
    SignECDSA *s = static_cast<SignECDSA*>(aClosure);
    s->mBadAlloc = false;
    try
      {
        std::vector<unsigned char> output;
        Source src (aSource);
        bool ok = s->sign (src, (HashAlgorithm)aHashAlgorithm, output);
        if (ok)
          assignByteArray (aOutput, output);
        return ok;
      }
    catch (std::bad_alloc &)
      {
        s->mBadAlloc = true;
        return SIGNDOC_FALSE;
      }
  }

  static int SDCAPI
  getSignatureSizeC (void *aClosure)
  {
    SignECDSA *s = static_cast<SignECDSA*>(aClosure);
    s->mBadAlloc = false;
    try
      {
        return s->getSignatureSize ();
      }
    catch (std::bad_alloc &)
      {
        s->mBadAlloc = true;
        return -1;
      }
  }

  static SIGNDOC_Boolean SDCAPI
  getSigningCertificateC (const void *aClosure,
                          struct SIGNDOC_ByteArray *aOutput)
  {
    const SignECDSA *s = static_cast<const SignECDSA*>(aClosure);
    s->mBadAlloc = false;
    try
      {
        std::vector<unsigned char> output;
        bool ok = s->getSigningCertificate (output);
        if (ok)
          assignByteArray (aOutput, output);
        return ok;
      }
    catch (std::bad_alloc &)
      {
        s->mBadAlloc = true;
        return SIGNDOC_FALSE;
      }
  }

  static int SDCAPI
  getCertificateCountC (const void *aClosure)
  {
    const SignECDSA *s = static_cast<const SignECDSA*>(aClosure);
    s->mBadAlloc = false;
    try
      {
        return s->getCertificateCount ();
      }
    catch (std::bad_alloc &)
      {
        s->mBadAlloc = true;
        return 0;
      }
  }

  static SIGNDOC_Boolean SDCAPI
  getCertificateC (const void *aClosure, int aIndex,
                   struct SIGNDOC_ByteArray *aOutput)
  {
    const SignECDSA *s = static_cast<const SignECDSA*>(aClosure);
    s->mBadAlloc = false;
    try
      {
        std::vector<unsigned char> output;
        bool ok = s->getCertificate (aIndex, output);
        if (ok)
          assignByteArray (aOutput, output);
        return ok;
      }
    catch (std::bad_alloc &)
      {
        s->mBadAlloc = true;
        return SIGNDOC_FALSE;
      }
  }

  static const char * SDCAPI
  getErrorMessageC (const void *aClosure)
  {
    const SignECDSA *s = static_cast<const SignECDSA*>(aClosure);
    if (s->mBadAlloc)
      return "out of memory";
    try
      {
        return s->getErrorMessage ();
      }
    catch (std::bad_alloc &)
      {
        s->mBadAlloc = true;
        return "out of memory";
      }
  }

  static void assignByteArray (SIGNDOC_ByteArray *aOutput,
                               const std::vector<unsigned char> &aInput)
  {
    if (aInput.empty ())
      SIGNDOC_ByteArray_clear (aOutput);
    else
      {
        struct SIGNDOC_Exception *ex = NULL;
        SIGNDOC_ByteArray_set (&ex, aOutput,
                               &aInput[0], aInput.size ());
        if (ex != NULL) SignDoc_throw (ex);
      }
  }

private:
  SIGNDOC_SignECDSA *p;
  mutable bool mBadAlloc;
};

class SignDocColor 
{
public:
  enum Type
  {
    t_gray,

    t_rgb
  };

public:
  ~SignDocColor ()
  {
    SIGNDOC_Color_delete (p);
  }

  SignDocColor *clone () const
  {
    SIGNDOC_Exception *ex = NULL;
    SIGNDOC_Color *r;
    r = SIGNDOC_Color_clone (&ex, p);
    if (ex != NULL) SignDoc_throw (ex);
    if (r == NULL)
      return NULL;
    try
      {
        return new SignDocColor (r);
      }
    catch (...)
      {
        SIGNDOC_Color_delete (r);
        throw;
      }
  }

  Type getType () const
  {
    return (Type)SIGNDOC_Color_getType (p);
  }

  unsigned getNumberOfComponents () const
  {
    return SIGNDOC_Color_getNumberOfComponents (p);
  }

  unsigned char getComponent (unsigned aIndex) const
  {
    return SIGNDOC_Color_getComponent (p, aIndex);
  }

  unsigned char getIntensity () const
  {
    return SIGNDOC_Color_getIntensity (p);
  }

  unsigned char getRed () const
  {
    return SIGNDOC_Color_getRed (p);
  }

  unsigned char getGreen () const
  {
    return SIGNDOC_Color_getGreen (p);
  }

  unsigned char getBlue () const
  {
    return SIGNDOC_Color_getBlue (p);
  }

  static SignDocColor *createGray (unsigned char aIntensity)
  {
    SIGNDOC_Exception *ex = NULL;
    SIGNDOC_Color *r;
    r = SIGNDOC_Color_createGray (&ex, aIntensity);
    if (ex != NULL) SignDoc_throw (ex);
    if (r == NULL)
      return NULL;
    try
      {
        return new SignDocColor (r);
      }
    catch (...)
      {
        SIGNDOC_Color_delete (r);
        throw;
      }
  }

  static SignDocColor *createRGB (unsigned char aRed, unsigned char aGreen,
                                  unsigned char aBlue)
  {
    SIGNDOC_Exception *ex = NULL;
    SIGNDOC_Color *r;
    r = SIGNDOC_Color_createRGB (&ex, aRed, aGreen, aBlue);
    if (ex != NULL) SignDoc_throw (ex);
    if (r == NULL)
      return NULL;
    try
      {
        return new SignDocColor (r);
      }
    catch (...)
      {
        SIGNDOC_Color_delete (r);
        throw;
      }
  }

private:
  SignDocColor ();

  // cppcheck-suppress noExplicitCopyMoveConstructor
  SignDocColor (const SignDocColor &);

  SignDocColor &operator= (const SignDocColor &);

public:
  SignDocColor (SIGNDOC_Color *aP) : p (aP) { }

  SIGNDOC_Color *getImpl () { return p; }

  const SIGNDOC_Color *getImpl () const { return p; }

  void setImpl (SIGNDOC_Color *aP) { SIGNDOC_Color_delete (p); p  = aP; }

private:
  SIGNDOC_Color *p;
};

class SignDocTextFieldAttributes 
{
public:

public:
  SignDocTextFieldAttributes ()
    : p (NULL)
  {
    SIGNDOC_Exception *ex = NULL;
    p = SIGNDOC_TextFieldAttributes_new (&ex);
    if (ex != NULL) SignDoc_throw (ex);
  }

  SignDocTextFieldAttributes (const SignDocTextFieldAttributes &aSource)
    : p (NULL)
  {
    SIGNDOC_Exception *ex = NULL;
    p = SIGNDOC_TextFieldAttributes_clone (&ex, aSource.getImpl ());
    if (ex != NULL) SignDoc_throw (ex);
  }

  ~SignDocTextFieldAttributes ()
  {
    SIGNDOC_TextFieldAttributes_delete (p);
  }

  SignDocTextFieldAttributes &operator= (const SignDocTextFieldAttributes &aSource)
  {
    SIGNDOC_Exception *ex = NULL;
    SIGNDOC_TextFieldAttributes_assign (&ex, p, aSource.getImpl ());
    if (ex != NULL) SignDoc_throw (ex);
    return *this;
  }

  void swap (SignDocTextFieldAttributes &aOther)
  {
    std::swap (p, aOther.p);
  }

  bool isSet () const
  {
    SIGNDOC_Exception *ex = NULL;
    bool r;
    r = (bool)SIGNDOC_TextFieldAttributes_isSet (&ex, p);
    if (ex != NULL) SignDoc_throw (ex);
    return r;
  }

  bool isValid () const
  {
    SIGNDOC_Exception *ex = NULL;
    bool r;
    r = (bool)SIGNDOC_TextFieldAttributes_isValid (&ex, p);
    if (ex != NULL) SignDoc_throw (ex);
    return r;
  }

  void clear ()
  {
    SIGNDOC_Exception *ex = NULL;
    SIGNDOC_TextFieldAttributes_clear (&ex, p);
    if (ex != NULL) SignDoc_throw (ex);
  }

  std::string getFontName (Encoding aEncoding) const
  {
    SIGNDOC_Exception *ex = NULL;
    std::string r;
    char *s = SIGNDOC_TextFieldAttributes_getFontName (&ex, p, aEncoding);
    if (ex != NULL) SignDoc_throw (ex);
    try
      {
        r = s;
      }
    catch (...)
      {
        SIGNDOC_free (s);
        throw;
      }
    SIGNDOC_free (s);
    return r;
  }

  void setFontName (Encoding aEncoding, const std::string &aFontName)
  {
    SIGNDOC_Exception *ex = NULL;
    SIGNDOC_TextFieldAttributes_setFontName (&ex, p, aEncoding, aFontName.c_str ());
    if (ex != NULL) SignDoc_throw (ex);
  }

  std::string getFontResourceName (Encoding aEncoding) const
  {
    SIGNDOC_Exception *ex = NULL;
    std::string r;
    char *s = SIGNDOC_TextFieldAttributes_getFontResourceName (&ex, p, aEncoding);
    if (ex != NULL) SignDoc_throw (ex);
    try
      {
        r = s;
      }
    catch (...)
      {
        SIGNDOC_free (s);
        throw;
      }
    SIGNDOC_free (s);
    return r;
  }

  double getFontSize () const
  {
    SIGNDOC_Exception *ex = NULL;
    double r;
    r = SIGNDOC_TextFieldAttributes_getFontSize (&ex, p);
    if (ex != NULL) SignDoc_throw (ex);
    return r;
  }

  void setFontSize (double aFontSize)
  {
    SIGNDOC_Exception *ex = NULL;
    SIGNDOC_TextFieldAttributes_setFontSize (&ex, p, aFontSize);
    if (ex != NULL) SignDoc_throw (ex);
  }

  SignDocColor *getTextColor () const
  {
    SIGNDOC_Exception *ex = NULL;
    SIGNDOC_Color *r;
    r = SIGNDOC_TextFieldAttributes_getTextColor (&ex, p);
    if (ex != NULL) SignDoc_throw (ex);
    if (r == NULL)
      return NULL;
    try
      {
        return new SignDocColor (r);
      }
    catch (...)
      {
        SIGNDOC_Color_delete (r);
        throw;
      }
  }

  void setTextColor (const SignDocColor &aTextColor)
  {
    SIGNDOC_Exception *ex = NULL;
    SIGNDOC_TextFieldAttributes_setTextColor (&ex, p, aTextColor.getImpl ());
    if (ex != NULL) SignDoc_throw (ex);
  }

  std::string getRest (Encoding aEncoding) const
  {
    SIGNDOC_Exception *ex = NULL;
    std::string r;
    char *s = SIGNDOC_TextFieldAttributes_getRest (&ex, p, aEncoding);
    if (ex != NULL) SignDoc_throw (ex);
    try
      {
        r = s;
      }
    catch (...)
      {
        SIGNDOC_free (s);
        throw;
      }
    SIGNDOC_free (s);
    return r;
  }

  void setRest (Encoding aEncoding, const std::string &aInput)
  {
    SIGNDOC_Exception *ex = NULL;
    SIGNDOC_TextFieldAttributes_setRest (&ex, p, aEncoding, aInput.c_str ());
    if (ex != NULL) SignDoc_throw (ex);
  }

private:
public:
  SignDocTextFieldAttributes (SIGNDOC_TextFieldAttributes *aP) : p (aP) { }

  SIGNDOC_TextFieldAttributes *getImpl () { return p; }

  const SIGNDOC_TextFieldAttributes *getImpl () const { return p; }

  void setImpl (SIGNDOC_TextFieldAttributes *aP) { SIGNDOC_TextFieldAttributes_delete (p); p  = aP; }

private:
  SIGNDOC_TextFieldAttributes *p;
};

class SignDocField 
{
public:

public:
  enum Type
  {
    t_unknown,              
    t_pushbutton,           
    t_check_box,            
    t_radio_button,         
    t_text,                 
    t_list_box,             
    t_signature_digsig,     
    t_signature_signdoc,    
    t_combo_box             
  };

  enum Flag
  {
    f_ReadOnly          = 1 << 0,  
    f_Required          = 1 << 1,  
    f_NoExport          = 1 << 2,  
    f_NoToggleToOff     = 1 << 3,  
    f_Radio             = 1 << 4,  
    f_Pushbutton        = 1 << 5,  
    f_RadiosInUnison    = 1 << 6,  

    f_MultiLine         = 1 << 7,

    f_Password          = 1 << 8,  
    f_FileSelect        = 1 << 9,  
    f_DoNotSpellCheck   = 1 << 10, 
    f_DoNotScroll       = 1 << 11, 
    f_Comb              = 1 << 12, 
    f_RichText          = 1 << 13, 
    f_Combo             = 1 << 14, 
    f_Edit              = 1 << 15, 
    f_Sort              = 1 << 16, 
    f_MultiSelect       = 1 << 17, 
    f_CommitOnSelChange = 1 << 18, 
    f_SinglePage        = 1 << 28, 
    f_EnableAddAfterSigning = 1 << 29, 
    f_Invisible         = 1 << 30  
  };

  enum WidgetFlag
  {
    wf_Invisible      = 1 << (1 - 1), 
    wf_Hidden         = 1 << (2 - 1), 
    wf_Print          = 1 << (3 - 1), 
    wf_NoZoom         = 1 << (4 - 1), 
    wf_NoRotate       = 1 << (5 - 1), 
    wf_NoView         = 1 << (6 - 1), 
    wf_ReadOnly       = 1 << (7 - 1), 
    wf_Locked         = 1 << (8 - 1), 
    wf_ToggleNoView   = 1 << (9 - 1), 
    wf_LockedContents = 1 << (10 - 1) 
  };

  enum Justification
  {
    j_none,             
    j_left,             
    j_center,           
    j_right             
  };

  enum BorderStyle
  {
    bos_other,                  
    bos_solid,                  
    bos_dashed,                 
    bos_beveled,                
    bos_inset,                  
    bos_underline               
  };

  enum ButtonStyle
  {
    bus_default,        
    bus_other,          
    bus_check_mark,     
    bus_cross,          
    bus_star,           
    bus_circle,         
    bus_square,         
    bus_diamond         
  };

  enum LockType
  {
    lt_na,              
    lt_none,            
    lt_all,             
    lt_include,         
    lt_exclude          
  };

  enum SignatureType
  {
    st_not_a_signature_field,  
    st_not_signed,             
    st_approval,               
    st_certification,          
    st_document_time_stamp     
  };

  enum CertSeedValueFlag
  {
    csvf_SubjectCert = 0x01,    
    csvf_IssuerCert  = 0x02,    
    csvf_Policy      = 0x04,    
    csvf_SubjectDN   = 0x08,    
    csvf_KeyUsage    = 0x20,    
    csvf_URL         = 0x40     
  };

public:
  SignDocField ()
    : p (NULL)
  {
    SIGNDOC_Exception *ex = NULL;
    p = SIGNDOC_Field_new (&ex);
    if (ex != NULL) SignDoc_throw (ex);
  }

  SignDocField (const SignDocField &aSource)
    : p (NULL)
  {
    SIGNDOC_Exception *ex = NULL;
    p = SIGNDOC_Field_clone (&ex, aSource.getImpl ());
    if (ex != NULL) SignDoc_throw (ex);
  }

  ~SignDocField ()
  {
    SIGNDOC_Field_delete (p);
  }

  SignDocField &operator= (const SignDocField &aSource)
  {
    SIGNDOC_Exception *ex = NULL;
    SIGNDOC_Field_assign (&ex, p, aSource.getImpl ());
    if (ex != NULL) SignDoc_throw (ex);
    return *this;
  }

  void swap (SignDocField &aOther)
  {
    std::swap (p, aOther.p);
  }

  std::string getName (Encoding aEncoding) const
  {
    SIGNDOC_Exception *ex = NULL;
    std::string r;
    char *s = SIGNDOC_Field_getName (&ex, p, aEncoding);
    if (ex != NULL) SignDoc_throw (ex);
    try
      {
        r = s;
      }
    catch (...)
      {
        SIGNDOC_free (s);
        throw;
      }
    SIGNDOC_free (s);
    return r;
  }

  const char *getNameUTF8 () const
  {
    SIGNDOC_Exception *ex = NULL;
    const char *r;
    r = SIGNDOC_Field_getNameUTF8 (&ex, p);
    if (ex != NULL) SignDoc_throw (ex);
    return r;
  }

  void setName (Encoding aEncoding, const std::string &aName)
  {
    SIGNDOC_Exception *ex = NULL;
    SIGNDOC_Field_setName (&ex, p, aEncoding, aName.c_str ());
    if (ex != NULL) SignDoc_throw (ex);
  }

  void setName (const wchar_t *aName)
  {
    SIGNDOC_Exception *ex = NULL;
    SIGNDOC_Field_setNameW (&ex, p, aName);
    if (ex != NULL) SignDoc_throw (ex);
  }

  std::string getAlternateName (Encoding aEncoding) const
  {
    SIGNDOC_Exception *ex = NULL;
    std::string r;
    char *s = SIGNDOC_Field_getAlternateName (&ex, p, aEncoding);
    if (ex != NULL) SignDoc_throw (ex);
    try
      {
        r = s;
      }
    catch (...)
      {
        SIGNDOC_free (s);
        throw;
      }
    SIGNDOC_free (s);
    return r;
  }

  void setAlternateName (Encoding aEncoding, const std::string &aName)
  {
    SIGNDOC_Exception *ex = NULL;
    SIGNDOC_Field_setAlternateName (&ex, p, aEncoding, aName.c_str ());
    if (ex != NULL) SignDoc_throw (ex);
  }

  std::string getMappingName (Encoding aEncoding) const
  {
    SIGNDOC_Exception *ex = NULL;
    std::string r;
    char *s = SIGNDOC_Field_getMappingName (&ex, p, aEncoding);
    if (ex != NULL) SignDoc_throw (ex);
    try
      {
        r = s;
      }
    catch (...)
      {
        SIGNDOC_free (s);
        throw;
      }
    SIGNDOC_free (s);
    return r;
  }

  void setMappingName (Encoding aEncoding, const std::string &aName)
  {
    SIGNDOC_Exception *ex = NULL;
    SIGNDOC_Field_setMappingName (&ex, p, aEncoding, aName.c_str ());
    if (ex != NULL) SignDoc_throw (ex);
  }

  int getValueCount () const
  {
    SIGNDOC_Exception *ex = NULL;
    int r;
    r = SIGNDOC_Field_getValueCount (&ex, p);
    if (ex != NULL) SignDoc_throw (ex);
    return r;
  }

  std::string getValue (Encoding aEncoding, int aIndex) const
  {
    SIGNDOC_Exception *ex = NULL;
    std::string r;
    char *s = SIGNDOC_Field_getValue (&ex, p, aEncoding, aIndex);
    if (ex != NULL) SignDoc_throw (ex);
    try
      {
        r = s;
      }
    catch (...)
      {
        SIGNDOC_free (s);
        throw;
      }
    SIGNDOC_free (s);
    return r;
  }

  const char *getValueUTF8 (int aIndex) const
  {
    SIGNDOC_Exception *ex = NULL;
    const char *r;
    r = SIGNDOC_Field_getValueUTF8 (&ex, p, aIndex);
    if (ex != NULL) SignDoc_throw (ex);
    return r;
  }

  void clearValues ()
  {
    SIGNDOC_Exception *ex = NULL;
    SIGNDOC_Field_clearValues (&ex, p);
    if (ex != NULL) SignDoc_throw (ex);
  }

  void addValue (Encoding aEncoding, const std::string &aValue)
  {
    SIGNDOC_Exception *ex = NULL;
    SIGNDOC_Field_addValue (&ex, p, aEncoding, aValue.c_str ());
    if (ex != NULL) SignDoc_throw (ex);
  }

  bool setValue (int aIndex, Encoding aEncoding, const std::string &aValue)
  {
    SIGNDOC_Exception *ex = NULL;
    bool r;
    r = (bool)SIGNDOC_Field_setValueByIndex (&ex, p, aIndex, aEncoding, aValue.c_str ());
    if (ex != NULL) SignDoc_throw (ex);
    return r;
  }

  void setValue (Encoding aEncoding, const std::string &aValue)
  {
    SIGNDOC_Exception *ex = NULL;
    SIGNDOC_Field_setValue (&ex, p, aEncoding, aValue.c_str ());
    if (ex != NULL) SignDoc_throw (ex);
  }

  bool removeValue (int aIndex)
  {
    SIGNDOC_Exception *ex = NULL;
    bool r;
    r = (bool)SIGNDOC_Field_removeValue (&ex, p, aIndex);
    if (ex != NULL) SignDoc_throw (ex);
    return r;
  }

  int getValueIndex () const
  {
    SIGNDOC_Exception *ex = NULL;
    int r;
    r = SIGNDOC_Field_getValueIndex (&ex, p);
    if (ex != NULL) SignDoc_throw (ex);
    return r;
  }

  void setValueIndex (int aIndex)
  {
    SIGNDOC_Exception *ex = NULL;
    SIGNDOC_Field_setValueIndex (&ex, p, aIndex);
    if (ex != NULL) SignDoc_throw (ex);
  }

  bool clickButton (int aIndex)
  {
    SIGNDOC_Exception *ex = NULL;
    bool r;
    r = (bool)SIGNDOC_Field_clickButton (&ex, p, aIndex);
    if (ex != NULL) SignDoc_throw (ex);
    return r;
  }

  int getChoiceCount () const
  {
    SIGNDOC_Exception *ex = NULL;
    int r;
    r = SIGNDOC_Field_getChoiceCount (&ex, p);
    if (ex != NULL) SignDoc_throw (ex);
    return r;
  }

  std::string getChoiceValue (Encoding aEncoding, int aIndex) const
  {
    SIGNDOC_Exception *ex = NULL;
    std::string r;
    char *s = SIGNDOC_Field_getChoiceValue (&ex, p, aEncoding, aIndex);
    if (ex != NULL) SignDoc_throw (ex);
    try
      {
        r = s;
      }
    catch (...)
      {
        SIGNDOC_free (s);
        throw;
      }
    SIGNDOC_free (s);
    return r;
  }

  const char *getChoiceValueUTF8 (int aIndex) const
  {
    SIGNDOC_Exception *ex = NULL;
    const char *r;
    r = SIGNDOC_Field_getChoiceValueUTF8 (&ex, p, aIndex);
    if (ex != NULL) SignDoc_throw (ex);
    return r;
  }

  std::string getChoiceExport (Encoding aEncoding, int aIndex) const
  {
    SIGNDOC_Exception *ex = NULL;
    std::string r;
    char *s = SIGNDOC_Field_getChoiceExport (&ex, p, aEncoding, aIndex);
    if (ex != NULL) SignDoc_throw (ex);
    try
      {
        r = s;
      }
    catch (...)
      {
        SIGNDOC_free (s);
        throw;
      }
    SIGNDOC_free (s);
    return r;
  }

  const char *getChoiceExportUTF8 (int aIndex) const
  {
    SIGNDOC_Exception *ex = NULL;
    const char *r;
    r = SIGNDOC_Field_getChoiceExportUTF8 (&ex, p, aIndex);
    if (ex != NULL) SignDoc_throw (ex);
    return r;
  }

  void clearChoices ()
  {
    SIGNDOC_Exception *ex = NULL;
    SIGNDOC_Field_clearChoices (&ex, p);
    if (ex != NULL) SignDoc_throw (ex);
  }

  void addChoice (Encoding aEncoding, const std::string &aValue)
  {
    SIGNDOC_Exception *ex = NULL;
    SIGNDOC_Field_addChoice (&ex, p, aEncoding, aValue.c_str ());
    if (ex != NULL) SignDoc_throw (ex);
  }

  void addChoice (Encoding aEncoding, const std::string &aValue,
                  const std::string &aExport)
  {
    SIGNDOC_Exception *ex = NULL;
    SIGNDOC_Field_addChoiceWithExport (&ex, p, aEncoding, aValue.c_str (), aExport.c_str ());
    if (ex != NULL) SignDoc_throw (ex);
  }

  bool setChoice (int aIndex, Encoding aEncoding, const std::string &aValue)
  {
    SIGNDOC_Exception *ex = NULL;
    bool r;
    r = (bool)SIGNDOC_Field_setChoice (&ex, p, aIndex, aEncoding, aValue.c_str ());
    if (ex != NULL) SignDoc_throw (ex);
    return r;
  }

  bool setChoice (int aIndex, Encoding aEncoding, const std::string &aValue,
                  const std::string &aExport)
  {
    SIGNDOC_Exception *ex = NULL;
    bool r;
    r = (bool)SIGNDOC_Field_setChoiceWithExport (&ex, p, aIndex, aEncoding, aValue.c_str (), aExport.c_str ());
    if (ex != NULL) SignDoc_throw (ex);
    return r;
  }

  bool removeChoice (int aIndex)
  {
    SIGNDOC_Exception *ex = NULL;
    bool r;
    r = (bool)SIGNDOC_Field_removeChoice (&ex, p, aIndex);
    if (ex != NULL) SignDoc_throw (ex);
    return r;
  }

  Type getType () const
  {
    SIGNDOC_Exception *ex = NULL;
    Type r;
    r = (Type)SIGNDOC_Field_getType (&ex, p);
    if (ex != NULL) SignDoc_throw (ex);
    return r;
  }

  void setType (Type aType)
  {
    SIGNDOC_Exception *ex = NULL;
    SIGNDOC_Field_setType (&ex, p, aType);
    if (ex != NULL) SignDoc_throw (ex);
  }

  int getFlags () const
  {
    SIGNDOC_Exception *ex = NULL;
    int r;
    r = SIGNDOC_Field_getFlags (&ex, p);
    if (ex != NULL) SignDoc_throw (ex);
    return r;
  }

  void setFlags (int aFlags)
  {
    SIGNDOC_Exception *ex = NULL;
    SIGNDOC_Field_setFlags (&ex, p, aFlags);
    if (ex != NULL) SignDoc_throw (ex);
  }

  SignatureType getSignatureType () const
  {
    SIGNDOC_Exception *ex = NULL;
    SignatureType r;
    r = (SignatureType)SIGNDOC_Field_getSignatureType (&ex, p);
    if (ex != NULL) SignDoc_throw (ex);
    return r;
  }

  int getDocMDP () const
  {
    SIGNDOC_Exception *ex = NULL;
    int r;
    r = SIGNDOC_Field_getDocMDP (&ex, p);
    if (ex != NULL) SignDoc_throw (ex);
    return r;
  }

  bool isSigned () const
  {
    SIGNDOC_Exception *ex = NULL;
    bool r;
    r = (bool)SIGNDOC_Field_isSigned (&ex, p);
    if (ex != NULL) SignDoc_throw (ex);
    return r;
  }

  bool isCurrentlyClearable () const
  {
    SIGNDOC_Exception *ex = NULL;
    bool r;
    r = (bool)SIGNDOC_Field_isCurrentlyClearable (&ex, p);
    if (ex != NULL) SignDoc_throw (ex);
    return r;
  }

  int getMaxLen () const
  {
    SIGNDOC_Exception *ex = NULL;
    int r;
    r = SIGNDOC_Field_getMaxLen (&ex, p);
    if (ex != NULL) SignDoc_throw (ex);
    return r;
  }

  void setMaxLen (int aMaxLen)
  {
    SIGNDOC_Exception *ex = NULL;
    SIGNDOC_Field_setMaxLen (&ex, p, aMaxLen);
    if (ex != NULL) SignDoc_throw (ex);
  }

  int getTopIndex () const
  {
    SIGNDOC_Exception *ex = NULL;
    int r;
    r = SIGNDOC_Field_getTopIndex (&ex, p);
    if (ex != NULL) SignDoc_throw (ex);
    return r;
  }

  void setTopIndex (int aTopIndex)
  {
    SIGNDOC_Exception *ex = NULL;
    SIGNDOC_Field_setTopIndex (&ex, p, aTopIndex);
    if (ex != NULL) SignDoc_throw (ex);
  }

  int getWidget () const
  {
    SIGNDOC_Exception *ex = NULL;
    int r;
    r = SIGNDOC_Field_getWidget (&ex, p);
    if (ex != NULL) SignDoc_throw (ex);
    return r;
  }

  int getWidgetCount () const
  {
    SIGNDOC_Exception *ex = NULL;
    int r;
    r = SIGNDOC_Field_getWidgetCount (&ex, p);
    if (ex != NULL) SignDoc_throw (ex);
    return r;
  }

  bool selectWidget (int aIndex)
  {
    SIGNDOC_Exception *ex = NULL;
    bool r;
    r = (bool)SIGNDOC_Field_selectWidget (&ex, p, aIndex);
    if (ex != NULL) SignDoc_throw (ex);
    return r;
  }

  bool addWidget ()
  {
    SIGNDOC_Exception *ex = NULL;
    bool r;
    r = (bool)SIGNDOC_Field_addWidget (&ex, p);
    if (ex != NULL) SignDoc_throw (ex);
    return r;
  }

  bool insertWidget (int aIndex)
  {
    SIGNDOC_Exception *ex = NULL;
    bool r;
    r = (bool)SIGNDOC_Field_insertWidget (&ex, p, aIndex);
    if (ex != NULL) SignDoc_throw (ex);
    return r;
  }

  bool removeWidget (int aIndex)
  {
    SIGNDOC_Exception *ex = NULL;
    bool r;
    r = (bool)SIGNDOC_Field_removeWidget (&ex, p, aIndex);
    if (ex != NULL) SignDoc_throw (ex);
    return r;
  }

  int getWidgetFlags () const
  {
    SIGNDOC_Exception *ex = NULL;
    int r;
    r = SIGNDOC_Field_getWidgetFlags (&ex, p);
    if (ex != NULL) SignDoc_throw (ex);
    return r;
  }

  void setWidgetFlags (int aFlags)
  {
    SIGNDOC_Exception *ex = NULL;
    SIGNDOC_Field_setWidgetFlags (&ex, p, aFlags);
    if (ex != NULL) SignDoc_throw (ex);
  }

  int getPage () const
  {
    SIGNDOC_Exception *ex = NULL;
    int r;
    r = SIGNDOC_Field_getPage (&ex, p);
    if (ex != NULL) SignDoc_throw (ex);
    return r;
  }

  void setPage (int aPage)
  {
    SIGNDOC_Exception *ex = NULL;
    SIGNDOC_Field_setPage (&ex, p, aPage);
    if (ex != NULL) SignDoc_throw (ex);
  }

  double getLeft () const
  {
    SIGNDOC_Exception *ex = NULL;
    double r;
    r = SIGNDOC_Field_getLeft (&ex, p);
    if (ex != NULL) SignDoc_throw (ex);
    return r;
  }

  void setLeft (double aLeft)
  {
    SIGNDOC_Exception *ex = NULL;
    SIGNDOC_Field_setLeft (&ex, p, aLeft);
    if (ex != NULL) SignDoc_throw (ex);
  }

  double getBottom () const
  {
    SIGNDOC_Exception *ex = NULL;
    double r;
    r = SIGNDOC_Field_getBottom (&ex, p);
    if (ex != NULL) SignDoc_throw (ex);
    return r;
  }

  void setBottom (double aBottom)
  {
    SIGNDOC_Exception *ex = NULL;
    SIGNDOC_Field_setBottom (&ex, p, aBottom);
    if (ex != NULL) SignDoc_throw (ex);
  }

  double getRight () const
  {
    SIGNDOC_Exception *ex = NULL;
    double r;
    r = SIGNDOC_Field_getRight (&ex, p);
    if (ex != NULL) SignDoc_throw (ex);
    return r;
  }

  void setRight (double aRight)
  {
    SIGNDOC_Exception *ex = NULL;
    SIGNDOC_Field_setRight (&ex, p, aRight);
    if (ex != NULL) SignDoc_throw (ex);
  }

  double getTop () const
  {
    SIGNDOC_Exception *ex = NULL;
    double r;
    r = SIGNDOC_Field_getTop (&ex, p);
    if (ex != NULL) SignDoc_throw (ex);
    return r;
  }

  void setTop (double aTop)
  {
    SIGNDOC_Exception *ex = NULL;
    SIGNDOC_Field_setTop (&ex, p, aTop);
    if (ex != NULL) SignDoc_throw (ex);
  }

  std::string getButtonValue (Encoding aEncoding) const
  {
    SIGNDOC_Exception *ex = NULL;
    std::string r;
    char *s = SIGNDOC_Field_getButtonValue (&ex, p, aEncoding);
    if (ex != NULL) SignDoc_throw (ex);
    try
      {
        r = s;
      }
    catch (...)
      {
        SIGNDOC_free (s);
        throw;
      }
    SIGNDOC_free (s);
    return r;
  }

  const char *getButtonValueUTF8 () const
  {
    SIGNDOC_Exception *ex = NULL;
    const char *r;
    r = SIGNDOC_Field_getButtonValueUTF8 (&ex, p);
    if (ex != NULL) SignDoc_throw (ex);
    return r;
  }

  void setButtonValue (Encoding aEncoding, const std::string &aValue)
  {
    SIGNDOC_Exception *ex = NULL;
    SIGNDOC_Field_setButtonValue (&ex, p, aEncoding, aValue.c_str ());
    if (ex != NULL) SignDoc_throw (ex);
  }

  Justification getJustification () const
  {
    SIGNDOC_Exception *ex = NULL;
    Justification r;
    r = (Justification)SIGNDOC_Field_getJustification (&ex, p);
    if (ex != NULL) SignDoc_throw (ex);
    return r;
  }

  void setJustification (Justification aJustification)
  {
    SIGNDOC_Exception *ex = NULL;
    SIGNDOC_Field_setJustification (&ex, p, aJustification);
    if (ex != NULL) SignDoc_throw (ex);
  }

  int getRotation () const
  {
    SIGNDOC_Exception *ex = NULL;
    int r;
    r = SIGNDOC_Field_getRotation (&ex, p);
    if (ex != NULL) SignDoc_throw (ex);
    return r;
  }

  void setRotation (int aRotation)
  {
    SIGNDOC_Exception *ex = NULL;
    SIGNDOC_Field_setRotation (&ex, p, aRotation);
    if (ex != NULL) SignDoc_throw (ex);
  }

  bool getTextFieldAttributes (SignDocTextFieldAttributes &aOutput) const
  {
    SIGNDOC_Exception *ex = NULL;
    bool r;
    r = (bool)SIGNDOC_Field_getTextFieldAttributes (&ex, p, aOutput.getImpl ());
    if (ex != NULL) SignDoc_throw (ex);
    return r;
  }

  bool setTextFieldAttributes (const SignDocTextFieldAttributes &aInput)
  {
    SIGNDOC_Exception *ex = NULL;
    bool r;
    r = (bool)SIGNDOC_Field_setTextFieldAttributes (&ex, p, aInput.getImpl ());
    if (ex != NULL) SignDoc_throw (ex);
    return r;
  }

  SignDocColor *getBackgroundColor () const
  {
    SIGNDOC_Exception *ex = NULL;
    SIGNDOC_Color *r;
    r = SIGNDOC_Field_getBackgroundColor (&ex, p);
    if (ex != NULL) SignDoc_throw (ex);
    if (r == NULL)
      return NULL;
    try
      {
        return new SignDocColor (r);
      }
    catch (...)
      {
        SIGNDOC_Color_delete (r);
        throw;
      }
  }

  void setBackgroundColor (const SignDocColor *aColor)
  {
    SIGNDOC_Exception *ex = NULL;
    SIGNDOC_Field_setBackgroundColor (&ex, p, aColor == NULL ? NULL : aColor->getImpl ());
    if (ex != NULL) SignDoc_throw (ex);
  }

  SignDocColor *getBorderColor () const
  {
    SIGNDOC_Exception *ex = NULL;
    SIGNDOC_Color *r;
    r = SIGNDOC_Field_getBorderColor (&ex, p);
    if (ex != NULL) SignDoc_throw (ex);
    if (r == NULL)
      return NULL;
    try
      {
        return new SignDocColor (r);
      }
    catch (...)
      {
        SIGNDOC_Color_delete (r);
        throw;
      }
  }

  void setBorderColor (const SignDocColor *aColor)
  {
    SIGNDOC_Exception *ex = NULL;
    SIGNDOC_Field_setBorderColor (&ex, p, aColor == NULL ? NULL : aColor->getImpl ());
    if (ex != NULL) SignDoc_throw (ex);
  }

  double getBorderWidth () const
  {
    SIGNDOC_Exception *ex = NULL;
    double r;
    r = SIGNDOC_Field_getBorderWidth (&ex, p);
    if (ex != NULL) SignDoc_throw (ex);
    return r;
  }

  void setBorderWidth (double aWidth)
  {
    SIGNDOC_Exception *ex = NULL;
    SIGNDOC_Field_setBorderWidth (&ex, p, aWidth);
    if (ex != NULL) SignDoc_throw (ex);
  }

  BorderStyle getBorderStyle () const
  {
    SIGNDOC_Exception *ex = NULL;
    BorderStyle r;
    r = (BorderStyle)SIGNDOC_Field_getBorderStyle (&ex, p);
    if (ex != NULL) SignDoc_throw (ex);
    return r;
  }

  void setBorderStyle (BorderStyle aStyle)
  {
    SIGNDOC_Exception *ex = NULL;
    SIGNDOC_Field_setBorderStyle (&ex, p, aStyle);
    if (ex != NULL) SignDoc_throw (ex);
  }

  ButtonStyle getButtonStyle () const
  {
    SIGNDOC_Exception *ex = NULL;
    ButtonStyle r;
    r = (ButtonStyle)SIGNDOC_Field_getButtonStyle (&ex, p);
    if (ex != NULL) SignDoc_throw (ex);
    return r;
  }

  void setButtonStyle (ButtonStyle aStyle)
  {
    SIGNDOC_Exception *ex = NULL;
    SIGNDOC_Field_setButtonStyle (&ex, p, aStyle);
    if (ex != NULL) SignDoc_throw (ex);
  }

  LockType getLockType () const
  {
    SIGNDOC_Exception *ex = NULL;
    LockType r;
    r = (LockType)SIGNDOC_Field_getLockType (&ex, p);
    if (ex != NULL) SignDoc_throw (ex);
    return r;
  }

  void setLockType (LockType aLockType)
  {
    SIGNDOC_Exception *ex = NULL;
    SIGNDOC_Field_setLockType (&ex, p, aLockType);
    if (ex != NULL) SignDoc_throw (ex);
  }

  int getLockFieldCount () const
  {
    SIGNDOC_Exception *ex = NULL;
    int r;
    r = SIGNDOC_Field_getLockFieldCount (&ex, p);
    if (ex != NULL) SignDoc_throw (ex);
    return r;
  }

  std::string getLockField (Encoding aEncoding, int aIndex) const
  {
    SIGNDOC_Exception *ex = NULL;
    std::string r;
    char *s = SIGNDOC_Field_getLockField (&ex, p, aEncoding, aIndex);
    if (ex != NULL) SignDoc_throw (ex);
    try
      {
        r = s;
      }
    catch (...)
      {
        SIGNDOC_free (s);
        throw;
      }
    SIGNDOC_free (s);
    return r;
  }

  const char *getLockFieldUTF8 (int aIndex) const
  {
    SIGNDOC_Exception *ex = NULL;
    const char *r;
    r = SIGNDOC_Field_getLockFieldUTF8 (&ex, p, aIndex);
    if (ex != NULL) SignDoc_throw (ex);
    return r;
  }

  void clearLockFields ()
  {
    SIGNDOC_Exception *ex = NULL;
    SIGNDOC_Field_clearLockFields (&ex, p);
    if (ex != NULL) SignDoc_throw (ex);
  }

  void addLockField (Encoding aEncoding, const std::string &aName)
  {
    SIGNDOC_Exception *ex = NULL;
    SIGNDOC_Field_addLockField (&ex, p, aEncoding, aName.c_str ());
    if (ex != NULL) SignDoc_throw (ex);
  }

  bool setLockField (int aIndex, Encoding aEncoding, const std::string &aName)
  {
    SIGNDOC_Exception *ex = NULL;
    bool r;
    r = (bool)SIGNDOC_Field_setLockFieldByIndex (&ex, p, aIndex, aEncoding, aName.c_str ());
    if (ex != NULL) SignDoc_throw (ex);
    return r;
  }

  void setLockField (Encoding aEncoding, const std::string &aName)
  {
    SIGNDOC_Exception *ex = NULL;
    SIGNDOC_Field_setLockField (&ex, p, aEncoding, aName.c_str ());
    if (ex != NULL) SignDoc_throw (ex);
  }

  bool removeLockField (int aIndex)
  {
    SIGNDOC_Exception *ex = NULL;
    bool r;
    r = (bool)SIGNDOC_Field_removeLockField (&ex, p, aIndex);
    if (ex != NULL) SignDoc_throw (ex);
    return r;
  }

  int getLockMDP () const
  {
    SIGNDOC_Exception *ex = NULL;
    int r;
    r = SIGNDOC_Field_getLockMDP (&ex, p);
    if (ex != NULL) SignDoc_throw (ex);
    return r;
  }

  void setLockMDP (int aMDP)
  {
    SIGNDOC_Exception *ex = NULL;
    SIGNDOC_Field_setLockMDP (&ex, p, aMDP);
    if (ex != NULL) SignDoc_throw (ex);
  }

  unsigned getCertSeedValueFlags () const
  {
    SIGNDOC_Exception *ex = NULL;
    unsigned r;
    r = SIGNDOC_Field_getCertSeedValueFlags (&ex, p);
    if (ex != NULL) SignDoc_throw (ex);
    return r;
  }

  void setCertSeedValueFlags (unsigned aFlags)
  {
    SIGNDOC_Exception *ex = NULL;
    SIGNDOC_Field_setCertSeedValueFlags (&ex, p, aFlags);
    if (ex != NULL) SignDoc_throw (ex);
  }

  int getCertSeedValueSubjectDNCount () const
  {
    SIGNDOC_Exception *ex = NULL;
    int r;
    r = SIGNDOC_Field_getCertSeedValueSubjectDNCount (&ex, p);
    if (ex != NULL) SignDoc_throw (ex);
    return r;
  }

  std::string getCertSeedValueSubjectDN (Encoding aEncoding, int aIndex) const
  {
    SIGNDOC_Exception *ex = NULL;
    std::string r;
    char *s = SIGNDOC_Field_getCertSeedValueSubjectDN (&ex, p, aEncoding, aIndex);
    if (ex != NULL) SignDoc_throw (ex);
    try
      {
        r = s;
      }
    catch (...)
      {
        SIGNDOC_free (s);
        throw;
      }
    SIGNDOC_free (s);
    return r;
  }

  const char *getCertSeedValueSubjectDNUTF8 (int aIndex) const
  {
    SIGNDOC_Exception *ex = NULL;
    const char *r;
    r = SIGNDOC_Field_getCertSeedValueSubjectDNUTF8 (&ex, p, aIndex);
    if (ex != NULL) SignDoc_throw (ex);
    return r;
  }

  void clearCertSeedValueSubjectDNs ()
  {
    SIGNDOC_Exception *ex = NULL;
    SIGNDOC_Field_clearCertSeedValueSubjectDNs (&ex, p);
    if (ex != NULL) SignDoc_throw (ex);
  }

  bool addCertSeedValueSubjectDN (Encoding aEncoding, const std::string &aName)
  {
    SIGNDOC_Exception *ex = NULL;
    bool r;
    r = (bool)SIGNDOC_Field_addCertSeedValueSubjectDN (&ex, p, aEncoding, aName.c_str ());
    if (ex != NULL) SignDoc_throw (ex);
    return r;
  }

  bool setCertSeedValueSubjectDN (int aIndex, Encoding aEncoding,
                                  const std::string &aName)
  {
    SIGNDOC_Exception *ex = NULL;
    bool r;
    r = (bool)SIGNDOC_Field_setCertSeedValueSubjectDNByIndex (&ex, p, aIndex, aEncoding, aName.c_str ());
    if (ex != NULL) SignDoc_throw (ex);
    return r;
  }

  bool setCertSeedValueSubjectDN (Encoding aEncoding, const std::string &aName)
  {
    SIGNDOC_Exception *ex = NULL;
    bool r;
    r = (bool)SIGNDOC_Field_setCertSeedValueSubjectDN (&ex, p, aEncoding, aName.c_str ());
    if (ex != NULL) SignDoc_throw (ex);
    return r;
  }

  bool removeCertSeedValueSubjectDN (int aIndex)
  {
    SIGNDOC_Exception *ex = NULL;
    bool r;
    r = (bool)SIGNDOC_Field_removeCertSeedValueSubjectDN (&ex, p, aIndex);
    if (ex != NULL) SignDoc_throw (ex);
    return r;
  }

  int getCertSeedValueSubjectCertificateCount () const
  {
    SIGNDOC_Exception *ex = NULL;
    int r;
    r = SIGNDOC_Field_getCertSeedValueSubjectCertificateCount (&ex, p);
    if (ex != NULL) SignDoc_throw (ex);
    return r;
  }

  bool getCertSeedValueSubjectCertificate (int aIndex,
                                           std::vector<unsigned char> &aOutput) const
  {
    SIGNDOC_Exception *ex = NULL;
    SIGNDOC_ByteArray *tempOutput = NULL;
    bool r;
    try
      {
        tempOutput = SIGNDOC_ByteArray_new (&ex);
        if (ex != NULL) SignDoc_throw (ex);
        r = (bool)SIGNDOC_Field_getCertSeedValueSubjectCertificate (&ex, p, aIndex, tempOutput);
        assignArray (aOutput, tempOutput);
      }
    catch (...)
      {
        if (tempOutput != NULL)
          SIGNDOC_ByteArray_delete (tempOutput);
        throw;
      }
    if (tempOutput != NULL)
      SIGNDOC_ByteArray_delete (tempOutput);
    if (ex != NULL) SignDoc_throw (ex);
    return r;
  }

  void clearCertSeedValueSubjectCertificates ()
  {
    SIGNDOC_Exception *ex = NULL;
    SIGNDOC_Field_clearCertSeedValueSubjectCertificates (&ex, p);
    if (ex != NULL) SignDoc_throw (ex);
  }

  void addCertSeedValueSubjectCertificate (const void *aPtr, size_t aSize)
  {
    SIGNDOC_Exception *ex = NULL;
    SIGNDOC_Field_addCertSeedValueSubjectCertificate (&ex, p, aPtr, aSize);
    if (ex != NULL) SignDoc_throw (ex);
  }

  bool setCertSeedValueSubjectCertificate (int aIndex, const void *aPtr,
                                           size_t aSize)
  {
    SIGNDOC_Exception *ex = NULL;
    bool r;
    r = (bool)SIGNDOC_Field_setCertSeedValueSubjectCertificateByIndex (&ex, p, aIndex, aPtr, aSize);
    if (ex != NULL) SignDoc_throw (ex);
    return r;
  }

  void setCertSeedValueSubjectCertificate (const void *aPtr, size_t aSize)
  {
    SIGNDOC_Exception *ex = NULL;
    SIGNDOC_Field_setCertSeedValueSubjectCertificate (&ex, p, aPtr, aSize);
    if (ex != NULL) SignDoc_throw (ex);
  }

  bool removeCertSeedValueSubjectCertificate (int aIndex)
  {
    SIGNDOC_Exception *ex = NULL;
    bool r;
    r = (bool)SIGNDOC_Field_removeCertSeedValueSubjectCertificate (&ex, p, aIndex);
    if (ex != NULL) SignDoc_throw (ex);
    return r;
  }

  int getCertSeedValueIssuerCertificateCount () const
  {
    SIGNDOC_Exception *ex = NULL;
    int r;
    r = SIGNDOC_Field_getCertSeedValueIssuerCertificateCount (&ex, p);
    if (ex != NULL) SignDoc_throw (ex);
    return r;
  }

  bool getCertSeedValueIssuerCertificate (int aIndex,
                                          std::vector<unsigned char> &aOutput) const
  {
    SIGNDOC_Exception *ex = NULL;
    SIGNDOC_ByteArray *tempOutput = NULL;
    bool r;
    try
      {
        tempOutput = SIGNDOC_ByteArray_new (&ex);
        if (ex != NULL) SignDoc_throw (ex);
        r = (bool)SIGNDOC_Field_getCertSeedValueIssuerCertificate (&ex, p, aIndex, tempOutput);
        assignArray (aOutput, tempOutput);
      }
    catch (...)
      {
        if (tempOutput != NULL)
          SIGNDOC_ByteArray_delete (tempOutput);
        throw;
      }
    if (tempOutput != NULL)
      SIGNDOC_ByteArray_delete (tempOutput);
    if (ex != NULL) SignDoc_throw (ex);
    return r;
  }

  void clearCertSeedValueIssuerCertificates ()
  {
    SIGNDOC_Exception *ex = NULL;
    SIGNDOC_Field_clearCertSeedValueIssuerCertificates (&ex, p);
    if (ex != NULL) SignDoc_throw (ex);
  }

  void addCertSeedValueIssuerCertificate (const void *aPtr, size_t aSize)
  {
    SIGNDOC_Exception *ex = NULL;
    SIGNDOC_Field_addCertSeedValueIssuerCertificate (&ex, p, aPtr, aSize);
    if (ex != NULL) SignDoc_throw (ex);
  }

  bool setCertSeedValueIssuerCertificate (int aIndex, const void *aPtr,
                                          size_t aSize)
  {
    SIGNDOC_Exception *ex = NULL;
    bool r;
    r = (bool)SIGNDOC_Field_setCertSeedValueIssuerCertificateByIndex (&ex, p, aIndex, aPtr, aSize);
    if (ex != NULL) SignDoc_throw (ex);
    return r;
  }

  void setCertSeedValueIssuerCertificate (const void *aPtr, size_t aSize)
  {
    SIGNDOC_Exception *ex = NULL;
    SIGNDOC_Field_setCertSeedValueIssuerCertificate (&ex, p, aPtr, aSize);
    if (ex != NULL) SignDoc_throw (ex);
  }

  bool removeCertSeedValueIssuerCertificate (int aIndex)
  {
    SIGNDOC_Exception *ex = NULL;
    bool r;
    r = (bool)SIGNDOC_Field_removeCertSeedValueIssuerCertificate (&ex, p, aIndex);
    if (ex != NULL) SignDoc_throw (ex);
    return r;
  }

  int getCertSeedValuePolicyCount () const
  {
    SIGNDOC_Exception *ex = NULL;
    int r;
    r = SIGNDOC_Field_getCertSeedValuePolicyCount (&ex, p);
    if (ex != NULL) SignDoc_throw (ex);
    return r;
  }

  std::string getCertSeedValuePolicy (Encoding aEncoding, int aIndex) const
  {
    SIGNDOC_Exception *ex = NULL;
    std::string r;
    char *s = SIGNDOC_Field_getCertSeedValuePolicy (&ex, p, aEncoding, aIndex);
    if (ex != NULL) SignDoc_throw (ex);
    try
      {
        r = s;
      }
    catch (...)
      {
        SIGNDOC_free (s);
        throw;
      }
    SIGNDOC_free (s);
    return r;
  }

  const char *getCertSeedValuePolicyUTF8 (int aIndex) const
  {
    SIGNDOC_Exception *ex = NULL;
    const char *r;
    r = SIGNDOC_Field_getCertSeedValuePolicyUTF8 (&ex, p, aIndex);
    if (ex != NULL) SignDoc_throw (ex);
    return r;
  }

  void clearCertSeedValuePolicies ()
  {
    SIGNDOC_Exception *ex = NULL;
    SIGNDOC_Field_clearCertSeedValuePolicies (&ex, p);
    if (ex != NULL) SignDoc_throw (ex);
  }

  void addCertSeedValuePolicy (Encoding aEncoding, const std::string &aOID)
  {
    SIGNDOC_Exception *ex = NULL;
    SIGNDOC_Field_addCertSeedValuePolicy (&ex, p, aEncoding, aOID.c_str ());
    if (ex != NULL) SignDoc_throw (ex);
  }

  bool setCertSeedValuePolicy (int aIndex, Encoding aEncoding,
                               const std::string &aOID)
  {
    SIGNDOC_Exception *ex = NULL;
    bool r;
    r = (bool)SIGNDOC_Field_setCertSeedValuePolicyByIndex (&ex, p, aIndex, aEncoding, aOID.c_str ());
    if (ex != NULL) SignDoc_throw (ex);
    return r;
  }

  void setCertSeedValuePolicy (Encoding aEncoding, const std::string &aOID)
  {
    SIGNDOC_Exception *ex = NULL;
    SIGNDOC_Field_setCertSeedValuePolicy (&ex, p, aEncoding, aOID.c_str ());
    if (ex != NULL) SignDoc_throw (ex);
  }

  bool removeCertSeedValuePolicy (int aIndex)
  {
    SIGNDOC_Exception *ex = NULL;
    bool r;
    r = (bool)SIGNDOC_Field_removeCertSeedValuePolicy (&ex, p, aIndex);
    if (ex != NULL) SignDoc_throw (ex);
    return r;
  }

  std::string getSeedValueTimeStampServerURL (Encoding aEncoding) const
  {
    SIGNDOC_Exception *ex = NULL;
    std::string r;
    char *s = SIGNDOC_Field_getSeedValueTimeStampServerURL (&ex, p, aEncoding);
    if (ex != NULL) SignDoc_throw (ex);
    try
      {
        r = s;
      }
    catch (...)
      {
        SIGNDOC_free (s);
        throw;
      }
    SIGNDOC_free (s);
    return r;
  }

  bool getSeedValueTimeStampRequired () const
  {
    SIGNDOC_Exception *ex = NULL;
    bool r;
    r = (bool)SIGNDOC_Field_getSeedValueTimeStampRequired (&ex, p);
    if (ex != NULL) SignDoc_throw (ex);
    return r;
  }

  bool setSeedValueTimeStamp (Encoding aEncoding, const std::string &aURL,
                              bool aRequired)
  {
    SIGNDOC_Exception *ex = NULL;
    bool r;
    r = (bool)SIGNDOC_Field_setSeedValueTimeStamp (&ex, p, aEncoding, aURL.c_str (), aRequired);
    if (ex != NULL) SignDoc_throw (ex);
    return r;
  }

  std::string getSeedValueFilter (Encoding aEncoding) const
  {
    SIGNDOC_Exception *ex = NULL;
    std::string r;
    char *s = SIGNDOC_Field_getSeedValueFilter (&ex, p, aEncoding);
    if (ex != NULL) SignDoc_throw (ex);
    try
      {
        r = s;
      }
    catch (...)
      {
        SIGNDOC_free (s);
        throw;
      }
    SIGNDOC_free (s);
    return r;
  }

  bool getSeedValueFilterRequired () const
  {
    SIGNDOC_Exception *ex = NULL;
    bool r;
    r = (bool)SIGNDOC_Field_getSeedValueFilterRequired (&ex, p);
    if (ex != NULL) SignDoc_throw (ex);
    return r;
  }

  bool setSeedValueFilter (Encoding aEncoding, const std::string &aFilter,
                           bool aRequired)
  {
    SIGNDOC_Exception *ex = NULL;
    bool r;
    r = (bool)SIGNDOC_Field_setSeedValueFilter (&ex, p, aEncoding, aFilter.c_str (), aRequired);
    if (ex != NULL) SignDoc_throw (ex);
    return r;
  }

  int getSeedValueSubFilterCount () const
  {
    SIGNDOC_Exception *ex = NULL;
    int r;
    r = SIGNDOC_Field_getSeedValueSubFilterCount (&ex, p);
    if (ex != NULL) SignDoc_throw (ex);
    return r;
  }

  std::string getSeedValueSubFilter (Encoding aEncoding, int aIndex) const
  {
    SIGNDOC_Exception *ex = NULL;
    std::string r;
    char *s = SIGNDOC_Field_getSeedValueSubFilter (&ex, p, aEncoding, aIndex);
    if (ex != NULL) SignDoc_throw (ex);
    try
      {
        r = s;
      }
    catch (...)
      {
        SIGNDOC_free (s);
        throw;
      }
    SIGNDOC_free (s);
    return r;
  }

  bool getSeedValueSubFilterRequired () const
  {
    SIGNDOC_Exception *ex = NULL;
    bool r;
    r = (bool)SIGNDOC_Field_getSeedValueSubFilterRequired (&ex, p);
    if (ex != NULL) SignDoc_throw (ex);
    return r;
  }

  void setSeedValueSubFilterRequired (bool aRequired) const
  {
    SIGNDOC_Exception *ex = NULL;
    SIGNDOC_Field_setSeedValueSubFilterRequired (&ex, p, aRequired);
    if (ex != NULL) SignDoc_throw (ex);
  }

  const char *getSeedValueSubFilterUTF8 (int aIndex) const
  {
    SIGNDOC_Exception *ex = NULL;
    const char *r;
    r = SIGNDOC_Field_getSeedValueSubFilterUTF8 (&ex, p, aIndex);
    if (ex != NULL) SignDoc_throw (ex);
    return r;
  }

  void clearSeedValueSubFilters ()
  {
    SIGNDOC_Exception *ex = NULL;
    SIGNDOC_Field_clearSeedValueSubFilters (&ex, p);
    if (ex != NULL) SignDoc_throw (ex);
  }

  void addSeedValueSubFilter (Encoding aEncoding,
                              const std::string &aSubFilter)
  {
    SIGNDOC_Exception *ex = NULL;
    SIGNDOC_Field_addSeedValueSubFilter (&ex, p, aEncoding, aSubFilter.c_str ());
    if (ex != NULL) SignDoc_throw (ex);
  }

  bool setSeedValueSubFilter (int aIndex, Encoding aEncoding,
                              const std::string &aSubFilter)
  {
    SIGNDOC_Exception *ex = NULL;
    bool r;
    r = (bool)SIGNDOC_Field_setSeedValueSubFilterByIndex (&ex, p, aIndex, aEncoding, aSubFilter.c_str ());
    if (ex != NULL) SignDoc_throw (ex);
    return r;
  }

  void setSeedValueSubFilter (Encoding aEncoding,
                              const std::string &aSubFilter)
  {
    SIGNDOC_Exception *ex = NULL;
    SIGNDOC_Field_setSeedValueSubFilter (&ex, p, aEncoding, aSubFilter.c_str ());
    if (ex != NULL) SignDoc_throw (ex);
  }

  bool removeSeedValueSubFilter (int aIndex)
  {
    SIGNDOC_Exception *ex = NULL;
    bool r;
    r = (bool)SIGNDOC_Field_removeSeedValueSubFilter (&ex, p, aIndex);
    if (ex != NULL) SignDoc_throw (ex);
    return r;
  }

  int getSeedValueDigestMethodCount () const
  {
    SIGNDOC_Exception *ex = NULL;
    int r;
    r = SIGNDOC_Field_getSeedValueDigestMethodCount (&ex, p);
    if (ex != NULL) SignDoc_throw (ex);
    return r;
  }

  std::string getSeedValueDigestMethod (Encoding aEncoding, int aIndex) const
  {
    SIGNDOC_Exception *ex = NULL;
    std::string r;
    char *s = SIGNDOC_Field_getSeedValueDigestMethod (&ex, p, aEncoding, aIndex);
    if (ex != NULL) SignDoc_throw (ex);
    try
      {
        r = s;
      }
    catch (...)
      {
        SIGNDOC_free (s);
        throw;
      }
    SIGNDOC_free (s);
    return r;
  }

  bool getSeedValueDigestMethodRequired () const
  {
    SIGNDOC_Exception *ex = NULL;
    bool r;
    r = (bool)SIGNDOC_Field_getSeedValueDigestMethodRequired (&ex, p);
    if (ex != NULL) SignDoc_throw (ex);
    return r;
  }

  void setSeedValueDigestMethodRequired (bool aRequired) const
  {
    SIGNDOC_Exception *ex = NULL;
    SIGNDOC_Field_setSeedValueDigestMethodRequired (&ex, p, aRequired);
    if (ex != NULL) SignDoc_throw (ex);
  }

  const char *getSeedValueDigestMethodUTF8 (int aIndex) const
  {
    SIGNDOC_Exception *ex = NULL;
    const char *r;
    r = SIGNDOC_Field_getSeedValueDigestMethodUTF8 (&ex, p, aIndex);
    if (ex != NULL) SignDoc_throw (ex);
    return r;
  }

  void clearSeedValueDigestMethods ()
  {
    SIGNDOC_Exception *ex = NULL;
    SIGNDOC_Field_clearSeedValueDigestMethods (&ex, p);
    if (ex != NULL) SignDoc_throw (ex);
  }

  void addSeedValueDigestMethod (Encoding aEncoding,
                                 const std::string &aDigestMethod)
  {
    SIGNDOC_Exception *ex = NULL;
    SIGNDOC_Field_addSeedValueDigestMethod (&ex, p, aEncoding, aDigestMethod.c_str ());
    if (ex != NULL) SignDoc_throw (ex);
  }

  bool setSeedValueDigestMethod (int aIndex, Encoding aEncoding,
                                 const std::string &aDigestMethod)
  {
    SIGNDOC_Exception *ex = NULL;
    bool r;
    r = (bool)SIGNDOC_Field_setSeedValueDigestMethodByIndex (&ex, p, aIndex, aEncoding, aDigestMethod.c_str ());
    if (ex != NULL) SignDoc_throw (ex);
    return r;
  }

  void setSeedValueDigestMethod (Encoding aEncoding,
                                 const std::string &aDigestMethod)
  {
    SIGNDOC_Exception *ex = NULL;
    SIGNDOC_Field_setSeedValueDigestMethod (&ex, p, aEncoding, aDigestMethod.c_str ());
    if (ex != NULL) SignDoc_throw (ex);
  }

  bool removeSeedValueDigestMethod (int aIndex)
  {
    SIGNDOC_Exception *ex = NULL;
    bool r;
    r = (bool)SIGNDOC_Field_removeSeedValueDigestMethod (&ex, p, aIndex);
    if (ex != NULL) SignDoc_throw (ex);
    return r;
  }

  bool getSeedValueAddRevInfo () const
  {
    SIGNDOC_Exception *ex = NULL;
    bool r;
    r = (bool)SIGNDOC_Field_getSeedValueAddRevInfo (&ex, p);
    if (ex != NULL) SignDoc_throw (ex);
    return r;
  }

  void setSeedValueAddRevInfo (bool aAddRevInfo)
  {
    SIGNDOC_Exception *ex = NULL;
    SIGNDOC_Field_setSeedValueAddRevInfo (&ex, p, aAddRevInfo);
    if (ex != NULL) SignDoc_throw (ex);
  }

  int getSeedValueMDP () const
  {
    SIGNDOC_Exception *ex = NULL;
    int r;
    r = SIGNDOC_Field_getSeedValueMDP (&ex, p);
    if (ex != NULL) SignDoc_throw (ex);
    return r;
  }

  bool setSeedValueMDP (int aMDP)
  {
    SIGNDOC_Exception *ex = NULL;
    bool r;
    r = (bool)SIGNDOC_Field_setSeedValueMDP (&ex, p, aMDP);
    if (ex != NULL) SignDoc_throw (ex);
    return r;
  }

  SignDocColor *getEmptyFieldColor () const
  {
    SIGNDOC_Exception *ex = NULL;
    SIGNDOC_Color *r;
    r = SIGNDOC_Field_getEmptyFieldColor (&ex, p);
    if (ex != NULL) SignDoc_throw (ex);
    if (r == NULL)
      return NULL;
    try
      {
        return new SignDocColor (r);
      }
    catch (...)
      {
        SIGNDOC_Color_delete (r);
        throw;
      }
  }

  void setEmptyFieldColor (const SignDocColor &aColor)
  {
    SIGNDOC_Exception *ex = NULL;
    SIGNDOC_Field_setEmptyFieldColor (&ex, p, aColor.getImpl ());
    if (ex != NULL) SignDoc_throw (ex);
  }

private:
public:
  SignDocField (SIGNDOC_Field *aP) : p (aP) { }

  SIGNDOC_Field *getImpl () { return p; }

  const SIGNDOC_Field *getImpl () const { return p; }

  void setImpl (SIGNDOC_Field *aP) { SIGNDOC_Field_delete (p); p  = aP; }

private:
  SIGNDOC_Field *p;
};

inline void assignArray (std::vector<SignDocField> &aDst,
                         SIGNDOC_FieldArray *aSrc)
{
  aDst.clear ();
  unsigned n = SIGNDOC_FieldArray_count (aSrc);
  if (aSrc == NULL)
    return;
  aDst.resize (n);
  for (unsigned i = 0; i < n; ++i)
    {
      SIGNDOC_Exception *ex = NULL;
      SIGNDOC_Field *p = SIGNDOC_Field_clone (&ex, SIGNDOC_FieldArray_at (aSrc, i));
      if (ex != NULL) SignDoc_throw (ex);
      aDst[i].setImpl (p);
    }
}

class SignDocSignatureParameters 
{
public:
  enum Method
  {
    m_default,

    m_digsig_pkcs1,

    m_digsig_pkcs7_detached,

    /*+
     * @brief PKCS #7 with SHA-1 (deprecated).
     */
    m_digsig_pkcs7_sha1,

    /*+
     * @brief The signature is just a hash (TIFF only).
     */
    m_hash,

    /*+
     * @brief Detached ETSI CAdES (PAdES-BES).
     */
    m_digsig_cades_detached,

    /*+
     * @brief ETSI CAdES RFC 3161 time stamp.
     */
    m_digsig_cades_rfc3161
  };

  enum DetachedHashAlgorithm
  {
    dha_default,

    dha_sha1,                  
    dha_sha256,                
    dha_sha384,                
    dha_sha512,                
    dha_ripemd160,             
    dha_sha224                 
  };

  enum AddCertificates
  {
    ac_all,

    ac_none,

    ac_trusted
  };

  enum AddRevocationInfo
  {
    ari_add = 0x01
  };

  enum RemoveXFA
  {
    rx_always,

    rx_if_allowed,

    rx_never
  };

  enum TimeStampHashAlgorithm
  {
    tsha_default,

    tsha_sha1,                  
    tsha_sha256,                
    tsha_sha384,                
    tsha_sha512                 
  };

  enum Optimize
  {
    o_optimize,               
    o_dont_optimize           
  };

  enum PDFAButtons
  {
    pb_freeze,

    pb_dont_freeze,

    pb_auto
  };

  enum CertificateSigningAlgorithm
  {
    csa_sha1_rsa,               
    csa_md5_rsa,                
    csa_sha256_rsa,             
    csa_sha384_rsa,             
    csa_sha512_rsa,             
    csa_ripemd160_rsa,          
    csa_ecdsa_sha1,             
    csa_ecdsa_sha224,           
    csa_ecdsa_sha256,           
    csa_ecdsa_sha384,           
    csa_ecdsa_sha512            
  };

  enum RSASignatureScheme
  {
    rss_pkcs1,

    rss_pss
  };

  enum BiometricEncryption
  {
    be_rsa,

    be_fixed,

    be_binary,

    be_passphrase,

    be_dont_store
  };

  enum BiometricHashLocation
  {
    bhl_attr,

    bhl_contents
  };

  enum HAlignment
  {
    ha_left,

    ha_center,

    ha_right,

    ha_justify,

    ha_auto,

    ha_default = -1
  };

  enum VAlignment
  {
    va_top,

    va_center,

    va_bottom
  };

  enum TextPosition
  {
    tp_overlay,       
    tp_below,         
    tp_underlay,      
    tp_right_of,      
    tp_above,         
    tp_left_of        
  };

  enum ValueType
  {
    vt_abs,                   
    vt_field_height,          
    vt_field_width            
  };

  enum TextItem
  {
    ti_signer,                
    ti_sign_time,             
    ti_comment,               
    ti_adviser,               
    ti_contact_info,          
    ti_location,              
    ti_reason,                
    ti_text1,                 
    ti_text2,                 
    ti_text3,                 
    ti_text4,                 
    ti_text5,                 
    ti_text6,                 
    ti_text7,                 
    ti_text8,                 
    ti_text9                  
  };

  enum TextGroup
  {
    tg_master,                
    tg_slave                  
  };

  enum TextItemDirection
  {
    tid_ltr = 0x1000,

    tid_rtl = 0x2000,

    tid_default_ltr = 0x4000,

    tid_default_rtl = 0x8000
  };

  enum IgnoreSeedValues
  {
    isv_SubFilter = 0x01,

    isv_DigestMethod = 0x02
  };

  enum CertificateSelectionFlags
  {
    csf_software = 0x01,

    csf_hardware = 0x02,

    csf_use_certificate_seed_values = 0x10, 
    csf_ask_if_ambiguous = 0x20, 
    csf_never_ask = 0x40,       
    csf_create_self_signed = 0x80 
  };

  enum RenderSignatureFlags
  {
    rsf_bw   = 0x01,

    rsf_gray = 0x02,

    rsf_antialias = 0x04,

    rsf_limit_size = 0x08
  };

  enum ImageTransparency
  {
    it_opaque,

    it_brightest
  };

  enum ReturnCode
  {
    rc_ok,                      
    rc_unknown,                 
    rc_not_supported,           
    rc_invalid_value            
  };

  enum ParameterState
  {
    ps_set,             
    ps_missing,         
    ps_supported,       
    ps_ignored,         
    ps_not_supported,   
    ps_unknown          
  };

public:
  SignDocSignatureParameters ()
    : p (NULL)
  {
  }

  ~SignDocSignatureParameters ()
  {
    SIGNDOC_SignatureParameters_delete (p);
  }

  ParameterState getState (const std::string &aName)
  {
    SIGNDOC_Exception *ex = NULL;
    ParameterState r;
    r = (ParameterState)SIGNDOC_SignatureParameters_getState (&ex, p, aName.c_str ());
    if (ex != NULL) SignDoc_throw (ex);
    return r;
  }

  ReturnCode setString (Encoding aEncoding, const std::string &aName,
                        const std::string &aValue)
  {
    SIGNDOC_Exception *ex = NULL;
    ReturnCode r;
    r = (ReturnCode)SIGNDOC_SignatureParameters_setString (&ex, p, aEncoding, aName.c_str (), aValue.c_str ());
    if (ex != NULL) SignDoc_throw (ex);
    return r;
  }

  ReturnCode setString (const std::string &aName, const wchar_t *aValue)
  {
    SIGNDOC_Exception *ex = NULL;
    ReturnCode r;
    r = (ReturnCode)SIGNDOC_SignatureParameters_setStringW (&ex, p, aName.c_str (), aValue);
    if (ex != NULL) SignDoc_throw (ex);
    return r;
  }

  ReturnCode setInteger (const std::string &aName, int aValue)
  {
    SIGNDOC_Exception *ex = NULL;
    ReturnCode r;
    r = (ReturnCode)SIGNDOC_SignatureParameters_setInteger (&ex, p, aName.c_str (), aValue);
    if (ex != NULL) SignDoc_throw (ex);
    return r;
  }

  ReturnCode setBlob (const std::string &aName, const unsigned char *aData,
                      size_t aSize)
  {
    SIGNDOC_Exception *ex = NULL;
    ReturnCode r;
    r = (ReturnCode)SIGNDOC_SignatureParameters_setBlob (&ex, p, aName.c_str (), aData, aSize);
    if (ex != NULL) SignDoc_throw (ex);
    return r;
  }

  ReturnCode setLength (const std::string &aName, ValueType aType,
                        double aValue)
  {
    SIGNDOC_Exception *ex = NULL;
    ReturnCode r;
    r = (ReturnCode)SIGNDOC_SignatureParameters_setLength (&ex, p, aName.c_str (), aType, aValue);
    if (ex != NULL) SignDoc_throw (ex);
    return r;
  }

  ReturnCode setColor (const std::string &aName, const SignDocColor &aValue)
  {
    SIGNDOC_Exception *ex = NULL;
    ReturnCode r;
    r = (ReturnCode)SIGNDOC_SignatureParameters_setColor (&ex, p, aName.c_str (), aValue.getImpl ());
    if (ex != NULL) SignDoc_throw (ex);
    return r;
  }

  ReturnCode addTextItem (TextItem aItem, TextGroup aGroup)
  {
    SIGNDOC_Exception *ex = NULL;
    ReturnCode r;
    r = (ReturnCode)SIGNDOC_SignatureParameters_addTextItem (&ex, p, aItem, aGroup);
    if (ex != NULL) SignDoc_throw (ex);
    return r;
  }

  ReturnCode addTextItem2 (TextItem aItem, TextGroup aGroup,
                           HAlignment aHAlignment, int aDirection)
  {
    SIGNDOC_Exception *ex = NULL;
    ReturnCode r;
    r = (ReturnCode)SIGNDOC_SignatureParameters_addTextItem2 (&ex, p, aItem, aGroup, aHAlignment, aDirection);
    if (ex != NULL) SignDoc_throw (ex);
    return r;
  }

  ReturnCode clearTextItems ()
  {
    SIGNDOC_Exception *ex = NULL;
    ReturnCode r;
    r = (ReturnCode)SIGNDOC_SignatureParameters_clearTextItems (&ex, p);
    if (ex != NULL) SignDoc_throw (ex);
    return r;
  }

  ReturnCode setTextItemDirection (TextItem aItem, HAlignment aHAlignment,
                                   int aDirection)
  {
    SIGNDOC_Exception *ex = NULL;
    ReturnCode r;
    r = (ReturnCode)SIGNDOC_SignatureParameters_setTextItemDirection (&ex, p, aItem, aHAlignment, aDirection);
    if (ex != NULL) SignDoc_throw (ex);
    return r;
  }

  ReturnCode setPKCS7 (SignPKCS7 *aPKCS7)
  {
    SIGNDOC_Exception *ex = NULL;
    ReturnCode r;
    r = (ReturnCode)SIGNDOC_SignatureParameters_setPKCS7 (&ex, p, aPKCS7 == NULL ? NULL : aPKCS7->getImpl ());
    if (ex != NULL) SignDoc_throw (ex);
    return r;
  }

  ReturnCode setRSA (SignRSA *aRSA)
  {
    SIGNDOC_Exception *ex = NULL;
    ReturnCode r;
    r = (ReturnCode)SIGNDOC_SignatureParameters_setRSA (&ex, p, aRSA == NULL ? NULL : aRSA->getImpl ());
    if (ex != NULL) SignDoc_throw (ex);
    return r;
  }

  ReturnCode setECDSA (SignECDSA *aECDSA)
  {
    SIGNDOC_Exception *ex = NULL;
    ReturnCode r;
    r = (ReturnCode)SIGNDOC_SignatureParameters_setECDSA (&ex, p, aECDSA == NULL ? NULL : aECDSA->getImpl ());
    if (ex != NULL) SignDoc_throw (ex);
    return r;
  }

  int getAvailableMethods ()
  {
    SIGNDOC_Exception *ex = NULL;
    int r;
    r = SIGNDOC_SignatureParameters_getAvailableMethods (&ex, p);
    if (ex != NULL) SignDoc_throw (ex);
    return r;
  }

  ReturnCode getTemplate (std::vector<unsigned char> &aOutput)
  {
    SIGNDOC_Exception *ex = NULL;
    SIGNDOC_ByteArray *tempOutput = NULL;
    ReturnCode r;
    try
      {
        tempOutput = SIGNDOC_ByteArray_new (&ex);
        if (ex != NULL) SignDoc_throw (ex);
        r = (ReturnCode)SIGNDOC_SignatureParameters_getTemplate (&ex, p, tempOutput);
        assignArray (aOutput, tempOutput);
      }
    catch (...)
      {
        if (tempOutput != NULL)
          SIGNDOC_ByteArray_delete (tempOutput);
        throw;
      }
    if (tempOutput != NULL)
      SIGNDOC_ByteArray_delete (tempOutput);
    if (ex != NULL) SignDoc_throw (ex);
    return r;
  }

  const char *getErrorMessage (Encoding aEncoding) const
  {
    SIGNDOC_Exception *ex = NULL;
    const char *r;
    r = SIGNDOC_SignatureParameters_getErrorMessage (&ex, p, aEncoding);
    if (ex != NULL) SignDoc_throw (ex);
    return r;
  }

  const wchar_t *getErrorMessageW () const
  {
    SIGNDOC_Exception *ex = NULL;
    const wchar_t *r;
    r = SIGNDOC_SignatureParameters_getErrorMessageW (&ex, p);
    if (ex != NULL) SignDoc_throw (ex);
    return r;
  }

private:
  SignDocSignatureParameters (const SignDocSignatureParameters &);

  SignDocSignatureParameters &operator= (const SignDocSignatureParameters &);
public:
  SignDocSignatureParameters (SIGNDOC_SignatureParameters *aP) : p (aP) { }

  SIGNDOC_SignatureParameters *getImpl () { return p; }

  const SIGNDOC_SignatureParameters *getImpl () const { return p; }

  void setImpl (SIGNDOC_SignatureParameters *aP) { SIGNDOC_SignatureParameters_delete (p); p  = aP; }

private:
  SIGNDOC_SignatureParameters *p;
};

class SignDocProperty 
{
public:

public:
  enum Type
  {
    t_string,
    t_integer,
    t_boolean
  };

public:
  SignDocProperty ()
    : p (NULL)
  {
    SIGNDOC_Exception *ex = NULL;
    p = SIGNDOC_Property_new (&ex);
    if (ex != NULL) SignDoc_throw (ex);
  }

  SignDocProperty (const SignDocProperty &aSource)
    : p (NULL)
  {
    SIGNDOC_Exception *ex = NULL;
    p = SIGNDOC_Property_clone (&ex, aSource.getImpl ());
    if (ex != NULL) SignDoc_throw (ex);
  }

  ~SignDocProperty ()
  {
    SIGNDOC_Property_delete (p);
  }

  void swap (SignDocProperty &aOther)
  {
    std::swap (p, aOther.p);
  }

  std::string getName (Encoding aEncoding) const
  {
    SIGNDOC_Exception *ex = NULL;
    std::string r;
    char *s = SIGNDOC_Property_getName (&ex, p, aEncoding);
    if (ex != NULL) SignDoc_throw (ex);
    try
      {
        r = s;
      }
    catch (...)
      {
        SIGNDOC_free (s);
        throw;
      }
    SIGNDOC_free (s);
    return r;
  }

  const char *getNameUTF8 () const
  {
    SIGNDOC_Exception *ex = NULL;
    const char *r;
    r = SIGNDOC_Property_getNameUTF8 (&ex, p);
    if (ex != NULL) SignDoc_throw (ex);
    return r;
  }

  Type getType () const
  {
    SIGNDOC_Exception *ex = NULL;
    Type r;
    r = (Type)SIGNDOC_Property_getType (&ex, p);
    if (ex != NULL) SignDoc_throw (ex);
    return r;
  }

private:
public:
  SignDocProperty (SIGNDOC_Property *aP) : p (aP) { }

  SIGNDOC_Property *getImpl () { return p; }

  const SIGNDOC_Property *getImpl () const { return p; }

  void setImpl (SIGNDOC_Property *aP) { SIGNDOC_Property_delete (p); p  = aP; }

private:
  SIGNDOC_Property *p;
};

inline void assignArray (std::vector<SignDocProperty> &aDst,
                         SIGNDOC_PropertyArray *aSrc)
{
  aDst.clear ();
  unsigned n = SIGNDOC_PropertyArray_count (aSrc);
  if (aSrc == NULL)
    return;
  aDst.resize (n);
  for (unsigned i = 0; i < n; ++i)
    {
      SIGNDOC_Exception *ex = NULL;
      SIGNDOC_Property *p = SIGNDOC_Property_clone (&ex, SIGNDOC_PropertyArray_at (aSrc, i));
      if (ex != NULL) SignDoc_throw (ex);
      aDst[i].setImpl (p);
    }
}

class SignDocAnnotation 
{
public:
  enum Type
  {
    t_unknown,              
    t_line,                 
    t_scribble,             
    t_freetext              
  };

  enum LineEnding
  {
    le_unknown,             
    le_none,                
    le_arrow                
  };

  enum HAlignment
  {
    ha_left,

    ha_center,

    ha_right
  };

  enum Flags
  {
    f_auto_alignment = 0x200,

    f_ltr = 0x1000,

    f_rtl = 0x2000,

    f_default_ltr = 0x4000,

    f_default_rtl = 0x8000
  };

  enum ReturnCode
  {
    rc_ok,                      
    rc_not_supported,           
    rc_invalid_value,           
    rc_not_available            
  };

protected:
  SignDocAnnotation ()
    : p (NULL)
  {
  }

public:
  ~SignDocAnnotation ()
  {
    SIGNDOC_Annotation_delete (p);
  }

  Type getType () const
  {
    SIGNDOC_Exception *ex = NULL;
    Type r;
    r = (Type)SIGNDOC_Annotation_getType (&ex, p);
    if (ex != NULL) SignDoc_throw (ex);
    return r;
  }

  std::string getName (Encoding aEncoding) const
  {
    SIGNDOC_Exception *ex = NULL;
    std::string r;
    char *s = SIGNDOC_Annotation_getName (&ex, p, aEncoding);
    if (ex != NULL) SignDoc_throw (ex);
    try
      {
        r = s;
      }
    catch (...)
      {
        SIGNDOC_free (s);
        throw;
      }
    SIGNDOC_free (s);
    return r;
  }

  int getPage () const
  {
    SIGNDOC_Exception *ex = NULL;
    int r;
    r = SIGNDOC_Annotation_getPage (&ex, p);
    if (ex != NULL) SignDoc_throw (ex);
    return r;
  }

  ReturnCode getBoundingBox (Rect &aOutput) const
  {
    SIGNDOC_Exception *ex = NULL;
    ReturnCode r;
    r = (ReturnCode)SIGNDOC_Annotation_getBoundingBox (&ex, p, (SIGNDOC_Rect*)&aOutput);
    if (ex != NULL) SignDoc_throw (ex);
    return r;
  }

  ReturnCode setName (Encoding aEncoding, const std::string &aName)
  {
    SIGNDOC_Exception *ex = NULL;
    ReturnCode r;
    r = (ReturnCode)SIGNDOC_Annotation_setName (&ex, p, aEncoding, aName.c_str ());
    if (ex != NULL) SignDoc_throw (ex);
    return r;
  }

  ReturnCode setName (const wchar_t *aName)
  {
    SIGNDOC_Exception *ex = NULL;
    ReturnCode r;
    r = (ReturnCode)SIGNDOC_Annotation_setNameW (&ex, p, aName);
    if (ex != NULL) SignDoc_throw (ex);
    return r;
  }

  ReturnCode setLineEnding (LineEnding aStart, LineEnding aEnd)
  {
    SIGNDOC_Exception *ex = NULL;
    ReturnCode r;
    r = (ReturnCode)SIGNDOC_Annotation_setLineEnding (&ex, p, aStart, aEnd);
    if (ex != NULL) SignDoc_throw (ex);
    return r;
  }

  ReturnCode setColor (const SignDocColor &aColor)
  {
    SIGNDOC_Exception *ex = NULL;
    ReturnCode r;
    r = (ReturnCode)SIGNDOC_Annotation_setColor (&ex, p, aColor.getImpl ());
    if (ex != NULL) SignDoc_throw (ex);
    return r;
  }

  ReturnCode setBackgroundColor (const SignDocColor &aColor)
  {
    SIGNDOC_Exception *ex = NULL;
    ReturnCode r;
    r = (ReturnCode)SIGNDOC_Annotation_setBackgroundColor (&ex, p, aColor.getImpl ());
    if (ex != NULL) SignDoc_throw (ex);
    return r;
  }

  ReturnCode setBorderColor (const SignDocColor &aColor)
  {
    SIGNDOC_Exception *ex = NULL;
    ReturnCode r;
    r = (ReturnCode)SIGNDOC_Annotation_setBorderColor (&ex, p, aColor.getImpl ());
    if (ex != NULL) SignDoc_throw (ex);
    return r;
  }

  ReturnCode setOpacity (double aOpacity)
  {
    SIGNDOC_Exception *ex = NULL;
    ReturnCode r;
    r = (ReturnCode)SIGNDOC_Annotation_setOpacity (&ex, p, aOpacity);
    if (ex != NULL) SignDoc_throw (ex);
    return r;
  }

  ReturnCode setLineWidthInPoints (double aWidth)
  {
    SIGNDOC_Exception *ex = NULL;
    ReturnCode r;
    r = (ReturnCode)SIGNDOC_Annotation_setLineWidthInPoints (&ex, p, aWidth);
    if (ex != NULL) SignDoc_throw (ex);
    return r;
  }

  ReturnCode setBorderLineWidthInPoints (double aWidth)
  {
    SIGNDOC_Exception *ex = NULL;
    ReturnCode r;
    r = (ReturnCode)SIGNDOC_Annotation_setBorderLineWidthInPoints (&ex, p, aWidth);
    if (ex != NULL) SignDoc_throw (ex);
    return r;
  }

  ReturnCode newStroke ()
  {
    SIGNDOC_Exception *ex = NULL;
    ReturnCode r;
    r = (ReturnCode)SIGNDOC_Annotation_newStroke (&ex, p);
    if (ex != NULL) SignDoc_throw (ex);
    return r;
  }

  ReturnCode addPoint (const Point &aPoint)
  {
    SIGNDOC_Exception *ex = NULL;
    ReturnCode r;
    r = (ReturnCode)SIGNDOC_Annotation_addPoint (&ex, p, (const SIGNDOC_Point*)&aPoint);
    if (ex != NULL) SignDoc_throw (ex);
    return r;
  }

  ReturnCode addPoint (double aX, double aY)
  {
    SIGNDOC_Exception *ex = NULL;
    ReturnCode r;
    r = (ReturnCode)SIGNDOC_Annotation_addPointXY (&ex, p, aX, aY);
    if (ex != NULL) SignDoc_throw (ex);
    return r;
  }

  ReturnCode setPlainText (Encoding aEncoding, const std::string &aText,
                           const std::string &aFont, double aFontSize,
                           HAlignment aHAlignment)
  {
    SIGNDOC_Exception *ex = NULL;
    ReturnCode r;
    r = (ReturnCode)SIGNDOC_Annotation_setPlainText (&ex, p, aEncoding, aText.c_str (), aFont.c_str (), aFontSize, aHAlignment);
    if (ex != NULL) SignDoc_throw (ex);
    return r;
  }

  ReturnCode getPlainText (Encoding aEncoding, std::string &aText)
  {
    SIGNDOC_Exception *ex = NULL;
    char *tempText = NULL;
    ReturnCode r;
    try
      {
        r = (ReturnCode)SIGNDOC_Annotation_getPlainText (&ex, p, aEncoding, &tempText);
        if (tempText != NULL)
          aText = tempText;
      }
    catch (...)
      {
        SIGNDOC_free (tempText);
        throw;
      }
    SIGNDOC_free (tempText);
    if (ex != NULL) SignDoc_throw (ex);
    return r;
  }

  ReturnCode getFont (Encoding aEncoding, std::string &aFont,
                      double &aFontSize)
  {
    SIGNDOC_Exception *ex = NULL;
    char *tempFont = NULL;
    ReturnCode r;
    try
      {
        r = (ReturnCode)SIGNDOC_Annotation_getFont (&ex, p, aEncoding, &tempFont, &aFontSize);
        if (tempFont != NULL)
          aFont = tempFont;
      }
    catch (...)
      {
        SIGNDOC_free (tempFont);
        throw;
      }
    SIGNDOC_free (tempFont);
    if (ex != NULL) SignDoc_throw (ex);
    return r;
  }

  ReturnCode setFlags (int aFlags)
  {
    SIGNDOC_Exception *ex = NULL;
    ReturnCode r;
    r = (ReturnCode)SIGNDOC_Annotation_setFlags (&ex, p, aFlags);
    if (ex != NULL) SignDoc_throw (ex);
    return r;
  }
  SignDocAnnotation (SIGNDOC_Annotation *aP) : p (aP) { }

  SIGNDOC_Annotation *getImpl () { return p; }

  const SIGNDOC_Annotation *getImpl () const { return p; }

  void setImpl (SIGNDOC_Annotation *aP) { SIGNDOC_Annotation_delete (p); p  = aP; }

private:
  SIGNDOC_Annotation *p;
};

class SignDocCharacterPosition 
{
public:
  int mPage;                    
  Point mRef; 
  Rect mBox;  
};

class SignDocFindTextPosition 
{
public:
  SignDocCharacterPosition mFirst;   
  SignDocCharacterPosition mLast;    
};

inline void assignArray (std::vector<SignDocFindTextPosition> &aDst,
                         SIGNDOC_FindTextPositionArray *aSrc)
{
  if (aSrc == NULL)
    aDst.clear ();
  else
    {
      unsigned n = SIGNDOC_FindTextPositionArray_count (aSrc);
      aDst.resize (n);
      for (unsigned i = 0; i < n; ++i)
        aDst[i] = *(const SignDocFindTextPosition*)SIGNDOC_FindTextPositionArray_at (aSrc, i);
    }
}

class SignDocRenderParameters 
{
public:
  enum Interlacing
  {
    i_off,

    i_on
  };

  enum Quality
  {
    q_low,

    q_high
  };

  enum PixelFormat
  {
    pf_default,

    pf_bw
  };

  enum Compression
  {
    c_default,     
    c_none,        
    c_group4,      
    c_lzw,         
    c_rle,         
    c_zip          
  };

  enum DecorationState
  {
    ds_auto,       
    ds_empty,      
    ds_ok,         
    ds_problem,    
    ds_broken      
  };

public:
  SignDocRenderParameters ()
    : p (NULL)
  {
    SIGNDOC_Exception *ex = NULL;
    p = SIGNDOC_RenderParameters_new (&ex);
    if (ex != NULL) SignDoc_throw (ex);
  }

  SignDocRenderParameters (const SignDocRenderParameters &aSource)
    : p (NULL)
  {
    SIGNDOC_Exception *ex = NULL;
    p = SIGNDOC_RenderParameters_clone (&ex, aSource.getImpl ());
    if (ex != NULL) SignDoc_throw (ex);
  }

  ~SignDocRenderParameters ()
  {
    SIGNDOC_RenderParameters_delete (p);
  }

  SignDocRenderParameters &operator= (const SignDocRenderParameters &aSource)
  {
    SIGNDOC_Exception *ex = NULL;
    SIGNDOC_RenderParameters_assign (&ex, p, aSource.getImpl ());
    if (ex != NULL) SignDoc_throw (ex);
    return *this;
  }

  bool setPage (int aPage)
  {
    SIGNDOC_Exception *ex = NULL;
    bool r;
    r = (bool)SIGNDOC_RenderParameters_setPage (&ex, p, aPage);
    if (ex != NULL) SignDoc_throw (ex);
    return r;
  }

  bool getPage (int &aPage) const
  {
    SIGNDOC_Exception *ex = NULL;
    bool r;
    r = (bool)SIGNDOC_RenderParameters_getPage (&ex, p, &aPage);
    if (ex != NULL) SignDoc_throw (ex);
    return r;
  }

  bool setPages (int aFirst, int aLast)
  {
    SIGNDOC_Exception *ex = NULL;
    bool r;
    r = (bool)SIGNDOC_RenderParameters_setPages (&ex, p, aFirst, aLast);
    if (ex != NULL) SignDoc_throw (ex);
    return r;
  }

  bool getPages (int &aFirst, int &aLast) const
  {
    SIGNDOC_Exception *ex = NULL;
    bool r;
    r = (bool)SIGNDOC_RenderParameters_getPages (&ex, p, &aFirst, &aLast);
    if (ex != NULL) SignDoc_throw (ex);
    return r;
  }

  bool setResolution (double aResX, double aResY)
  {
    SIGNDOC_Exception *ex = NULL;
    bool r;
    r = (bool)SIGNDOC_RenderParameters_setResolution (&ex, p, aResX, aResY);
    if (ex != NULL) SignDoc_throw (ex);
    return r;
  }

  bool getResolution (double &aResX, double &aResY) const
  {
    SIGNDOC_Exception *ex = NULL;
    bool r;
    r = (bool)SIGNDOC_RenderParameters_getResolution (&ex, p, &aResX, &aResY);
    if (ex != NULL) SignDoc_throw (ex);
    return r;
  }

  bool setZoom (double aZoom)
  {
    SIGNDOC_Exception *ex = NULL;
    bool r;
    r = (bool)SIGNDOC_RenderParameters_setZoom (&ex, p, aZoom);
    if (ex != NULL) SignDoc_throw (ex);
    return r;
  }

  bool getZoom (double &aZoom) const
  {
    SIGNDOC_Exception *ex = NULL;
    bool r;
    r = (bool)SIGNDOC_RenderParameters_getZoom (&ex, p, &aZoom);
    if (ex != NULL) SignDoc_throw (ex);
    return r;
  }

  bool fitWidth (int aWidth)
  {
    SIGNDOC_Exception *ex = NULL;
    bool r;
    r = (bool)SIGNDOC_RenderParameters_fitWidth (&ex, p, aWidth);
    if (ex != NULL) SignDoc_throw (ex);
    return r;
  }

  bool getFitWidth (int &aWidth) const
  {
    SIGNDOC_Exception *ex = NULL;
    bool r;
    r = (bool)SIGNDOC_RenderParameters_getFitWidth (&ex, p, &aWidth);
    if (ex != NULL) SignDoc_throw (ex);
    return r;
  }

  bool fitHeight (int aHeight)
  {
    SIGNDOC_Exception *ex = NULL;
    bool r;
    r = (bool)SIGNDOC_RenderParameters_fitHeight (&ex, p, aHeight);
    if (ex != NULL) SignDoc_throw (ex);
    return r;
  }

  bool getFitHeight (int &aHeight) const
  {
    SIGNDOC_Exception *ex = NULL;
    bool r;
    r = (bool)SIGNDOC_RenderParameters_getFitHeight (&ex, p, &aHeight);
    if (ex != NULL) SignDoc_throw (ex);
    return r;
  }

  bool fitRect (int aWidth, int aHeight)
  {
    SIGNDOC_Exception *ex = NULL;
    bool r;
    r = (bool)SIGNDOC_RenderParameters_fitRect (&ex, p, aWidth, aHeight);
    if (ex != NULL) SignDoc_throw (ex);
    return r;
  }

  bool getFitRect (int &aWidth, int &aHeight) const
  {
    SIGNDOC_Exception *ex = NULL;
    bool r;
    r = (bool)SIGNDOC_RenderParameters_getFitRect (&ex, p, &aWidth, &aHeight);
    if (ex != NULL) SignDoc_throw (ex);
    return r;
  }

  bool setFormat (const std::string &aFormat)
  {
    SIGNDOC_Exception *ex = NULL;
    bool r;
    r = (bool)SIGNDOC_RenderParameters_setFormat (&ex, p, aFormat.c_str ());
    if (ex != NULL) SignDoc_throw (ex);
    return r;
  }

  bool getFormat (std::string &aFormat) const
  {
    SIGNDOC_Exception *ex = NULL;
    char *tempFormat = NULL;
    bool r;
    try
      {
        r = (bool)SIGNDOC_RenderParameters_getFormat (&ex, p, &tempFormat);
        if (tempFormat != NULL)
          aFormat = tempFormat;
      }
    catch (...)
      {
        SIGNDOC_free (tempFormat);
        throw;
      }
    SIGNDOC_free (tempFormat);
    if (ex != NULL) SignDoc_throw (ex);
    return r;
  }

  bool setInterlacing (Interlacing aInterlacing)
  {
    SIGNDOC_Exception *ex = NULL;
    bool r;
    r = (bool)SIGNDOC_RenderParameters_setInterlacing (&ex, p, aInterlacing);
    if (ex != NULL) SignDoc_throw (ex);
    return r;
  }

  bool getInterlacing (Interlacing &aInterlacing) const
  {
    SIGNDOC_Exception *ex = NULL;
    int tempInterlacing = 0;
    bool r;
    try
      {
        r = (bool)SIGNDOC_RenderParameters_getInterlacing (&ex, p, &tempInterlacing);
        aInterlacing = (Interlacing )tempInterlacing;
      }
    catch (...)
      {
        throw;
      }
    if (ex != NULL) SignDoc_throw (ex);
    return r;
  }

  bool setQuality (Quality aQuality)
  {
    SIGNDOC_Exception *ex = NULL;
    bool r;
    r = (bool)SIGNDOC_RenderParameters_setQuality (&ex, p, aQuality);
    if (ex != NULL) SignDoc_throw (ex);
    return r;
  }

  bool getQuality (Quality &aQuality) const
  {
    SIGNDOC_Exception *ex = NULL;
    int tempQuality = 0;
    bool r;
    try
      {
        r = (bool)SIGNDOC_RenderParameters_getQuality (&ex, p, &tempQuality);
        aQuality = (Quality )tempQuality;
      }
    catch (...)
      {
        throw;
      }
    if (ex != NULL) SignDoc_throw (ex);
    return r;
  }

  bool setPixelFormat (PixelFormat aPixelFormat)
  {
    SIGNDOC_Exception *ex = NULL;
    bool r;
    r = (bool)SIGNDOC_RenderParameters_setPixelFormat (&ex, p, aPixelFormat);
    if (ex != NULL) SignDoc_throw (ex);
    return r;
  }

  bool getPixelFormat (PixelFormat &aPixelFormat) const
  {
    SIGNDOC_Exception *ex = NULL;
    int tempPixelFormat = 0;
    bool r;
    try
      {
        r = (bool)SIGNDOC_RenderParameters_getPixelFormat (&ex, p, &tempPixelFormat);
        aPixelFormat = (PixelFormat )tempPixelFormat;
      }
    catch (...)
      {
        throw;
      }
    if (ex != NULL) SignDoc_throw (ex);
    return r;
  }

  bool setCompression (Compression aCompression)
  {
    SIGNDOC_Exception *ex = NULL;
    bool r;
    r = (bool)SIGNDOC_RenderParameters_setCompression (&ex, p, aCompression);
    if (ex != NULL) SignDoc_throw (ex);
    return r;
  }

  bool getCompression (Compression &aCompression) const
  {
    SIGNDOC_Exception *ex = NULL;
    int tempCompression = 0;
    bool r;
    try
      {
        r = (bool)SIGNDOC_RenderParameters_getCompression (&ex, p, &tempCompression);
        aCompression = (Compression )tempCompression;
      }
    catch (...)
      {
        throw;
      }
    if (ex != NULL) SignDoc_throw (ex);
    return r;
  }

  bool setDecorations (bool aDecorations)
  {
    SIGNDOC_Exception *ex = NULL;
    bool r;
    r = (bool)SIGNDOC_RenderParameters_setDecorations (&ex, p, aDecorations);
    if (ex != NULL) SignDoc_throw (ex);
    return r;
  }

  bool getDecorations (bool &aDecorations) const
  {
    SIGNDOC_Exception *ex = NULL;
    SIGNDOC_Boolean tempDecorations = 0;
    bool r;
    try
      {
        r = (bool)SIGNDOC_RenderParameters_getDecorations (&ex, p, &tempDecorations);
        aDecorations = (bool )tempDecorations;
      }
    catch (...)
      {
        throw;
      }
    if (ex != NULL) SignDoc_throw (ex);
    return r;
  }

  bool setDecorationState (Encoding aEncoding, const std::string &aName,
                           DecorationState aDecorationState)
  {
    SIGNDOC_Exception *ex = NULL;
    bool r;
    r = (bool)SIGNDOC_RenderParameters_setDecorationState (&ex, p, aEncoding, aName.c_str (), aDecorationState);
    if (ex != NULL) SignDoc_throw (ex);
    return r;
  }

  bool setDecorationState (const wchar_t *aName,
                           DecorationState aDecorationState)
  {
    SIGNDOC_Exception *ex = NULL;
    bool r;
    r = (bool)SIGNDOC_RenderParameters_setDecorationStateW (&ex, p, aName, aDecorationState);
    if (ex != NULL) SignDoc_throw (ex);
    return r;
  }

  bool getDecorationState (Encoding aEncoding, const std::string &aName,
                           DecorationState &aDecorationState) const
  {
    SIGNDOC_Exception *ex = NULL;
    int tempDecorationState = 0;
    bool r;
    try
      {
        r = (bool)SIGNDOC_RenderParameters_getDecorationState (&ex, p, aEncoding, aName.c_str (), &tempDecorationState);
        aDecorationState = (DecorationState )tempDecorationState;
      }
    catch (...)
      {
        throw;
      }
    if (ex != NULL) SignDoc_throw (ex);
    return r;
  }

  bool getDecorationState (const wchar_t *aName,
                           DecorationState &aDecorationState) const
  {
    SIGNDOC_Exception *ex = NULL;
    int tempDecorationState = 0;
    bool r;
    try
      {
        r = (bool)SIGNDOC_RenderParameters_getDecorationStateW (&ex, p, aName, &tempDecorationState);
        aDecorationState = (DecorationState )tempDecorationState;
      }
    catch (...)
      {
        throw;
      }
    if (ex != NULL) SignDoc_throw (ex);
    return r;
  }
                               
  bool setPrint (bool aPrint)
  {
    SIGNDOC_Exception *ex = NULL;
    bool r;
    r = (bool)SIGNDOC_RenderParameters_setPrint (&ex, p, aPrint);
    if (ex != NULL) SignDoc_throw (ex);
    return r;
  }

  bool getPrint (bool &aPrint) const
  {
    SIGNDOC_Exception *ex = NULL;
    SIGNDOC_Boolean tempPrint = 0;
    bool r;
    try
      {
        r = (bool)SIGNDOC_RenderParameters_getPrint (&ex, p, &tempPrint);
        aPrint = (bool )tempPrint;
      }
    catch (...)
      {
        throw;
      }
    if (ex != NULL) SignDoc_throw (ex);
    return r;
  }

  bool setModificationState (bool aCheck)
  {
    SIGNDOC_Exception *ex = NULL;
    bool r;
    r = (bool)SIGNDOC_RenderParameters_setModificationState (&ex, p, aCheck);
    if (ex != NULL) SignDoc_throw (ex);
    return r;
  }

  bool getModificationState (bool &aCheck) const
  {
    SIGNDOC_Exception *ex = NULL;
    SIGNDOC_Boolean tempCheck = 0;
    bool r;
    try
      {
        r = (bool)SIGNDOC_RenderParameters_getModificationState (&ex, p, &tempCheck);
        aCheck = (bool )tempCheck;
      }
    catch (...)
      {
        throw;
      }
    if (ex != NULL) SignDoc_throw (ex);
    return r;
  }

  bool operator== (const SignDocRenderParameters &aRHS) const
  {
    SIGNDOC_Exception *ex = NULL;
    bool r;
    r = (bool)SIGNDOC_RenderParameters_equals (&ex, p, aRHS.getImpl ());
    if (ex != NULL) SignDoc_throw (ex);
    return r;
  }

private:
public:
  SignDocRenderParameters (SIGNDOC_RenderParameters *aP) : p (aP) { }

  SIGNDOC_RenderParameters *getImpl () { return p; }

  const SIGNDOC_RenderParameters *getImpl () const { return p; }

  void setImpl (SIGNDOC_RenderParameters *aP) { SIGNDOC_RenderParameters_delete (p); p  = aP; }

private:
  SIGNDOC_RenderParameters *p;
};

class SignDocRenderOutput 
{
public:
  int mWidth;

  int mHeight;
};

class SignDocAttachment 
{
public:

public:
  SignDocAttachment ()
    : p (NULL)
  {
    SIGNDOC_Exception *ex = NULL;
    p = SIGNDOC_Attachment_new (&ex);
    if (ex != NULL) SignDoc_throw (ex);
  }

  SignDocAttachment (const SignDocAttachment &aSource)
    : p (NULL)
  {
    SIGNDOC_Exception *ex = NULL;
    p = SIGNDOC_Attachment_clone (&ex, aSource.getImpl ());
    if (ex != NULL) SignDoc_throw (ex);
  }

  ~SignDocAttachment ()
  {
    SIGNDOC_Attachment_delete (p);
  }

  SignDocAttachment &operator= (const SignDocAttachment &aSource)
  {
    SIGNDOC_Exception *ex = NULL;
    SIGNDOC_Attachment_assign (&ex, p, aSource.getImpl ());
    if (ex != NULL) SignDoc_throw (ex);
    return *this;
  }

  void swap (SignDocAttachment &aOther)
  {
    std::swap (p, aOther.p);
  }

  std::string getName (Encoding aEncoding) const
  {
    SIGNDOC_Exception *ex = NULL;
    std::string r;
    char *s = SIGNDOC_Attachment_getName (&ex, p, aEncoding);
    if (ex != NULL) SignDoc_throw (ex);
    try
      {
        r = s;
      }
    catch (...)
      {
        SIGNDOC_free (s);
        throw;
      }
    SIGNDOC_free (s);
    return r;
  }

  const char *getNameUTF8 () const
  {
    SIGNDOC_Exception *ex = NULL;
    const char *r;
    r = SIGNDOC_Attachment_getNameUTF8 (&ex, p);
    if (ex != NULL) SignDoc_throw (ex);
    return r;
  }

  std::string getFileName (Encoding aEncoding) const
  {
    SIGNDOC_Exception *ex = NULL;
    std::string r;
    char *s = SIGNDOC_Attachment_getFileName (&ex, p, aEncoding);
    if (ex != NULL) SignDoc_throw (ex);
    try
      {
        r = s;
      }
    catch (...)
      {
        SIGNDOC_free (s);
        throw;
      }
    SIGNDOC_free (s);
    return r;
  }

  const char *getFileNameUTF8 () const
  {
    SIGNDOC_Exception *ex = NULL;
    const char *r;
    r = SIGNDOC_Attachment_getFileNameUTF8 (&ex, p);
    if (ex != NULL) SignDoc_throw (ex);
    return r;
  }

  std::string getDescription (Encoding aEncoding) const
  {
    SIGNDOC_Exception *ex = NULL;
    std::string r;
    char *s = SIGNDOC_Attachment_getDescription (&ex, p, aEncoding);
    if (ex != NULL) SignDoc_throw (ex);
    try
      {
        r = s;
      }
    catch (...)
      {
        SIGNDOC_free (s);
        throw;
      }
    SIGNDOC_free (s);
    return r;
  }

  const char *getDescriptionUTF8 () const
  {
    SIGNDOC_Exception *ex = NULL;
    const char *r;
    r = SIGNDOC_Attachment_getDescriptionUTF8 (&ex, p);
    if (ex != NULL) SignDoc_throw (ex);
    return r;
  }

  int getSize () const
  {
    SIGNDOC_Exception *ex = NULL;
    int r;
    r = SIGNDOC_Attachment_getSize (&ex, p);
    if (ex != NULL) SignDoc_throw (ex);
    return r;
  }

  int getCompressedSize () const
  {
    SIGNDOC_Exception *ex = NULL;
    int r;
    r = SIGNDOC_Attachment_getCompressedSize (&ex, p);
    if (ex != NULL) SignDoc_throw (ex);
    return r;
  }

  const char *getType () const
  {
    SIGNDOC_Exception *ex = NULL;
    const char *r;
    r = SIGNDOC_Attachment_getType (&ex, p);
    if (ex != NULL) SignDoc_throw (ex);
    return r;
  }

  const char *getCreationTime () const
  {
    SIGNDOC_Exception *ex = NULL;
    const char *r;
    r = SIGNDOC_Attachment_getCreationTime (&ex, p);
    if (ex != NULL) SignDoc_throw (ex);
    return r;
  }

  const char *getModificationTime () const
  {
    SIGNDOC_Exception *ex = NULL;
    const char *r;
    r = SIGNDOC_Attachment_getModificationTime (&ex, p);
    if (ex != NULL) SignDoc_throw (ex);
    return r;
  }

private:
public:
  SignDocAttachment (SIGNDOC_Attachment *aP) : p (aP) { }

  SIGNDOC_Attachment *getImpl () { return p; }

  const SIGNDOC_Attachment *getImpl () const { return p; }

  void setImpl (SIGNDOC_Attachment *aP) { SIGNDOC_Attachment_delete (p); p  = aP; }

private:
  SIGNDOC_Attachment *p;
};

class SignDocWatermark 
{
public:

  enum Justification
  {
    j_left, j_center, j_right
  };

  enum Location
  {
    l_overlay,                  
    l_underlay                  
  };

  enum HAlignment
  {
    ha_left,

    ha_center,

    ha_right
  };

  enum VAlignment
  {
    va_top,

    va_center,

    va_bottom
  };

  enum Flags
  {
    f_ltr = 0x1000,

    f_rtl = 0x2000,

    f_default_ltr = 0x4000,

    f_default_rtl = 0x8000
  };

public:
  SignDocWatermark ()
    : p (NULL)
  {
    SIGNDOC_Exception *ex = NULL;
    p = SIGNDOC_Watermark_new (&ex);
    if (ex != NULL) SignDoc_throw (ex);
  }

  SignDocWatermark (const SignDocWatermark &aSource)
    : p (NULL)
  {
    SIGNDOC_Exception *ex = NULL;
    p = SIGNDOC_Watermark_clone (&ex, aSource.getImpl ());
    if (ex != NULL) SignDoc_throw (ex);
  }

  ~SignDocWatermark ()
  {
    SIGNDOC_Watermark_delete (p);
  }

  SignDocWatermark &operator= (const SignDocWatermark &aSource)
  {
    SIGNDOC_Exception *ex = NULL;
    SIGNDOC_Watermark_assign (&ex, p, aSource.getImpl ());
    if (ex != NULL) SignDoc_throw (ex);
    return *this;
  }

  void swap (SignDocWatermark &aOther)
  {
    std::swap (p, aOther.p);
  }

  void clear ()
  {
    SIGNDOC_Exception *ex = NULL;
    SIGNDOC_Watermark_clear (&ex, p);
    if (ex != NULL) SignDoc_throw (ex);
  }

  void setText (Encoding aEncoding, const std::string &aText)
  {
    SIGNDOC_Exception *ex = NULL;
    SIGNDOC_Watermark_setText (&ex, p, aEncoding, aText.c_str ());
    if (ex != NULL) SignDoc_throw (ex);
  }

  void setFontName (Encoding aEncoding, const std::string &aFontName)
  {
    SIGNDOC_Exception *ex = NULL;
    SIGNDOC_Watermark_setFontName (&ex, p, aEncoding, aFontName.c_str ());
    if (ex != NULL) SignDoc_throw (ex);
  }

  void setFontSize (double aFontSize)
  {
    SIGNDOC_Exception *ex = NULL;
    SIGNDOC_Watermark_setFontSize (&ex, p, aFontSize);
    if (ex != NULL) SignDoc_throw (ex);
  }

  void setTextColor (const SignDocColor &aTextColor)
  {
    SIGNDOC_Exception *ex = NULL;
    SIGNDOC_Watermark_setTextColor (&ex, p, aTextColor.getImpl ());
    if (ex != NULL) SignDoc_throw (ex);
  }

  void setJustification (Justification aJustification)
  {
    SIGNDOC_Exception *ex = NULL;
    SIGNDOC_Watermark_setJustification (&ex, p, aJustification);
    if (ex != NULL) SignDoc_throw (ex);
  }

  void setRotation (double aRotation)
  {
    SIGNDOC_Exception *ex = NULL;
    SIGNDOC_Watermark_setRotation (&ex, p, aRotation);
    if (ex != NULL) SignDoc_throw (ex);
  }

  void setOpacity (double aOpacity)
  {
    SIGNDOC_Exception *ex = NULL;
    SIGNDOC_Watermark_setOpacity (&ex, p, aOpacity);
    if (ex != NULL) SignDoc_throw (ex);
  }

  void setScale (double aScale)
  {
    SIGNDOC_Exception *ex = NULL;
    SIGNDOC_Watermark_setScale (&ex, p, aScale);
    if (ex != NULL) SignDoc_throw (ex);
  }

  void setLocation (Location aLocation)
  {
    SIGNDOC_Exception *ex = NULL;
    SIGNDOC_Watermark_setLocation (&ex, p, aLocation);
    if (ex != NULL) SignDoc_throw (ex);
  }

  void setHorizontalPosition (HAlignment aAlignment, double aDistance)
  {
    SIGNDOC_Exception *ex = NULL;
    SIGNDOC_Watermark_setHorizontalPosition (&ex, p, aAlignment, aDistance);
    if (ex != NULL) SignDoc_throw (ex);
  }

  void setVerticalPosition (VAlignment aAlignment, double aDistance)
  {
    SIGNDOC_Exception *ex = NULL;
    SIGNDOC_Watermark_setVerticalPosition (&ex, p, aAlignment, aDistance);
    if (ex != NULL) SignDoc_throw (ex);
  }

  void setFirstPage (int aPage)
  {
    SIGNDOC_Exception *ex = NULL;
    SIGNDOC_Watermark_setFirstPage (&ex, p, aPage);
    if (ex != NULL) SignDoc_throw (ex);
  }

  void setLastPage (int aPage)
  {
    SIGNDOC_Exception *ex = NULL;
    SIGNDOC_Watermark_setLastPage (&ex, p, aPage);
    if (ex != NULL) SignDoc_throw (ex);
  }

  void setPageIncrement (int aIncr)
  {
    SIGNDOC_Exception *ex = NULL;
    SIGNDOC_Watermark_setPageIncrement (&ex, p, aIncr);
    if (ex != NULL) SignDoc_throw (ex);
  }

  void setFlags (int aFlags)
  {
    SIGNDOC_Exception *ex = NULL;
    SIGNDOC_Watermark_setFlags (&ex, p, aFlags);
    if (ex != NULL) SignDoc_throw (ex);
  }

private:
public:
  SignDocWatermark (SIGNDOC_Watermark *aP) : p (aP) { }

  SIGNDOC_Watermark *getImpl () { return p; }

  const SIGNDOC_Watermark *getImpl () const { return p; }

  void setImpl (SIGNDOC_Watermark *aP) { SIGNDOC_Watermark_delete (p); p  = aP; }

private:
  SIGNDOC_Watermark *p;
};

class SignDocVerificationParameters 
{
public:
  enum CertificateChainVerificationPolicy
  {
    ccvp_dont_verify,

    ccvp_accept_self_signed,

    ccvp_accept_self_signed_with_bio,

    ccvp_accept_self_signed_with_rsa_bio,

    ccvp_require_trusted_root
  };

  enum CertificateRevocationVerificationPolicy
  {
    crvp_dont_check,

    crvp_offline,

    crvp_online
  };

  enum VerificationFlags
  {
    vf_check_revocation = 0x01,

    vf_use_crl_only = 0x02,

    vf_use_ocsp_only = 0x04,

    vf_offline = 0x08,

    vf_enforce_next_update = 0x10,

    vf_enforce_ocsp_signer = 0x20,

    vf_online = 0x40,

    vf_no_ocsp_nonce = 0x80,

    vf_crl_first = 0x100,

    vf_ignore_no_revocation = 0x200
  };

  enum VerificationModel
  {
    vm_minimal,

    vm_chain,

    vm_modified_shell,

    vm_shell
  };

  enum ReturnCode
  {
    rc_ok,                      
    rc_unknown,                 
    rc_not_supported,           
    rc_invalid_value            
  };

public:
  SignDocVerificationParameters ()
    : p (NULL)
  {
    SIGNDOC_Exception *ex = NULL;
    p = SIGNDOC_VerificationParameters_new (&ex);
    if (ex != NULL) SignDoc_throw (ex);
  }

  SignDocVerificationParameters (const SignDocVerificationParameters &aSource)
    : p (NULL)
  {
    SIGNDOC_Exception *ex = NULL;
    p = SIGNDOC_VerificationParameters_clone (&ex, aSource.getImpl ());
    if (ex != NULL) SignDoc_throw (ex);
  }

  ~SignDocVerificationParameters ()
  {
    SIGNDOC_VerificationParameters_delete (p);
  }

  SignDocVerificationParameters &operator= (const SignDocVerificationParameters &aSource)
  {
    SIGNDOC_Exception *ex = NULL;
    SIGNDOC_VerificationParameters_assign (&ex, p, aSource.getImpl ());
    if (ex != NULL) SignDoc_throw (ex);
    return *this;
  }

  bool operator== (const SignDocVerificationParameters &aRHS) const
  {
    SIGNDOC_Exception *ex = NULL;
    bool r;
    r = (bool)SIGNDOC_VerificationParameters_equals (&ex, p, aRHS.getImpl ());
    if (ex != NULL) SignDoc_throw (ex);
    return r;
  }

  void setForUpdateDSS ()
  {
    SIGNDOC_Exception *ex = NULL;
    SIGNDOC_VerificationParameters_setForUpdateDSS (&ex, p);
    if (ex != NULL) SignDoc_throw (ex);
  }

  ReturnCode setString (Encoding aEncoding, const std::string &aName,
                        const std::string &aValue)
  {
    SIGNDOC_Exception *ex = NULL;
    ReturnCode r;
    r = (ReturnCode)SIGNDOC_VerificationParameters_setString (&ex, p, aEncoding, aName.c_str (), aValue.c_str ());
    if (ex != NULL) SignDoc_throw (ex);
    return r;
  }

  ReturnCode setString (const std::string &aName, const wchar_t *aValue)
  {
    SIGNDOC_Exception *ex = NULL;
    ReturnCode r;
    r = (ReturnCode)SIGNDOC_VerificationParameters_setStringW (&ex, p, aName.c_str (), aValue);
    if (ex != NULL) SignDoc_throw (ex);
    return r;
  }

  ReturnCode setInteger (const std::string &aName, int aValue)
  {
    SIGNDOC_Exception *ex = NULL;
    ReturnCode r;
    r = (ReturnCode)SIGNDOC_VerificationParameters_setInteger (&ex, p, aName.c_str (), aValue);
    if (ex != NULL) SignDoc_throw (ex);
    return r;
  }

  ReturnCode setBlob (const std::string &aName, const unsigned char *aData,
                      size_t aSize)
  {
    SIGNDOC_Exception *ex = NULL;
    ReturnCode r;
    r = (ReturnCode)SIGNDOC_VerificationParameters_setBlob (&ex, p, aName.c_str (), aData, aSize);
    if (ex != NULL) SignDoc_throw (ex);
    return r;
  }

  const char *getErrorMessage (Encoding aEncoding) const
  {
    SIGNDOC_Exception *ex = NULL;
    const char *r;
    r = SIGNDOC_VerificationParameters_getErrorMessage (&ex, p, aEncoding);
    if (ex != NULL) SignDoc_throw (ex);
    return r;
  }

  const wchar_t *getErrorMessageW () const
  {
    SIGNDOC_Exception *ex = NULL;
    const wchar_t *r;
    r = SIGNDOC_VerificationParameters_getErrorMessageW (&ex, p);
    if (ex != NULL) SignDoc_throw (ex);
    return r;
  }

private:
public:
  SignDocVerificationParameters (SIGNDOC_VerificationParameters *aP) : p (aP) { }

  SIGNDOC_VerificationParameters *getImpl () { return p; }

  const SIGNDOC_VerificationParameters *getImpl () const { return p; }

  void setImpl (SIGNDOC_VerificationParameters *aP) { SIGNDOC_VerificationParameters_delete (p); p  = aP; }

private:
  SIGNDOC_VerificationParameters *p;
};

class SignDocChange 
{
public:
  enum Type
  {
    t_other,

    t_field_added,

    t_field_removed,

    t_field_modified,

    t_field_filled_in,

    t_annotation_added,

    t_annotation_removed,

    t_annotation_modified,

    t_attachment_added,

    t_attachment_removed,

    t_attachment_modified,

    t_page_added,

    t_page_removed,

    t_page_modified
  };

public:
  ~SignDocChange ()
  {
    SIGNDOC_Change_delete (p);
  }

  Type getType () const
  {
    SIGNDOC_Exception *ex = NULL;
    Type r;
    r = (Type)SIGNDOC_Change_getType (&ex, p);
    if (ex != NULL) SignDoc_throw (ex);
    return r;
  }

  std::string getName (Encoding aEncoding) const
  {
    SIGNDOC_Exception *ex = NULL;
    std::string r;
    char *s = SIGNDOC_Change_getName (&ex, p, aEncoding);
    if (ex != NULL) SignDoc_throw (ex);
    try
      {
        r = s;
      }
    catch (...)
      {
        SIGNDOC_free (s);
        throw;
      }
    SIGNDOC_free (s);
    return r;
  }

  const char *getNameUTF8 () const
  {
    SIGNDOC_Exception *ex = NULL;
    const char *r;
    r = SIGNDOC_Change_getNameUTF8 (&ex, p);
    if (ex != NULL) SignDoc_throw (ex);
    return r;
  }

  int getPage () const
  {
    SIGNDOC_Exception *ex = NULL;
    int r;
    r = SIGNDOC_Change_getPage (&ex, p);
    if (ex != NULL) SignDoc_throw (ex);
    return r;
  }

  SignDocField::Type getFieldType () const
  {
    SIGNDOC_Exception *ex = NULL;
    SignDocField::Type r;
    r = (SignDocField::Type)SIGNDOC_Change_getFieldType (&ex, p);
    if (ex != NULL) SignDoc_throw (ex);
    return r;
  }

  const char *getAnnotationType () const
  {
    SIGNDOC_Exception *ex = NULL;
    const char *r;
    r = SIGNDOC_Change_getAnnotationType (&ex, p);
    if (ex != NULL) SignDoc_throw (ex);
    return r;
  }

protected:
  SignDocChange ()
    : p (NULL)
  {
  }

public:
  SignDocChange (SIGNDOC_Change *aP) : p (aP) { }

  SIGNDOC_Change *getImpl () { return p; }

  const SIGNDOC_Change *getImpl () const { return p; }

  void setImpl (SIGNDOC_Change *aP) { SIGNDOC_Change_delete (p); p  = aP; }

private:
  SIGNDOC_Change *p;
};

class SignDocSignature 
{
public:
  ~SignDocSignature ()
  {
    SIGNDOC_Signature_delete (p);
  }

  std::string getFieldName (Encoding aEncoding) const
  {
    SIGNDOC_Exception *ex = NULL;
    std::string r;
    char *s = SIGNDOC_Signature_getFieldName (&ex, p, aEncoding);
    if (ex != NULL) SignDoc_throw (ex);
    try
      {
        r = s;
      }
    catch (...)
      {
        SIGNDOC_free (s);
        throw;
      }
    SIGNDOC_free (s);
    return r;
  }

  const char *getFieldNameUTF8 () const
  {
    SIGNDOC_Exception *ex = NULL;
    const char *r;
    r = SIGNDOC_Signature_getFieldNameUTF8 (&ex, p);
    if (ex != NULL) SignDoc_throw (ex);
    return r;
  }

  int getFieldPage () const
  {
    SIGNDOC_Exception *ex = NULL;
    int r;
    r = SIGNDOC_Signature_getFieldPage (&ex, p);
    if (ex != NULL) SignDoc_throw (ex);
    return r;
  }

  SignDocField::SignatureType getSignatureType () const
  {
    SIGNDOC_Exception *ex = NULL;
    SignDocField::SignatureType r;
    r = (SignDocField::SignatureType)SIGNDOC_Signature_getSignatureType (&ex, p);
    if (ex != NULL) SignDoc_throw (ex);
    return r;
  }

  int getClearedIndex () const
  {
    SIGNDOC_Exception *ex = NULL;
    int r;
    r = SIGNDOC_Signature_getClearedIndex (&ex, p);
    if (ex != NULL) SignDoc_throw (ex);
    return r;
  }

  int getDocMDP () const
  {
    SIGNDOC_Exception *ex = NULL;
    int r;
    r = SIGNDOC_Signature_getDocMDP (&ex, p);
    if (ex != NULL) SignDoc_throw (ex);
    return r;
  }

  int getLockMDP () const
  {
    SIGNDOC_Exception *ex = NULL;
    int r;
    r = SIGNDOC_Signature_getLockMDP (&ex, p);
    if (ex != NULL) SignDoc_throw (ex);
    return r;
  }

  bool getSigningCertificate (std::vector<unsigned char> &aOutput) const
  {
    SIGNDOC_Exception *ex = NULL;
    SIGNDOC_ByteArray *tempOutput = NULL;
    bool r;
    try
      {
        tempOutput = SIGNDOC_ByteArray_new (&ex);
        if (ex != NULL) SignDoc_throw (ex);
        r = (bool)SIGNDOC_Signature_getSigningCertificate (&ex, p, tempOutput);
        assignArray (aOutput, tempOutput);
      }
    catch (...)
      {
        if (tempOutput != NULL)
          SIGNDOC_ByteArray_delete (tempOutput);
        throw;
      }
    if (tempOutput != NULL)
      SIGNDOC_ByteArray_delete (tempOutput);
    if (ex != NULL) SignDoc_throw (ex);
    return r;
  }

  std::string getSignerCommonName (Encoding aEncoding) const
  {
    SIGNDOC_Exception *ex = NULL;
    std::string r;
    char *s = SIGNDOC_Signature_getSignerCommonName (&ex, p, aEncoding);
    if (ex != NULL) SignDoc_throw (ex);
    try
      {
        r = s;
      }
    catch (...)
      {
        SIGNDOC_free (s);
        throw;
      }
    SIGNDOC_free (s);
    return r;
  }

  const char *getSignerCommonNameUTF8 () const
  {
    SIGNDOC_Exception *ex = NULL;
    const char *r;
    r = SIGNDOC_Signature_getSignerCommonNameUTF8 (&ex, p);
    if (ex != NULL) SignDoc_throw (ex);
    return r;
  }

  std::string getSignerEmail (Encoding aEncoding) const
  {
    SIGNDOC_Exception *ex = NULL;
    std::string r;
    char *s = SIGNDOC_Signature_getSignerEmail (&ex, p, aEncoding);
    if (ex != NULL) SignDoc_throw (ex);
    try
      {
        r = s;
      }
    catch (...)
      {
        SIGNDOC_free (s);
        throw;
      }
    SIGNDOC_free (s);
    return r;
  }

  const char *getSignerEmailUTF8 () const
  {
    SIGNDOC_Exception *ex = NULL;
    const char *r;
    r = SIGNDOC_Signature_getSignerEmailUTF8 (&ex, p);
    if (ex != NULL) SignDoc_throw (ex);
    return r;
  }

  const char *getTimeStamp () const
  {
    SIGNDOC_Exception *ex = NULL;
    const char *r;
    r = SIGNDOC_Signature_getTimeStamp (&ex, p);
    if (ex != NULL) SignDoc_throw (ex);
    return r;
  }

  int getChangeCount () const
  {
    SIGNDOC_Exception *ex = NULL;
    int r;
    r = SIGNDOC_Signature_getChangeCount (&ex, p);
    if (ex != NULL) SignDoc_throw (ex);
    return r;
  }

  bool getChange (int aIndex, SIGNDOC_PTR<SignDocChange> &aOutput) const
  {
    SIGNDOC_Exception *ex = NULL;
    SIGNDOC_Change *tempOutput = NULL;
    aOutput.reset ((SignDocChange*)NULL);
    bool r;
    try
      {
        r = (bool)SIGNDOC_Signature_getChange (&ex, p, aIndex, &tempOutput);
        if (tempOutput != NULL)
          {
            aOutput.reset (new SignDocChange (tempOutput));
            tempOutput = NULL;
          }
      }
    catch (...)
      {
        if (tempOutput != NULL)
          SIGNDOC_Change_delete (tempOutput);
        throw;
      }
    if (tempOutput != NULL)
      SIGNDOC_Change_delete (tempOutput);
    if (ex != NULL) SignDoc_throw (ex);
    return r;
  }

  int getBiometricEncryption () const
  {
    SIGNDOC_Exception *ex = NULL;
    int r;
    r = SIGNDOC_Signature_getBiometricEncryption (&ex, p);
    if (ex != NULL) SignDoc_throw (ex);
    return r;
  }

protected:
  SignDocSignature ()
    : p (NULL)
  {
  }

private:
  // cppcheck-suppress noExplicitCopyMoveConstructor
  SignDocSignature (const SignDocSignature &);

  SignDocSignature &operator= (const SignDocSignature &);
public:
  SignDocSignature (SIGNDOC_Signature *aP) : p (aP) { }

  SIGNDOC_Signature *getImpl () { return p; }

  const SIGNDOC_Signature *getImpl () const { return p; }

  void setImpl (SIGNDOC_Signature *aP) { SIGNDOC_Signature_delete (p); p  = aP; }

private:
  SIGNDOC_Signature *p;
};

class SignDocDocument 
{
public:
  enum DocumentType
  {
    dt_unknown,                 
    dt_pdf,                     
    dt_tiff,                    
    dt_other,                   
    dt_fdf                      
  };

  enum SaveFlags
  {
    sf_incremental   = 0x01,

    sf_remove_unused = 0x02,

    sf_linearized    = 0x04,

    sf_pdf_1_4       = 0x08,

    sf_pdfa_buttons  = 0x10,

    sf_auto_incremental = 0x20
  };

  enum CopyToStreamFlags
  {
    ctsf_unsaved = 0x01
  };

  enum SetFieldFlags
  {
    sff_font_fail    = 0x01,

    sff_move = 0x08,

    sff_keep_ap = 0x10,

    sff_update_ap = 0x20,

    sff_fit_height_only = 0x40,

    sff_force_border_width = 0x80,

    sff_dont_break_lines = 0x100,

    sff_auto_alignment = 0x200,

    sff_ltr = 0x1000,

    sff_rtl = 0x2000,

    sff_default_ltr = 0x4000,

    sff_default_rtl = 0x8000
  };

  enum FlattenFieldsFlags
  {
    fff_include_signature_unsigned      = 0x01,

    fff_include_signature_signed        = 0x02,

    fff_include_hidden                  = 0x04,

    fff_keep_structure                  = 0x08
  };

  enum FlattenAnnotationsFlags
  {
    faf_include_hidden                  = 0x04,

    faf_keep_structure                  = 0x08
  };

  enum FindTextFlags
  {
    ftf_ignore_hspace      = 0x0001,  
    ftf_ignore_hyphenation = 0x0002,  
    ftf_ignore_sequence    = 0x0004   
  };

  enum ExportFlags
  {
    e_top = 0x01  
  };

  enum ImportFlags
  {
    i_atomic = 0x01  
  };

  enum ImportImageFlags
  {
    ii_keep_aspect_ratio = 0x01,

    ii_brightest_transparent = 0x02
  };

  enum KeepOrRemove
  {
    kor_keep,                   
    kor_remove                  
  };

  enum ReturnCode
  {
    rc_ok,                    
    rc_invalid_argument,      
    rc_field_not_found,       
    rc_invalid_profile,       
    rc_invalid_image,         
    rc_type_mismatch,         
    rc_font_not_found,        
    rc_no_datablock,          
    rc_not_supported,         
    rc_io_error,              
    rc_not_verified,          
    rc_property_not_found,    
    rc_page_not_found,        
    rc_wrong_collection,      
    rc_field_exists,          
    rc_license_error,         
    rc_unexpected_error,      
    rc_cancelled,             
    rc_no_biometric_data,     
    rc_parameter_not_set,     
    rc_field_not_signed,      
    rc_invalid_signature,     
    rc_annotation_not_found,  
    rc_attachment_not_found,  
    rc_attachment_exists,     
    rc_no_certificate,        
    rc_ambiguous_certificate, 
    rc_not_allowed            
  };

  enum CheckAttachmentResult
  {
    car_match,                  
    car_no_checksum,            
    car_mismatch                
  };

  enum HAlignment
  {
    ha_left,

    ha_center,

    ha_right,

    ha_do_not_uses_this,

    ha_auto
  };

  enum VAlignment
  {
    va_top,

    va_center,

    va_bottom
  };

  enum AddTextRectFlags
  {
    atrf_compat = 0x01,

    atrf_ltr = 0x1000,

    atrf_rtl = 0x2000,

    atrf_default_ltr = 0x4000,

    atrf_default_rtl = 0x8000
  };

  enum Flags
  {
    f_relax_byte_range = 0x01,

    f_ambiguous_button_value_empty = 0x02,

    f_use_dss_only = 0x04,

    f_no_kerning_for_standard_fonts = 0x08,

    f_prevent_breaking_tagged_pdf = 0x10
  };

  enum ShootInFootFlags
  {
    siff_allow_breaking_signatures  = 0x01,

    siff_allow_breaking_permissions = 0x02,

    siff_allow_invalid_certificate  = 0x04,

    siff_allow_non_standard_external_fonts = 0x08,

    siff_assume_ap_not_shared = 0x10,

    siff_assume_ap_shared = 0x20,

    siff_dont_verify_after_signing = 0x40,

    siff_allow_all_curves = 0x80
  };

  enum UpdateDSSFlags
  {
    udf_simulate = 0x01,

    udf_vri      = 0x02
  };

  SignDocDocument ()
    : p (NULL)
  {
  }

  ~SignDocDocument ()
  {
    SIGNDOC_Document_delete (p);
  }

  DocumentType getType () const
  {
    SIGNDOC_Exception *ex = NULL;
    DocumentType r;
    r = (DocumentType)SIGNDOC_Document_getType (&ex, p);
    if (ex != NULL) SignDoc_throw (ex);
    return r;
  }

  int getPageCount () const
  {
    SIGNDOC_Exception *ex = NULL;
    int r;
    r = SIGNDOC_Document_getPageCount (&ex, p);
    if (ex != NULL) SignDoc_throw (ex);
    return r;
  }

  ReturnCode createSignatureParameters (Encoding aEncoding,
                                        const std::string &aFieldName,
                                        const std::string &aProfile,
                                        SIGNDOC_PTR<SignDocSignatureParameters> &aOutput)
  {
    SIGNDOC_Exception *ex = NULL;
    SIGNDOC_SignatureParameters *tempOutput = NULL;
    aOutput.reset ((SignDocSignatureParameters*)NULL);
    ReturnCode r;
    try
      {
        r = (ReturnCode)SIGNDOC_Document_createSignatureParameters (&ex, p, aEncoding, aFieldName.c_str (), aProfile.c_str (), &tempOutput);
        if (tempOutput != NULL)
          {
            aOutput.reset (new SignDocSignatureParameters (tempOutput));
            tempOutput = NULL;
          }
      }
    catch (...)
      {
        if (tempOutput != NULL)
          SIGNDOC_SignatureParameters_delete (tempOutput);
        throw;
      }
    if (tempOutput != NULL)
      SIGNDOC_SignatureParameters_delete (tempOutput);
    if (ex != NULL) SignDoc_throw (ex);
    return r;
  }

  ReturnCode createSignatureParameters (const wchar_t *aFieldName,
                                        const wchar_t *aProfile,
                                        SIGNDOC_PTR<SignDocSignatureParameters> &aOutput)
  {
    SIGNDOC_Exception *ex = NULL;
    SIGNDOC_SignatureParameters *tempOutput = NULL;
    aOutput.reset ((SignDocSignatureParameters*)NULL);
    ReturnCode r;
    try
      {
        r = (ReturnCode)SIGNDOC_Document_createSignatureParametersW (&ex, p, aFieldName, aProfile, &tempOutput);
        if (tempOutput != NULL)
          {
            aOutput.reset (new SignDocSignatureParameters (tempOutput));
            tempOutput = NULL;
          }
      }
    catch (...)
      {
        if (tempOutput != NULL)
          SIGNDOC_SignatureParameters_delete (tempOutput);
        throw;
      }
    if (tempOutput != NULL)
      SIGNDOC_SignatureParameters_delete (tempOutput);
    if (ex != NULL) SignDoc_throw (ex);
    return r;
  }

  ReturnCode createSignatureParametersForTimeStamp (SIGNDOC_PTR<SignDocSignatureParameters> &aOutput)
  {
    SIGNDOC_Exception *ex = NULL;
    SIGNDOC_SignatureParameters *tempOutput = NULL;
    aOutput.reset ((SignDocSignatureParameters*)NULL);
    ReturnCode r;
    try
      {
        r = (ReturnCode)SIGNDOC_Document_createSignatureParametersForTimeStamp (&ex, p, &tempOutput);
        if (tempOutput != NULL)
          {
            aOutput.reset (new SignDocSignatureParameters (tempOutput));
            tempOutput = NULL;
          }
      }
    catch (...)
      {
        if (tempOutput != NULL)
          SIGNDOC_SignatureParameters_delete (tempOutput);
        throw;
      }
    if (tempOutput != NULL)
      SIGNDOC_SignatureParameters_delete (tempOutput);
    if (ex != NULL) SignDoc_throw (ex);
    return r;
  }

  ReturnCode getProfiles (Encoding aEncoding, const std::string &aFieldName,
                          std::vector<std::string> &aOutput)
  {
    SIGNDOC_Exception *ex = NULL;
    SIGNDOC_StringArray *tempOutput = NULL;
    ReturnCode r;
    try
      {
        tempOutput = SIGNDOC_StringArray_new (&ex);
        if (ex != NULL) SignDoc_throw (ex);
        r = (ReturnCode)SIGNDOC_Document_getProfiles (&ex, p, aEncoding, aFieldName.c_str (), tempOutput);
        assignArray (aOutput, tempOutput);
      }
    catch (...)
      {
        if (tempOutput != NULL)
          SIGNDOC_StringArray_delete (tempOutput);
        throw;
      }
    if (tempOutput != NULL)
      SIGNDOC_StringArray_delete (tempOutput);
    if (ex != NULL) SignDoc_throw (ex);
    return r;
  }

  ReturnCode addSignature (SignDocSignatureParameters *aSignatureParameters,
                           const SignDocVerificationParameters *aVerificationParameters)
  {
    SIGNDOC_Exception *ex = NULL;
    ReturnCode r;
    r = (ReturnCode)SIGNDOC_Document_addSignature (&ex, p, aSignatureParameters == NULL ? NULL : aSignatureParameters->getImpl (), aVerificationParameters == NULL ? NULL : aVerificationParameters->getImpl ());
    if (ex != NULL) SignDoc_throw (ex);
    return r;
  }

  ReturnCode getLastTimestamp (std::string &aTime)
  {
    SIGNDOC_Exception *ex = NULL;
    char *tempTime = NULL;
    ReturnCode r;
    try
      {
        r = (ReturnCode)SIGNDOC_Document_getLastTimestamp (&ex, p, &tempTime);
        if (tempTime != NULL)
          aTime = tempTime;
      }
    catch (...)
      {
        SIGNDOC_free (tempTime);
        throw;
      }
    SIGNDOC_free (tempTime);
    if (ex != NULL) SignDoc_throw (ex);
    return r;
  }

  ReturnCode getPathname (Encoding aEncoding, std::string &aPath)
  {
    SIGNDOC_Exception *ex = NULL;
    char *tempPath = NULL;
    ReturnCode r;
    try
      {
        r = (ReturnCode)SIGNDOC_Document_getPathname (&ex, p, aEncoding, &tempPath);
        if (tempPath != NULL)
          aPath = tempPath;
      }
    catch (...)
      {
        SIGNDOC_free (tempPath);
        throw;
      }
    SIGNDOC_free (tempPath);
    if (ex != NULL) SignDoc_throw (ex);
    return r;
  }

  int getAvailableMethods ()
  {
    SIGNDOC_Exception *ex = NULL;
    int r;
    r = SIGNDOC_Document_getAvailableMethods (&ex, p);
    if (ex != NULL) SignDoc_throw (ex);
    return r;
  }

  int getSignatureCount ()
  {
    SIGNDOC_Exception *ex = NULL;
    int r;
    r = SIGNDOC_Document_getSignatureCount (&ex, p);
    if (ex != NULL) SignDoc_throw (ex);
    return r;
  }

  ReturnCode getSignature (int aIndex, SIGNDOC_PTR<SignDocSignature> &aOutput)
  {
    SIGNDOC_Exception *ex = NULL;
    SIGNDOC_Signature *tempOutput = NULL;
    aOutput.reset ((SignDocSignature*)NULL);
    ReturnCode r;
    try
      {
        r = (ReturnCode)SIGNDOC_Document_getSignature (&ex, p, aIndex, &tempOutput);
        if (tempOutput != NULL)
          {
            aOutput.reset (new SignDocSignature (tempOutput));
            tempOutput = NULL;
          }
      }
    catch (...)
      {
        if (tempOutput != NULL)
          SIGNDOC_Signature_delete (tempOutput);
        throw;
      }
    if (tempOutput != NULL)
      SIGNDOC_Signature_delete (tempOutput);
    if (ex != NULL) SignDoc_throw (ex);
    return r;
  }

  ReturnCode verifySignature (Encoding aEncoding,
                              const std::string &aFieldName,
                              SIGNDOC_PTR<SignDocVerificationResult> &aOutput)
  {
    SIGNDOC_Exception *ex = NULL;
    SIGNDOC_VerificationResult *tempOutput = NULL;
    aOutput.reset ((SignDocVerificationResult*)NULL);
    ReturnCode r;
    try
      {
        r = (ReturnCode)SIGNDOC_Document_verifySignature (&ex, p, aEncoding, aFieldName.c_str (), &tempOutput);
        if (tempOutput != NULL)
          {
            aOutput.reset (makeSignDocVerificationResult (tempOutput));
            tempOutput = NULL;
          }
      }
    catch (...)
      {
        if (tempOutput != NULL)
          SIGNDOC_VerificationResult_delete (tempOutput);
        throw;
      }
    if (tempOutput != NULL)
      SIGNDOC_VerificationResult_delete (tempOutput);
    if (ex != NULL) SignDoc_throw (ex);
    return r;
  }

  ReturnCode verifySignature (const wchar_t *aFieldName,
                              SIGNDOC_PTR<SignDocVerificationResult> &aOutput)
  {
    SIGNDOC_Exception *ex = NULL;
    SIGNDOC_VerificationResult *tempOutput = NULL;
    aOutput.reset ((SignDocVerificationResult*)NULL);
    ReturnCode r;
    try
      {
        r = (ReturnCode)SIGNDOC_Document_verifySignatureW (&ex, p, aFieldName, &tempOutput);
        if (tempOutput != NULL)
          {
            aOutput.reset (makeSignDocVerificationResult (tempOutput));
            tempOutput = NULL;
          }
      }
    catch (...)
      {
        if (tempOutput != NULL)
          SIGNDOC_VerificationResult_delete (tempOutput);
        throw;
      }
    if (tempOutput != NULL)
      SIGNDOC_VerificationResult_delete (tempOutput);
    if (ex != NULL) SignDoc_throw (ex);
    return r;
  }

  ReturnCode verifySignature2 (const SignDocSignature &aSignature,
                               SIGNDOC_PTR<SignDocVerificationResult> &aOutput)
  {
    SIGNDOC_Exception *ex = NULL;
    SIGNDOC_VerificationResult *tempOutput = NULL;
    aOutput.reset ((SignDocVerificationResult*)NULL);
    ReturnCode r;
    try
      {
        r = (ReturnCode)SIGNDOC_Document_verifySignature2 (&ex, p, aSignature.getImpl (), &tempOutput);
        if (tempOutput != NULL)
          {
            aOutput.reset (makeSignDocVerificationResult (tempOutput));
            tempOutput = NULL;
          }
      }
    catch (...)
      {
        if (tempOutput != NULL)
          SIGNDOC_VerificationResult_delete (tempOutput);
        throw;
      }
    if (tempOutput != NULL)
      SIGNDOC_VerificationResult_delete (tempOutput);
    if (ex != NULL) SignDoc_throw (ex);
    return r;
  }

  ReturnCode clearSignature (Encoding aEncoding, const std::string &aFieldName)
  {
    SIGNDOC_Exception *ex = NULL;
    ReturnCode r;
    r = (ReturnCode)SIGNDOC_Document_clearSignature (&ex, p, aEncoding, aFieldName.c_str ());
    if (ex != NULL) SignDoc_throw (ex);
    return r;
  }

  ReturnCode clearAllSignatures ()
  {
    SIGNDOC_Exception *ex = NULL;
    ReturnCode r;
    r = (ReturnCode)SIGNDOC_Document_clearAllSignatures (&ex, p);
    if (ex != NULL) SignDoc_throw (ex);
    return r;
  }

  ReturnCode clearApprovalSignatures ()
  {
    SIGNDOC_Exception *ex = NULL;
    ReturnCode r;
    r = (ReturnCode)SIGNDOC_Document_clearApprovalSignatures (&ex, p);
    if (ex != NULL) SignDoc_throw (ex);
    return r;
  }

  ReturnCode updateDSS (const SignDocVerificationParameters *aParameters,
                        unsigned aFlags, int &aCount)
  {
    SIGNDOC_Exception *ex = NULL;
    ReturnCode r;
    r = (ReturnCode)SIGNDOC_Document_updateDSS (&ex, p, aParameters == NULL ? NULL : aParameters->getImpl (), aFlags, &aCount);
    if (ex != NULL) SignDoc_throw (ex);
    return r;
  }

  ReturnCode updateDSS2 (Encoding aEncoding, const std::string &aFieldName,
                         const SignDocVerificationParameters *aParameters,
                         unsigned aFlags)
  {
    SIGNDOC_Exception *ex = NULL;
    ReturnCode r;
    r = (ReturnCode)SIGNDOC_Document_updateDSS2 (&ex, p, aEncoding, aFieldName.c_str (), aParameters == NULL ? NULL : aParameters->getImpl (), aFlags);
    if (ex != NULL) SignDoc_throw (ex);
    return r;
  }

  ReturnCode saveToStream (OutputStream &aStream, int aFlags)
  {
    SIGNDOC_Exception *ex = NULL;
    ReturnCode r;
    r = (ReturnCode)SIGNDOC_Document_saveToStream (&ex, p, aStream.getImpl (), aFlags);
    if (ex != NULL) SignDoc_throw (ex);
    return r;
  }

  ReturnCode saveToFile (Encoding aEncoding, const char *aPath, int aFlags)
  {
    SIGNDOC_Exception *ex = NULL;
    ReturnCode r;
    r = (ReturnCode)SIGNDOC_Document_saveToFile (&ex, p, aEncoding, aPath, aFlags);
    if (ex != NULL) SignDoc_throw (ex);
    return r;
  }

  ReturnCode saveToFile (const wchar_t *aPath, int aFlags)
  {
    SIGNDOC_Exception *ex = NULL;
    ReturnCode r;
    r = (ReturnCode)SIGNDOC_Document_saveToFileW (&ex, p, aPath, aFlags);
    if (ex != NULL) SignDoc_throw (ex);
    return r;
  }

  ReturnCode copyToStream (OutputStream &aStream, unsigned aFlags)
  {
    SIGNDOC_Exception *ex = NULL;
    ReturnCode r;
    r = (ReturnCode)SIGNDOC_Document_copyToStream (&ex, p, aStream.getImpl (), aFlags);
    if (ex != NULL) SignDoc_throw (ex);
    return r;
  }

  ReturnCode copyAsSignedToStream (Encoding aEncoding,
                                   const std::string &aFieldName,
                                   OutputStream &aStream)
  {
    SIGNDOC_Exception *ex = NULL;
    ReturnCode r;
    r = (ReturnCode)SIGNDOC_Document_copyAsSignedToStream (&ex, p, aEncoding, aFieldName.c_str (), aStream.getImpl ());
    if (ex != NULL) SignDoc_throw (ex);
    return r;
  }

  ReturnCode getSaveToStreamFlags (int &aOutput)
  {
    SIGNDOC_Exception *ex = NULL;
    ReturnCode r;
    r = (ReturnCode)SIGNDOC_Document_getSaveToStreamFlags (&ex, p, &aOutput);
    if (ex != NULL) SignDoc_throw (ex);
    return r;
  }

  ReturnCode getSaveToFileFlags (int &aOutput)
  {
    SIGNDOC_Exception *ex = NULL;
    ReturnCode r;
    r = (ReturnCode)SIGNDOC_Document_getSaveToFileFlags (&ex, p, &aOutput);
    if (ex != NULL) SignDoc_throw (ex);
    return r;
  }

  ReturnCode getRequiredSaveToFileFlags (int &aOutput)
  {
    SIGNDOC_Exception *ex = NULL;
    ReturnCode r;
    r = (ReturnCode)SIGNDOC_Document_getRequiredSaveToFileFlags (&ex, p, &aOutput);
    if (ex != NULL) SignDoc_throw (ex);
    return r;
  }

  ReturnCode getFields (int aTypes, std::vector<SignDocField> &aOutput)
  {
    SIGNDOC_Exception *ex = NULL;
    SIGNDOC_FieldArray *tempOutput = NULL;
    ReturnCode r;
    try
      {
        tempOutput = SIGNDOC_FieldArray_new (&ex);
        if (ex != NULL) SignDoc_throw (ex);
        r = (ReturnCode)SIGNDOC_Document_getFields (&ex, p, aTypes, tempOutput);
        assignArray (aOutput, tempOutput);
      }
    catch (...)
      {
        if (tempOutput != NULL)
          SIGNDOC_FieldArray_delete (tempOutput);
        throw;
      }
    if (tempOutput != NULL)
      SIGNDOC_FieldArray_delete (tempOutput);
    if (ex != NULL) SignDoc_throw (ex);
    return r;
  }

  ReturnCode getFieldsOfPage (int aPage, int aTypes,
                              std::vector<SignDocField> &aOutput)
  {
    SIGNDOC_Exception *ex = NULL;
    SIGNDOC_FieldArray *tempOutput = NULL;
    ReturnCode r;
    try
      {
        tempOutput = SIGNDOC_FieldArray_new (&ex);
        if (ex != NULL) SignDoc_throw (ex);
        r = (ReturnCode)SIGNDOC_Document_getFieldsOfPage (&ex, p, aPage, aTypes, tempOutput);
        assignArray (aOutput, tempOutput);
      }
    catch (...)
      {
        if (tempOutput != NULL)
          SIGNDOC_FieldArray_delete (tempOutput);
        throw;
      }
    if (tempOutput != NULL)
      SIGNDOC_FieldArray_delete (tempOutput);
    if (ex != NULL) SignDoc_throw (ex);
    return r;
  }

  ReturnCode getField (Encoding aEncoding, const std::string &aName,
                       SignDocField &aOutput)
  {
    SIGNDOC_Exception *ex = NULL;
    ReturnCode r;
    r = (ReturnCode)SIGNDOC_Document_getField (&ex, p, aEncoding, aName.c_str (), aOutput.getImpl ());
    if (ex != NULL) SignDoc_throw (ex);
    return r;
  }

  ReturnCode setField (SignDocField &aField, unsigned aFlags)
  {
    SIGNDOC_Exception *ex = NULL;
    ReturnCode r;
    r = (ReturnCode)SIGNDOC_Document_setField (&ex, p, aField.getImpl (), aFlags);
    if (ex != NULL) SignDoc_throw (ex);
    return r;
  }

  ReturnCode addField (SignDocField &aField, unsigned aFlags)
  {
    SIGNDOC_Exception *ex = NULL;
    ReturnCode r;
    r = (ReturnCode)SIGNDOC_Document_addField (&ex, p, aField.getImpl (), aFlags);
    if (ex != NULL) SignDoc_throw (ex);
    return r;
  }

  ReturnCode removeField (Encoding aEncoding, const std::string &aName)
  {
    SIGNDOC_Exception *ex = NULL;
    ReturnCode r;
    r = (ReturnCode)SIGNDOC_Document_removeField (&ex, p, aEncoding, aName.c_str ());
    if (ex != NULL) SignDoc_throw (ex);
    return r;
  }

  ReturnCode flattenField (Encoding aEncoding, const std::string &aName,
                           int aWidget)
  {
    SIGNDOC_Exception *ex = NULL;
    ReturnCode r;
    r = (ReturnCode)SIGNDOC_Document_flattenField (&ex, p, aEncoding, aName.c_str (), aWidget);
    if (ex != NULL) SignDoc_throw (ex);
    return r;
  }

  ReturnCode flattenFields (int aFirstPage, int aLastPage, unsigned aFlags)
  {
    SIGNDOC_Exception *ex = NULL;
    ReturnCode r;
    r = (ReturnCode)SIGNDOC_Document_flattenFields (&ex, p, aFirstPage, aLastPage, aFlags);
    if (ex != NULL) SignDoc_throw (ex);
    return r;
  }

  ReturnCode exportFields (OutputStream &aStream, int aFlags)
  {
    SIGNDOC_Exception *ex = NULL;
    ReturnCode r;
    r = (ReturnCode)SIGNDOC_Document_exportFields (&ex, p, aStream.getImpl (), aFlags);
    if (ex != NULL) SignDoc_throw (ex);
    return r;
  }

  ReturnCode applyFdf (Encoding aEncoding, const char *aPath, unsigned aFlags)
  {
    SIGNDOC_Exception *ex = NULL;
    ReturnCode r;
    r = (ReturnCode)SIGNDOC_Document_applyFdf (&ex, p, aEncoding, aPath, aFlags);
    if (ex != NULL) SignDoc_throw (ex);
    return r;
  }

  ReturnCode applyFdf (const wchar_t *aPath, unsigned aFlags)
  {
    SIGNDOC_Exception *ex = NULL;
    ReturnCode r;
    r = (ReturnCode)SIGNDOC_Document_applyFdfW (&ex, p, aPath, aFlags);
    if (ex != NULL) SignDoc_throw (ex);
    return r;
  }

  ReturnCode getTextFieldAttributes (SignDocTextFieldAttributes &aOutput)
  {
    SIGNDOC_Exception *ex = NULL;
    ReturnCode r;
    r = (ReturnCode)SIGNDOC_Document_getTextFieldAttributes (&ex, p, aOutput.getImpl ());
    if (ex != NULL) SignDoc_throw (ex);
    return r;
  }

  ReturnCode setTextFieldAttributes (SignDocTextFieldAttributes &aData)
  {
    SIGNDOC_Exception *ex = NULL;
    ReturnCode r;
    r = (ReturnCode)SIGNDOC_Document_setTextFieldAttributes (&ex, p, aData.getImpl ());
    if (ex != NULL) SignDoc_throw (ex);
    return r;
  }

  ReturnCode getProperties (const std::string &aCollection,
                            std::vector<SignDocProperty> &aOutput)
  {
    SIGNDOC_Exception *ex = NULL;
    SIGNDOC_PropertyArray *tempOutput = NULL;
    ReturnCode r;
    try
      {
        tempOutput = SIGNDOC_PropertyArray_new (&ex);
        if (ex != NULL) SignDoc_throw (ex);
        r = (ReturnCode)SIGNDOC_Document_getProperties (&ex, p, aCollection.c_str (), tempOutput);
        assignArray (aOutput, tempOutput);
      }
    catch (...)
      {
        if (tempOutput != NULL)
          SIGNDOC_PropertyArray_delete (tempOutput);
        throw;
      }
    if (tempOutput != NULL)
      SIGNDOC_PropertyArray_delete (tempOutput);
    if (ex != NULL) SignDoc_throw (ex);
    return r;
  }

  ReturnCode getIntegerProperty (Encoding aEncoding,
                                 const std::string &aCollection,
                                 const std::string &aName, long &aValue)
  {
    SIGNDOC_Exception *ex = NULL;
    ReturnCode r;
    r = (ReturnCode)SIGNDOC_Document_getIntegerProperty (&ex, p, aEncoding, aCollection.c_str (), aName.c_str (), &aValue);
    if (ex != NULL) SignDoc_throw (ex);
    return r;
  }

  ReturnCode getStringProperty (Encoding aEncoding,
                                const std::string &aCollection,
                                const std::string &aName, std::string &aValue)
  {
    SIGNDOC_Exception *ex = NULL;
    char *tempValue = NULL;
    ReturnCode r;
    try
      {
        r = (ReturnCode)SIGNDOC_Document_getStringProperty (&ex, p, aEncoding, aCollection.c_str (), aName.c_str (), &tempValue);
        if (tempValue != NULL)
          aValue = tempValue;
      }
    catch (...)
      {
        SIGNDOC_free (tempValue);
        throw;
      }
    SIGNDOC_free (tempValue);
    if (ex != NULL) SignDoc_throw (ex);
    return r;
  }

  ReturnCode getBooleanProperty (Encoding aEncoding,
                                 const std::string &aCollection,
                                 const std::string &aName, bool &aValue)
  {
    SIGNDOC_Exception *ex = NULL;
    SIGNDOC_Boolean tempValue = 0;
    ReturnCode r;
    try
      {
        r = (ReturnCode)SIGNDOC_Document_getBooleanProperty (&ex, p, aEncoding, aCollection.c_str (), aName.c_str (), &tempValue);
        aValue = (bool )tempValue;
      }
    catch (...)
      {
        throw;
      }
    if (ex != NULL) SignDoc_throw (ex);
    return r;
  }

  ReturnCode setIntegerProperty (Encoding aEncoding,
                                 const std::string &aCollection,
                                 const std::string &aName, long aValue)
  {
    SIGNDOC_Exception *ex = NULL;
    ReturnCode r;
    r = (ReturnCode)SIGNDOC_Document_setIntegerProperty (&ex, p, aEncoding, aCollection.c_str (), aName.c_str (), aValue);
    if (ex != NULL) SignDoc_throw (ex);
    return r;
  }

  ReturnCode setStringProperty (Encoding aEncoding,
                                const std::string &aCollection,
                                const std::string &aName,
                                const std::string &aValue)
  {
    SIGNDOC_Exception *ex = NULL;
    ReturnCode r;
    r = (ReturnCode)SIGNDOC_Document_setStringProperty (&ex, p, aEncoding, aCollection.c_str (), aName.c_str (), aValue.c_str ());
    if (ex != NULL) SignDoc_throw (ex);
    return r;
  }

  ReturnCode setBooleanProperty (Encoding aEncoding,
                                 const std::string &aCollection,
                                 const std::string &aName, bool aValue)
  {
    SIGNDOC_Exception *ex = NULL;
    ReturnCode r;
    r = (ReturnCode)SIGNDOC_Document_setBooleanProperty (&ex, p, aEncoding, aCollection.c_str (), aName.c_str (), aValue);
    if (ex != NULL) SignDoc_throw (ex);
    return r;
  }

  ReturnCode removeProperty (Encoding aEncoding,
                             const std::string &aCollection,
                             const std::string &aName)
  {
    SIGNDOC_Exception *ex = NULL;
    ReturnCode r;
    r = (ReturnCode)SIGNDOC_Document_removeProperty (&ex, p, aEncoding, aCollection.c_str (), aName.c_str ());
    if (ex != NULL) SignDoc_throw (ex);
    return r;
  }

  ReturnCode exportProperties (const std::string &aCollection,
                               OutputStream &aStream, int aFlags)
  {
    SIGNDOC_Exception *ex = NULL;
    ReturnCode r;
    r = (ReturnCode)SIGNDOC_Document_exportProperties (&ex, p, aCollection.c_str (), aStream.getImpl (), aFlags);
    if (ex != NULL) SignDoc_throw (ex);
    return r;
  }

  ReturnCode importProperties (const std::string &aCollection,
                               InputStream &aStream, int aFlags)
  {
    SIGNDOC_Exception *ex = NULL;
    ReturnCode r;
    r = (ReturnCode)SIGNDOC_Document_importProperties (&ex, p, aCollection.c_str (), aStream.getImpl (), aFlags);
    if (ex != NULL) SignDoc_throw (ex);
    return r;
  }

  ReturnCode getResolution (int aPage, double &aResX, double &aResY)
  {
    SIGNDOC_Exception *ex = NULL;
    ReturnCode r;
    r = (ReturnCode)SIGNDOC_Document_getResolution (&ex, p, aPage, &aResX, &aResY);
    if (ex != NULL) SignDoc_throw (ex);
    return r;
  }

  ReturnCode getConversionFactors (int aPage, double &aFactorX,
                                   double &aFactorY)
  {
    SIGNDOC_Exception *ex = NULL;
    ReturnCode r;
    r = (ReturnCode)SIGNDOC_Document_getConversionFactors (&ex, p, aPage, &aFactorX, &aFactorY);
    if (ex != NULL) SignDoc_throw (ex);
    return r;
  }

  ReturnCode getPageSize (int aPage, double &aWidth, double &aHeight)
  {
    SIGNDOC_Exception *ex = NULL;
    ReturnCode r;
    r = (ReturnCode)SIGNDOC_Document_getPageSize (&ex, p, aPage, &aWidth, &aHeight);
    if (ex != NULL) SignDoc_throw (ex);
    return r;
  }

  ReturnCode getBitsPerPixel (int aPage, int &aBPP)
  {
    SIGNDOC_Exception *ex = NULL;
    ReturnCode r;
    r = (ReturnCode)SIGNDOC_Document_getBitsPerPixel (&ex, p, aPage, &aBPP);
    if (ex != NULL) SignDoc_throw (ex);
    return r;
  }

  ReturnCode computeZoom (double &aOutput,
                          const SignDocRenderParameters &aParams)
  {
    SIGNDOC_Exception *ex = NULL;
    ReturnCode r;
    r = (ReturnCode)SIGNDOC_Document_computeZoom (&ex, p, &aOutput, aParams.getImpl ());
    if (ex != NULL) SignDoc_throw (ex);
    return r;
  }

  ReturnCode convCanvasPointToPagePoint (Point &aPoint,
                                         const SignDocRenderParameters &aParams)
  {
    SIGNDOC_Exception *ex = NULL;
    ReturnCode r;
    r = (ReturnCode)SIGNDOC_Document_convCanvasPointToPagePoint (&ex, p, (SIGNDOC_Point*)&aPoint, aParams.getImpl ());
    if (ex != NULL) SignDoc_throw (ex);
    return r;
  }

  ReturnCode convPagePointToCanvasPoint (Point &aPoint,
                                         const SignDocRenderParameters &aParams)
  {
    SIGNDOC_Exception *ex = NULL;
    ReturnCode r;
    r = (ReturnCode)SIGNDOC_Document_convPagePointToCanvasPoint (&ex, p, (SIGNDOC_Point*)&aPoint, aParams.getImpl ());
    if (ex != NULL) SignDoc_throw (ex);
    return r;
  }

  ReturnCode renderPageAsImage (std::vector<unsigned char> &aImage,
                                SignDocRenderOutput &aOutput,
                                const SignDocRenderParameters &aRenderParameters,
                                const SignDocVerificationParameters *aVerificationParameters,
                                const Rect *aClipRect)
  {
    SIGNDOC_Exception *ex = NULL;
    SIGNDOC_ByteArray *tempImage = NULL;
    ReturnCode r;
    try
      {
        tempImage = SIGNDOC_ByteArray_new (&ex);
        if (ex != NULL) SignDoc_throw (ex);
        r = (ReturnCode)SIGNDOC_Document_renderPageAsImage (&ex, p, tempImage, (SIGNDOC_RenderOutput*)&aOutput, aRenderParameters.getImpl (), aVerificationParameters == NULL ? NULL : aVerificationParameters->getImpl (), (const SIGNDOC_Rect*)aClipRect);
        assignArray (aImage, tempImage);
      }
    catch (...)
      {
        if (tempImage != NULL)
          SIGNDOC_ByteArray_delete (tempImage);
        throw;
      }
    if (tempImage != NULL)
      SIGNDOC_ByteArray_delete (tempImage);
    if (ex != NULL) SignDoc_throw (ex);
    return r;
  }

  ReturnCode getRenderedSize (SignDocRenderOutput &aOutput,
                              const SignDocRenderParameters &aRenderParameters)
  {
    SIGNDOC_Exception *ex = NULL;
    ReturnCode r;
    r = (ReturnCode)SIGNDOC_Document_getRenderedSize (&ex, p, (SIGNDOC_RenderOutput*)&aOutput, aRenderParameters.getImpl ());
    if (ex != NULL) SignDoc_throw (ex);
    return r;
  }

  SignDocAnnotation *createLineAnnotation (const Point &aStart,
                                           const Point &aEnd)
  {
    SIGNDOC_Exception *ex = NULL;
    SIGNDOC_Annotation *r;
    r = SIGNDOC_Document_createLineAnnotation (&ex, p, (const SIGNDOC_Point*)&aStart, (const SIGNDOC_Point*)&aEnd);
    if (ex != NULL) SignDoc_throw (ex);
    if (r == NULL)
      return NULL;
    try
      {
        return new SignDocAnnotation (r);
      }
    catch (...)
      {
        SIGNDOC_Annotation_delete (r);
        throw;
      }
  }

  SignDocAnnotation *createLineAnnotation (double aStartX, double aStartY,
                                           double aEndX, double aEndY)
  {
    SIGNDOC_Exception *ex = NULL;
    SIGNDOC_Annotation *r;
    r = SIGNDOC_Document_createLineAnnotationXY (&ex, p, aStartX, aStartY, aEndX, aEndY);
    if (ex != NULL) SignDoc_throw (ex);
    if (r == NULL)
      return NULL;
    try
      {
        return new SignDocAnnotation (r);
      }
    catch (...)
      {
        SIGNDOC_Annotation_delete (r);
        throw;
      }
  }

  SignDocAnnotation *createScribbleAnnotation ()
  {
    SIGNDOC_Exception *ex = NULL;
    SIGNDOC_Annotation *r;
    r = SIGNDOC_Document_createScribbleAnnotation (&ex, p);
    if (ex != NULL) SignDoc_throw (ex);
    if (r == NULL)
      return NULL;
    try
      {
        return new SignDocAnnotation (r);
      }
    catch (...)
      {
        SIGNDOC_Annotation_delete (r);
        throw;
      }
  }

  SignDocAnnotation *createFreeTextAnnotation (const Point &aLowerLeft,
                                               const Point &aUpperRight)
  {
    SIGNDOC_Exception *ex = NULL;
    SIGNDOC_Annotation *r;
    r = SIGNDOC_Document_createFreeTextAnnotation (&ex, p, (const SIGNDOC_Point*)&aLowerLeft, (const SIGNDOC_Point*)&aUpperRight);
    if (ex != NULL) SignDoc_throw (ex);
    if (r == NULL)
      return NULL;
    try
      {
        return new SignDocAnnotation (r);
      }
    catch (...)
      {
        SIGNDOC_Annotation_delete (r);
        throw;
      }
  }

  SignDocAnnotation *createFreeTextAnnotation (double aX0, double aY0,
                                               double aX1, double aY1)
  {
    SIGNDOC_Exception *ex = NULL;
    SIGNDOC_Annotation *r;
    r = SIGNDOC_Document_createFreeTextAnnotationXY (&ex, p, aX0, aY0, aX1, aY1);
    if (ex != NULL) SignDoc_throw (ex);
    if (r == NULL)
      return NULL;
    try
      {
        return new SignDocAnnotation (r);
      }
    catch (...)
      {
        SIGNDOC_Annotation_delete (r);
        throw;
      }
  }

  ReturnCode addAnnotation (int aPage, const SignDocAnnotation *aAnnot)
  {
    SIGNDOC_Exception *ex = NULL;
    ReturnCode r;
    r = (ReturnCode)SIGNDOC_Document_addAnnotation (&ex, p, aPage, aAnnot == NULL ? NULL : aAnnot->getImpl ());
    if (ex != NULL) SignDoc_throw (ex);
    return r;
  }

  ReturnCode getAnnotations (Encoding aEncoding, int aPage,
                             std::vector<std::string> &aOutput)
  {
    SIGNDOC_Exception *ex = NULL;
    SIGNDOC_StringArray *tempOutput = NULL;
    ReturnCode r;
    try
      {
        tempOutput = SIGNDOC_StringArray_new (&ex);
        if (ex != NULL) SignDoc_throw (ex);
        r = (ReturnCode)SIGNDOC_Document_getAnnotations (&ex, p, aEncoding, aPage, tempOutput);
        assignArray (aOutput, tempOutput);
      }
    catch (...)
      {
        if (tempOutput != NULL)
          SIGNDOC_StringArray_delete (tempOutput);
        throw;
      }
    if (tempOutput != NULL)
      SIGNDOC_StringArray_delete (tempOutput);
    if (ex != NULL) SignDoc_throw (ex);
    return r;
  }

  ReturnCode getAnnotation (Encoding aEncoding, int aPage,
                            const std::string &aName,
                            SIGNDOC_PTR<SignDocAnnotation> &aOutput)
  {
    SIGNDOC_Exception *ex = NULL;
    SIGNDOC_Annotation *tempOutput = NULL;
    aOutput.reset ((SignDocAnnotation*)NULL);
    ReturnCode r;
    try
      {
        r = (ReturnCode)SIGNDOC_Document_getAnnotation (&ex, p, aEncoding, aPage, aName.c_str (), &tempOutput);
        if (tempOutput != NULL)
          {
            aOutput.reset (new SignDocAnnotation (tempOutput));
            tempOutput = NULL;
          }
      }
    catch (...)
      {
        if (tempOutput != NULL)
          SIGNDOC_Annotation_delete (tempOutput);
        throw;
      }
    if (tempOutput != NULL)
      SIGNDOC_Annotation_delete (tempOutput);
    if (ex != NULL) SignDoc_throw (ex);
    return r;
  }

  ReturnCode removeAnnotation (Encoding aEncoding, int aPage,
                               const std::string &aName)
  {
    SIGNDOC_Exception *ex = NULL;
    ReturnCode r;
    r = (ReturnCode)SIGNDOC_Document_removeAnnotation (&ex, p, aEncoding, aPage, aName.c_str ());
    if (ex != NULL) SignDoc_throw (ex);
    return r;
  }

  ReturnCode addText (Encoding aEncoding, const std::string &aText, int aPage,
                      double aX, double aY, const std::string &aFontName,
                      double aFontSize, const SignDocColor &aTextColor,
                      double aOpacity, int aFlags)
  {
    SIGNDOC_Exception *ex = NULL;
    ReturnCode r;
    r = (ReturnCode)SIGNDOC_Document_addText (&ex, p, aEncoding, aText.c_str (), aPage, aX, aY, aFontName.c_str (), aFontSize, aTextColor.getImpl (), aOpacity, aFlags);
    if (ex != NULL) SignDoc_throw (ex);
    return r;
  }

  ReturnCode addTextRect (Encoding aEncoding, const std::string &aText,
                          int aPage, double aX0, double aY0, double aX1,
                          double aY1, const std::string &aFontName,
                          double aFontSize, double aLineSkip,
                          const SignDocColor &aTextColor, double aOpacity,
                          HAlignment aHAlignment, VAlignment aVAlignment,
                          int aFlags)
  {
    SIGNDOC_Exception *ex = NULL;
    ReturnCode r;
    r = (ReturnCode)SIGNDOC_Document_addTextRect (&ex, p, aEncoding, aText.c_str (), aPage, aX0, aY0, aX1, aY1, aFontName.c_str (), aFontSize, aLineSkip, aTextColor.getImpl (), aOpacity, aHAlignment, aVAlignment, aFlags);
    if (ex != NULL) SignDoc_throw (ex);
    return r;
  }

  ReturnCode addWatermark (const SignDocWatermark &aInput)
  {
    SIGNDOC_Exception *ex = NULL;
    ReturnCode r;
    r = (ReturnCode)SIGNDOC_Document_addWatermark (&ex, p, aInput.getImpl ());
    if (ex != NULL) SignDoc_throw (ex);
    return r;
  }

  ReturnCode findText (Encoding aEncoding, int aFirstPage, int aLastPage,
                       const std::string &aText, int aFlags,
                       std::vector<SignDocFindTextPosition> &aOutput)
  {
    SIGNDOC_Exception *ex = NULL;
    SIGNDOC_FindTextPositionArray *tempOutput = NULL;
    ReturnCode r;
    try
      {
        tempOutput = SIGNDOC_FindTextPositionArray_new (&ex);
        if (ex != NULL) SignDoc_throw (ex);
        r = (ReturnCode)SIGNDOC_Document_findText (&ex, p, aEncoding, aFirstPage, aLastPage, aText.c_str (), aFlags, tempOutput);
        assignArray (aOutput, tempOutput);
      }
    catch (...)
      {
        if (tempOutput != NULL)
          SIGNDOC_FindTextPositionArray_delete (tempOutput);
        throw;
      }
    if (tempOutput != NULL)
      SIGNDOC_FindTextPositionArray_delete (tempOutput);
    if (ex != NULL) SignDoc_throw (ex);
    return r;
  }

  ReturnCode addAttachmentBlob (Encoding aEncoding, const std::string &aName,
                                const std::string &aDescription,
                                const std::string &aType,
                                const std::string &aModificationTime,
                                const void *aPtr, size_t aSize, int aFlags)
  {
    SIGNDOC_Exception *ex = NULL;
    ReturnCode r;
    r = (ReturnCode)SIGNDOC_Document_addAttachmentBlob (&ex, p, aEncoding, aName.c_str (), aDescription.c_str (), aType.c_str (), aModificationTime.c_str (), aPtr, aSize, aFlags);
    if (ex != NULL) SignDoc_throw (ex);
    return r;
  }

  ReturnCode addAttachmentFile (Encoding aEncoding1, const std::string &aName,
                                const std::string &aDescription,
                                const std::string &aType, Encoding aEncoding2,
                                const std::string &aPath, int aFlags)
  {
    SIGNDOC_Exception *ex = NULL;
    ReturnCode r;
    r = (ReturnCode)SIGNDOC_Document_addAttachmentFile (&ex, p, aEncoding1, aName.c_str (), aDescription.c_str (), aType.c_str (), aEncoding2, aPath.c_str (), aFlags);
    if (ex != NULL) SignDoc_throw (ex);
    return r;
  }

  ReturnCode removeAttachment (Encoding aEncoding, const std::string &aName)
  {
    SIGNDOC_Exception *ex = NULL;
    ReturnCode r;
    r = (ReturnCode)SIGNDOC_Document_removeAttachment (&ex, p, aEncoding, aName.c_str ());
    if (ex != NULL) SignDoc_throw (ex);
    return r;
  }

  ReturnCode changeAttachmentDescription (Encoding aEncoding,
                                          const std::string &aName,
                                          const std::string &aDescription)
  {
    SIGNDOC_Exception *ex = NULL;
    ReturnCode r;
    r = (ReturnCode)SIGNDOC_Document_changeAttachmentDescription (&ex, p, aEncoding, aName.c_str (), aDescription.c_str ());
    if (ex != NULL) SignDoc_throw (ex);
    return r;
  }

  ReturnCode getAttachments (Encoding aEncoding,
                             std::vector<std::string> &aOutput)
  {
    SIGNDOC_Exception *ex = NULL;
    SIGNDOC_StringArray *tempOutput = NULL;
    ReturnCode r;
    try
      {
        tempOutput = SIGNDOC_StringArray_new (&ex);
        if (ex != NULL) SignDoc_throw (ex);
        r = (ReturnCode)SIGNDOC_Document_getAttachments (&ex, p, aEncoding, tempOutput);
        assignArray (aOutput, tempOutput);
      }
    catch (...)
      {
        if (tempOutput != NULL)
          SIGNDOC_StringArray_delete (tempOutput);
        throw;
      }
    if (tempOutput != NULL)
      SIGNDOC_StringArray_delete (tempOutput);
    if (ex != NULL) SignDoc_throw (ex);
    return r;
  }

  ReturnCode getAttachment (Encoding aEncoding, const std::string &aName,
                            SignDocAttachment &aOutput)
  {
    SIGNDOC_Exception *ex = NULL;
    ReturnCode r;
    r = (ReturnCode)SIGNDOC_Document_getAttachment (&ex, p, aEncoding, aName.c_str (), aOutput.getImpl ());
    if (ex != NULL) SignDoc_throw (ex);
    return r;
  }

  ReturnCode checkAttachment (Encoding aEncoding, const std::string &aName,
                              CheckAttachmentResult &aOutput)
  {
    SIGNDOC_Exception *ex = NULL;
    int tempOutput = 0;
    ReturnCode r;
    try
      {
        r = (ReturnCode)SIGNDOC_Document_checkAttachment (&ex, p, aEncoding, aName.c_str (), &tempOutput);
        aOutput = (CheckAttachmentResult )tempOutput;
      }
    catch (...)
      {
        throw;
      }
    if (ex != NULL) SignDoc_throw (ex);
    return r;
  }

  ReturnCode getAttachmentBlob (Encoding aEncoding, const std::string &aName,
                                std::vector<unsigned char> &aOutput)
  {
    SIGNDOC_Exception *ex = NULL;
    SIGNDOC_ByteArray *tempOutput = NULL;
    ReturnCode r;
    try
      {
        tempOutput = SIGNDOC_ByteArray_new (&ex);
        if (ex != NULL) SignDoc_throw (ex);
        r = (ReturnCode)SIGNDOC_Document_getAttachmentBlob (&ex, p, aEncoding, aName.c_str (), tempOutput);
        assignArray (aOutput, tempOutput);
      }
    catch (...)
      {
        if (tempOutput != NULL)
          SIGNDOC_ByteArray_delete (tempOutput);
        throw;
      }
    if (tempOutput != NULL)
      SIGNDOC_ByteArray_delete (tempOutput);
    if (ex != NULL) SignDoc_throw (ex);
    return r;
  }

  ReturnCode getAttachmentStream (Encoding aEncoding, const std::string &aName,
                                  SIGNDOC_PTR<InputStream> &aOutput)
  {
    SIGNDOC_Exception *ex = NULL;
    SIGNDOC_InputStream *tempOutput = NULL;
    aOutput.reset ((InputStream*)NULL);
    ReturnCode r;
    try
      {
        r = (ReturnCode)SIGNDOC_Document_getAttachmentStream (&ex, p, aEncoding, aName.c_str (), &tempOutput);
        if (tempOutput != NULL)
          {
            aOutput.reset (new LibraryInputStream (tempOutput));
            tempOutput = NULL;
          }
      }
    catch (...)
      {
        if (tempOutput != NULL)
          SIGNDOC_InputStream_delete (tempOutput);
        throw;
      }
    if (tempOutput != NULL)
      SIGNDOC_InputStream_delete (tempOutput);
    if (ex != NULL) SignDoc_throw (ex);
    return r;
  }

  ReturnCode addPage (int aTargetPage, double aWidth, double aHeight)
  {
    SIGNDOC_Exception *ex = NULL;
    ReturnCode r;
    r = (ReturnCode)SIGNDOC_Document_addPage (&ex, p, aTargetPage, aWidth, aHeight);
    if (ex != NULL) SignDoc_throw (ex);
    return r;
  }

  ReturnCode importPages (int aTargetPage, SignDocDocument *aSource,
                          int aSourcePage, int aPageCount, int aFlags)
  {
    SIGNDOC_Exception *ex = NULL;
    ReturnCode r;
    r = (ReturnCode)SIGNDOC_Document_importPages (&ex, p, aTargetPage, aSource == NULL ? NULL : aSource->getImpl (), aSourcePage, aPageCount, aFlags);
    if (ex != NULL) SignDoc_throw (ex);
    return r;
  }

  ReturnCode importPageFromImageBlob (int aTargetPage,
                                      const unsigned char *aPtr, size_t aSize,
                                      double aZoom, double aWidth,
                                      double aHeight, int aFlags)
  {
    SIGNDOC_Exception *ex = NULL;
    ReturnCode r;
    r = (ReturnCode)SIGNDOC_Document_importPageFromImageBlob (&ex, p, aTargetPage, aPtr, aSize, aZoom, aWidth, aHeight, aFlags);
    if (ex != NULL) SignDoc_throw (ex);
    return r;
  }

  ReturnCode importPageFromImageFile (int aTargetPage, Encoding aEncoding,
                                      const std::string &aPath, double aZoom,
                                      double aWidth, double aHeight,
                                      int aFlags)
  {
    SIGNDOC_Exception *ex = NULL;
    ReturnCode r;
    r = (ReturnCode)SIGNDOC_Document_importPageFromImageFile (&ex, p, aTargetPage, aEncoding, aPath.c_str (), aZoom, aWidth, aHeight, aFlags);
    if (ex != NULL) SignDoc_throw (ex);
    return r;
  }

  ReturnCode addImageFromBlob (int aTargetPage, const unsigned char *aPtr,
                               size_t aSize, double aZoom, double aX,
                               double aY, double aWidth, double aHeight,
                               int aFlags)
  {
    SIGNDOC_Exception *ex = NULL;
    ReturnCode r;
    r = (ReturnCode)SIGNDOC_Document_addImageFromBlob (&ex, p, aTargetPage, aPtr, aSize, aZoom, aX, aY, aWidth, aHeight, aFlags);
    if (ex != NULL) SignDoc_throw (ex);
    return r;
  }

  ReturnCode addImageFromFile (int aTargetPage, Encoding aEncoding,
                               const std::string &aPath, double aZoom,
                               double aX, double aY, double aWidth,
                               double aHeight, int aFlags)
  {
    SIGNDOC_Exception *ex = NULL;
    ReturnCode r;
    r = (ReturnCode)SIGNDOC_Document_addImageFromFile (&ex, p, aTargetPage, aEncoding, aPath.c_str (), aZoom, aX, aY, aWidth, aHeight, aFlags);
    if (ex != NULL) SignDoc_throw (ex);
    return r;
  }

  ReturnCode removePages (const int *aPagesPtr, int aPagesCount,
                          KeepOrRemove aMode)
  {
    SIGNDOC_Exception *ex = NULL;
    ReturnCode r;
    r = (ReturnCode)SIGNDOC_Document_removePages (&ex, p, aPagesPtr, aPagesCount, aMode);
    if (ex != NULL) SignDoc_throw (ex);
    return r;
  }

  ReturnCode setCompatibility (int aMajor, int aMinor)
  {
    SIGNDOC_Exception *ex = NULL;
    ReturnCode r;
    r = (ReturnCode)SIGNDOC_Document_setCompatibility (&ex, p, aMajor, aMinor);
    if (ex != NULL) SignDoc_throw (ex);
    return r;
  }

  ReturnCode isModified (bool &aModified) const
  {
    SIGNDOC_Exception *ex = NULL;
    SIGNDOC_Boolean tempModified = 0;
    ReturnCode r;
    try
      {
        r = (ReturnCode)SIGNDOC_Document_isModified (&ex, p, &tempModified);
        aModified = (bool )tempModified;
      }
    catch (...)
      {
        throw;
      }
    if (ex != NULL) SignDoc_throw (ex);
    return r;
  }

  ReturnCode setFlags (unsigned aFlags)
  {
    SIGNDOC_Exception *ex = NULL;
    ReturnCode r;
    r = (ReturnCode)SIGNDOC_Document_setFlags (&ex, p, aFlags);
    if (ex != NULL) SignDoc_throw (ex);
    return r;
  }

  unsigned getFlags () const
  {
    SIGNDOC_Exception *ex = NULL;
    unsigned r;
    r = SIGNDOC_Document_getFlags (&ex, p);
    if (ex != NULL) SignDoc_throw (ex);
    return r;
  }

  ReturnCode setCompressionLevel (int aLevel)
  {
    SIGNDOC_Exception *ex = NULL;
    ReturnCode r;
    r = (ReturnCode)SIGNDOC_Document_setCompressionLevel (&ex, p, aLevel);
    if (ex != NULL) SignDoc_throw (ex);
    return r;
  }

  int getDocMDP () const
  {
    SIGNDOC_Exception *ex = NULL;
    int r;
    r = SIGNDOC_Document_getDocMDP (&ex, p);
    if (ex != NULL) SignDoc_throw (ex);
    return r;
  }

  int getLockMDP () const
  {
    SIGNDOC_Exception *ex = NULL;
    int r;
    r = SIGNDOC_Document_getLockMDP (&ex, p);
    if (ex != NULL) SignDoc_throw (ex);
    return r;
  }

  ReturnCode removeDocMDP ()
  {
    SIGNDOC_Exception *ex = NULL;
    ReturnCode r;
    r = (ReturnCode)SIGNDOC_Document_removeDocMDP (&ex, p);
    if (ex != NULL) SignDoc_throw (ex);
    return r;
  }

  ReturnCode removePermissions (unsigned aFlags)
  {
    SIGNDOC_Exception *ex = NULL;
    ReturnCode r;
    r = (ReturnCode)SIGNDOC_Document_removePermissions (&ex, p, aFlags);
    if (ex != NULL) SignDoc_throw (ex);
    return r;
  }

  ReturnCode removePDFA (unsigned aFlags)
  {
    SIGNDOC_Exception *ex = NULL;
    ReturnCode r;
    r = (ReturnCode)SIGNDOC_Document_removePDFA (&ex, p, aFlags);
    if (ex != NULL) SignDoc_throw (ex);
    return r;
  }

  ReturnCode removePDFUA (unsigned aFlags)
  {
    SIGNDOC_Exception *ex = NULL;
    ReturnCode r;
    r = (ReturnCode)SIGNDOC_Document_removePDFUA (&ex, p, aFlags);
    if (ex != NULL) SignDoc_throw (ex);
    return r;
  }

  ReturnCode removeLogicalStructure (unsigned aFlags)
  {
    SIGNDOC_Exception *ex = NULL;
    ReturnCode r;
    r = (ReturnCode)SIGNDOC_Document_removeLogicalStructure (&ex, p, aFlags);
    if (ex != NULL) SignDoc_throw (ex);
    return r;
  }

  ReturnCode removeXFA (unsigned aFlags)
  {
    SIGNDOC_Exception *ex = NULL;
    ReturnCode r;
    r = (ReturnCode)SIGNDOC_Document_removeXFA (&ex, p, aFlags);
    if (ex != NULL) SignDoc_throw (ex);
    return r;
  }

  ReturnCode setShootInFoot (unsigned aFlags)
  {
    SIGNDOC_Exception *ex = NULL;
    ReturnCode r;
    r = (ReturnCode)SIGNDOC_Document_setShootInFoot (&ex, p, aFlags);
    if (ex != NULL) SignDoc_throw (ex);
    return r;
  }

  unsigned getShootInFoot () const
  {
    SIGNDOC_Exception *ex = NULL;
    unsigned r;
    r = SIGNDOC_Document_getShootInFoot (&ex, p);
    if (ex != NULL) SignDoc_throw (ex);
    return r;
  }

  const char *getErrorMessage (Encoding aEncoding) const
  {
    SIGNDOC_Exception *ex = NULL;
    const char *r;
    r = SIGNDOC_Document_getErrorMessage (&ex, p, aEncoding);
    if (ex != NULL) SignDoc_throw (ex);
    return r;
  }

  const wchar_t *getErrorMessageW () const
  {
    SIGNDOC_Exception *ex = NULL;
    const wchar_t *r;
    r = SIGNDOC_Document_getErrorMessageW (&ex, p);
    if (ex != NULL) SignDoc_throw (ex);
    return r;
  }

  SPPDF_Document *getSPPDFDocument (bool aDestroy)
  {
    SIGNDOC_Exception *ex = NULL;
    SPPDF_Document *r;
    r = SIGNDOC_Document_getSPPDFDocument (&ex, p, aDestroy);
    if (ex != NULL) SignDoc_throw (ex);
    return r;
  }

  ReturnCode getPageLabel (int aPage, std::string &aOutput)
  {
    SIGNDOC_Exception *ex = NULL;
    char *tempOutput = NULL;
    ReturnCode r;
    try
      {
        r = (ReturnCode)SIGNDOC_Document_getPageLabel (&ex, p, aPage, &tempOutput);
        if (tempOutput != NULL)
          aOutput = tempOutput;
      }
    catch (...)
      {
        SIGNDOC_free (tempOutput);
        throw;
      }
    SIGNDOC_free (tempOutput);
    if (ex != NULL) SignDoc_throw (ex);
    return r;
  }

  ReturnCode flattenAnnotations (int aFirstPage, int aLastPage,
                                 unsigned aFlags)
  {
    SIGNDOC_Exception *ex = NULL;
    ReturnCode r;
    r = (ReturnCode)SIGNDOC_Document_flattenAnnotations (&ex, p, aFirstPage, aLastPage, aFlags);
    if (ex != NULL) SignDoc_throw (ex);
    return r;
  }

private:
  SignDocDocument (const SignDocDocument &);

  SignDocDocument &operator= (const SignDocDocument &);
public:
  SignDocDocument (SIGNDOC_Document *aP) : p (aP) { }

  SIGNDOC_Document *getImpl () { return p; }

  const SIGNDOC_Document *getImpl () const { return p; }

  void setImpl (SIGNDOC_Document *aP) { SIGNDOC_Document_delete (p); p  = aP; }

private:
  SIGNDOC_Document *p;
};

class SignDocDocumentHandler 
{
public:
  SignDocDocumentHandler ()
    : p (NULL)
  {
  }

  virtual ~SignDocDocumentHandler ()
  {
    SIGNDOC_DocumentHandler_delete (p);
  }

private:
  SignDocDocumentHandler (const SignDocDocumentHandler &);

public:
  SignDocDocumentHandler (SIGNDOC_DocumentHandler *aP) : p (aP) { }

  SIGNDOC_DocumentHandler *getImpl () { return p; }

  const SIGNDOC_DocumentHandler *getImpl () const { return p; }

  void destroyWithoutImpl () { p = NULL; delete this; }

  void setImpl (SIGNDOC_DocumentHandler *aP) { SIGNDOC_DocumentHandler_delete (p); p  = aP; }

protected:
  SIGNDOC_DocumentHandler *p;
};

class SignDocDocumentLoader 
{
public:
  enum RemainingDays
  {
    rd_product,

    rd_signing
  };

  enum Flags
  {
    f_map_into_memory = 0x01
  };

public:
  SignDocDocumentLoader ()
    : p (NULL)
  {
    SIGNDOC_Exception *ex = NULL;
    p = SIGNDOC_DocumentLoader_new (&ex);
    if (ex != NULL) SignDoc_throw (ex);
  }

  ~SignDocDocumentLoader ()
  {
    SIGNDOC_DocumentLoader_delete (p);
  }

  static bool initLicenseManager (int aWho1, int aWho2)
  {
    SIGNDOC_Exception *ex = NULL;
    bool r;
    r = (bool)SIGNDOC_DocumentLoader_initLicenseManager (&ex, aWho1, aWho2);
    if (ex != NULL) SignDoc_throw (ex);
    return r;
  }

  static bool setLicenseKey (const void *aKeyPtr, size_t aKeySize,
                             const char *aProduct, const char *aVersion,
                             const void *aTokenPtr, size_t aTokenSize)
  {
    SIGNDOC_Exception *ex = NULL;
    bool r;
    r = (bool)SIGNDOC_DocumentLoader_setLicenseKey (&ex, aKeyPtr, aKeySize, aProduct, aVersion, aTokenPtr, aTokenSize);
    if (ex != NULL) SignDoc_throw (ex);
    return r;
  }

  static bool generateLicenseToken (const char *aProduct,
                                    std::vector<unsigned char> &aOutput)
  {
    SIGNDOC_Exception *ex = NULL;
    SIGNDOC_ByteArray *tempOutput = NULL;
    bool r;
    try
      {
        tempOutput = SIGNDOC_ByteArray_new (&ex);
        if (ex != NULL) SignDoc_throw (ex);
        r = (bool)SIGNDOC_DocumentLoader_generateLicenseToken (&ex, aProduct, tempOutput);
        assignArray (aOutput, tempOutput);
      }
    catch (...)
      {
        if (tempOutput != NULL)
          SIGNDOC_ByteArray_delete (tempOutput);
        throw;
      }
    if (tempOutput != NULL)
      SIGNDOC_ByteArray_delete (tempOutput);
    if (ex != NULL) SignDoc_throw (ex);
    return r;
  }

  static int getRemainingDays (RemainingDays aWhat)
  {
    SIGNDOC_Exception *ex = NULL;
    int r;
    r = SIGNDOC_DocumentLoader_getRemainingDays (&ex, aWhat);
    if (ex != NULL) SignDoc_throw (ex);
    return r;
  }

  static bool getInstallationCode (std::string &aCode)
  {
    SIGNDOC_Exception *ex = NULL;
    char *tempCode = NULL;
    bool r;
    try
      {
        r = (bool)SIGNDOC_DocumentLoader_getInstallationCode (&ex, &tempCode);
        if (tempCode != NULL)
          aCode = tempCode;
      }
    catch (...)
      {
        SIGNDOC_free (tempCode);
        throw;
      }
    SIGNDOC_free (tempCode);
    if (ex != NULL) SignDoc_throw (ex);
    return r;
  }

  static bool getVersionNumber (std::string &aVersion)
  {
    SIGNDOC_Exception *ex = NULL;
    char *tempVersion = NULL;
    bool r;
    try
      {
        r = (bool)SIGNDOC_DocumentLoader_getVersionNumber (&ex, &tempVersion);
        if (tempVersion != NULL)
          aVersion = tempVersion;
      }
    catch (...)
      {
        SIGNDOC_free (tempVersion);
        throw;
      }
    SIGNDOC_free (tempVersion);
    if (ex != NULL) SignDoc_throw (ex);
    return r;
  }

  static bool getComponentVersionNumber (const char *aComponent,
                                         std::string &aVersion)
  {
    SIGNDOC_Exception *ex = NULL;
    char *tempVersion = NULL;
    bool r;
    try
      {
        r = (bool)SIGNDOC_DocumentLoader_getComponentVersionNumber (&ex, aComponent, &tempVersion);
        if (tempVersion != NULL)
          aVersion = tempVersion;
      }
    catch (...)
      {
        SIGNDOC_free (tempVersion);
        throw;
      }
    SIGNDOC_free (tempVersion);
    if (ex != NULL) SignDoc_throw (ex);
    return r;
  }

  static int getLicenseTextCount ()
  {
    SIGNDOC_Exception *ex = NULL;
    int r;
    r = SIGNDOC_DocumentLoader_getLicenseTextCount (&ex);
    if (ex != NULL) SignDoc_throw (ex);
    return r;
  }

  static const char *getLicenseText (int aIndex)
  {
    SIGNDOC_Exception *ex = NULL;
    const char *r;
    r = SIGNDOC_DocumentLoader_getLicenseText (&ex, aIndex);
    if (ex != NULL) SignDoc_throw (ex);
    return r;
  }

  SignDocDocument *loadFromMemory (const unsigned char *aData, size_t aSize,
                                   bool aCopy)
  {
    SIGNDOC_Exception *ex = NULL;
    SIGNDOC_Document *r;
    r = SIGNDOC_DocumentLoader_loadFromMemory (&ex, p, aData, aSize, aCopy);
    if (ex != NULL) SignDoc_throw (ex);
    if (r == NULL)
      return NULL;
    try
      {
        return new SignDocDocument (r);
      }
    catch (...)
      {
        SIGNDOC_Document_delete (r);
        throw;
      }
  }

  SignDocDocument *loadFromFile (Encoding aEncoding, const char *aPath,
                                 bool aWritable)
  {
    SIGNDOC_Exception *ex = NULL;
    SIGNDOC_Document *r;
    r = SIGNDOC_DocumentLoader_loadFromFile (&ex, p, aEncoding, aPath, aWritable);
    if (ex != NULL) SignDoc_throw (ex);
    if (r == NULL)
      return NULL;
    try
      {
        return new SignDocDocument (r);
      }
    catch (...)
      {
        SIGNDOC_Document_delete (r);
        throw;
      }
  }

  SignDocDocument *loadFromFile (const wchar_t *aPath, bool aWritable)
  {
    SIGNDOC_Exception *ex = NULL;
    SIGNDOC_Document *r;
    r = SIGNDOC_DocumentLoader_loadFromFileW (&ex, p, aPath, aWritable);
    if (ex != NULL) SignDoc_throw (ex);
    if (r == NULL)
      return NULL;
    try
      {
        return new SignDocDocument (r);
      }
    catch (...)
      {
        SIGNDOC_Document_delete (r);
        throw;
      }
  }

  SignDocDocument *createPDF (int aMajor, int aMinor)
  {
    SIGNDOC_Exception *ex = NULL;
    SIGNDOC_Document *r;
    r = SIGNDOC_DocumentLoader_createPDF (&ex, p, aMajor, aMinor);
    if (ex != NULL) SignDoc_throw (ex);
    if (r == NULL)
      return NULL;
    try
      {
        return new SignDocDocument (r);
      }
    catch (...)
      {
        SIGNDOC_Document_delete (r);
        throw;
      }
  }

  SignDocDocument *createPDFA (int aMajor, int aMinor,
                               const char *aConformance,
                               const unsigned char *aICCPtr, size_t aICCSize)
  {
    SIGNDOC_Exception *ex = NULL;
    SIGNDOC_Document *r;
    r = SIGNDOC_DocumentLoader_createPDFA (&ex, p, aMajor, aMinor, aConformance, aICCPtr, aICCSize);
    if (ex != NULL) SignDoc_throw (ex);
    if (r == NULL)
      return NULL;
    try
      {
        return new SignDocDocument (r);
      }
    catch (...)
      {
        SIGNDOC_Document_delete (r);
        throw;
      }
  }

  SignDocDocument::DocumentType ping (InputStream &aStream)
  {
    SIGNDOC_Exception *ex = NULL;
    SignDocDocument::DocumentType r;
    r = (SignDocDocument::DocumentType)SIGNDOC_DocumentLoader_ping (&ex, p, aStream.getImpl ());
    if (ex != NULL) SignDoc_throw (ex);
    return r;
  }

  bool loadFontConfigFile (Encoding aEncoding, const char *aPath)
  {
    SIGNDOC_Exception *ex = NULL;
    bool r;
    r = (bool)SIGNDOC_DocumentLoader_loadFontConfigFile (&ex, p, aEncoding, aPath);
    if (ex != NULL) SignDoc_throw (ex);
    return r;
  }

  bool loadFontConfigFile (const wchar_t *aPath)
  {
    SIGNDOC_Exception *ex = NULL;
    bool r;
    r = (bool)SIGNDOC_DocumentLoader_loadFontConfigFileW (&ex, p, aPath);
    if (ex != NULL) SignDoc_throw (ex);
    return r;
  }

  bool loadFontConfigEnvironment (const char *aName)
  {
    SIGNDOC_Exception *ex = NULL;
    bool r;
    r = (bool)SIGNDOC_DocumentLoader_loadFontConfigEnvironment (&ex, p, aName);
    if (ex != NULL) SignDoc_throw (ex);
    return r;
  }

  bool loadFontConfigStream (InputStream &aStream, Encoding aEncoding,
                             const char *aDirectory)
  {
    SIGNDOC_Exception *ex = NULL;
    bool r;
    r = (bool)SIGNDOC_DocumentLoader_loadFontConfigStream (&ex, p, aStream.getImpl (), aEncoding, aDirectory);
    if (ex != NULL) SignDoc_throw (ex);
    return r;
  }

  bool loadFontConfigStream (InputStream &aStream, const wchar_t *aDirectory)
  {
    SIGNDOC_Exception *ex = NULL;
    bool r;
    r = (bool)SIGNDOC_DocumentLoader_loadFontConfigStreamW (&ex, p, aStream.getImpl (), aDirectory);
    if (ex != NULL) SignDoc_throw (ex);
    return r;
  }

  bool loadPdfFontConfigFile (Encoding aEncoding, const char *aPath)
  {
    SIGNDOC_Exception *ex = NULL;
    bool r;
    r = (bool)SIGNDOC_DocumentLoader_loadPdfFontConfigFile (&ex, p, aEncoding, aPath);
    if (ex != NULL) SignDoc_throw (ex);
    return r;
  }

  bool loadPdfFontConfigFile (const wchar_t *aPath)
  {
    SIGNDOC_Exception *ex = NULL;
    bool r;
    r = (bool)SIGNDOC_DocumentLoader_loadPdfFontConfigFileW (&ex, p, aPath);
    if (ex != NULL) SignDoc_throw (ex);
    return r;
  }

  bool loadPdfFontConfigEnvironment (const char *aName)
  {
    SIGNDOC_Exception *ex = NULL;
    bool r;
    r = (bool)SIGNDOC_DocumentLoader_loadPdfFontConfigEnvironment (&ex, p, aName);
    if (ex != NULL) SignDoc_throw (ex);
    return r;
  }

  bool loadPdfFontConfigStream (InputStream &aStream, Encoding aEncoding,
                                const char *aDirectory)
  {
    SIGNDOC_Exception *ex = NULL;
    bool r;
    r = (bool)SIGNDOC_DocumentLoader_loadPdfFontConfigStream (&ex, p, aStream.getImpl (), aEncoding, aDirectory);
    if (ex != NULL) SignDoc_throw (ex);
    return r;
  }

  bool loadPdfFontConfigStream (InputStream &aStream,
                                const wchar_t *aDirectory)
  {
    SIGNDOC_Exception *ex = NULL;
    bool r;
    r = (bool)SIGNDOC_DocumentLoader_loadPdfFontConfigStreamW (&ex, p, aStream.getImpl (), aDirectory);
    if (ex != NULL) SignDoc_throw (ex);
    return r;
  }

  void getFailedFontFiles (std::vector<std::string> &aOutput)
  {
    SIGNDOC_Exception *ex = NULL;
    SIGNDOC_StringArray *tempOutput = NULL;
    try
      {
        tempOutput = SIGNDOC_StringArray_new (&ex);
        if (ex != NULL) SignDoc_throw (ex);
        SIGNDOC_DocumentLoader_getFailedFontFiles (&ex, p, tempOutput);
        assignArray (aOutput, tempOutput);
      }
    catch (...)
      {
        if (tempOutput != NULL)
          SIGNDOC_StringArray_delete (tempOutput);
        throw;
      }
    if (tempOutput != NULL)
      SIGNDOC_StringArray_delete (tempOutput);
    if (ex != NULL) SignDoc_throw (ex);
  }

  bool loadTrustedCertificatesFromFile (Encoding aEncoding, const char *aPath)
  {
    SIGNDOC_Exception *ex = NULL;
    bool r;
    r = (bool)SIGNDOC_DocumentLoader_loadTrustedCertificatesFromFile (&ex, p, aEncoding, aPath);
    if (ex != NULL) SignDoc_throw (ex);
    return r;
  }

  bool loadTrustedCertificatesFromFile (const wchar_t *aPath)
  {
    SIGNDOC_Exception *ex = NULL;
    bool r;
    r = (bool)SIGNDOC_DocumentLoader_loadTrustedCertificatesFromFileW (&ex, p, aPath);
    if (ex != NULL) SignDoc_throw (ex);
    return r;
  }

  bool loadTrustedCertificatesFromStream (InputStream &aStream)
  {
    SIGNDOC_Exception *ex = NULL;
    bool r;
    r = (bool)SIGNDOC_DocumentLoader_loadTrustedCertificatesFromStream (&ex, p, aStream.getImpl ());
    if (ex != NULL) SignDoc_throw (ex);
    return r;
  }

  bool initLogging (Encoding aEncoding, const char *aLevel,
                    const char *aPathname)
  {
    SIGNDOC_Exception *ex = NULL;
    bool r;
    r = (bool)SIGNDOC_DocumentLoader_initLogging (&ex, p, aEncoding, aLevel, aPathname);
    if (ex != NULL) SignDoc_throw (ex);
    return r;
  }

  const char *getErrorMessage (Encoding aEncoding) const
  {
    SIGNDOC_Exception *ex = NULL;
    const char *r;
    r = SIGNDOC_DocumentLoader_getErrorMessage (&ex, p, aEncoding);
    if (ex != NULL) SignDoc_throw (ex);
    return r;
  }

  const wchar_t *getErrorMessageW () const
  {
    SIGNDOC_Exception *ex = NULL;
    const wchar_t *r;
    r = SIGNDOC_DocumentLoader_getErrorMessageW (&ex, p);
    if (ex != NULL) SignDoc_throw (ex);
    return r;
  }

  bool registerDocumentHandler (SignDocDocumentHandler *aHandler)
  {
    SIGNDOC_Exception *ex = NULL;
    bool r;
    r = (bool)SIGNDOC_DocumentLoader_registerDocumentHandler (&ex, p, aHandler == NULL ? NULL : aHandler->getImpl ());
    if (ex == NULL) aHandler->destroyWithoutImpl ();
    if (ex != NULL) SignDoc_throw (ex);
    return r;
  }

  void setFlags (unsigned aFlags)
  {
    SIGNDOC_Exception *ex = NULL;
    SIGNDOC_DocumentLoader_setFlags (&ex, p, aFlags);
    if (ex != NULL) SignDoc_throw (ex);
  }

private:
  SignDocDocumentLoader (const SignDocDocumentLoader &);

  SignDocDocumentLoader &operator= (const SignDocDocumentLoader &);

private:
public:
  SignDocDocumentLoader (SIGNDOC_DocumentLoader *aP) : p (aP) { }

  SIGNDOC_DocumentLoader *getImpl () { return p; }

  const SIGNDOC_DocumentLoader *getImpl () const { return p; }

  void setImpl (SIGNDOC_DocumentLoader *aP) { SIGNDOC_DocumentLoader_delete (p); p  = aP; }

private:
  SIGNDOC_DocumentLoader *p;
};

class SignDocVerificationResult 
{
public:
  enum ReturnCode
  {
    rc_ok = SignDocDocument::rc_ok, 
    rc_invalid_argument = SignDocDocument::rc_invalid_argument, 
    rc_not_supported = SignDocDocument::rc_not_supported, 
    rc_not_verified = SignDocDocument::rc_not_verified, 
    rc_property_not_found = SignDocDocument::rc_property_not_found, 
    rc_no_biometric_data = SignDocDocument::rc_no_biometric_data, 
    rc_unexpected_error = SignDocDocument::rc_unexpected_error 
  };

  enum SignatureState
  {
    ss_unmodified,            
    ss_document_extended,     
    ss_document_modified,     
    ss_unsupported_signature, 
    ss_invalid_certificate,   
    ss_empty                  
  };

  enum ModificationState
  {
    ms_unmodified,

    ms_allowed,

    ms_prohibited
  };

  enum TimeStampState
  {
    tss_valid,                
    tss_missing,              
    tss_invalid               
  };

  enum CertificateChainState
  {
    ccs_ok,                   
    ccs_broken_chain,         
    ccs_untrusted_root,       
    ccs_critical_extension,   
    ccs_not_time_valid,       
    ccs_path_length,          
    ccs_invalid,              
    ccs_error                 
  };

  enum CertificateRevocationState
  {
    crs_ok,                     
    crs_not_checked,            
    crs_offline,                
    crs_revoked,                
    crs_error                   
  };

public:
  SignDocVerificationResult ()
    : p (NULL)
  {
  }

  ~SignDocVerificationResult ()
  {
    SIGNDOC_VerificationResult_delete (p);
  }

  ReturnCode getState (SignatureState &aOutput)
  {
    SIGNDOC_Exception *ex = NULL;
    int tempOutput = 0;
    ReturnCode r;
    try
      {
        r = (ReturnCode)SIGNDOC_VerificationResult_getState (&ex, p, &tempOutput);
        aOutput = (SignatureState )tempOutput;
      }
    catch (...)
      {
        throw;
      }
    if (ex != NULL) SignDoc_throw (ex);
    return r;
  }

  ReturnCode getModificationState (ModificationState &aOutput)
  {
    SIGNDOC_Exception *ex = NULL;
    int tempOutput = 0;
    ReturnCode r;
    try
      {
        r = (ReturnCode)SIGNDOC_VerificationResult_getModificationState (&ex, p, &tempOutput);
        aOutput = (ModificationState )tempOutput;
      }
    catch (...)
      {
        throw;
      }
    if (ex != NULL) SignDoc_throw (ex);
    return r;
  }

  ReturnCode getMethod (SignDocSignatureParameters::Method &aOutput)
  {
    SIGNDOC_Exception *ex = NULL;
    int tempOutput = 0;
    ReturnCode r;
    try
      {
        r = (ReturnCode)SIGNDOC_VerificationResult_getMethod (&ex, p, &tempOutput);
        aOutput = (SignDocSignatureParameters::Method )tempOutput;
      }
    catch (...)
      {
        throw;
      }
    if (ex != NULL) SignDoc_throw (ex);
    return r;
  }

  int getDocMDP ()
  {
    SIGNDOC_Exception *ex = NULL;
    int r;
    r = SIGNDOC_VerificationResult_getDocMDP (&ex, p);
    if (ex != NULL) SignDoc_throw (ex);
    return r;
  }

  int getLockMDP ()
  {
    SIGNDOC_Exception *ex = NULL;
    int r;
    r = SIGNDOC_VerificationResult_getLockMDP (&ex, p);
    if (ex != NULL) SignDoc_throw (ex);
    return r;
  }

  ReturnCode getDigestAlgorithm (std::string &aOutput)
  {
    SIGNDOC_Exception *ex = NULL;
    char *tempOutput = NULL;
    ReturnCode r;
    try
      {
        r = (ReturnCode)SIGNDOC_VerificationResult_getDigestAlgorithm (&ex, p, &tempOutput);
        if (tempOutput != NULL)
          aOutput = tempOutput;
      }
    catch (...)
      {
        SIGNDOC_free (tempOutput);
        throw;
      }
    SIGNDOC_free (tempOutput);
    if (ex != NULL) SignDoc_throw (ex);
    return r;
  }

  ReturnCode getCertificates (std::vector<std::vector<unsigned char> > &aOutput)
  {
    SIGNDOC_Exception *ex = NULL;
    SIGNDOC_ByteArrayArray *tempOutput = NULL;
    ReturnCode r;
    try
      {
        tempOutput = SIGNDOC_ByteArrayArray_new (&ex);
        if (ex != NULL) SignDoc_throw (ex);
        r = (ReturnCode)SIGNDOC_VerificationResult_getCertificates (&ex, p, tempOutput);
        assignArray (aOutput, tempOutput);
      }
    catch (...)
      {
        if (tempOutput != NULL)
          SIGNDOC_ByteArrayArray_delete (tempOutput);
        throw;
      }
    if (tempOutput != NULL)
      SIGNDOC_ByteArrayArray_delete (tempOutput);
    if (ex != NULL) SignDoc_throw (ex);
    return r;
  }

  ReturnCode verifyCertificateChain (const SignDocVerificationParameters *aParameters,
                                     CertificateChainState &aOutput)
  {
    SIGNDOC_Exception *ex = NULL;
    int tempOutput = 0;
    ReturnCode r;
    try
      {
        r = (ReturnCode)SIGNDOC_VerificationResult_verifyCertificateChain (&ex, p, aParameters == NULL ? NULL : aParameters->getImpl (), &tempOutput);
        aOutput = (CertificateChainState )tempOutput;
      }
    catch (...)
      {
        throw;
      }
    if (ex != NULL) SignDoc_throw (ex);
    return r;
  }

  ReturnCode getCertificateRevocationState (CertificateRevocationState &aOutput)
  {
    SIGNDOC_Exception *ex = NULL;
    int tempOutput = 0;
    ReturnCode r;
    try
      {
        r = (ReturnCode)SIGNDOC_VerificationResult_getCertificateRevocationState (&ex, p, &tempOutput);
        aOutput = (CertificateRevocationState )tempOutput;
      }
    catch (...)
      {
        throw;
      }
    if (ex != NULL) SignDoc_throw (ex);
    return r;
  }

  ReturnCode verifyCertificateSimplified (const SignDocVerificationParameters *aParameters)
  {
    SIGNDOC_Exception *ex = NULL;
    ReturnCode r;
    r = (ReturnCode)SIGNDOC_VerificationResult_verifyCertificateSimplified (&ex, p, aParameters == NULL ? NULL : aParameters->getImpl ());
    if (ex != NULL) SignDoc_throw (ex);
    return r;
  }

  ReturnCode getCertificateChainLength (int &aOutput)
  {
    SIGNDOC_Exception *ex = NULL;
    ReturnCode r;
    r = (ReturnCode)SIGNDOC_VerificationResult_getCertificateChainLength (&ex, p, &aOutput);
    if (ex != NULL) SignDoc_throw (ex);
    return r;
  }

  ReturnCode getSignatureString (Encoding aEncoding, const std::string &aName,
                                 std::string &aOutput)
  {
    SIGNDOC_Exception *ex = NULL;
    char *tempOutput = NULL;
    ReturnCode r;
    try
      {
        r = (ReturnCode)SIGNDOC_VerificationResult_getSignatureString (&ex, p, aEncoding, aName.c_str (), &tempOutput);
        if (tempOutput != NULL)
          aOutput = tempOutput;
      }
    catch (...)
      {
        SIGNDOC_free (tempOutput);
        throw;
      }
    SIGNDOC_free (tempOutput);
    if (ex != NULL) SignDoc_throw (ex);
    return r;
  }

  ReturnCode getSignatureBlob (const std::string &aName,
                               std::vector<unsigned char> &aOutput)
  {
    SIGNDOC_Exception *ex = NULL;
    SIGNDOC_ByteArray *tempOutput = NULL;
    ReturnCode r;
    try
      {
        tempOutput = SIGNDOC_ByteArray_new (&ex);
        if (ex != NULL) SignDoc_throw (ex);
        r = (ReturnCode)SIGNDOC_VerificationResult_getSignatureBlob (&ex, p, aName.c_str (), tempOutput);
        assignArray (aOutput, tempOutput);
      }
    catch (...)
      {
        if (tempOutput != NULL)
          SIGNDOC_ByteArray_delete (tempOutput);
        throw;
      }
    if (tempOutput != NULL)
      SIGNDOC_ByteArray_delete (tempOutput);
    if (ex != NULL) SignDoc_throw (ex);
    return r;
  }

  ReturnCode getBiometricData (const unsigned char *aKeyPtr, size_t aKeySize,
                               const wchar_t *aKeyPath,
                               const char *aPassphrase,
                               std::vector<unsigned char> &aOutput)
  {
    SIGNDOC_Exception *ex = NULL;
    SIGNDOC_ByteArray *tempOutput = NULL;
    ReturnCode r;
    try
      {
        tempOutput = SIGNDOC_ByteArray_new (&ex);
        if (ex != NULL) SignDoc_throw (ex);
        r = (ReturnCode)SIGNDOC_VerificationResult_getBiometricDataW (&ex, p, aKeyPtr, aKeySize, aKeyPath, aPassphrase, tempOutput);
        assignArray (aOutput, tempOutput);
      }
    catch (...)
      {
        if (tempOutput != NULL)
          SIGNDOC_ByteArray_delete (tempOutput);
        throw;
      }
    if (tempOutput != NULL)
      SIGNDOC_ByteArray_delete (tempOutput);
    if (ex != NULL) SignDoc_throw (ex);
    return r;
  }

  ReturnCode getBiometricData (Encoding aEncoding,
                               const unsigned char *aKeyPtr, size_t aKeySize,
                               const char *aKeyPath, const char *aPassphrase,
                               std::vector<unsigned char> &aOutput)
  {
    SIGNDOC_Exception *ex = NULL;
    SIGNDOC_ByteArray *tempOutput = NULL;
    ReturnCode r;
    try
      {
        tempOutput = SIGNDOC_ByteArray_new (&ex);
        if (ex != NULL) SignDoc_throw (ex);
        r = (ReturnCode)SIGNDOC_VerificationResult_getBiometricData (&ex, p, aEncoding, aKeyPtr, aKeySize, aKeyPath, aPassphrase, tempOutput);
        assignArray (aOutput, tempOutput);
      }
    catch (...)
      {
        if (tempOutput != NULL)
          SIGNDOC_ByteArray_delete (tempOutput);
        throw;
      }
    if (tempOutput != NULL)
      SIGNDOC_ByteArray_delete (tempOutput);
    if (ex != NULL) SignDoc_throw (ex);
    return r;
  }

  ReturnCode getEncryptedBiometricData (std::vector<unsigned char> &aOutput)
  {
    SIGNDOC_Exception *ex = NULL;
    SIGNDOC_ByteArray *tempOutput = NULL;
    ReturnCode r;
    try
      {
        tempOutput = SIGNDOC_ByteArray_new (&ex);
        if (ex != NULL) SignDoc_throw (ex);
        r = (ReturnCode)SIGNDOC_VerificationResult_getEncryptedBiometricData (&ex, p, tempOutput);
        assignArray (aOutput, tempOutput);
      }
    catch (...)
      {
        if (tempOutput != NULL)
          SIGNDOC_ByteArray_delete (tempOutput);
        throw;
      }
    if (tempOutput != NULL)
      SIGNDOC_ByteArray_delete (tempOutput);
    if (ex != NULL) SignDoc_throw (ex);
    return r;
  }

  ReturnCode getBiometricEncryption (SignDocSignatureParameters::BiometricEncryption &aOutput)
  {
    SIGNDOC_Exception *ex = NULL;
    int tempOutput = 0;
    ReturnCode r;
    try
      {
        r = (ReturnCode)SIGNDOC_VerificationResult_getBiometricEncryption (&ex, p, &tempOutput);
        aOutput = (SignDocSignatureParameters::BiometricEncryption )tempOutput;
      }
    catch (...)
      {
        throw;
      }
    if (ex != NULL) SignDoc_throw (ex);
    return r;
  }

  ReturnCode checkBiometricHash (const unsigned char *aBioPtr, size_t aBioSize,
                                 bool &aOutput)
  {
    SIGNDOC_Exception *ex = NULL;
    SIGNDOC_Boolean tempOutput = 0;
    ReturnCode r;
    try
      {
        r = (ReturnCode)SIGNDOC_VerificationResult_checkBiometricHash (&ex, p, aBioPtr, aBioSize, &tempOutput);
        aOutput = (bool )tempOutput;
      }
    catch (...)
      {
        throw;
      }
    if (ex != NULL) SignDoc_throw (ex);
    return r;
  }

  ReturnCode getTimeStampState (TimeStampState &aOutput)
  {
    SIGNDOC_Exception *ex = NULL;
    int tempOutput = 0;
    ReturnCode r;
    try
      {
        r = (ReturnCode)SIGNDOC_VerificationResult_getTimeStampState (&ex, p, &tempOutput);
        aOutput = (TimeStampState )tempOutput;
      }
    catch (...)
      {
        throw;
      }
    if (ex != NULL) SignDoc_throw (ex);
    return r;
  }

  ReturnCode getTimeStampDigestAlgorithm (std::string &aOutput)
  {
    SIGNDOC_Exception *ex = NULL;
    char *tempOutput = NULL;
    ReturnCode r;
    try
      {
        r = (ReturnCode)SIGNDOC_VerificationResult_getTimeStampDigestAlgorithm (&ex, p, &tempOutput);
        if (tempOutput != NULL)
          aOutput = tempOutput;
      }
    catch (...)
      {
        SIGNDOC_free (tempOutput);
        throw;
      }
    SIGNDOC_free (tempOutput);
    if (ex != NULL) SignDoc_throw (ex);
    return r;
  }

  ReturnCode verifyTimeStampCertificateChain (const SignDocVerificationParameters *aParameters,
                                              CertificateChainState &aOutput)
  {
    SIGNDOC_Exception *ex = NULL;
    int tempOutput = 0;
    ReturnCode r;
    try
      {
        r = (ReturnCode)SIGNDOC_VerificationResult_verifyTimeStampCertificateChain (&ex, p, aParameters == NULL ? NULL : aParameters->getImpl (), &tempOutput);
        aOutput = (CertificateChainState )tempOutput;
      }
    catch (...)
      {
        throw;
      }
    if (ex != NULL) SignDoc_throw (ex);
    return r;
  }

  ReturnCode getTimeStampCertificateRevocationState (CertificateRevocationState &aOutput)
  {
    SIGNDOC_Exception *ex = NULL;
    int tempOutput = 0;
    ReturnCode r;
    try
      {
        r = (ReturnCode)SIGNDOC_VerificationResult_getTimeStampCertificateRevocationState (&ex, p, &tempOutput);
        aOutput = (CertificateRevocationState )tempOutput;
      }
    catch (...)
      {
        throw;
      }
    if (ex != NULL) SignDoc_throw (ex);
    return r;
  }

  ReturnCode verifyTimeStampCertificateSimplified (const SignDocVerificationParameters *aParameters)
  {
    SIGNDOC_Exception *ex = NULL;
    ReturnCode r;
    r = (ReturnCode)SIGNDOC_VerificationResult_verifyTimeStampCertificateSimplified (&ex, p, aParameters == NULL ? NULL : aParameters->getImpl ());
    if (ex != NULL) SignDoc_throw (ex);
    return r;
  }

  ReturnCode getTimeStamp (std::string &aOutput)
  {
    SIGNDOC_Exception *ex = NULL;
    char *tempOutput = NULL;
    ReturnCode r;
    try
      {
        r = (ReturnCode)SIGNDOC_VerificationResult_getTimeStamp (&ex, p, &tempOutput);
        if (tempOutput != NULL)
          aOutput = tempOutput;
      }
    catch (...)
      {
        SIGNDOC_free (tempOutput);
        throw;
      }
    SIGNDOC_free (tempOutput);
    if (ex != NULL) SignDoc_throw (ex);
    return r;
  }

  ReturnCode getTimeStampCertificates (std::vector<std::vector<unsigned char> > &aOutput)
  {
    SIGNDOC_Exception *ex = NULL;
    SIGNDOC_ByteArrayArray *tempOutput = NULL;
    ReturnCode r;
    try
      {
        tempOutput = SIGNDOC_ByteArrayArray_new (&ex);
        if (ex != NULL) SignDoc_throw (ex);
        r = (ReturnCode)SIGNDOC_VerificationResult_getTimeStampCertificates (&ex, p, tempOutput);
        assignArray (aOutput, tempOutput);
      }
    catch (...)
      {
        if (tempOutput != NULL)
          SIGNDOC_ByteArrayArray_delete (tempOutput);
        throw;
      }
    if (tempOutput != NULL)
      SIGNDOC_ByteArrayArray_delete (tempOutput);
    if (ex != NULL) SignDoc_throw (ex);
    return r;
  }

  const char *getErrorMessage (Encoding aEncoding) const
  {
    SIGNDOC_Exception *ex = NULL;
    const char *r;
    r = SIGNDOC_VerificationResult_getErrorMessage (&ex, p, aEncoding);
    if (ex != NULL) SignDoc_throw (ex);
    return r;
  }

  const wchar_t *getErrorMessageW () const
  {
    SIGNDOC_Exception *ex = NULL;
    const wchar_t *r;
    r = SIGNDOC_VerificationResult_getErrorMessageW (&ex, p);
    if (ex != NULL) SignDoc_throw (ex);
    return r;
  }
  SignDocVerificationResult (SIGNDOC_VerificationResult *aP) : p (aP) { }

  SIGNDOC_VerificationResult *getImpl () { return p; }

  const SIGNDOC_VerificationResult *getImpl () const { return p; }

  void setImpl (SIGNDOC_VerificationResult *aP) { SIGNDOC_VerificationResult_delete (p); p  = aP; }

private:
  SIGNDOC_VerificationResult *p;
};

class SignDocPdfDocumentHandler : public SignDocDocumentHandler
{
public:

  static SignDocDocumentHandler *create ()
  {
    SIGNDOC_Exception *ex = NULL;
    SIGNDOC_DocumentHandler *r;
    r = SIGNDOC_PdfDocumentHandler_new (&ex);
    if (ex != NULL) SignDoc_throw (ex);
    if (r == NULL)
      return NULL;
    try
      {
        return new SignDocDocumentHandler (r);
      }
    catch (...)
      {
        SIGNDOC_DocumentHandler_delete (r);
        throw;
      }
  }

private:
  SignDocPdfDocumentHandler ();

  SignDocPdfDocumentHandler (const SIGNDOC_PdfDocumentHandler &);

  SignDocPdfDocumentHandler& operator= (const SIGNDOC_PdfDocumentHandler &);
};

class SignDocTiffDocumentHandler : public SignDocDocumentHandler
{
public:

  static SignDocDocumentHandler *create ()
  {
    SIGNDOC_Exception *ex = NULL;
    SIGNDOC_DocumentHandler *r;
    r = SIGNDOC_TiffDocumentHandler_new (&ex);
    if (ex != NULL) SignDoc_throw (ex);
    if (r == NULL)
      return NULL;
    try
      {
        return new SignDocDocumentHandler (r);
      }
    catch (...)
      {
        SIGNDOC_DocumentHandler_delete (r);
        throw;
      }
  }

private:
  SignDocTiffDocumentHandler ();

  SignDocTiffDocumentHandler (const SIGNDOC_TiffDocumentHandler &);

  SignDocTiffDocumentHandler& operator= (const SIGNDOC_TiffDocumentHandler &);
};

inline SignDocVerificationResult *
makeSignDocVerificationResult (SIGNDOC_VerificationResult *aP)
{
  if (aP == NULL)
    return NULL;
  return new SignDocVerificationResult (aP);
}

#ifdef _MSC_VER
#pragma warning(pop)
#endif

}}}

#endif