// document command loop
void UppCadDocument::commandLoop(void)
{
	// loop not ended
	INTERLOCKED_(mutex)
	{
		loopEnded = false;
	}
	while(!Thread::IsShutdownThreads())
	{
	
		if(commandLine.HasCommand())
		{
			String cmd = commandLine.GetCommand();
			if(cmd != "<ESC>" && cmd != "")
				SendCommand(cmd);
		}
		Sleep(100);
	}
	// loop ended
	INTERLOCKED_(mutex)
	{
		loopEnded = true;
	}
}

void SomeEventHandler(somedata)
{
    GetActiveDocument().InjectEvent(eventtype, somedata);
}

while(true)
{
    WaitForInjectedEventsWithoutEatingCpu();
    while(eventsInQueue)
        ProcessPendingEvents()
}

void UppCadDocument::commandLoop(void)
{
	// loop not ended
	INTERLOCKED_(mutex)
	{
		loopEnded = false;
	}
	while(!Thread::IsShutdownThreads())
	{
            String currentCommand;
            {
                Mutex::Lock __(commandLineMutex)
	        currentCommand = commandLine;
            }
		if(currentCommand.HasCommand())
		{
			String cmd = currentCommand.GetCommand();
			if(cmd != "<ESC>" && cmd != "")
				SendCommand(cmd);
		}
		Sleep(100);
	}
	// loop ended
	INTERLOCKED_(mutex)
	{
		loopEnded = true;
	}
}

// wait for next event and process it
// returns false if shutting down
bool ThreadQueue::WaitAndProcessEvent(void)
{
	// test again if shutting down
	if(Thread::IsShutdownThreads() || exiting)
		return false;
	
	// wait for events
	semaphore.Wait();
	
	// test again if shutting down
	if(Thread::IsShutdownThreads() || exiting)
		return false;
	
	Callback c;
	
	// pops next event
	INTERLOCKED_(mutex) {
		ASSERT(!queue.IsEmpty());
		c = queue.Head();
		queue.DropHead();
	}
	
	// runs the callback
	c.Execute();
	
	// test again if shutting down
	if(Thread::IsShutdownThreads() || exiting)
		return false;
	
	return true;
}

// sends an evento to this thread
void ThreadQueue::SendEvent(Callback c)
{
	INTERLOCKED_(mutex) {
		queue.AddTail(c);
		semaphore.Release();
	}
}

// document command loop
void UppCadDocument::commandLoop(void)
{
	while(WaitAndProcessEvent())
	{
		if(commandLine.HasCommand())
		{
			String cmd = commandLine.GetCommand();
			if(cmd != "<ESC>" && cmd != "")
				SendCommand(cmd);
		}
	}
}

///////////////////////////////////////////////////////////////////////////////////////////////
// middle up - resets pan/3dorbit behaviour
void UppCadView::MiddleUp(Point p, dword keyflags)
{
	SendViewEvent2(uppCadDocument. MiddleUp0, p, keyFlags);
}

void UppCadView::MiddleUp0(Point p, dword keyflags)
{
	isPanning = false;
	PanStartPoint.SetNull();
	
	isRotating = false;
	
} // END UppCadView::MiddleUp()

#ifndef _ThreadQueue_ThreadQueue_h
#define _ThreadQueue_ThreadQueue_h

#include <Core/Core.h>

using namespace Upp;

class ThreadQueue
{
	private:
	
		// thread running loop;
		Thread loopThread;
		
		// loop call function
		void callLoop(Callback cb);
	
		// the queue/fifo
		BiVector<Callback> queue;
		
		// controlling semaphore
		Semaphore semaphore;
		
		// sync mutex
		Mutex mutex;
		
		// exiting flag -- to manually shutdonwn
		bool exiting;
		
		// exited flag
		bool exited;
	
	protected:

	public:
	
		typedef ThreadQueue CLASSNAME;
	
		// constructor
		ThreadQueue();
		
		// destructor
		~ThreadQueue();
	
		// sends an evento to this thread
		void SendEvent(Callback c);
		
		// wait for next event and process it
		// returns false if shutting down
		bool WaitAndProcessEvent(void);
		
		// shutdown this thread
		// returns true if successfully shut down after some
		// wait time, false if loop is blocked somehow
		bool Shutdown(void);
		
		// ask if we're exiting from thread loop
		bool Exiting(void);
		
		// ask if thread exited
		bool Exited(void);
		
		// start the command loop
		void StartLoop(Callback cb);
};

#endif

#include "ThreadQueue.h"

// constructor
ThreadQueue::ThreadQueue()
{
	// not exited on startup
	exited = false;
	
	// end not exiting too....
	exiting = false;
}

// destructor
ThreadQueue::~ThreadQueue()
{
	// try to exit loop on destruction, if not already out
	Shutdown();
}

// loop call function
void ThreadQueue::callLoop(Callback cb)
{
	INTERLOCKED_(mutex) {
		exited = false;
	}
	cb();
	INTERLOCKED_(mutex) {
		exited = true;
	}
}
	
// wait for next event and process it
// returns false if shutting down
bool ThreadQueue::WaitAndProcessEvent(void)
{
	// test again if shutting down
	if(exiting)
		return false;
	
	// wait for events
	semaphore.Wait();
	
	// test again if shutting down
	if(exiting)
		return false;
	
	Callback c;
	
	// pops next event
	INTERLOCKED_(mutex) {
		ASSERT(!queue.IsEmpty());
		c = queue.Head();
		queue.DropHead();
	}
	
	// runs the callback
	c.Execute();
	
	// test again if shutting down
	if(exiting)
		return false;
	
	return true;
}
		
// sends an evento to this thread
void ThreadQueue::SendEvent(Callback c)
{
	INTERLOCKED_(mutex) {
		queue.AddTail(c);
		semaphore.Release();
	}
}

// shutdown this thread
// returns true if successfully shut down after some
// wait time, false if loop is blocked somehow
bool ThreadQueue::Shutdown(void)
{
	// if already out of loop, just return true
	if(Exited())
		return true;
	
	// signals that we wanna exit
	INTERLOCKED_(mutex) {
		exiting = true;
	}
	
	// send a fake event to unlock event waiting
	SendEvent(Callback());
	
	// wait to give time for loop exiting
	// here about 1s wait max
	for(int i = 0; i < 10; i++)
	{
		if(Exited())
			return true;
		// send a fake event to unlock event waiting
		SendEvent(Callback());
		Sleep(100);
	}
	
	// if here, thread loop is still busy
	return false;
}

// ask if thread exited
bool ThreadQueue::Exited(void)
{
	bool ex;
	INTERLOCKED_(mutex) {
		ex = exited;
	}
	return ex;
}

// ask if thread exited
bool ThreadQueue::Exiting(void)
{
	bool ex;
	INTERLOCKED_(mutex) {
		ex = exiting;
	}
	return ex;
}

// start the command loop
void ThreadQueue::StartLoop(Callback cb)
{
	exiting = exited = false;
	loopThread.Start(THISBACK1(callLoop, cb));
}

// document command loop
void UppCadDocument::commandLoop(void)
{
	while(WaitAndProcessEvent())
	{
		if(commandLine.HasCommand())
		{
			String cmd = commandLine.GetCommand();
			if(cmd != "<ESC>" && cmd != "")
				SendCommand(cmd);
			GetCurrentView()->RefreshView();
		}
	}
}