From: Philippe Houdoin Date: Sat, 14 Aug 2004 10:27:08 +0000 (+0000) Subject: Update to Jake Hamby's BeOS GLUT 3.7 port. X-Git-Url: https://git.libre-soc.org/?a=commitdiff_plain;h=a041e62418a72f0fd379e50263e1c9d2e6c6bb55;p=mesa.git Update to Jake Hamby's BeOS GLUT 3.7 port. --- diff --git a/src/glut/beos/beos_x11.cpp b/src/glut/beos/beos_x11.cpp index 20c75036d55..2d1bc655cbd 100644 --- a/src/glut/beos/beos_x11.cpp +++ b/src/glut/beos/beos_x11.cpp @@ -37,6 +37,8 @@ suitability of this software for any purpose. It is provided "as is" without express or implied warranty. */ +#if 0 // Not used currently... + /* *Returns pointer to first char ins search which is also in what, else NULL. */ @@ -45,13 +47,16 @@ static char *strscan (char *search, char *what) int i, len = strlen (what); char c; - while ((c = *(search++)) != (int)NULL) + while ((c = *(search++))) { for (i = 0; i < len; i++) if (c == what [i]) return (--search); + } return (NULL); } +#endif + /* * XParseGeometry parses strings of the form * "=x{+-}{+-}", where diff --git a/src/glut/beos/glutBlocker.cpp b/src/glut/beos/glutBlocker.cpp index e2cfcf7b393..aa948522b9b 100644 --- a/src/glut/beos/glutBlocker.cpp +++ b/src/glut/beos/glutBlocker.cpp @@ -1,5 +1,9 @@ /*********************************************************** - * Copyright (C) 1997, Be Inc. All rights reserved. + * 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: glutBlocker.cpp * diff --git a/src/glut/beos/glutBlocker.h b/src/glut/beos/glutBlocker.h index e6d1f4e049f..fc9e4cc309b 100644 --- a/src/glut/beos/glutBlocker.h +++ b/src/glut/beos/glutBlocker.h @@ -1,5 +1,9 @@ /*********************************************************** - * Copyright (C) 1997, Be Inc. All rights reserved. + * 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: glutBlocker.h * @@ -40,4 +44,4 @@ private: /*********************************************************** * Global variable ***********************************************************/ -extern GlutBlocker gBlock; \ No newline at end of file +extern GlutBlocker gBlock; diff --git a/src/glut/beos/glutCallback.cpp b/src/glut/beos/glutCallback.cpp index 82707d5db25..cf3daaaf36f 100644 --- a/src/glut/beos/glutCallback.cpp +++ b/src/glut/beos/glutCallback.cpp @@ -1,5 +1,10 @@ /*********************************************************** - * Copyright (C) 1997, Be Inc. All rights reserved. + * 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: glutCallback.cpp * @@ -65,10 +70,29 @@ glutEntryFunc(GLUTentryCB entryFunc) } } +void APIENTRY +glutWindowStatusFunc(GLUTwindowStatusCB windowStatusFunc) +{ + gState.currentWindow->windowStatus = windowStatusFunc; +} + +static void +visibilityHelper(int status) +{ + if (status == GLUT_HIDDEN || status == GLUT_FULLY_COVERED) + gState.currentWindow->visibility(GLUT_NOT_VISIBLE); + else + gState.currentWindow->visibility(GLUT_VISIBLE); +} + void APIENTRY glutVisibilityFunc(GLUTvisibilityCB visibilityFunc) { gState.currentWindow->visibility = visibilityFunc; + if (visibilityFunc) + glutWindowStatusFunc(visibilityHelper); + else + glutWindowStatusFunc(NULL); } void APIENTRY @@ -144,4 +168,4 @@ glutTabletMotionFunc(GLUTtabletMotionCB tabletMotionFunc) void APIENTRY glutTabletButtonFunc(GLUTtabletButtonCB tabletButtonFunc) { -} \ No newline at end of file +} diff --git a/src/glut/beos/glutColor.cpp b/src/glut/beos/glutColor.cpp index 5979deafca4..d9f7739ae5a 100644 --- a/src/glut/beos/glutColor.cpp +++ b/src/glut/beos/glutColor.cpp @@ -1,5 +1,10 @@ /*********************************************************** - * Copyright (C) 1997, Be Inc. All rights reserved. + * 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: glutColor.cpp * @@ -24,4 +29,4 @@ GLfloat glutGetColor(int cell, int component) { void glutCopyColormap(int win) { __glutWarning("glutCopyColormap: color index not supported in BeOS"); -} \ No newline at end of file +} diff --git a/src/glut/beos/glutCursor.cpp b/src/glut/beos/glutCursor.cpp index e8debe800e0..3081fff44b3 100644 --- a/src/glut/beos/glutCursor.cpp +++ b/src/glut/beos/glutCursor.cpp @@ -1,5 +1,10 @@ /*********************************************************** - * Copyright (C) 1997, Be Inc. All rights reserved. + * 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: glutCursor.cpp * @@ -82,4 +87,4 @@ void __glutSetCursor(int cursor) { * DESCRIPTION: move the mouse pointer to a new location * (note: can't do this in BeOS!) ***********************************************************/ -void glutWarpPointer(int x, int y) { } \ No newline at end of file +void glutWarpPointer(int x, int y) { } diff --git a/src/glut/beos/glutDstr.cpp b/src/glut/beos/glutDstr.cpp index c594cfdafd5..281a0397017 100644 --- a/src/glut/beos/glutDstr.cpp +++ b/src/glut/beos/glutDstr.cpp @@ -1,5 +1,10 @@ /*********************************************************** - * Copyright (C) 1997, Be Inc. All rights reserved. + * 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: glutDstr.cpp * @@ -46,8 +51,7 @@ glutInitDisplayString(const char *string) * RETURNS: 1 if the current display mode is possible, else 0 ***********************************************************/ int __glutConvertDisplayModeFromString(unsigned long *options) { - ulong newoptions = BGL_DOUBLE; - gState.swapHack = true; // assume single buffered + ulong newoptions = 0; char *word = strtok(gState.displayString, " \t"); do { @@ -66,7 +70,7 @@ int __glutConvertDisplayModeFromString(unsigned long *options) { } else if(!strcmp(word, "depth")) { newoptions |= BGL_DEPTH; } else if(!strcmp(word, "double")) { - gState.swapHack = false; + newoptions |= BGL_DOUBLE; } else if(!strcmp(word, "stencil")) { newoptions |= BGL_STENCIL; } diff --git a/src/glut/beos/glutEvent.cpp b/src/glut/beos/glutEvent.cpp index 20b1cad23f4..cffbc1aa543 100644 --- a/src/glut/beos/glutEvent.cpp +++ b/src/glut/beos/glutEvent.cpp @@ -1,5 +1,10 @@ /*********************************************************** - * Copyright (C) 1997, Be Inc. All rights reserved. + * 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 * @@ -111,12 +116,14 @@ processEventsAndTimeouts(void) // 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; iWindow()->Lock(); // 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 @@ -134,11 +141,6 @@ processEventsAndTimeouts(void) win->displayEvent = false; __glutSetWindow(win); win->display(); - if (gState.windowList[i] && win->swapHack) { - // fake single buffering by swapping buffers - __glutSetWindow(win); - win->SwapBuffers(); - } } if (!gState.windowList[i]) continue; // window was destroyed by callback! @@ -229,17 +231,15 @@ processEventsAndTimeouts(void) if (!gState.windowList[i]) continue; // window was destroyed by callback! - if (win->visEvent) { - win->visEvent = false; + if (win->windowStatusEvent) { + win->windowStatusEvent = false; __glutSetWindow(win); - if (win->visibility) - win->visibility(win->visState); + if (win->windowStatus) + win->windowStatus(win->visState); } if (!gState.windowList[i]) continue; // window was destroyed by callback! } - if(gState.windowList[i]) // window hasn't been destroyed - win->Window()->Unlock(); } } if (gState.currentWindow) @@ -304,8 +304,9 @@ idleWait(void) /* Make sure idle func still exists! */ if(gState.currentWindow) gState.currentWindow->LockGL(); - if (gState.idle) + if (gState.idle) { gState.idle(); + } if(gState.currentWindow) gState.currentWindow->UnlockGL(); } @@ -604,7 +605,7 @@ void GlutWindow::MouseMoved(BPoint point, void GlutWindow::FrameResized(float width, float height) { BGLView::FrameResized(width, height); - if (visState == GLUT_VISIBLE) { + if (visible) { anyevents = reshapeEvent = true; m_width = (int)(width)+1; m_height = (int)(height)+1; @@ -626,39 +627,12 @@ void GlutWindow::Draw(BRect updateRect) if (m_width != (frame.Width()+1) || m_height != (frame.Height()+1)) { FrameResized(frame.Width(), frame.Height()); } - if (visState == GLUT_VISIBLE) { + Window()->Lock(); + if (visible) { anyevents = displayEvent = true; gBlock.NewEvent(); } -} - -/*********************************************************** - * CLASS: GlutWindow - * - * FUNCTION: Hide - * Show - * - * DESCRIPTION: handles visibility event - ***********************************************************/ -void GlutWindow::Hide() -{ - BGLView::Hide(); - if (visibility) { - anyevents = visEvent = true; - visState = GLUT_NOT_VISIBLE; - displayEvent = false; // display callbacks not allowed when hidden - gBlock.NewEvent(); - } -} - -void GlutWindow::Show() -{ - BGLView::Show(); - if (visibility) { - anyevents = visEvent = true; - visState = GLUT_VISIBLE; - gBlock.NewEvent(); - } + Window()->Unlock(); } /*********************************************************** diff --git a/src/glut/beos/glutGet.cpp b/src/glut/beos/glutGet.cpp index 33355afb835..45d07f7e46a 100644 --- a/src/glut/beos/glutGet.cpp +++ b/src/glut/beos/glutGet.cpp @@ -1,5 +1,10 @@ /*********************************************************** - * Copyright (C) 1997, Be Inc. All rights reserved. + * 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: glutGet.cpp * @@ -12,6 +17,8 @@ #include #include #include +#include + #include "glutint.h" #include "glutState.h" diff --git a/src/glut/beos/glutInit.cpp b/src/glut/beos/glutInit.cpp index 9aa0f4787d9..401081328f8 100644 --- a/src/glut/beos/glutInit.cpp +++ b/src/glut/beos/glutInit.cpp @@ -1,5 +1,10 @@ /*********************************************************** - * Copyright (C) 1997, Be Inc. All rights reserved. + * 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: glutInit.cpp * @@ -12,14 +17,17 @@ #include #include #include +#include #include "glutint.h" #include "glutState.h" +#include "glutBlocker.h" #include "beos_x11.h" /*********************************************************** * Global variables ***********************************************************/ GlutState gState; +char *__glutProgramName = NULL; /*********************************************************** * Private variables @@ -72,6 +80,16 @@ static int32 bAppThread(void *arg) { return be_app->Run(); } +/*********************************************************** + * FUNCTION: sigHandler + * + * DESCRIPTION: shuts down the app on CTRL-C + ***********************************************************/ +static void sigHandler(int) { + gState.quitAll = true; + gBlock.NewEvent(); +} + /*********************************************************** * FUNCTION: glutInit (2.1) * @@ -89,9 +107,9 @@ void glutInit(int *argcp, char **argv) { /* Determine temporary program name. */ str = strrchr(argv[0], '/'); if (str == NULL) { - gState.programName = argv[0]; + __glutProgramName = argv[0]; } else { - gState.programName = str + 1; + __glutProgramName = str + 1; } /* Make private copy of command line arguments. */ @@ -108,9 +126,9 @@ void glutInit(int *argcp, char **argv) { /* determine permanent program name */ str = strrchr(__glutArgv[0], '/'); if (str == NULL) { - gState.programName = __glutArgv[0]; + __glutProgramName = __glutArgv[0]; } else { - gState.programName = str + 1; + __glutProgramName = str + 1; } /* parse arguments for standard options */ @@ -201,11 +219,18 @@ void __glutInit() { // open BApplication gState.display = new BApplication("application/x-glut-demo"); be_app->Unlock(); - thread_id appthread = spawn_thread(bAppThread, "BApplication", B_NORMAL_PRIORITY, 0); - resume_thread(appthread); + gState.appthread = spawn_thread(bAppThread, "BApplication", B_NORMAL_PRIORITY, 0); + resume_thread(gState.appthread); bigtime_t unused; __glutInitTime(&unused); + + /* set atexit() function to destroy all windows before exiting */ + if(atexit(__glutDestroyAllWindows)) + __glutFatalError("can't set exit handler"); + + /* similarly, destroy all windows on CTRL-C */ + signal(SIGINT, sigHandler); } /*********************************************************** diff --git a/src/glut/beos/glutMenu.cpp b/src/glut/beos/glutMenu.cpp index 1dad5970c9d..2f9e6a2c67c 100644 --- a/src/glut/beos/glutMenu.cpp +++ b/src/glut/beos/glutMenu.cpp @@ -1,5 +1,9 @@ /*********************************************************** - * Copyright (C) 1997, Be Inc. All rights reserved. + * 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: glutMenu.cpp * diff --git a/src/glut/beos/glutMenu.h b/src/glut/beos/glutMenu.h index f61b9aaaf76..1ee170694b8 100644 --- a/src/glut/beos/glutMenu.h +++ b/src/glut/beos/glutMenu.h @@ -1,5 +1,9 @@ /*********************************************************** - * Copyright (C) 1997, Be Inc. All rights reserved. + * 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: glutMenu.h * @@ -12,6 +16,7 @@ #include #include #include +#include /*********************************************************** * Definitions diff --git a/src/glut/beos/glutOverlay.cpp b/src/glut/beos/glutOverlay.cpp index eaabb8373ad..fed757fe954 100644 --- a/src/glut/beos/glutOverlay.cpp +++ b/src/glut/beos/glutOverlay.cpp @@ -1,5 +1,10 @@ /*********************************************************** - * Copyright (C) 1997, Be Inc. All rights reserved. + * 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: glutOverlay.cpp * @@ -35,4 +40,8 @@ void glutShowOverlay() { void glutHideOverlay() { // ignore -} \ No newline at end of file +} + +void glutPostWindowOverlayRedisplay(int win) { + // ignore +} diff --git a/src/glut/beos/glutState.h b/src/glut/beos/glutState.h index c9a9a52127e..9c44eb6b53a 100644 --- a/src/glut/beos/glutState.h +++ b/src/glut/beos/glutState.h @@ -1,5 +1,10 @@ /*********************************************************** - * Copyright (C) 1997, Be Inc. All rights reserved. + * 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: glutState.h * @@ -22,7 +27,8 @@ ***********************************************************/ struct GlutState { BApplication *display; - char *programName; // used in error messages + thread_id appthread; + int initX, initY; // initial window position int initWidth, initHeight; // initial window size unsigned int displayMode; // initial display mode @@ -39,11 +45,11 @@ struct GlutState { int modifierKeys; // only valid during keyboard callback bool debug; // call glGetError - bool swapHack; + bool quitAll; // quit GlutState() { display = 0; - programName = 0; + appthread = 0; initX = initY = -1; initWidth = initHeight = 300; displayMode = GLUT_RGB | GLUT_SINGLE | GLUT_DEPTH; @@ -55,11 +61,11 @@ struct GlutState { idle = 0; menuStatus = 0; modifierKeys = ~0; - debug = swapHack = false; + debug = quitAll = false; } }; /*********************************************************** * Global variable (declared in glutInit.cpp) ***********************************************************/ -extern GlutState gState; \ No newline at end of file +extern GlutState gState; diff --git a/src/glut/beos/glutWindow.cpp b/src/glut/beos/glutWindow.cpp index dbdd3b84a88..66ea2a00a83 100644 --- a/src/glut/beos/glutWindow.cpp +++ b/src/glut/beos/glutWindow.cpp @@ -1,5 +1,10 @@ /*********************************************************** - * Copyright (C) 1997, Be Inc. All rights reserved. + * 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: glutWindow.cpp * @@ -117,10 +122,8 @@ GlutWindow::GlutWindow(GlutWindow *nparent, char *name, keyboard = 0; visibility = 0; special = 0; - - // faked out single buffering - swapHack = gState.swapHack; - + windowStatus = 0; + // clear event counters anyevents = 1; displayEvent = 1; // get a reshape and a display event right away @@ -130,11 +133,12 @@ GlutWindow::GlutWindow(GlutWindow *nparent, char *name, passiveEvent = 0; entryEvent = 0; keybEvent = 0; - visEvent = 1; // we also get a visibility event - visState = GLUT_VISIBLE; + windowStatusEvent = 0; // DirectConnected() will report change in + visState = -1; // visibility specialEvent = 0; statusEvent = 0; menuEvent = 0; + visible = true; gBlock.QuickNewEvent(); // if i'm a subwindow, add me to my parent view @@ -147,6 +151,7 @@ GlutWindow::GlutWindow(GlutWindow *nparent, char *name, GlutBWindow *mybwindow = new GlutBWindow( BRect(x,y,x+width-1,y+height-1), name); mybwindow->AddChild(this); + mybwindow->bgl = this; mybwindow->Show(); } @@ -291,22 +296,27 @@ __glutDestroyWindow(GlutWindow *window, GlutWindow *initialWindow) { ***********************************************************/ void glutDestroyWindow(int win) { // can't destroy a window if another window has the GL context - gState.currentWindow->UnlockGL(); - + if (gState.currentWindow) + gState.currentWindow->UnlockGL(); + // lock the window GlutWindow *window = gState.windowList[win-1]; BWindow *bwindow = window->Window(); bwindow->Lock(); - // if win is the current window, set current window to 0 and unlock GL + // if win is the current window, set current window to 0 if (gState.currentWindow == window) { - gState.currentWindow = 0; } // recursively set child entries to 0 __glutDestroyWindow(window, window); - + + // try flushing OpenGL + window->LockGL(); + glFlush(); + window->UnlockGL(); + // now, if the window was top-level, delete its BWindow if(!window->parent) { bwindow->Quit(); @@ -316,12 +326,30 @@ void glutDestroyWindow(int win) { delete window; bwindow->Unlock(); } - // relock GL if the current window is still valid if(gState.currentWindow) gState.currentWindow->LockGL(); } +/*********************************************************** + * FUNCTION: __glutDestroyAllWindows + * + * DESCRIPTION: destroy all windows when exit() is called + * this seems to be necessary to avoid delays + * and crashes when using BDirectWindow + ***********************************************************/ +void __glutDestroyAllWindows() { + for(int i=0; iLock(); + gState.display->Quit(); + status_t ignored; + wait_for_thread(gState.appthread, &ignored); +} + /*********************************************************** * FUNCTION: glutPostRedisplay (4.5) * @@ -335,6 +363,20 @@ void glutPostRedisplay() { gBlock.QuickNewEvent(); } +/*********************************************************** + * FUNCTION: glutPostWindowRedisplay + * + * DESCRIPTION: mark window as needing redisplay + ***********************************************************/ +void glutPostWindowRedisplay(int win) { + GlutWindow *gwin = gState.windowList[win - 1]; + gwin->Window()->Lock(); + gwin->anyevents = true; + gwin->displayEvent = true; + gwin->Window()->Unlock(); + gBlock.QuickNewEvent(); +} + /*********************************************************** * FUNCTION: glutSwapBuffers (4.6) * @@ -350,12 +392,17 @@ void glutSwapBuffers() { * DESCRIPTION: move window ***********************************************************/ void glutPositionWindow(int x, int y) { - gState.currentWindow->Window()->Lock(); + BDirectWindow *win = dynamic_cast(gState.currentWindow->Window()); + win->Lock(); if (gState.currentWindow->parent) gState.currentWindow->MoveTo(x, y); // move the child view - else - gState.currentWindow->Window()->MoveTo(x, y); // move the window - gState.currentWindow->Window()->Unlock(); + else { + if(win->IsFullScreen()) { + win->SetFullScreen(false); + } + win->MoveTo(x, y); // move the window + } + win->Unlock(); } /*********************************************************** @@ -365,26 +412,29 @@ void glutPositionWindow(int x, int y) { * when the view gets a Draw() message ***********************************************************/ void glutReshapeWindow(int width, int height) { - gState.currentWindow->Window()->Lock(); + BDirectWindow *win = dynamic_cast(gState.currentWindow->Window()); + win->Lock(); if (gState.currentWindow->parent) gState.currentWindow->ResizeTo(width-1, height-1); // resize the child - else - gState.currentWindow->Window()->ResizeTo(width-1, height-1); // resize the parent - gState.currentWindow->Window()->Unlock(); + else { + if(win->IsFullScreen()) { + win->SetFullScreen(false); + } + win->ResizeTo(width-1, height-1); // resize the parent + } + win->Unlock(); } /*********************************************************** * FUNCTION: glutFullScreen (4.9) * * DESCRIPTION: makes the window full screen - * NOTE: we could add Game Kit support later? ***********************************************************/ void glutFullScreen() { - gState.currentWindow->Window()->Lock(); - BRect frame = BScreen(gState.currentWindow->Window()).Frame(); - glutPositionWindow(0, 0); - glutReshapeWindow((int)(frame.Width()) + 1, (int)(frame.Height()) + 1); - gState.currentWindow->Window()->Unlock(); + BDirectWindow *win = dynamic_cast(gState.currentWindow->Window()); + win->Lock(); + win->SetFullScreen(true); + win->Unlock(); } /*********************************************************** @@ -411,7 +461,8 @@ void glutShowWindow() { if (gState.currentWindow->parent) // subwindow gState.currentWindow->Show(); else { - gState.currentWindow->Window()->Show(); // show the actual BWindow + if(gState.currentWindow->Window()->IsHidden()) + gState.currentWindow->Window()->Show(); // show the actual BWindow gState.currentWindow->Window()->Minimize(false); } gState.currentWindow->Window()->Unlock(); @@ -476,21 +527,20 @@ int __glutConvertDisplayMode(unsigned long *options) { } if(options) { - ulong newoptions = BGL_DOUBLE; + ulong newoptions = 0; if(gState.displayMode & GLUT_ACCUM) newoptions |= BGL_ACCUM; if(gState.displayMode & GLUT_ALPHA) newoptions |= BGL_ALPHA; if(gState.displayMode & GLUT_DEPTH) newoptions |= BGL_DEPTH; + if(gState.displayMode & GLUT_DOUBLE) + newoptions |= BGL_DOUBLE; if(gState.displayMode & GLUT_STENCIL) newoptions |= BGL_STENCIL; *options = newoptions; } - // if not GLUT_DOUBLE, turn on the swap hack bit - gState.swapHack = !(gState.displayMode & GLUT_DOUBLE); - if(gState.displayMode & GLUT_INDEX) { __glutWarning("BeOS doesn't support indexed color"); return 0; @@ -515,11 +565,69 @@ int __glutConvertDisplayMode(unsigned long *options) { * DESCRIPTION: very thin wrapper around BWindow ***********************************************************/ GlutBWindow::GlutBWindow(BRect frame, char *name) : - BWindow(frame, name, B_TITLED_WINDOW, 0) { + BDirectWindow(frame, name, B_TITLED_WINDOW, 0) { + fConnectionDisabled = false; + bgl = 0; SetPulseRate(100000); + + if (!SupportsWindowMode()) { + __glutFatalError("video card doesn't support windowed operation"); + } } +void GlutBWindow::DirectConnected( direct_buffer_info *info ) { + bgl->DirectConnected(info); + if(bgl && !fConnectionDisabled) { + bgl->EnableDirectMode(true); + } + int newVisState; + if((info->buffer_state & B_DIRECT_MODE_MASK) == B_DIRECT_START) { + bgl->visible = true; + } + if(!bgl->visible || info->buffer_state == B_DIRECT_STOP) + newVisState = GLUT_HIDDEN; + else { + if (info->clip_list_count == 0) + newVisState = GLUT_FULLY_COVERED; + else if (info->clip_list_count == 1) + newVisState = GLUT_FULLY_RETAINED; + else + newVisState = GLUT_PARTIALLY_RETAINED; + } + if(newVisState != bgl->visState) { + bgl->visState = newVisState; + bgl->anyevents = bgl->windowStatusEvent = true; + gBlock.NewEvent(); + } +} + +GlutBWindow::~GlutBWindow() { + fConnectionDisabled = true; + if(bgl) { + bgl->EnableDirectMode(false); + } + if(!IsHidden()) + Hide(); + Sync(); +} + bool GlutBWindow::QuitRequested() { - exit(0); // exit program completely on quit - return true; // UNREACHED + gState.quitAll = true; + gBlock.NewEvent(); + return false; // don't quit now, wait for main thread to do it +} + +void GlutBWindow::Minimize(bool minimize) { + bgl->visible = !minimize; + BWindow::Minimize(minimize); +} + +void GlutBWindow::Hide() { + BWindow::Hide(); + bgl->visible = false; +} + +void GlutBWindow::Show() { + BWindow::Show(); + bgl->visible = true; } diff --git a/src/glut/beos/glutWindow.h b/src/glut/beos/glutWindow.h index 7a4292e7331..d3ac1862695 100644 --- a/src/glut/beos/glutWindow.h +++ b/src/glut/beos/glutWindow.h @@ -1,5 +1,10 @@ /*********************************************************** - * Copyright (C) 1997, Be Inc. All rights reserved. + * 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: glutWindow.h * @@ -32,8 +37,6 @@ public: void MouseMoved(BPoint point, uint32 transit, const BMessage *message); void FrameResized(float width, float height); void Draw(BRect updateRect); - void Hide(); - void Show(); void Pulse(); // needed since MouseUp() is broken void MouseCheck(); // check for button state changes void ErrorCallback(GLenum errorCode); @@ -62,6 +65,7 @@ public: GLUTkeyboardCB keyboard; /* keyboard (ASCII,x,y) */ GLUTvisibilityCB visibility; /* visibility */ GLUTspecialCB special; /* special key */ + GLUTwindowStatusCB windowStatus; /* window status */ bool anyevents; // were any events received? bool displayEvent; // call display @@ -71,13 +75,11 @@ public: bool passiveEvent; // call passive bool entryEvent; // call entry bool keybEvent; // call keyboard - bool visEvent; // call visibility + bool windowStatusEvent; // call visibility bool specialEvent; // call special bool statusEvent; // menu status changed bool menuEvent; // menu selected - bool swapHack; // faked out single buffering - int button, mouseState; // for mouse callback int mouseX, mouseY; // for mouse callback int motionX, motionY; // for motion callback @@ -93,17 +95,25 @@ public: int statusX, statusY; // for status callback int menuNumber; // for menu and status callbacks int menuValue; // for menu callback + bool visible; // for visibility callback }; /*********************************************************** * CLASS: GlutBWindow * - * INHERITS FROM: BWindow + * INHERITS FROM: BDirectWindow * * DESCRIPTION: basically a BWindow that won't quit ***********************************************************/ -class GlutBWindow : public BWindow { +class GlutBWindow : public BDirectWindow { public: GlutBWindow(BRect frame, char *name); + ~GlutBWindow(); + void DirectConnected(direct_buffer_info *info); bool QuitRequested(); // exits app -}; \ No newline at end of file + void Minimize(bool minimized); // minimized windows are not visible + void Hide(); + void Show(); + GlutWindow *bgl; + bool fConnectionDisabled; +}; diff --git a/src/glut/beos/glutbitmap.h b/src/glut/beos/glutbitmap.h index 55d341706cb..32bf53c097b 100644 --- a/src/glut/beos/glutbitmap.h +++ b/src/glut/beos/glutbitmap.h @@ -7,12 +7,7 @@ and is provided without guarantee or warrantee expressed or implied. This program is -not- in the public domain. */ - -#if defined(WIN32) -#include -#pragma warning(disable:4244) -#endif /* WIN32 */ -#include +#include typedef struct { const GLsizei width; diff --git a/src/glut/beos/glutint.h b/src/glut/beos/glutint.h index 5ce2970d24f..06b417e9ca8 100644 --- a/src/glut/beos/glutint.h +++ b/src/glut/beos/glutint.h @@ -1,18 +1,253 @@ -/*********************************************************** - * Copyright (C) 1997, Be Inc. All rights reserved. - * - * FILE: glutint.h - * - * DESCRIPTION: This is the new glut internal header file. - * most of the things formerly stored here are now in - * their own header files as C++ classes. - ***********************************************************/ +#ifndef __glutint_h__ +#define __glutint_h__ -#include +/* Copyright (c) Mark J. Kilgard, 1994, 1997, 1998. */ + +/* 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. */ + +#if defined(__CYGWIN32__) +#include +#endif + +#if defined(_WIN32) +#include "glutwin32.h" +#elif !defined(__BEOS__) +#ifdef __sgi +#define SUPPORT_FORTRAN +#endif +#include +#include +#include +#endif + +#include + +/* Non-Win32 platforms need APIENTRY defined to nothing + because all the GLUT routines have the APIENTRY prefix + to make Win32 happy. */ +#ifndef APIENTRY +#define APIENTRY +#endif + +#ifdef __vms +#if ( __VMS_VER < 70000000 ) +struct timeval { + __int64 val; +}; +extern int sys$gettim(struct timeval *); +#else +#include +#endif +#else +#include +#if !defined(_WIN32) +#include +#else +#include +#endif +#endif +#if defined(__vms) && ( __VMS_VER < 70000000 ) + +/* For VMS6.2 or lower : + One TICK on VMS is 100 nanoseconds; 0.1 microseconds or + 0.0001 milliseconds. This means that there are 0.01 + ticks/ns, 10 ticks/us, 10,000 ticks/ms and 10,000,000 + ticks/second. */ + +#define TICKS_PER_MILLISECOND 10000 +#define TICKS_PER_SECOND 10000000 + +#define GETTIMEOFDAY(_x) (void) sys$gettim (_x); + +#define ADD_TIME(dest, src1, src2) { \ + (dest).val = (src1).val + (src2).val; \ +} + +#define TIMEDELTA(dest, src1, src2) { \ + (dest).val = (src1).val - (src2).val; \ +} + +#define IS_AFTER(t1, t2) ((t2).val > (t1).val) + +#define IS_AT_OR_AFTER(t1, t2) ((t2).val >= (t1).val) + +#else +#if defined(SVR4) && !defined(sun) /* Sun claims SVR4, but + wants 2 args. */ +#define GETTIMEOFDAY(_x) gettimeofday(_x) +#else +#define GETTIMEOFDAY(_x) gettimeofday(_x, NULL) +#endif +#define ADD_TIME(dest, src1, src2) { \ + if(((dest).tv_usec = \ + (src1).tv_usec + (src2).tv_usec) >= 1000000) { \ + (dest).tv_usec -= 1000000; \ + (dest).tv_sec = (src1).tv_sec + (src2).tv_sec + 1; \ + } else { \ + (dest).tv_sec = (src1).tv_sec + (src2).tv_sec; \ + if(((dest).tv_sec >= 1) && (((dest).tv_usec <0))) { \ + (dest).tv_sec --;(dest).tv_usec += 1000000; \ + } \ + } \ +} +#define TIMEDELTA(dest, src1, src2) { \ + if(((dest).tv_usec = (src1).tv_usec - (src2).tv_usec) < 0) { \ + (dest).tv_usec += 1000000; \ + (dest).tv_sec = (src1).tv_sec - (src2).tv_sec - 1; \ + } else { \ + (dest).tv_sec = (src1).tv_sec - (src2).tv_sec; \ + } \ +} +#define IS_AFTER(t1, t2) \ + (((t2).tv_sec > (t1).tv_sec) || \ + (((t2).tv_sec == (t1).tv_sec) && \ + ((t2).tv_usec > (t1).tv_usec))) +#define IS_AT_OR_AFTER(t1, t2) \ + (((t2).tv_sec > (t1).tv_sec) || \ + (((t2).tv_sec == (t1).tv_sec) && \ + ((t2).tv_usec >= (t1).tv_usec))) +#endif + +#define IGNORE_IN_GAME_MODE() \ + { if (__glutGameModeWindow) return; } + +/* BeOS doesn't need most of this file */ +#ifndef __BEOS__ + +#define GLUT_WIND_IS_RGB(x) (((x) & GLUT_INDEX) == 0) +#define GLUT_WIND_IS_INDEX(x) (((x) & GLUT_INDEX) != 0) +#define GLUT_WIND_IS_SINGLE(x) (((x) & GLUT_DOUBLE) == 0) +#define GLUT_WIND_IS_DOUBLE(x) (((x) & GLUT_DOUBLE) != 0) +#define GLUT_WIND_HAS_ACCUM(x) (((x) & GLUT_ACCUM) != 0) +#define GLUT_WIND_HAS_ALPHA(x) (((x) & GLUT_ALPHA) != 0) +#define GLUT_WIND_HAS_DEPTH(x) (((x) & GLUT_DEPTH) != 0) +#define GLUT_WIND_HAS_STENCIL(x) (((x) & GLUT_STENCIL) != 0) +#define GLUT_WIND_IS_MULTISAMPLE(x) (((x) & GLUT_MULTISAMPLE) != 0) +#define GLUT_WIND_IS_STEREO(x) (((x) & GLUT_STEREO) != 0) +#define GLUT_WIND_IS_LUMINANCE(x) (((x) & GLUT_LUMINANCE) != 0) +#define GLUT_MAP_WORK (1 << 0) +#define GLUT_EVENT_MASK_WORK (1 << 1) +#define GLUT_REDISPLAY_WORK (1 << 2) +#define GLUT_CONFIGURE_WORK (1 << 3) +#define GLUT_COLORMAP_WORK (1 << 4) +#define GLUT_DEVICE_MASK_WORK (1 << 5) +#define GLUT_FINISH_WORK (1 << 6) +#define GLUT_DEBUG_WORK (1 << 7) +#define GLUT_DUMMY_WORK (1 << 8) +#define GLUT_FULL_SCREEN_WORK (1 << 9) +#define GLUT_OVERLAY_REDISPLAY_WORK (1 << 10) +#define GLUT_REPAIR_WORK (1 << 11) +#define GLUT_OVERLAY_REPAIR_WORK (1 << 12) + +/* Frame buffer capability macros and types. */ +#define RGBA 0 +#define BUFFER_SIZE 1 +#define DOUBLEBUFFER 2 +#define STEREO 3 +#define AUX_BUFFERS 4 +#define RED_SIZE 5 /* Used as mask bit for + "color selected". */ +#define GREEN_SIZE 6 +#define BLUE_SIZE 7 +#define ALPHA_SIZE 8 +#define DEPTH_SIZE 9 +#define STENCIL_SIZE 10 +#define ACCUM_RED_SIZE 11 /* Used as mask bit for + "acc selected". */ +#define ACCUM_GREEN_SIZE 12 +#define ACCUM_BLUE_SIZE 13 +#define ACCUM_ALPHA_SIZE 14 +#define LEVEL 15 -/*********************************************************** - * GLUT function types - ***********************************************************/ +#define NUM_GLXCAPS (LEVEL + 1) + +#define XVISUAL (NUM_GLXCAPS + 0) +#define TRANSPARENT (NUM_GLXCAPS + 1) +#define SAMPLES (NUM_GLXCAPS + 2) +#define XSTATICGRAY (NUM_GLXCAPS + 3) /* Used as + mask bit + for "any + visual type + selected". */ +#define XGRAYSCALE (NUM_GLXCAPS + 4) +#define XSTATICCOLOR (NUM_GLXCAPS + 5) +#define XPSEUDOCOLOR (NUM_GLXCAPS + 6) +#define XTRUECOLOR (NUM_GLXCAPS + 7) +#define XDIRECTCOLOR (NUM_GLXCAPS + 8) +#define SLOW (NUM_GLXCAPS + 9) +#define CONFORMANT (NUM_GLXCAPS + 10) + +#define NUM_CAPS (NUM_GLXCAPS + 11) + +/* Frame buffer capablities that don't have a corresponding + FrameBufferMode entry. These get used as mask bits. */ +#define NUM (NUM_CAPS + 0) +#define RGBA_MODE (NUM_CAPS + 1) +#define CI_MODE (NUM_CAPS + 2) +#define LUMINANCE_MODE (NUM_CAPS + 3) + +#define NONE 0 +#define EQ 1 +#define NEQ 2 +#define LTE 3 +#define GTE 4 +#define GT 5 +#define LT 6 +#define MIN 7 + +typedef struct _Criterion { + int capability; + int comparison; + int value; +} Criterion; + +typedef struct _FrameBufferMode { + XVisualInfo *vi; +#if defined(GLX_VERSION_1_1) && defined(GLX_SGIX_fbconfig) + + /* fbc is non-NULL when the XVisualInfo* is not OpenGL-capable + (ie, GLX_USE_GL is false), but the SGIX_fbconfig extension shows + the visual's fbconfig is OpenGL-capable. The reason for this is typically + an RGBA luminance fbconfig such as 16-bit StaticGray that could + not be advertised as a GLX visual since StaticGray visuals are + required (by the GLX specification) to be color index. The + SGIX_fbconfig allows StaticGray visuals to instead advertised as + fbconfigs that can provide RGBA luminance support. */ + + GLXFBConfigSGIX fbc; +#endif + int valid; + int cap[NUM_CAPS]; +} FrameBufferMode; + +/* DisplayMode capability macros for game mode. */ +#define DM_WIDTH 0 /* "width" */ +#define DM_HEIGHT 1 /* "height" */ +#define DM_PIXEL_DEPTH 2 /* "bpp" (bits per pixel) */ +#define DM_HERTZ 3 /* "hertz" */ +#define DM_NUM 4 /* "num" */ + +#define NUM_DM_CAPS (DM_NUM+1) + +typedef struct _DisplayMode { +#ifdef _WIN32 + DEVMODE devmode; +#else + /* XXX The X Window System does not have a standard + mechanism for display setting changes. On SGI + systems, GLUT could use the XSGIvc (SGI X video + control extension). Perhaps this can be done in + a future release of GLUT. */ +#endif + int valid; + int cap[NUM_DM_CAPS]; +} DisplayMode; + +#endif /* BeOS */ + +/* GLUT function types */ typedef void (*GLUTdisplayCB) (void); typedef void (*GLUTreshapeCB) (int, int); typedef void (*GLUTkeyboardCB) (unsigned char, int, int); @@ -24,8 +259,7 @@ typedef void (*GLUTvisibilityCB) (int); typedef void (*GLUTwindowStatusCB) (int); typedef void (*GLUTidleCB) (void); typedef void (*GLUTtimerCB) (int); -typedef void (*GLUTmenuStateCB) (int); /* DEPRICATED. - */ +typedef void (*GLUTmenuStateCB) (int); /* DEPRICATED. */ typedef void (*GLUTmenuStatusCB) (int, int, int); typedef void (*GLUTselectCB) (int); typedef void (*GLUTspecialCB) (int, int, int); @@ -36,40 +270,545 @@ typedef void (*GLUTdialsCB) (int, int); typedef void (*GLUTbuttonBoxCB) (int, int); typedef void (*GLUTtabletMotionCB) (int, int); typedef void (*GLUTtabletButtonCB) (int, int, int, int); +typedef void (*GLUTjoystickCB) (unsigned int buttonMask, int x, int y, int z); +#ifdef SUPPORT_FORTRAN +typedef void (*GLUTdisplayFCB) (void); +typedef void (*GLUTreshapeFCB) (int *, int *); +/* NOTE the pressed key is int, not unsigned char for Fortran! */ +typedef void (*GLUTkeyboardFCB) (int *, int *, int *); +typedef void (*GLUTmouseFCB) (int *, int *, int *, int *); +typedef void (*GLUTmotionFCB) (int *, int *); +typedef void (*GLUTpassiveFCB) (int *, int *); +typedef void (*GLUTentryFCB) (int *); +typedef void (*GLUTvisibilityFCB) (int *); +typedef void (*GLUTwindowStatusFCB) (int *); +typedef void (*GLUTidleFCB) (void); +typedef void (*GLUTtimerFCB) (int *); +typedef void (*GLUTmenuStateFCB) (int *); /* DEPRICATED. */ +typedef void (*GLUTmenuStatusFCB) (int *, int *, int *); +typedef void (*GLUTselectFCB) (int *); +typedef void (*GLUTspecialFCB) (int *, int *, int *); +typedef void (*GLUTspaceMotionFCB) (int *, int *, int *); +typedef void (*GLUTspaceRotateFCB) (int *, int *, int *); +typedef void (*GLUTspaceButtonFCB) (int *, int *); +typedef void (*GLUTdialsFCB) (int *, int *); +typedef void (*GLUTbuttonBoxFCB) (int *, int *); +typedef void (*GLUTtabletMotionFCB) (int *, int *); +typedef void (*GLUTtabletButtonFCB) (int *, int *, int *, int *); +typedef void (*GLUTjoystickFCB) (unsigned int *buttonMask, int *x, int *y, int *z); +#endif + +#ifndef __BEOS__ + +typedef struct _GLUTcolorcell GLUTcolorcell; +struct _GLUTcolorcell { + /* GLUT_RED, GLUT_GREEN, GLUT_BLUE */ + GLfloat component[3]; +}; + +typedef struct _GLUTcolormap GLUTcolormap; +struct _GLUTcolormap { + Visual *visual; /* visual of the colormap */ + Colormap cmap; /* X colormap ID */ + int refcnt; /* number of windows using colormap */ + int size; /* number of cells in colormap */ + int transparent; /* transparent pixel, or -1 if opaque */ + GLUTcolorcell *cells; /* array of cells */ + GLUTcolormap *next; /* next colormap in list */ +}; + +typedef struct _GLUTwindow GLUTwindow; +typedef struct _GLUToverlay GLUToverlay; +struct _GLUTwindow { + int num; /* Small integer window id (0-based). */ + + /* Window system related state. */ +#if defined(_WIN32) + int pf; /* Pixel format. */ + HDC hdc; /* Window's Win32 device context. */ +#endif + Window win; /* X window for GLUT window */ + GLXContext ctx; /* OpenGL context GLUT glut window */ + XVisualInfo *vis; /* visual for window */ + Bool visAlloced; /* if vis needs deallocate on destroy */ + Colormap cmap; /* RGB colormap for window; None if CI */ + GLUTcolormap *colormap; /* colormap; NULL if RGBA */ + GLUToverlay *overlay; /* overlay; NULL if no overlay */ +#if defined(_WIN32) + HDC renderDc; /* Win32's device context for rendering. */ +#endif + Window renderWin; /* X window for rendering (might be + overlay) */ + GLXContext renderCtx; /* OpenGL context for rendering (might + be overlay) */ + /* GLUT settable or visible window state. */ + int width; /* window width in pixels */ + int height; /* window height in pixels */ + int cursor; /* cursor name */ + int visState; /* visibility state (-1 is unknown) */ + int shownState; /* if window mapped */ + int entryState; /* entry state (-1 is unknown) */ +#define GLUT_MAX_MENUS 3 + + int menu[GLUT_MAX_MENUS]; /* attatched menu nums */ + /* Window relationship state. */ + GLUTwindow *parent; /* parent window */ + GLUTwindow *children; /* list of children */ + GLUTwindow *siblings; /* list of siblings */ + /* Misc. non-API visible (hidden) state. */ + Bool treatAsSingle; /* treat this window as single-buffered + (it might be "fake" though) */ + Bool forceReshape; /* force reshape before display */ +#if !defined(_WIN32) + Bool isDirect; /* if direct context (X11 only) */ +#endif + Bool usedSwapBuffers; /* if swap buffers used last display */ + long eventMask; /* mask of X events selected for */ + int buttonUses; /* number of button uses, ref cnt */ + int tabletPos[2]; /* tablet position (-1 is invalid) */ + /* Work list related state. */ + unsigned int workMask; /* mask of window work to be done */ + GLUTwindow *prevWorkWin; /* link list of windows to work on */ + Bool desiredMapState; /* how to mapped window if on map work + list */ + Bool ignoreKeyRepeat; /* if window ignores autorepeat */ + int desiredConfMask; /* mask of desired window configuration + */ + int desiredX; /* desired X location */ + int desiredY; /* desired Y location */ + int desiredWidth; /* desired window width */ + int desiredHeight; /* desired window height */ + int desiredStack; /* desired window stack */ + /* Per-window callbacks. */ + GLUTdisplayCB display; /* redraw */ + GLUTreshapeCB reshape; /* resize (width,height) */ + GLUTmouseCB mouse; /* mouse (button,state,x,y) */ + GLUTmotionCB motion; /* motion (x,y) */ + GLUTpassiveCB passive; /* passive motion (x,y) */ + GLUTentryCB entry; /* window entry/exit (state) */ + GLUTkeyboardCB keyboard; /* keyboard (ASCII,x,y) */ + GLUTkeyboardCB keyboardUp; /* keyboard up (ASCII,x,y) */ + GLUTwindowStatusCB windowStatus; /* window status */ + GLUTvisibilityCB visibility; /* visibility */ + GLUTspecialCB special; /* special key */ + GLUTspecialCB specialUp; /* special up key */ + GLUTbuttonBoxCB buttonBox; /* button box */ + GLUTdialsCB dials; /* dials */ + GLUTspaceMotionCB spaceMotion; /* Spaceball motion */ + GLUTspaceRotateCB spaceRotate; /* Spaceball rotate */ + GLUTspaceButtonCB spaceButton; /* Spaceball button */ + GLUTtabletMotionCB tabletMotion; /* tablet motion */ + GLUTtabletButtonCB tabletButton; /* tablet button */ +#ifdef _WIN32 + GLUTjoystickCB joystick; /* joystick */ + int joyPollInterval; /* joystick polling interval */ +#endif +#ifdef SUPPORT_FORTRAN + /* Special Fortran display unneeded since no + parameters! */ + GLUTreshapeFCB freshape; /* Fortran reshape */ + GLUTmouseFCB fmouse; /* Fortran mouse */ + GLUTmotionFCB fmotion; /* Fortran motion */ + GLUTpassiveFCB fpassive; /* Fortran passive */ + GLUTentryFCB fentry; /* Fortran entry */ + GLUTkeyboardFCB fkeyboard; /* Fortran keyboard */ + GLUTkeyboardFCB fkeyboardUp; /* Fortran keyboard up */ + GLUTwindowStatusFCB fwindowStatus; /* Fortran visibility + */ + GLUTvisibilityFCB fvisibility; /* Fortran visibility + */ + GLUTspecialFCB fspecial; /* special key */ + GLUTspecialFCB fspecialUp; /* special key up */ + GLUTbuttonBoxFCB fbuttonBox; /* button box */ + GLUTdialsFCB fdials; /* dials */ + GLUTspaceMotionFCB fspaceMotion; /* Spaceball motion + */ + GLUTspaceRotateFCB fspaceRotate; /* Spaceball rotate + */ + GLUTspaceButtonFCB fspaceButton; /* Spaceball button + */ + GLUTtabletMotionFCB ftabletMotion; /* tablet motion + */ + GLUTtabletButtonFCB ftabletButton; /* tablet button + */ +#ifdef _WIN32 + GLUTjoystickFCB fjoystick; /* joystick */ +#endif +#endif +}; -/*********************************************************** - * Prototypes for glutInit.cpp - ***********************************************************/ +struct _GLUToverlay { +#if defined(_WIN32) + int pf; + HDC hdc; +#endif + Window win; + GLXContext ctx; + XVisualInfo *vis; /* visual for window */ + Bool visAlloced; /* if vis needs deallocate on destroy */ + Colormap cmap; /* RGB colormap for window; None if CI */ + GLUTcolormap *colormap; /* colormap; NULL if RGBA */ + int shownState; /* if overlay window mapped */ + Bool treatAsSingle; /* treat as single-buffered */ +#if !defined(_WIN32) + Bool isDirect; /* if direct context */ +#endif + int transparentPixel; /* transparent pixel value */ + GLUTdisplayCB display; /* redraw */ + /* Special Fortran display unneeded since no + parameters! */ +}; + +typedef struct _GLUTstale GLUTstale; +struct _GLUTstale { + GLUTwindow *window; + Window win; + GLUTstale *next; +}; + +extern GLUTstale *__glutStaleWindowList; + +#define GLUT_OVERLAY_EVENT_FILTER_MASK \ + (ExposureMask | \ + StructureNotifyMask | \ + EnterWindowMask | \ + LeaveWindowMask) +#define GLUT_DONT_PROPAGATE_FILTER_MASK \ + (ButtonReleaseMask | \ + ButtonPressMask | \ + KeyPressMask | \ + KeyReleaseMask | \ + PointerMotionMask | \ + Button1MotionMask | \ + Button2MotionMask | \ + Button3MotionMask) +#define GLUT_HACK_STOP_PROPAGATE_MASK \ + (KeyPressMask | \ + KeyReleaseMask) + +typedef struct _GLUTmenu GLUTmenu; +typedef struct _GLUTmenuItem GLUTmenuItem; +struct _GLUTmenu { + int id; /* small integer menu id (0-based) */ + Window win; /* X window for the menu */ + GLUTselectCB select; /* function of menu */ + GLUTmenuItem *list; /* list of menu entries */ + int num; /* number of entries */ +#if !defined(_WIN32) + Bool managed; /* are the InputOnly windows size + validated? */ + Bool searched; /* help detect menu loops */ + int pixheight; /* height of menu in pixels */ + int pixwidth; /* width of menu in pixels */ +#endif + int submenus; /* number of submenu entries */ + GLUTmenuItem *highlighted; /* pointer to highlighted menu + entry, NULL not highlighted */ + GLUTmenu *cascade; /* currently cascading this menu */ + GLUTmenuItem *anchor; /* currently anchored to this entry */ + int x; /* current x origin relative to the + root window */ + int y; /* current y origin relative to the + root window */ +#ifdef SUPPORT_FORTRAN + GLUTselectFCB fselect; /* function of menu */ +#endif +}; + +struct _GLUTmenuItem { + Window win; /* InputOnly X window for entry */ + GLUTmenu *menu; /* menu entry belongs to */ + Bool isTrigger; /* is a submenu trigger? */ + int value; /* value to return for selecting this + entry; doubles as submenu id + (0-base) if submenu trigger */ +#if defined(_WIN32) + UINT unique; /* unique menu item id (Win32 only) */ +#endif + char *label; /* __glutStrdup'ed label string */ + int len; /* length of label string */ + int pixwidth; /* width of X window in pixels */ + GLUTmenuItem *next; /* next menu entry on list for menu */ +}; + +typedef struct _GLUTtimer GLUTtimer; +struct _GLUTtimer { + GLUTtimer *next; /* list of timers */ + struct timeval timeout; /* time to be called */ + GLUTtimerCB func; /* timer (value) */ + int value; /* return value */ +#ifdef SUPPORT_FORTRAN + GLUTtimerFCB ffunc; /* Fortran timer */ +#endif +}; + +typedef struct _GLUTeventParser GLUTeventParser; +struct _GLUTeventParser { + int (*func) (XEvent *); + GLUTeventParser *next; +}; + +/* Declarations to implement glutFullScreen support with + mwm/4Dwm. */ + +/* The following X property format is defined in Motif 1.1's + Xm/MwmUtils.h, but GLUT should not depend on that header + file. Note: Motif 1.2 expanded this structure with + uninteresting fields (to GLUT) so just stick with the + smaller Motif 1.1 structure. */ +typedef struct { +#define MWM_HINTS_DECORATIONS 2 + long flags; + long functions; + long decorations; + long input_mode; +} MotifWmHints; + +/* Make current and buffer swap macros. */ +#ifdef _WIN32 +#define MAKE_CURRENT_LAYER(window) \ + { \ + HGLRC currentContext = wglGetCurrentContext(); \ + HDC currentDc = wglGetCurrentDC(); \ + \ + if (currentContext != window->renderCtx \ + || currentDc != window->renderDc) { \ + wglMakeCurrent(window->renderDc, window->renderCtx); \ + } \ + } +#define MAKE_CURRENT_WINDOW(window) \ + { \ + HGLRC currentContext = wglGetCurrentContext(); \ + HDC currentDc = wglGetCurrentDC(); \ + \ + if (currentContext != window->ctx || currentDc != window->hdc) { \ + wglMakeCurrent(window->hdc, window->ctx); \ + } \ + } +#define MAKE_CURRENT_OVERLAY(overlay) \ + wglMakeCurrent(overlay->hdc, overlay->ctx) +#define UNMAKE_CURRENT() \ + wglMakeCurrent(NULL, NULL) +#define SWAP_BUFFERS_WINDOW(window) \ + SwapBuffers(window->hdc) +#define SWAP_BUFFERS_LAYER(window) \ + SwapBuffers(window->renderDc) +#else +#define MAKE_CURRENT_LAYER(window) \ + glXMakeCurrent(__glutDisplay, window->renderWin, window->renderCtx) +#define MAKE_CURRENT_WINDOW(window) \ + glXMakeCurrent(__glutDisplay, window->win, window->ctx) +#define MAKE_CURRENT_OVERLAY(overlay) \ + glXMakeCurrent(__glutDisplay, overlay->win, overlay->ctx) +#define UNMAKE_CURRENT() \ + glXMakeCurrent(__glutDisplay, None, NULL) +#define SWAP_BUFFERS_WINDOW(window) \ + glXSwapBuffers(__glutDisplay, window->win) +#define SWAP_BUFFERS_LAYER(window) \ + glXSwapBuffers(__glutDisplay, window->renderWin) +#endif + +/* private variables from glut_event.c */ +extern GLUTwindow *__glutWindowWorkList; +extern int __glutWindowDamaged; +#ifdef SUPPORT_FORTRAN +extern GLUTtimer *__glutTimerList; +extern GLUTtimer *__glutNewTimer; +#endif +extern GLUTmenu *__glutMappedMenu; + +extern void (*__glutUpdateInputDeviceMaskFunc) (GLUTwindow *); +#if !defined(_WIN32) +extern void (*__glutMenuItemEnterOrLeave)(GLUTmenuItem * item, + int num, int type); +extern void (*__glutFinishMenu)(Window win, int x, int y); +extern void (*__glutPaintMenu)(GLUTmenu * menu); +extern void (*__glutStartMenu)(GLUTmenu * menu, + GLUTwindow * window, int x, int y, int x_win, int y_win); +extern GLUTmenu * (*__glutGetMenuByNum)(int menunum); +extern GLUTmenuItem * (*__glutGetMenuItem)(GLUTmenu * menu, + Window win, int *which); +extern GLUTmenu * (*__glutGetMenu)(Window win); +#endif + +/* private variables from glut_init.c */ +extern Atom __glutWMDeleteWindow; +extern Display *__glutDisplay; +extern unsigned int __glutDisplayMode; +extern char *__glutDisplayString; +extern XVisualInfo *(*__glutDetermineVisualFromString) (char *string, Bool * treatAsSingle, + Criterion * requiredCriteria, int nRequired, int requiredMask, void **fbc); +extern GLboolean __glutDebug; +extern GLboolean __glutForceDirect; +extern GLboolean __glutIconic; +extern GLboolean __glutTryDirect; +extern Window __glutRoot; +extern XSizeHints __glutSizeHints; +extern char **__glutArgv; +#endif /* BeOS */ +extern char *__glutProgramName; +#ifndef __BEOS__ +extern int __glutArgc; +extern int __glutConnectionFD; +extern int __glutInitHeight; +extern int __glutInitWidth; +extern int __glutInitX; +extern int __glutInitY; +extern int __glutScreen; +extern int __glutScreenHeight; +extern int __glutScreenWidth; +extern Atom __glutMotifHints; +extern unsigned int __glutModifierMask; + +/* private variables from glut_menu.c */ +extern GLUTmenuItem *__glutItemSelected; +extern GLUTmenu **__glutMenuList; +extern void (*__glutMenuStatusFunc) (int, int, int); +extern void __glutMenuModificationError(void); +extern void __glutSetMenuItem(GLUTmenuItem * item, + const char *label, int value, Bool isTrigger); + +/* private variables from glut_win.c */ +extern GLUTwindow **__glutWindowList; +extern GLUTwindow *__glutCurrentWindow; +extern GLUTwindow *__glutMenuWindow; +extern GLUTmenu *__glutCurrentMenu; +extern int __glutWindowListSize; +extern void (*__glutFreeOverlayFunc) (GLUToverlay *); +extern XVisualInfo *__glutDetermineWindowVisual(Bool * treatAsSingle, + Bool * visAlloced, void **fbc); + +/* private variables from glut_mesa.c */ +extern int __glutMesaSwapHackSupport; + +/* private variables from glut_gamemode.c */ +extern GLUTwindow *__glutGameModeWindow; + +/* private routines from glut_cindex.c */ +extern GLUTcolormap * __glutAssociateNewColormap(XVisualInfo * vis); +extern void __glutFreeColormap(GLUTcolormap *); + +/* private routines from glut_cmap.c */ +extern void __glutSetupColormap( + XVisualInfo * vi, + GLUTcolormap ** colormap, + Colormap * cmap); +#if !defined(_WIN32) +extern void __glutEstablishColormapsProperty( + GLUTwindow * window); +extern GLUTwindow *__glutToplevelOf(GLUTwindow * window); +#endif + +/* private routines from glut_cursor.c */ +extern void __glutSetCursor(GLUTwindow *window); + +/* private routines from glut_event.c */ +extern void __glutPutOnWorkList(GLUTwindow * window, + int work_mask); +extern void __glutRegisterEventParser(GLUTeventParser * parser); +extern void __glutPostRedisplay(GLUTwindow * window, int layerMask); + +/* private routines from glut_init.c */ +#if !defined(_WIN32) +extern void __glutOpenXConnection(char *display); +#else +extern void __glutOpenWin32Connection(char *display); +#endif +extern void __glutInitTime(struct timeval *beginning); + +/* private routines for glut_menu.c (or win32_menu.c) */ +#if defined(_WIN32) +extern GLUTmenu *__glutGetMenu(Window win); +extern GLUTmenu *__glutGetMenuByNum(int menunum); +extern GLUTmenuItem *__glutGetMenuItem(GLUTmenu * menu, + Window win, int *which); +extern void __glutStartMenu(GLUTmenu * menu, + GLUTwindow * window, int x, int y, int x_win, int y_win); +extern void __glutFinishMenu(Window win, int x, int y); +#endif +extern void __glutSetMenu(GLUTmenu * menu); + +#endif /* BeOS */ +#ifdef __cplusplus +extern "C" { +#endif +/* private routines from glut_util.c */ +extern char * __glutStrdup(const char *string); +extern void __glutWarning(char *format,...); +extern void __glutFatalError(char *format,...); +extern void __glutFatalUsage(char *format,...); +#ifdef __cplusplus +} +#endif +#ifndef __BEOS__ + +/* private routines from glut_win.c */ +extern GLUTwindow *__glutGetWindow(Window win); +extern void __glutChangeWindowEventMask(long mask, Bool add); +extern XVisualInfo *__glutDetermineVisual( + unsigned int mode, + Bool * fakeSingle, + XVisualInfo * (getVisualInfo) (unsigned int)); +extern XVisualInfo *__glutGetVisualInfo(unsigned int mode); +extern void __glutSetWindow(GLUTwindow * window); +extern void __glutReshapeFunc(GLUTreshapeCB reshapeFunc, + int callingConvention); +extern void __glutDefaultReshape(int, int); +extern GLUTwindow *__glutCreateWindow( + GLUTwindow * parent, + int x, int y, int width, int height, int gamemode); +extern void __glutDestroyWindow( + GLUTwindow * window, + GLUTwindow * initialWindow); + +#if !defined(_WIN32) +/* private routines from glut_glxext.c */ +extern int __glutIsSupportedByGLX(char *); +#endif + +/* private routines from glut_input.c */ +extern void __glutUpdateInputDeviceMask(GLUTwindow * window); + +/* private routines from glut_mesa.c */ +extern void __glutDetermineMesaSwapHackSupport(void); + +/* private routines from glut_gameglut.c */ +extern void __glutCloseDownGameMode(void); + +#if defined(_WIN32) +/* private routines from win32_*.c */ +extern LONG WINAPI __glutWindowProc(HWND win, UINT msg, WPARAM w, LPARAM l); +extern HDC XHDC; +#endif + +#else /* BeOS */ +/* BeOS specific C++ function prototypes */ +#ifdef __cplusplus + +#include + +/* private routines from glutInit.cpp */ void __glutInitTime(bigtime_t *beginning); void __glutInit(); -/*********************************************************** - * Prototypes for glut_util.c - ***********************************************************/ -void __glutWarning(char *format,...); -void __glutFatalError(char *format,...); -void __glutFatalUsage(char *format,...); - -/*********************************************************** - * Prototypes for glutMenu.cpp - ***********************************************************/ -class GlutMenu; // avoid including glutMenu.h +/* private routines from glutMenu.cpp */ +class GlutMenu; // avoid including glutMenu.h GlutMenu *__glutGetMenuByNum(int menunum); - -/*********************************************************** - * Prototypes for glutWindow.cpp - ***********************************************************/ + +/* private routines from glutWindow.cpp */ int __glutConvertDisplayMode(unsigned long *options); void __glutDefaultReshape(int width, int height); -class GlutWindow; // avoid including glutWindow.h in every source file +class GlutWindow; // avoid including glutWindow.h in every source file void __glutSetWindow(GlutWindow * window); +void __glutDestroyAllWindows(); -/*********************************************************** - * Prototypes for glutDstr.cpp - ***********************************************************/ +/* private routines from glutDstr.cpp */ int __glutConvertDisplayModeFromString(unsigned long *options); -/*********************************************************** - * Prototypes for glutCursor.cpp - ***********************************************************/ +/* private routines from glutCursor.cpp */ void __glutSetCursor(int cursor); + +#endif /* __cplusplus */ +#endif /* BeOS */ + +#endif /* __glutint_h__ */ diff --git a/src/glut/beos/glutstroke.h b/src/glut/beos/glutstroke.h index 4712ebbde97..cbc9e156fea 100644 --- a/src/glut/beos/glutstroke.h +++ b/src/glut/beos/glutstroke.h @@ -7,8 +7,9 @@ and is provided without guarantee or warrantee expressed or implied. This program is -not- in the public domain. */ -#if defined(WIN32) -#pragma warning (disable:4244) +#if defined(_WIN32) +#pragma warning (disable:4244) /* disable bogus conversion warnings */ +#pragma warning (disable:4305) /* VC++ 5.0 version of above warning. */ #endif typedef struct {