void ProcessEventQueue()
{
// While processing the current queue, we need a new queue to store additional events that
// might be generated during current queue events processing. Thanks to the gate mechanism,
// events put in the new queue will be processed before the remaining events in the current
// queue (but after processing of the event generating them is completed).
//
// For example, MouseDownEvent generates FocusOut, FocusIn, Blur and Focus events. And let's
// say that FocusIn generates ValueChanged and GeometryChanged events.
//
// Without queue swapping, order of event processing would be MouseDown, FocusOut, FocusIn,
// Blur, Focus, ValueChanged, GeometryChanged. It is not the same as order of event emission.
//
// With queue swapping, order is MouseDown, FocusOut, FocusIn, ValueChanged, GeometryChanged,
// Blur, Focus. This preserve the order of event emission, and each event is completely
// processed before processing the next event.
Queue <EventRecord> queueToProcess = m_Queue;
m_Queue = k_EventQueuePool.Get();
ExitGUIException caughtExitGUIException = null;
try
{
processingEvents = true;
while (queueToProcess.Count > 0)
{
EventRecord eventRecord = queueToProcess.Dequeue();
EventBase evt = eventRecord.m_Event;
IPanel panel = eventRecord.m_Panel;
try
{
ProcessEvent(evt, panel);
}
catch (ExitGUIException e)
{
Debug.Assert(caughtExitGUIException == null);
caughtExitGUIException = e;
}
finally
{
// Balance the Acquire when the event was put in queue.
evt.Dispose();
}
}
}
finally
{
processingEvents = false;
k_EventQueuePool.Release(queueToProcess);
}
if (caughtExitGUIException != null)
{
throw caughtExitGUIException;
}
}
private void ProcessEventQueue()
{
Queue <EventDispatcher.EventRecord> queue = this.m_Queue;
this.m_Queue = EventDispatcher.k_EventQueuePool.Get();
ExitGUIException ex = null;
try
{
while (queue.Count > 0)
{
EventDispatcher.EventRecord eventRecord = queue.Dequeue();
EventBase @event = eventRecord.m_Event;
IPanel panel = eventRecord.m_Panel;
try
{
this.ProcessEvent(@event, panel);
}
catch (ExitGUIException ex2)
{
Debug.Assert(ex == null);
ex = ex2;
}
finally
{
@event.Dispose();
}
}
}
finally
{
EventDispatcher.k_EventQueuePool.Release(queue);
}
bool flag = ex != null;
if (flag)
{
throw ex;
}
}
