tahoma2d/toonz/sources/include/toonz/observer.h

#ifndef T_OBSERVER_INCLUDED
#define T_OBSERVER_INCLUDED

// OBSOLETO??

//=============================================================================
//
// TODO:
//
// separarlo in piu' file (almeno uno che contenga il solo TChangeObserver
// e che va incluso in frame.h; forse non e' necessario se tutti quelli che
// includono frame.h includono anche observer.h (probabile)
//
//=============================================================================

//#include "tlevel.h"
#include "tgeometry.h"
#include "tfilepath.h"
#include <set>

//=============================================================================

#undef DVAPI
#undef DVVAR
#ifdef TOONZLIB_EXPORTS
#define DVAPI DV_EXPORT_API
#define DVVAR DV_EXPORT_VAR
#else
#define DVAPI DV_IMPORT_API
#define DVVAR DV_IMPORT_VAR
#endif

//-------------------------------------------------------------------

namespace DagViewer
{
class Viewer;
}

//-------------------------------------------------------------------

class TChangeObserver
{
public:
	virtual ~TChangeObserver() {}
};

template <class T>
class TChangeObserverT
{
public:
	virtual ~TChangeObserverT() {}
	virtual void update(const T &) = 0;
};

//-------------------------------------------------------------------

class TObserverList
{
public:
	virtual ~TObserverList() {}
	virtual void attach(TChangeObserver *observer) = 0;
	virtual void detach(TChangeObserver *observer) = 0;
};

//-------------------------------------------------------------------

template <class T>
class TObserverListT : public TObserverList
{
	friend class TNotifier;

public:
	TObserverListT() {}
	~TObserverListT() {}
	typedef TChangeObserverT<T> Observer;

	void attach(TChangeObserver *observer)
	{
		if (Observer *o = dynamic_cast<Observer *>(observer))
			m_observers.push_back(o);
	}
	void detach(TChangeObserver *observer)
	{
		if (Observer *o = dynamic_cast<Observer *>(observer))
			m_observers.erase(
				std::remove(m_observers.begin(), m_observers.end(), o),
				m_observers.end());
	}
	void notify(const T &change)
	{
		std::vector<Observer *> observers(m_observers);
		for (typename std::vector<Observer *>::iterator it = observers.begin();
			 it != observers.end(); ++it)
			(*it)->update(change);
	}

private:
	std::vector<Observer *> m_observers;
};

//-------------------------------------------------------------------

class TFrameChange
{
public:
	int m_frame;
	int m_oldFrame;
	TFrameId m_fid;
	TFrameChange(int frame, int oldFrame)
		: m_frame(frame), m_oldFrame(oldFrame), m_fid(0) {}
	TFrameChange(const TFrameId &fid)
		: m_frame(-1), m_fid(fid) {}
};
typedef TChangeObserverT<TFrameChange> TFrameObserver;

//-------------------------------------------------------------------

class TColumnChange
{
public:
	int m_columnIndex;
	TColumnChange(int columnIndex)
		: m_columnIndex(columnIndex) {}
};
typedef TChangeObserverT<TColumnChange> TColumnObserver;

//-------------------------------------------------------------------

class TCurrentFxChange
{
public:
	TCurrentFxChange() {}
};
typedef TChangeObserverT<TCurrentFxChange> TCurrentFxObserver;

//-------------------------------------------------------------------

class TGlobalChange
{
	bool m_sceneChanged;

public:
	TGlobalChange(bool sceneChanged = false) : m_sceneChanged(sceneChanged) {}
	bool isSceneChanged() const { return m_sceneChanged; }
};
typedef TChangeObserverT<TGlobalChange> TGlobalObserver;

//-------------------------------------------------------------------

class TSceneNameChange
{
public:
	TSceneNameChange() {}
};
typedef TChangeObserverT<TSceneNameChange> TSceneNameObserver;

//-------------------------------------------------------------------

class TDirectoryChange
{
	TFilePath m_path;

public:
	TDirectoryChange(const TFilePath &path) : m_path(path) {}
	TFilePath getPath() const { return m_path; }
};
typedef TChangeObserverT<TDirectoryChange> TDirectoryObserver;

//-------------------------------------------------------------------

class TStageChange
{
public:
	TRectD m_rect;

	TStageChange() : m_rect(0, 0, 0, 0) {}
	TStageChange(const TRectD &rect) : m_rect(rect) {}
};

typedef TChangeObserverT<TStageChange> TStageObserver;

//-------------------------------------------------------------------

class TColumnHeadChange
{
public:
	int m_columnIndex;
	TColumnHeadChange() : m_columnIndex(-2) {}
	TColumnHeadChange(int index) : m_columnIndex(index) {}
};

typedef TChangeObserverT<TColumnHeadChange> TColumnHeadObserver;

//-------------------------------------------------------------------

class TXshLevel;

class TDrawingChange
{
public:
	TXshLevel *m_xl;
	TFrameId m_fid;
	bool m_wholeLevel;
	TDrawingChange(TXshLevel *xl, TFrameId fid) : m_xl(xl), m_fid(fid), m_wholeLevel(false) {}
	TDrawingChange(TXshLevel *xl) : m_xl(xl), m_wholeLevel(true) {}
	TDrawingChange() : m_xl(0), m_wholeLevel(true) {}
};

typedef TChangeObserverT<TDrawingChange> TDrawingObserver;

//-------------------------------------------------------------------

class TXsheetChange
{
public:
};

typedef TChangeObserverT<TXsheetChange> TXsheetObserver;

//-------------------------------------------------------------------

class TLevelChange
{
public:
	TLevelChange() {}
};

typedef TChangeObserverT<TLevelChange> TLevelObserver;

//-------------------------------------------------------------------

class TPatternStrokeStylesChange
{
public:
};

typedef TChangeObserverT<TPatternStrokeStylesChange> TPatternStrokeStyleObserver;

//-------------------------------------------------------------------

class TStageObjectChange
{
public:
	TStageObjectChange() {}
};

typedef TChangeObserverT<TStageObjectChange> TStageObjectObserver;

//-------------------------------------------------------------------

class TKeyFrameChange
{
public:
	TKeyFrameChange() {}
};

typedef TChangeObserverT<TKeyFrameChange> TKeyFrameObserver;

//-------------------------------------------------------------------

class TColorStyleChange
{
public:
	TColorStyleChange() {}
};

typedef TChangeObserverT<TColorStyleChange> TColorStyleObserver;

//-------------------------------------------------------------------

class TPaletteChange
{
	bool m_isCleanup;

public:
	TPaletteChange(bool isCleanup = false) : m_isCleanup(isCleanup) {}
	bool isCleanup() const { return m_isCleanup; }
};

typedef TChangeObserverT<TPaletteChange> TPaletteObserver;

//-------------------------------------------------------------------

class TToolChange
{
public:
	TToolChange() {}
};

typedef TChangeObserverT<TToolChange> TToolObserver;

//-------------------------------------------------------------------

class TCastChange
{
public:
	TCastChange() {}
};

typedef TChangeObserverT<TCastChange> TCastObserver;

//-------------------------------------------------------------------

class TDagViewerChange
{
	DagViewer::Viewer *m_viewer;

public:
	TDagViewerChange(DagViewer::Viewer *viewer) : m_viewer(viewer) {}
	const DagViewer::Viewer *getViewer() const { return m_viewer; }
};

typedef TChangeObserverT<TDagViewerChange> TDagViewerObserver;
//-------------------------------------------------------------------

class TFxDagChange
{
public:
	TFxDagChange() {}
};

typedef TChangeObserverT<TFxDagChange> TFxDagObserver;

//===================================================================

class DVAPI TNotifier
{
	vector<TObserverList *> m_obsList;
	TObserverListT<TGlobalChange> m_globalObs;
	TObserverListT<TSceneNameChange> m_sceneNameObs;
	TObserverListT<TDirectoryChange> m_directoryObs;
	TObserverListT<TStageChange> m_stageObs;
	TObserverListT<TColumnHeadChange> m_columnHeadObs;
	TObserverListT<TDrawingChange> m_drawingObs;
	TObserverListT<TLevelChange> m_levelObs;
	TObserverListT<TXsheetChange> m_xsheetObs;
	TObserverListT<TFrameChange> m_frameObs;
	TObserverListT<TCurrentFxChange> m_currentFxObs;
	TObserverListT<TStageObjectChange> m_stageObjectObs;
	TObserverListT<TPatternStrokeStylesChange>
		m_patternStrokeStylesObs;
	TObserverListT<TKeyFrameChange> m_keyFrameObs;
	TObserverListT<TColorStyleChange> m_colorStyleObs;
	TObserverListT<TPaletteChange> m_paletteObs;
	TObserverListT<TToolChange> m_toolObs;
	TObserverListT<TCastChange> m_castObs;

	TObserverListT<TDagViewerChange> m_dagViewerObs;
	TObserverListT<TFxDagChange> m_fxDagObs;

	bool m_dirtyFlag;

	std::set<TGlobalObserver *> m_newSceneNotifiedObs;

	TNotifier() : m_dirtyFlag(false)
	{
		m_obsList.push_back(&m_globalObs);
		m_obsList.push_back(&m_sceneNameObs);
		m_obsList.push_back(&m_directoryObs);
		m_obsList.push_back(&m_stageObs);
		m_obsList.push_back(&m_columnHeadObs);
		m_obsList.push_back(&m_drawingObs);
		m_obsList.push_back(&m_levelObs);
		m_obsList.push_back(&m_xsheetObs);
		m_obsList.push_back(&m_patternStrokeStylesObs);
		m_obsList.push_back(&m_frameObs);
		m_obsList.push_back(&m_stageObjectObs);
		m_obsList.push_back(&m_keyFrameObs);
		m_obsList.push_back(&m_colorStyleObs);
		m_obsList.push_back(&m_paletteObs);
		m_obsList.push_back(&m_toolObs);
		m_obsList.push_back(&m_castObs);
		m_obsList.push_back(&m_dagViewerObs);
		m_obsList.push_back(&m_currentFxObs);
		m_obsList.push_back(&m_fxDagObs);
	}

public:
	static TNotifier *instance();

	// void attach(TChangeObserver*observer);
	// void detach(TChangeObserver*observer);

	void notify(const TGlobalChange &c);

	void notify(const TStageChange &c) { m_stageObs.notify(c); }
	void notify(const TSceneNameChange &c) { m_sceneNameObs.notify(c); }
	void notify(const TDirectoryChange &c) { m_directoryObs.notify(c); }
	void notify(const TColumnHeadChange &c)
	{
		m_columnHeadObs.notify(c);
		m_dirtyFlag = true;
	}
	void notify(const TDrawingChange &c)
	{
		m_drawingObs.notify(c);
		m_dirtyFlag = true;
	}
	void notify(const TLevelChange &c)
	{
		m_levelObs.notify(c);
		m_dirtyFlag = true;
	}
	void notify(const TXsheetChange &c)
	{
		m_xsheetObs.notify(c);
		m_dirtyFlag = true;
	}
	void notify(const TPatternStrokeStylesChange &c)
	{
		m_patternStrokeStylesObs.notify(c);
	}
	void notify(const TFrameChange &c) { m_frameObs.notify(c); }
	void notify(const TCurrentFxChange &c) { m_currentFxObs.notify(c); }
	void notify(const TStageObjectChange &c) { m_stageObjectObs.notify(c); }
	void notify(const TKeyFrameChange &c)
	{
		m_keyFrameObs.notify(c);
		m_dirtyFlag = true;
	}
	void notify(const TColorStyleChange &c) { m_colorStyleObs.notify(c); }
	void notify(const TPaletteChange &c)
	{
		m_paletteObs.notify(c);
		m_dirtyFlag = true;
	}
	void notify(const TToolChange &c) { m_toolObs.notify(c); }
	void notify(const TCastChange &c) { m_castObs.notify(c); }

	void notify(const TDagViewerChange &c) { m_dagViewerObs.notify(c); }
	void notify(const TFxDagChange &c) { m_fxDagObs.notify(c); }

	bool getDirtyFlag() const { return m_dirtyFlag; }
	void setDirtyFlag(bool on) { m_dirtyFlag = on; }
};

//-------------------------------------------------------------------

#endif