void wxGLContext::Update()
{
if (m_glContext)
{
aglUpdateContext(m_glContext);
}
}
bool Window::processEvent( const WindowEvent& event )
{
if( event.type == Event::WINDOW_RESIZE && _aglContext )
aglUpdateContext( _aglContext );
return SystemWindow::processEvent( event );
}
static pascal OSStatus EventHandler(
EventHandlerCallRef nextHandler, /* I - Next handler to call */
EventRef event, /* I - Event reference */
void *userData) /* I - User data (not used) */
{
UInt32 kind; /* Kind of event */
Rect rect; /* New window size */
EventMouseButton button; /* Mouse button */
Point point; /* Mouse position */
kind = GetEventKind(event);
switch (kind)
{
case kEventWindowBoundsChanged:
GetEventParameter(event, kEventParamCurrentBounds, typeQDRectangle, NULL, sizeof(Rect), NULL, &rect);
if (aglContext)
aglUpdateContext(aglContext);
altEngine.resize(rect.right - rect.left, rect.bottom - rect.top);
break;
case kEventWindowShown:
WindowVisible = 1;
break;
case kEventWindowHidden:
WindowVisible = 0;
break;
case kEventMouseDown:
GetEventParameter(event, kEventParamMouseButton, typeMouseButton, NULL, sizeof(EventMouseButton), NULL, &button);
GetEventParameter(event, kEventParamMouseLocation, typeQDPoint, NULL, sizeof(Point), NULL, &point);
//MouseFunc(button, 0, point.h, point.v);
break;
case kEventMouseUp:
GetEventParameter(event, kEventParamMouseButton, typeMouseButton, NULL, sizeof(EventMouseButton), NULL, &button);
GetEventParameter(event, kEventParamMouseLocation, typeQDPoint, NULL, sizeof(Point), NULL, &point);
//MouseFunc(button, 1, point.h, point.v);
break;
case kEventMouseDragged:
GetEventParameter(event, kEventParamMouseLocation, typeQDPoint, NULL, sizeof(Point), NULL, &point);
//MotionFunc(point.h, point.v);
break;
case kEventWindowClose:
altEngine.destroy();
ExitToShell();
break;
default:
return CallNextEventHandler(nextHandler, event);
}
return noErr;
}
bool Window::processEvent( const EventType type, const EventRef eventRef,
SizeEvent& event )
{
if( type == EVENT_WINDOW_RESIZE && _impl->aglContext )
aglUpdateContext( _impl->aglContext );
return WindowIF::processEvent( type, eventRef, event );
}
void AquaOglGlue::render()
{
GNASH_REPORT_FUNCTION;
assert(aglSetCurrentContext(_context));
aglUpdateContext(_context);
aglSwapBuffers(_context);
}
static OSStatus handleWindowEvent(EventHandlerCallRef nextHandler, EventRef event, void *userData)
{
OSStatus err;
// Get the window
WindowRef window;
err = GetEventParameter(event, kEventParamDirectObject, typeWindowRef, 0, sizeof(window), 0, &window);
if (err != noErr)
return err;
// Handle the different kinds of events
::UInt32 eventKind = GetEventKind(event);
switch (eventKind)
{
// Quit the application when the user closes the window
case kEventWindowClose:
QuitApplicationEventLoop();
return noErr;
// Draw the contents of the window
case kEventWindowDrawContent:
redraw();
return noErr;
case kEventWindowBoundsChanged:
{
// Update the GL context
aglUpdateContext(win->getContext());
// Find out if we have a move or a resize situation
::UInt32 attributes;
GetEventParameter(event, kEventParamAttributes, typeUInt32, 0, sizeof(attributes), 0, &attributes);
if ((attributes & kWindowBoundsChangeSizeChanged) != 0)
{
// Get the new bounds of the window
Rect bounds;
GetEventParameter(event, kEventParamCurrentBounds, typeQDRectangle, 0, sizeof(Rect), 0, &bounds);
// Resize the OpenSG Window
GLsizei width = bounds.right - bounds.left;
GLsizei height = bounds.bottom - bounds.top;
win->resize(width, height);
// Redraw the whole window
Rect portRect;
GetWindowPortBounds(window, &portRect);
InvalWindowRect(window, &portRect);
}
return noErr;
}
default:
return eventNotHandledErr;
}
}
void DoDrag(WindowPtr myWindow, Point mouseloc)
{
Rect dragBounds;
dragBounds = (**GetGrayRgn()).rgnBBox;
DragWindow(myWindow,mouseloc,&dragBounds);
aglUpdateContext(aglGetCurrentContext());
}
void OpenGLApp::onSize(const int w, const int h){
BaseApp::onSize(w, h);
if (glContext != NULL){
#if defined(__APPLE__)
aglUpdateContext(glContext);
#endif
glViewport(0, 0, w, h);
}
}
static void DoUpdate(WindowPtr myWindow)
{
GrafPtr origPort;
GetPort(&origPort);
SetPort(myWindow);
BeginUpdate(myWindow);
EndUpdate(myWindow);
aglUpdateContext(aglGetCurrentContext());
SetPort(origPort);
}
OSStatus HIOpenGLViewEventControlDraw (EventHandlerCallRef, EventRef, HIOpenGLViewData* inData)
{
// We don't always know the control bounds at construction time, so
// we wait until the first time we draw to set up the OpenGL context.
AGLContext context = HIOpenGLViewGetContext(inData);
HIRect bounds;
OSStatus err = HIViewGetBounds(inData->mControl, &bounds);
if (err != noErr) return err;
double w = bounds.size.width;
double h = bounds.size.height;
double alpha = (GetControlHilite(inData->mControl) == kControlNoPart) ? 1.0 : 0.5;
aglSetCurrentContext(context);
aglUpdateContext(context);
glClearColor(1.0, 1.0, 1.0, 1.0);
glClear (GL_COLOR_BUFFER_BIT);
glEnable(GL_SMOOTH);
glEnable(GL_ALPHA_TEST);
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
glEnable(GL_BLEND);
GLint r[4];
glGetIntegerv(GL_VIEWPORT, r);
glMatrixMode(GL_PROJECTION);
glPushMatrix();
glLoadIdentity();
gluOrtho2D(0, r[2] - r[0], 0, r[3] - r[1]);
glMatrixMode(GL_MODELVIEW);
glPushMatrix();
glLoadIdentity();
glBegin(GL_QUADS);
glColor4f(1.0, 0.0, 0.0, alpha);
glVertex3f(0.0, h, 0.0);
glColor4f(1.0, 1.0, 0.0, alpha);
glVertex3f(w, h, 0.0);
glColor4f(0.0, 0.0, 1.0, alpha);
glVertex3f(w, 0.0, 0.0);
glColor4f(0.0, 1.0, 0.0, alpha);
glVertex3f(0.0, 0.0, 0.0);
glEnd();
aglSwapBuffers(context);
return noErr;
}
void wxGLCanvas::SetViewport()
{
#ifndef __LP64__
// viewport is initially set to entire port
// adjust glViewport to just this window
int x = 0 ;
int y = 0 ;
wxWindow* iter = this ;
while( iter->GetParent() )
{
iter = iter->GetParent() ;
}
if ( iter && iter->IsTopLevel() )
{
MacClientToRootWindow( &x , &y ) ;
int width, height;
GetClientSize(& width, & height);
Rect bounds ;
#if 0
// TODO in case we adopt point vs pixel coordinates, this will make the conversion
GetWindowPortBounds( MAC_WXHWND(MacGetTopLevelWindowRef()) , &bounds ) ;
HIRect hiRect = CGRectMake( x, y, width, height ) ;
HIRectConvert( &hiRect, kHICoordSpace72DPIGlobal, NULL, kHICoordSpaceScreenPixel, NULL) ;
HIRect hiBounds = CGRectMake( 0, 0, bounds.right - bounds.left , bounds.bottom - bounds.top ) ;
HIRectConvert( &hiBounds, kHICoordSpace72DPIGlobal, NULL, kHICoordSpaceScreenPixel, NULL) ;
GLint parms[4] ;
parms[0] = hiRect.origin.x ;
parms[1] = hiBounds.size.height - (hiRect.origin.y + hiRect.size.height) ;
parms[2] = hiRect.size.width ;
parms[3] = hiRect.size.height ;
#else
GetWindowPortBounds( MAC_WXHWND(MacGetTopLevelWindowRef()) , &bounds ) ;
GLint parms[4] ;
parms[0] = x ;
parms[1] = bounds.bottom - bounds.top - ( y + height ) ;
parms[2] = width ;
parms[3] = height ;
#endif
if ( !m_macCanvasIsShown )
parms[0] += 20000 ;
aglSetInteger( m_glContext->m_glContext , AGL_BUFFER_RECT , parms ) ;
aglUpdateContext(m_glContext->m_glContext);
}
#endif
}
void QGLWidget::resizeEvent(QResizeEvent *)
{
Q_D(QGLWidget);
if(!isValid())
return;
if (!isWindow())
d->glcx->d_func()->update = true;
makeCurrent();
if(!d->glcx->initialized())
glInit();
resizeGL(width(), height());
if(d->olcx) {
makeOverlayCurrent();
aglUpdateContext((AGLContext)d->olcx);
resizeOverlayGL(width(), height());
}
}
//-------------------------------------------------------------------------------------------------//
void OSXCarbonWindow::windowMovedOrResized()
{
// External windows will call this method.
if(mView != NULL)
{
// Determine the AGL_BUFFER_RECT for the view. The coordinate
// system for this rectangle is relative to the owning window, with
// the origin at the bottom left corner and the y-axis inverted.
// Also, when leaving fullscreen, the display properties are not guaranteed to be
// the same as when we were windowed previously. So resize the window and views back
// to their original dimensions.
HIRect newFrame = CGRectMake(mLeft, mTop+22, mWidth, mHeight);
HIRect viewBounds = CGRectZero, winBounds = CGRectZero;
SizeWindow(mWindow, mWidth, mHeight, true);
HIViewSetFrame(mView, &newFrame);
HIViewGetBounds(mView, &viewBounds);
HIViewRef root = HIViewGetRoot(HIViewGetWindow(mView));
HIViewGetBounds(root, &winBounds);
HIViewConvertRect(&viewBounds, mView, root);
// Set the AGL buffer rectangle (i.e. the bounds that we will use)
GLint bufferRect[4];
bufferRect[0] = viewBounds.origin.x; // 0 = left edge
bufferRect[1] = winBounds.size.height - (viewBounds.origin.y + viewBounds.size.height); // 0 = bottom edge
bufferRect[2] = viewBounds.size.width; // width of buffer rect
bufferRect[3] = viewBounds.size.height; // height of buffer rect
aglSetInteger(mAGLContext, AGL_BUFFER_RECT, bufferRect);
aglEnable(mAGLContext, AGL_BUFFER_RECT);
aglUpdateContext(mAGLContext);
mLeft = viewBounds.origin.x;
mTop = bufferRect[1];
}
for (ViewportList::iterator it = mViewportList.begin(); it != mViewportList.end(); ++it)
{
(*it).second->_updateDimensions();
}
}
//-------------------------------------------------------------------------------------------------//
void OSXCarbonWindow::windowResized()
{
// Ensure the context is current
if(!mIsFullScreen)
{
// Determine the AGL_BUFFER_RECT for the view. The coordinate
// system for this rectangle is relative to the owning window, with
// the origin at the bottom left corner and the y-axis inverted.
HIRect newFrame = CGRectMake(mLeft, mTop+22, mWidth, mHeight);
HIRect viewBounds = CGRectZero, winBounds = CGRectZero;
SizeWindow(mWindow, mWidth, mHeight, true);
HIViewSetFrame(mView, &newFrame);
HIViewGetBounds(mView, &viewBounds);
HIViewRef root = HIViewGetRoot(HIViewGetWindow(mView));
HIViewGetBounds(root, &winBounds);
HIViewConvertRect(&viewBounds, mView, root);
// Set the AGL buffer rectangle (i.e. the bounds that we will use)
GLint bufferRect[4];
bufferRect[0] = viewBounds.origin.x; // 0 = left edge
bufferRect[1] = winBounds.size.height - (viewBounds.origin.y + viewBounds.size.height); // 0 = bottom edge
bufferRect[2] = viewBounds.size.width; // width of buffer rect
bufferRect[3] = viewBounds.size.height; // height of buffer rect
aglSetInteger(mAGLContext, AGL_BUFFER_RECT, bufferRect);
aglEnable(mAGLContext, AGL_BUFFER_RECT);
aglUpdateContext(mAGLContext);
mLeft = viewBounds.origin.x;
mTop = bufferRect[1];
}
else
{
swapCGLBuffers();
}
for (ViewportList::iterator it = mViewportList.begin(); it != mViewportList.end(); ++it)
{
(*it).second->_updateDimensions();
}
}
void wxGLCanvas::SetViewport()
{
if ( !m_needsUpdate )
return;
m_needsUpdate = false;
// AGLContext context = aglGetCurrentContext();
// if ( !context )
// return;
// viewport is initially set to entire port, adjust it to just this window
int x = 0,
y = 0;
MacClientToRootWindow(&x , &y);
int width, height;
GetClientSize(&width, &height);
Rect bounds;
GetWindowPortBounds(MAC_WXHWND(MacGetTopLevelWindowRef()) , &bounds);
GLint parms[4];
parms[0] = x;
parms[1] = bounds.bottom - bounds.top - ( y + height );
parms[2] = width;
parms[3] = height;
// move the buffer rect out of sight if we're hidden
if ( !m_macCanvasIsShown )
parms[0] += 20000;
if ( !aglSetInteger(m_dummyContext, AGL_BUFFER_RECT, parms) )
wxLogAGLError("aglSetInteger(AGL_BUFFER_RECT)");
if ( !aglEnable(m_dummyContext, AGL_BUFFER_RECT) )
wxLogAGLError("aglEnable(AGL_BUFFER_RECT)");
if ( !aglUpdateContext(m_dummyContext) )
wxLogAGLError("aglUpdateContext");
}
void
PaneView::resize(short left, short top, short right, short bottom)
{
aglSetCurrentContext(_model._aglContext);
aglUpdateContext(_model._aglContext);
short width = right - left;
short height = bottom - top;
float aspectRatio = (float) width / (float) height;
// float fieldOfViewY = 45.0f * _model.getSpace().getCurrentShot().getCamera().getZoom();
float fieldOfViewY = 45.0f * _model.getSpace().getShots().next().getCamera().getZoom();
Rect portRect;
GetWindowPortBounds(_model._windowRef, &portRect);
short portHeight = portRect.bottom - portRect.top;
GLint bufferRect[4];
bufferRect[0] = _model._bounds->left; // x
bufferRect[1] = portHeight - _model._bounds->bottom; // y
bufferRect[2] = _model._bounds->right - _model._bounds->left; // width
bufferRect[3] = _model._bounds->bottom - _model._bounds->top; // height
aglSetInteger(_model._aglContext, AGL_BUFFER_RECT, bufferRect);
aglEnable(_model._aglContext, AGL_BUFFER_RECT);
// aglSetInteger(inData->mContext, AGL_CLIP_REGION, (const GLint*)rgn);
// aglEnable(inData->mContext, AGL_CLIP_REGION);
glViewport(0, 0, width, height);
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
gluPerspective(fieldOfViewY, aspectRatio, 1.0f, 1000.0f);
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
InvalWindowRect(_model._windowRef, &portRect);
_model.getSpace().resize(width, height);
}
void CL_DisplayWindow_OpenGL::set_windowed()
{
if(!fullscreen)
return;
if (context == fs_context)
{
aglSetDrawable(fs_context, 0);
}
CGReleaseAllDisplays();
aglSetCurrentContext(win_context);
aglUpdateContext(win_context);
install_event_handler(GetWindowEventTarget(window_ref));
fullscreen = false;
context = win_context;
focus = IsWindowHilited(window_ref);
//After toggling to the fullscreen context, nothing is going draw unless
//we reapply the GL states/properties -mrfun 6-2-2006
CL_GLStateChecker::from_gc(get_gc())->reinitialize_asap();
}
// ---------------------------------------------------------------------------
void OSXWindowImpl::on_init()
{
init_gl();
init_glfont();
aglUpdateContext(mGLContext);
}
void QGLContext::updatePaintDevice()
{
Q_D(QGLContext);
d->update = false;
#if 0 //(MAC_OS_X_VERSION_MAX_ALLOWED >= MAC_OS_X_VERSION_10_5)
if (QSysInfo::MacintoshVersion >= QSysInfo::MV_10_5) {
if(d->paintDevice->devType() == QInternal::Widget) {
QWidget *w = (QWidget *)d->paintDevice;
aglSetHIViewRef((AGLContext)d->cx, (HIViewRef)w->winId());
} else if(d->paintDevice->devType() == QInternal::Pixmap) {
QPixmap *pm = (QPixmap *)d->paintDevice;
aglSetOffScreen((AGLContext)d->cx, pm->width(), pm->height(),
qt_mac_pixmap_get_bytes_per_line(pm), qt_mac_pixmap_get_base(pm));
} else {
qWarning("QGLContext::updatePaintDevice(): Not sure how to render OpenGL on this device!");
}
} else
#endif
{
#ifndef Q_OS_MAC64
if(d->paintDevice->devType() == QInternal::Widget) {
//get control information
QWidget *w = (QWidget *)d->paintDevice;
HIViewRef hiview = (HIViewRef)w->winId();
WindowPtr window = qt_mac_window_for(hiview);
#ifdef DEBUG_OPENGL_REGION_UPDATE
static int serial_no_gl = 0;
qDebug("[%d] %p setting on %s::%s %p/%p [%s]", ++serial_no_gl, w,
w->metaObject()->className(), w->objectName().toLatin1().constData(),
hiview, window, w->handle() ? "Inside" : "Outside");
#endif
//update drawable
if(0 && w->isWindow() && w->isFullScreen()) {
aglSetDrawable((AGLContext)d->cx, 0);
aglSetFullScreen((AGLContext)d->cx, w->width(), w->height(), 0, QApplication::desktop()->screenNumber(w));
w->hide();
} else {
AGLDrawable old_draw = aglGetDrawable((AGLContext)d->cx), new_draw = GetWindowPort(window);
if(old_draw != new_draw)
aglSetDrawable((AGLContext)d->cx, new_draw);
}
if(!w->isWindow()) {
QRegion clp = qt_mac_get_widget_rgn(w); //get drawable area
#ifdef DEBUG_OPENGL_REGION_UPDATE
if(clp.isEmpty()) {
qDebug(" Empty area!");
} else {
QVector<QRect> rs = clp.rects();
for(int i = 0; i < rs.count(); i++)
qDebug(" %d %d %d %d", rs[i].x(), rs[i].y(), rs[i].width(), rs[i].height());
}
#endif
//update the clip
if(!aglIsEnabled((AGLContext)d->cx, AGL_BUFFER_RECT))
aglEnable((AGLContext)d->cx, AGL_BUFFER_RECT);
if(clp.isEmpty()) {
GLint offs[4] = { 0, 0, 0, 0 };
aglSetInteger((AGLContext)d->cx, AGL_BUFFER_RECT, offs);
if(aglIsEnabled((AGLContext)d->cx, AGL_CLIP_REGION))
aglDisable((AGLContext)d->cx, AGL_CLIP_REGION);
} else {
HIPoint origin = { 0., 0. };
HIViewConvertPoint(&origin, HIViewRef(w->winId()), 0);
const GLint offs[4] = { qRound(origin.x),
w->window()->frameGeometry().height()
- (qRound(origin.y) + w->height()),
w->width(), w->height() };
aglSetInteger((AGLContext)d->cx, AGL_BUFFER_RECT, offs);
aglSetInteger((AGLContext)d->cx, AGL_CLIP_REGION, (const GLint *)clp.handle(true));
if(!aglIsEnabled((AGLContext)d->cx, AGL_CLIP_REGION))
aglEnable((AGLContext)d->cx, AGL_CLIP_REGION);
}
}
} else if(d->paintDevice->devType() == QInternal::Pixmap) {
QPixmap *pm = (QPixmap *)d->paintDevice;
PixMapHandle mac_pm = GetGWorldPixMap((GWorldPtr)pm->macQDHandle());
aglSetOffScreen((AGLContext)d->cx, pm->width(), pm->height(),
GetPixRowBytes(mac_pm), GetPixBaseAddr(mac_pm));
} else {
qWarning("QGLContext::updatePaintDevice(): Not sure how to render OpenGL on this device!");
}
#endif // Q_OS_MAC64
}
aglUpdateContext((AGLContext)d->cx);
}
OSStatus _glfwWindowEventHandler( EventHandlerCallRef handlerCallRef,
EventRef event,
void *userData )
{
switch( GetEventKind(event) )
{
case kEventWindowBoundsChanged:
{
WindowRef window;
GetEventParameter( event, kEventParamDirectObject, typeWindowRef, NULL,
sizeof(WindowRef), NULL, &window );
Rect rect;
GetWindowPortBounds( window, &rect );
if( _glfwWin.Width != rect.right ||
_glfwWin.Height != rect.bottom )
{
aglUpdateContext(_glfwWin.AGLContext);
_glfwWin.Width = rect.right;
_glfwWin.Height = rect.bottom;
if( _glfwWin.WindowSizeCallback )
{
_glfwWin.WindowSizeCallback( _glfwWin.Width,
_glfwWin.Height );
}
// Emulate (force) content invalidation
if( _glfwWin.WindowRefreshCallback )
{
_glfwWin.WindowRefreshCallback();
}
}
break;
}
case kEventWindowClose:
{
// Check if the program wants us to close the window
if( _glfwWin.WindowCloseCallback )
{
if( _glfwWin.WindowCloseCallback() )
{
glfwCloseWindow();
}
}
else
{
glfwCloseWindow();
}
return noErr;
}
case kEventWindowDrawContent:
{
// Call user callback function
if( _glfwWin.WindowRefreshCallback )
{
_glfwWin.WindowRefreshCallback();
}
break;
}
case kEventWindowActivated:
{
_glfwWin.Active = GL_TRUE;
break;
}
case kEventWindowDeactivated:
{
_glfwWin.Active = GL_FALSE;
_glfwInputDeactivation();
break;
}
}
return eventNotHandledErr;
}
OSStatus CSMNativeWindow::handleWindowEvent(EventHandlerCallRef nextHandler,
EventRef event )
{
OSStatus err;
// Get the window
WindowRef window;
err = GetEventParameter(event,
kEventParamDirectObject,
typeWindowRef, 0, sizeof(window), 0, &window);
if (err != noErr)
return err;
// Handle the different kinds of events
::UInt32 eventKind = GetEventKind(event);
switch (eventKind)
{
// Quit the application when the user closes the window
case kEventWindowClose:
//QuitApplicationEventLoop();
_bRun = false;
return noErr;
// Draw the contents of the window
case kEventWindowDrawContent:
//ComplexSceneManager::the()->frame();
//Thread::getCurrentChangeList()->commitChangesAndClear();
return noErr;
case kEventWindowBoundsChanged:
{
// Update the GL context
// WARNING this crap might crash later
aglUpdateContext(_pCarbWindow->getContext());
// Find out if we have a move or a resize situation
::UInt32 attributes;
GetEventParameter(event,
kEventParamAttributes,
typeUInt32,
0,
sizeof(attributes),
0,
&attributes);
if ((attributes & kWindowBoundsChangeSizeChanged) != 0)
{
// Get the new bounds of the window
Rect bounds;
GetEventParameter(event,
kEventParamCurrentBounds,
typeQDRectangle,
0,
sizeof(Rect),
0,
&bounds);
// Resize the OpenSG Window
GLsizei width = bounds.right - bounds.left;
GLsizei height = bounds.bottom - bounds.top;
this->reshape(width, height);
// Redraw the whole window
Rect portRect;
GetWindowPortBounds(window, &portRect);
InvalWindowRect (window, &portRect);
}
return noErr;
}
default:
return eventNotHandledErr;
}
}
// ---------------------------------------------------------------------------
OSStatus OSXWindowImpl::windowHandler(EventHandlerCallRef next, EventRef e) {
EventClass clazz = GetEventClass(e);
EventKind kind = GetEventKind(e);
switch( clazz ) {
case kEventClassWindow:
{
switch( kind ) {
case kEventWindowDrawContent:
on_paint();
break;
case kEventWindowClosed:
on_dispose();
break;
case kEventWindowBoundsChanged:
{
aglUpdateContext(mGLContext);
GetWindowBounds(mWindowRef,kWindowContentRgn,&mRect);
if (window)
window->resize( mRect.right - mRect.left, mRect.bottom - mRect.top );
}
break;
}
}
break;
case kEventClassMouse:
{
EventMouseButton button;
GetEventParameter(e,kEventParamMouseButton, typeMouseButton, NULL, sizeof(button), NULL, &button);
Point location;
GetEventParameter(e,kEventParamMouseLocation, typeQDPoint, NULL, sizeof(Point), NULL, &location);
int mouseX = location.h - mRect.left;
int mouseY = location.v - mRect.top;
switch( kind ) {
case kEventMouseDown:
{
UInt32 mod = GetCurrentKeyModifiers();
if (mod & EMULATE_RIGHT_KEYMOD) {
mButtonDown = GUI_ButtonRight;
mMouseDownMod = EMULATE_RIGHT_KEYMOD;
} else if (mod & EMULATE_MIDDLE_KEYMOD) {
mButtonDown = GUI_ButtonMiddle;
mMouseDownMod = EMULATE_MIDDLE_KEYMOD;
} else {
mButtonDown = button;
mMouseDownMod = 0;
}
window->buttonPress( mButtonDown,mouseX,mouseY);
}
break;
case kEventMouseUp:
if ( (mButtonDown) && ( (mMouseDownMod) || (mButtonDown == button) ) ) {
window->buttonRelease( mButtonDown,mouseX,mouseY);
mMouseDownMod = 0;
mButtonDown = 0;
}
break;
case kEventMouseMoved:
case kEventMouseDragged:
window->mouseMove(mouseX,mouseY);
break;
case kEventMouseWheelMoved:
UInt16 axis;
GetEventParameter(e,kEventParamMouseWheelAxis, typeMouseWheelAxis, NULL, sizeof(axis), NULL, &axis);
if (axis == kEventMouseWheelAxisY) {
int delta;
GetEventParameter(e,kEventParamMouseWheelDelta, typeSInt32, NULL, sizeof(delta), NULL, &delta);
if (delta != 0)
window->wheelRotate( (delta > 0) ? GUI_WheelForward : GUI_WheelBackward );
}
}
}
break;
case kEventClassKeyboard:
{
UInt32 keycode;
GetEventParameter(e,kEventParamKeyCode, typeUInt32, NULL, sizeof(keycode), NULL, &keycode);
switch( kind ) {
case kEventRawKeyDown:
break;
case kEventRawKeyUp:
break;
case kEventRawKeyModifiersChanged:
break;
default:
break;
}
}
break;
default:
break;
}
return CallNextEventHandler(next,e);
}
