CODE:

//Object displaying something.
//Each concrete-type object may handle some part of the entire view, therefore the view may consist of a group of IDispItem.
class IDispItem
{
public:
	virtual ~IDispItem(){}
public:
	//Returns true if this object has been finished its work.
	//If this method returns true, it means that callers of this object's paint() method should stop making further calls.
	//
	//The value returned by this method should only change due to the execution of Update() :
	//if this method returns X at some time, this method must returns X until the next update() call.
	virtual bool Finished() const = 0;

	//Returns whether need to redraw or not : In other words, returning true indicates that Paint() should be called.
	//So this method must return true if some data to show are changed.
	virtual bool Update() = 0;

	//If this method is called under the state that finished() returning true, the behavior of this method is undefined.
	virtual void Paint( /*XXX*/ ) const = 0;
};

CODE:

//Observer pattern implementation.
class Notifier
{
public:
	class INotified
	{
	public:
		virtual ~INotified(){}
	public:
		//Returns whether need to unregister or not.
		//if true, this object will be unregistered from the Notifier.
		virtual bool OnNotify() = 0;
	};

public:
	Notifier(){}
	Notifier( const Notifier & ) = delete;
	Notifier &operator=( const Notifier & ) = delete;

	//Note : invalid usage such as null or duplication don't be checked.
	void Register( std::weak_ptr<INotified> pObserver ){	m_Observers.push_back(pObserver);	}

	void Clear(){	m_Observers.clear();	}
	bool Empty() const {	return m_Observers.empty();	}

	void Notify()
	{
		for( auto iter=m_Observers.begin(); iter!=m_Observers.end(); /*NOP*/ )
		{
			auto sp = iter->lock();
			if( !sp  ||  sp->OnNotify() )
			{	iter = m_Observers.erase( iter );	}
			else
			{	++iter;	}
		}
	}
private:
	std::list< std::weak_ptr<INotified> > m_Observers;
};

CODE:

//The "caller" for a IDispItem sequence.
//Has finish notification mechanism.
class DisplayMechanism : public IDispItem
{
public:
	DisplayMechanism(){}
	DisplayMechanism( const DisplayMechanism & ) = delete;
	DisplayMechanism &operator=( const DisplayMechanism & ) = delete;

public:
	void AddDispItem( std::shared_ptr<IDispItem> pItem )
	{	m_Items.push_back( pItem );	}

	//Register observer which waits the state that this object's Finish() returns true.
	void RegisterWaiter( std::weak_ptr< Notifier::INotified > pWaiter )
	{	m_FinishNotifier.Register(pWaiter);	}

	//---
	// IDispItem implementation

	virtual bool Finished() const override {	return m_Items.empty();	}

	virtual bool Update() override
	{
		bool NeedToRedraw = false;
		for( auto iter=m_Items.begin();	iter!=m_Items.end();	/*NOP*/ )
		{
			NeedToRedraw |= (*iter)->Update();
			if( (*iter)->Finished() )
			{	iter = m_Items.erase( iter );	}
			else
			{	++iter;	}
		}

		if( Finished() ){	m_FinishNotifier.Notify();	}

		return NeedToRedraw;
	}

	virtual void Paint( /*XXX*/ ) const override
	{
		for( const auto &pItem : m_Items )
		{	pItem->Paint( /*XXX*/ );	}
	}

private:
	std::list< std::shared_ptr<IDispItem> > m_Items;
	Notifier m_FinishNotifier;
};

CODE:

void Update()
{
  if( Waiting )return;  //待ってたら即return
  
  //処理
}

CODE:

class Notifier
{
public:
	//Returns whether need to unregister or not.
	//If true, this object will be unregistered from the Notifier.
	using Observer = std::function< bool(void) >;

public:
	Notifier(){}
	Notifier( const Notifier & ) = delete;
	Notifier &operator=( const Notifier & ) = delete;

	//Note : invalid usage such as null or duplication don't be checked.
	void Register( const Observer &rObserver ){	m_Observers.push_back(rObserver);	}

	void Clear(){	m_Observers.clear();	}
	bool Empty() const {	return m_Observers.empty();	}

	void Notify()
	{
		for( auto iter=m_Observers.begin(); iter!=m_Observers.end(); /*NOP*/ )
		{
			if( (*iter)() ){	iter = m_Observers.erase( iter );	}
			else {	++iter;	}
		}
	}
private:
	std::list< Observer > m_Observers;
};

CODE:

//IDispItem with finish notification.
class IWaitableDispItem : public IDispItem
{
public:
	//Register observer which waits the state that this Object's Finish() returns true.
	virtual void RegisterWaiter( const Notifier::Observer &Waiter ) = 0;
};

CODE:

//Sequence of IDispItem.
class DispItemSeq : public IDispItem
{
public:
	DispItemSeq(){}
	DispItemSeq( const DispItemSeq & ) = delete;
	DispItemSeq &operator=( const DispItemSeq & ) = delete;
	virtual ~DispItemSeq(){}

public:
	//Add to the tail of sequence.
	//When the added item's Finished() returns true, the item would be automatically removed from this sequence.
	void AddDispItem( std::shared_ptr<IDispItem> spItem ){	m_Items.push_back( spItem );	}

public:	//IDispItem implementation
	virtual bool Finished() const override {	return m_Items.empty();	}

	virtual bool Update() override
	{
		bool NeedToRedraw = false;
		for( auto iter=m_Items.begin();	iter!=m_Items.end();	/*NOP*/ )
		{
			NeedToRedraw |= (*iter)->Update();
			if( (*iter)->Finished() ){	iter = m_Items.erase( iter );	}
			else {	++iter;	}
		}
		return NeedToRedraw;
	}

	virtual void Paint( HDC hdc, int W, int H ) const override
	{	for( const auto &pItem : m_Items ){	pItem->Paint( hdc,W,H );	}	}

protected:
	std::list< std::shared_ptr<IDispItem> > m_Items;
};

CODE:

//A concrete implementation of IWaitableDispItem
class WaitableDispItem : public IWaitableDispItem
{
private:
	std::unique_ptr<IDispItem> m_upDispItem;
	Notifier m_FinishNotifier;
public:
	WaitableDispItem( std::unique_ptr<IDispItem> &&upDispItem ) : m_upDispItem{ std::move(upDispItem) } {}
	WaitableDispItem( std::unique_ptr<IDispItem> &&upDispItem, const Notifier::Observer &Waiter ) : WaitableDispItem{ std::move(upDispItem) } {	RegisterWaiter( Waiter );	}
public:	//IWaitableDispItem implementation
	void RegisterWaiter( const Notifier::Observer &Waiter ){	m_FinishNotifier.Register(Waiter);	}
public:	//IDispItem implementation
	virtual bool Finished() const override {	return m_upDispItem->Finished();	}
	virtual void Paint( HDC hdc, int W, int H ) const override {	m_upDispItem->Paint( hdc,W,H );	}
	virtual bool Update() override
	{
		bool Ret = m_upDispItem->Update();
		if( Finished() ){	m_FinishNotifier.Notify();	}
		return Ret;
	}
};