i2p/haiku-beta6
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

* Minor cleanup - this stuff really has "reimplement me" written all over it...

Browse Source 
git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@27901 a95241bf-73f2-0310-859d-f6bbb57e9c96
This commit is contained in:
Axel Dörfler
2008-10-07 11:43:15 +00:00
parent 044627ee89
commit 5007e8e478
2 changed files with 336 additions and 326 deletions
Download Patch File Download Diff File Expand all files Collapse all files
src/kits/opengl/glut/glutWindow.cpp
+310 -291
View File
@@ -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 <GL/glut.h>
#include <stdlib.h>
#include <GL/glut.h>
#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<char*>(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<char*>(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; i<gState.windowListSize; i++) {
if (gState.windowList[i]) {
/*! 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; i < gState.windowListSize; i++) {
if (gState.windowList[i])
glutDestroyWindow(i + 1);
}
}
gState.display->Lock();
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<BDirectWindow*>(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<BDirectWindow*>(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<BDirectWindow*>(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;
}
src/kits/opengl/glut/glutWindow.h
+26 -35
View File
@@ -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 <GL/glut.h>
#include <Window.h>
#include <GLView.h>
/***********************************************************
* 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