From 5007e8e4783e994a5a1adeb1c7b8c17809ea177b Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Axel=20D=C3=B6rfler?= Date: Tue, 7 Oct 2008 11:43:15 +0000 Subject: [PATCH] * Minor cleanup - this stuff really has "reimplement me" written all over it... git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@27901 a95241bf-73f2-0310-859d-f6bbb57e9c96 --- src/kits/opengl/glut/glutWindow.cpp | 601 ++++++++++++++-------------- src/kits/opengl/glut/glutWindow.h | 61 ++- 2 files changed, 336 insertions(+), 326 deletions(-) diff --git a/src/kits/opengl/glut/glutWindow.cpp b/src/kits/opengl/glut/glutWindow.cpp index 2159c41c45..6c1de40189 100644 --- a/src/kits/opengl/glut/glutWindow.cpp +++ b/src/kits/opengl/glut/glutWindow.cpp @@ -5,88 +5,76 @@ * and is provided without guarantee or warrantee expressed or * implied. This program is -not- in the public domain. * - * - * FILE: glutWindow.cpp - * * DESCRIPTION: all the routines for dealing with GlutWindows ***********************************************************/ -/*********************************************************** - * Headers - ***********************************************************/ -#include #include + +#include + #include "glutint.h" #include "glutState.h" #include "glutBlocker.h" -/*********************************************************** - * FUNCTION: getUnusedWindowSlot - * - * DESCRIPTION: helper function to get a new window slot - ***********************************************************/ + +/*! Helper function to get a new window slot */ static int getUnusedWindowSlot() { - int i; + int i; - /* Look for allocated, unused slot. */ - for (i = 0; i < gState.windowListSize; i++) { - if (!gState.windowList[i]) { - return i; - } - } - /* Allocate a new slot. */ - gState.windowListSize++; - gState.windowList = (GlutWindow **) - realloc(gState.windowList, - gState.windowListSize * sizeof(GlutWindow *)); + /* Look for allocated, unused slot. */ + for (i = 0; i < gState.windowListSize; i++) { + if (!gState.windowList[i]) + return i; + } - if (!gState.windowList) - __glutFatalError("out of memory."); - gState.windowList[gState.windowListSize - 1] = NULL; - return gState.windowListSize - 1; + /* Allocate a new slot. */ + gState.windowListSize++; + gState.windowList = (GlutWindow **)realloc(gState.windowList, + gState.windowListSize * sizeof(GlutWindow *)); + if (gState.windowList == NULL) + __glutFatalError("out of memory."); + + gState.windowList[gState.windowListSize - 1] = NULL; + return gState.windowListSize - 1; } -/*********************************************************** - * FUNCTION: __glutDefaultDisplay - * __glutDefaultReshape - * - * DESCRIPTION: default display and reshape functions - ***********************************************************/ + +/*! Default display function */ static void __glutDefaultDisplay(void) { - /* XXX Remove the warning after GLUT 3.0. */ - __glutWarning("The following is a new check for GLUT 3.0; update your code."); - __glutFatalError( - "redisplay needed for window %d, but no display callback.", - gState.currentWindow->num + 1); + /* XXX Remove the warning after GLUT 3.0. */ + __glutWarning("The following is a new check for GLUT 3.0; update your " + "code."); + __glutFatalError("redisplay needed for window %d, but no display callback.", + gState.currentWindow->num + 1); } + +/*! Default reshape function */ void __glutDefaultReshape(int width, int height) { - /* Adjust the viewport of the window */ - glViewport(0, 0, (GLsizei) width, (GLsizei) height); + /* Adjust the viewport of the window */ + glViewport(0, 0, (GLsizei) width, (GLsizei) height); } -/*********************************************************** - * CLASS: GlutWindow - * - * FUNCTION: (constructor) - * - * DESCRIPTION: creates a new GLUT window - * note: subwindows don't resize, but top-level windows - * follow all sides - ***********************************************************/ -GlutWindow::GlutWindow(GlutWindow *nparent, char *name, - int x, int y, int width, int height, ulong options) : - BGLView( - (nparent ? BRect(x,y,x+width-1,y+height-1) : - BRect(0,0,width-1,height-1)), name, - (nparent ? B_FOLLOW_NONE : B_FOLLOW_ALL_SIDES), - B_WILL_DRAW|B_FRAME_EVENTS|B_FULL_UPDATE_ON_RESIZE|B_PULSE_NEEDED, + +// #pragma mark - + + +/*! Creates a new GLUT window + Note: subwindows don't resize, but top-level windows + follow all sides. +*/ +GlutWindow::GlutWindow(GlutWindow *nparent, const char *name, + int x, int y, int width, int height, ulong options) + : BGLView(nparent != NULL ? BRect(x, y, x + width - 1, y + height - 1) + : BRect(0, 0, width - 1, height - 1), const_cast(name), + nparent != NULL ? B_FOLLOW_NONE : B_FOLLOW_ALL_SIDES, + B_WILL_DRAW | B_FRAME_EVENTS | B_FULL_UPDATE_ON_RESIZE | B_PULSE_NEEDED, options) { // add myself to window list @@ -102,7 +90,7 @@ GlutWindow::GlutWindow(GlutWindow *nparent, char *name, siblings = 0; } children = 0; - + // initialize variables cursor = GLUT_CURSOR_INHERIT; // default cursor for (int i = 0; i < GLUT_MAX_MENUS; i++) { @@ -111,7 +99,7 @@ GlutWindow::GlutWindow(GlutWindow *nparent, char *name, m_width = width; m_height = height; m_buttons = 0; - + // clear callbacks display = __glutDefaultDisplay; reshape = __glutDefaultReshape; @@ -125,7 +113,7 @@ GlutWindow::GlutWindow(GlutWindow *nparent, char *name, special = 0; specialUp = 0; windowStatus = 0; - + // clear event counters anyevents = 1; displayEvent = 1; // get a reshape and a display event right away @@ -144,7 +132,7 @@ GlutWindow::GlutWindow(GlutWindow *nparent, char *name, menuEvent = 0; visible = true; gBlock.QuickNewEvent(); - + // if i'm a subwindow, add me to my parent view if (parent) { parent->Window()->Lock(); @@ -153,28 +141,27 @@ GlutWindow::GlutWindow(GlutWindow *nparent, char *name, } else { // if I'm a top-level window, create my BWindow GlutBWindow *mybwindow = new GlutBWindow( - BRect(x,y,x+width-1,y+height-1), name); + BRect(x, y, x + width - 1, y + height - 1), name); mybwindow->AddChild(this); mybwindow->bgl = this; mybwindow->Show(); } - + // give me the keyboard focus (focus follows mouse, X style, as // implemented in GlutWindow::MouseMoved()) Window()->Lock(); MakeFocus(); Window()->Unlock(); - + // make myself the default window __glutSetWindow(this); } -/*********************************************************** - * FUNCTION: glutCreateWindow (4.1) - * - * DESCRIPTION: creates a new GLUT window - ***********************************************************/ -int glutCreateWindow(const char *name) { + +/*! Creates a new GLUT window */ +int +glutCreateWindow(const char *name) +{ if (!be_app) __glutInit(); @@ -182,86 +169,82 @@ int glutCreateWindow(const char *name) { if (!__glutConvertDisplayMode(&options)) { __glutWarning("visual with necessary capabilities not found."); } - + // if X or Y is negative, then start at a reasonable position - bool defaultxy = (gState.initX < 0) || (gState.initY < 0); - - GlutWindow *window = new GlutWindow(0, const_cast(name), - (defaultxy ? 50 : gState.initX), (defaultxy ? 50 : gState.initY), + bool defaultxy = gState.initX < 0 || gState.initY < 0; + + GlutWindow *window = new GlutWindow(0, name, + defaultxy ? 50 : gState.initX, defaultxy ? 50 : gState.initY, gState.initWidth, gState.initHeight, options); - + return window->num + 1; } -/*********************************************************** - * FUNCTION: glutCreateSubWindow (4.2) - * - * DESCRIPTION: creates a new GLUT subwindow - * Note: a subwindow is a GlutWindow (which is actually - * a BGLView) without its own BWindow - ***********************************************************/ -int glutCreateSubWindow(int win, int x, int y, int width, int height) { + +/*! Creates a new GLUT subwindow + Note: a subwindow is a GlutWindow (which is actually + a BGLView) without its own BWindow +*/ +int +glutCreateSubWindow(int win, int x, int y, int width, int height) +{ ulong options; if (!__glutConvertDisplayMode(&options)) { __glutFatalError("visual with necessary capabilities not found."); } - + GlutWindow *window = new GlutWindow(gState.windowList[win-1], "child", x, y, width, height, options); - + return window->num + 1; } -/*********************************************************** - * FUNCTION: __glutSetWindow - * - * DESCRIPTION: set the current window (utility function) - ***********************************************************/ + +/*! Set the current window (utility function) */ void -__glutSetWindow(GlutWindow * window) +__glutSetWindow(GlutWindow *window) { - if (gState.currentWindow) - gState.currentWindow->UnlockGL(); - gState.currentWindow = window; - gState.currentWindow->LockGL(); + if (gState.currentWindow) + gState.currentWindow->UnlockGL(); + gState.currentWindow = window; + gState.currentWindow->LockGL(); } -/*********************************************************** - * FUNCTION: glutSetWindow (4.3) - * glutGetWindow - * - * DESCRIPTION: set and get the current window - ***********************************************************/ -void glutSetWindow(int win) { - GlutWindow *window; - if (win < 1 || win > gState.windowListSize) { - __glutWarning("glutSetWindow attempted on bogus window."); - return; - } - window = gState.windowList[win - 1]; - if (!window) { - __glutWarning("glutSetWindow attempted on bogus window."); - return; - } - __glutSetWindow(window); +/*! Set and get the current window */ +void +glutSetWindow(int win) +{ + GlutWindow *window; + + if (win < 1 || win > gState.windowListSize) { + __glutWarning("glutSetWindow attempted on bogus window."); + return; + } + + window = gState.windowList[win - 1]; + if (!window) { + __glutWarning("glutSetWindow attempted on bogus window."); + return; + } + __glutSetWindow(window); } -int glutGetWindow() { - if (gState.currentWindow) { - return gState.currentWindow->num + 1; - } else { - return 0; - } + +int +glutGetWindow() +{ + if (gState.currentWindow) + return gState.currentWindow->num + 1; + + return 0; } -/*********************************************************** - * FUNCTION: __glutDestroyWindow - * - * DESCRIPTION: recursively set entries to 0 - ***********************************************************/ + +/*! Recursively set entries to 0. */ static void -__glutDestroyWindow(GlutWindow *window, GlutWindow *initialWindow) { +__glutDestroyWindow(GlutWindow *window, GlutWindow *initialWindow) +{ // first, find all children recursively and set their entries to 0 GlutWindow *cur = window->children; while (cur) { @@ -269,49 +252,47 @@ __glutDestroyWindow(GlutWindow *window, GlutWindow *initialWindow) { __glutDestroyWindow(cur, initialWindow); cur = siblings; } + + /* Remove from parent's children list (only necessary for + non-initial windows and subwindows!). */ + GlutWindow *parent = window->parent; + if (parent && parent == initialWindow->parent) { + GlutWindow **prev = &parent->children; + cur = parent->children; + while (cur) { + if (cur == window) { + *prev = cur->siblings; + break; + } + prev = &(cur->siblings); + cur = cur->siblings; + } + } - /* Remove from parent's children list (only necessary for - non-initial windows and subwindows!). */ - GlutWindow *parent = window->parent; - if (parent && parent == initialWindow->parent) { - GlutWindow **prev = &parent->children; - cur = parent->children; - while (cur) { - if (cur == window) { - *prev = cur->siblings; - break; - } - prev = &(cur->siblings); - cur = cur->siblings; - } - } - - // finally, check if we are the current window, and set to 0 - if (gState.currentWindow == window) { - gState.currentWindow = 0; - } - gState.windowList[window->num] = 0; + // finally, check if we are the current window, and set to 0 + if (gState.currentWindow == window) + gState.currentWindow = 0; + + gState.windowList[window->num] = 0; } -/*********************************************************** - * FUNCTION: glutDestroyWindow (4.4) - * - * DESCRIPTION: destroy window and all its children - ***********************************************************/ -void glutDestroyWindow(int win) { + +/*! Destroy window and all its children. */ +void +glutDestroyWindow(int win) +{ // can't destroy a window if another window has the GL context if (gState.currentWindow) gState.currentWindow->UnlockGL(); // lock the window - GlutWindow *window = gState.windowList[win-1]; + GlutWindow *window = gState.windowList[win - 1]; BWindow *bwindow = window->Window(); bwindow->Lock(); // if win is the current window, set current window to 0 - if (gState.currentWindow == window) { + if (gState.currentWindow == window) gState.currentWindow = 0; - } // recursively set child entries to 0 __glutDestroyWindow(window, window); @@ -322,7 +303,7 @@ void glutDestroyWindow(int win) { window->UnlockGL(); // now, if the window was top-level, delete its BWindow - if(!window->parent) { + if (!window->parent) { bwindow->Quit(); } else { // else, detach it from the BWindow and delete it @@ -330,36 +311,35 @@ void glutDestroyWindow(int win) { delete window; bwindow->Unlock(); } + // relock GL if the current window is still valid - if(gState.currentWindow) + 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) - * - * DESCRIPTION: mark window as needing redisplay - ***********************************************************/ -void glutPostRedisplay() { + +/*! Mark window as needing redisplay */ +void +glutPostRedisplay() +{ gState.currentWindow->Window()->Lock(); gState.currentWindow->anyevents = true; gState.currentWindow->displayEvent = true; @@ -367,12 +347,11 @@ void glutPostRedisplay() { gBlock.QuickNewEvent(); } -/*********************************************************** - * FUNCTION: glutPostWindowRedisplay - * - * DESCRIPTION: mark window as needing redisplay - ***********************************************************/ -void glutPostWindowRedisplay(int win) { + +/*! Mark window as needing redisplay */ +void +glutPostWindowRedisplay(int win) +{ GlutWindow *gwin = gState.windowList[win - 1]; gwin->Window()->Lock(); gwin->anyevents = true; @@ -381,86 +360,95 @@ void glutPostWindowRedisplay(int win) { gBlock.QuickNewEvent(); } -/*********************************************************** - * FUNCTION: glutSwapBuffers (4.6) - * - * DESCRIPTION: swap buffers - ***********************************************************/ -void glutSwapBuffers() { + +void +glutSwapBuffers() +{ gState.currentWindow->SwapBuffers(); } -/*********************************************************** - * FUNCTION: glutPositionWindow (4.7) - * - * DESCRIPTION: move window - ***********************************************************/ -void glutPositionWindow(int x, int y) { + +/*! Move window */ +void +glutPositionWindow(int x, int y) +{ BDirectWindow *win = dynamic_cast(gState.currentWindow->Window()); + if (win == NULL) + return; + win->Lock(); if (gState.currentWindow->parent) gState.currentWindow->MoveTo(x, y); // move the child view else { - if(win->IsFullScreen()) { + if (win->IsFullScreen()) win->SetFullScreen(false); - } + win->MoveTo(x, y); // move the window } win->Unlock(); } -/*********************************************************** - * FUNCTION: glutReshapeWindow (4.8) - * - * DESCRIPTION: reshape window (we'll catch the callback - * when the view gets a Draw() message - ***********************************************************/ -void glutReshapeWindow(int width, int height) { + +/*! Reshape window (we'll catch the callback when the view gets + a Draw() message). +*/ +void +glutReshapeWindow(int width, int height) +{ BDirectWindow *win = dynamic_cast(gState.currentWindow->Window()); + if (win == NULL) + return; + win->Lock(); - if (gState.currentWindow->parent) - gState.currentWindow->ResizeTo(width-1, height-1); // resize the child - else { - if(win->IsFullScreen()) { + if (gState.currentWindow->parent) { + // resize the child + gState.currentWindow->ResizeTo(width - 1, height - 1); + } else { + if (win->IsFullScreen()) win->SetFullScreen(false); - } - win->ResizeTo(width-1, height-1); // resize the parent + + // resize the parent + win->ResizeTo(width - 1, height - 1); } win->Unlock(); } -/*********************************************************** - * FUNCTION: glutFullScreen (4.9) - * - * DESCRIPTION: makes the window full screen - ***********************************************************/ -void glutFullScreen() { + +/*! Makes the window full screen */ +void +glutFullScreen() +{ BDirectWindow *win = dynamic_cast(gState.currentWindow->Window()); + if (win == NULL) + return; + win->Lock(); win->SetFullScreen(true); win->Unlock(); } -/*********************************************************** - * FUNCTION: glutPopWindow (4.10) - * glutPushWindow - * - * DESCRIPTION: change the stacking order of the current window - * NOTE: I can't figure out how to do this for windows, - * and there is no concept of "stacking order" for - * subwindows, so these are currently no-ops. - ***********************************************************/ -void glutPopWindow() { } -void glutPushWindow() { } -/*********************************************************** - * FUNCTION: glutShowWindow (4.11) - * glutHideWindow - * glutIconifyWindow - * - * DESCRIPTION: change display status of current window - ***********************************************************/ -void glutShowWindow() { +/*! Supposed to change the stacking order of the current window + NOTE: I can't figure out how to do this for windows, + and there is no concept of "stacking order" for + subwindows, so these are currently no-ops. +*/ +void +glutPopWindow() +{ +} + + +/*! Same problem as glutPopWindow() */ +void +glutPushWindow() +{ +} + + +void +glutShowWindow() +{ gState.currentWindow->Window()->Lock(); if (gState.currentWindow->parent) // subwindow gState.currentWindow->Show(); @@ -472,17 +460,26 @@ void glutShowWindow() { gState.currentWindow->Window()->Unlock(); } -void glutHideWindow() { + +void +glutHideWindow() +{ gState.currentWindow->Window()->Lock(); + if (gState.currentWindow->parent) // subwindow gState.currentWindow->Hide(); else gState.currentWindow->Window()->Hide(); // show the actual BWindow + gState.currentWindow->Window()->Unlock(); } -void glutIconifyWindow() { - if(gState.currentWindow->parent) + +/*! Minimizes window */ +void +glutIconifyWindow() +{ + if (gState.currentWindow->parent) __glutFatalError("can't iconify a subwindow"); gState.currentWindow->Window()->Lock(); @@ -490,37 +487,38 @@ void glutIconifyWindow() { gState.currentWindow->Window()->Unlock(); } -/*********************************************************** - * FUNCTION: glutSetWindowTitle (4.12) - * glutSetIconTitle - * - * DESCRIPTION: set the window title (icon title is same) - ***********************************************************/ -void glutSetWindowTitle(const char *name) { + +/*! Sets the window title */ +void +glutSetWindowTitle(const char *name) +{ if (gState.currentWindow->parent) __glutFatalError("glutSetWindowTitle: isn't a top-level window"); - + gState.currentWindow->Window()->Lock(); gState.currentWindow->Window()->SetTitle(name); gState.currentWindow->Window()->Unlock(); } -void glutSetIconTitle(const char *name) { + +/*! Same as glutSetWindowTitle() */ +void +glutSetIconTitle(const char *name) +{ glutSetWindowTitle(name); } -/*********************************************************** - * FUNCTION: __glutConvertDisplayMode - * - * DESCRIPTION: converts the current display mode into a BGLView - * display mode, printing warnings as appropriate. - * - * PARAMETERS: if options is non-NULL, the current display mode is - * returned in it. - * - * RETURNS: 1 if the current display mode is possible, else 0 - ***********************************************************/ -int __glutConvertDisplayMode(unsigned long *options) { + +/*! Converts the current display mode into a BGLView + display mode, printing warnings as appropriate. + + \param options if non-NULL, the current display mode is + returned in it. + \return 1 if the current display mode is possible, else 0 +*/ +int +__glutConvertDisplayMode(unsigned long *options) +{ if (gState.displayString) { /* __glutDisplayString should be NULL except if glutInitDisplayString has been called to register a @@ -530,68 +528,72 @@ int __glutConvertDisplayMode(unsigned long *options) { return __glutConvertDisplayModeFromString(options); } - if(options) { + if (options) { ulong newoptions = 0; - if(gState.displayMode & GLUT_ACCUM) + if (gState.displayMode & GLUT_ACCUM) newoptions |= BGL_ACCUM; - if(gState.displayMode & GLUT_ALPHA) + if (gState.displayMode & GLUT_ALPHA) newoptions |= BGL_ALPHA; - if(gState.displayMode & GLUT_DEPTH) + if (gState.displayMode & GLUT_DEPTH) newoptions |= BGL_DEPTH; - if(gState.displayMode & GLUT_DOUBLE) + if (gState.displayMode & GLUT_DOUBLE) newoptions |= BGL_DOUBLE; - if(gState.displayMode & GLUT_STENCIL) + if (gState.displayMode & GLUT_STENCIL) newoptions |= BGL_STENCIL; *options = newoptions; } - if(gState.displayMode & GLUT_INDEX) { + if (gState.displayMode & GLUT_INDEX) { __glutWarning("BeOS doesn't support indexed color"); return 0; } - if(gState.displayMode & GLUT_MULTISAMPLE) { + if (gState.displayMode & GLUT_MULTISAMPLE) { return 1; // try to go without multisampling } - if(gState.displayMode & GLUT_STEREO) { + if (gState.displayMode & GLUT_STEREO) { __glutWarning("BeOS doesn't support stereo windows"); return 0; } - if(gState.displayMode & GLUT_LUMINANCE) { + if (gState.displayMode & GLUT_LUMINANCE) { __glutWarning("BeOS doesn't support luminance color model"); return 0; } return 1; // visual supported } -/*********************************************************** - * CLASS: GlutBWindow - * - * DESCRIPTION: very thin wrapper around BWindow - ***********************************************************/ -GlutBWindow::GlutBWindow(BRect frame, char *name) : - BDirectWindow(frame, name, B_TITLED_WINDOW, 0) { + +// #pragma mark - + + +/*! Very thin wrapper around BWindow */ +GlutBWindow::GlutBWindow(BRect frame, const char *name) + : 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 ) { + +void +GlutBWindow::DirectConnected(direct_buffer_info *info) +{ if (!bgl) return; bgl->DirectConnected(info); - if(!fConnectionDisabled) { + if (!fConnectionDisabled) bgl->EnableDirectMode(true); - } + int newVisState; - if((info->buffer_state & B_DIRECT_MODE_MASK) == B_DIRECT_START) { + if ((info->buffer_state & B_DIRECT_MODE_MASK) == B_DIRECT_START) bgl->visible = true; - } - if(!bgl->visible || info->buffer_state == B_DIRECT_STOP) + + if (!bgl->visible || info->buffer_state == B_DIRECT_STOP) newVisState = GLUT_HIDDEN; else { if (info->clip_list_count == 0) @@ -601,40 +603,57 @@ void GlutBWindow::DirectConnected( direct_buffer_info *info ) { else newVisState = GLUT_PARTIALLY_RETAINED; } - if(newVisState != bgl->visState) { + + if (newVisState != bgl->visState) { bgl->visState = newVisState; bgl->anyevents = bgl->windowStatusEvent = true; gBlock.NewEvent(); } } -GlutBWindow::~GlutBWindow() { + +GlutBWindow::~GlutBWindow() +{ fConnectionDisabled = true; - if(bgl) { + if (bgl) bgl->EnableDirectMode(false); - } - if(!IsHidden()) + + if (!IsHidden()) Hide(); + Sync(); } -bool GlutBWindow::QuitRequested() { + +bool +GlutBWindow::QuitRequested() +{ gState.quitAll = true; gBlock.NewEvent(); - return false; // don't quit now, wait for main thread to do it + return false; + // don't quit now, wait for main thread to do it } -void GlutBWindow::Minimize(bool minimize) { + +void +GlutBWindow::Minimize(bool minimize) +{ bgl->visible = !minimize; BWindow::Minimize(minimize); } -void GlutBWindow::Hide() { + +void +GlutBWindow::Hide() +{ BWindow::Hide(); bgl->visible = false; } -void GlutBWindow::Show() { + +void +GlutBWindow::Show() +{ BWindow::Show(); bgl->visible = true; } diff --git a/src/kits/opengl/glut/glutWindow.h b/src/kits/opengl/glut/glutWindow.h index f4200ddc66..6a0f66ee29 100644 --- a/src/kits/opengl/glut/glutWindow.h +++ b/src/kits/opengl/glut/glutWindow.h @@ -5,33 +5,23 @@ * and is provided without guarantee or warrantee expressed or * implied. This program is -not- in the public domain. * - * - * FILE: glutWindow.h - * * DESCRIPTION: the GlutWindow class saves all events for * handling by main thread ***********************************************************/ -/*********************************************************** - * Headers - ***********************************************************/ #include #include #include -/*********************************************************** - * CLASS: GlutWindow - * - * INHERITS FROM: BGLView (NOT BWindow!) - * - * DESCRIPTION: all information needed for windows and - * subwindows (handled as similarly as possible) - ***********************************************************/ + +/*! All information needed for windows and + subwindows (handled as similarly as possible). +*/ class GlutWindow : public BGLView { public: - GlutWindow(GlutWindow *nparent, char *name, int x, int y, int width, - int height, ulong options); - + GlutWindow(GlutWindow *nparent, const char *name, int x, int y, int width, + int height, ulong options); + virtual void MessageReceived(BMessage *message); void KeyDown(const char *bytes, int32 numBytes); void KeyUp(const char *bytes, int32 numBytes); @@ -44,7 +34,7 @@ public: void ErrorCallback(GLenum errorCode); static long MenuThread(void *menu); - + int num; // window number returned to user int cursor; // my cursor #define GLUT_MAX_MENUS 3 @@ -53,23 +43,23 @@ public: uint32 m_buttons; // the last mouse button state /* Window relationship state. */ - GlutWindow *parent; /* parent window */ - GlutWindow *children; /* first child window */ - GlutWindow *siblings; /* next sibling */ + GlutWindow *parent; /* parent window */ + GlutWindow *children; /* first child window */ + GlutWindow *siblings; /* next sibling */ // leave out buttons and dials callbacks that we don't support - 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) */ - GLUTvisibilityCB visibility; /* visibility */ - GLUTspecialCB special; /* special key */ - GLUTspecialCB specialUp; /* special key up */ - GLUTwindowStatusCB windowStatus; /* window status */ + 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) */ + GLUTvisibilityCB visibility; /* visibility */ + GLUTspecialCB special; /* special key */ + GLUTspecialCB specialUp; /* special key up */ + GLUTwindowStatusCB windowStatus; /* window status */ bool anyevents; // were any events received? bool displayEvent; // call display @@ -85,7 +75,7 @@ public: bool specialUpEvent; // call special bool statusEvent; // menu status changed bool menuEvent; // menu selected - + int button, mouseState; // for mouse callback int mouseX, mouseY; // for mouse callback int motionX, motionY; // for motion callback @@ -113,8 +103,9 @@ public: ***********************************************************/ class GlutBWindow : public BDirectWindow { public: - GlutBWindow(BRect frame, char *name); + GlutBWindow(BRect frame, const char *name); ~GlutBWindow(); + void DirectConnected(direct_buffer_info *info); bool QuitRequested(); // exits app void Minimize(bool minimized); // minimized windows are not visible