#pragma once

#ifndef TSCANNER_H

#define TSCANNER_H

#include "trasterimage.h"

#include <set></set>

#include <qstring></qstring>

#undef DVAPI

#undef DVVAR

#ifdef TNZBASE_EXPORTS

#define DVAPI DV_EXPORT_API

#define DVVAR DV_EXPORT_VAR

#else

#define DVAPI DV_IMPORT_API

#define DVVAR DV_IMPORT_VAR

#endif

// forward declaration

class TOStream;

class TIStream;

class TFilePath;

struct DVAPI TScanParam {

  TScanParam()

      : m_supported(false)

      , m_min(0)

      , m_max(0)

      , m_def(0)

      , m_step(0)

      , m_value(0) {}

  TScanParam(float _min, float _max, float _def, float _step)

      : m_supported(true)

      , m_min(_min)

      , m_max(_max)

      , m_def(_def)

      , m_step(1)

      , m_value(_def) {}

  bool m_supported;

  float m_min, m_max, m_def, m_step,

      m_value;  // questi sono float per seguire lo standard TWAIN !

  void update(const TScanParam &model);

  // assegna min,max,def,step e supported da model a this

  // mantiene value a patto che sia contenuto nel nuovo range, diversamente ne

  // fa il crop

};

class DVAPI TScannerParameters {

public:

  enum ScanType { None, BW, GR8, RGB24 };

private:

  // Supported scan types: Black and white, graytones, color

  bool m_bw, m_gray, m_rgb;

  // Current scan type

  ScanType m_scanType;

  std::string m_paperFormat;  // e.g. "A4 paper"

  TRectD m_scanArea;  // in mm /* TWAIN preferirebbe gli inch, ma uso i mm per

                      // seguire tnz4.x*/

  TRectD m_cropBox;   // in mm /* TWAIN preferirebbe gli inch, ma uso i mm per

                      // seguire tnz4.x*/

  bool m_isPreview;

  TDimensionD m_maxPaperSize;  // in mm /* TWAIN preferirebbe gli inch, ma uso i

                               // mm per seguire tnz4.x*/

  bool m_paperOverflow;  // vale true se la scanArea e' stata tagliata rispetto

                         // alle dimensioni della carta

                         // per rispettare la maxPaperSize

  bool m_validatedByCurrentScanner;

  // vale false se bisogna ancora chiamare adaptToCurrentScanner()

  // l'idea e' di chiamare questo metodo il meno possibile

public:

  TScanParam m_brightness;

  TScanParam m_contrast;

  TScanParam m_threshold;

  TScanParam m_dpi;

  TScanParam m_paperFeeder;  // value==1.0 => use paper feeder

private:

  // other useful info ?!

  std::string m_twainVersion;

  std::string m_manufacturer;

  std::string m_prodFamily;

  std::string m_productName;

  std::string m_version;

  bool m_reverseOrder;  // if true then scan levels starting from last frame

  void cropScanArea();  // assicura che scanArea sia dentro maxPaperSize

public:

  TScannerParameters();

  ~TScannerParameters();

  void setSupportedTypes(bool bw, bool gray, bool rgb);

  bool isSupported(ScanType) const;

  void setMaxPaperSize(double maxWidth,

                       double maxHeight);  // note: possibly update m_scanArea

  std::string getPaperFormat() const { return m_paperFormat; }

  void setPaperFormat(std::string paperFormat);

  // assert(TPaperFormatManager::instance()->isValidFormat(paperFormat));

  // updates scanArea (cropping with maxPaperSize)

  void updatePaperFormat();

  // if paperFormat=="" set default paper format; recompute (to be sure!)

  // scanArea

  bool getPaperOverflow() const {

    return m_paperOverflow;

  }  // true iff paperSize > maxPaperSize

  TRectD getScanArea() const { return m_scanArea; }

  void setCropBox(const TRectD &cropBox) { m_cropBox = cropBox * m_scanArea; }

  TRectD getCropBox() const { return m_cropBox; }

  void setIsPreview(bool isPreview) { m_isPreview = isPreview; };

  bool isPreview() const { return m_isPreview; }

  bool isReverseOrder() const { return m_reverseOrder; }

  void setReverseOrder(bool reverseOrder) { m_reverseOrder = reverseOrder; }

  bool isPaperFeederEnabled() const { return m_paperFeeder.m_value == 1.0; }

  void enablePaperFeeder(bool on) { m_paperFeeder.m_value = on ? 1.0f : 0.0f; }

  void setScanType(ScanType scanType);

  ScanType getScanType() const { return m_scanType; }

  // se e' stato definito uno scanner aggiorna lo stato (enabled/disabled,

  // range, etc.)

  // dei parametri rispetto a quest'ultimo

  void adaptToCurrentScanner();

  void adaptToCurrentScannerIfNeeded() {

    if (!m_validatedByCurrentScanner) adaptToCurrentScanner();

  }

  void assign(const TScannerParameters *params);

  void saveData(TOStream &os) const;

  void loadData(TIStream &is);

};

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

class TScannerListener {

public:

  virtual void onImage(const TRasterImageP &) = 0;

  virtual void onError()                      = 0;

  virtual void onNextPaper()                  = 0;

  virtual void onAutomaticallyNextPaper()     = 0;

  virtual bool isCanceled()                   = 0;

  virtual ~TScannerListener() {}

};

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

class DVAPI TScanner {

  std::set<tscannerlistener *=""> m_listeners;</tscannerlistener>

protected:

  TScanParam m_brightness, m_contrast, m_threshold, m_dpi;

  int m_paperLeft;

  QString m_scannerName;

public:

  TScanner();

  virtual ~TScanner();

  static bool m_isTwain;  // brutto, brutto :(

  static TScanner *instance();

  virtual void selectDevice()      = 0;

  virtual bool isDeviceAvailable() = 0;

  virtual bool isDeviceSelected() { return false; }

  virtual void updateParameters(TScannerParameters ¶meters) = 0;

  // aggiorna i parametri 'parameters' in funzione del tipo di scanner

  // selezionato

  // se possibile non modifica i valori correnti, ma cambia solo quello che non

  // e' piu' adatto

  // abilita/disabilita i parametri "opzionali".

  // n.b. i parametri opzionali che vengono disabilitati mantengono il loro

  // valore

  // (cosi' se fai save default settings dopo aver cambiato scanner non ti perdi

  // i vecchi settaggi)

  virtual void acquire(const TScannerParameters ¶m, int paperCount) = 0;

  void addListener(TScannerListener *);

  void removeListener(TScannerListener *);

  void notifyImageDone(const TRasterImageP &image);

  void notifyNextPaper();

  void notifyAutomaticallyNextPaper();

  void notifyError();

  bool isScanningCanceled();

  int getPaperLeftCount() const { return m_paperLeft; }

  void setPaperLeftCount(int count) { m_paperLeft = count; }

  void decrementPaperLeftCount() { --m_paperLeft; }

  QString getName() const { return m_scannerName; }

  void setName(const QString &name) { m_scannerName = name; }

};

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

class DVAPI TPaperFormatManager {  // singleton

public:

  class Format {

  public:

    TDimensionD m_size;

    Format() : m_size(0, 0) {}

    Format(const TDimensionD &size) : m_size(size) {}

  };

private:

  typedef std::map<std::string, format=""> FormatTable;</std::string,>

  FormatTable m_formats;

  TPaperFormatManager();

  void readPaperFormat(const TFilePath &fp);

  void readPaperFormats();

public:

  static TPaperFormatManager *instance();

  // resitutisce la lista dei formati

  void getFormats(std::vector<std::string> &names) const;</std::string>

  bool isValidFormat(std::string name) const;

  std::string getDefaultFormat() const;

  // nome formato --> dimensione

  TDimensionD getSize(std::string name) const;

};

#endif