guilib.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

    guilib.h
*/

#ifndef GSAFE__GUILIB_HEADER_FILE_X_
#define GSAFE__GUILIB_HEADER_FILE_X_

#include <QtCore>
#include <QtGui>

#ifndef COMPILED_WITH_QT4X
#include <QtWidgets>
#endif

#ifdef WEBKITBASED_HTMLSHOW
#ifndef COMPILED_WITH_QT4X
#include <QtWebKitWidgets>
#else
#include <QtWebKit>
#endif
#endif

#include "datalib.h"

/*  @{  */

#define EXT_EDIT_PROCESS    "externaledit.bat"

#define NEED_UPDATE 0
#define CLICK_ON_CELL 1

#define KEEP_ALL     0
#define FULL_CLEAN   1 
#define START_CLEAN  2 
#define END_CLEAN    3 


#define DONT_DELETE_DATA 0
#define DELETE_DATA      1 

class QLabel;
class QLineEdit;
class QComboBox;
class QTextEdit;
class QCheckBox;
class QDateEdit;
class QToolButton;
class QVBoxLayout;
class QHBoxLayout;
class QGridLayout;
class QPoint;
class QKeyEvent;

class HTableBrowserElement;

class HArrayButton : public QPushButton
{
    Q_OBJECT

    public:
        static int defaultSizeX,defaultSizeY;

        HArrayButton(QString text,QWidget *parent);
        ~HArrayButton(void);

        static QLayout * abc_filt(QWidget *parent,const QObject *receiver,const char *member);

    private slots:
        int clickHandler(void);

    signals:
        void clickedValue(QString text);
};

class HSpinBox : public QFrame
{
    Q_OBJECT

    public:
        HSpinBox(QWidget *parent);
        ~HSpinBox(void);

        void setMinValue(int v) { min = v; check(); }
        void setMaxValue(int v) { max = v; check(); }
        int value(void)         { return val; }

    public slots:
        int setValue(int v);

    protected:
        int val;
        int min,max;
        QString oldtext;

        QLineEdit *le;

    protected slots:
        void check(void);
        int  leChanged(const QString& t);
        int  bUp(void);
        int  bDown(void);

    protected:
        void wheelEvent(QWheelEvent *e);

    signals:
        void valueChanged(int);
};

/* NOT DOCUMENTED: Helper class of HTableBrowser. Do not use directly.
 * The HTableBrowser class uses this to qsort the elements. */
class HTableBrowserElementPair
{
    public:
        HTableBrowserElementPair(HTableBrowserElement *lp,HTableBrowserElement *rp)
            { left = lp; right = rp; }

        HTableBrowserElement *left;
        HTableBrowserElement *right;
};

class HTableBrowser : public QFrame
{
    Q_OBJECT

    public:
        HTableBrowser(QWidget *parent);
        ~HTableBrowser(void);

        void setColumnColor(int col,QColor c);

    public slots:

        void queryToStart(void);
        void queryToTop(void);     
        void queryToCurrent(void); 

    public:

        HTableBrowserElement *queryNextElement(void);
        QStringList          *queryNextValues(void);
        QString              *queryNextKey(void);

        int numberOfElements(void);

        HTableBrowserElement *elementByIndex(int n);
        QStringList          *valuesByIndex(int n);
        QString              *keyByIndex(int n);

        bool hasKey(QString key);

    public slots:

        int fulshDrawingCache(void);

        int clear();

        int addElement(HTableBrowserElement *e);

        int removeAllElementByKey(QString key);

        int setHeadTexts(QStringList h);

        int setCurrentElement(QString c,QString t="");

        int setCurrentElement(int index);

        int setTopElement(int index);

        void sort(int keycol);

        int  cursorToBegin(void);
        int  cursorToEnd(void);

    public:

        int mouseRightClickPosX;
        int mouseRightClickPosY;

        HTableBrowserElement * currentElement(void);
        QString                currentKey(void);
        HTableBrowserElement * topElement(void);
        QString                topKey(void);

        void setSpecSort(int col,QString specsortname);

        void setBackgroundColor(QColor c);
        void setCursorColor(QColor c) { color_cursor = c; }
        void setHeaderColor(QColor c) { color_header = c; }
        void setHeaderColorCursor(QColor c) { color_header_cursor = c; }

    //================================================================
    private:
        int limitCache(void);
        QLinkedList<HTableBrowserElement *> cachedElements;
        int cacheLimit;

    private:
        QColor color_cursor;
        QColor color_header;
        QColor color_header_cursor;
        QColor color_background;

        bool asc;
        bool asc2;
        int  keycolumn;
        int  keycolumn2;
        int sortmode;    // 0-normal 1-dropchar

        void q_sort    (void);
        void q_sort_run(HTableBrowserElementPair *p);
        bool ch(bool m,HTableBrowserElement *a,HTableBrowserElement *b);

        QStack<HTableBrowserElementPair *> *q_sort_stack;

        QString lastkey;

        int oldw,oldh,old_col_scroll;

        QMutex cacheMutex;

    protected:
        QString last_right_clicked;
        int number;
        int curc;
        HTableBrowserElement *start,*end,*top,*cur,*query_cursor;
        int col_scroll;

        static bool    staticinit;
        static QPixmap *pix_up;
        static QPixmap *pix_down;
        static QPixmap *pix_asc;
        static QPixmap *pix_desc;
        static QPixmap *pix_asc2;
        static QPixmap *pix_desc2;

        QFontMetrics      *fm;
        QList<int>         colw;
        QList<QColor>      colc;
        QList<QString>     spec_sort;
        QStringList        head;
        int                rowh;
        int                plusw;
        int                showrow;
        QString            seek;
        bool               inscroll;

        QMap<int,QColor>   precolor;

    protected:
        bool stepUp(void);
        bool stepDown(void);
        bool mouseNetClick(QMouseEvent *e,int rmode = NEED_UPDATE);

    protected:
        void paintEvent(QPaintEvent *e);
        void keyPressEvent(QKeyEvent *e);
        void mousePressEvent(QMouseEvent *e);
        void mouseReleaseEvent(QMouseEvent *e);
        void mouseDoubleClickEvent(QMouseEvent *e);
        void mouseMoveEvent(QMouseEvent *e);
        void wheelEvent(QWheelEvent *e);
        void resizeEvent(QResizeEvent *e);

    signals:
        void activateItem(const QString& s);
        void alternateActivateItem(const QString& s);
        void itemChanged(const QString& s);
};

class HTableBrowserElement
{
    public:
        int index; 
        QString key; 
        QStringList *rows; 

        bool owncolor; 
        int ocr,ocg,ocb; 

        QPixmap *cachePixmap;

    public:
        HTableBrowserElement(QString k,QStringList *c);

        HTableBrowserElement(QString k,QString v1,QString v2="",QString v3="",QString v4="",QString v5="",
                             QString v6="",QString v7="",QString v8="",QString v9="");
        ~HTableBrowserElement(void);

        QString operator[](int i);
        QString getCVal(int i) { return (*rows)[i]; }

        HTableBrowserElement * setColor(int r,int g,int b);
        HTableBrowserElement * clearColor(void);

        int size(void);

        void swapWith(HTableBrowserElement *x);

        HTableBrowserElement& operator=(HTableBrowserElement& e);
        HTableBrowserElement& operator=(HTableBrowserElement* e);

    public:
        HTableBrowserElement *next; 
        HTableBrowserElement *prev; 
};

class HDispPlainDataMatrix : public QFrame
{
    Q_OBJECT

    protected:
        QString genhtml_parameters;
        HPlainDataMatrix  *data;
        HTableBrowser     *list;
        int deletedata;     

    public:
        HDispPlainDataMatrix(QWidget *parent,HBase *d,bool htmlmode=false,int keyfield=-1,int ddata=DONT_DELETE_DATA);
        ~HDispPlainDataMatrix(void);

    public:
        void setGenHtmlParameters(QString p) { genhtml_parameters = p; }

        void setColumnColor(int col,QColor color) { list->setColumnColor(col,color); }

    public slots:
        int dialogPrint(void);
        int dialogXml(void);
        int dialogHtmlShow(void);

        int slotActivateItem(const QString k);
        int itemAlternateActivated(const QString& s);

    signals:
        void activateItem(QString k);
};

class HPlainDMD : public QDialog
{
    Q_OBJECT

    private:
        HDispPlainDataMatrix * dpdm;
    public:
        HPlainDMD(QWidget *parent,HBase *d,bool htmlmode=false);
        ~HPlainDMD(void);

        HDispPlainDataMatrix *getHDispPlainDataMatrix(void) { return dpdm; }

};

class HDispTable : public QFrame
{
    Q_OBJECT

    protected:

        bool ro_mask;       
        int datamode;       
        int deletedata;     
        HTable *data;       
        QVBoxLayout *layout;

    public:
        HDispTable(QWidget *parent,HTable *d,int datamodep = FULL_CLEAN,int ddata=DONT_DELETE_DATA);
        ~HDispTable(void);

        HTable *getDataClass(void) { return data;};

    public slots:

        int updateDisplay(void);

        int dialogPrint(void);
        int dialogXml(void);

        int addStretchToEnd(void);

    signals:
        void updateDisplaySignal(void);
};

class HDispList : public QFrame
{
    Q_OBJECT

    protected:
        int datamode;   
        int deletedata; 
        HList  *data;   
        HTableBrowser *list; 

    public:
        HDispList(QWidget *parent,HList *d,int datamodep = FULL_CLEAN,int ddata=DONT_DELETE_DATA);
        ~HDispList(void);

        HList *getDataClass(void) { return data;}
        HTableBrowser *getBrowserObjectClass(void) { return list; }

    public slots:

        int updateDisplay(void);

        int dialogPrint(void);
        int dialogXml(void);

        int toBegin() { list->cursorToBegin(); return updateDisplay(); }
        int toEnd()   { list->cursorToEnd();   return updateDisplay(); }

        int sortByColumn(int col);

        int itemActivated(const QString& s);
        int itemAlternateActivated(const QString& s);
        int litemChanged(const QString& s);

    signals:
        void listItemChanged(void);

    protected:
        void keyPressEvent(QKeyEvent *e);

};

// ///////////////////////////////////////////////////////////////////////////////
// / data fields /////////////////////////////////////////////////////////////////
// ///////////////////////////////////////////////////////////////////////////////

class HDispDataField : public QFrame
{
    Q_OBJECT

    protected:
        HDataField *data;
        bool ro_mask;
        bool tbool;

        QHBoxLayout *sublayout;
    public:
        static QHBoxLayout *static_sublayout;

    public:
        HDispDataField(QWidget *parent,HDataField *d,bool _ro_mask=false);
        ~HDispDataField(void);

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

    public slots:
        int updateDisplaySlot(void);
        int timedUpdateSlot(void);

    public slots:
        int enableControlSlot(void) { enableControl(); return 0; }
        int disableControlSlot(void) { disableControl(); return 0; }

    protected:
        void paintEvent(QPaintEvent *e);

    private:
        int  blink;

};

class HDispKey : public HDispDataField
{
    Q_OBJECT

    protected:
        QLabel *explain,*key;

    public:
        HDispKey(QWidget *parent,HDataField *d,bool _ro_mask=false);
        ~HDispKey(void);

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

    public slots:
        int updateDisplaySlot(void);
        int updateStaticGuiElementsSlot(void);

};

class HDispSmallText : public HDispDataField
{
    Q_OBJECT

    protected:
        QLabel    *explain;
        QLineEdit *edtext;
        QLabel    *nedtext;
        QLabel    *tailtext;

    public:
        HDispSmallText(QWidget *parent,HDataField *d,bool _ro_mask=false);
        ~HDispSmallText(void);

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

    public slots:
        int textUpdate(const QString& n);
        int updateDisplaySlot(void);
        int updateStaticGuiElementsSlot(void);
};

class HDispLargeText : public HDispDataField
{
    Q_OBJECT

    protected:
        QLabel          *explain;
        QTextEdit       *edtext;
        QTextEdit       *nedtext;
    public:
        HDispLargeText(QWidget *parent,HDataField *d,bool _ro_mask=false);
        ~HDispLargeText(void);

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

    public slots:
        int textUpdate(void);
        int updateDisplaySlot(void);
        int updateStaticGuiElementsSlot(void);
};

class HDispCharHash : public HDispDataField
{
    Q_OBJECT

    protected:
        QLabel    *explain;
        QComboBox *edval;
        QLabel    *nedtext;
        QLabel    *tailtext;
    public:
        HDispCharHash(QWidget *parent,HDataField *d,bool _ro_mask=false);
        ~HDispCharHash(void);

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

    public slots:
        int itemSelected(int index);
        int updateDisplaySlot(void);
        int updateStaticGuiElementsSlot(void);
};

class HDispNumHash : public HDispDataField
{
    Q_OBJECT

    protected:
        QLabel    *explain;
        QComboBox *edval;
        QLabel    *nedtext;
        QLabel    *tailtext;
    public:
        HDispNumHash(QWidget *parent,HDataField *d,bool _ro_mask=false);
        ~HDispNumHash(void);

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

    public slots:
        int itemSelected(int index);
        int updateDisplaySlot(void);
        int updateStaticGuiElementsSlot(void);
};

class HDispNumber : public HDispDataField
{
    Q_OBJECT

    protected:
        QLabel    *explain;
        HSpinBox  *edval;
        QLabel    *nedtext;
        QLabel    *tailtext;
    public:
        HDispNumber(QWidget *parent,HDataField *d,bool _ro_mask=false);
        ~HDispNumber(void);

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

    public slots:
        int valueUpdate(int value);
        int updateDisplaySlot(void);
        int updateStaticGuiElementsSlot(void);
};

class HDispStatic : public HDispDataField
{
    Q_OBJECT

    protected:
        QLabel    *explain;
        QLabel    *nedtext;
    public:
        HDispStatic(QWidget *parent,HDataField *d,bool _ro_mask=false);
        ~HDispStatic(void);

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

    public slots:
        int updateDisplaySlot(void);
        int updateStaticGuiElementsSlot(void);
};

class HDispCheck : public HDispDataField
{
    Q_OBJECT

    protected:
        QLabel *explain;
        QCheckBox *edval;
        QLabel    *nedtext;

    public:
        HDispCheck(QWidget *parent,HDataField *d,bool _ro_mask=false);
        ~HDispCheck(void);

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

    public slots:
        int valueUpdate(void);
        int updateDisplaySlot(void);
        int updateStaticGuiElementsSlot(void);
};

class HDispFloating : public HDispDataField
{
    Q_OBJECT

    protected:
        QLabel    *explain;
        QLineEdit *edtext;
        QLabel    *nedtext;
        QLabel    *tailtext;

    public:
        HDispFloating(QWidget *parent,HDataField *d,bool _ro_mask=false);
        ~HDispFloating(void);

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

    public slots:
        int textUpdate(const QString& n);
        int updateDisplaySlot(void);
        int updateStaticGuiElementsSlot(void);
};

class HDispDate : public HDispDataField
{
    Q_OBJECT

    protected:
        QLabel *explain;
        QDateEdit *edval;
        QCheckBox *unk;
        QLabel  *nedtext;

    public:
        HDispDate(QWidget *parent,HDataField *d,bool _ro_mask=false);
        ~HDispDate(void);

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

    public slots:
        int valueUnkUpdate(void);
        int valueUpdate(const QDate& d);
        int updateDisplaySlot(void);
        int updateStaticGuiElementsSlot(void);
};

class HDispTimestamp : public HDispDataField
{
    Q_OBJECT

    protected:
        QLabel    *explain;
        QLabel    *nedtext;

    public:
        HDispTimestamp(QWidget *parent,HDataField *d,bool _ro_mask=false);
        ~HDispTimestamp(void);

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


    public slots:
        int updateDisplaySlot(void);
        int updateStaticGuiElementsSlot(void);
};

class SqlChooseDialog;
class HDispSqlChoose : public HDispDataField
{
    Q_OBJECT

    protected:
        QLabel    *explain;
        QComboBox *edval;
        QLabel    *nedtext;
        QToolButton *rfbutt;
        QPushButton *pbutt;

        SqlChooseDialog *pupup_dialog;

    public:
        HDispSqlChoose(QWidget *parent,HDataField *d,bool _ro_mask=false);
        ~HDispSqlChoose(void);

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

        void setToolbarbuttonSignalOn(QString text);
        void setToolbarbuttonSignalOff();

        HSqlChoose *getHSqlChoose(void) { return ((HSqlChoose *)data); }

    public slots:
        int itemSelected(int index);
        int refresh(void);
        int updateDisplaySlot(void);
        int updateStaticGuiElementsSlot(void);

        int popupSelector(void);
        int itemSelected(const QString& s);


};

/* NOT DOCUMENTED: This is not a disp field class. This class is part of the HDispSqlChoose.
 *  If the HSqlChoose in disabled easy mode, (popup selection) this class will be the popup selection dialog.
 *  It connects to the slot of HDispSqlChoose and notify the selected record this way. */
class SqlChooseDialog : public QDialog
{
    Q_OBJECT

    private:
        QString popupped_key;

    public:
        SqlChooseDialog( HDispSqlChoose* p);
        ~SqlChooseDialog();

        HTableBrowser* table;
        QPushButton* button;
        bool disabled_recvkey;
        bool key_received;
        QString received_key;

    protected:
        HDispSqlChoose* parent;

        QVBoxLayout* SqlChooseDialogLayout;
        QHBoxLayout* layout1;

        bool have_extra_func;

    public slots:
        int nullButtonPressed(void);
        int buttonPressed(void);
        int listviewitemSelected(const QString& s);
        int updateList(void);

        /*  This slot is called when the plus toolbarbutton is pushed. (See HSqlChoose::addToolButton())
         *  This slot is emits the callToolButtonHandler signal (down here) which is can be connected to the handler slot
         *  which do the effective work. (That external work which defined by you in HSqlChoose::addToolButton() ) \n
         *  This event chain is designed because of this class need a meta-data refresh after you do the external work.
         *  That slot (which you define) can change the list of values, so the list need to be updated before the user select an item. \n
         *  That's why I need a passing middle slot to grab the event when the external work finishes.
         *  If I would directly connect to the toolbutton signal, the class could not refresh the values in the necessary time */
        int toolbarButtonClicked(void);

        int receivedASelectedKey(QString key);

        int popUpMenuActivated(const QString& key);

        /*  The extra popup menu activates this slots.
         *  Because the popup menu only can call slots without key,
         *  this slots are emits the sigToExtraFunc signals (down here) which can pass the selected key values too.
         *  That signals are connected with the target slots. */
        int popup_catch_0(void);
        int popup_catch_1(void);
        int popup_catch_2(void);
        int popup_catch_3(void);
        int popup_catch_4(void);

        int captureNotify(QString tblname);

    signals:
        void callToolButtonHandler(void);
        void itemSelected(const QString& s);    //this connected to the parents

        void sigToExtraFunc_0(QString key);
        void sigToExtraFunc_1(QString key);
        void sigToExtraFunc_2(QString key);
        void sigToExtraFunc_3(QString key);
        void sigToExtraFunc_4(QString key);
};


class HShowPrintHtml : public QDialog
{
    Q_OBJECT

private:
    QString html;

#ifdef WEBKITBASED_HTMLSHOW
    QWebView *te;
#else
    QTextEdit *te;
#endif

public:
    HShowPrintHtml(QWidget *parent);
    ~HShowPrintHtml(void);

public:
    void setContent(QString str);
    void setWinTitle(QString t);

public slots:
    void slotPrint(void);
    void slotStart(void);
    void slotSave(void);
};

// ///////////////////////////////////////////////////////////////////////////////////////////
// // OTHER CLASSES //////////////////////////////////////////////////////////////////////////
// ///////////////////////////////////////////////////////////////////////////////////////////

class HPleaseWaitWindow : public QWidget
 {
  Q_OBJECT

  private:
    int sizex,sizey;
    int lastx,lasty;
    int seq;
    int refreshTime;

    HPleaseWaitWindow(int sizex_=80,int sizey_=80,int refreshTime_=80);
    ~HPleaseWaitWindow();

  public slots:
    void progress(void);

  protected:

    QTime t;
    void mouseMoveEvent(QMouseEvent *me);
    void mousePressEvent(QMouseEvent *me);

    void paintEvent(QPaintEvent *pe);

  public:
      static HPleaseWaitWindow *pww;

      static HPleaseWaitWindow * start(void);
      static void                step (void);
      static void                end  (void);
 };


class HDecorDialog : public QDialog
{
    Q_OBJECT

    public:
        HDecorDialog(QWidget *parent,QString title,int no_action_closetime);

    public:
        void setTitleFont(QFont f);
        bool anywhere_click_close;
        bool dont_reset_timer;

        QColor bgcolor;
        int framewidth;
        QColor frcolor;
        int titleheight;
        int closerwidth;
        QColor titlecolor;
        QColor indcolor;
        int crossthick;
        int crossmargin;

    private slots:
        int incr_t(void);

    protected:
        void paintEvent(QPaintEvent *pe);

        void mousePressEvent(QMouseEvent *e);
        void mouseMoveEvent(QMouseEvent *e);
        void keyPressEvent(QKeyEvent *e);

    private:
        QFont  titlefont;
        QString title;
        int no_action_closetime;
        int end_t;
        int t_t;
        int t_time;
};


class HPressButtonSizeSyncronizer;
class HPressButton : public QFrame
{
    Q_OBJECT

    public:
        HPressButton(QWidget *parent,QString text,QString code="");
        ~HPressButton(void);

        void setColor(int red,int green,int blue);
        void setEffect(int effectwidth);
        void setMargin(int margin);
        void setTextPointSize(int size);

    private:
        bool enablestat;
        bool hidestat;
        int cmargin;
        int c3deffect;

        QFont font;
        bool willmid;
        bool mid;
        bool down;
        QString textstr,idstr;

        int r,rd,g,gd,b,bd;

        void calcSize();
        //static int mx,my;
        HPressButtonSizeSyncronizer* size_sync;
    public:

        static HPressButtonSizeSyncronizer* createSizeSyncronizer(void);

        HPressButtonSizeSyncronizer* getSizeSyncronizer(void)    { return size_sync; }
        void setSizeSyncronizer(HPressButtonSizeSyncronizer* ss) { size_sync = ss;   }

    public slots:
        int recalcSize();
        int setHide();
        int setShow();
        int setEnabled(bool enable);

    protected:
        void paintEvent(QPaintEvent *e);

        void keyPressEvent(QKeyEvent *e);
        void keyReleaseEvent(QKeyEvent *e);

        void mousePressEvent(QMouseEvent *e);
        void mouseReleaseEvent(QMouseEvent *e);
        void mouseMoveEvent(QMouseEvent *e);

    signals:
        void clicked(void);
        void clickedCode(QString code);
};

class HPressButtonSizeSyncronizer
{
    private:
        HPressButtonSizeSyncronizer()
        {
            mx = 0;
            my = 0;
        }

    private:
        int mx,my;
    friend class HPressButton;
};

class HDynTableDispConnector : public QObject
{
    Q_OBJECT

public:
    HDynTableDispConnector(HDynTable *dynt,QTableWidget *qtw);
    ~HDynTableDispConnector(void);

private:
    typedef struct
    {
        QString name;
        int r,c;
        QTableWidgetItem *glink;
    } cellData;

    HDynTable *dynt;
    QList<cellData> cells;
    bool ccprogress;
    bool rfprogress;

public slots:
    int refreshGui(void);
    int slotCellChanged(int row,int column);

signals:
    void dataChangedByGui(void);

};

/* @} */

#endif