From 952e9c81b4be4c51d4a9b745e106f0203a016798 Mon Sep 17 00:00:00 2001 From: Sam Lantinga Date: Mon, 24 Jul 2006 05:03:02 +0000 Subject: [PATCH] Implemented Cocoa window support --- src/video/SDL_video.c | 1 - src/video/cocoa/SDL_cocoavideo.h | 2 +- src/video/cocoa/SDL_cocoavideo.m | 2 +- src/video/cocoa/SDL_cocoawindow.h | 89 +++++ src/video/cocoa/SDL_cocoawindow.m | 557 ++++++++++++++++++++++++++++++ src/video/win32/SDL_win32window.h | 3 - test/Makefile.in | 4 +- test/common.c | 8 +- test/common.h | 1 + test/testwm2.c | 86 ++--- 10 files changed, 679 insertions(+), 74 deletions(-) create mode 100644 src/video/cocoa/SDL_cocoawindow.h create mode 100644 src/video/cocoa/SDL_cocoawindow.m diff --git a/src/video/SDL_video.c b/src/video/SDL_video.c index a76ed29d9..bca102d0e 100644 --- a/src/video/SDL_video.c +++ b/src/video/SDL_video.c @@ -1282,7 +1282,6 @@ SDL_DestroyWindow(SDL_WindowID windowID) if (window->title) { SDL_free(window->title); } - SDL_free(window); if (j != display->num_windows - 1) { SDL_memcpy(&display->windows[i], &display->windows[i + 1], diff --git a/src/video/cocoa/SDL_cocoavideo.h b/src/video/cocoa/SDL_cocoavideo.h index 4b5f3a3c8..d53261c13 100644 --- a/src/video/cocoa/SDL_cocoavideo.h +++ b/src/video/cocoa/SDL_cocoavideo.h @@ -34,8 +34,8 @@ #include "SDL_cocoamouse.h" /* #include "SDL_cocoaopengl.h" -#include "SDL_cocoawindow.h" */ +#include "SDL_cocoawindow.h" /* Private display data */ diff --git a/src/video/cocoa/SDL_cocoavideo.m b/src/video/cocoa/SDL_cocoavideo.m index ff09111b6..fade35ffa 100644 --- a/src/video/cocoa/SDL_cocoavideo.m +++ b/src/video/cocoa/SDL_cocoavideo.m @@ -73,7 +73,6 @@ device->SetDisplayMode = Cocoa_SetDisplayMode; device->PumpEvents = Cocoa_PumpEvents; - /* device->CreateWindow = Cocoa_CreateWindow; device->CreateWindowFrom = Cocoa_CreateWindowFrom; device->SetWindowTitle = Cocoa_SetWindowTitle; @@ -88,6 +87,7 @@ device->SetWindowGrab = Cocoa_SetWindowGrab; device->DestroyWindow = Cocoa_DestroyWindow; device->GetWindowWMInfo = Cocoa_GetWindowWMInfo; + /* #ifdef SDL_VIDEO_OPENGL device->GL_LoadLibrary = Cocoa_GL_LoadLibrary; device->GL_GetProcAddress = Cocoa_GL_GetProcAddress; diff --git a/src/video/cocoa/SDL_cocoawindow.h b/src/video/cocoa/SDL_cocoawindow.h new file mode 100644 index 000000000..77c3d09e1 --- /dev/null +++ b/src/video/cocoa/SDL_cocoawindow.h @@ -0,0 +1,89 @@ +/* + SDL - Simple DirectMedia Layer + Copyright (C) 1997-2006 Sam Lantinga + + This library is free software; you can redistribute it and/or + modify it under the terms of the GNU Lesser General Public + License as published by the Free Software Foundation; either + version 2.1 of the License, or (at your option) any later version. + + This library is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + Lesser General Public License for more details. + + You should have received a copy of the GNU Lesser General Public + License along with this library; if not, write to the Free Software + Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA + + Sam Lantinga + slouken@libsdl.org +*/ +#include "SDL_config.h" + +#ifndef _SDL_cocoawindow_h +#define _SDL_cocoawindow_h + +typedef struct SDL_WindowData SDL_WindowData; + +@interface Cocoa_WindowListener:NSResponder { + SDL_WindowData *_data; +} + +-(void) listen:(SDL_WindowData *) data; +-(void) close; + +/* Window delegate functionality */ +-(BOOL) windowShouldClose:(id) sender; +-(void) windowDidExpose:(NSNotification *) aNotification; +-(void) windowDidMove:(NSNotification *) aNotification; +-(void) windowDidResize:(NSNotification *) aNotification; +-(void) windowDidMiniaturize:(NSNotification *) aNotification; +-(void) windowDidDeminiaturize:(NSNotification *) aNotification; +-(void) windowDidBecomeKey:(NSNotification *) aNotification; +-(void) windowDidResignKey:(NSNotification *) aNotification; +-(void) windowDidHide:(NSNotification *) aNotification; +-(void) windowDidUnhide:(NSNotification *) aNotification; + +/* Window event handling */ +-(void) mouseDown:(NSEvent *) theEvent; +-(void) rightMouseDown:(NSEvent *) theEvent; +-(void) otherMouseDown:(NSEvent *) theEvent; +-(void) mouseUp:(NSEvent *) theEvent; +-(void) rightMouseUp:(NSEvent *) theEvent; +-(void) otherMouseUp:(NSEvent *) theEvent; +-(void) mouseMoved:(NSEvent *) theEvent; +-(void) scrollWheel:(NSEvent *) theEvent; +-(void) mouseEntered:(NSEvent *) theEvent; +-(void) mouseExited:(NSEvent *) theEvent; +-(void) keyDown:(NSEvent *) theEvent; +-(void) keyUp:(NSEvent *) theEvent; +@end struct SDL_WindowData +{ + SDL_WindowID windowID; + NSWindow *window; + BOOL created; + Cocoa_WindowListener *listener; + struct SDL_VideoData *videodata; +}; + +extern int Cocoa_CreateWindow(_THIS, SDL_Window * window); +extern int Cocoa_CreateWindowFrom(_THIS, SDL_Window * window, + const void *data); +extern void Cocoa_SetWindowTitle(_THIS, SDL_Window * window); +extern void Cocoa_SetWindowPosition(_THIS, SDL_Window * window); +extern void Cocoa_SetWindowSize(_THIS, SDL_Window * window); +extern void Cocoa_ShowWindow(_THIS, SDL_Window * window); +extern void Cocoa_HideWindow(_THIS, SDL_Window * window); +extern void Cocoa_RaiseWindow(_THIS, SDL_Window * window); +extern void Cocoa_MaximizeWindow(_THIS, SDL_Window * window); +extern void Cocoa_MinimizeWindow(_THIS, SDL_Window * window); +extern void Cocoa_RestoreWindow(_THIS, SDL_Window * window); +extern void Cocoa_SetWindowGrab(_THIS, SDL_Window * window); +extern void Cocoa_DestroyWindow(_THIS, SDL_Window * window); +extern SDL_bool Cocoa_GetWindowWMInfo(_THIS, SDL_Window * window, + struct SDL_SysWMinfo *info); + +#endif /* _SDL_cocoawindow_h */ + +/* vi: set ts=4 sw=4 expandtab: */ diff --git a/src/video/cocoa/SDL_cocoawindow.m b/src/video/cocoa/SDL_cocoawindow.m new file mode 100644 index 000000000..f7a60dc22 --- /dev/null +++ b/src/video/cocoa/SDL_cocoawindow.m @@ -0,0 +1,557 @@ +/* + SDL - Simple DirectMedia Layer + Copyright (C) 1997-2006 Sam Lantinga + + This library is free software; you can redistribute it and/or + modify it under the terms of the GNU Lesser General Public + License as published by the Free Software Foundation; either + version 2.1 of the License, or (at your option) any later version. + + This library is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + Lesser General Public License for more details. + + You should have received a copy of the GNU Lesser General Public + License along with this library; if not, write to the Free Software + Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA + + Sam Lantinga + slouken@libsdl.org +*/ +#include "SDL_config.h" + +#include "SDL_syswm.h" +#include "../SDL_sysvideo.h" +#include "../../events/SDL_keyboard_c.h" +#include "../../events/SDL_mouse_c.h" +#include "../../events/SDL_windowevents_c.h" + +#include "SDL_cocoavideo.h" + +static __inline__ void ConvertNSRect(NSRect *r) +{ + r->origin.y = CGDisplayPixelsHigh(kCGDirectMainDisplay) - r->origin.y - r->size.height; +} + +@implementation Cocoa_WindowListener + +- (void)listen:(SDL_WindowData *)data +{ + NSNotificationCenter *center; + + _data = data; + + center = [NSNotificationCenter defaultCenter]; + + [_data->window setNextResponder:self]; + if ([_data->window delegate] != nil) { + [center addObserver:self selector:@selector(windowDisExpose:) name:NSWindowDidExposeNotification object:_data->window]; + [center addObserver:self selector:@selector(windowDidMove:) name:NSWindowDidMoveNotification object:_data->window]; + [center addObserver:self selector:@selector(windowDidResize:) name:NSWindowDidResizeNotification object:_data->window]; + [center addObserver:self selector:@selector(windowDidMiniaturize:) name:NSWindowDidMiniaturizeNotification object:_data->window]; + [center addObserver:self selector:@selector(windowDidDeminiaturize:) name:NSWindowDidDeminiaturizeNotification object:_data->window]; + [center addObserver:self selector:@selector(windowDidBecomeKey:) name:NSWindowDidBecomeKeyNotification object:_data->window]; + [center addObserver:self selector:@selector(windowDidResignKey:) name:NSWindowDidResignKeyNotification object:_data->window]; + } else { + [_data->window setDelegate:self]; + } + [center addObserver:self selector:@selector(windowDidHide:) name:NSApplicationDidHideNotification object:NSApp]; + [center addObserver:self selector:@selector(windowDidUnhide:) name:NSApplicationDidUnhideNotification object:NSApp]; + + [_data->window setAcceptsMouseMovedEvents:YES]; +} + +- (void)close +{ + NSNotificationCenter *center; + + center = [NSNotificationCenter defaultCenter]; + + [_data->window setNextResponder:nil]; + if ([_data->window delegate] != self) { + [center removeObserver:self name:NSWindowDidExposeNotification object:_data->window]; + [center removeObserver:self name:NSWindowDidMoveNotification object:_data->window]; + [center removeObserver:self name:NSWindowDidResizeNotification object:_data->window]; + [center removeObserver:self name:NSWindowDidMiniaturizeNotification object:_data->window]; + [center removeObserver:self name:NSWindowDidDeminiaturizeNotification object:_data->window]; + [center removeObserver:self name:NSWindowDidBecomeKeyNotification object:_data->window]; + [center removeObserver:self name:NSWindowDidResignKeyNotification object:_data->window]; + } else { + [_data->window setDelegate:nil]; + } + [center removeObserver:self name:NSApplicationDidHideNotification object:NSApp]; + [center removeObserver:self name:NSApplicationDidUnhideNotification object:NSApp]; +} + +- (BOOL)windowShouldClose:(id)sender +{ + SDL_SendWindowEvent(_data->windowID, SDL_WINDOWEVENT_CLOSE, 0, 0); + return NO; +} + +- (void)windowDidExpose:(NSNotification *)aNotification +{ + SDL_SendWindowEvent(_data->windowID, SDL_WINDOWEVENT_EXPOSED, 0, 0); +} + +- (void)windowDidMove:(NSNotification *)aNotification +{ + int x, y; + NSRect rect = [_data->window contentRectForFrameRect:[_data->window frame]]; + ConvertNSRect(&rect); + x = (int)rect.origin.x; + y = (int)rect.origin.y; + SDL_SendWindowEvent(_data->windowID, SDL_WINDOWEVENT_MOVED, x, y); +} + +- (void)windowDidResize:(NSNotification *)aNotification +{ + int w, h; + NSRect rect = [_data->window contentRectForFrameRect:[_data->window frame]]; + w = (int)rect.size.width; + h = (int)rect.size.height; + SDL_SendWindowEvent(_data->windowID, SDL_WINDOWEVENT_RESIZED, w, h); +} + +- (void)windowDidMiniaturize:(NSNotification *)aNotification +{ + SDL_SendWindowEvent(_data->windowID, SDL_WINDOWEVENT_MINIMIZED, 0, 0); +} + +- (void)windowDidDeminiaturize:(NSNotification *)aNotification +{ + SDL_SendWindowEvent(_data->windowID, SDL_WINDOWEVENT_RESTORED, 0, 0); +} + +- (void)windowDidBecomeKey:(NSNotification *)aNotification +{ + SDL_SendWindowEvent(_data->windowID, SDL_WINDOWEVENT_FOCUS_GAINED, 0, 0); +} + +- (void)windowDidResignKey:(NSNotification *)aNotification +{ + SDL_SendWindowEvent(_data->windowID, SDL_WINDOWEVENT_FOCUS_LOST, 0, 0); +} + +- (void)windowDidHide:(NSNotification *)aNotification +{ + SDL_SendWindowEvent(_data->windowID, SDL_WINDOWEVENT_HIDDEN, 0, 0); +} + +- (void)windowDidUnhide:(NSNotification *)aNotification +{ + SDL_SendWindowEvent(_data->windowID, SDL_WINDOWEVENT_SHOWN, 0, 0); +} + +- (void)mouseDown:(NSEvent *)theEvent +{ + int index; + + index = _data->videodata->mouse; + SDL_SendMouseButton(index, SDL_PRESSED, SDL_BUTTON_LEFT); +} + +- (void)rightMouseDown:(NSEvent *)theEvent +{ + int index; + + index = _data->videodata->mouse; + SDL_SendMouseButton(index, SDL_PRESSED, SDL_BUTTON_RIGHT); +} + +- (void)otherMouseDown:(NSEvent *)theEvent +{ + int index; + + index = _data->videodata->mouse; + SDL_SendMouseButton(index, SDL_PRESSED, SDL_BUTTON_MIDDLE); +} + +- (void)mouseUp:(NSEvent *)theEvent +{ + int index; + + index = _data->videodata->mouse; + SDL_SendMouseButton(index, SDL_RELEASED, SDL_BUTTON_LEFT); +} + +- (void)rightMouseUp:(NSEvent *)theEvent +{ + int index; + + index = _data->videodata->mouse; + SDL_SendMouseButton(index, SDL_RELEASED, SDL_BUTTON_RIGHT); +} + +- (void)otherMouseUp:(NSEvent *)theEvent +{ + int index; + + index = _data->videodata->mouse; + SDL_SendMouseButton(index, SDL_RELEASED, SDL_BUTTON_MIDDLE); +} + +- (void)mouseMoved:(NSEvent *)theEvent +{ + int index; + SDL_Mouse *mouse; + NSPoint point; + NSRect rect = [_data->window contentRectForFrameRect:[_data->window frame]]; + + index = _data->videodata->mouse; + mouse = SDL_GetMouse(index); + if (mouse->focus != _data->windowID) { + SDL_SetMouseFocus(index, _data->windowID); + } + + point = [NSEvent mouseLocation]; + point.x = point.x - rect.origin.x; + point.y = rect.size.height - (point.y - rect.origin.y); + SDL_SendMouseMotion(index, 0, (int)point.x, (int)point.y); +} + +- (void)scrollWheel:(NSEvent *)theEvent +{ +fprintf(stderr, "scrollWheel\n"); +} + +- (void)mouseEntered:(NSEvent *)theEvent +{ +fprintf(stderr, "mouseEntered\n"); + SDL_SendWindowEvent(_data->windowID, SDL_WINDOWEVENT_ENTER, 0, 0); +} + +- (void)mouseExited:(NSEvent *)theEvent +{ +fprintf(stderr, "mouseExited\n"); + SDL_SendWindowEvent(_data->windowID, SDL_WINDOWEVENT_LEAVE, 0, 0); +} + +- (void)keyDown:(NSEvent *)theEvent +{ +fprintf(stderr, "keyDown\n"); +} + +- (void)keyUp:(NSEvent *)theEvent +{ +fprintf(stderr, "keyUp\n"); +} + +@end + +static int +SetupWindowData(SDL_Window * window, NSWindow *nswindow, BOOL created) +{ + NSAutoreleasePool *pool; + SDL_WindowData *data; + + /* Allocate the window data */ + data = (SDL_WindowData *) SDL_malloc(sizeof(*data)); + if (!data) { + SDL_OutOfMemory(); + return -1; + } + data->windowID = window->id; + data->window = nswindow; + data->created = created; + data->videodata = (SDL_VideoData *) SDL_GetVideoDevice()->driverdata; + + pool = [[NSAutoreleasePool alloc] init]; + + /* Create an event listener for the window */ + data->listener = [[Cocoa_WindowListener alloc] init]; + [data->listener listen:data]; + + /* Fill in the SDL window with the window data */ + { + NSRect rect = [nswindow contentRectForFrameRect:[nswindow frame]]; + ConvertNSRect(&rect); + window->x = (int)rect.origin.x; + window->y = (int)rect.origin.y; + window->w = (int)rect.size.width; + window->h = (int)rect.size.height; + } + if ([nswindow isVisible]) { + window->flags |= SDL_WINDOW_SHOWN; + } else { + window->flags &= ~SDL_WINDOW_SHOWN; + } + { + unsigned int style = [nswindow styleMask]; + + if (style == NSBorderlessWindowMask) { + window->flags |= SDL_WINDOW_BORDERLESS; + } else { + window->flags &= ~SDL_WINDOW_BORDERLESS; + } + if (style & NSResizableWindowMask) { + window->flags |= SDL_WINDOW_RESIZABLE; + } else { + window->flags &= ~SDL_WINDOW_RESIZABLE; + } + } + if ([nswindow isZoomed]) { + window->flags |= SDL_WINDOW_MAXIMIZED; + } else { + window->flags &= ~SDL_WINDOW_MAXIMIZED; + } + if ([nswindow isMiniaturized]) { + window->flags |= SDL_WINDOW_MINIMIZED; + } else { + window->flags &= ~SDL_WINDOW_MINIMIZED; + } + if ([nswindow isKeyWindow]) { + int index = data->videodata->keyboard; + window->flags |= SDL_WINDOW_INPUT_FOCUS; + SDL_SetKeyboardFocus(index, data->windowID); + + if (window->flags & SDL_WINDOW_INPUT_GRABBED) { + /* FIXME */ + } + } + + /* All done! */ + [pool release]; + window->driverdata = data; + return 0; +} + +int +Cocoa_CreateWindow(_THIS, SDL_Window * window) +{ + NSAutoreleasePool *pool; + NSWindow *nswindow; + NSRect rect; + unsigned int style; + NSString *title; + + pool = [[NSAutoreleasePool alloc] init]; + + if ((window->flags & SDL_WINDOW_FULLSCREEN) || + window->x == SDL_WINDOWPOS_CENTERED) { + rect.origin.x = (CGDisplayPixelsWide(kCGDirectMainDisplay) - window->w) / 2; + } else if (window->x == SDL_WINDOWPOS_UNDEFINED) { + rect.origin.x = 0; + } else { + rect.origin.x = window->x; + } + if ((window->flags & SDL_WINDOW_FULLSCREEN) || + window->y == SDL_WINDOWPOS_CENTERED) { + rect.origin.y = (CGDisplayPixelsHigh(kCGDirectMainDisplay) - window->h) / 2; + } else if (window->y == SDL_WINDOWPOS_UNDEFINED) { + rect.origin.y = 0; + } else { + rect.origin.y = window->y; + } + rect.size.width = window->w; + rect.size.height = window->h; + ConvertNSRect(&rect); + + if (window->flags & SDL_WINDOW_BORDERLESS) { + style = NSBorderlessWindowMask; + } else { + style = (NSTitledWindowMask|NSClosableWindowMask|NSMiniaturizableWindowMask); + } + if (window->flags & SDL_WINDOW_RESIZABLE) { + style |= NSResizableWindowMask; + } + + nswindow = [[NSWindow alloc] initWithContentRect:rect styleMask:style backing:NSBackingStoreBuffered defer:FALSE]; + + if (window->flags & SDL_WINDOW_SHOWN) { + [nswindow makeKeyAndOrderFront:nil]; + } + if (window->flags & SDL_WINDOW_MAXIMIZED) { + [nswindow performZoom:nil]; + } + if (window->flags & SDL_WINDOW_MINIMIZED) { + [nswindow performMiniaturize:nil]; + } + + if (window->title) { + title = [[NSString alloc] initWithUTF8String:window->title]; + [nswindow setTitle:title]; + [nswindow setMiniwindowTitle:title]; + [title release]; + } + + [pool release]; + + if (SetupWindowData(window, nswindow, YES) < 0) { + [nswindow release]; + [pool release]; + return -1; + } +#ifdef SDL_VIDEO_OPENGL + /* + if (window->flags & SDL_WINDOW_OPENGL) { + if (Cocoa_GL_SetupWindow(_this, window) < 0) { + Cocoa_DestroyWindow(_this, window); + return -1; + } + } + */ +#endif + return 0; +} + +int +Cocoa_CreateWindowFrom(_THIS, SDL_Window * window, const void *data) +{ + NSAutoreleasePool *pool; + NSWindow *nswindow = (NSWindow *) data; + NSString *title; + int status; + + pool = [[NSAutoreleasePool alloc] init]; + + /* Query the title from the existing window */ + title = [nswindow title]; + if (title) { + window->title = SDL_strdup([title UTF8String]); + } + + [pool release]; + + return SetupWindowData(window, nswindow, NO); +} + +void +Cocoa_SetWindowTitle(_THIS, SDL_Window * window) +{ + NSWindow *nswindow = ((SDL_WindowData *) window->driverdata)->window; + NSString *string; + + string = [[NSString alloc] initWithUTF8String:window->title]; + [nswindow setTitle:string]; + [nswindow setMiniwindowTitle:string]; + [string release]; +} + +void +Cocoa_SetWindowPosition(_THIS, SDL_Window * window) +{ + NSWindow *nswindow = ((SDL_WindowData *) window->driverdata)->window; + NSRect rect; + + rect.origin.x = window->x; + rect.origin.y = window->y; + rect.size.width = window->w; + rect.size.height = window->h; + ConvertNSRect(&rect); + rect = [nswindow frameRectForContentRect:rect]; + [nswindow setFrameOrigin:rect.origin]; +} + +void +Cocoa_SetWindowSize(_THIS, SDL_Window * window) +{ + NSWindow *nswindow = ((SDL_WindowData *) window->driverdata)->window; + NSSize size; + + size.width = window->w; + size.height = window->h; + [nswindow setContentSize:size]; +} + +void +Cocoa_ShowWindow(_THIS, SDL_Window * window) +{ + NSWindow *nswindow = ((SDL_WindowData *) window->driverdata)->window; + + [nswindow makeKeyAndOrderFront:nil]; +} + +void +Cocoa_HideWindow(_THIS, SDL_Window * window) +{ + NSWindow *nswindow = ((SDL_WindowData *) window->driverdata)->window; + + /* FIXME */ +} + +void +Cocoa_RaiseWindow(_THIS, SDL_Window * window) +{ + NSWindow *nswindow = ((SDL_WindowData *) window->driverdata)->window; + + [nswindow makeKeyAndOrderFront:nil]; +} + +void +Cocoa_MaximizeWindow(_THIS, SDL_Window * window) +{ + NSWindow *nswindow = ((SDL_WindowData *) window->driverdata)->window; + + [nswindow performZoom:nil]; +} + +void +Cocoa_MinimizeWindow(_THIS, SDL_Window * window) +{ + NSWindow *nswindow = ((SDL_WindowData *) window->driverdata)->window; + + [nswindow performMiniaturize:nil]; +} + +void +Cocoa_RestoreWindow(_THIS, SDL_Window * window) +{ + NSWindow *nswindow = ((SDL_WindowData *) window->driverdata)->window; + + /* FIXME */ +} + +void +Cocoa_SetWindowGrab(_THIS, SDL_Window * window) +{ + if ((window->flags & SDL_WINDOW_INPUT_GRABBED) && + (window->flags & SDL_WINDOW_INPUT_FOCUS)) { + /* FIXME: Grab mouse */ + } else { + /* FIXME: Release mouse */ + } +} + +void +Cocoa_DestroyWindow(_THIS, SDL_Window * window) +{ + SDL_WindowData *data = (SDL_WindowData *) window->driverdata; + + if (data) { + NSAutoreleasePool *pool; +#ifdef SDL_VIDEO_OPENGL + /* + if (window->flags & SDL_WINDOW_OPENGL) { + Cocoa_GL_CleanupWindow(_this, window); + } + */ +#endif + pool = [[NSAutoreleasePool alloc] init]; + [data->listener close]; + [data->listener release]; + if (data->created) { + [data->window close]; + } + SDL_free(data); + [pool release]; + } +} + +SDL_bool +Cocoa_GetWindowWMInfo(_THIS, SDL_Window * window, SDL_SysWMinfo * info) +{ + NSWindow *nswindow = ((SDL_WindowData *) window->driverdata)->window; + + if (info->version.major <= SDL_MAJOR_VERSION) { + //info->window = nswindow; + return SDL_TRUE; + } else { + SDL_SetError("Application not compiled with SDL %d.%d\n", + SDL_MAJOR_VERSION, SDL_MINOR_VERSION); + return SDL_FALSE; + } +} + +/* vi: set ts=4 sw=4 expandtab: */ diff --git a/src/video/win32/SDL_win32window.h b/src/video/win32/SDL_win32window.h index b6be0c215..a6818592e 100644 --- a/src/video/win32/SDL_win32window.h +++ b/src/video/win32/SDL_win32window.h @@ -24,9 +24,6 @@ #ifndef _SDL_win32window_h #define _SDL_win32window_h -#include "../SDL_sysvideo.h" -#include "SDL_win32video.h" - typedef struct { SDL_WindowID windowID; diff --git a/test/Makefile.in b/test/Makefile.in index 75af6e1ef..cf4dc5375 100644 --- a/test/Makefile.in +++ b/test/Makefile.in @@ -107,8 +107,8 @@ testwin$(EXE): $(srcdir)/testwin.c testwm$(EXE): $(srcdir)/testwm.c $(CC) -o $@ $? $(CFLAGS) $(LIBS) -testwm2$(EXE): $(srcdir)/testwm.c - $(CC) -o $@ $? $(CFLAGS) $(LIBS) +testwm2$(EXE): $(srcdir)/testwm2.c $(srcdir)/common.c + $(CC) -o $@ $(srcdir)/testwm2.c $(srcdir)/common.c $(CFLAGS) $(LIBS) threadwin$(EXE): $(srcdir)/threadwin.c $(CC) -o $@ $? $(CFLAGS) $(LIBS) diff --git a/test/common.c b/test/common.c index d6a5447d5..c37d9ed5e 100644 --- a/test/common.c +++ b/test/common.c @@ -660,8 +660,9 @@ CommonInit(CommonState * state) return SDL_FALSE; } - if (state->renderdriver - || !(state->window_flags & SDL_WINDOW_OPENGL)) { + if (!state->skip_renderer + && (state->renderdriver + || !(state->window_flags & SDL_WINDOW_OPENGL))) { m = -1; if (state->renderdriver) { SDL_RendererInfo info; @@ -784,6 +785,9 @@ PrintEvent(SDL_Event * event) fprintf(stderr, "Window %d lost keyboard focus", event->window.windowID); break; + case SDL_WINDOWEVENT_CLOSE: + fprintf(stderr, "Window %d closed", event->window.windowID); + break; default: fprintf(stderr, "Window %d got unknown event %d", event->window.windowID, event->window.event); diff --git a/test/common.h b/test/common.h index 20e1b4c94..cb7abf91b 100644 --- a/test/common.h +++ b/test/common.h @@ -33,6 +33,7 @@ typedef struct /* Renderer info */ const char *renderdriver; Uint32 render_flags; + SDL_bool skip_renderer; /* Audio info */ const char *audiodriver; diff --git a/test/testwm2.c b/test/testwm2.c index a5fc8bfcb..f55c45588 100644 --- a/test/testwm2.c +++ b/test/testwm2.c @@ -1,98 +1,56 @@ -/* Simple program: Move N sprites around on the screen as fast as possible */ -#include "SDL.h" +#include +#include -#define NUM_WINDOWS 2 -#define WINDOW_W 640 -#define WINDOW_H 480 +#include "common.h" -static int num_windows; -static SDL_WindowID *windows; +static CommonState *state; /* Call this instead of exit(), so we can clean up SDL: atexit() is evil. */ static void quit(int rc) { - if (windows) { - SDL_free(windows); - } - SDL_Quit(); + CommonQuit(state); exit(rc); } int main(int argc, char *argv[]) { - int window_w, window_h; int i, done; SDL_Event event; - /* Initialize SDL */ - if (SDL_Init(SDL_INIT_VIDEO) < 0) { - fprintf(stderr, "Couldn't initialize SDL: %s\n", SDL_GetError()); - return (1); + /* Initialize test framework */ + state = CommonCreateState(argv, SDL_INIT_VIDEO); + if (!state) { + return 1; } + state->skip_renderer = SDL_TRUE; + for (i = 1; i < argc;) { + int consumed; - num_windows = NUM_WINDOWS; - window_w = WINDOW_W; - window_h = WINDOW_H; - while (argc > 1) { - if (strcmp(argv[argc - 1], "-width") == 0) { - window_w = atoi(argv[argc]); - --argc; - } else if (strcmp(argv[argc - 1], "-height") == 0) { - window_h = atoi(argv[argc]); - --argc; - } else { - fprintf(stderr, "Usage: %s [-width] [-height]\n", argv[0]); + consumed = CommonArg(state, i); + if (consumed == 0) { + consumed = -1; + } + if (consumed < 0) { + fprintf(stderr, "Usage: %s %s", argv[0], CommonUsage(state)); quit(1); } + i += consumed; } - - /* Create the windows */ - windows = (SDL_WindowID *) SDL_malloc(num_windows * sizeof(*windows)); - if (!windows) { - fprintf(stderr, "Out of memory!\n"); + if (!CommonInit(state)) { quit(2); } - for (i = 0; i < num_windows; ++i) { - char title[32]; - int x, y; - - SDL_snprintf(title, sizeof(title), "testwm %d", i + 1); - if (i == 0) { - x = SDL_WINDOWPOS_CENTERED; - y = SDL_WINDOWPOS_CENTERED; - } else { - x = SDL_WINDOWPOS_UNDEFINED; - y = SDL_WINDOWPOS_UNDEFINED; - } - windows[i] = - SDL_CreateWindow(title, x, y, window_w, window_h, - SDL_WINDOW_SHOWN); - if (!windows[i]) { - fprintf(stderr, "Couldn't create window: %s\n", SDL_GetError()); - quit(2); - } - } - /* Loop, blitting sprites and waiting for a keystroke */ + /* Main render loop */ done = 0; while (!done) { /* Check for events */ while (SDL_PollEvent(&event)) { - switch (event.type) { - case SDL_KEYDOWN: - /* Any keypress quits the app... */ - case SDL_QUIT: - done = 1; - break; - default: - break; - } + CommonEvent(state, &event, &done); } } - quit(0); }