src/flbase/FLObjectFactory.h

Ir a la documentación de este archivo.

/***************************************************************************
 FLObjectFactory.h
 -------------------
 begin                : jue abr 23 2003
 copyright            : (C) 2003-2008 by InfoSiAL S.L.
 email                : mail@infosial.com
 ***************************************************************************/
/***************************************************************************
 *   This program is free software; you can redistribute it and/or modify  *
 *   it under the terms of the GNU General Public License as published by  *
 *   the Free Software Foundation; version 2 of the License.               *
 ***************************************************************************/
/***************************************************************************
 Este  programa es software libre. Puede redistribuirlo y/o modificarlo
 bajo  los  términos  de  la  Licencia  Pública General de GNU   en  su
 versión 2, publicada  por  la  Free  Software Foundation.
 ***************************************************************************/

#ifndef FLOBJECTFACTORY_H
#define FLOBJECTFACTORY_H

#include "FLApplication.h"
#include "FLSqlCursor.h"
#include "FLSqlQuery.h"
#include "FLUtil.h"
#include "FLTableMetaData.h"
#include "FLFormDB.h"
#include "FLFormRecordDB.h"
#include "FLFormSearchDB.h"
#include "FLFieldDB.h"
#include "FLTableDB.h"
#include "FLDataTable.h"
#include "FLManager.h"
#include "FLManagerModules.h"
#include "FLReportViewer.h"
#include "FLReportEngine.h"
#include "FLReportPages.h"
#include "FLCodBar.h"
#include "FLScriptEditor.h"
#include "FLAction.h"
#include "FLVar.h"
#include "FLAccessControlLists.h"
#include "FLSqlDatabase.h"
#include "posprinter.h"
#include "FLSqlConnections.h"
#include "FLSmtpClient.h"
#include "FLImageViewer.h"
#include "FLPicture.h"
#include "FLDiskCache.h"
#include "FLNetwork.h"
#include "FLTable.h"
#include "mimecodec.h"
#include "qextserialport.h"
#include "FLDigiDoc.h"

#include "AQConfig.h"

#include <qsobjectfactory.h>
#include <qapplication.h>
#include <qdatetime.h>
#include <qtable.h>
#include <qlistview.h>
#include <qdom.h>
#include <qtabwidget.h>
#include <qptrdict.h>

class FLDomNodeInterface;
class FLDomNodesCache;
class FLSqlQueryInterface;

#define DN_ ( dn_ ? dn_ : newNode() )



class  FLApplicationInterface : public QObject
{

  Q_OBJECT
  Q_ENUMS(FLScaleMode)

public:

  enum FLScaleMode {
    ScaleFree,
    ScaleMin,
    ScaleMax
  };

  FLApplicationInterface(FLApplication *obj) : QObject(obj) {
    obj_ = obj;
    connect(obj_, SIGNAL(databaseLockDetected()), this, SIGNAL(databaseLockDetected()));
  }

public slots:

  QWidget *mainWidget() const {
    return obj_->mainWidget();
  }

  QWidget *modMainWidget(const QString &idModulo) const {
    return obj_->modMainWidget(idModulo);
  }

  void statusHelpMsg(const QString &text) {
    obj_->statusHelpMsg(text);
  }

  void openMasterForm(const QString &n, const QPixmap &p = QPixmap()) {
    obj_->openMasterForm(n, p);
  }

  void execMainScript(const QString &n) {
    obj_->execMainScript(n);
  }

  void processEvents() {
    obj_->processEvents();
  }

  QString getWidgetList(const QString &wN, const QString &c) {
    return obj_->getWidgetList(wN, c);
  }

  QString getTabWidgetPages(const QString &wN, const QString &n) {
    return obj_->getTabWidgetPages(wN, n);
  }

  QString installPrefix() {
    return AQ_PREFIX;
  }

  QString diskCacheAbsDirPath() {
    return AQ_DISKCACHE_DIRPATH;
  }

  QString version() {
    return AQ_VERSION;
  }

  void updateAreas() {
    obj_->initToolBox();
  }

  bool isLoadedModule(const QString &idM, const QString &connName = "default") {
    return FLSqlConnections::database(connName)->managerModules()->listAllIdModules().contains(idM);
  }

  bool isDebugEnabled() {
#ifdef FL_DEBUG
    return true;
#endif
    return false;
  }

  bool isTestEnabled() {
    return false;
  }

  QString versionModule(const QString &idM, const QString &connName = "default") {
    return FLSqlConnections::database(connName)->managerModules()->versionModule(idM);
  }

  QString nameObjectScript(const QString &nFS) {
    qWarning("nameObjectScript: OBSOLETA no usar");
    return QString::null;
  }

  void showDocPage(const QString &url) {
    obj_->showDocPage(url);
  }

  QSArgument call(const QString &function, const QSArgumentList &arguments = QSArgumentList(),
                  const QString &nameObjectContext = QString::null) {
    return obj_->call(function, arguments, nameObjectContext);
  }

  QSArgument call(const QString &function, const QString &nameObjectContext) {
    return obj_->call(function, QSArgumentList(), nameObjectContext);
  }

  void setCaptionMainWidget(const QString &text) {
    obj_->setCaptionMainWidget(text);
  }

  QString lastTextCaption() const {
    return obj_->lastTextCaption();
  }

  QString nameDriver(const QString &connName = "default") const {
    return FLSqlConnections::database(connName)->driverName();
  }

  QString nameUser(const QString &connName = "default") const {
    return FLSqlConnections::database(connName)->user();
  }

  QString nameBD(const QString &connName = "default") const {
    return FLSqlConnections::database(connName)->database();
  }

  QString nameHost(const QString &connName = "default") const {
    return FLSqlConnections::database(connName)->host();
  }

  int portBD(const QString &connName = "default") const {
    return FLSqlConnections::database(connName)->port();
  }

  void installACL(const QString &idacl) {
    FLAccessControlLists *acl = obj_->acl();
    if (acl)
      acl->installACL(idacl);
  }

  QString idSession() {
    return aqApp ->timeUser().toString(Qt::ISODate);
  }

  void printTextEdit(QTextEdit *editor) {
    obj_->printTextEdit(editor);
  }

  void reinit() {
    QTimer::singleShot(0, obj_, SLOT(reinit()));
  }

  void cleanupMetaData(const QString &connName = "default") {
    FLSqlConnections::database(connName)->manager()->cleanupMetaData();
  }

  void Mr_Proper(const QString &connName = "default") {
    FLSqlConnections::database(connName)->Mr_Proper();
  }

  bool addDatabase(const QString &driverAlias, const QString &nameDB, const QString &user,
                   const QString &password, const QString &host, int port, const QString &connectionName) {
    return FLSqlConnections::addDatabase(driverAlias, nameDB, user, password, host, port, connectionName);
  }

  bool addDatabase(const QString &newConnName, const QString &sourceConnName = "default") {
    FLSqlDatabase *srcDb = FLSqlConnections::database(sourceConnName);
    if (!srcDb)
      return false;
    return FLSqlConnections::addDatabase(srcDb->driverName(), srcDb->database(),
                                         srcDb->user(), srcDb->password(), srcDb->host(),
                                         srcDb->port(), newConnName);
  }

  bool removeDatabase(const QString &connectionName) {
    return FLSqlConnections::removeDatabase(connectionName);
  }

  QString toUnicode(const QString &text, const QString &codecName) {
    QTextCodec *codec = QTextCodec::codecForName(codecName);
    if (codec) {
      return codec->toUnicode(text);
    } else {
      return text;
    }
  }

  QCString fromUnicode(const QString &text, const QString &codecName) {
    QTextCodec *codec = QTextCodec::codecForName(codecName);
    if (codec)
      return codec->fromUnicode(text);
    else
      return text.utf8();
  }

  QCString canonicalForm(const QString &str) {
    return MIMECodec::canonicalForm(str.ascii());
  }

  QString mimeTranslate(const QString &str) {
    return MIMECodec::translate(str.ascii());
  }

  QCString fold(const QString &str) {
    return MIMECodec::fold(str.ascii());
  }

  QCString unfold(const QString &str) {
    return MIMECodec::unfold(str.ascii());
  }

  QCString encodeEndLine(const QString &str) {
    return MIMECodec::encodeEndLine(str.ascii());
  }

  QCString decodeEndLine(const QString &str) {
    return MIMECodec::decodeEndLine(str.ascii());
  }

  QCString encodeQuotedPrintable(const QString &str, bool compat = false) {
    return MIMECodec::encodeQuotedPrintable(str.ascii(), compat);
  }

  QCString decodeQuotedPrintable(const QString &str) {
    return MIMECodec::decodeQuotedPrintable(str.ascii());
  }

  QString dialogGetFileImage();

  QPixmap toPixmap(const QVariant &v);
  QPixmap toPixmap(const QString &s) {
    return toPixmap(QVariant(s));
  }

  QVariant fromPixmap(const QPixmap &p);

  QPixmap scalePixmap(const QPixmap &p, int w, int h,
                      FLScaleMode mode = FLApplicationInterface::ScaleFree);

  QPixmap pixmapFromMimeSource(const QString &abs_name) {
    return QPixmap::fromMimeSource(abs_name);
  }

  int transactionLevel() {
    return FLSqlCursor::transactionLevel();
  }

  bool addSysCode(const QString &code, const QString &scriptEntryFunction = QString::null) {
    return obj_->addSysCode(code, scriptEntryFunction);
  }

  void setScriptEntryFunction(const QString &scriptEntryFunction) {
    obj_->setScriptEntryFunction(scriptEntryFunction);
  }

  void setDatabaseLockDetection(bool on = true, int msecLapsus = 30000, int limChecks = -1,
                                bool showWarn = true, const QString &msgWarn = QString::null,
                                const QString &connectionName = "default") {
    obj_->setDatabaseLockDetection(on, msecLapsus, limChecks, showWarn, msgWarn, connectionName);
  }

  QStringList locksStatus(const QString &connectionName = "default") {
    return FLSqlConnections::database(connectionName)->locksStatus();
  }

  QStringList detectLocks(const QString &connectionName = "default") {
    return FLSqlConnections::database(connectionName)->detectLocks();
  }

  QStringList detectRisksLocks(const QString &table = QString::null, const QString &primaryKeyValue = QString::null,
                               const QString &connectionName = "default") {
    return FLSqlConnections::database(connectionName)->detectRisksLocks(table, primaryKeyValue);
  }

  void popupWarn(const QString &msgWarn,
                 const QMap<QString, QVariant> &scriptCalls);

  FLDomNodeInterface *toXmlReportData(FLSqlQueryInterface *q);

  QString translate(const QString &contexto, const QString &s) const {
    return obj_->translate(contexto, s);
  }
  QString translate(const QString &s) const {
    return obj_->translate("scripts", s);
  }

  QString trMulti(const QString &s, const QString &l) {
    return obj_->trMulti(s, l);
  }

  void setMultiLang(bool enable = true, const QString &langid = QString::null) {
    obj_->setMultiLang(enable, langid);
  }

  bool multiLangEnabled() const {
    return obj_->multiLangEnabled();
  }

  QString multiLangId() const {
    return obj_->multiLangId();
  }

  void openQSWorkbench() {
    obj_->openQSWorkbench();
  }

  void evaluateProject() {
    obj_->evaluateProject();
  }

  QString osName() const {
    return FLUtil::getOS();
  }

  QString localLang() const {
    return FLUtil::getIdioma();
  }

  QString localEncoding() const {
    QTextCodec *codec = QTextCodec::codecForLocale();
    return (codec ? codec->mimeName() : "");
  }

  bool isQuickBuild() const {
#ifdef AQ_QUICK_BUILD
    return true;
#endif
    return false;
  }

  bool isDebuggerBuild() const {
#ifdef AQ_DEBUGGER_BUILD
    return true;
#endif
    return false;
  }

  bool isNebulaBuild() const {
#ifdef AQ_NEBULA_BUILD
    return true;
#endif
    return false;
  }

  FLApplication *obj() {
    return obj_;
  }

signals:

  void databaseLockDetected();

private:

  FLApplication *obj_;
};

class FLSqlCursorsCache;


class  FLSqlCursorInterface : public QObject
{
  Q_OBJECT
  Q_ENUMS(Mode)
  Q_ENUMS(AcosConditionEval)

public:

  enum Mode {
    Insert = 0,
    Edit = 1,
    Del = 2,
    Browse = 3
  };

  enum AcosConditionEval {
    Value = 0,
    Regexp = 1,
    Function = 2
  };

  FLSqlCursorInterface(const QString &n = QString::null,
                       const QString &connName = "default") :
    QObject(0), obj_(0), cursorRelation_(0), cached_(false) {
    if (!n.isEmpty()) {
      obj_ = new FLSqlCursor(n, true, connName, 0, 0, this);
      if (obj_->cursorRelation())
        cursorRelation_ = sqlCursorInterface(obj_->cursorRelation());
      connects();
    }
  }

  FLSqlCursorInterface(QObject *obj) :
    QObject(obj), obj_(0), cursorRelation_(0), cached_(false) {
    setObj(::qt_cast<FLSqlCursor *>(obj));
  }

  ~FLSqlCursorInterface() {
    if (cached_ && obj_)
      removeCache();
  }

  void setObj(FLSqlCursor *obj);

  static FLSqlCursorInterface *sqlCursorInterface(FLSqlCursor *c);

public slots:

  int modeAccess() const {
    return (obj_ ? obj_->modeAccess() : 0);
  }

  bool setEditMode() {
    return (obj_ ? obj_->setEditMode() : false);
  }

  QString mainFilter() const {
    return (obj_ ? obj_->mainFilter() : QString::null);
  }

  void setMainFilter(const QString &f) {
    if (obj_)
      obj_->setMainFilter(QString(f).replace("NaN", ""));
  }

  void setModeAccess(const int m) {
    if (obj_)
      obj_->setModeAccess(m);
  }

  void setAtomicValueBuffer(const QString &fN, const QString &functionName) {
    if (obj_)
      obj_->setAtomicValueBuffer(fN, functionName);
  }

  void setValueBuffer(const QString &fN, const QVariant &v) {
    if (obj_) {
      if (v.isValid() && !v.isNull()) {
        if (v.toString().upper() == "NAN") {
          obj_->setValueBuffer(fN, QVariant());
          return;
        }
      }
      obj_->setValueBuffer(fN, v);
    }
  }
  void setValueBuffer(const QString &fN, const QString &v) {
    setValueBuffer(fN, QVariant(v));
  }
  void setValueBuffer(const QString &fN, bool v) {
    setValueBuffer(fN, QVariant(v));
  }
  void setValueBuffer(const QString &fN, double v) {
    setValueBuffer(fN, QVariant(v));
  }
  void setValueBuffer(const QString &fN, int v) {
    setValueBuffer(fN, QVariant(v));
  }

  QVariant valueBuffer(const QString &fN) const {
    return (obj_ ? obj_->valueBuffer(fN) : QVariant());
  }

  QVariant valueBufferCopy(const QString &fN) const {
    return (obj_ ? obj_->valueBufferCopy(fN) : QVariant());
  }

  bool isNull(const QString &name) const {
    return (obj_ ? obj_->bufferIsNull(name) : false);
  }

  void setNull(const QString &name) {
    if (obj_)
      obj_->bufferSetNull(name);
  }

  bool isCopyNull(const QString &name) const {
    return (obj_ ? obj_->bufferCopyIsNull(name) : false);
  }

  void setCopyNull(const QString &name) {
    if (obj_)
      obj_->bufferCopySetNull(name);
  }

  void setEdition(bool b) {
    if (obj_)
      obj_->setEdition(b);
  }

  void setBrowse(bool b) {
    if (obj_)
      obj_->setBrowse(b);
  }

  bool fieldDisabled(const QString &fN) {
    return (obj_ ? obj_->fieldDisabled(fN) : false);
  }

  bool inTransaction() {
    return (obj_ ? obj_->inTransaction() : false);
  }

  bool transaction(bool lock) {
    return (obj_ ? obj_->transaction(lock) : false);
  }

  bool rollback() {
    return (obj_ ? obj_->rollback() : false);
  }

  bool commit() {
    return (obj_ ? obj_->commit() : false);
  }

  void setAskForCancelChanges(bool a) {
    if (obj_)
      obj_->setAskForCancelChanges(a);
  }

  void setActivatedCheckIntegrity(bool a) {
    if (obj_)
      obj_->setActivatedCheckIntegrity(a);
  }

  void setActivatedCommitActions(bool a) {
    if (obj_)
      obj_->setActivatedCommitActions(a);
  }

  QString msgCheckIntegrity() {
    return (obj_ ? obj_->msgCheckIntegrity() : QString::null);
  }

  bool checkIntegrity(bool showError = true) {
    return (obj_ ? obj_->checkIntegrity(showError) : false);
  }

  void refresh(const QString &fN = QString::null) {
    if (obj_)
      obj_->refresh(fN);
  }

  bool refreshBuffer() {
    return (obj_ ? obj_->refreshBuffer() : false);
  }

  int at() {
    return (obj_ ? obj_->at() : -1);
  }

  bool seek(int i, bool relative = false, bool emite = false) {
    return (obj_ ? obj_->seek(i, relative, emite) : false);
  }

  bool next(bool emite = true) {
    return (obj_ ? obj_->next(emite) : false);
  }

  bool prev(bool emite = true) {
    return (obj_ ? obj_->prev(emite) : false);
  }

  bool first(bool emite = true) {
    return (obj_ ? obj_->first(emite) : false);
  }

  bool last(bool emite = true) {
    return (obj_ ? obj_->last(emite) : false);
  }

  int del(bool invalidate = true) {
    return (obj_ ? obj_->del(invalidate) : false);
  }

  bool select(const QString &filter, const QSqlIndex &sort = QSqlIndex()) {
    return (obj_ ? obj_->select(QString(filter).replace("NaN", ""), sort) : false);
  }

  bool select() {
    if (!obj_)
      return false;
    obj_->QSqlCursor::setFilter(obj_->curFilter());
    return obj_->QSqlCursor::select();
  }

  int size() {
    return (obj_ ? obj_->size() : 0);
  }

  int atFrom() {
    return (obj_ ? obj_->atFrom() : -1);
  }

  int atFromBinarySearch(const QString &fN, const QString &v, bool orderAsc = true) {
    return (obj_ ? obj_->atFromBinarySearch(fN, v, orderAsc) : -1);
  }

  bool commitBuffer(bool checkLocks = false) {
    return (obj_ ? obj_->commitBuffer(true, checkLocks) : false);
  }

  bool commitBufferCursorRelation() {
    return (obj_ ? obj_->commitBufferCursorRelation() : false);
  }

  FLSqlCursorInterface *cursorRelation() {
    return cursorRelation_;
  }

  void setContext(QObject *c) {
    if (obj_)
      obj_->setContext(c);
  }

  QObject *context() const {
    return (obj_ ? obj_->context() : 0);
  }

  QString action() {
    if (!obj_)
      return QString::null;
    if (!obj_->action())
      return QString::null;
    return obj_->action() ->name();
  }

  void setAction(const QString &action) {
    if (obj_) {
      const FLAction *a = obj_->db()->manager()->action(action);
      if (a)
        obj_->setAction(a);
    }
  }

  void setUnLock(const QString &fN, bool v) {
    if (obj_)
      obj_->setUnLock(fN, v);
  }

  bool isLocked() {
    return (obj_ ? obj_->isLocked() : false);
  }

  void editRecord() {
    if (obj_) {
      if (obj_->parent() == this) {
        removeChild(obj_);
        if (qApp->focusWidget())
          qApp->focusWidget()->insertChild(obj_);
      }
      obj_->editRecord();
    }
  }

  void insertRecord() {
    if (obj_) {
      if (obj_->parent() == this) {
        removeChild(obj_);
        if (qApp->focusWidget())
          qApp->focusWidget()->insertChild(obj_);
      }
      obj_->insertRecord();
    }
  }

  void browseRecord() {
    if (obj_) {
      if (obj_->parent() == this) {
        removeChild(obj_);
        if (qApp->focusWidget())
          qApp->focusWidget()->insertChild(obj_);
      }
      obj_->browseRecord();
    }
  }

  void chooseRecord() {
    if (obj_)
      obj_->chooseRecord();
  }

  QString table() const {
    return (obj_ ? (obj_->metadata() ? obj_->metadata() ->name() : QString::null) : QString::null);
  }

  const int fieldType(const QString &fN) const {
    return (obj_ ? (obj_->metadata() ? obj_->metadata() ->fieldType(fN) : 0) : 0);
  }

  QString primaryKey() const {
    return (obj_ ? (obj_->metadata() ? obj_->metadata() ->primaryKey() : QString::null) : QString::null);
  }

  bool isValid() const {
    return (obj_ ? obj_->isValid() : false);
  }

  bool isModifiedBuffer() {
    return (obj_ ? obj_->isModifiedBuffer() : false);
  }

  int transactionLevel() {
    return FLSqlCursor::transactionLevel();
  }

  QStringList transactionsOpened() {
    return (obj_ ? obj_->transactionsOpened() : QStringList());
  }

  void rollbackOpened(int count = -1, const QString &msg = QString::null) {
    if (obj_)
      obj_->rollbackOpened(count, msg);
  }

  void commitOpened(int count = -1, const QString &msg = QString::null) {
    if (obj_)
      obj_->commitOpened(count, msg);
  }

  void checkRisksLocks(bool terminate = false) {
    if (obj_)
      obj_->checkRisksLocks(terminate);
  }

  void setAcTable(const QString &ac) {
    if (obj_)
      obj_->setAcTable(ac);
  }

  void setAcosTable(const QStringList &acos) {
    if (obj_)
      obj_->setAcosTable(acos);
  }

  void setAcosCondition(const QString &condName, int cond, const QVariant &condVal) {
    if (obj_)
      obj_->setAcosCondition(condName, (FLSqlCursor::AcosConditionEval) cond, condVal);
  }

  void clearAcosCondition() {
    if (obj_)
      obj_->setAcosCondition(QString::null, FLSqlCursor::VALUE, QVariant());
  }

  void setForwardOnly(bool forward) {
    obj_->setForwardOnly(forward);
  }

  QStringList concurrencyFields() {
    return obj_->concurrencyFields();
  }

  FLSqlCursor *obj() {
    return obj_;
  }

  void emitNewBuffer() {
    emit newBuffer();
  }
  void emitBufferChanged(const QString &v) {
    emit bufferChanged(v);
  }
  void emitCursorUpdated() {
    emit cursorUpdated();
  }
  void emitRecordChoosed() {
    emit recordChoosed();
  }
  void emitCurrentChanged(int v) {
    emit currentChanged(v);
  }
  void emitAutoCommit() {
    emit autoCommit();
  }
  void emitBufferCommited() {
    emit bufferCommited();
  }

signals:

  void newBuffer();

  void bufferChanged(const QString &);

  void cursorUpdated();

  void recordChoosed();

  void currentChanged(int);

  void autoCommit();

  void bufferCommited();

private:

  void connects() const;
  void removeCache();

  FLSqlCursor *obj_;
  FLSqlCursorInterface *cursorRelation_;
  bool cached_;

  static FLSqlCursorsCache *cursorsCache;

  friend class FLObjectFactory;
};


class  FLSqlQueryInterface : public QObject
{
  Q_OBJECT

public:

  FLSqlQueryInterface(const QString &n = QString::null, const QString &connName = "default") : QObject(0) {
    if (n.isEmpty())
      obj_ = new FLSqlQuery(this, connName);
    else
      obj_ = FLSqlConnections::database(connName)->manager()->query(n, this);
  }

  FLSqlQueryInterface(FLSqlQuery *obj) : QObject(obj), obj_(0) {
    obj_ = obj;
  }

public slots:

  QString select() const {
    return obj_->select();
  }

  QString from() const {
    return obj_->from();
  }

  QString where() const {
    return obj_->where();
  }

  QString orderBy() const {
    return obj_->orderBy();
  }

  void setSelect(const QString &s, const QString &sep = QString::fromLatin1(",")) {
    obj_->setSelect(s, sep);
  }

  void setFrom(const QString &f) {
    obj_->setFrom(QString(f).replace("NaN", ""));
  }

  void setWhere(const QString &w) {
    obj_->setWhere(QString(w).replace("NaN", ""));
  }

  void setOrderBy(const QString &oB) {
    obj_->setOrderBy(QString(oB).replace("NaN", ""));
  }

  QString sql() const {
    return obj_->sql();
  }

  QVariant value(int i) const {
    return obj_->value(i);
  }

  QVariant value(const QString &n) const {
    return obj_->value(n);
  }

  bool isNull(int i) const {
    return obj_->isNull(i);
  }

  bool isNull(QString n) const {
    return obj_->isNull(n);
  }



  QString posToFieldName(const int p) const {
    return obj_->posToFieldName(p);
  }

  int fieldNameToPos(const QString &n) const {
    return obj_->fieldNameToPos(n);
  }

  void setTablesList(const QString &tl) {
    obj_->setTablesList(tl);
  }

  QVariant valueParam(const QString &name) const {
    return obj_->valueParam(name);
  }

  void setValueParam(const QString &name, const QVariant &v) {
    obj_->setValueParam(name, v);
  }

  bool next() {
    return obj_->next();
  }

  bool prev() {
    return obj_->prev();
  }

  bool first() {
    return obj_->first();
  }

  bool last() {
    return obj_->last();
  }

  bool exec() {
    return obj_->exec();
  }

  void showDebug() {
    obj_->showDebug();
  }

  int size() const {
    return obj_->size();
  }

  void setForwardOnly(bool forward) {
    obj_->setForwardOnly(forward);
  }

  FLSqlQuery *obj() {
    return obj_;
  }

private:

  FLSqlQuery *obj_;
};


class  FLFieldDBInterface : public QObject
{
  Q_OBJECT

  Q_PROPERTY(QString fieldName READ fieldName WRITE setFieldName)
  Q_PROPERTY(QString tableName READ tableName WRITE setTableName)
  Q_PROPERTY(QString foreignField READ foreignField WRITE setForeignField)
  Q_PROPERTY(QString fieldRelation READ fieldRelation WRITE setFieldRelation)
  Q_PROPERTY(QString fieldAlias READ fieldAlias WRITE setFieldAlias)
  Q_PROPERTY(QString actionName READ actionName WRITE setActionName)
  Q_PROPERTY(bool showAlias READ showAlias WRITE setShowAlias)
  Q_PROPERTY(bool showEditor READ showEditor WRITE setShowEditor)
  Q_PROPERTY(int textFormat READ textFormat WRITE setTextFormat)

public:

  FLFieldDBInterface(QWidget *p, const QString &n) : QObject(p) {
    obj_ = new FLFieldDB(p, n);
    if (obj_)
      connects();
  }

  FLFieldDBInterface(FLFieldDB *obj) : QObject(obj) {
    obj_ = obj;
    if (obj_)
      connects();
  }

  FLFieldDBInterface() : QObject(0) {}

public slots:

  FLSqlCursorInterface *cursor() {
    if (!obj_)
      return new FLSqlCursorInterface();
    return FLSqlCursorInterface::sqlCursorInterface(obj_->cursor());
  }

  void setDisabled(const bool b) {
    obj_->setDisabled(b);
    obj_->setKeepDisabled(b);
  }

  QString actionName() const {
    return obj_->actionName();
  }

  void setActionName(const QString &aN) {
    obj_->setActionName(aN);
  }

  QString fieldName() const {
    return obj_->fieldName();
  }

  void setFieldName(const QString &fN) {
    obj_->setFieldName(fN);
  }

  QString tableName() const {
    return obj_->tableName();
  }

  void setTableName(const QString &fT) {
    obj_->setTableName(fT);
  }

  QString foreignField() const {
    return obj_->foreignField();
  }

  void setForeignField(const QString &fN) {
    obj_->setForeignField(fN);
  }

  QString fieldRelation() const {
    return obj_->fieldRelation();
  }

  QString fieldAlias() const {
    return obj_->fieldAlias();
  }

  QWidget *editor() const {
    return obj_->editor();
  }

  void setFilter(const QString &f) {
    obj_->setFilter(f);
  }

  QString filter() const {
    return obj_->filter();
  }

  void setFieldRelation(const QString &fN) {
    obj_->setFieldRelation(fN);
  }

  void setFieldAlias(const QString &alias) {
    obj_->setFieldAlias(alias);
  }

  void setValue(const QVariant &v) {
    if (v.isValid() && !v.isNull()) {
      if (v.toString().upper() == "NAN") {
        obj_->setValue(QVariant());
        return;
      }
    }
    obj_->setValue(v);
  }
  void setValue(const QString &v) {
    setValue(QVariant(v));
  }
  void setValue(bool v) {
    setValue(QVariant(v));
  }
  void setValue(double v) {
    setValue(QVariant(v));
  }
  void setValue(int v) {
    setValue(QVariant(v));
  }

  void setPixmap(const QString &filename) {
    obj_->setPixmap(filename);
  }

  void setFocus() {
    obj_->setFocus();
  }

  void selectAll() {
    obj_->selectAll();
  }

  QVariant value() {
    obj_->showWidget();
    return obj_->value();
  }

  void close() {
    obj_->close();
  }

  int insertAccel(const QString &key) {
    obj_->insertAccel(key);
  }

  void removeAccel(int id) {
    obj_->removeAccel(id);
  }

  void setTextFormat(const int &f) {
    Qt::TextFormat tt;
    switch (f) {
      case 0: {
        tt = Qt::PlainText;
        break;
      }
      case 1: {
        tt = Qt::RichText;
        break;
      }
      case 2: {
        tt = Qt::AutoText;
        break;
      }
      case 3: {
        tt = Qt::LogText;
        break;
      }
      default : {
        return;
      }
    }
    obj_->setTextFormat(tt);
  }

  int textFormat() const {
    return obj_->textFormat();
  }

  void emitActivatedAccel(int id) {
    emit activatedAccel(id);
  }

  bool showAlias() const {
    return obj_->showAlias();
  }

  void setShowAlias(const bool value) {
    obj_->setShowAlias(value);
  }

  bool showEditor() const {
    return obj_->showEditor();
  }

  void setShowEditor(const bool show) {
    obj_->setShowEditor(show);
  }

  void setPartDecimal(int d) {
    obj_->setPartDecimal(d);
  }

  FLFieldDB *obj() {
    return obj_;
  }

signals:

  void activatedAccel(int);

  void keyF2Pressed();

  void keyF4Pressed();

  void keyReturnPressed();

private:

  void connects() const;

  FLFieldDB *obj_;
};


class  FLTableDBInterface : public QObject
{
  Q_OBJECT

  Q_PROPERTY(QString tableName READ tableName WRITE setTableName)
  Q_PROPERTY(QString foreignField READ foreignField WRITE setForeignField)
  Q_PROPERTY(QString fieldRelation READ fieldRelation WRITE setFieldRelation)
  Q_PROPERTY(bool checkColumnEnabled READ checkColumnEnabled WRITE setCheckColumnEnabled)
  Q_PROPERTY(QString aliasCheckColumn READ aliasCheckColumn WRITE setAliasCheckColumn)
  Q_PROPERTY(bool findHidden READ findHidden WRITE setFindHidden)
  Q_PROPERTY(bool filterHidden READ filterHidden WRITE setFilterHidden)
  Q_PROPERTY(bool showAllPixmaps READ showAllPixmaps WRITE setShowAllPixmaps)
  Q_PROPERTY(QString functionGetColor READ functionGetColor WRITE setFunctionGetColor)

public:

  FLTableDBInterface(QWidget *p, const QString &n) : QObject(p) {
    obj_ = new FLTableDB(p, n);
    if (obj_)
      connects();
  }

  FLTableDBInterface(FLTableDB *obj) : QObject(obj) {
    obj_ = obj;
    if (obj_)
      connects();
  }

  FLTableDBInterface() : QObject(0) {}

public slots:

  QString tableName() const {
    return obj_->tableName();
  }

  void setTableName(const QString &fT) {
    obj_->setTableName(fT);
  }

  QString foreignField() const {
    return obj_->foreignField();
  }

  void setForeignField(const QString &fN) {
    obj_->setForeignField(fN);
  }

  QString fieldRelation() const {
    return obj_->fieldRelation();
  }

  void setFieldRelation(const QString &fN) {
    obj_->setFieldRelation(fN);
  }

  void setReadOnly(const bool mode) {
    obj_->setReadOnly(mode);
  }

  void setEditOnly(const bool mode) {
    obj_->setEditOnly(mode);
  }

  void setInsertOnly(const bool mode) {
    obj_->setInsertOnly(mode);
  }

  void refresh() {
    obj_->refresh(false, true);
  }

  void refresh(const bool refreshHead, const bool refreshData) {
    obj_->refresh(refreshHead, refreshData);
  }

  void insertRecord() {
    obj_->insertRecord();
  }

  void editRecord() {
    obj_->editRecord();
  }

  void browseRecord() {
    obj_->browseRecord();
  }

  void deleteRecord() {
    obj_->deleteRecord();
  }

  void copyRecord() {
    obj_->copyRecord();
  }

  void show() {
    obj_->show();
  }

  void setFocus() {
    obj_->setFocus();
  }

  void setFilter(const QString &f) {
    obj_->setFilter(f);
  }

  QString filter() {
    return obj_->filter();
  }

  QString findFilter() const {
    return obj_->findFilter();
  }

  void setInitSearch(const QString &iS) {
    obj_->setInitSearch(iS);
  }

  FLSqlCursorInterface *cursor() {
    if (!obj_)
      return new FLSqlCursorInterface();
    return FLSqlCursorInterface::sqlCursorInterface(obj_->cursor());
  }

  void emitReadOnlyChanged(bool b) {
    emit readOnlyChanged(b);
  }

  void emitEditOnlyChanged(bool b) {
    emit editOnlyChanged(b);
  }

  void emitInsertOnlyChanged(bool b) {
    emit insertOnlyChanged(b);
  }

  void emitCurrentChanged() {
    emit currentChanged();
  }

  void setCurrentRow(const int r) {
    FLDataTable *t = obj_->tableRecords();
    if (t) {
      obj_->showWidget();
      t->selectRow(r);
    }
  }

  int currentRow(void) {
    FLDataTable *t = obj_->tableRecords();
    if (t) {
      obj_->showWidget();
      return t->currentRow();
    }
    return -1;
  }

  void close() {
    obj_->close();
  }

  FLTableDB *obj() {
    return obj_;
  }

  void setDisabled(const bool b) {
    obj_->setDisabled(b);
  }

  void putFirstCol(const QString &c) {
    obj_->putFirstCol(c);
  }

  void moveCol(const QString &from, const QString &to) {
    obj_->moveCol(from, to);
  }

  void setOrderCols(QStringList &fields) {
    obj_->setOrderCols(fields);
  }

  QStringList orderCols() {
    return obj_->orderCols();
  }

  bool checkColumnEnabled() const {
    return obj_->checkColumnEnabled();
  }

  void setCheckColumnEnabled(bool b) {
    obj_->setCheckColumnEnabled(b);
  }

  QString aliasCheckColumn() const {
    return obj_->aliasCheckColumn();
  }

  void setAliasCheckColumn(const QString &t) {
    obj_->setAliasCheckColumn(t);
  }

  QStringList primarysKeysChecked();

  void clearChecked() {
    FLDataTable *dt = obj_->tableRecords();
    if (dt)
      dt->clearChecked();
  }

  void setPrimaryKeyChecked(const QVariant &primaryKeyValue, bool on) {
    FLDataTable *dt = obj_->tableRecords();
    if (dt)
      dt->setPrimaryKeyChecked(primaryKeyValue, on);
  }

  void emitPrimaryKeyToggled(const QVariant &primaryKeyValue, bool on) {
    emit primaryKeyToggled(primaryKeyValue, on);
  }

  bool findHidden() const {
    return obj_->findHidden();
  }

  void setFindHidden(bool h) {
    obj_->setFindHidden(h);
  }

  bool filterHidden() const {
    return obj_->filterHidden();
  }

  void setFilterHidden(bool h) {
    obj_->setFilterHidden(h);
  }

  void setColumnWidth(const QString &field, int w) {
    obj_->setColumnWidth(field, w);
  }

  int columnWidth(int c) {
    return obj_->columnWidth(c);
  }

  void setRowHeight(int row, int h) {
    obj_->setRowHeight(row, h);
  }

  int rowHeight(int row) {
    return obj_->rowHeight(row);
  }

  bool showAllPixmaps() const {
    return obj_->showAllPixmaps();
  }

  void setShowAllPixmaps(bool s) {
    obj_->setShowAllPixmaps(s);
  }

  QString functionGetColor() const {
    return obj_->functionGetColor();
  }

  void setFunctionGetColor(const QString &f) {
    obj_->setFunctionGetColor(f);
  }

signals:

  void readOnlyChanged(bool);

  void editOnlyChanged(bool);

  void insertOnlyChanged(bool);

  void currentChanged();

  void primaryKeyToggled(const QVariant &, bool);

private:

  void connects() const;

  FLTableDB *obj_;
};


#define NEW_TABLE if (!obj_) { obj_ = new FLTable(qApp->mainWidget()); connects(); }

class FLTableInterface : public QObject
{
  Q_OBJECT
  Q_ENUMS(CellAlignment)

public:

  FLTableInterface(QWidget *p, const QString &n) : QObject(p) {
    obj_ = new FLTable(p, n);
    if (obj_)
      connects();
  }

  FLTableInterface() : QObject(0), obj_(0) {}

  FLTableInterface(QTable *t) : QObject(t), obj_(t) {
    connects();
  }

  enum CellAlignment {
    AlignAuto = Qt::AlignAuto,
    AlignLeft = Qt::AlignLeft,
    AlignRight = Qt::AlignRight,
    AlignHCenter = Qt::AlignHCenter,
    AlignJustify = Qt::AlignJustify,
    AlignTop = Qt::AlignTop,
    AlignBottom = Qt::AlignBottom,
    AlignVCenter = Qt::AlignVCenter,
    AlignCenter = Qt::AlignCenter
  };

public slots:

  void setRowReadOnly(int row, bool ro) {
    NEW_TABLE
    obj_->setRowReadOnly(row, ro);
  }

  void sortColumn(int col, bool ascending = true, bool wholeRows = false) {
    NEW_TABLE
    obj_->sortColumn(col, ascending, wholeRows);
  }

  void setColumnReadOnly(int col, bool ro) {
    NEW_TABLE
    obj_->setColumnReadOnly(col, ro);
  }

  void removeRow(int row) {
    NEW_TABLE
    obj_->removeRow(row);
  }

  void clear();

  void editCell(int row, int col) {
    NEW_TABLE
    obj_->editCell(row, col, false);
  }

  void hideColumn(int col) {
    NEW_TABLE
    obj_->hideColumn(col);
  }

  void hideRow(int row) {
    NEW_TABLE
    obj_->hideRow(row);
  }

  void showColumn(int col) {
    NEW_TABLE
    obj_->showColumn(col);
  }

  void showRow(int row) {
    NEW_TABLE
    obj_->showRow(row);
  }

  QString text(int row, int col) {
    NEW_TABLE
    return obj_->text(row, col);
  }

  void setColumnLabels(const QString &sep, const QString &str) {
    NEW_TABLE
    QStringList sL = QStringList::split(sep, str);
    obj_->setColumnLabels(sL);
  }

  void setRowLabels(const QString &sep, const QString &str) {
    NEW_TABLE
    QStringList sL = QStringList::split(sep, str);
    obj_->setRowLabels(sL);
  }

  void setLeftMargin(int m) {
    NEW_TABLE
    obj_->setLeftMargin(m);
  }

  void setTopMargin(int m) {
    NEW_TABLE
    obj_->setTopMargin(m);
  }

  void setNumCols(const int c) {
    NEW_TABLE
    obj_->setNumCols(c);
  }

  void setNumRows(const int r) {
    NEW_TABLE
    obj_->setNumRows(r);
  }

  void setColumnWidth(const int c, const int w) {
    NEW_TABLE
    obj_->setColumnWidth(c, w);
  }

  int columnWidth(int c) {
    NEW_TABLE
    return obj_->columnWidth(c);
  }

  void setRowHeight(int row, int h) {
    NEW_TABLE
    obj_->setRowHeight(row, h);
  }

  int rowHeight(int row) {
    NEW_TABLE
    return obj_->rowHeight(row);
  }

  int currentRow() {
    NEW_TABLE
    return obj_->currentRow();
  }

  int currentColumn() {
    NEW_TABLE
    return obj_->currentColumn();
  }

  void selectRow(int row) {
    NEW_TABLE
    obj_->selectRow(row);
  }

  int numRows() {
    NEW_TABLE
    return obj_->numRows();
  }

  int numCols() {
    NEW_TABLE
    return obj_->numCols();
  }

  void swapRows(int row1, int row2, bool swapHeader = false) {
    NEW_TABLE
    return obj_->swapRows(row1, row2, swapHeader);
  }

  void swapColumns(int col1, int col2, bool swapHeader = false) {
    NEW_TABLE
    return obj_->swapColumns(col1, col2, swapHeader);
  }

  void repaintContents() {
    NEW_TABLE
    return obj_->repaintContents();
  }

  void clearSelection(bool repaint = true) {
    NEW_TABLE
    return obj_->clearSelection(repaint);
  }

  QStringList selectedRows();

  QStringList selectedCols();

  QStringList selectedCells();

  void setText(int row, int col, const QString &text) {
    NEW_TABLE
    int d = row - obj_->numRows() + 1;
    if (d > 0)
      insertRows(obj_->numRows() - 1, d);
    d = col - obj_->numCols() + 1;
    if (d > 0)
      insertColumns(obj_->numCols() - 1, d);
    obj_->setText(row, col, text);
  }

  void insertRows(int row, int count = 1) {
    NEW_TABLE
    obj_->insertRows(row, count);
  }

  void insertColumns(int col, int count = 1) {
    NEW_TABLE
    obj_->insertColumns(col, count);
  }

  void adjustColumn(int col) {
    NEW_TABLE
    obj_->adjustColumn(col);
  }

  void adjustRow(int fil) {
    NEW_TABLE
    obj_->adjustRow(fil);
  }

  void setPixmap(int row, int col, const QPixmap &pix) {
    NEW_TABLE
    obj_->setPixmap(row, col, pix);
  }

  QPixmap pixmap(int row, int col) {
    NEW_TABLE
    return obj_->pixmap(row, col);
  }

  void emitCurrentChanged(int row, int col) {
    emit currentChanged(row, col);
  }

  void emitClicked(int row, int col, int, const QPoint &) {
    emit clicked(row, col);
  }

  void emitDoubleClicked(int row, int col, int, const QPoint &) {
    emit doubleClicked(row, col);
  }

  void emitValueChanged(int row, int col) {
    emit valueChanged(row, col);
  }

  void emitSelectionChanged() {
    emit selectionChanged();
  }

signals:

  void currentChanged(int, int);

  void clicked(int, int);

  void doubleClicked(int, int);

  void valueChanged(int, int);

  void selectionChanged();

protected:

  void connects() const;

  QTable *obj_;
};

class  FLTablePlusInterface : public FLTableInterface
{
  Q_OBJECT

public:

  FLTablePlusInterface(QWidget *p, const QString &n) : FLTableInterface(p, n) {
  }

  FLTablePlusInterface(FLTable *t) : FLTableInterface(::qt_cast<QTable *>(t)) {
  }

public slots:

  void setCellBackgroundColor(int row, int col, const QColor &color) {
    NEW_TABLE
    int d = row - obj_->numRows() + 1;
    if (d > 0)
      insertRows(obj_->numRows() - 1, d);
    d = col - obj_->numCols() + 1;
    if (d > 0)
      insertColumns(obj_->numCols() - 1, d);

    FLTable *t = ::qt_cast<FLTable *>(obj_);
    if (t)
      t->setCellBackgroundColor(row, col, color);
  }

  void setCellAlignment(int row, int col, const int a) {
    NEW_TABLE
    int d = row - obj_->numRows() + 1;
    if (d > 0)
      insertRows(obj_->numRows() - 1, d);
    d = col - obj_->numCols() + 1;
    if (d > 0)
      insertColumns(obj_->numCols() - 1, d);

    FLTable *t = ::qt_cast<FLTable *>(obj_);
    if (t)
      t->setCellAlignment(row, col, a);
  }
};


#define NEW_VIEW if (!obj_) { obj_ = new QListView(qApp->mainWidget()); connects(); }

class FLListViewItemInterface;

class FLListViewItem : public QListViewItem
{
public:

  FLListViewItem(QListView *parent): QListViewItem(parent) {}
  FLListViewItem(QListViewItem *parent): QListViewItem(parent) {}
  FLListViewItem(FLListViewItem *parent): QListViewItem(parent) {}
  void setKey(const QString &k) {
    key_ = k;
  }
  QString key() const {
    return key_;
  }

private:

  QString key_;
};

class  FLListViewInterface : public QObject
{
  Q_OBJECT

public:

  FLListViewInterface(QWidget *p, const QString &n) : QObject(p) {
    obj_ = new QListView(p, n);
    if (obj_)
      connects();
  }

  FLListViewInterface() : QObject(0), obj_(0) {}

  FLListViewInterface(QListView *t) : QObject(t), obj_(t) {
    connects();
  }

public slots:

  int addColumn(const QString &label, int width = -1) {
    NEW_VIEW
    obj_->addColumn(label, width);
  }

  void setColumnText(int column, const QString &label) {
    NEW_VIEW
    obj_->setColumnText(column, label);
  }

  void setColumnAlignment(int column, int align) {
    NEW_VIEW
    obj_->setColumnAlignment(column, align);
  }

  QListView *obj() {
    NEW_VIEW
    return obj_;
  }

  void clear() {
    NEW_VIEW
    obj_->clear();
  }

  FLListViewItemInterface *firstChild() const;

  void emitDoubleClicked(QListViewItem *lvI);
  void emitExpanded(QListViewItem *lvI);
  void emitSelectionChanged(QListViewItem *lvI);

signals:

  void doubleClicked(FLListViewItemInterface *);
  void expanded(FLListViewItemInterface *);
  void selectionChanged(FLListViewItemInterface *);

private:

  void connects() const;

  QListView *obj_;
};


class  FLListViewItemInterface : public QObject
{
  Q_OBJECT

public:

  FLListViewItemInterface(FLListViewInterface *parent) : QObject(0), obj_(0) {
    if (parent)
      obj_ = new FLListViewItem(parent->obj());
  }

  FLListViewItemInterface(FLListViewItemInterface *parent) : QObject(0), obj_(0) {
    if (parent)
      obj_ = new FLListViewItem(parent->obj());
  }

  FLListViewItemInterface() : QObject(0), obj_(0) {}

  FLListViewItemInterface(FLListViewItem *lvI) : QObject(0), obj_(0) {
    if (lvI)
      setObj(lvI);
  }

  ~FLListViewItemInterface() {}

public slots:

  void setKey(const QString &k) {
    obj_->setKey(k);
  }

  QString key() const {
    return obj_->key();
  }

  void setText(int column, const QString &text) {
    obj_->setText(column, text);
  }

  QString text(int column) const {
    return obj_->text(column);
  }

  FLListViewItem *obj() {
    return obj_;
  }

  void setObj(FLListViewItem *lvI) {
    obj_ = lvI;
  }

  void setOpen(bool o) {
    obj_->setOpen(o);
  }

  FLListViewItemInterface *firstChild() const;

  FLListViewItemInterface *nextSibling() const;

  FLListViewItemInterface *parent() const;

  void del() {
    delete obj_;
  }

  void setExpandable(bool enable) {
    obj_->setExpandable(enable);
  }

  bool isExpandable() const {
    return obj_->isExpandable();
  }

  void setPixmap(int column, const QVariant &pm);

private:

  FLListViewItem *obj_;
};


class  FLTabWidgetInterface : public QObject
{
  Q_OBJECT

public:

  FLTabWidgetInterface() {
    obj_ = new QTabWidget(qApp->mainWidget());
    connects();
  }

  FLTabWidgetInterface(QTabWidget *t) : QObject(t), obj_(t) {
    if (obj_)
      connects();
  }

public slots:

  void setTabEnabled(int index, bool enable) {
    obj_->setTabEnabled(obj_->page(index), enable);
  }

  void setTabEnabled(const QString &name, bool enable);

  void removePage(int index) {
    obj_->removePage(obj_->page(index));
  }

  void removePage(const QString &name);

  void showPage(int index) {
    obj_->showPage(obj_->page(index));
  }

  void showPage(const QString &name);

  void emitCurrentChanged(QWidget *w) {
    if (w)
      emit currentChanged(QString::fromLatin1(w->name()));
  }

signals:

  void currentChanged(const QString &);

private:

  void connects() const;

  QTabWidget *obj_;
};


class  FLFormDBInterface : public QObject
{
  Q_OBJECT

public:

  FLFormDBInterface(const QString &a, QWidget *p, WFlags f = 0)
    : QObject(p), obj_(0), cursor_(0), script_(0) {
    setObj(new FLFormDB(a, p ? p : aqApp->mainWidget(), f));
  }

  FLFormDBInterface(FLSqlCursorInterface *c, const QString &a, QWidget *p, WFlags f = 0)
    : QObject(p), obj_(0), cursor_(0), script_(0) {
    setObj(new FLFormDB(c->obj(), a, p ? p : aqApp->mainWidget(), f));
  }

  FLFormDBInterface(FLFormDB *obj) : QObject(obj), obj_(0), cursor_(0), script_(0) {
    setObj(obj);
  }

  FLFormDBInterface() : QObject(0), obj_(0), cursor_(0), script_(0) {}

  ~FLFormDBInterface() {
  }

  void setObj(FLFormDB *obj) {
    obj_ = obj;
    if (obj_) {
      setName(obj_->name());
      cursor_ = FLSqlCursorInterface::sqlCursorInterface(obj_->cursor());
      connects();
    } else
      cursor_ = 0;
  }

  void setObjCursor(FLSqlCursor *c) {
    if (c && obj_)
      cursor_ = FLSqlCursorInterface::sqlCursorInterface(obj_->cursor());
  }

  void setScript(QSScript *s) {
    script_ = s;
  }

  QSScript *script() {
    return script_;
  }

public slots:

  void setCursor(FLSqlCursorInterface *c) {
    if (c && obj_) {
      obj_->setCursor(c->obj());
      cursor_ = FLSqlCursorInterface::sqlCursorInterface(obj_->cursor());
    }
  }

  FLSqlCursorInterface *cursor() {
    if (!cursor_ && obj_)
      cursor_ = FLSqlCursorInterface::sqlCursorInterface(obj_->cursor());
    return (cursor_ ? cursor_ : new FLSqlCursorInterface());
  }

  QWidget *mainWidget() const {
    return (obj_ ? obj_->mainWidget() : 0);
  }

  void setMainWidget(QWidget *w) {
    if (obj_)
      obj_->setMainWidget(w);
  }

  void setMainWidget() {
    if (obj_)
      obj_->setMainWidget();
  }

  void setMainWidget(const QString &uiFileName) {
    if (obj_)
      obj_->setMainWidget(uiFileName);
  }

  QWidget *parentWidget() {
    return (obj_ ? obj_->parentWidget() : 0);
  }

  QObject *child(const QString &objName) {
    if (!obj_)
      return 0;
    QObject *o = obj_->child(objName, "QWidget");
    if (o) {
      if (::qt_cast<FLFieldDB *>(o)) {
        return new FLFieldDBInterface(static_cast<FLFieldDB *>(o));
      }
      if (::qt_cast<FLTableDB *>(o)) {
        return new FLTableDBInterface(static_cast<FLTableDB *>(o));
      }
      if (::qt_cast<FLTable *>(o)) {
        return new FLTablePlusInterface(static_cast<FLTable *>(o));
      }
      if (::qt_cast<QTable *>(o)) {
        return new FLTableInterface(static_cast<QTable *>(o));
      }
      if (::qt_cast<QTabWidget *>(o)) {
        return new FLTabWidgetInterface(static_cast<QTabWidget *>(o));
      }
      if (::qt_cast<QListView *>(o)) {
        return new FLListViewInterface(static_cast<QListView *>(o));
      }
    }
    return o;
  }

  bool close() {
    if (obj_) {
      bool ret = obj_->close();
      obj_ = 0;
      return ret;
    } else
      return false;
  }

  FLFormDB *obj() {
    return obj_;
  }

  void setDisabled(const bool b) {
    if (obj_)
      obj_->setDisabled(b);
  }

  QImage snapShot() {
    return (obj_ ? obj_->snapShot() : QImage());
  }

  void saveSnapShot(const QString &pathFile) {
    if (obj_)
      obj_->saveSnapShot(pathFile);
  }

  void show() {
    if (obj_)
      obj_->show();
  }

  void showForDocument() {
    if (obj_)
      obj_->showForDocument();
  }

  void setMaximized() {
    if (obj_)
      obj_->setMaximized();
  }

signals:

  void closed();

  void formReady();

private:

  void connects() const;

  FLFormDB *obj_;
  FLSqlCursorInterface *cursor_;
  QSScript *script_;
};


class  FLFormRecordDBInterface : public QObject
{
  Q_OBJECT

public:

  FLFormRecordDBInterface(FLSqlCursorInterface *c, const QString &a, QWidget *p, bool sA) : QObject(p), obj_(0),
    cursor_(0), script_(0) {
    setObj(new FLFormRecordDB(c->obj(), a, aqApp->mainWidget(), sA));
  }

  FLFormRecordDBInterface(FLFormRecordDB *obj) : QObject(obj), obj_(0), cursor_(0), script_(0) {
    setObj(obj);
  }

  FLFormRecordDBInterface() : QObject(0), obj_(0), cursor_(0), script_(0) {}

  ~FLFormRecordDBInterface() {}

  void finish() {}

  void setObj(FLFormRecordDB *obj) {
    obj_ = obj;
    if (obj_) {
      setName(obj_->name());
      cursor_ = FLSqlCursorInterface::sqlCursorInterface(obj_->cursor());
      connects();
    } else
      cursor_ = 0;
  }

  void setObjCursor(FLSqlCursor *c) {
    if (c && obj_)
      cursor_ = FLSqlCursorInterface::sqlCursorInterface(obj_->cursor());
  }

  void setScript(QSScript *s) {
    script_ = s;
  }

  QSScript *script() {
    return script_;
  }

public slots:

  void setCursor(FLSqlCursorInterface *c) {
    if (c) {
      if (obj_) {
        obj_->setCursor(c->obj());
        cursor_ = FLSqlCursorInterface::sqlCursorInterface(obj_->cursor());
      } else
        cursor_ = c;
    }
  }

  FLSqlCursorInterface *cursor() {
    if (!cursor_ && obj_)
      cursor_ = FLSqlCursorInterface::sqlCursorInterface(obj_->cursor());
    return (cursor_ ? cursor_ : new FLSqlCursorInterface());
  }

  QWidget *mainWidget() const {
    return (obj_ ? obj_->mainWidget() : 0);
  }

  void setMainWidget(QWidget *w) {
    if (obj_)
      obj_->setMainWidget(w);
  }

  void setMainWidget() {
    if (obj_)
      obj_->setMainWidget();
  }

  void setMainWidget(const QString &uiFileName) {
    if (obj_)
      ::qt_cast<FLFormDB *>(obj_)->setMainWidget(uiFileName);
  }

  QObject *child(const QString &objName) {
    if (!obj_)
      return 0;
    QObject *o = obj_->child(objName, "QWidget");
    if (o) {
      if (::qt_cast<FLFieldDB *>(o)) {
        return new FLFieldDBInterface(static_cast<FLFieldDB *>(o));
      }
      if (::qt_cast<FLTableDB *>(o)) {
        return new FLTableDBInterface(static_cast<FLTableDB *>(o));
      }
      if (::qt_cast<FLTable *>(o)) {
        return new FLTablePlusInterface(static_cast<FLTable *>(o));
      }
      if (::qt_cast<QTable *>(o)) {
        return new FLTableInterface(static_cast<QTable *>(o));
      }
      if (::qt_cast<QTabWidget *>(o)) {
        return new FLTabWidgetInterface(static_cast<QTabWidget *>(o));
      }
      if (::qt_cast<QListView *>(o)) {
        return new FLListViewInterface(static_cast<QListView *>(o));
      }
    }
    return o;
  }

  bool close() {
    if (obj_) {
      bool ret = obj_->close();
      obj_ = 0;
      return ret;
    } else
      return false;
  }

  void accept() {
    if (obj_)
      obj_->accept();
  }

  void reject() {
    if (obj_)
      obj_->reject();
  }

  void acceptContinue() {
    if (obj_)
      obj_->acceptContinue();
  }

  FLFormRecordDB *obj() {
    return obj_;
  }

  void setDisabled(const bool b) {
    if (obj_)
      obj_->setDisabled(b);
  }

  QImage snapShot() {
    return (obj_ ? obj_->snapShot() : QImage());
  }

  void saveSnapShot(const QString &pathFile) {
    if (obj_)
      obj_->saveSnapShot(pathFile);
  }

  void show() {
    if (obj_)
      obj_->show();
  }

  void showForDocument() {
    if (obj_)
      obj_->showForDocument();
  }

  void setMaximized() {
    if (obj_)
      obj_->setMaximized();
  }

signals:

  void closed();

  void formReady();

private:

  void connects() const;

  FLFormRecordDB *obj_;
  FLSqlCursorInterface *cursor_;
  QSScript *script_;
};


class  FLFormSearchDBInterface : public QObject
{
  Q_OBJECT

public:

  FLFormSearchDBInterface(const QString &a) : QObject(0), obj_(0), cursor_(0),
    script_(0) {
    setObj(new FLFormSearchDB(a));
  }

  FLFormSearchDBInterface(FLSqlCursorInterface *c, const QString &a) : QObject(0), obj_(0), cursor_(0),
    script_(0) {
    setObj(new FLFormSearchDB(c->obj(), a));
  }

  FLFormSearchDBInterface(FLFormSearchDB *obj) : QObject(obj), obj_(0), cursor_(0), script_(0) {
    setObj(obj);
  }

  FLFormSearchDBInterface() : QObject(0), obj_(0), cursor_(0), script_(0) {
  }

  ~FLFormSearchDBInterface() {
    close();
  }

  void finish() {}

  void setObj(FLFormSearchDB *obj) {
    obj_ = obj;
    if (obj_) {
      setName(obj_->name());
      cursor_ = FLSqlCursorInterface::sqlCursorInterface(obj_->cursor());
      connects();
    } else
      cursor_ = 0;
  }

  void setObjCursor(FLSqlCursor *c) {
    if (c && obj_)
      cursor_ = FLSqlCursorInterface::sqlCursorInterface(obj_->cursor());
  }

  void setScript(QSScript *s) {
    script_ = s;
  }

  QSScript *script() {
    return script_;
  }

public slots:

  void setCursor(FLSqlCursorInterface *c) {
    if (c && obj_) {
      obj_->setCursor(c->obj());
      cursor_ = FLSqlCursorInterface::sqlCursorInterface(obj_->cursor());
    }
  }

  FLSqlCursorInterface *cursor() {
    if (!cursor_ && obj_)
      cursor_ = FLSqlCursorInterface::sqlCursorInterface(obj_->cursor());
    return (cursor_ ? cursor_ : new FLSqlCursorInterface());
  }

  QWidget *mainWidget() const {
    return (obj_ ? obj_->mainWidget() : 0);
  }

  void setMainWidget(QWidget *w) {
    if (obj_)
      obj_->setMainWidget(w);
  }

  void setMainWidget() {
    if (obj_)
      obj_->setMainWidget();
  }

  void setMainWidget(const QString &uiFileName) {
    if (obj_)
      ::qt_cast<FLFormDB *>(obj_)->setMainWidget(uiFileName);
  }

  QVariant exec(const QString &n = QString::null) {
    return (obj_ ? obj_->exec(n) : QVariant());
  }
  void show() {
    if (obj_)
      obj_->exec();
  }

  bool accepted() {
    return (obj_ ? obj_->accepted() : false);
  }

  QObject *child(const QString &objName) {
    if (!obj_)
      return 0;
    QObject *o = obj_->child(objName, "QWidget");
    if (o) {
      if (::qt_cast<FLFieldDB *>(o)) {
        return new FLFieldDBInterface(static_cast<FLFieldDB *>(o));
      }
      if (::qt_cast<FLTableDB *>(o)) {
        return new FLTableDBInterface(static_cast<FLTableDB *>(o));
      }
      if (::qt_cast<FLTable *>(o)) {
        return new FLTablePlusInterface(static_cast<FLTable *>(o));
      }
      if (::qt_cast<QTable *>(o)) {
        return new FLTableInterface(static_cast<QTable *>(o));
      }
      if (::qt_cast<QTabWidget *>(o)) {
        return new FLTabWidgetInterface(static_cast<QTabWidget *>(o));
      }
      if (::qt_cast<QListView *>(o)) {
        return new FLListViewInterface(static_cast<QListView *>(o));
      }
    }
    return o;
  }

  bool close() {
    if (obj_) {
      bool ret = obj_->close();
      obj_ = 0;
      return ret;
    } else
      return false;
  }

  void accept() {
    if (obj_)
      obj_->accept();
  }

  void reject() {
    if (obj_)
      obj_->reject();
  }

  FLFormSearchDB *obj() {
    return obj_;
  }

  void setDisabled(const bool b) {
    if (obj_)
      obj_->setDisabled(b);
  }

  QImage snapShot() {
    return (obj_ ? obj_->snapShot() : QImage());
  }

  void saveSnapShot(const QString &pathFile) {
    saveSnapShot(pathFile);
  }

  void setMaximized() {
    if (obj_)
      obj_->setMaximized();
  }

signals:

  void closed();

  void formReady();

private:

  void connects() const;

  FLFormSearchDB *obj_;
  FLSqlCursorInterface *cursor_;
  QSScript *script_;
};


class  FLVarInterface : public QObject
{

  Q_OBJECT

public:

  FLVarInterface() {}

  ~FLVarInterface() {}

public slots:

  bool set(const QString &n, const QVariant &v) {
    return FLVar::set(n, v);
  }

  QVariant get(const QString &n) {
    return FLVar::get(n);
  }
};


class  FLUtilInterface : public QObject
{
  Q_OBJECT
  Q_ENUMS(specialType)
  Q_ENUMS(Type)

public:

  enum specialType {
    Serial = 100,
    Unlock = 200,
    Check = 300
  };

  enum Type {
    Invalid,
    Map,
    List,
    String,
    StringList,
    Font,
    Pixmap,
    Brush,
    Rect,
    Size,
    Color,
    Palette,
    ColorGroup,
    IconSet,
    Point,
    Image,
    Int,
    UInt,
    Bool,
    Double,
    CString,
    PointArray,
    Region,
    Bitmap,
    Cursor,
    SizePolicy,
    Date,
    Time,
    DateTime,
    ByteArray,
    BitArray,
    KeySequence,
    Pen,
    LongLong,
    ULongLong
  };

  FLUtilInterface(QObject *parent = 0) : QObject(parent) {
    QObject::setName("FLUtil" + QDateTime::currentDateTime().toString("ddMMyyyyhhmmsszzz"));
  }

public slots:
  QVariant partInteger(double n) {
    return QVariant((Q_ULLONG) FLUtil::partInteger(n));
  }

  QVariant partDecimal(double n) {
    return QVariant((Q_ULLONG) FLUtil::partDecimal(n));
  }

  QString buildNumber(const QVariant &v, char tipo, int partDecimal) {
    return FLUtil::buildNumber(v, tipo, partDecimal);
  }
  QString buildNumber(double v, char tipo, int partDecimal) {
    return buildNumber(QVariant(v), tipo, partDecimal);
  }
  QString buildNumber(int v, char tipo, int partDecimal) {
    return buildNumber(QVariant(v), tipo, partDecimal);
  }

  QVariant readSettingEntry(const QString &key, const QString &def = QString::null, bool *ok = 0) {
    return FLUtil::readSettingEntry(key, def, ok);
  }

  bool writeSettingEntry(const QString &key, const QString &value) {
    return FLUtil::writeSettingEntry(key, value);
  }

  QVariant readDBSettingEntry(const QString &key) {
    return FLUtil::readDBSettingEntry(key);
  }

  bool writeDBSettingEntry(const QString &key, const QString &value) {
    return FLUtil::writeDBSettingEntry(key, value);
  }

  QString roundFieldValue(const QVariant &n, const QString &table, const QString &field) {
    return FLUtil::roundFieldValue(n, table, field);
  }
  QString roundFieldValue(double n, const QString &table, const QString &field) {
    return roundFieldValue(QVariant(n), table, field);
  }
  QString roundFieldValue(int n, const QString &table, const QString &field) {
    return roundFieldValue(QVariant(n), table, field);
  }

  QString unidades(long n) {
    return FLUtil::unidades(n);
  }

  QString centenamillar(long n) {
    return FLUtil::centenamillar(n);
  }

  QString decenas(long n) {
    return FLUtil::decenas(n);
  }

  QString centenas(long n) {
    return FLUtil::centenas(n);
  }

  QString unidadesmillar(long n) {
    return FLUtil::unidadesmillar(n);
  }

  QCString utf8(const QString &s) {
    return FLUtil::utf8(s);
  }

  QString decenasmillar(long n) {
    return FLUtil::decenasmillar(n);
  }

  QString enLetra(long n) {
    return FLUtil::enLetra(n);
  }

  QString enLetraMoneda(double n, const QString &m) {
    return FLUtil::enLetraMoneda(n, m);
  }

  QString enLetraMonedaEuro(double n) {
    return FLUtil::enLetraMonedaEuro(n);
  }

  QString letraDni(long n) {
    return FLUtil::letraDni(n);
  }

  QString calcularDC(const QString &n) {
    return FLUtil::calcularDC(n);
  }

  QString dateDMAtoAMD(const QString &f) {
    return FLUtil::dateDMAtoAMD(f);
  }

  QString dateAMDtoDMA(const QString &f) {
    return FLUtil::dateAMDtoDMA(f);
  }

  QString formatoMiles(const QString &s) {
    return FLUtil::formatoMiles(s);
  }

  QString translate(const QString &contexto, const QString &s) {
    return FLUtil::translate(contexto, s);
  }

  bool numCreditCard(const QString &num) {
    return FLUtil::numCreditCard(num);
  }

  QVariant nextCounter(const QString &name, FLSqlCursorInterface *cursor_) {
    return FLUtil::nextCounter(name, cursor_->obj());
  }

  QString nextSequence(int nivel, const QString &secuencia, const QString &ultimo) {
    return FLUtil::nextSequence(nivel, secuencia, ultimo);
  }

  QString serialLettertoNumber(const QString &letter) {
    return FLUtil::serialLettertoNumber(letter);
  }

  QString serialNumbertoLetter(int number) {
    return FLUtil::serialNumbertoLetter(number);
  }

  bool isFLDefFile(const QString &head) {
    return FLUtil::isFLDefFile(head);
  }

  uint length(const QString &str) {
    return str.length();
  }

  QStringList nombreCampos(const QString &tabla) {
    return FLUtil::nombreCampos(tabla);
  }

  QString fieldNameToAlias(const QString &fN, const QString &tN, const QString &connName = "default") const;

  QString tableNameToAlias(const QString &tN, const QString &connName = "default") const;

  QString fieldAliasToName(const QString &aN, const QString &tN, const QString &connName = "default") const;

  int fieldType(const QString &fN, const QString &tN, const QString &connName = "default") const;

  int fieldLength(const QString &fN, const QString &tN, const QString &connName = "default") const;

  bool fieldAllowNull(const QString &fN, const QString &tN, const QString &connName = "default") const;

  bool fieldIsPrimaryKey(const QString &fN, const QString &tN, const QString &connName = "default") const;

  bool fieldIsCompoundKey(const QString &fN, const QString &tN, const QString &connName = "default") const;

  QVariant fieldDefaultValue(const QString &fN, const QString &tN, const QString &connName = "default") const;

  QString formatValue(int t, const QVariant &v, const bool upper = false,
                      const QString &connName = "default") const;

  QDate addDays(const QDate &d, int nd) {
    return FLUtil::addDays(d, nd);
  }
  QDate addDays(const QString &d, int nd) {
    return FLUtil::addDays(QDate::fromString(d, Qt::ISODate), nd);
  }

  QDate addMonths(const QDate &d, int nm) {
    return FLUtil::addMonths(d, nm);
  }
  QDate addMonths(const QString &d, int nm) {
    return FLUtil::addMonths(QDate::fromString(d, Qt::ISODate), nm);
  }

  QDate addYears(const QDate &d, int ny) {
    return FLUtil::addYears(d, ny);
  }
  QDate addYears(const QString &d, int ny) {
    return FLUtil::addYears(QDate::fromString(d, Qt::ISODate), ny);
  }

  int daysTo(const QDate &d1, const QDate &d2) {
    return FLUtil::daysTo(d1, d2);
  }
  int daysTo(const QString &d1, const QString &d2) {
    return FLUtil::daysTo(QDate::fromString(d1, Qt::ISODate),
                          QDate::fromString(d2, Qt::ISODate));
  }

  QVariant sqlSelect(const QString &f, const QString &s, const QString &w,
                     const QString &tL = QString::null,
                     const QString &connName = "default") {
    return FLUtil::sqlSelect(f, s, w, tL, 0, connName);
  }

  QVariant quickSqlSelect(const QString &f, const QString &s, const QString &w,
                          const QString &connName = "default") {
    return FLUtil::quickSqlSelect(f, s, w, connName);
  }

  bool sqlInsert(const QString &t, const QString &fL, const QString &vL, const QString &connName = "default") {
    return FLUtil::sqlInsert(t, fL, vL, connName);
  }

  bool sqlUpdate(const QString &t, const QString &fL, const QString &vL, const QString &w, const QString &connName = "default") {
    return FLUtil::sqlUpdate(t, fL, vL, w, connName);
  }

  bool sqlDelete(const QString &t, const QString &w, const QString &connName = "default") {
    return FLUtil::sqlDelete(t, w, connName);
  }

  bool quickSqlDelete(const QString &t, const QString &w, const QString &connName = "default") {
    return FLUtil::quickSqlDelete(t, w, connName);
  }

  void createProgressDialog(const QString &l, int tS) {
    FLUtil::createProgressDialog(l, tS, QObject::name());
  }
  void createProgressDialog() {
    FLUtil::createProgressDialog(QString::null, 0, QObject::name());
  }

  void destroyProgressDialog() {
    FLUtil::destroyProgressDialog(QObject::name());
  }

  void setProgress(int p) {
    FLUtil::setProgress(p, QObject::name());
  }

  void setTotalSteps(int tS) {
    FLUtil::setTotalSteps(tS, QObject::name());
  }

  void setLabelText(const QString &l) {
    FLUtil::setLabelText(l, QObject::name());
  }

  QString sha1(const QString &str) {
    return FLUtil::sha1(str);
  }

  QImage snapShotUI(const QString &n) {
    return FLUtil::snapShotUI(n);
  }

  void saveSnapShotUI(const QString &n, const QString &pathFile) {
    FLUtil::saveSnapShotUI(n, pathFile);
  }

  void saveIconFile(const QString &data, const QString &pathFile) {
    FLUtil::saveIconFile(data, pathFile);
  }

  QString getIdioma() {
    return FLUtil::getIdioma();
  }

  QString getOS() {
    return FLUtil::getOS();
  }

  QStringList findFiles(const QStringList &paths, const QString &filter = "*",
                        bool breakOnFirstMatch = false) {
    return FLUtil::findFiles(paths, filter, breakOnFirstMatch);
  }

  bool execSql(const QString &sql, const QString &connName = "default") {
    return FLUtil::execSql(sql, connName);
  }

  void setFastRandSeed(uint seed) {
    aq_seed_rand = seed;
  }
  uint fastRand() const {
    uint t;
    aq_seed_rand_x ^= aq_seed_rand_x << 16;
    aq_seed_rand_x ^= aq_seed_rand_x >> 5;
    aq_seed_rand_x ^= aq_seed_rand_x << 1;

    t = aq_seed_rand_x;
    aq_seed_rand_x = aq_seed_rand_y;
    aq_seed_rand_y = aq_seed_rand_z;
    aq_seed_rand_z = t ^ aq_seed_rand_x ^ aq_seed_rand_y;

    return aq_seed_rand_z % aq_seed_rand;
  }

private:
  // Ver FLUtilInterface::fastRand()
  static uint aq_seed_rand;
  static uint aq_seed_rand_x;
  static uint aq_seed_rand_y;
  static uint aq_seed_rand_z;
};


class  FLCodBarInterface : public QObject
{

  Q_OBJECT

public:

  FLCodBarInterface(const QString &value, int type, int margin, double scale, double cut, int rotation,
                    bool text_flag = false, QColor fg = Qt::black, QColor bg = Qt::white, int res = 72) : obj_(0), owner(false) {
    obj_ = new FLCodBar(value, type, margin, scale, cut, rotation, text_flag, fg, bg, res);
    owner = true;
  }

  FLCodBarInterface(FLCodBar *obj) : QObject(obj), obj_(0), owner(false) {
    obj_ = obj;
    owner = false;
  }

  ~FLCodBarInterface() {
    if (owner && obj_)
      obj_->deleteLater();
  }

public slots:

  QPixmap pixmap() {
    return obj_->pixmap();
  }

  QPixmap pixmapError() {
    return obj_->pixmapError();
  }

  QString typeToName(const int t) {
    return FLCodBar::typeToName(t);
  }

  QString value() {
    return obj_->value();
  }

  int type() {
    return obj_->type();
  }

  int margin() {
    return obj_->margin();
  }

  double scale() {
    return obj_->scale();
  }

  double cut() {
    return obj_->cut();
  }

  bool text() {
    return obj_->text();
  }

  int rotation() {
    return obj_->rotation();
  }

  QColor fg() {
    return obj_->fg();
  }

  QColor bg() {
    return obj_->bg();
  }

  int res() {
    return obj_->res();
  }

  bool validBarcode() {
    return obj_->validBarcode();
  }

  void setCaption(const QString &caption) {
    obj_->setCaption(caption);
  }

  QString caption() {
    return obj_->caption();
  }

  void setValue(const QString &value) {
    obj_->setValue(value);
  }

  void setType(const int type) {
    obj_->setType(type);
  }

  void setMargin(const int margin) {
    obj_->setMargin(margin);
  }

  void setScale(const double scale) {
    obj_->setScale(scale);
  }

  void setCut(const double cut) {
    obj_->setCut(cut);
  }

  void setText(const bool text) {
    obj_->setText(text);
  }

  void setRotation(const int rotation) {
    obj_->setRotation(rotation);
  }

  void setFg(const QColor &fg) {
    obj_->setFg(fg);
  }

  void setBg(const QColor &bg) {
    obj_->setBg(bg);
  }

  void setRes(const int res) {
    obj_->setRes(res);
  }

  int nameToType(const QString &n) {
    return FLCodBar::nameToType(n);
  }

  void cleanUp() {
    obj_->cleanUp();
  }

  FLCodBar *obj() {
    return obj_;
  }

private:

  FLCodBar *obj_;
  bool owner;
};


class  FLScriptEditorInterface : public QObject
{

  Q_OBJECT

public:

  FLScriptEditorInterface(const QString &nFS) : obj_(0) {
    obj_ = new FLScriptEditor(nFS, qApp->mainWidget());
  }

  ~FLScriptEditorInterface() {}

public slots:

  void setCode(const QString &c) {
    obj_->setCode(c);
  }

  QString code() const {
    return obj_->code();
  }

  int exec() {
    return obj_->exec();
  }

  FLScriptEditor *obj() {
    return obj_;
  }

private:

  FLScriptEditor *obj_;
};


class  FLDomNodeListInterface : public QObject
{

  Q_OBJECT

public:

  FLDomNodeListInterface(QObject *parent = 0)
    : QObject(parent) {
  }

  FLDomNodeListInterface(const QDomNodeList &nl, QObject *parent = 0)
    : QObject(parent),
      nl_(nl) {
  }

  ~FLDomNodeListInterface() {}

public slots:

  FLDomNodeInterface *item(int index);

  uint length() const {
    return nl_.length();
  }
  uint count() const {
    return nl_.count();
  }

  QDomNodeList obj() {
    return nl_;
  }

private:

  QDomNodeList nl_;
};


class  FLDomNodeInterface : public QObject
{
  Q_OBJECT

public:

  FLDomNodeInterface(QObject *parent = 0)
    : QObject(parent),
      dn_(0),
      type_(QDomNode::BaseNode) {
    setIdNode();
  }
  FLDomNodeInterface(QDomNode::NodeType type, QObject *parent = 0)
    : QObject(parent),
      dn_(0),
      type_(type) {
    setIdNode();
  }
  FLDomNodeInterface(const QDomNode &n, QObject *parent = 0)
    : QObject(parent),
      dn_(n.isNull() ? 0 : new QDomNode(n)),
      type_(QDomNode::BaseNode) {
    setIdNode();
  }
  FLDomNodeInterface(const QDomElement &n, QObject *parent = 0)
    : QObject(parent),
      dn_(n.isNull() ? 0 : new QDomElement(n)),
      type_(QDomNode::ElementNode) {
    setIdNode();
  }
  FLDomNodeInterface(const QDomText &n, QObject *parent = 0)
    : QObject(parent),
      dn_(n.isNull() ? 0 : new QDomText(n)),
      type_(QDomNode::TextNode) {
    setIdNode();
  }
  FLDomNodeInterface(const QDomDocument &n, QObject *parent = 0)
    : QObject(parent),
      dn_(n.isNull() ? 0 : new QDomDocument(n)),
      type_(QDomNode::DocumentNode) {
    setIdNode();
  }

  virtual ~FLDomNodeInterface();

  static FLDomNodeInterface *nodeInterface(const QDomNode &n);
  static FLDomNodeInterface *nodeInterface(const QDomElement &n);
  static FLDomNodeInterface *nodeInterface(const QDomText &n);
  static FLDomNodeInterface *nodeInterface(const QDomDocument &n);

  QDomNode *newNode() {
    delete dn_;
    dn_ = 0;
    switch (type_) {
      case QDomNode::ElementNode:
        dn_ = new QDomElement();
        break;
      case QDomNode::TextNode:
        dn_ = new QDomText();
        break;
      case QDomNode::DocumentNode:
        dn_ = new QDomDocument();
        break;
      default:
        dn_ = new QDomNode();
    }
    return dn_;
  }

  void updateNode(const QDomNode &n) {
    if (dn_)
      *dn_ = n;
    else
      dn_ = new QDomNode(n);
  }

  void updateNode(const QDomElement &n) {
    if (dn_) {
      if (type_ != QDomNode::ElementNode) {
        delete dn_;
        dn_ = new QDomElement(n);
      } else
        *dn_ = n;
    } else
      dn_ = new QDomElement(n);
    type_ = QDomNode::ElementNode;
  }

  void updateNode(const QDomText &n) {
    if (dn_) {
      if (type_ != QDomNode::TextNode) {
        delete dn_;
        dn_ = new QDomText(n);
      } else
        *dn_ = n;
    } else
      dn_ = new QDomText(n);
    type_ = QDomNode::TextNode;
  }

  void updateNode(const QDomDocument &n) {
    if (dn_) {
      if (type_ != QDomNode::DocumentNode) {
        delete dn_;
        dn_ = new QDomDocument(n);
      } else
        *dn_ = n;
    } else
      dn_ = new QDomDocument(n);
    type_ = QDomNode::DocumentNode;
  }

  void setIdNode();

  QDomNode::NodeType type() const {
    return type_;
  }

public slots:

  QString idNode() const {
    return QString::number(idNode_);
  }

  FLDomNodeInterface *nodeFromIdNode(const QString &id) const;

  void clear() {
    delete dn_;
    dn_ = 0;
  }

  QString nodeValue() const {
    return (dn_ ? dn_->nodeValue() : QString::null);
  }

  QString nodeName() const {
    return (dn_ ? dn_->nodeName() : QString::null);
  }

  FLDomNodeInterface *toElement() {
    return (dn_ ? nodeInterface(dn_->toElement()) : 0);
  }

  bool isElement() const {
    return (dn_ ? dn_->isElement() : false);
  }

  bool isText() const {
    return (dn_ ? dn_->isText() : false);
  }

  bool isComment() const {
    return (dn_ ? dn_->isComment() : false);
  }

  FLDomNodeInterface *nextSibling() {
    return (dn_ ? nodeInterface(dn_->nextSibling()) : 0);
  }

  FLDomNodeInterface *previousSibling() {
    return (dn_ ? nodeInterface(dn_->previousSibling()) : 0);
  }

  FLDomNodeInterface *namedItem(const QString &name) {
    return (dn_ ? nodeInterface(dn_->namedItem(name)) : 0);
  }

  FLDomNodeInterface *cloneNode(bool deep = true) {
    return nodeInterface(DN_->cloneNode(deep));
  }

  bool isEqualNode(FLDomNodeInterface *n) {
    if (!n)
      return false;
    QDomDocument d1;
    QDomDocument d2;
    QString content = "<dd/>";
    d1.setContent(content);
    d2.setContent(content);
    d1.firstChild().appendChild(DN_->cloneNode());
    d2.firstChild().appendChild(n->obj().cloneNode());
    return (d1.toString() == d2.toString());
  }

  FLDomNodeInterface *insertBefore(FLDomNodeInterface *newChild, FLDomNodeInterface *refChild = 0) {
    if (!dn_ || !newChild)
      return 0;
    if (!refChild)
      return nodeInterface(dn_->insertBefore(newChild->obj(), QDomNode()));
    return nodeInterface(dn_->insertBefore(newChild->obj(), refChild->obj()));
  }

  FLDomNodeInterface *insertAfter(FLDomNodeInterface *newChild, FLDomNodeInterface *refChild) {
    return ((dn_ && newChild && refChild) ? nodeInterface(dn_->insertAfter(newChild->obj(), refChild->obj())) : 0);
  }

  FLDomNodeInterface *removeChild(FLDomNodeInterface *oldChild) {
    return ((dn_ && oldChild) ? nodeInterface(dn_->removeChild(oldChild->obj())) : 0);
  }

  bool hasAttributes() const {
    return (dn_ ? dn_->hasAttributes() : false);
  }

  bool hasChildNodes() const {
    return (dn_ ? dn_->hasChildNodes() : false);
  }

  QString attributeValue(const QString &att) const {
    if (!hasAttributes())
      return QString::null;
    QDomNode n(dn_->attributes().namedItem(att));
    return (n.isNull() ? QString::null : n.nodeValue());
  }

  QString comment() const {
    if (!dn_)
      return QString::null;
    QDomNodeList nl(dn_->childNodes());
    uint ncount = nl.count();
    for (uint i = 0; i < ncount; ++i) {
      if (nl.item(i).isComment())
        return nl.item(i).nodeValue();
    }
    return QString::null;
  }

  void setNodeValue(const QString &v) {
    DN_->setNodeValue(v);
  }

  FLDomNodeInterface *firstChild() {
    return (dn_ ? nodeInterface(dn_->firstChild()) : 0);
  }

  FLDomNodeInterface *lastChild() {
    return (dn_ ? nodeInterface(dn_->lastChild()) : 0);
  }

  FLDomNodeInterface *parentNode() {
    return (dn_ ? nodeInterface(dn_->parentNode()) : 0);
  }

  FLDomNodeInterface *appendChild(FLDomNodeInterface *newChild) {
    return (newChild ? nodeInterface(DN_->appendChild(newChild->obj())) : 0);
  }

  FLDomNodeInterface *replaceChild(FLDomNodeInterface *newChild, FLDomNodeInterface *oldChild) {
    return ((newChild && oldChild) ? nodeInterface(DN_->replaceChild(newChild->obj() , oldChild->obj())) : 0);
  }

  FLDomNodeListInterface *childNodes() const {
    return (hasChildNodes() ? new FLDomNodeListInterface(dn_->childNodes()) : 0);
  }

  FLDomNodeInterface *ownerDocument() const {
    return (dn_ ? nodeInterface(dn_->ownerDocument()) : 0);
  }

  bool isNull() const {
    return (dn_ ? dn_->isNull() : true);
  }

  QDomNode::NodeType nodeType() const {
    return (dn_ ? dn_->nodeType() : QDomNode::BaseNode);
  }

  QDomNode obj() {
    return *DN_;
  }
  QDomNode *ptroObj() {
    return dn_;
  }


  QString text() const {
    return ((dn_ && type_ == QDomNode::ElementNode) ?
            static_cast<QDomElement *>(dn_)->text() :
            QString::null);
  }

  QString attribute(const QString &name, const QString &defValue = QString::null) const {
    return ((dn_ && type_ == QDomNode::ElementNode) ?
            static_cast<QDomElement *>(dn_)->attribute(name, defValue) :
            QString::null);
  }

  void setAttribute(const QString &name, const QString &value) {
    if (type_ == QDomNode::ElementNode)
      static_cast<QDomElement *>(DN_)->setAttribute(name, value);
  }

  void removeAttribute(const QString &name) {
    if (dn_ && type_ == QDomNode::ElementNode)
      static_cast<QDomElement *>(dn_)->removeAttribute(name);
  }


  bool setContent(const QString &buffer);

  FLDomNodeInterface *createElement(const QString &tagName) {
    if (type_ != QDomNode::DocumentNode)
      return 0;
    return nodeInterface(static_cast<QDomDocument *>(DN_)->createElement(tagName));
  }

  FLDomNodeInterface *createTextNode(const QString &value) {
    if (type_ != QDomNode::DocumentNode)
      return 0;
    return nodeInterface(static_cast<QDomDocument *>(DN_)->createTextNode(value));
  }

  QString toString(const int indent = 0) {
    return ((dn_ && type_ == QDomNode::DocumentNode) ?
            static_cast<QDomDocument *>(dn_)->toString(indent) :
            QString::null);
  }

  FLDomNodeListInterface *elementsByTagName(const QString &tagName) const {
    if (!dn_)
      return 0;
    QDomNodeList nl;
    if (type_ == QDomNode::ElementNode)
      nl = QDomNodeList(static_cast<QDomElement *>(dn_)->elementsByTagName(tagName));
    else if (type_ == QDomNode::DocumentNode)
      nl = QDomNodeList(static_cast<QDomDocument *>(dn_)->elementsByTagName(tagName));
    return (nl.count() ? new FLDomNodeListInterface(nl) : 0);
  }

  void cleanup();

public:

  static void cleanupDomNodesCache();

private:

  QDomNode *dn_;
  QDomNode::NodeType type_;
  uint idNode_;

  static FLDomNodesCache *nodesCache;
  static uint idNodeGlob;

  friend class FLObjectFactory;
};

inline FLDomNodeInterface *FLDomNodeListInterface::item(int index)
{
  return FLDomNodeInterface::nodeInterface(nl_.item(index));
}


class  FLReportViewerInterface : public QObject
{

  Q_OBJECT
  Q_ENUMS(RenderReportFlags)

public:

  enum RenderReportFlags {
    Append    = 0x00000001,
    Display   = 0x00000002,
    PageBreak = 0x00000004
  };

  FLReportViewerInterface() : QObject(0), obj_(0) {
    obj_ = new FLReportViewer();
    connects();
  }

  FLReportViewerInterface(FLReportViewer *obj) : QObject(obj), obj_(0) {
    obj_ = obj;
    connects();
  }

  FLReportViewerInterface(QWidget *w, bool) : QObject(w) {
    obj_ = new FLReportViewer(w, 0, true);
    connects();
  }

  FLReportViewerInterface(FLReportEngine *r) : QObject(0) {
    obj_ = new FLReportViewer(0, 0, false, r);
    connects();
  }

  ~FLReportViewerInterface() {}

public slots:

  // Obsoleta
  //   bool renderReport(const int initRow = 0, const int initCol = 0, const bool append = false, const bool displayReport = true) {
  //     return obj_->renderReport(initRow, initCol, append, displayReport);
  //   }
  bool renderReport(const int initRow = 0, const int initCol = 0, const uint flags = FLReportViewerInterface::Display) {
    return obj_->renderReport(initRow, initCol, flags);
  }

  bool setReportData(FLSqlQueryInterface *q) {
    return obj_->setReportData(q->obj());
  }

  bool setReportData(FLDomNodeInterface *xmlDoc) {
    if (xmlDoc)
      return obj_->setReportData(xmlDoc->obj());
    return false;
  }

  bool setReportTemplate(const QString &t, const QString &style = QString::null) {
    return obj_->setReportTemplate(t, style);
  }

  bool setReportTemplate(FLDomNodeInterface *xmlDoc, const QString &style = QString::null) {
    if (!xmlDoc) {
      return false;
    }
    return obj_->setReportTemplate(xmlDoc->obj(), style);
  }

  FLDomNodeInterface *reportData() const {
    return obj_->rptEngine()->reportData();
  }

  FLDomNodeInterface *reportTemplate() const {
    return obj_->rptEngine()->reportTemplate();
  }

  void exec() {
    obj_->exec();
  }
  void show() {
    obj_->exec();
  }

  QString csvData() {
    return obj_->csvData();
  }

  void printReport() {
    obj_->slotPrintReport();
  }

  void printReportToPS(const QString &outPsFile) {
    obj_->slotPrintReportToPS(outPsFile);
  }

  void printReportToPDF(const QString &outPdfFile) {
    obj_->slotPrintReportToPDF(outPdfFile);
  }

  void setNumCopies(const int numCopies) {
    obj_->setNumCopies(numCopies);
  }

  void setPrintToPos(bool ptp) {
    obj_->setPrintToPos(ptp);
  }

  void setPrinterName(const QString &pName) {
    obj_->setPrinterName(pName);
  }

  bool reportPrinted() {
    obj_->reportPrinted();
  }

  void reparent(QWidget *parentFrame) {
    obj_->rptViewerReparent(parentFrame);
  }

  void slotFirstPage() {
    obj_->slotFirstPage();
  }

  void slotLastPage() {
    obj_->slotLastPage();
  }

  void slotNextPage() {
    obj_->slotNextPage();
  }

  void slotPrevPage() {
    obj_->slotPrevPage();
  }

  void slotZoomUp() {
    obj_->slotZoomUp();
  }

  void slotZoomDown() {
    obj_->slotZoomDown();
  }

  void exportFileCSVData() {
    obj_->exportFileCSVData();
  }

  void exportToPDF() {
    obj_->exportToPDF();
  }

  void sendEMailPDF() {
    obj_->sendEMailPDF();
  }

  void saveSVGStyle() {
    obj_->saveSVGStyle();
  }

  void saveSimpleSVGStyle() {
    obj_->saveSimpleSVGStyle();
  }

  void loadSVGStyle() {
    obj_->exportFileCSVData();
  }

  void setAutoClose(const bool b) {
    obj_->setAutoClose(b);
  }

  void setResolution(int dpi) {
    obj_->setResolution(dpi);
  }
  void setPixel(int relDpi) {
    obj_->setPixel(relDpi);
  }
  void setDefaults() {
    obj_->setDefaults();
  }

  void updateReport() {
    obj_->updateReport();
  }

  void  updateDisplay() {
    obj_->updateDisplay();
  }

  void setStyleName(const QString &style) {
    obj_->setStyleName(style);
  }

  MReportViewer *rptViewer() {
    return obj_->rptViewer();
  }

  void setReportEngine(FLReportEngine *r) {
    obj_->setReportEngine(r);
  }

  void rptViewerEmbedInParent(QWidget *parentFrame) {
    obj_->rptViewerEmbedInParent(parentFrame);
  }

  void setReportPages(FLReportPages *pgs) {
    obj_->setReportPages(pgs);
  }

  FLPicture *getCurrentPage() {
    return obj_->getCurrentPage();
  }
  FLPicture *getFirstPage() {
    return obj_->getFirstPage();
  }
  FLPicture *getPreviousPage() {
    return obj_->getPreviousPage();
  }
  FLPicture *getNextPage() {
    return obj_->getNextPage();
  }
  FLPicture *getLastPage() {
    return obj_->getLastPage();
  }
  FLPicture *getPageAt(uint i) {
    return obj_->getPageAt(i);
  }
  void clearPages() {
    obj_->clearPages();
  }
  void appendPage() {
    obj_->appendPage();
  }
  int getCurrentIndex() {
    return obj_->getCurrentIndex();
  }
  void setCurrentPage(int idx) {
    obj_->setCurrentPage(idx);
  }
  void setPageSize(int s) {
    obj_->setPageSize(s);
  }
  void setPageOrientation(int o) {
    obj_->setPageOrientation(o);
  }
  void setPageDimensions(QSize dim) {
    obj_->setPageDimensions(dim);
  }
  int pageSize() {
    return obj_->pageSize();
  }
  int pageOrientation() {
    return obj_->pageOrientation();
  }
  QSize pageDimensions() {
    return obj_->pageDimensions();
  }
  int pageCount() {
    return obj_->pageCount();
  }

  QObject *child(const QString &objName) {
    if (!obj_)
      return 0;
    return obj_->child(objName);
  }

  void disableSlotsPrintExports(bool disablePrints = true, bool disableExports = true) {
    obj_->disableSlotsPrintExports(disablePrints, disableExports);
  }

  void setName(const QString &n) {
    obj_->setName(n);
  }

  FLReportViewer *obj() {
    return obj_;
  }

signals:

  void requestUpdateReport();

private:

  void connects() const {
    connect(obj_, SIGNAL(requestUpdateReport()), this, SIGNAL(requestUpdateReport()));
    connect(obj_, SIGNAL(destroyed()), this, SIGNAL(destroyed()));
  }

  FLReportViewer *obj_;
};


class  FLProcessInterface : public QProcess
{

  Q_OBJECT

public:

  FLProcessInterface() : obj_(0) {
    obj_ = new QProcess();
    connects();
  };

  FLProcessInterface(const QString &arg0) : obj_(0) {
    obj_ = new QProcess(arg0);
    connects();
  };

  ~FLProcessInterface() {
    if (obj_)
      obj_->deleteLater();
  }

public slots:

  bool start() {
    return obj_->start();
  }

  void setWorkingDirectory(const QString &path) {
    QDir dir(path);
    obj_->setWorkingDirectory(dir);
  }

  void setArguments(const QStringList &args) {
    obj_->setArguments(args);
  }

  void addArgument(const QString &arg) {
    obj_->addArgument(arg);
  }

  bool isRunning() {
    return obj_->isRunning();
  }

  QByteArray readStdout() {
    return obj_->readStdout();
  }

  void emitExited() {
    emit exited();
  }

signals:

  void exited();

private:

  void connects() {
    disconnect(obj_, SIGNAL(processExited()), this, SLOT(emitExited()));
    connect(obj_, SIGNAL(processExited()), this, SLOT(emitExited()));
  }

  QProcess *obj_;
};

class  FLPosPrinterInterface : public QObject
{

  Q_OBJECT
  Q_ENUMS(PaperWidth)

public:

  enum PaperWidth {P57_5MM, P69_5MM, P76MM, NPaperWidth = P76MM};

  FLPosPrinterInterface() : obj_(0) {
    obj_ = new FLPosPrinter();
  }

  ~FLPosPrinterInterface() {
    if (obj_)
      delete obj_;
  }

public slots:

  int paperWidth() {
    return obj_->paperWidth();
  }

  void setPaperWidth(int pw) {
    obj_->setPaperWidth((FLPosPrinter::PaperWidth)pw);
  }

  const QString &printerName() {
    return obj_->printerName();
  }

  void setPrinterName(const QString &pName) {
    obj_->setPrinterName(pName);
  }

  void cleanup() {
    obj_->cleanup();
  }

  void flush() {
    obj_->flush();
  }

  void send(const QString &str, const int col = -1, const int row = -1) {
    obj_->send(str, col, row);
  }

private:

  FLPosPrinter *obj_;
};


class  FLSmtpClientInterface : public QObject
{
  Q_OBJECT

public:

  FLSmtpClientInterface() : QObject(0) {
    obj_ = new FLSmtpClient(this);
    connects();
  }

  FLSmtpClientInterface(FLSmtpClient *obj) : QObject(obj), obj_(0) {
    obj_ = obj;
  }

  ~FLSmtpClientInterface() {}

public slots:

  void setFrom(const QString &from) {
    obj_->setFrom(from);
  }

  void setTo(const QString &to) {
    obj_->setTo(to);
  }

  void setSubject(const QString &subject) {
    obj_->setSubject(subject);
  }

  void setBody(const QString &body) {
    obj_->setBody(body);
  }

  void addAttachment(const QString &attach, const QString &cid = QString::null) {
    obj_->addAttachment(attach, cid);
  }

  void addTextPart(const QString &text, const QString &mimeType = "text/plain") {
    obj_->addTextPart(text, mimeType);
  }

  void setMailServer(const QString &mS) {
    obj_->setMailServer(mS);
  }

  void setMimeType(const QString &mT) {
    obj_->setMimeType(mT);
  }

  void startSend() {
    obj_->startSend();
  }

  void emitStatus(const QString &st) {
    emit status(st);
  }

  void emitSendStarted() {
    emit sendStarted();
  }

  void emitSendEnded() {
    emit sendEnded();
  }

  void emitSendTotalSteps(int ts) {
    emit sendTotalSteps(ts);
  }

  void emitSendStepNumber(int sn) {
    emit sendStepNumber(sn);
  }

  FLSmtpClient *obj() {
    return obj_;
  }

signals:

  void status(const QString &);

  void sendStarted();

  void sendEnded();

  void sendTotalSteps(int);

  void sendStepNumber(int);

private:

  void connects() const;

  FLSmtpClient *obj_;
};

class  FLImageViewerInterface : public QObject
{

  Q_OBJECT

public:

  FLImageViewerInterface() : QObject(0) {
    obj_ = new FLImageViewer();
  }

  FLImageViewerInterface(FLImageViewer *obj) : QObject(obj), obj_(0) {
    obj_ = obj;
  }

  ~FLImageViewerInterface() {}

public slots:

  bool loadImage(const QString &pathFile) {
    obj_->loadImage(pathFile);
  }

  void openFile() {
    obj_->openFile();
  }

  void show() {
    obj_->show();
  }

  void close() {
    obj_->close();
  }

  QString fileName() {
    return obj_->filename;
  }

  void saveImage(int f) {
    obj_->saveImage(f);
  }

  void savePixmap(int f) {
    obj_->savePixmap(f);
  }

  void setImage(const QVariant &v) {
    obj_->setImage(QImage(v.toCString()));
  }

  void setImage(const QPixmap &p) {
    obj_->setImage(p.convertToImage());
  }

private:

  FLImageViewer *obj_;
};

class  FLSerialPortInterface : public QObject
{
  Q_OBJECT
  Q_ENUMS(BaudRateType DataBitsType ParityType StopBitsType FlowType)

public:

  enum BaudRateType {
    BAUD50, //POSIX ONLY
    BAUD75, //POSIX ONLY
    BAUD110,
    BAUD134, //POSIX ONLY
    BAUD150, //POSIX ONLY
    BAUD200, //POSIX ONLY
    BAUD300,
    BAUD600,
    BAUD1200,
    BAUD1800, //POSIX ONLY
    BAUD2400,
    BAUD4800,
    BAUD9600,
    BAUD14400, //WINDOWS ONLY
    BAUD19200,
    BAUD38400,
    BAUD56000, //WINDOWS ONLY
    BAUD57600,
    BAUD76800, //POSIX ONLY
    BAUD115200,
    BAUD128000, //WINDOWS ONLY
    BAUD256000 //WINDOWS ONLY
  };

  enum DataBitsType {
    DATA_5, //only for compatibility
    DATA_6,
    DATA_7,
    DATA_8
  };

  enum ParityType {
    PAR_NONE,
    PAR_ODD,
    PAR_EVEN,
    PAR_MARK, //WINDOWS ONLY
    PAR_SPACE //WINDOWS directly, POSIX simulated
  };

  enum StopBitsType {
    STOP_1,
    STOP_1_5, //WINDOWS ONLY
    STOP_2
  };

  enum FlowType {
    FLOW_OFF,
    FLOW_HARDWARE,
    FLOW_XONXOFF
  };

  FLSerialPortInterface(const QString &name = QString::null) : QObject(0) {
    obj_ = new QextSerialPort(name);
  }

  ~FLSerialPortInterface() {
    delete obj_;
  }

public slots:

  bool open(int mode = 0) {
    return obj_->open(mode);
  }
  void close() {
    obj_->close();
  }
  void flush() {
    obj_->flush();
  }

  QIODevice::Offset size() const {
    return obj_->size();
  }

  Q_LONG readBlock(char *data, Q_ULONG maxSize) {
    return obj_->readBlock(data, maxSize);
  }
  Q_LONG writeBlock(const QString &data, Q_ULONG size) {
    return obj_->writeBlock(data, size);
  }
  void writeText(const QString &text) {
    writeBlock(text.latin1(), text.length());
  }

  int getch() {
    return obj_->getch();
  }
  int putch(int ch) {
    return obj_->putch(ch);
  }
  int ungetch(int ch) {
    return obj_->ungetch(ch);
  }

  Q_ULONG bytesAvailable() const {
    return obj_->bytesAvailable();
  }

  void setName(const QString &name) {
    obj_->setName(name);
  }
  QString name() {
    return obj_->name();
  }

  void setBaudRate(BaudRateType b) {
    obj_->setBaudRate((QextSerialPort::BaudRateType) b);
  }
  void setDataBits(DataBitsType d) {
    obj_->setDataBits((QextSerialPort::DataBitsType) d);
  }
  void setParity(ParityType p) {
    obj_->setParity((QextSerialPort::ParityType) p);
  }
  void setStopBits(StopBitsType s) {
    obj_->setStopBits((QextSerialPort::StopBitsType) s);
  }
  void setFlowControl(FlowType f) {
    obj_->setFlowControl((QextSerialPort::FlowType) f);
  }
  void setTimeout(int sec, int msec) {
    obj_->setTimeout(sec, msec);
  }

  BaudRateType baudRate() const {
    return (FLSerialPortInterface::BaudRateType) obj_->baudRate();
  }
  DataBitsType setDataBits() const {
    return (FLSerialPortInterface::DataBitsType) obj_->setDataBits();
  }
  ParityType setParity() const {
    return (FLSerialPortInterface::ParityType) obj_->setParity();
  }
  StopBitsType setStopBits() const {
    return (FLSerialPortInterface::StopBitsType) obj_->setStopBits();
  }
  FlowType setFlowControl() const {
    return (FLSerialPortInterface::FlowType) obj_->setFlowControl();
  }

  void setRts(bool set = TRUE) {
    obj_->setRts(set);
  }
  void setDtr(bool set = TRUE) {
    obj_->setDtr(set);
  }

  bool cts() const {
    return obj_->cts();
  }
  bool dsr() const {
    return obj_->dsr();
  }
  bool dcd() const {
    return obj_->dcd();
  }
  bool ri() const {
    return obj_->ri();
  }

private:

  QextSerialPort *obj_;
};


class AQSignalMapper : public QSignalMapper
{
  Q_OBJECT

public:

  AQSignalMapper(QObject *parent) :
    QSignalMapper(parent) {
    QObject::setName("AQSignalMapper" +
                     QDateTime::currentDateTime().toString("ddMMyyyyhhmmsszzz"));
  }

public slots:

  void setMapping(QObject *sender, int identifier) {
    QSignalMapper::setMapping(sender, identifier);
  }
  void setMapping(QObject *sender, const QString &identifier) {
    QSignalMapper::setMapping(sender, identifier);
  }
  void removeMappings(QObject *sender) {
    QSignalMapper::removeMappings(sender);
  }
};


class AQObjectQueryList : public QObject
{
  Q_OBJECT

public:

  AQObjectQueryList(QObject *obj,
                    const QString &inheritsClass,
                    const QString &objName,
                    bool regexpMatch,
                    bool recursiveSearch) :
    QObject(0), l_(0) {
    if (obj) {
      l_ = obj->queryList(inheritsClass.isEmpty() ? 0 : inheritsClass.latin1(),
                          objName.isEmpty() ? 0 : objName.latin1(),
                          regexpMatch, recursiveSearch);
      l_->first();
    }
  }

  AQObjectQueryList(QObject *obj) :
    QObject(0), l_(0) {
    if (obj) {
      l_ = obj->queryList();
      l_->first();
    }
  }

  ~AQObjectQueryList() {
    delete l_;
  }

public slots:

  QObject *first() const {
    if (!l_) return 0;
    return l_->first();
  }

  QObject *last() const {
    if (!l_) return 0;
    return l_->last();
  }

  QObject *next() const {
    if (!l_) return 0;
    return l_->next();
  }

  QObject *prev() const {
    if (!l_) return 0;
    return l_->prev();
  }

  QObject *current() const {
    if (!l_) return 0;
    return l_->current();
  }

  bool isValid() const {
    if (!l_) return false;
    return (l_->current() != 0);
  }

private:

  QObjectList *l_;
};


class FLObjectFactory : public QSObjectFactory
{
public:

  FLObjectFactory();

  ~FLObjectFactory();

  QObject *create(const QString &className, const QSArgumentList &arguments, QObject *);

private:

  FLUtilInterface *util_;
  QObject *voidObject_;
};

#endif