| /*********************************************************** |
| * Copyright (C) 1997, Be Inc. Copyright (C) 1999, Jake Hamby. |
| * |
| * This program is freely distributable without licensing fees |
| * and is provided without guarantee or warrantee expressed or |
| * implied. This program is -not- in the public domain. |
| * |
| * |
| * FILE: glutEvent.cpp |
| * |
| * DESCRIPTION: here it is, the BeOS GLUT event loop |
| ***********************************************************/ |
| |
| /*********************************************************** |
| * Headers |
| ***********************************************************/ |
| #include <GL/glut.h> |
| #include "glutint.h" |
| #include "glutState.h" |
| #include "glutBlocker.h" |
| |
| /*********************************************************** |
| * CLASS: GLUTtimer |
| * |
| * DESCRIPTION: list of timer callbacks |
| ***********************************************************/ |
| struct GLUTtimer { |
| GLUTtimer *next; // list of timers |
| bigtime_t timeout; // time to be called |
| GLUTtimerCB func; // function to call |
| int value; // value |
| }; |
| |
| /*********************************************************** |
| * Private variables |
| ***********************************************************/ |
| static GLUTtimer *__glutTimerList = 0; // list of timer callbacks |
| static GLUTtimer *freeTimerList = 0; |
| |
| /*********************************************************** |
| * FUNCTION: glutTimerFunc (7.19) |
| * |
| * DESCRIPTION: register a new timer callback |
| ***********************************************************/ |
| void APIENTRY |
| glutTimerFunc(unsigned int interval, GLUTtimerCB timerFunc, int value) |
| { |
| GLUTtimer *timer, *other; |
| GLUTtimer **prevptr; |
| |
| if (!timerFunc) |
| return; |
| |
| if (freeTimerList) { |
| timer = freeTimerList; |
| freeTimerList = timer->next; |
| } else { |
| timer = new GLUTtimer(); |
| if (!timer) |
| __glutFatalError("out of memory."); |
| } |
| |
| timer->func = timerFunc; |
| timer->value = value; |
| timer->next = NULL; |
| timer->timeout = system_time() + (interval*1000); // 1000 ticks in a millisecond |
| prevptr = &__glutTimerList; |
| other = *prevptr; |
| while (other && (other->timeout < timer->timeout)) { |
| prevptr = &other->next; |
| other = *prevptr; |
| } |
| timer->next = other; |
| *prevptr = timer; |
| } |
| |
| /*********************************************************** |
| * FUNCTION: handleTimeouts |
| * |
| * DESCRIPTION: private function to handle outstanding timeouts |
| ***********************************************************/ |
| static void |
| handleTimeouts(void) |
| { |
| bigtime_t now; |
| GLUTtimer *timer; |
| |
| /* Assumption is that __glutTimerList is already determined |
| to be non-NULL. */ |
| now = system_time(); |
| while (__glutTimerList->timeout <= now) { |
| timer = __glutTimerList; |
| if(gState.currentWindow) |
| gState.currentWindow->LockGL(); |
| timer->func(timer->value); |
| if(gState.currentWindow) |
| gState.currentWindow->UnlockGL(); |
| __glutTimerList = timer->next; |
| timer->next = freeTimerList; |
| freeTimerList = timer; |
| if (!__glutTimerList) |
| break; |
| } |
| } |
| |
| |
| /*********************************************************** |
| * FUNCTION: processEventsAndTimeouts |
| * |
| * DESCRIPTION: clear gBlock, then check all windows for events |
| ***********************************************************/ |
| static void |
| processEventsAndTimeouts(void) |
| { |
| gBlock.WaitEvent(); // if there is already an event, returns |
| // immediately, otherwise wait forever |
| gBlock.ClearEvents(); |
| |
| if(gState.quitAll) |
| exit(0); // exit handler cleans up windows and quits nicely |
| |
| if (gState.currentWindow) |
| gState.currentWindow->LockGL(); |
| for(int i=0; i<gState.windowListSize; i++) { |
| if (gState.windowList[i]) { |
| GlutWindow *win = gState.windowList[i]; |
| // NOTE: we can use win as a shortcut for gState.windowList[i] |
| // in callbacks, EXCEPT we need to check the original variable |
| // after each callback to make sure the window hasn't been destroyed |
| if (win->anyevents) { |
| win->anyevents = false; |
| if (win->reshapeEvent) { |
| win->reshapeEvent = false; |
| __glutSetWindow(win); |
| win->reshape(win->m_width, win->m_height); |
| } |
| if (!gState.windowList[i]) |
| continue; // window was destroyed by callback! |
| |
| if (win->displayEvent) { |
| win->displayEvent = false; |
| __glutSetWindow(win); |
| win->display(); |
| } |
| if (!gState.windowList[i]) |
| continue; // window was destroyed by callback! |
| |
| if (win->mouseEvent) { |
| win->mouseEvent = false; |
| __glutSetWindow(win); |
| if (win->mouse) { |
| gState.modifierKeys = win->modifierKeys; |
| win->mouse(win->button, win->mouseState, win->mouseX, win->mouseY); |
| gState.modifierKeys = ~0; |
| } |
| } |
| if (!gState.windowList[i]) |
| continue; // window was destroyed by callback! |
| |
| if (win->menuEvent) { |
| win->menuEvent = false; |
| __glutSetWindow(win); |
| GlutMenu *menu = __glutGetMenuByNum(win->menuNumber); |
| if (menu) { |
| gState.currentMenu = menu; |
| menu->select(win->menuValue); |
| } |
| } |
| if (!gState.windowList[i]) |
| continue; // window was destroyed by callback! |
| |
| if (win->statusEvent) { |
| win->statusEvent = false; |
| __glutSetWindow(win); |
| if (gState.menuStatus) { |
| gState.currentMenu = __glutGetMenuByNum(win->menuNumber); |
| gState.menuStatus(win->menuStatus, win->statusX, win->statusY); |
| } |
| } |
| if (!gState.windowList[i]) |
| continue; // window was destroyed by callback! |
| |
| if (win->motionEvent) { |
| win->motionEvent = false; |
| __glutSetWindow(win); |
| if (win->motion) |
| win->motion(win->motionX, win->motionY); |
| } |
| if (!gState.windowList[i]) |
| continue; // window was destroyed by callback! |
| |
| if (win->passiveEvent) { |
| win->passiveEvent = false; |
| __glutSetWindow(win); |
| if (win->passive) |
| win->passive(win->passiveX, win->passiveY); |
| } |
| if (!gState.windowList[i]) |
| continue; // window was destroyed by callback! |
| |
| if (win->keybEvent) { |
| win->keybEvent = false; |
| __glutSetWindow(win); |
| if (win->keyboard) { |
| gState.modifierKeys = win->modifierKeys; |
| win->keyboard(win->key, win->keyX, win->keyY); |
| gState.modifierKeys = ~0; |
| } |
| } |
| if (!gState.windowList[i]) |
| continue; // window was destroyed by callback! |
| |
| if (win->specialEvent) { |
| win->specialEvent = false; |
| __glutSetWindow(win); |
| if (win->special) { |
| gState.modifierKeys = win->modifierKeys; |
| win->special(win->specialKey, win->specialX, win->specialY); |
| gState.modifierKeys = ~0; |
| } |
| } |
| if (!gState.windowList[i]) |
| continue; // window was destroyed by callback! |
| |
| if (win->entryEvent) { |
| win->entryEvent = false; |
| __glutSetWindow(win); |
| if (win->entry) |
| win->entry(win->entryState); |
| } |
| if (!gState.windowList[i]) |
| continue; // window was destroyed by callback! |
| |
| if (win->windowStatusEvent) { |
| win->windowStatusEvent = false; |
| __glutSetWindow(win); |
| if (win->windowStatus) |
| win->windowStatus(win->visState); |
| } |
| if (!gState.windowList[i]) |
| continue; // window was destroyed by callback! |
| } |
| } |
| } |
| if (gState.currentWindow) |
| gState.currentWindow->UnlockGL(); |
| |
| // This code isn't necessary since BGLView automatically traps errors |
| #if 0 |
| if(gState.debug) { |
| for(int i=0; i<gState.windowListSize; i++) { |
| if (gState.windowList[i]) { |
| gState.windowList[i]->LockGL(); |
| glutReportErrors(); |
| gState.windowList[i]->UnlockGL(); |
| } |
| } |
| } |
| #endif |
| if (__glutTimerList) { |
| handleTimeouts(); |
| } |
| } |
| |
| /*********************************************************** |
| * FUNCTION: waitForSomething |
| * |
| * DESCRIPTION: use gBlock to wait for a new event or timeout |
| ***********************************************************/ |
| static void |
| waitForSomething(void) |
| { |
| bigtime_t timeout = __glutTimerList->timeout; |
| bigtime_t now = system_time(); |
| |
| if (gBlock.PendingEvent()) |
| goto immediatelyHandleEvent; |
| |
| if(timeout>now) |
| gBlock.WaitEvent(timeout-now); |
| if (gBlock.PendingEvent()) { |
| immediatelyHandleEvent: |
| processEventsAndTimeouts(); |
| } else { |
| if (__glutTimerList) |
| handleTimeouts(); |
| } |
| } |
| |
| /*********************************************************** |
| * FUNCTION: idleWait |
| * |
| * DESCRIPTION: check for events, then call idle function |
| ***********************************************************/ |
| static void |
| idleWait(void) |
| { |
| if (gBlock.PendingEvent()) { |
| processEventsAndTimeouts(); |
| } else { |
| if (__glutTimerList) |
| handleTimeouts(); |
| } |
| /* Make sure idle func still exists! */ |
| if(gState.currentWindow) |
| gState.currentWindow->LockGL(); |
| if (gState.idle) { |
| gState.idle(); |
| } |
| if(gState.currentWindow) |
| gState.currentWindow->UnlockGL(); |
| } |
| |
| /*********************************************************** |
| * FUNCTION: glutMainLoop (3.1) |
| * |
| * DESCRIPTION: enter the event processing loop |
| ***********************************************************/ |
| void glutMainLoop() |
| { |
| if (!gState.windowListSize) |
| __glutFatalUsage("main loop entered with no windows created."); |
| |
| if(gState.currentWindow) |
| gState.currentWindow->UnlockGL(); |
| |
| for (;;) { |
| if (gState.idle) { |
| idleWait(); |
| } else { |
| if (__glutTimerList) { |
| waitForSomething(); |
| } else { |
| processEventsAndTimeouts(); |
| } |
| } |
| } |
| } |
| |
| /*********************************************************** |
| * CLASS: GlutWindow |
| * |
| * FUNCTION: KeyDown |
| * |
| * DESCRIPTION: handles keyboard and special events |
| ***********************************************************/ |
| void GlutWindow::KeyDown(const char *s, int32 slen) |
| { |
| ulong aChar = s[0]; |
| BGLView::KeyDown(s,slen); |
| |
| BPoint p; |
| |
| switch (aChar) { |
| case B_FUNCTION_KEY: |
| switch(Window()->CurrentMessage()->FindInt32("key")) { |
| case B_F1_KEY: |
| aChar = GLUT_KEY_F1; |
| goto specialLabel; |
| case B_F2_KEY: |
| aChar = GLUT_KEY_F2; |
| goto specialLabel; |
| case B_F3_KEY: |
| aChar = GLUT_KEY_F3; |
| goto specialLabel; |
| case B_F4_KEY: |
| aChar = GLUT_KEY_F4; |
| goto specialLabel; |
| case B_F5_KEY: |
| aChar = GLUT_KEY_F5; |
| goto specialLabel; |
| case B_F6_KEY: |
| aChar = GLUT_KEY_F6; |
| goto specialLabel; |
| case B_F7_KEY: |
| aChar = GLUT_KEY_F7; |
| goto specialLabel; |
| case B_F8_KEY: |
| aChar = GLUT_KEY_F8; |
| goto specialLabel; |
| case B_F9_KEY: |
| aChar = GLUT_KEY_F9; |
| goto specialLabel; |
| case B_F10_KEY: |
| aChar = GLUT_KEY_F10; |
| goto specialLabel; |
| case B_F11_KEY: |
| aChar = GLUT_KEY_F11; |
| goto specialLabel; |
| case B_F12_KEY: |
| aChar = GLUT_KEY_F12; |
| goto specialLabel; |
| default: |
| return; |
| } |
| case B_LEFT_ARROW: |
| aChar = GLUT_KEY_LEFT; |
| goto specialLabel; |
| case B_UP_ARROW: |
| aChar = GLUT_KEY_UP; |
| goto specialLabel; |
| case B_RIGHT_ARROW: |
| aChar = GLUT_KEY_RIGHT; |
| goto specialLabel; |
| case B_DOWN_ARROW: |
| aChar = GLUT_KEY_DOWN; |
| goto specialLabel; |
| case B_PAGE_UP: |
| aChar = GLUT_KEY_PAGE_UP; |
| goto specialLabel; |
| case B_PAGE_DOWN: |
| aChar = GLUT_KEY_PAGE_DOWN; |
| goto specialLabel; |
| case B_HOME: |
| aChar = GLUT_KEY_HOME; |
| goto specialLabel; |
| case B_END: |
| aChar = GLUT_KEY_END; |
| goto specialLabel; |
| case B_INSERT: |
| aChar = GLUT_KEY_INSERT; |
| specialLabel: |
| if (special) { |
| anyevents = specialEvent = true; |
| GetMouse(&p,&m_buttons); |
| specialKey = aChar; |
| specialX = (int)p.x; |
| specialY = (int)p.y; |
| goto setModifiers; // set the modifier variable |
| } |
| return; |
| |
| default: |
| break; |
| } |
| |
| if (keyboard) { |
| anyevents = keybEvent = true; |
| GetMouse(&p,&m_buttons); |
| key = aChar; |
| keyX = (int)p.x; |
| keyY = (int)p.y; |
| setModifiers: |
| modifierKeys = 0; |
| uint32 beMod = Window()->CurrentMessage()->FindInt32("modifiers"); |
| if(beMod & B_SHIFT_KEY) |
| modifierKeys |= GLUT_ACTIVE_SHIFT; |
| if(beMod & B_CONTROL_KEY) |
| modifierKeys |= GLUT_ACTIVE_CTRL; |
| if(beMod & B_OPTION_KEY) { |
| // since the window traps B_COMMAND_KEY, we'll have to settle |
| // for the option key.. but we need to get the raw character, |
| // not the Unicode-enhanced version |
| key = Window()->CurrentMessage()->FindInt32("raw_char"); |
| modifierKeys |= GLUT_ACTIVE_ALT; |
| } |
| gBlock.NewEvent(); |
| } |
| } |
| |
| /*********************************************************** |
| * CLASS: GlutWindow |
| * |
| * FUNCTION: MouseDown |
| * |
| * DESCRIPTION: handles mouse and menustatus events |
| ***********************************************************/ |
| void GlutWindow::MouseDown(BPoint point) |
| { |
| BGLView::MouseDown(point); |
| MouseCheck(); |
| } |
| |
| /*********************************************************** |
| * CLASS: GlutWindow |
| * |
| * FUNCTION: MouseCheck |
| * |
| * DESCRIPTION: checks for button state changes |
| ***********************************************************/ |
| void GlutWindow::MouseCheck() |
| { |
| if (mouseEvent) |
| return; // we already have an outstanding mouse event |
| |
| BPoint point; |
| uint32 newButtons; |
| GetMouse(&point, &newButtons); |
| if (m_buttons != newButtons) { |
| if (newButtons&B_PRIMARY_MOUSE_BUTTON && !(m_buttons&B_PRIMARY_MOUSE_BUTTON)) { |
| button = GLUT_LEFT_BUTTON; |
| mouseState = GLUT_DOWN; |
| } else if (m_buttons&B_PRIMARY_MOUSE_BUTTON && !(newButtons&B_PRIMARY_MOUSE_BUTTON)) { |
| button = GLUT_LEFT_BUTTON; |
| mouseState = GLUT_UP; |
| } else if (newButtons&B_SECONDARY_MOUSE_BUTTON && !(m_buttons&B_SECONDARY_MOUSE_BUTTON)) { |
| button = GLUT_RIGHT_BUTTON; |
| mouseState = GLUT_DOWN; |
| } else if (m_buttons&B_SECONDARY_MOUSE_BUTTON && !(newButtons&B_SECONDARY_MOUSE_BUTTON)) { |
| button = GLUT_RIGHT_BUTTON; |
| mouseState = GLUT_UP; |
| } else if (newButtons&B_TERTIARY_MOUSE_BUTTON && !(m_buttons&B_TERTIARY_MOUSE_BUTTON)) { |
| button = GLUT_MIDDLE_BUTTON; |
| mouseState = GLUT_DOWN; |
| } else if (m_buttons&B_TERTIARY_MOUSE_BUTTON && !(newButtons&B_TERTIARY_MOUSE_BUTTON)) { |
| button = GLUT_MIDDLE_BUTTON; |
| mouseState = GLUT_UP; |
| } |
| } else { |
| return; // no change, return |
| } |
| m_buttons = newButtons; |
| |
| if (mouseState == GLUT_DOWN) { |
| BWindow *w = Window(); |
| GlutMenu *m = __glutGetMenuByNum(menu[button]); |
| if (m) { |
| if (gState.menuStatus) { |
| anyevents = statusEvent = true; |
| menuNumber = menu[button]; |
| menuStatus = GLUT_MENU_IN_USE; |
| statusX = (int)point.x; |
| statusY = (int)point.y; |
| gBlock.NewEvent(); |
| } |
| BRect bounds = w->Frame(); |
| point.x += bounds.left; |
| point.y += bounds.top; |
| GlutPopUp *bmenu = static_cast<GlutPopUp*>(m->CreateBMenu()); // start menu |
| bmenu->point = point; |
| bmenu->win = this; |
| thread_id menu_thread = spawn_thread(MenuThread, "menu thread", B_NORMAL_PRIORITY, bmenu); |
| resume_thread(menu_thread); |
| return; |
| } |
| } |
| |
| if (mouse) { |
| anyevents = mouseEvent = true; |
| mouseX = (int)point.x; |
| mouseY = (int)point.y; |
| modifierKeys = 0; |
| uint32 beMod = modifiers(); |
| if(beMod & B_SHIFT_KEY) |
| modifierKeys |= GLUT_ACTIVE_SHIFT; |
| if(beMod & B_CONTROL_KEY) |
| modifierKeys |= GLUT_ACTIVE_CTRL; |
| if(beMod & B_OPTION_KEY) { |
| modifierKeys |= GLUT_ACTIVE_ALT; |
| } |
| gBlock.NewEvent(); |
| } |
| } |
| |
| /*********************************************************** |
| * CLASS: GlutWindow |
| * |
| * FUNCTION: MouseMoved |
| * |
| * DESCRIPTION: handles entry, motion, and passive events |
| ***********************************************************/ |
| void GlutWindow::MouseMoved(BPoint point, |
| ulong transit, const BMessage *msg) |
| { |
| BGLView::MouseMoved(point,transit,msg); |
| |
| if(transit != B_INSIDE_VIEW) { |
| if (entry) { |
| anyevents = entryEvent = true; |
| gBlock.NewEvent(); |
| } |
| if (transit == B_ENTERED_VIEW) { |
| entryState = GLUT_ENTERED; |
| MakeFocus(); // make me the current focus |
| __glutSetCursor(cursor); |
| } else |
| entryState = GLUT_LEFT; |
| } |
| |
| MouseCheck(); |
| if(m_buttons) { |
| if(motion) { |
| anyevents = motionEvent = true; |
| motionX = (int)point.x; |
| motionY = (int)point.y; |
| gBlock.NewEvent(); |
| } |
| } else { |
| if(passive) { |
| anyevents = passiveEvent = true; |
| passiveX = (int)point.x; |
| passiveY = (int)point.y; |
| gBlock.NewEvent(); |
| } |
| } |
| } |
| |
| /*********************************************************** |
| * CLASS: GlutWindow |
| * |
| * FUNCTION: FrameResized |
| * |
| * DESCRIPTION: handles reshape event |
| ***********************************************************/ |
| void GlutWindow::FrameResized(float width, float height) |
| { |
| BGLView::FrameResized(width, height); |
| if (visible) { |
| anyevents = reshapeEvent = true; |
| m_width = (int)(width)+1; |
| m_height = (int)(height)+1; |
| gBlock.NewEvent(); |
| } |
| } |
| |
| /*********************************************************** |
| * CLASS: GlutWindow |
| * |
| * FUNCTION: Draw |
| * |
| * DESCRIPTION: handles reshape and display events |
| ***********************************************************/ |
| void GlutWindow::Draw(BRect updateRect) |
| { |
| BGLView::Draw(updateRect); |
| BRect frame = Frame(); |
| if (m_width != (frame.Width()+1) || m_height != (frame.Height()+1)) { |
| FrameResized(frame.Width(), frame.Height()); |
| } |
| Window()->Lock(); |
| if (visible) { |
| anyevents = displayEvent = true; |
| gBlock.NewEvent(); |
| } |
| Window()->Unlock(); |
| } |
| |
| /*********************************************************** |
| * CLASS: GlutWindow |
| * |
| * FUNCTION: Pulse |
| * |
| * DESCRIPTION: handles mouse up event (MouseUp is broken) |
| ***********************************************************/ |
| void GlutWindow::Pulse() |
| { |
| BGLView::Pulse(); |
| if (m_buttons) { // if there are buttons pressed |
| MouseCheck(); |
| } |
| } |
| |
| /*********************************************************** |
| * CLASS: GlutWindow |
| * |
| * FUNCTION: ErrorCallback |
| * |
| * DESCRIPTION: handles GL error messages |
| ***********************************************************/ |
| void GlutWindow::ErrorCallback(GLenum errorCode) { |
| __glutWarning("GL error: %s", gluErrorString(errorCode)); |
| } |
| |
| /*********************************************************** |
| * CLASS: GlutWindow |
| * |
| * FUNCTION: MenuThread |
| * |
| * DESCRIPTION: a new thread to launch popup menu, wait |
| * wait for response, then clean up afterwards and |
| * send appropriate messages |
| ***********************************************************/ |
| long GlutWindow::MenuThread(void *m) { |
| GlutPopUp *bmenu = static_cast<GlutPopUp*>(m); |
| GlutWindow *win = bmenu->win; // my window |
| GlutBMenuItem *result = (GlutBMenuItem*)bmenu->Go(bmenu->point); |
| win->Window()->Lock(); |
| win->anyevents = win->statusEvent = true; |
| win->menuStatus = GLUT_MENU_NOT_IN_USE; |
| win->menuNumber = bmenu->menu; |
| BPoint cursor; |
| uint32 buttons; |
| win->GetMouse(&cursor, &buttons); |
| win->statusX = (int)cursor.x; |
| win->statusY = (int)cursor.y; |
| if(result && result->menu) { |
| win->menuEvent = true; |
| win->menuNumber = result->menu; // in case it was a submenu |
| win->menuValue = result->value; |
| } |
| win->Window()->Unlock(); |
| gBlock.NewEvent(); |
| delete bmenu; |
| return 0; |
| } |
