observable.h

/*
 For general Scribus (>=1.3.2) copyright and licensing information please refer
 to the COPYING file provided with the program. Following this notice may exist
 a copyright and/or license notice that predates the release of Scribus 1.3.2
 for which a new license (GPL+exception) is in place.
 */
/***************************************************************************
*                                                                         *
*   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; either version 2 of the License, or     *
*   (at your option) any later version.                                   *
*                                                                         *
***************************************************************************/

#ifndef OBSERVABLE_H
#define OBSERVABLE_H

#include "scribusapi.h"

#include <QObject>
#include <QSet>
#include <QVariant>

#include "updatemanager.h"


//#include "observable_private.h"
struct SCRIBUS_API Private_Signal : public QObject 
{
    Q_OBJECT;
    
public:
    void emitSignal(QObject* what)
{
        emit changedObject(what);
}

void emitSignal(QVariant what)
{
    emit changedData(what);
}

bool connectSignal(QObject*, QObject* o, const char* slot)
{
    return QObject::connect(this, SIGNAL(changedObject(QObject*)), o, slot);
}

bool disconnectSignal(QObject*, QObject* o, const char* slot)
{
    return QObject::disconnect(this, SIGNAL(changedObject(QObject*)), o, slot);
}

bool connectSignal(QVariant, QObject* o, const char* slot)
{
    return QObject::connect(this, SIGNAL(changedData(QVariant)), o, slot);
}

bool disconnectSignal(QVariant, QObject* o, const char* slot)
{
    return QObject::disconnect(this, SIGNAL(changedData(QVariant)), o, slot);
}

signals:
void changedObject(QObject* what);
void changedData(QVariant what);
};



template<class OBSERVED>
struct Private_Memento : public UpdateMemento
{
    Private_Memento(OBSERVED data) : m_data(data), m_layout(false) {};
    Private_Memento(OBSERVED data, bool layout) : m_data(data), m_layout(layout) {};
    
    OBSERVED m_data;
    bool     m_layout;
};



template<class OBSERVED>
class SCRIBUS_API Observer {
public:
    virtual void changed(OBSERVED, bool doLayout) = 0;
    virtual ~Observer() {}
};




template<class OBSERVED>
class MassObservable : public UpdateManaged 
{   
    friend class UpdateManager;
    
public:
    MassObservable(UpdateManager* um = NULL);
    virtual ~MassObservable();
    void setUpdateManager(UpdateManager* um);
    
    virtual void update(OBSERVED what);

    virtual void updateLayout(OBSERVED what);
    
    void connectObserver(Observer<OBSERVED>* o);
    void disconnectObserver(Observer<OBSERVED>* o);
    
    bool connectObserver(QObject* o, const char* slot);
    bool disconnectObserver(QObject* o, const char* slot = 0);
    
protected:
    virtual void updateNow(UpdateMemento* what);

    QSet<Observer<OBSERVED>*> m_observers;
    Private_Signal* changedSignal;
    UpdateManager* m_um;
};




template<class OBSERVED>
class SCRIBUS_API SingleObservable
{
public:
    SingleObservable(MassObservable<OBSERVED*> * massObservable) : m_massObservable(massObservable) 
    {};
    
    virtual ~SingleObservable() 
    {};
    
    void setMassObservable(MassObservable<OBSERVED*> * massObservable) 
    {
        m_massObservable = massObservable;
    }
    
    virtual void update() 
    { 
        m_massObservable->update(dynamic_cast<OBSERVED*>(this)); 
    }

    virtual void updateLayout() 
    { 
        m_massObservable->updateLayout(dynamic_cast<OBSERVED*>(this)); 
    }
    
private:
    MassObservable<OBSERVED*>* m_massObservable;
};





template<class OBSERVED>
class SCRIBUS_API Observable : public MassObservable<OBSERVED*> 
{   
public:
    Observable(UpdateManager* um = NULL) : MassObservable<OBSERVED*>(um) 
    {};
    
    virtual void update() 
    { 
        MassObservable<OBSERVED*>::update(dynamic_cast<OBSERVED*>(this)); 
    }
private:
    using MassObservable<OBSERVED*>::update;
};



// IMPLEMENTATION



template<class OBSERVED>
inline MassObservable<OBSERVED>::MassObservable(UpdateManager* um) : m_observers(), changedSignal(new Private_Signal()), m_um(um)
{
}

template<class OBSERVED>
inline MassObservable<OBSERVED>::~MassObservable()
{
    m_observers.clear();
    delete changedSignal;
}


template<class OBSERVED>
inline void MassObservable<OBSERVED>::setUpdateManager(UpdateManager* um)
{
    m_um = um;
}


template<class OBSERVED>
inline void MassObservable<OBSERVED>::update(OBSERVED what)
{
    Private_Memento<OBSERVED>* memento = new Private_Memento<OBSERVED>(what);
    if (m_um == NULL || m_um->requestUpdate(this, memento))
    {
        updateNow(memento);
    }
}

template<class OBSERVED>
inline void MassObservable<OBSERVED>::updateLayout(OBSERVED what)
{
    Private_Memento<OBSERVED>* memento = new Private_Memento<OBSERVED>(what, true);
    if (m_um == NULL || m_um->requestUpdate(this, memento))
    {
        updateNow(memento);
    }
}

template<class OBSERVED>
inline void MassObservable<OBSERVED>::updateNow(UpdateMemento* what)
{
    Private_Memento<OBSERVED>* memento = dynamic_cast<Private_Memento<OBSERVED>*>(what);
    foreach (Observer<OBSERVED>* obs, m_observers)
    {
        obs->changed(memento->m_data, memento->m_layout);
    }
    changedSignal->emitSignal(QVariant::fromValue(memento->m_data));
    delete memento;
}


template<class OBSERVED>
inline void MassObservable<OBSERVED>::connectObserver(Observer<OBSERVED>* o)
{
    m_observers.insert(o);
}

template<class OBSERVED>
inline void MassObservable<OBSERVED>::disconnectObserver(Observer<OBSERVED>* o)
{
    m_observers.remove(o);
}


template <typename T>
inline void Private_Init(T& dummy) {}

template <>
inline void Private_Init(QObject*& dummy) 
{ 
//  dummy->die_compiler_die(); 
    dummy = 0;
}


template<class OBSERVED>
inline bool MassObservable<OBSERVED>::connectObserver(QObject* o, const char* slot)
{
    OBSERVED dummy;
    Private_Init(dummy);
    return changedSignal->connectSignal(QVariant::fromValue(dummy), o, slot);
}

template<class OBSERVED>
inline bool MassObservable<OBSERVED>::disconnectObserver(QObject* o, const char* slot)
{
    OBSERVED dummy;
    Private_Init(dummy);
    return changedSignal->disconnectSignal(QVariant::fromValue(dummy), o, slot);
}


#endif