datalib.h

/*  gSAFE - LIB
    general Sql dAtabase FrontEnd
    http://hyperprog.com/gsafe/

   (C) 2005-2013 Peter Deak  (hyper80@gmail.com)

    License: GPLv2  http://www.gnu.org/licenses/gpl-2.0.html

    datalib.h
*/

#ifndef GSAFE__DATALIB_HEADER_FILE_X_
#define GSAFE__DATALIB_HEADER_FILE_X_

#include <QtCore>

/*  @{  */

#include "gstexts.h"

#define GSAFE_VERSION   "1.3.8"

// ///////////////////////////////////
// BEGIN - CONFIG/MODIFIERS/MODULES //
// ///////////////////////////////////

#define PROGRESS_POSSIBILITY 1

#define MODULE_REFRESHAGENT_NETSERVER 1
#define REFRESHAGENT_TCPPORT          1234

#define MODULE_REFRESHAGENT_NETCLIENT 1

#define HASHMUL 1.5

//#define VALIDATE_HALT_ON_FIRST_ERROR

// //////////////////////////////////
// END - CONFIG/MODIFIERS/MODULES  //
// //////////////////////////////////

#define MAX_SQL_INTERFACES  7

#define INNER_JOIN 0
#define LEFT_OUTER_JOIN 1

#define HEAD true
#define VALUE false

#ifdef MODULE_REFRESHAGENT_NETSERVER
#include <QtNetwork>
#endif
#ifdef MODULE_REFRESHAGENT_NETCLIENT
#include <QtNetwork>
#endif

// Global functions //

int getIndexOf(QStringList l,QString s);
void setErrorLocal(QString s);

void error(QString s);

int my_dtoa(double v,char *buffer,int bufflen,int min,int max,int group);

QString doubleToQString(double val,int min,int max,int group);

#define ROUND_MATH  0
#define ROUND_FLOOR 1

double dRound(double val,int mode=ROUND_MATH);

QStringList * deep_copy_stringlist(QStringList *target,QStringList *source);

// Classes //

class QTextCodec;
class QSqlDatabase;
class QSqlQuery;

QString convNationalToHtmlCodes(QString input);

class HXmlWriter
{
    private:
        QString     codec_name;
        int         indent_pos;
        QTextStream *output_stream;
        QStack<QString> *node_stack;
        QTextCodec  *tc;
        bool no_recode;

    private:
        void eatData(QString d);

    public:
        HXmlWriter(void);
        ~HXmlWriter(void);

        QTextStream *getStream(void);
        void setStream(QTextStream *oo);

        void putHead(QString enc,bool nullhead = false);

        void beginNode(QString n,QString parameters="");

        void endNode(void);

        void putCData(QString n,QString data,QString parameters="");

        void putEmptyNode(QString n,QString parameters="");

        void putRawData(QString data);

        QByteArray recodeDataNoconvert(QString d);

        QByteArray recodeData(QString d);
};

class HRefreshAgent : public QObject
{
    Q_OBJECT

    protected:
        static HRefreshAgent *theone;

    public slots:
        int notifySlot(QString tblname);

    public:
        HRefreshAgent(void);
        ~HRefreshAgent(void);

        static void notify(QString tblname);

        static HRefreshAgent* getNotifyAgent(void) { return theone; }


    protected:
        void internalNotify(QString tblname);

    signals:
        void getnotify(QString tblname);
};

#ifdef MODULE_REFRESHAGENT_NETSERVER

class HRefreshAgentNetserver : public QObject
{
    Q_OBJECT

    public:
        HRefreshAgentNetserver(void);
        ~HRefreshAgentNetserver(void);

        static bool isRunning(void);
        static HRefreshAgentNetserver * getHRefreshAgentNetserver(void) { return theone; }
        static QString serverAddress();

    protected:
        static bool inNotify;
        static HRefreshAgentNetserver *theone;

    private:
        QTcpServer *tcpServer;
        QList<QTcpSocket *> tcps_list;
        QString laddr;

    private slots:
        int newConn(void);
        int request(void);
        int clientLeaving(void);
        int action(QString name,int sendernum);

};
#endif

#ifdef MODULE_REFRESHAGENT_NETCLIENT

class HRefreshAgentNetclient : public QObject
{
    Q_OBJECT

    public:
        HRefreshAgentNetclient(QString server_ip);
        ~HRefreshAgentNetclient();

        static bool isConnected(void);
        static HRefreshAgentNetclient * getHRefreshAgentNetclient(void) { return theone; }

    protected:
        static bool inNotify;
        static HRefreshAgentNetclient *theone;

    private:
        QTcpSocket *socket;
        bool c_ok;

    private slots:
        int request(void);
        int serverClosing(void);
        int action(QString name);

    signals:
        void connectionLost();
        void connectionEstablished();
};
#endif

class HBase : public QObject
{
    Q_OBJECT

    protected:
        QString whoami;
    public:
        QString getWhoami(void);

    public:
        HBase(void);
        ~HBase(void);
};

class HPlainDataMatrix : public HBase
{
    Q_OBJECT

    private:
        int col_count;
        QString title;
        QString exp_title;

        QString* hheader;

        QList<QVariant *> data;
        QList<QString>    control;
        QList<QVariant *>::iterator iter;
        QList<QString>::iterator iter_ctrl;
        bool *printCellWrap;
        int  *printMaxCellWidth;
        QString htmlcss;
    public:
        int keyfield;

    public:
        QString getTitle(void) { return title; }
        void setTitle(QString t) { title = t; }
        void setExtendedTitle(QString xt) { exp_title = xt; }

        HPlainDataMatrix(int col);
        ~HPlainDataMatrix(void);

        void clearData();
        void clearAll();

        int columnCount();
        int rowCount();
        int recordCount() { return rowCount(); }
        int fieldCount() { return columnCount(); }


        void setHeaderCell(int col,QString strdata);

        void setHeader(QList<QString> strlistdata);
        void setHeader(QString d1="",QString d2="",QString d3=""
                       ,QString d4="",QString d5="",QString d6=""
                       ,QString d7="",QString d8="",QString d9=""
                       ,QString d10="",QString d11="",QString d12=""
                       ,QString d13="",QString d14="",QString d15="");
        QString getHeaderItem(int col);
        QList<QString> getHeader(void);

        void setColumnPrintWrap(int col,bool wrap) { if(col <= col_count) printCellWrap[col] = wrap; }
        bool getColumnPrintWrap(int col)           { if(col <= col_count) return printCellWrap[col]; else return false; }
        void setColumnPrintMaxWidth(int col,int m) { if(col <= col_count) printMaxCellWidth[col] = m; }
        int  getColumnPrintMaxWidth(int col)       { if(col <= col_count) return printMaxCellWidth[col]; else return 0; }

        void replaceTextInColumn(int col,QString find,QString replace,bool parts=false);
        void replaceSameUnderCellToEmpty(int col);

        void firstRow(void);
        bool nextRow(void);
        bool isEnded(void);
        void removeCurrentRow(void);
        QList<QVariant> currentRow(void);
        QList<QString> currentRowStr(void);
        QString currentRowStr(QString separator);
        QString currentRowControl(void);

        void addRow(QList<QVariant> listdata,QString ctrl="");
        void addRowStr(QList<QString> strlistdata,QString ctrl="");
        void addRowStr(QString d1="",QString d2="",QString d3=""
                      ,QString d4="",QString d5="",QString d6=""
                      ,QString d7="",QString d8="",QString d9=""
                      ,QString d10="",QString d11="",QString d12=""
                      ,QString d13="",QString d14="",QString d15="")
            {
                addRowStrCTRL("",d1,d2,d3,d4,d5,d6,d7,d8,d9,d10,d11,d12,d13,d14,d15);
            }
        void addRowStrCTRL(QString ctrl,QString d1="",QString d2="",QString d3=""
                          ,QString d4="",QString d5="",QString d6=""
                          ,QString d7="",QString d8="",QString d9=""
                          ,QString d10="",QString d11="",QString d12=""
                          ,QString d13="",QString d14="",QString d15="");

        void appendHPainDataMatrix(HPlainDataMatrix *tail);

        QList<QVariant> getRow(int row);
        QList<QString> getRowStr(int row);
        QString getRowStr(int row,QString separator);

        QVariant getCell(int row,int col);
        QString getCellStr(int row,int col);
        void setCell(int row,int col,QVariant vdata);
        void setCellStr(int row,int col,QString strdata);

        void setRowControl(int row,QString ctrl);

        void setAppendPrependColumn(int col,QString prepend,QString append);

        void removeHTMLTags(bool force_all=false);

        int sumCoulmnAsInt(int col);
        double sumCoulmnAsDouble(int col);
        QString concatenateCoulmn(int col,QString separator);

        QString getContentAsHtml(QString params);

        void setHtmlCssText(QString css) { htmlcss = css; }

        QString getColumn(int col,QString separator);

    public slots:
        int actLine(QString key);
        int alternateActLine(QString key);
    signals:
        void actionOnRecord(QString key);
        void alternateActionOnRecord(QString key);

};

class HSqlSingleInterface
{
    public:
        HSqlSingleInterface();

    public:

        QString hsqli_currentModeName;

        bool hsqli_usequerysize;

        QString hsqli_booleantypename;

        QString hsqli_truevalue;

        QString hsqli_falsevalue;

        bool hsqli_hkeytype_varchar_int;

        int hsqli_varcharhkeylength;

        bool hsqli_need_create_sequence_before;

        QString hsqli_sequence_creation_string;

        QString hsqli_hkeyconstraint;

        int  hsqli_charhash_varcharlength;

        int  hsqli_smalltext_varcharlength;

        bool hsqli_largetext_sizemustdefine;

        int  hsqli_largetext_varcharlength;

        QString hsqli_numbertypename;

        QString hsqli_floattypename;

        bool hsqli_hastimestamptype;

        QString hsqli_timestamptypename;

        bool hsqli_hasdatetype;

        QString hsqli_datetypename;

        bool hsqli_sqlchooseconstraint;

        QString hsqli_timestampnowvalue;

        bool hsqli_appendsqlerrormsg;

        int hsqli_hackconvert_stdsqlconcatenation_to_local;
};

class HSqlSingleInterface_SqliteWin : public HSqlSingleInterface
{
    public:
        HSqlSingleInterface_SqliteWin(void);
};

class HSqlSingleInterface_SqliteLin : public HSqlSingleInterface
{
    public:
        HSqlSingleInterface_SqliteLin(void);
};

class HSqlSingleInterface_PsqlOdbcWin : public HSqlSingleInterface
{
    public:
        HSqlSingleInterface_PsqlOdbcWin(void);
};

class HSqlSingleInterface_PostgresqlLin : public HSqlSingleInterface
{
    public:
        HSqlSingleInterface_PostgresqlLin(void);
};

class HSqlSingleInterface_MysqlOdbcWin : public HSqlSingleInterface
{
    public:
        HSqlSingleInterface_MysqlOdbcWin(void);
};

class HSqlSingleInterface_MysqlLin : public HSqlSingleInterface
{
    public:
        HSqlSingleInterface_MysqlLin(void);
};

class HSqlInterface : public HBase
{
    Q_OBJECT

    private:
        static bool isset;
        static int currentDefaultInterface;
        static int defaultDefaultInterface;
        static HSqlSingleInterface *interfaces[MAX_SQL_INTERFACES];

        int myinterface;

    public:
        HSqlInterface();
        ~HSqlInterface();

        static void setSqlMode(QString modename);

        static void setSqlModeBackToFirst(void);

        void cloneSqlInterfaceSettingsFrom(HSqlInterface *other) { myinterface = other->myinterface; }

        HSqlSingleInterface *myInterface(void) { return interfaces[myinterface]; }

        static HSqlSingleInterface *currentDefaultSqlInterface(void);
        static HSqlSingleInterface *getSqlInterface(QString interfacename);

        QString sqlConcatenateToLocal(QString string);

        QString sqlConcatenateToLocal(QStringList fields);
};

class HSqlHandler : public HSqlInterface
{
    Q_OBJECT

    protected:
        bool query_error_occured;

    private:
        static bool globalnew_nodefault;
        static QString globalnew_current_database;

        bool    nodefault;
        QString current_database;

    public:
        static int trans;

    public:
        HSqlHandler(void);
        ~HSqlHandler(void);

        static void setCustomSqlDatabase(QString databaseName,QString sqlinterfacename = "");
        static void setDefaultSqlDatabase(void);

        QSqlDatabase workDB(void);

        QSqlQuery *allocateQSqlQuery(void);

        void cloneSqlSettingsFrom(HSqlHandler *other);

        void transaction(void);

        void commit(void);

        void rollback(void);

        bool submit0ResultQuery(QString q,QString err,bool tdisabled=false);

        QVariant submit1ResultQuery(QString q,QString err,bool tdisabled=false);

        HPlainDataMatrix* submitNResultQuery(int N,QString q,QString err,bool tdisabled=false);

        bool errorStatus(void) { return query_error_occured; }

    signals:
        void errorSignal(QString err);
};

class HDataField;
/* NOT DOCUMENTED: This is a helper class which is makes list from the HDataField-s. Don't use directly!
 * It is used by the HTableBase class automatically. */
class HDataField_List : public HSqlHandler
{
    Q_OBJECT

    public:
        HDataField_List(void);
        ~HDataField_List(void);

        void addElement(HDataField *d);
        void clearElements(void);
        void connectElement(HDataField_List *c);
        void disconnectElement(void);

    public:
        HDataField *data;
        HDataField_List *next;
        HDataField_List *nextall;

};

class HDataChangeLogger;

class HTableBase : public HSqlHandler
{
        Q_OBJECT

    protected:

        QString     tabletitle;
        int         field;
        HDataField_List *table,*run; // < Head of the list
        QString     sqlTable;
        QStringList *depend;

        QString conn_part;

        QString     imc_thiskey,imc_thatkey;
        HTableBase *imc_thattable;

        QStack<HTableBase *> *connectedTableBases;

    public:
        bool extrafeatures;

        bool gui_showtabletitle;

        QString errstr;

        HTableBase(QString t);
        ~HTableBase(void);

        HTableBase(HTableBase *t);

        void deepcopy_from_htablebase(HTableBase *x);

        void connectTable(HTableBase *ct,int type=INNER_JOIN,QString connconstraint="");

        void connectTable(HTableBase *ct,QString thiskey,QString thatkey,int type=INNER_JOIN,QString connconstraint="");

        void clearConnections(void);

        void clearAndFreeConnections(void);

        void freeTable(void);

        void addField(HDataField *i);

        void firstField(void);

        HDataField *nextField(void);

        HDataField *nextFieldAll(void);

        HDataField *fieldBySqlName(QString sqln,bool all=false,QString containerSqlTable="");

        HDataField *fieldByIndex(int i,bool all=false);

        HDataField *staticFieldByTitle(QString title="");

        int fieldCount(bool withconnect=false);

        void setEditable(void);

        void setReadonly(void);

        void setHide(void);

        void setShow(void);

        void setColor(int r,int g,int b);

        void setAllNOSet(void);
        void setAllYESSet(void);

        void resetLogging(void);
        void setLogging(void);

        bool isChanged(bool all=false);

        QString  tableTitle(void)         { return tabletitle; }
        void     setTableTitle(QString s) { tabletitle = s;    }

        QString sqlTableName(void);

        QStringList getExplainHeads(void)      { return getHeads(1); }

        QStringList getShortTitleHeads(void) { return getHeads(2); }

        QStringList getHeads(int what);

        QString sqlSelect(QString tail="",bool all=false,bool keypart=false);

        QString sqlSelectAll(QString tail="") { return sqlSelect(tail,true,false); }

        QString sqlSelectWk(QString tail="",bool all=false) { return sqlSelect(tail,all,true); }

        QString sqlSelectWkAll(QString tail="") { return sqlSelect(tail,true,true); }

        QVariant operator[](int i);

        void dataUpdated(void);

        void sqlSynced(HDataChangeLogger *dclog = NULL,bool forcechange=false,bool forcelog = false);
        void clearSqlSynced(void);
        bool isReallyChanged(void);

        QString validate(bool all=true);

        QString sqlCreateString(QString switches="");

        void setShowAllMarked(QString mark);
        void setHideAllMarked(QString mark);
        void setEditableAllMarked(QString mark);
        void setReadolnyAllMarked(QString mark);
        void returnToDefaultAllMarked(QString mark);

        void setGuiEnabledAllMarked(QString mark);
        void setGuiDisabledAllMarked(QString mark);
        void setLoggingAllMarked(QString mark);

        void setColorAllMarked(QString mark,int r,int g,int b);

        void removeSqlCooseButtons(void);

        void blockReInitializeBase(QString hide_marker,QString ro_marker);

        void useRole(QString name);
        void delRole(QString name);
        void clearRoles(void);

    public slots:
        int errorPassSlot(QString err);

        void addDependTableName(QString n);

    signals:
        void dataChanged(void);

        void dataUpdatedSignal(void);

        void dataModifiedSignal(void);

#ifdef PROGRESS_POSSIBILITY

        void startWorking(void);
        void doWorking(void);
        void endWorking(void);

#endif

};

class HTable : public HTableBase
{
    Q_OBJECT

    protected:
        bool ro_mask;
        bool reread_key;
        QString insertedKey;

        HDataChangeLogger *dclog;

    public:
        HTable(QString t);
        ~HTable(void);

        HTable(HTable *t);

        void deepcopy_from_htable(HTable *x);

        QString sqlInsert(bool insertkey=false);

        QString sqlInsertAll(void);

        QString sqlUpdate(bool all=false);
        QString sqlUpdateAll(void) { return sqlUpdate(true); }

        QString getKey(bool head_val,QString intable="");

        QVariant operator[](int i);

        void setSqlFieldValue(QString sqln,QVariant v,bool sdisable=false);

        QVariant getSqlFieldValue(QString sqln);

        bool readonlyMask(void) { return ro_mask; }

        void blockReInitialize(QString hide_marker,QString ro_marker);

        void setDataChangeLogger(HDataChangeLogger *dcl) { dclog = dcl; }
        void clearDataChangeLogger(void) { dclog = NULL; }

        int recordCount(void) { return 1; }

    public slots:
        int updateWithKey(QString key="",bool all=false,bool update = true,bool tdisabled=false);

        int updateWithKeyAll(QString key="",bool update=true,bool tdisabled=false) { return updateWithKey(key,true,update,tdisabled); }

        int setKey(QString key);

        int saveRecord(bool all=false,bool tdisabled=false);

        int saveRecordAll(bool tdisabled=false) { return saveRecord(true,tdisabled); }

        int insertRecord(bool insertkey=false,bool disable_tr=false,bool resetafterinsert=true);

        int insertRecordAll(bool disable_tr=false);

        QString getInsertedKey(void) { return insertedKey; }
        void rereadNextInsertedKey(void) { insertedKey=""; reread_key = true; }

        int returnToDefault(bool all=true);

        int enableReadonlyMask(void)  { ro_mask = true;  return 0; }
        int disableReadonlyMask(void) { ro_mask = false; return 0; }

    protected:
        QString getKeyValueAfterInsert(void);

        QString specifyKey(QString tablename);
};


#define FLOATTABLES_STS_UNDEF       0
#define FLOATTABLES_STS_ALIVE       1
#define FLOATTABLES_STS_NEW         2
#define FLOATTABLES_STS_DELETED     3
#define FLOATTABLES_STS_CANCELLED   4

class HFloatTables : public HSqlHandler
{
    protected:
        QString sqlTable;
        bool fiter;
        QList<HTable *>::iterator titer;
        QList<int>::iterator siter;

    public:
        HTable *baserecord;
        QList<int>       *sts;
        QList<HTable *> *tbls;

    public:
        HFloatTables(HTable *baserec);
        ~HFloatTables(void);

        QString sqlTableName(void) { return sqlTable; }

        int count(void);
        int recordCount(void) { return count(); }
        int countAllStat(void);

        HTable *getTByField(QString field,QString key);
        HTable *getTByKey(QString key);
        HTable *getTByNum(int idx);

        void allAliveToNew(void);
        void setAllField(QString fname,QVariant value);

        void first(void);
        HTable *nextRecord(void);
        QString nextKey(void);

        HTable *createRecord(void);
        HTable *createRecordAsUndef(void);
        void markedRecordToNew(HTable *r);
        void removeUndef(void);

        int deleteRecord(HTable *d);
        int deleteRecord(int idx);

        int clearMem(void);

        int readDBTable(QString filter,bool tdisabled=false);

        int saveDBTable(bool tdisabled=false);
};

class HList : public HTableBase
{
    Q_OBJECT

    protected:

        QStringList          *keys;
        QList<QStringList *> *values;
        QString              active_key;

        QList<QStringList *>::iterator  query_valiter;
        QStringList::iterator           query_keyiter;

    public:
        QString last_filter;
        bool    last_all;

    public:

        HList(QString t);
        ~HList(void);

        HList(HList *t);
        void deepcopy_from_hlist(HList *x);

        virtual QList<QStringList *>*  getValues(void) { return values; }
        virtual QStringList*           getKeys(void)   { return keys;   }

        QString operator[](int i);

        int recordCount(void) { return keys->count(); }

        QString activeKey(void);
        void setActiveKey(QString k);

        virtual QString getSqlFieldValue(QString sqln);

        QString soft_current_key;

        void queryToFirst(void);
        bool queryNextRecord(void);
        QString queryNextKey(void);
        QStringList* queryNextValues(void);
        QString queryCurrKey(void);
        QStringList* queryCurrValues(void);

    public slots:
        virtual int clearList(void);

        int actLine(void);
        int alternateActLine(void);

        virtual int readList(QString filter="",bool all=true);
        int reReadList(void) { return readList(last_filter,last_all); }

        int captureNotify(QString tblname);

    signals:
        void actionOnRecord(QString key);
        void alternateActionOnRecord(QString key);

};

class HFloatTablesAsHList : public HList
{
    Q_OBJECT

    protected:
        HFloatTables *mem;

    public:
        HFloatTablesAsHList(HFloatTables *memt,HList *templ=NULL,bool clone_struct_from_memt=false);
        ~HFloatTablesAsHList();

        HTable *getActiveTable(void);

        void refreshValuesKeys(bool updSignal=false);

        virtual QList<QStringList *>* getValues(void) { return values; }
        virtual QStringList*          getKeys(void)   { return keys; }

    public slots:
        virtual int clearList(void);
        virtual int readList(QString filter="",bool all=true);

    private:
        //don't use this (that's why it is private)
        virtual QString getSqlFieldValue(QString sqln);

};

// ///////////////////////////////////////////////////////////////////////////////
// / Classes of data fields (and related) ////////////////////////////////////////
// ///////////////////////////////////////////////////////////////////////////////

class HDataFieldRole
{
    public:
        QString name;
        QString mod;
        QString val;

    public:
        HDataFieldRole(void);
        HDataFieldRole(QString name,QString mod="",QString val="");

        ~HDataFieldRole(void);

        void addShowMod(void);
        void addHideMod(void);

        void addEditableMod(void);
        void addReadonlyMod(void);

        void addGuienabledMod(void);
        void addGuidisabledMod(void);

        void addResetMod(void);
        void addSetvalMod(void);


        bool hasShowMod(void);
        bool hasHideMod(void);

        bool hasEditableMod(void);
        bool hasReadonlyMod(void);

        bool hasGuienabledMod(void);
        bool hasGuidisabledMod(void);

        bool hasResetMod(void);
        bool hasSetvalMod(void);

};

class HDataField : public HSqlHandler
{
    Q_OBJECT

    protected:
        int set;
        QString explain;
        QString title;
        QString tailstr;
        QString sqlColumn;
        QString defval;
        QString valid;
        QStringList notvalid;
        QString function;
        QString derived;
        bool    meldwithnext;
        bool    nomiddlestretch;
        int     editboxmaxwidth;

        QString spec_disp_sort;

        bool lastvalidate_result;
        bool permanentvalidate_result;
        QString manual_validate_error;

        bool editable;
        bool sql;
        bool show;
        bool guienabled;

        int  wcellw_print;
        bool wcell_print;

        int color_r,color_g,color_b;

        QStringList markers;
        QList<HDataFieldRole> roles;

        bool logged;
        bool sync_valueInSql;
        QString  valueInSql;

    public:
        bool connected;
        QString conn_sqlTable;

    public:
        HDataField(QString _sqlColumn,QString _explain,QString tit,
                   QString _tailstr="",bool _editable=true);
        ~HDataField(void);

        HDataField(HDataField *t);

        void setData(QString _sqlColumn,QString _explain,QString tit,
                     QString _tailstr="",bool _editable=true);

    public:
        void deepcopy_from_hdatafield(HDataField *x);

        virtual HDataField* get_clone(void);

        QString getExplainText(void) { return explain; }
        QString getTitleText(void)   { return title;   }
        QString getTailText(void)    { return tailstr; }

        void setExplainText(QString expl);
        void setTitleText(QString titl);
        void setTailText(QString tail);

        void setSpecDisplaySortMode(QString m) { spec_disp_sort=m;      }
        QString getSpecDisplaySortMode(void)      { return spec_disp_sort; }

        virtual int setValue (QVariant v,bool sdisabled=false);
        virtual QVariant getValue(void);
        virtual int setDefval(QVariant v);
        QString getDefaultValue(void) { return defval; }
        virtual QString getSQLValue(void);
        virtual QString getSQLValueAsString(void);
        virtual QString sqlInsertHead(void);
        virtual QString sqlInsertValue(void);
        virtual QString sqlUpdate(void);
        virtual QString sqlSelectHead(void);

        virtual void value_changed();

        virtual QVariant dbValueToDispValue(QVariant v);

        virtual QVariant getDispValue() { return dbValueToDispValue(getValue()); }

        bool isSQLField(void) { return sql; }
        bool isEditable(void) { return editable; }
        bool isShow(void) { return show; }
        bool isSet(void) { if(set) return true; else return false; }
        bool isGuienabled(void) { return guienabled; }

        void setEditable(void);
        void setReadonly(void);
        void setShow(void) { show = true; }
        void setHide(void) { show = false; }
        void setGuienabled(void) { guienabled = true; }
        void setGuidisabled(void) { guienabled = false; }
        void notSet(void) { set=0; }
        void doSet(void) { set=1; }
        void setLogging(void) { logged = true; }
        void resetLogging(void) { logged = false; }
        bool isLogged(void) { return logged; }

        HDataField * asConstant(void) { setReadonly(); return this; }
        HDataField * asHide(void) { setHide(); return this; }

        void setColor(int r,int g,int b);
        int getRColor(void) { return color_r; }
        int getGColor(void) { return color_g; }
        int getBColor(void) { return color_b; }
        HDataField * asColored(int r,int g,int b) { setColor(r,g,b); return this;}

        void meldWithNext(void)         { meldwithnext = true;  }
        void resetMeldWithNext(void)    { meldwithnext = false; }
        bool isMeldedWithNext(void)     { return meldwithnext;  }

        void noMiddleStretch(void)      { nomiddlestretch = true; }
        void resetNoMiddleStretch(void) { nomiddlestretch = false;}
        bool isNoMiddleStretch(void)    { return nomiddlestretch; }

        void setEditBoxMaxWidth(int max) { editboxmaxwidth = max;  }
        int  editBoxMaxWidth(void) { return editboxmaxwidth; }

        virtual bool acceptFunction(void) { return false; }
        void setFunction(QString func);
        void resetFunction(void)       { function = "";   }
        QString getFunction(void)      { return function; }

        virtual bool acceptSubselect(void) { return false; }
        void setSubselect(QString subs);
        void resetSubselect(void)       { derived = "";   }
        QString getSubselect(void)      { return derived; }

        void setPrintCellWidth (int w) { wcellw_print = w; }
        int  getPrintCellWidth (void)  { return wcellw_print; }

        void setPrintCellWrap  (void)  { wcell_print = true; }
        void setPrintCellNoWrap(void)  { wcell_print = true; }
        bool isPrintCellWrap   (void)  { return wcell_print; }

        virtual QString sqlCreateStringPart(QString switches="");

        int returnToDefault(void);

        QVariant defvalParser(QString s);

        void sqlSynced(HDataChangeLogger *dclog = NULL,bool forcechange=false,bool forcelog = false);
        void clearSqlSynced(void);
        bool isReallyChanged(void);

        void setValidator(QString v="");
        QString validate(void);
        virtual QString lowerValidate(void) { return QString(""); }

        void addNotValidValue(QString v);
        void setNotValidValues(QStringList nvl);
        void clearNotValidValues(void);

        void addMark(QString mark);
        void addMark(QStringList pmarkers);
        bool hasMark(QString mark);
        void clearMarkers(void);
        QStringList allMarker(void);

        void addRole(HDataFieldRole role);
        void delRole(QString name);
        void clearRoles(void);
        void useRole(QString name);

        bool getLastValidateStatus() { return lastvalidate_result; }
        void resetValidateStatus()   { lastvalidate_result=false;  }
        bool getPermanentValidateStatus() { return permanentvalidate_result; }
        void setMaulallyValidateError(QString message);

    public slots:
        void disableControlSlot(void) { emit disableControl(); }
        void enableControlSlot(void) { emit enableControl(); }

    signals:

        void dataChanged(void);

        void disableControl(void);
        void enableControl(void);

        void updateStaticDisplayElementsSignal(void);
};

class HKey : public HDataField
{
    Q_OBJECT

    protected:
        QString value;

    public:
        HKey(QString sqlc,QString ex,QString tit,QString def);
        ~HKey(void);

        HKey(HKey *t);
        void deepcopy_from(HKey *x);
        virtual HDataField* get_clone(void);

        virtual int     setValue (QVariant v,bool sdisabled=false);
        virtual int     setDefval(QVariant v);
        virtual QVariant getValue(void);
        virtual QString getSQLValue(void);
        virtual QString getSQLValueAsString(void);
        virtual QString sqlInsertHead(void);
        virtual QString sqlInsertValue(void);
        virtual QString sqlUpdate(void);
        virtual QString sqlSelectHead(void);

        virtual QString sqlCreateStringPart(QString switches="");
};

class HConnect : public HDataField
{
    Q_OBJECT

    protected:
        QString connected_table;
        QString value;

    public:
        HConnect(QString sqlc,QString connected_tablep);
        ~HConnect(void);

        HConnect(HConnect *t);
        void deepcopy_from(HConnect *x);
        virtual HDataField* get_clone(void);

        /* Returns the name of the connected table */
        QString getConnectedTable(void) { return connected_table; }

        virtual int     setValue (QVariant v,bool sdisabled=false);
        virtual int     setDefval(QVariant v);
        virtual QVariant getValue(void);
        virtual QString getSQLValue(void);
        virtual QString getSQLValueAsString(void);
        virtual QString sqlInsertHead(void);
        virtual QString sqlInsertValue(void);
        virtual QString sqlUpdate(void);
        virtual QString sqlSelectHead(void);

        virtual QString sqlCreateStringPart(QString switches="");
};

class HSmallText : public HDataField
{
    Q_OBJECT

    protected:
        QString value;
        bool initial_selected;

    public:
        HSmallText(QString sqlc,QString ex,QString tit,QString t,QString def);
        ~HSmallText(void);

        HSmallText(HSmallText *t);
        void deepcopy_from(HSmallText *x);
        virtual HDataField* get_clone(void);

        virtual QVariant dbValueToDispValue(QVariant v);
        virtual int     setValue (QVariant v,bool sdisabled=false);
        virtual int     setDefval(QVariant v);
        virtual QVariant getValue(void);
        virtual QString getSQLValue(void);
        virtual QString getSQLValueAsString(void);
        virtual QString sqlInsertHead(void);
        virtual QString sqlInsertValue(void);
        virtual QString sqlUpdate(void);
        virtual QString sqlSelectHead(void);

        virtual bool acceptFunction(void) { return true; }
        virtual bool acceptSubselect(void) { return true; }

        virtual QString sqlCreateStringPart(QString switches="");

        void setInitialSelected(bool selected)  { initial_selected = selected;  }
        bool isInitialSelected(void)            { return initial_selected;      }
};

class HLargeText : public HDataField
{
    Q_OBJECT

    protected:
        QString value;

    public:
        HLargeText(QString sqlc,QString ex,QString tit,QString def);
        ~HLargeText(void);

        HLargeText(HLargeText *t);
        void deepcopy_from(HLargeText *x);
        virtual HDataField* get_clone(void);

        virtual int     setValue (QVariant v,bool sdisabled=false);
        virtual int     setDefval(QVariant v);
        virtual QVariant getValue(void);
        virtual QString getSQLValue(void);
        virtual QString getSQLValueAsString(void);
        virtual QString sqlInsertHead(void);
        virtual QString sqlInsertValue(void);
        virtual QString sqlUpdate(void);
        virtual QString sqlSelectHead(void);

        virtual bool acceptFunction(void) { return true; }
        virtual bool acceptSubselect(void) { return true; }

        virtual QString sqlCreateStringPart(QString switches="");
};

class HCharHash : public HDataField
{
    Q_OBJECT

    protected:
        QString value;

    public:
        QStringList keys;
        QStringList values;

    public:
        HCharHash(QString sqlc,QString ex,QString tit,QString t,QString def,
                  QStringList k,QStringList v);
        ~HCharHash();

        HCharHash(HCharHash *t);
        void deepcopy_from(HCharHash *x);
        virtual HDataField* get_clone(void);

        virtual QVariant dbValueToDispValue(QVariant v);
        virtual int     setValue (QVariant v,bool sdisabled=false);
        virtual int     setDefval(QVariant v);
        virtual QVariant getValue(void);
        virtual QString getSQLValue(void);
        virtual QString getSQLValueAsString(void);
        virtual QString sqlInsertHead(void);
        virtual QString sqlInsertValue(void);
        virtual QString sqlUpdate(void);
        virtual QString sqlSelectHead(void);

        virtual QString sqlCreateStringPart(QString switches="");

        QString getKeyOfValue(QString s);
        QString getValueOfKey(QString s);
};

class HNumHash : public HDataField
{
    Q_OBJECT

    protected:
        int value;

    public:
        QStringList keys;
        QStringList values;

    public:
        HNumHash(QString sqlc,QString ex,QString tit,QString t,QString def,
                  QStringList k,QStringList v);
        ~HNumHash();

        HNumHash(HNumHash *t);
        void deepcopy_from(HNumHash *x);
        virtual HDataField* get_clone(void);

        virtual QVariant dbValueToDispValue(QVariant v);
        virtual int     setValue (QVariant v,bool sdisabled=false);
        virtual int     setDefval(QVariant v);
        virtual QVariant getValue(void);
        virtual QString getSQLValue(void);
        virtual QString getSQLValueAsString(void);
        virtual QString sqlInsertHead(void);
        virtual QString sqlInsertValue(void);
        virtual QString sqlUpdate(void);
        virtual QString sqlSelectHead(void);

        virtual QString sqlCreateStringPart(QString switches="");

        QString getKeyOfValue(QString s);
        QString getValueOfKey(QString s);

};

class HNumber : public HDataField
{
    Q_OBJECT

    protected:
        int value;
        long int minimum,maximum;

    public:
        HNumber(QString sqlc,QString ex,QString tit,QString t,QString def);
        ~HNumber(void);

        HNumber(HNumber *t);
        void deepcopy_from(HNumber *x);
        virtual HDataField* get_clone(void);

        virtual int     setValue (QVariant v,bool sdisabled=false);
        virtual int     setDefval(QVariant v);
        virtual QVariant getValue(void);
        virtual QString getSQLValue(void);
        virtual QString getSQLValueAsString(void);
        virtual QString sqlInsertHead(void);
        virtual QString sqlInsertValue(void);
        virtual QString sqlUpdate(void);
        virtual QString sqlSelectHead(void);

        virtual bool acceptFunction(void) { return true; }
        virtual bool acceptSubselect(void) { return true; }

        virtual QVariant dbValueToDispValue(QVariant v);

        virtual QString sqlCreateStringPart(QString switches="");

        virtual QString lowerValidate(void);

        void setMinimum(long int m) { minimum = m;    }
        void setMaximum(long int m) { maximum = m;    }
        long int getMinimum(void)   { return minimum; }
        long int getMaximum(void)   { return maximum; }

};

class HStatic : public HDataField
{
    Q_OBJECT

    protected:
        QString value;

    public:
        HStatic(QString ex,QString tit="",QString def="");
        ~HStatic(void);

        HStatic(HStatic *t);
        void deepcopy_from(HStatic *x);
        virtual HDataField* get_clone(void);

        virtual int     setValue (QVariant v,bool sdisabled=false);
        virtual int     setDefval(QVariant v);
        virtual QVariant getValue(void);
        virtual QString getSQLValue(void);
        virtual QString getSQLValueAsString(void);
        virtual QString sqlInsertHead(void);
        virtual QString sqlInsertValue(void);
        virtual QString sqlUpdate(void);
        virtual QString sqlSelectHead(void);

        virtual QString sqlCreateStringPart(QString switches="");
};

class HCheck : public HDataField
{
    Q_OBJECT

    protected:
        bool value;

    public:
        QString trues;
        QString falses;

    public:
        HCheck(QString sqlc,QString ex,QString tit,QString t,QString def,QString ts=GSAFETEXT_YES_HAVE,QString fs=GSAFETEXT_NO_HAVENOT);
        ~HCheck(void);

        HCheck(HCheck *t);
        void deepcopy_from(HCheck *x);
        virtual HDataField* get_clone(void);

        virtual QVariant dbValueToDispValue(QVariant v);
        virtual int     setValue (QVariant v,bool sdisabled=false);
        virtual int     setDefval(QVariant v);
        virtual QVariant getValue(void);
        virtual QString getSQLValue(void);
        virtual QString getSQLValueAsString(void);
        virtual QString sqlInsertHead(void);
        virtual QString sqlInsertValue(void);
        virtual QString sqlUpdate(void);
        virtual QString sqlSelectHead(void);

        virtual QString sqlCreateStringPart(QString switches="");
};

class HFloating : public HDataField
{
    Q_OBJECT

    protected:
        double value;
        double minimum,maximum;
        int dMminDf,dMmaxDf,dMgroup;

    public:
        HFloating(QString sqlc,QString ex,QString tit,QString t,QString def);
        ~HFloating(void);

        HFloating(HFloating *t);
        void deepcopy_from(HFloating *x);
        virtual HDataField* get_clone(void);

        virtual int     setValue (QVariant v,bool sdisabled=false);
        virtual int     setDefval(QVariant v);
        virtual QVariant getValue(void);
        virtual QString getSQLValue(void);
        virtual QString getSQLValueAsString(void);
        virtual QString sqlInsertHead(void);
        virtual QString sqlInsertValue(void);
        virtual QString sqlUpdate(void);
        virtual QString sqlSelectHead(void);

        virtual bool acceptFunction(void) { return true; }
        virtual bool acceptSubselect(void) { return true; }

        virtual QVariant dbValueToDispValue(QVariant v);
        virtual QString sqlCreateStringPart(QString switches="");
        virtual QString lowerValidate(void);

        void setMinimum(double m) { minimum = m; }
        void setMaximum(double m) { maximum = m; }
        double getMinimum(void) { return minimum; }
        double getMaximum(void) { return maximum; }

        void setDisplayMode(int minDf,int maxDf,int groupDf) {dMminDf=minDf; dMmaxDf=maxDf; dMgroup=groupDf; }

        QString getValueAsString(void);

};

class HDate : public HDataField
{
    Q_OBJECT

    protected:
        QDate value;
        bool u_alive;
        bool unknown;

    public:
        HDate(QString sqlc,QString ex,QString tit,QString def,bool u_a=true,bool unk=true);
        ~HDate(void);

        HDate(HDate *t);
        void deepcopy_from(HDate *x);
        virtual HDataField* get_clone(void);

        virtual int     setValue (QVariant v,bool sdisabled=false);
        virtual int     setDefval(QVariant v);
        virtual QVariant getValue(void);
        virtual QString getSQLValue(void);
        virtual QString getSQLValueAsString(void);
        virtual QString sqlInsertHead(void);
        virtual QString sqlInsertValue(void);
        virtual QString sqlUpdate(void);
        virtual QString sqlSelectHead(void);

        virtual bool acceptFunction(void) { return true; }
        virtual bool acceptSubselect(void) { return true; }

        void possible_unknown(void)   { u_alive=true;   }
        void impossible_unknown(void) { u_alive=false;  }
        bool is_unknown_alive(void)   { return u_alive; }

        void value_is_unknown(void);
        void value_is_known(void);
        bool is_value_unknown(void)   { return unknown; }

        virtual QVariant getKnownValue(void);

        virtual QString sqlCreateStringPart(QString switches="");
};

class HTimestamp : public HDataField
{
    Q_OBJECT

    protected:
        QString value;
        bool check;
        bool readed;

    public:
        HTimestamp(QString sqlc,QString ex,QString tit,QString def,bool c);
        ~HTimestamp(void);

        HTimestamp(HTimestamp *t);
        void deepcopy_from(HTimestamp *x);
        virtual HDataField* get_clone(void);

        virtual QVariant dbValueToDispValue(QVariant v);
        virtual int     setValue (QVariant v,bool sdisabled=false);
        virtual int     setDefval(QVariant v);
        virtual QVariant getValue(void);
        virtual QString getSQLValue(void);
        virtual QString getSQLValueAsString(void);
        virtual QString sqlInsertHead(void);
        virtual QString sqlInsertValue(void);
        virtual QString sqlUpdate(void);
        virtual QString sqlSelectHead(void);

        void set_havetocheck(void)      { check = true; }
        void set_donthavetocheck(void)  { check = false; }
        bool is_checkenabled(void)      { return check;  }

        void read_from_sql(void) { readed = true; }
        bool is_sqlreaded(void)  { return readed; }

        virtual QString sqlCreateStringPart(QString switches="");
};

/* NOT DOCUMENTED: Key - Value pair. Helper class of HSqlChoose. Don't use directly! */
class KVPair
{
    public:
        KVPair(void) { key = ""; value = ""; busy = false; }
        QString key,value;
        bool busy;
};

class HSqlChoose : public HDataField
{
    Q_OBJECT

    protected:
        int (*hash)(const char*);

        QString value;

        QString connected_table;
        QString key_field;
        QString showed_field;

        QString showed_field_head;
        QString filter_part;
        QString order_part;
        QString popupdialog_title;
        int sortc; // gui based sort/sort by column c; c=-1(no sort)

        //If this attribute is false the referenced table is have not readed yet.
        // (It means the "keys" "values" "spevalues" has invalid status)
        bool readed_reftable;

        QStringList keys;      //cache
        QStringList values;    //cache
        QStringList sepvalues; //cache

        int maxhash;
        KVPair *pairs;

        bool easyform;

    public:
        const QObject *toolbrec;
        QString btext;
        QString toolbarbutton_down_text;

        bool progress_on_read;

        const QObject* extrafunc_receiver[5];
        QString extrafunc_text[5];

    public:
        HSqlChoose(QString sqlc,QString ex,QString tit,QString def,
                   QString ct,QString kf,QString sf,QString sfh,QString fp,QString op,
                   QString inthash="",bool easyf=true);
        ~HSqlChoose(void);

        HSqlChoose(HSqlChoose *t);
        void deepcopy_from(HSqlChoose *x);
        virtual HDataField* get_clone(void);

        virtual QVariant dbValueToDispValue(QVariant v);
        virtual int     setValue (QVariant v,bool sdisabled=false);
        virtual int     setDefval(QVariant v);
        virtual QVariant getValue(void);
        virtual QString getSQLValue(void);
        virtual QString getSQLValueAsString(void);
        virtual QString sqlInsertHead(void);
        virtual QString sqlInsertValue(void);
        virtual QString sqlUpdate(void);
        virtual QString sqlSelectHead(void);

        QString getConnectedTableName(void) { return connected_table; }

        void setFilterPart(QString fp);
        void enableEasyForm(void);
        void disableEasyForm(void);
        bool getEasyForm(void) { return easyform; }

        void deferredSqlRefresh(void) { readed_reftable = false; }
        int refreshSqlValues(bool emitsignal=true,bool tdisabled=false);
        QStringList& getKeys  (void);
        QStringList& getValues(void);
        QStringList& getSeparatedValues(void);
        QString getFieldHeads(void) { return showed_field_head; }

        void setGuiSortIndicator(int i) { sortc = i;    }
        int  getGuiSortIndicator(void)  { return sortc; }

        void addToolButton(const QObject* receiver,QString text);
        void removeToolButton(void);

        void addExtraFunction(int pos,const QObject* receiver,QString text);
        void removeExtraFunction(void);

        void setPopupDialogTitle(QString title) { popupdialog_title = title;    }
        void resetPopupDialogTitle(void)        { popupdialog_title = "";       }
        QString getPopupDialogTitle(void)       { return popupdialog_title;     }

        void setHashFunction(int (*nh)(const char*) ) { hash = nh; }
        void setInernalHashFunction(QString hashname);

        virtual QString sqlCreateStringPart(QString switches="");

    signals:
        void dataUpdatedSignal(void);

    #ifdef PROGRESS_POSSIBILITY

        void startWorking(void);
        void doWorking(void);
        void endWorking(void);
    #endif

};

//The default hash functions.
int nullhash    (const char *c); //Codename: "nullhash"
int charcodehash(const char *c); //Codename: "charcodehash"
int dropchar    (const char *c); //Codename: "dropchar"

// ///////////////////////////////////////////////////////////////////////////////
// / Classes of HDataChangeLoggerdata fields (and related) ///////////////////////
// ///////////////////////////////////////////////////////////////////////////////

/* NOT DOCUMENTED: Helper struct of HDataChangeLogger, do not use directly */
struct HOneDataChange
{
    QString pos;
    QString user;
    QString tablename;
    QString changedkey;
    QString fieldname;
    QString oldvalue;
    QString newvalue;
};

class HDataChangeLogger : public HSqlHandler
{
    Q_OBJECT

    friend class HTable;
    friend class HDataField;

public:
    HDataChangeLogger(HTable *logtable,QString startpos=GSAFETEXT_UNKNOWN,QString startuser=GSAFETEXT_UNKNOWN);
    ~HDataChangeLogger(void);

    void setPosAndUser(QString pos,QString user) { curr_pos = pos; curr_user = user; }
    void setPos(QString pos) { curr_pos = pos; }
    void setUser(QString user) { curr_user = user; }

private:
    void setTablename(QString tablename) { curr_table = tablename; }
    void setChangedKey(QString changedkey) { curr_ckey = changedkey; }
    void addChange(QString fieldname,QString oldval,QString newval);
    void writeOut(bool tdisabled = false);

private:
    QString curr_pos;
    QString curr_user;
    QString curr_table;
    QString curr_ckey;
    HTable *logtable;
    QList<HOneDataChange> changes;
};


// ///////////////////////////////////////////////////////////////////////////////
// / Classes of HDynTable (and related) //////////////////////////////////////////
// ///////////////////////////////////////////////////////////////////////////////

#define HDYNELEMENT_STRING 0
#define HDYNELEMENT_DOUBLE 1

class HDynTableElement
{
    friend class HDynTable;

private:
    QString name;
    QString rowName,colName;
    QString sqlname;
    QList<QString> labels;

    int type; // HDYNELEMENT_STRING:textual 1:double
    QString textual_value;
    double  double_value;

private:

    HDynTableElement(int type,QString name,QString sqlname,QString rowName,QString colName,QString labels="");

    int  getType(void);
    bool isNumeric(void);
    bool isTextual(void);

    void    setDoubleValue(double d);
    void    setTextualValue(QString s);
    double  getDoubleValue(void);
    QString getTextualValue(void);

    void addLabel(QString l);
    bool hasLabel(QString l);
};


class HDynTable : public HBase
{
    Q_OBJECT

private:
    QList<HDynTableElement> elements;
    QList<HDynTableElement>::iterator internal_iterator;

    void add(HDynTableElement e);
public:
    HDynTable(void);
    HDynTable(const HDynTable& t);
    ~HDynTable(void);

    void defN(QString name,QString sqlname="",QString rowName="",QString colName="",QString labels="")
    { add(HDynTableElement(HDYNELEMENT_DOUBLE,name,sqlname,rowName,colName,labels));  }

    void defS(QString name,QString sqlname="",QString rowName="",QString colName="",QString labels="")
    { add(HDynTableElement(HDYNELEMENT_STRING,name,sqlname,rowName,colName,labels));  }

    void defT(int type,QString name,QString sqlname="",QString rowName="",QString colName="",QString labels="")
    { add(HDynTableElement(type,name,sqlname,rowName,colName,labels));  }

    void clear(void) { elements.clear(); }

    QString dumpElements(void);

    void setElementValue(QString name,double value);
    void setElementValue(QString name,QString value);

    double  getElementValueDouble(QString name,bool *found=NULL);
    QString getElementValueString(QString name,bool *found=NULL);

    void setElementValueByRowColName(QString r,QString c,double value);
    void setElementValueByRowColName(QString r,QString c,QString value);

    double getElementValueDoubleByRowColName(QString r,QString c,bool *found=NULL);
    QString getElementValueStringByRowColName(QString r,QString c,bool *found=NULL);

    QString getElementSqlName(QString name);


    void firstElement(void);
    bool isEnded(void);
    void nextElement(void);

    QString currentElementName(void);
    QString currentElementRowName(void);
    QString currentElementColumnName(void);
    QString currentElementSqlName(void);
    QStringList currentElementLabels(void);

    bool    currentElementIsNumeric(void);

    double  currentElementValueDouble(void);
    QString currentElementValueString(void);

    void setCurrentElementValue(double d);
    void setCurrentElementValue(QString s);


    void   emptyall(QString limitTo = "");
    void   zeroall(QString limitTo = "");
    double max(QString limitTo = "");
    double min(QString limitTo = "");
    double sum(QString limitTo = "");

    void sustraction(double d,QString limitTo = "");
    void sustraction(HDynTable dt,QString limitTo = "");
    void addition(double d,QString limitTo = "");
    void addition(HDynTable dt,QString limitTo = "");
    void multiplicate(double d,QString limitTo = "");
    void multiplicate(HDynTable dt,QString limitTo = "");
    void divide(double d,QString limitTo = "");
    void divide(HDynTable dt,QString limitTo = "");

    int countElements(QString limitTo="");
    QString indexedElementName(int index);
    QString indexedElementSqlName(int index);
    double getIndexedValueDouble(int index,bool *found=NULL);
    QString getIndexedValueString(int index,bool *found=NULL);

    void setIndexedElementValue(int index,double d);
    void setIndexedElementValue(int index,QString s);

    bool elementHasLabel(QString name,QString label,bool *found=NULL);

private:
    HDynTableElement& getElementByName(QString name);

    class HDynTableElementNameReferencer
    {
        private:
            HDynTable* ref;
            QString name;

            friend class HDynTable;
            HDynTableElementNameReferencer(HDynTable *ref,QString name)
            {   this->ref = ref;    this->name = name;   }
        public:
            HDynTableElementNameReferencer operator=(double value)
                    { ref->setElementValue(name,value); return *this; }
            HDynTableElementNameReferencer operator=(QString value)
                    { ref->setElementValue(name,value); return *this; }
            operator double()
                    { return ref->getElementValueDouble(name); }
            operator QString()
                    { return ref->getElementValueString(name); }

            HDynTableElementNameReferencer operator+=(double value)
                    { ref->setElementValue(name,ref->getElementValueDouble(name)+value); return *this; }
            HDynTableElementNameReferencer operator-=(double value)
                    { ref->setElementValue(name,ref->getElementValueDouble(name)-value); return *this; }
            HDynTableElementNameReferencer operator*=(double value)
                    { ref->setElementValue(name,ref->getElementValueDouble(name)*value); return *this; }
            HDynTableElementNameReferencer operator/=(double value)
                    { ref->setElementValue(name,ref->getElementValueDouble(name)/value); return *this; }
    };

public:

    HDynTableElementNameReferencer operator[](QString name) { return HDynTableElementNameReferencer(this,name); }

    HDynTable& operator=(HDynTable s);

signals:
    void dataChangedNongui(void);

};

class HDynTableSqlConnector : public HSqlHandler
{
    Q_OBJECT

public:
    bool tdisabled;
    QString errorText;

    HDynTableSqlConnector(HDynTable *dynt,QString tablename,QString filterpart="")
    {
        this->dynt       = dynt;
        this->tablename  = tablename;
        this->filterpart = filterpart;
        errorText =  "Error in HDynTableSqlConnector";
        tdisabled = false;
    }

    ~HDynTableSqlConnector(void)
    {
        this->dynt       = NULL;
        this->tablename  = "";
        this->filterpart = "";
    }

    void insertSql(QString additionaldefpart="",QString additionalvaluepart="");

    QString sqlCreateString(QString switches="");

public slots:
    int readSql(void);
    int updateSql(void);
signals:
    void justReaded(void);
    void justUpdated(void);

private:
    HDynTable *dynt;
    QString tablename;
    QString filterpart;

};

/* @} */
#endif

//End of gSAFE datalib.h