void EventSystem::propagateEnterLeaveEvent(Event* event)
{
// "leave" events for old views, "enter" events for new views
s32 maxn = (s32)std::max(currentViewStack.size(), previousMouseMoveStack.size());
View* oldView = NULL;
View* newView = NULL;
event->base.bubbles = true;
for(s32 i=0; i<maxn; ++i)
{
oldView = i < previousMouseMoveStack.size() ? previousMouseMoveStack[i] : NULL;
newView = i < currentViewStack.size() ? currentViewStack[i] : NULL;
if(oldView != newView)
{
if(oldView)
{
event->base.target = oldView;
event->base.type = ET_MouseLeave;
// DOUT("leaving "<<oldView->name());
propagateEvent(previousMouseMoveStack, event, i);
}
if(newView)
{
event->base.target = newView;
event->base.type = ET_MouseEnter;
// DOUT("entering "<<newView->name());
propagateEvent(currentViewStack, event, i);
}
}
}
}
void ProtocolManager::update()
{
// before updating, notice protocols that they have received events
pthread_mutex_lock(&m_events_mutex); // secure threads
int size = (int)m_events_to_process.size();
int offset = 0;
for (int i = 0; i < size; i++)
{
bool result = propagateEvent(&m_events_to_process[i+offset], true);
if (result)
{
m_events_to_process.erase(m_events_to_process.begin()+i+offset,m_events_to_process.begin()+i+offset+1);
offset --;
}
}
pthread_mutex_unlock(&m_events_mutex); // release the mutex
// now update all protocols
pthread_mutex_lock(&m_protocols_mutex);
for (unsigned int i = 0; i < m_protocols.size(); i++)
{
if (m_protocols[i].state == PROTOCOL_STATE_RUNNING)
m_protocols[i].protocol->update();
}
pthread_mutex_unlock(&m_protocols_mutex);
}
/*!
\internal
*/
void QObjectPickerPrivate::movedEvent(QPickEvent *event)
{
Q_Q(QObjectPicker);
emit q->moved(event);
if (!event->isAccepted())
propagateEvent(event, EventType::Moved);
}
/*!
\internal
*/
void QObjectPickerPrivate::clickedEvent(QPickEvent *event)
{
Q_Q(QObjectPicker);
emit q->clicked(event);
if (!event->isAccepted())
propagateEvent(event, Clicked);
}
void EventSystem::propagateMouseEvent(Event* event)
{
updateCurrentViewStack(event);
if(currentViewStack.size() == 0) { return; } // bail if no views, happens when mouse outside of window
// logViewStack(currentViewStack);
event->base.bubbles = true;
event->base.stopDispatch = false;
event->base.stopPropagation = false;
EventType et = event->base.type;
if((et == ET_MouseUp) || (et == ET_MouseDown))
{
propagateUpDownEvent(event);
if(et == ET_MouseDown)
{
propagateFocusEvent(event);
}
}
else
{
// propagate scroll/move
event->base.target = currentViewStack.back();
s32 targetIndex = s32(currentViewStack.size())-1;
propagateEvent(currentViewStack, event, targetIndex);
}
// enter/leave
if(et == ET_MouseMove)
{
propagateEnterLeaveEvent(event);
previousMouseMoveStack = currentViewStack;
}
}
void EventSystem::propagateUpDownEvent(Event* event)
{
EventType et = event->base.type;
if(et == ET_MouseDown)
{
if(currentViewStack.size() == 0)
{
WOUT("currentViewStack was empty!");
return;
}
event->base.target = currentViewStack.back();
propagateEvent(currentViewStack, event, (s32)currentViewStack.size()-1);
previousMouseClickStack = currentViewStack;
}
else if(et == ET_MouseUp)
{
s32 oldIndex = previousMouseClickStack.size() > 0 ? (s32)previousMouseClickStack.size()-1 : -1;
s32 newIndex = currentViewStack.size() > 0 ? (s32)currentViewStack.size()-1 : -1;
View* oldView = oldIndex > 0 ? previousMouseClickStack[oldIndex] : NULL;
View* newView = newIndex > 0 ? currentViewStack[newIndex] : NULL;
if(oldView && (oldView != newView))
{
event->base.target = oldView;
event->base.type = ET_MouseUpOutside;
event->base.bubbles = true;
propagateEvent(previousMouseClickStack, event, oldIndex);
event->base.bubbles = true;
event->base.type = ET_MouseUp;
propagateEvent(previousMouseClickStack, event, oldIndex);
}
if(newView)
{
event->base.target = newView;
event->base.type = ET_MouseUpInside;
event->base.bubbles = true;
propagateEvent(currentViewStack, event, newIndex);
event->base.type = ET_MouseUp;
event->base.bubbles = true;
propagateEvent(currentViewStack, event, newIndex);
}
previousMouseClickStack = currentViewStack;
}
}
/*!
\internal
*/
void QObjectPickerPrivate::releasedEvent(QPickEvent *event)
{
Q_Q(QObjectPicker);
if (m_acceptedLastPressedEvent) {
emit q->released(event);
setPressed(false);
} else {
event->setAccepted(false);
propagateEvent(event, Released);
}
}
void ProtocolManager::asynchronousUpdate()
{
// before updating, notice protocols that they have received information
pthread_mutex_lock(&m_events_mutex); // secure threads
int size = (int)m_events_to_process.size();
int offset = 0;
for (int i = 0; i < size; i++)
{
bool result = propagateEvent(&m_events_to_process[i+offset], false);
if (result)
{
m_events_to_process.erase(m_events_to_process.begin()+i+offset,m_events_to_process.begin()+i+offset+1);
offset --;
}
}
pthread_mutex_unlock(&m_events_mutex); // release the mutex
// now update all protocols that need to be updated in asynchronous mode
pthread_mutex_lock(&m_asynchronous_protocols_mutex);
for (unsigned int i = 0; i < m_protocols.size(); i++)
{
if (m_protocols[i].state == PROTOCOL_STATE_RUNNING)
m_protocols[i].protocol->asynchronousUpdate();
}
pthread_mutex_unlock(&m_asynchronous_protocols_mutex);
// process queued events for protocols
// these requests are asynchronous
pthread_mutex_lock(&m_requests_mutex);
for (unsigned int i = 0; i < m_requests.size(); i++)
{
switch (m_requests[i].type)
{
case PROTOCOL_REQUEST_START:
startProtocol(m_requests[i].protocol_info);
break;
case PROTOCOL_REQUEST_STOP:
stopProtocol(m_requests[i].protocol_info);
break;
case PROTOCOL_REQUEST_PAUSE:
pauseProtocol(m_requests[i].protocol_info);
break;
case PROTOCOL_REQUEST_UNPAUSE:
unpauseProtocol(m_requests[i].protocol_info);
break;
case PROTOCOL_REQUEST_TERMINATE:
protocolTerminated(m_requests[i].protocol_info);
break;
}
}
m_requests.clear();
pthread_mutex_unlock(&m_requests_mutex);
}
void EventSystem::propagateFocusEvent(Event* event)
{
event->base.bubbles = true;
event->base.stopDispatch = false;
event->base.stopPropagation = false;
currentFocusStack = currentViewStack;
s32 maxn = (s32)std::max(currentFocusStack.size(), previousFocusStack.size());
View* oldView = NULL;
View* newView = NULL;
for(s32 i=0; i<maxn; ++i)
{
oldView = i < previousFocusStack.size() ? previousFocusStack[i] : NULL;
newView = i < currentFocusStack.size() ? currentFocusStack[i] : NULL;
if(oldView != newView)
{
focusChanged = true;
if(oldView && oldView->focusable)
{
oldView->focused = false;
event->base.bubbles = true;
event->base.target = oldView;
event->base.type = ET_FocusLost;
propagateEvent(previousFocusStack, event, i);
}
if(newView && newView->focusable)
{
newView->focused = true;
event->base.bubbles = true;
event->base.target = newView;
event->base.type = ET_FocusGained;
propagateEvent(currentFocusStack, event, i);
}
}
}
previousFocusStack = currentViewStack;
}
/*!
\internal
*/
void QObjectPickerPrivate::pressedEvent(QPickEvent *event)
{
Q_Q(QObjectPicker);
emit q->pressed(event);
m_acceptedLastPressedEvent = event->isAccepted();
if (!m_acceptedLastPressedEvent) {
// Travel parents to transmit the event
propagateEvent(event, Pressed);
} else {
setPressed(true);
}
}
void Widget::dispatchEvent(Event &evt) {
if (!isEventTypeTracked(evt.getType()))
return;
propagateEvent(evt);
if (evt.isConsumed())
return;
const EventListener *listener = getListener(evt.getType());
if (listener == NULL)
return;
EventListener::const_iterator it;
for (it = listener->begin(); it != listener->end(); it++)
(**it)(evt);
}
void EventSystem::loseFocus(View* view)
{
// check if view is in focusStack and find index
s32 viewIndex =-1;
for(s32 i=0; i<previousFocusStack.size(); ++i)
{
if(previousFocusStack[i] == view)
{
viewIndex = i;
break;
}
}
// rootview can never lose focus, so we test for > 0
if(viewIndex > 0)
{
// if it was, send it a FocusLost event, and all focused views underneath it.
Event* event = Application::instance()->eventPool->borrowEvent();
event->base.bubbles = true;
event->base.stopDispatch = false;
event->base.stopPropagation = false;
event->base.type = ET_FocusLost;
for(s32 i=viewIndex; i<previousFocusStack.size(); ++i)
{
View* currentView = previousFocusStack[i];
if(currentView->focused)
{
currentView->focused = false;
event->base.target = currentView;
propagateEvent(previousFocusStack, event, i);
}
}
// remove the view and all focused views underneath from the currentViewStack
previousFocusStack.resize(viewIndex);
}
}
int main()
{
if (ID::Init(SDL_INIT_VIDEO) == -1)
{
std::cout << "Fatal Error: ID::Init()" << std::endl;
return -1;
}
ID::Window* win;
ID::Wrapper_Event* we;
ID::Event event;
Env* env;
Sockets_manager* sktM;
Protocol_Manager* pm;
try
{
win = new ID::Window(UI_WIDTH, UI_HEIGHT,
SDL_SWSURFACE /*| SDL_NOFRAME*/);
if (win == NULL)
{
std::cerr << "Fatal Error: ID::Window()" << std::endl;
return -1;
}
SDL_EnableKeyRepeat(SDL_DEFAULT_REPEAT_DELAY,
SDL_DEFAULT_REPEAT_INTERVAL);
win->SetCbKeyUp(__main_winKeyUp, NULL);
win->SetCbKeyDown(__main_winKeyDown, NULL);
if (ID::InitWrappers() == -1)
{
std::cerr << "Fatal Error: ID::InitWrappers()" << std::endl;
delete win;
ID::Quit();
return -1;
}
if (InitInstances(win) == -1)
throw 1;
}
catch (int e)
{
std::cerr << "Error " << e << ": Cannot init program" << std::endl;
CleanProgram(win);
return -1;
}
env = Env::GetInstance();
we = ID::Wrapper_Event::GetInstance();
sktM = Sockets_manager::GetInstance();
pm = Protocol_Manager::GetInstance();
while (env->alive == true)
{
CheckNetwork(sktM, pm);
if (we->PollEvent(&event))
{
pthread_mutex_lock(&(env->displayMutex));
if (propagateEvent(win, &event) == 1)
env->alive = false;
pthread_mutex_unlock(&(env->displayMutex));
}
usleep(10);
}
CleanProgram(win);
return 0;
}
void EventSystem::propagateKeyEvent(Event* event)
{
event->base.bubbles = true;
event->base.target = focusedView();
propagateEvent(previousFocusStack, event, (s32)previousFocusStack.size()-1); // don't need to range check since rootView is always in focus
}
