gui.h

#ifndef GUI_HEADER_
#define GUI_HEADER_

#include "headers.h"

#include <QAction>
#include <QApplication>
#include <QComboBox>
#include <QDialogButtonBox>
#include <QDoubleSpinBox>
#include <QFileDialog>
#include <QFileInfo>
#include <QGridLayout>
#include <QGroupBox>
#include <QLabel>
#include <QMainWindow>
#include <QMenu>
#include <QMenuBar>
#include <QMessageBox>
#include <QMouseEvent>
#include <QProgressDialog>
#include <QScrollArea>
#include <QScrollBar>
#include <QSpinBox>
#include <QStatusBar>
#include <QThread>
#include <QTime>
#include <QTimer>
#include <QTranslator>
#include <QTreeWidgetItem>

class ImageViewer;
class SettingsDialog;
class EncodingProgress;

class ImageViewer: public QMainWindow { Q_OBJECT
    friend class SettingsDialog;
    friend class EncodingProgress;
    
    static const int AutoIterationCount= 10;

    IRoot *modules_settings 
    , *modules_encoding;    
    int zoom;               
    std::string encData;    

    QTranslator &translator;
    QLabel *imageLabel;     
    
    QDir lastPath;
    QAction
        readAct, writeAct, compareAct, exitAct,
        settingsAct, encodeAct, saveAct,
        loadAct, clearAct, iterateAct, zoomIncAct, zoomDecAct,
        loadLangAct, useLangAct;
        //aboutAct, aboutQtAct;

    QMenu imageMenu, compMenu, decompMenu, langMenu;//, helpMenu;
    void createActions();   
    void createMenus();     
    void translateUi();     
    void updateActions();   
    void changePixmap(const QPixmap &pixmap) {
        imageLabel->setPixmap(pixmap);
        imageLabel->resize( pixmap.size() );
    }                       
private slots:
    void read();
    void write();
    void compare();
    void settings();
    void encode();
    void save();
    void load();
    void clear();
    void iterate();
    void zoomInc();
    void zoomDec();
    void loadLang();
    void useLang(bool use);
    //void about();
    //void aboutQt();
    void encDone();
public:
    ImageViewer(QApplication &app,QTranslator &trans);
    virtual ~ImageViewer()
        { delete modules_settings; delete modules_encoding; }
private:
    bool rezoom();
    QString lastDir() 
        { QDir dir(lastPath); return dir.cdUp() ? dir.path() : QDir::currentPath(); }
#ifndef NDEBUG
    void mousePressEvent(QMouseEvent *event);
#endif
};

inline void aConnect( const QObject *sender, const char *signal, const QObject *receiver
, const char *slot, Qt::ConnectionType type=Qt::AutoCompatConnection ) {
    DEBUG_ONLY( bool result= )
        QObject::connect(sender,signal,receiver,slot,type);
    ASSERT(result);
}

class SettingsDialog: public QDialog { Q_OBJECT
    QGroupBox *setBox;                  
    QTreeWidget *treeWidget;            
    QDialogButtonBox *loadSaveButtons;  
    IRoot *settings;                    
    
    ImageViewer& parentViewer() { 
        ImageViewer *result= debugCast<ImageViewer*>(parent()); 
        ASSERT(result); 
        return *result; 
    }
    void initialize();
private slots:
    void currentItemChanged(QTreeWidgetItem *current,QTreeWidgetItem *previous);
    void settingChanges(int which);
    void loadSaveClick(QAbstractButton *button);
public:
    SettingsDialog(ImageViewer *parent,IRoot *settingsHolder);
    IRoot* getSettings() { return settings; }
};

class SignalChanger: public QObject { Q_OBJECT
    int signal;
public:
    SignalChanger( int whichSignal, QWidget *parent=0, Module::ChoiceType type=Module::Stop )
    : QObject(parent), signal(whichSignal) {
        if (!parent)
            return;
    //  connect widget's changing signal to my notifyXxx slot
        const char *signalString=0, *slotString=0;
        switch (type) {
            case Module::Int:
            case Module::IntLog2:
                signalString= SIGNAL(valueChanged(int));
                slotString= SLOT(notifyInt(int));
                break;
            case Module::Float:
                signalString= SIGNAL(valueChanged(double));
                slotString= SLOT(notifyDouble(double));
                break;
            case Module::ModuleCombo:
            case Module::Combo:
                signalString= SIGNAL(currentIndexChanged(int));
                slotString= SLOT(notifyInt(int));
                break;
            default:
                ASSERT(false);
        }// switch
        aConnect( parent, signalString, this, slotString );
    }
public slots:
    void notifyInt(int)         { emit notify(signal); }
    void notifyDouble(double)   { emit notify(signal); }
signals:
    void notify(int);
}; // SignalChanger class



class EncodingProgress: public QProgressDialog { Q_OBJECT
    class EncThread: public QThread { //Q_OBJECT
        IRoot *root;
        QImage image;
        bool success;
        UpdateInfo updateInfo;
    public:
        EncThread(IRoot *root_,const QImage &image_,const UpdateInfo &updateInfo_)
        : root(root_), image(image_), updateInfo(updateInfo_) {}
        virtual void run()
            { success= root->encode(image,updateInfo); }
        bool getSuccess() const
            { return success; }
    }; // EncThread class
    
    static EncodingProgress *instance; 

    bool terminate  
    , updateMaxProgress
    , updateProgress;
    int progress    
    , maxProgress;  
    
    IRoot *modules_encoding;
    UpdateInfo updateInfo;  
    
    QTimer updateTimer;     
    QTime encTime;          
    EncThread encThread;    

private:
    static void incMaxProgress(int increment) { 
        instance->maxProgress+= increment;
        instance->updateMaxProgress= true;
    }
    static void incProgress(int increment) { 
        instance->progress+= increment;
            //< a race can occur, but only affects progress display
        instance->updateProgress= true;
    }

private slots:
    void setTerminate()         
        { terminate= true; }
    void update() {
        if (updateMaxProgress) {
            setMaximum(maxProgress);
            updateMaxProgress= false;
        }
        if (updateProgress) {
            setValue(progress);
            updateProgress= false;
        }
    }
private:
    EncodingProgress(ImageViewer *parent)
    : QProgressDialog( tr("Encoding..."), tr("Cancel"), 0, 100, parent, Qt::Dialog )
    , terminate(false), updateMaxProgress(false), updateProgress(false)
    , progress(0), maxProgress(0)
    , modules_encoding(parent->modules_settings->clone())
    , updateInfo( terminate, &incMaxProgress, &incProgress ), updateTimer(this)
    , encThread( modules_encoding, parent->imageLabel->pixmap()->toImage(), updateInfo ) {
        ASSERT(!instance);
        instance= this;
    //  set some dialog features
        setWindowModality(Qt::ApplicationModal);
        setAutoClose(false);
        setAutoReset(false);
    //  to switch to terminating status when cancel is clicked
        aConnect( this, SIGNAL(canceled()), this, SLOT(setTerminate()) );
    //  start the updating timer
        aConnect( &updateTimer, SIGNAL(timeout()), this, SLOT(update()) );
        updateTimer.start(1000);
        encTime.start(); // start measuring the time
    //  start the encoding thread, set it to call ImageViewer::encDone when finished    
        aConnect( &encThread, SIGNAL(finished()), parent, SLOT(encDone()) );
        encThread.start(QThread::LowPriority);
    }
    ~EncodingProgress() {
        ASSERT(this==instance);
        instance= 0;
    }
public:
    static void create(ImageViewer *parent) {
        new EncodingProgress(parent);
    }
    static IRoot* destroy(int &elapsed) {
        ASSERT( instance && instance->encThread.isFinished() );
    //  get the encoding result if successful, delete it otherwise
        IRoot *result= instance->modules_encoding;
        if ( !instance->encThread.getSuccess() ) {
            delete result;
            result= 0;
        }
        elapsed= instance->encTime.elapsed();
    //  delete the dialog
        delete instance;
        return result;
    }
}; // EncodingProgress class

#endif // GUI_HEADER_

---