TheCloud/panda3d
1
0
Fork 0
mirror of https://github.com/panda3d/panda3d.git synced 2025-10-04 02:42:49 -04:00
Code Issues Packages Projects Releases Wiki Activity

Cleaning up Some..

Browse Source
This commit is contained in:
Roger Hughston 2006-03-11 01:54:02 +00:00
parent 5a52512d8e
commit 325e42d530
10 changed files with 568 additions and 530 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

11
panda/src/osxdisplay/config_osxdisplay.cxx
View File

@ -1,10 +1,7 @@
// Filename: config_glxdisplay.cxx
// Created by: cary (07Oct99)
//
////////////////////////////////////////////////////////////////////
//
// PANDA 3D SOFTWARE
// Copyright (c) 2001 - 2004, Disney Enterprises, Inc. All rights reserved
// Copyright (c) 2001 - 2006, Disney Enterprises, Inc. All rights reserved
//
// All use of this software is subject to the terms of the Panda 3d
// Software license. You should have received a copy of this license
@ -55,8 +52,6 @@ init_libosxdisplay() {
}
initialized = true;
printf("****** In libosx init \n");
osxGraphicsStateGuardian::init_type();
osxGraphicsPipe::init_type();
osxGraphicsWindow::init_type();
@ -69,8 +64,4 @@ init_libosxdisplay() {
PandaSystem *ps = PandaSystem::get_global_ptr();
ps->set_system_tag("OpenGL", "window_system", "OSX");
printf("****** out libosx init \n");
}

3
panda/src/osxdisplay/config_osxdisplay.h
View File

@ -1,7 +1,7 @@
////////////////////////////////////////////////////////////////////
//
// PANDA 3D SOFTWARE
// Copyright (c) 2001 - 2004, Disney Enterprises, Inc. All rights reserved
// Copyright (c) 2001 - 2006, Disney Enterprises, Inc. All rights reserved
//
// All use of this software is subject to the terms of the Panda 3d
// Software license. You should have received a copy of this license
@ -26,6 +26,5 @@ NotifyCategoryDecl( osxdisplay , EXPCL_PANDAGL, EXPTP_PANDAGL);
extern EXPCL_PANDAGL void init_libosxdisplay();
extern ConfigVariableString display_cfg;
extern ConfigVariableBool osx_error_abort;
#endif /* __CONFIG_OSXDISPLAY_H__ */

14
panda/src/osxdisplay/osxGraphicsBuffer.cxx
View File

@ -38,8 +38,6 @@ osxGraphicsBuffer(GraphicsPipe *pipe, GraphicsStateGuardian *gsg,
osxGraphicsPipe *osx_pipe;
DCAST_INTO_V(osx_pipe, _pipe);
// Since the pbuffer never gets flipped, we get screenshots from the
// same buffer we draw into.
_screenshot_buffer_type = _draw_buffer_type;
}
@ -74,13 +72,10 @@ begin_frame(FrameMode mode) {
DCAST_INTO_R(osxgsg, _gsg, false);
// osxMakeCurrent(_display, _pbuffer, osxgsg->_context);
// Now that we have made the context current to a window, we can
// reset the GSG state if this is the first time it has been used.
// (We can't just call reset() when we construct the GSG, because
// reset() requires having a current context.)
osxgsg->reset_if_new();
if (mode == FM_render) {
if (mode == FM_render)
{
// begin_render_texture();
clear_cube_map_selection();
}
@ -99,7 +94,8 @@ end_frame(FrameMode mode) {
end_frame_spam();
nassertv(_gsg != (GraphicsStateGuardian *)NULL);
if (mode == FM_render) {
if (mode == FM_render)
{
// end_render_texture();
copy_to_textures();
}
@ -138,7 +134,7 @@ release_gsg() {
void osxGraphicsBuffer::
close_buffer() {
// _is_valid = false;
_is_valid = false;
}
////////////////////////////////////////////////////////////////////

15
panda/src/osxdisplay/osxGraphicsBuffer.h
View File

@ -26,14 +26,11 @@
#include "graphicsBuffer.h"
#include "glgsg.h"
// This must be included after we have included glgsg.h (which
// includes gl.h).
//#include "wglext.h"
//#include <windows.h>
////////////////////////////////////////////////////////////////////
// Class : OSXGraphicsBuffer
// rhh mar-2006
// Sorry ... this is not functional at all... I have no need for it yet ?
//
////////////////////////////////////////////////////////////////////
class EXPCL_PANDAGL osxGraphicsBuffer : public GraphicsBuffer {
public:
@ -42,20 +39,16 @@ public:
int x_size, int y_size);
virtual ~osxGraphicsBuffer();
virtual bool begin_frame(FrameMode mode);
virtual void end_frame(FrameMode mode);
virtual void release_gsg();
// virtual void begin_render_texture();
// virtual void end_render_texture();
protected:
virtual void close_buffer();
virtual bool open_buffer();
private:
public:
static TypeHandle get_class_type() {

1
panda/src/osxdisplay/osxGraphicsPipe.cxx
View File

@ -19,7 +19,6 @@
#include "osxGraphicsBuffer.h"
#include "osxGraphicsStateGuardian.h"
//typedef enum {Software, MCD, ICD} OGLDriverType;
TypeHandle osxGraphicsPipe::_type_handle;

2
panda/src/osxdisplay/osxGraphicsPipe.h
View File

@ -64,6 +64,4 @@ private:
friend class osxGraphicsBuffer;
};
//#include "osxGraphicsPipe.I"
#endif

4
panda/src/osxdisplay/osxGraphicsStateGuardian.cxx
View File

@ -60,7 +60,6 @@ osxGraphicsStateGuardian(const FrameBufferProperties &properties,
_aglPixFmt(NULL),
_aglcontext(NULL)
{
}
////////////////////////////////////////////////////////////////////
@ -102,7 +101,8 @@ void osxGraphicsStateGuardian::reset()
////////////////////////////////////////////////////////////////////
// Function: osxGraphicsStateGuardian::buildGL
// Access: Public, Virtual
// Description:
// Description: This function will build up a context for a gsg..
// rhh.. This does not respect the flags passed into it for context type ?? hmmm things to do things to do..
//
////////////////////////////////////////////////////////////////////
OSStatus osxGraphicsStateGuardian::buildGL (osxGraphicsWindow &window)

8
panda/src/osxdisplay/osxGraphicsStateGuardian.h
View File

@ -40,18 +40,14 @@ public:
osxGraphicsStateGuardian *share_with,
int pfnum);
virtual ~osxGraphicsStateGuardian();
virtual void reset();
AGLContext get_context(void) { return _aglcontext; };
OSStatus buildGL (osxGraphicsWindow &window);
protected:
virtual void *get_extension_func(const char *prefix, const char *name);
private:
OSStatus buildGL (osxGraphicsWindow &window);
AGLContext get_context(void) { return _aglcontext; };
// We have to save a pointer to the GSG we intend to share texture
// context with, since we don't create our own context in the

263
panda/src/osxdisplay/osxGraphicsWindow.cxx
View File

@ -27,20 +27,18 @@
#include <AGL/agl.h>
#include <ApplicationServices/ApplicationServices.h>
////////////////////////// Global Objects .....
TypeHandle osxGraphicsWindow::_type_handle;
osxGraphicsWindow * osxGraphicsWindow::FullScreenWindow = NULL;
ButtonHandle OSX_TranslateKey( UInt32 key, EventRef event );
EventHandlerUPP gEvtHandler; // main event handler
EventHandlerUPP gWinEvtHandler; // window event handler
//AbsoluteTime gStartTime;
char gErrorMessage[256] = ""; // buffer for error message output
float gErrorTime = 0.0;
static osxGraphicsWindow * FullScreenWindow = NULL;
osxGraphicsWindow * GetCurrentOSxWindow (WindowRef window)
////////////////////////////////////////////////////////////////////
// Function: GetCurrentOSxWindow
// Access: Static,
// Description: How to find the active window for events on osx..
//
////////////////////////////////////////////////////////////////////
osxGraphicsWindow * osxGraphicsWindow::GetCurrentOSxWindow (WindowRef window)
{
if(FullScreenWindow != NULL)
return FullScreenWindow;
@ -53,8 +51,12 @@ osxGraphicsWindow * GetCurrentOSxWindow (WindowRef window)
return NULL;
}
////////////////////////////////////////////////////////////////////
// Function: aglReportError
// Access: public
// Description: Helper function for AGL error message and Grabing error code if any
//
////////////////////////////////////////////////////////////////////
OSStatus aglReportError (void)
{
GLenum err = aglGetError();
@ -66,8 +68,13 @@ OSStatus aglReportError (void)
else
return (OSStatus) err;
}
void InvertGLImage( char *imageData, size_t imageSize, size_t rowBytes )
////////////////////////////////////////////////////////////////////
// Function: InvertGLImage
// Access: file scopre, static
// Description: Helper function invertiung a gl image
//
////////////////////////////////////////////////////////////////////
static void InvertGLImage( char *imageData, size_t imageSize, size_t rowBytes )
{
size_t i, j;
char *tBuffer = (char*) malloc (rowBytes);
@ -82,8 +89,13 @@ void InvertGLImage( char *imageData, size_t imageSize, size_t rowBytes )
free(tBuffer);
}
void CompositeGLBufferIntoWindow (AGLContext ctx, Rect *bufferRect, GrafPtr out_port)
////////////////////////////////////////////////////////////////////
// Function: CompositeGLBufferIntoWindow
// Access: file scopre, static
// Description: Drop a Gl overlay onto a carbon window..
//
////////////////////////////////////////////////////////////////////
static void CompositeGLBufferIntoWindow (AGLContext ctx, Rect *bufferRect, GrafPtr out_port)
{
GWorldPtr pGWorld;
QDErr err;
@ -93,7 +105,6 @@ void CompositeGLBufferIntoWindow (AGLContext ctx, Rect *bufferRect, GrafPtr out_
long height = (bufferRect->bottom - bufferRect->top);
Rect src_rect = {0, 0, height, width};
Rect ddrc_rect = {0, 0, height, width};
long rowBytes = width * 4;
@ -104,8 +115,6 @@ void CompositeGLBufferIntoWindow (AGLContext ctx, Rect *bufferRect, GrafPtr out_
return; // no harm in continuing
}
// printf(" Reading aa Conte Data %d %d\n",height,width);
// pull GL content down to our image buffer
aglSetCurrentContext( ctx );
glReadPixels (0, 0, width, height, GL_BGRA, GL_UNSIGNED_INT_8_8_8_8_REV, image);
@ -131,16 +140,26 @@ void CompositeGLBufferIntoWindow (AGLContext ctx, Rect *bufferRect, GrafPtr out_
DisposeGWorld( pGWorld );
DisposePtr ( image );
}
////////////////////////////////////////////////////////////////////
// Function: osxGraphicsWindow::SystemCloseWindow
// Access: private
// Description: The Windows is closed by a OS resource not by a internal request
//
////////////////////////////////////////////////////////////////////
void osxGraphicsWindow::SystemCloseWindow()
{
osxdisplay_cat.debug() << "System Closing Window \n";
ReleaseSystemResources();
};
// window event handler
////////////////////////////////////////////////////////////////////
// Function: windowEvtHndlr
// Access: file scope static
// Description: The C callback for Window Events ..
//
// We only hook this up for none fullscreen window... so we only handle system window events..
//
////////////////////////////////////////////////////////////////////
static pascal OSStatus windowEvtHndlr (EventHandlerCallRef myHandler, EventRef event, void* userData)
{
#pragma unused (userData)
@ -187,9 +206,17 @@ static pascal OSStatus windowEvtHndlr (EventHandlerCallRef myHandler, EventRef e
}
return result;
}
///////////////////////////////////////////////////////////////////
// Function: osxGraphicsWindow::DoResize
// Access:
// Description: The C callback for Window Events ..
//
// We only hook this up for none fullscreen window... so we only handle system window events..
//
////////////////////////////////////////////////////////////////////
void osxGraphicsWindow::DoResize(void)
{
// only in window mode .. not full screen
if(_osx_window != NULL)
{
Rect rectPort = {0,0,0,0};
@ -198,22 +225,27 @@ void osxGraphicsWindow::DoResize(void)
GetWindowPortBounds (_osx_window, &rectPort);
viewRect.size.width = (float) (rectPort.right - rectPort.left);
viewRect.size.height = (float) (rectPort.bottom - rectPort.top);
// tell panda
WindowProperties properties;
properties.set_size((int)viewRect.size.width,(int)viewRect.size.height);
properties.set_origin((int) rectPort.left,(int)rectPort.top);
system_changed_properties(properties);
osxdisplay_cat.debug() << " Resizing Window " << viewRect.size.width << " " << viewRect.size.height << "\n";
// ping gl
aglUpdateContext (aglGetCurrentContext());
aglReportError();
}
//printf(" Setting Window Size to %d %d \n",(int)viewRect.size.width,(int)viewRect.size.height);
};
// application level event handler
///////////////////////////////////////////////////////////////////
// Function: appEvtHndlr
// Access:
// Description: The C callback for APlication Events..
//
// Hooked once for application
//
////////////////////////////////////////////////////////////////////
static pascal OSStatus appEvtHndlr (EventHandlerCallRef myHandler, EventRef event, void* userData)
{
#pragma unused (myHandler)
@ -269,7 +301,13 @@ static pascal OSStatus appEvtHndlr (EventHandlerCallRef myHandler, EventRef even
return result;
}
///////////////////////////////////////////////////////////////////
// Function: osxGraphicsWindow::handleTextInput
// Access:
// Description: Trap Unicode Input.
//
//
////////////////////////////////////////////////////////////////////
OSStatus osxGraphicsWindow::handleTextInput (EventHandlerCallRef myHandler, EventRef theTextEvent)
{
UniChar *text = NULL;
@ -288,17 +326,19 @@ OSStatus osxGraphicsWindow::handleTextInput (EventHandlerCallRef myHandler, Even
return ret;
for(unsigned int x = 0; x < actualSize/sizeof(UniChar); ++x)
{
printf(" Push KetStroke %x\n",(int)text[x]);
_input_devices[0].keystroke(text[x]);
}
DisposePtr((char *)text);
}
return ret;
}
///////////////////////////////////////////////////////////////////
// Function: osxGraphicsWindow::handleTextInput
// Access: private..
// Description: Clean up the OS level messes..
////////////////////////////////////////////////////////////////////
void osxGraphicsWindow::ReleaseSystemResources()
{
@ -391,11 +431,11 @@ osxGraphicsWindow::~osxGraphicsWindow()
cerr << " osxGraphicsWindow::~osxGraphicsWindow() \n";
}
void osxGraphicsWindow::make_current()
{
}
///////////////////////////////////////////////////////////////////
// Function: osxGraphicsWindow::get_context
// Access: private..
// Description: Helper to Decide whitch context to use if any
////////////////////////////////////////////////////////////////////
AGLContext osxGraphicsWindow::get_context(void)
{
if(_aglcontext != NULL)
@ -403,6 +443,11 @@ AGLContext osxGraphicsWindow::get_context(void)
return get_ggs_context();
}
///////////////////////////////////////////////////////////////////
// Function: osxGraphicsWindow::get_ggs_context
// Access: private..
// Description:
////////////////////////////////////////////////////////////////////
AGLContext osxGraphicsWindow::get_ggs_context(void)
{
@ -415,7 +460,11 @@ AGLContext osxGraphicsWindow::get_ggs_context(void)
return NULL;
}
///////////////////////////////////////////////////////////////////
// Function: osxGraphicsWindow::buildGL
// Access: private..
// Description: Code of the class.. used to control the GL context Allocation ..
////////////////////////////////////////////////////////////////////
OSStatus osxGraphicsWindow::buildGL (void)
{
// make sure the ggs is up and runnig..
@ -479,20 +528,21 @@ bool osxGraphicsWindow::begin_frame(FrameMode mode) {
begin_frame_spam();
if (_gsg == (GraphicsStateGuardian *)NULL || (_osx_window == NULL && _is_fullsreen != true))
{
// not powered up .. just abort..
return false;
}
if(_is_fullsreen)
{
if (!aglSetCurrentContext(get_context()))
aglReportError ();
// printf(" In Full Screen begin_frame\n");
}
else
{
#ifndef HACK_SCREEN_HASH_CONTEXT
// if we do not have local contexts we need to do some wor
GrafPtr OtherWin = (GrafPtr)aglGetDrawable(get_context());
aglReportError();
WindowPtr other = GetWindowFromPort(OtherWin);
@ -505,6 +555,8 @@ bool osxGraphicsWindow::begin_frame(FrameMode mode) {
CompositeGLBufferIntoWindow(get_context(),& r,OtherWin);
}
// uggly uggly uggly on a mac ... not a good thing..
aglSetDrawable (get_context(),GetWindowPort (_osx_window));
aglReportError();
@ -513,6 +565,13 @@ bool osxGraphicsWindow::begin_frame(FrameMode mode) {
aglReportError ();
}
#else
if (!aglSetCurrentContext(get_context()))
aglReportError ();
#endif
@ -611,10 +670,9 @@ extern OSErr CPSSetFrontProcess( struct CPSProcessSerNum *psn);
// thread. Returns true if the window is successfully
// opened, or false if there was a problem.
////////////////////////////////////////////////////////////////////
bool osxGraphicsWindow::open_window() {
bool osxGraphicsWindow::open_window()
{
OSErr err;
printf(" In Open Window \n");
static bool GlobalInits = false;
if(GlobalInits != true)
@ -633,6 +691,7 @@ OSErr err;
{ kEventClassKeyboard, kEventRawKeyModifiersChanged } ,
{kEventClassTextInput, kEventTextInputUnicodeForKeyEvent},
};
EventHandlerUPP gEvtHandler; // main event handler
gEvtHandler = NewEventHandlerUPP(appEvtHndlr);
@ -718,13 +777,6 @@ if(_properties.has_fullscreen() && _properties.get_fullscreen() == true)
if (!aglSetInteger (get_context(), AGL_SWAP_INTERVAL, &swap))
aglReportError ();
// CreateNewWindow(//
// kOverlayWindowClass,
// kWindowStandardHandlerAttribute,
// &r, &_osx_window);
_is_fullsreen =true;
FullScreenWindow = this;
}
@ -742,6 +794,18 @@ else
if (_osx_window)
{
EventHandlerUPP gWinEvtHandler; // window event handler
EventHandlerRef ref;
EventTypeSpec list[] = { { kEventClassWindow, kEventWindowCollapsing },
{ kEventClassWindow, kEventWindowShown },
{ kEventClassWindow, kEventWindowActivated },
{ kEventClassWindow, kEventWindowClose },
{ kEventClassWindow, kEventWindowBoundsChanged },
{ kEventClassWindow, kEventWindowZoomed },
// { kEventClassKeyboard, kEventRawKeyDown },
// { kEventClassKeyboard, kEventRawKeyUp } ,
// { kEventClassKeyboard, kEventRawKeyModifiersChanged }
};
SetWRefCon (_osx_window, (long) this); // point to the window record in the ref con of the window
gWinEvtHandler = NewEventHandlerUPP(windowEvtHndlr);
@ -769,7 +833,9 @@ else
}
}
//RunApplicationEventLoop();
//
// pull the size from the real window .. do not trust the requested values?
WindowProperties properties;
_properties.set_foreground(true);
@ -794,7 +860,13 @@ else
}
return true;
}
////////////////////////////////////////////////////////////////////
// Function: osxGraphicsWindow::process_events()
// Access: virtual, protected
// Description: Required Event upcall . Used to dispatch Window and Aplication Events
// back into panda
//
////////////////////////////////////////////////////////////////////
void osxGraphicsWindow::process_events()
{
GraphicsWindow::process_events();
@ -833,24 +905,13 @@ void handleWindowDMEvent (void *userData, short theMessage, void *notifyData)
}
}
}
/*
EventRef theTextEvent;
UniChar *text;
UInt32 actualSize;
GetEventParameter (theTextEvent, kEventParamTextInputSendText,
typeUnicodeText, NULL, 0, &actualSize, NULL);
text = (UniChar*) NewPtr(actualSize);
GetEventParameter (theTextEvent, kEventParamTextInputSendText,
typeUnicodeText, NULL, actualSize, NULL, text);
*/
////////////////////////////////////////////////////////////////////
// Function: osxGraphicsWindow::process_events()
// Access: virtual, protected
// Description: Required Event upcall . Used to dispatch Window and Aplication Events
// back into panda
//
////////////////////////////////////////////////////////////////////
// key input handler
OSStatus osxGraphicsWindow::handleKeyInput (EventHandlerCallRef myHandler, EventRef event, Boolean keyDown)
{
@ -879,14 +940,22 @@ OSStatus osxGraphicsWindow::handleKeyInput (EventHandlerCallRef myHandler, Event
return result;
}
////////////////////////////////////////////////////////////////////
// Function:
// Access:
// Description:
////////////////////////////////////////////////////////////////////
void osxGraphicsWindow::SystemSetWindowForground(bool forground)
{
WindowProperties properties;
properties.set_foreground(forground);
system_changed_properties(properties);
};
////////////////////////////////////////////////////////////////////
// Function:
// Access:
// Description:
////////////////////////////////////////////////////////////////////
void osxGraphicsWindow::SystemPointToLocalPoint(Point &qdGlobalPoint)
{
@ -897,15 +966,18 @@ void osxGraphicsWindow::SystemSetWindowForground(bool forground)
SetPort( savePort );
};
////////////////////////////////////////////////////////////////////
// Function:
// Access:
// Description:
////////////////////////////////////////////////////////////////////
OSStatus osxGraphicsWindow::handleWindowMouseEvents (EventHandlerCallRef myHandler, EventRef event)
{
WindowRef window = NULL;
// pRecContext pContextInfo = NULL;
OSStatus result = eventNotHandledErr;
UInt32 kind = GetEventKind (event);
EventMouseButton button = 0;
// HIPoint location = {0.0f, 0.0f};
Point qdGlobalPoint = {0, 0};
UInt32 modifiers = 0;
long wheelDelta = 0;
@ -914,14 +986,8 @@ OSStatus osxGraphicsWindow::handleWindowMouseEvents (EventHandlerCallRef myHandl
// Mac OS X v10.1 and later
// should this be front window???
GetEventParameter(event, kEventParamWindowRef, typeWindowRef, NULL, sizeof(WindowRef), NULL, &window);
// if (window)
// pContextInfo = GetCurrentContextInfo (window);
// if (!pContextInfo)
// return result; // not an application GLWindow so do not process (there is an exception)
GetWindowPortBounds (window, &rectPort);
//printf(" Got Mouse Event \n");
result = CallNextEventHandler(myHandler, event);
if (eventNotHandledErr == result)
{ // only handle events not already handled (prevents wierd resize interaction)
@ -930,7 +996,6 @@ OSStatus osxGraphicsWindow::handleWindowMouseEvents (EventHandlerCallRef myHandl
case kEventMouseDown:
{
GetEventParameter(event, kEventParamMouseButton, typeMouseButton, NULL, sizeof(EventMouseButton), NULL, &button);
// GetEventParameter(event, kEventParamMouseLocation, typeHIPoint, NULL, sizeof(HIPoint), NULL, &location); // Mac OS X v10.1 and later
GetEventParameter(event, kEventParamKeyModifiers, typeUInt32, NULL, sizeof(UInt32), NULL, &modifiers);
GetEventParameter(event, kEventParamMouseLocation,typeQDPoint, NULL, sizeof(Point),NULL , (void*) &qdGlobalPoint);
SystemPointToLocalPoint(qdGlobalPoint);
@ -940,11 +1005,6 @@ OSStatus osxGraphicsWindow::handleWindowMouseEvents (EventHandlerCallRef myHandl
button_h = MouseButton::two();
if(kEventMouseButtonTertiary == button)
button_h = MouseButton::three();
// cerr << " Mouse Down " << location.x << " " << location.y << " "<< button_h << "\n" ;
// cerr << " Mouse Down " << qdGlobalPoint.h << " " << qdGlobalPoint.v << " "<< button_h << "\n" ;
// cerr << " Window Port " << rectPort.top << " " << rectPort.bottom ;
// _input_devices[0].set_pointer_in_window((int)location.x, (int)location.y);
_input_devices[0].set_pointer_in_window((int)qdGlobalPoint.h, (int)qdGlobalPoint.v);
_input_devices[0].button_down(button_h);
}
@ -962,20 +1022,12 @@ OSStatus osxGraphicsWindow::handleWindowMouseEvents (EventHandlerCallRef myHandl
button_h = MouseButton::two();
if(kEventMouseButtonTertiary == button)
button_h = MouseButton::three();
// cerr << " Mouse Up " << location.x << " " << location.y << " "<< button_h << "\n";
// cerr << " Mouse up " << qdGlobalPoint.h << " " << qdGlobalPoint.v << " "<< button_h << "\n" ;
_input_devices[0].set_pointer_in_window((int)qdGlobalPoint.h, (int)qdGlobalPoint.v);
_input_devices[0].button_up(button_h);
}
break;
case kEventMouseMoved:
case kEventMouseDragged:
// GetEventParameter(event, kEventParamWindowMouseLocation, typeHIPoint, NULL, sizeof(HIPoint), NULL, &location); // Mac OS X v10.1 and later
// GetEventParameter(event, kEventParamWindowMouseLocation, typeHIPoint, NULL, sizeof(HIPoint), NULL, &location); // Mac OS X v10.1 and later
// _input_devices[0].set_pointer_in_window((int)location.x, (int)location.y);
// _input_devices[0].set_pointer_in_window(event.xmotion.x, event.xmotion.y);
GetEventParameter(event, kEventParamMouseLocation,typeQDPoint, NULL, sizeof(Point),NULL , (void*) &qdGlobalPoint);
SystemPointToLocalPoint(qdGlobalPoint);
@ -991,8 +1043,12 @@ OSStatus osxGraphicsWindow::handleWindowMouseEvents (EventHandlerCallRef myHandl
return result;
}
ButtonHandle OSX_TranslateKey( UInt32 key, EventRef event)
////////////////////////////////////////////////////////////////////
// Function: osxGraphicsWindow::OSX_TranslateKey
// Access: Private
// Description: MAC Key Codes to Panda Key Codes
////////////////////////////////////////////////////////////////////
ButtonHandle osxGraphicsWindow::OSX_TranslateKey( UInt32 key, EventRef event)
{
@ -1110,8 +1166,11 @@ ButtonHandle OSX_TranslateKey( UInt32 key, EventRef event)
}
return nk;
}
////////////////////////////////////////////////////////////////////
// Function: osxGraphicsWindow::HandleModifireDeleta
// Access: Private
// Description: Used to emulate key events for the MAC key Modifiers..
////////////////////////////////////////////////////////////////////
void osxGraphicsWindow::HandleModifireDeleta(UInt32 newModifiers)
{
UInt32 changed = _last_key_modifiers ^ newModifiers;

25
panda/src/osxdisplay/osxGraphicsWindow.h
View File

@ -43,20 +43,19 @@ public:
const string &name);
virtual ~osxGraphicsWindow();
// virtual bool move_pointer(int device, int x, int y);
virtual bool move_pointer(int device, int x, int y);
//virtual bool make_context();
virtual void make_current();
virtual void release_gsg();
virtual bool begin_frame(FrameMode mode);
virtual void end_frame(FrameMode mode);
virtual void begin_flip();
virtual void process_events();
private:
void ReleaseSystemResources();
@ -65,11 +64,19 @@ protected:
virtual bool open_window();
private:
//
// a singleton .. for the events to find the right pipe to push the event into
//
static osxGraphicsWindow * FullScreenWindow;
static osxGraphicsWindow * GetCurrentOSxWindow (WindowRef hint);
public: // do not call direct ..
OSStatus handleKeyInput (EventHandlerCallRef myHandler, EventRef event, Boolean keyDown);
OSStatus handleTextInput (EventHandlerCallRef myHandler, EventRef event);
OSStatus handleWindowMouseEvents (EventHandlerCallRef myHandler, EventRef event);
ButtonHandle OSX_TranslateKey( UInt32 key, EventRef event );
void HandleModifireDeleta(UInt32 modifiers);
void DoResize(void);
@ -92,10 +99,10 @@ public: // do not call direct ..
}
inline bool IsAlive(void)
{
return (_is_fullsreen || _osx_window != NULL);
}
// inline bool IsAlive(void)
// {
// return (_is_fullsreen || _osx_window != NULL);
// }
WindowProperties & properties() { return _properties; };
private: