summaryrefslogtreecommitdiff
diff options
context:
space:
mode:
Diffstat
-rw-r--r--indra/llwindow/CMakeLists.txt2
-rw-r--r--indra/llwindow/llkeyboardmacosx.cpp33
-rw-r--r--indra/llwindow/llkeyboardmacosx.h9
-rw-r--r--indra/llwindow/llopenglview-objc.h72
-rw-r--r--indra/llwindow/llopenglview-objc.mm352
-rw-r--r--indra/llwindow/llwindowmacosx-objc.h53
-rw-r--r--indra/llwindow/llwindowmacosx-objc.mm221
-rw-r--r--indra/llwindow/llwindowmacosx.cpp2438
-rw-r--r--indra/llwindow/llwindowmacosx.h52
-rw-r--r--indra/newview/llviewerkeyboard.cpp2
-rwxr-xr-xindra/newview/llviewerwindow.cpp1
11 files changed, 1120 insertions, 2115 deletions
diff --git a/indra/llwindow/CMakeLists.txt b/indra/llwindow/CMakeLists.txt
index 341bddfffd..8a38db751e 100644
--- a/indra/llwindow/CMakeLists.txt
+++ b/indra/llwindow/CMakeLists.txt
@@ -75,11 +75,13 @@ if (DARWIN)
llkeyboardmacosx.cpp
llwindowmacosx.cpp
llwindowmacosx-objc.mm
+ llopenglview-objc.mm
)
list(APPEND llwindow_HEADER_FILES
llkeyboardmacosx.h
llwindowmacosx.h
llwindowmacosx-objc.h
+ llopenglview-objc.h
)
# We use a bunch of deprecated system APIs.
diff --git a/indra/llwindow/llkeyboardmacosx.cpp b/indra/llwindow/llkeyboardmacosx.cpp
index 7f8f303517..3f357c600e 100644
--- a/indra/llwindow/llkeyboardmacosx.cpp
+++ b/indra/llwindow/llkeyboardmacosx.cpp
@@ -30,7 +30,7 @@
#include "llkeyboardmacosx.h"
#include "llwindowcallbacks.h"
-#include <Carbon/Carbon.h>
+#include "llwindowmacosx-objc.h"
LLKeyboardMacOSX::LLKeyboardMacOSX()
{
@@ -162,23 +162,23 @@ LLKeyboardMacOSX::LLKeyboardMacOSX()
void LLKeyboardMacOSX::resetMaskKeys()
{
- U32 mask = GetCurrentEventKeyModifiers();
+ U32 mask = getModifiers();
// MBW -- XXX -- This mirrors the operation of the Windows version of resetMaskKeys().
// It looks a bit suspicious, as it won't correct for keys that have been released.
// Is this the way it's supposed to work?
- if(mask & shiftKey)
+ if(mask & MAC_SHIFT_KEY)
{
mKeyLevel[KEY_SHIFT] = TRUE;
}
- if(mask & (controlKey))
+ if(mask & (MAC_CTRL_KEY))
{
mKeyLevel[KEY_CONTROL] = TRUE;
}
- if(mask & optionKey)
+ if(mask & MAC_ALT_KEY)
{
mKeyLevel[KEY_ALT] = TRUE;
}
@@ -201,17 +201,17 @@ MASK LLKeyboardMacOSX::updateModifiers(const U32 mask)
// translate the mask
MASK out_mask = 0;
- if(mask & shiftKey)
+ if(mask & MAC_SHIFT_KEY)
{
out_mask |= MASK_SHIFT;
}
- if(mask & (controlKey | cmdKey))
+ if(mask & (MAC_CTRL_KEY | MAC_CMD_KEY))
{
out_mask |= MASK_CONTROL;
}
- if(mask & optionKey)
+ if(mask & MAC_ALT_KEY)
{
out_mask |= MASK_ALT;
}
@@ -231,7 +231,12 @@ BOOL LLKeyboardMacOSX::handleKeyDown(const U16 key, const U32 mask)
{
handled = handleTranslatedKeyDown(translated_key, translated_mask);
}
-
+ if (!handled)
+ {
+ LL_INFOS("Keyboard") << "Unhandled key: " << mTranslateKeyMap[key] << LL_ENDL;
+ } else {
+ LL_INFOS("Keyboard") << "Handled key: " << mTranslateKeyMap[key] << LL_ENDL;
+ }
return handled;
}
@@ -255,16 +260,16 @@ BOOL LLKeyboardMacOSX::handleKeyUp(const U16 key, const U32 mask)
MASK LLKeyboardMacOSX::currentMask(BOOL for_mouse_event)
{
MASK result = MASK_NONE;
- U32 mask = GetCurrentEventKeyModifiers();
+ U32 mask = getModifiers();
- if (mask & shiftKey) result |= MASK_SHIFT;
- if (mask & controlKey) result |= MASK_CONTROL;
- if (mask & optionKey) result |= MASK_ALT;
+ if (mask & MAC_SHIFT_KEY) result |= MASK_SHIFT;
+ if (mask & MAC_CTRL_KEY) result |= MASK_CONTROL;
+ if (mask & MAC_ALT_KEY) result |= MASK_ALT;
// For keyboard events, consider Command equivalent to Control
if (!for_mouse_event)
{
- if (mask & cmdKey) result |= MASK_CONTROL;
+ if (mask & MAC_CMD_KEY) result |= MASK_CONTROL;
}
return result;
diff --git a/indra/llwindow/llkeyboardmacosx.h b/indra/llwindow/llkeyboardmacosx.h
index f09ff720ce..6e1f4d3b96 100644
--- a/indra/llwindow/llkeyboardmacosx.h
+++ b/indra/llwindow/llkeyboardmacosx.h
@@ -29,6 +29,15 @@
#include "llkeyboard.h"
+// These more or less mirror their equivalents in NSEvent.h.
+enum EMacEventKeys {
+ MAC_SHIFT_KEY = 1 << 17,
+ MAC_CTRL_KEY = 1 << 18,
+ MAC_ALT_KEY = 1 << 19,
+ MAC_CMD_KEY = 1 << 20,
+ MAC_FN_KEY = 1 << 23
+};
+
class LLKeyboardMacOSX : public LLKeyboard
{
public:
diff --git a/indra/llwindow/llopenglview-objc.h b/indra/llwindow/llopenglview-objc.h
new file mode 100644
index 0000000000..8abe81ce9e
--- /dev/null
+++ b/indra/llwindow/llopenglview-objc.h
@@ -0,0 +1,72 @@
+//
+// LLOpenGLView.h
+// SecondLife
+//
+// Created by Geenz on 10/2/12.
+//
+//
+
+#import <Cocoa/Cocoa.h>
+#include "llwindowmacosx-objc.h"
+
+// Some nasty shovelling of LLOpenGLView from LLNativeBindings to prevent any C++ <-> Obj-C interop oddities.
+// Redraw callback handling removed (for now) due to being unneeded in the patch that preceeds this addition.
+
+@interface LLOpenGLView : NSOpenGLView
+{
+ NSPoint mousePos;
+ ResizeCallback mResizeCallback;
+}
+
+- (id) initWithFrame:(NSRect)frame withSamples:(NSUInteger)samples andVsync:(BOOL)vsync;
+
+// rebuildContext
+// Destroys and recreates a context with the view's internal format set via setPixelFormat;
+// Use this in event of needing to rebuild a context for whatever reason, without needing to assign a new pixel format.
+- (BOOL) rebuildContext;
+
+// rebuildContextWithFormat
+// Destroys and recreates a context with the specified pixel format.
+- (BOOL) rebuildContextWithFormat:(NSOpenGLPixelFormat *)format;
+
+// These are mostly just for C++ <-> Obj-C interop. We can manipulate the CGLContext from C++ without reprecussions.
+- (CGLContextObj) getCGLContextObj;
+- (CGLPixelFormatObj*)getCGLPixelFormatObj;
+
+- (void) registerResizeCallback:(ResizeCallback)callback;
+@end
+
+@interface LLNSWindow : NSWindow {
+ float mMousePos[2];
+ unsigned int mModifiers;
+
+ KeyCallback mKeyDownCallback;
+ KeyCallback mKeyUpCallback;
+ UnicodeCallback mUnicodeCallback;
+ ModifierCallback mModifierCallback;
+ MouseCallback mMouseDownCallback;
+ MouseCallback mMouseUpCallback;
+ MouseCallback mMouseDoubleClickCallback;
+ MouseCallback mRightMouseDownCallback;
+ MouseCallback mRightMouseUpCallback;
+ MouseCallback mMouseMovedCallback;
+ ScrollWheelCallback mScrollWhellCallback;
+ VoidCallback mMouseExitCallback;
+ MouseCallback mDeltaUpdateCallback;
+}
+
+- (void) registerKeyDownCallback:(KeyCallback)callback;
+- (void) registerKeyUpCallback:(KeyCallback)callback;
+- (void) registerUnicodeCallback:(UnicodeCallback)callback;
+- (void) registerModifierCallback:(ModifierCallback)callback;
+- (void) registerMouseDownCallback:(MouseCallback)callback;
+- (void) registerMouseUpCallback:(MouseCallback)callback;
+- (void) registerRightMouseDownCallback:(MouseCallback)callback;
+- (void) registerRightMouseUpCallback:(MouseCallback)callback;
+- (void) registerDoubleClickCallback:(MouseCallback)callback;
+- (void) registerMouseMovedCallback:(MouseCallback)callback;
+- (void) registerScrollCallback:(ScrollWheelCallback)callback;
+- (void) registerMouseExitCallback:(VoidCallback)callback;
+- (void) registerDeltaUpdateCallback:(MouseCallback)callback;
+
+@end \ No newline at end of file
diff --git a/indra/llwindow/llopenglview-objc.mm b/indra/llwindow/llopenglview-objc.mm
new file mode 100644
index 0000000000..a96c4cf82c
--- /dev/null
+++ b/indra/llwindow/llopenglview-objc.mm
@@ -0,0 +1,352 @@
+//
+// LLOpenGLView.m
+// SecondLife
+//
+// Created by Geenz on 10/2/12.
+//
+//
+
+#import "llopenglview-objc.h"
+
+@implementation LLOpenGLView
+
+- (void)viewDidMoveToWindow
+{
+ [[NSNotificationCenter defaultCenter] addObserver:self
+ selector:@selector(windowResized:) name:NSWindowDidResizeNotification
+ object:[self window]];
+}
+
+- (void)windowResized:(NSNotification *)notification;
+{
+ NSSize size = [[self window] frame].size;
+
+ mResizeCallback(size.width, size.height);
+}
+
+- (void)dealloc
+{
+ [[NSNotificationCenter defaultCenter] removeObserver:self];
+ [super dealloc];
+}
+
+- (id) initWithFrame:(NSRect)frame withSamples:(NSUInteger)samples andVsync:(BOOL)vsync
+{
+
+ [self initWithFrame:frame];
+
+ // Initialize with a default "safe" pixel format that will work with versions dating back to OS X 10.6.
+ // Any specialized pixel formats, i.e. a core profile pixel format, should be initialized through rebuildContextWithFormat.
+ // 10.7 and 10.8 don't really care if we're defining a profile or not. If we don't explicitly request a core or legacy profile, it'll always assume a legacy profile (for compatibility reasons).
+ NSOpenGLPixelFormatAttribute attrs[] = {
+ NSOpenGLPFANoRecovery,
+ NSOpenGLPFADoubleBuffer,
+ NSOpenGLPFAClosestPolicy,
+ NSOpenGLPFAAccelerated,
+ NSOpenGLPFASampleBuffers, (samples > 0 ? 1 : 0),
+ NSOpenGLPFASamples, samples,
+ NSOpenGLPFAStencilSize, 8,
+ NSOpenGLPFADepthSize, 24,
+ NSOpenGLPFAAlphaSize, 8,
+ NSOpenGLPFAColorSize, 24,
+ 0
+ };
+
+ NSOpenGLPixelFormat *pixelFormat = [[[NSOpenGLPixelFormat alloc] initWithAttributes:attrs] autorelease];
+
+ if (pixelFormat == nil)
+ {
+ NSLog(@"Failed to create pixel format!", nil);
+ return nil;
+ }
+
+ NSOpenGLContext *glContext = [[NSOpenGLContext alloc] initWithFormat:pixelFormat shareContext:nil];
+
+ if (glContext == nil)
+ {
+ NSLog(@"Failed to create OpenGL context!", nil);
+ return nil;
+ }
+
+ [self setPixelFormat:pixelFormat];
+
+ [self setOpenGLContext:glContext];
+
+ [glContext setView:self];
+
+ [glContext makeCurrentContext];
+
+ if (vsync)
+ {
+ [glContext setValues:(const GLint*)1 forParameter:NSOpenGLCPSwapInterval];
+ } else {
+ [glContext setValues:(const GLint*)0 forParameter:NSOpenGLCPSwapInterval];
+ }
+
+ return self;
+}
+
+- (BOOL) rebuildContext
+{
+ return [self rebuildContextWithFormat:[self pixelFormat]];
+}
+
+- (BOOL) rebuildContextWithFormat:(NSOpenGLPixelFormat *)format
+{
+ NSOpenGLContext *ctx = [self openGLContext];
+
+ [ctx clearDrawable];
+ [ctx initWithFormat:format shareContext:nil];
+
+ if (ctx == nil)
+ {
+ NSLog(@"Failed to create OpenGL context!", nil);
+ return false;
+ }
+
+ [self setOpenGLContext:ctx];
+ [ctx setView:self];
+ [ctx makeCurrentContext];
+ return true;
+}
+
+- (CGLContextObj)getCGLContextObj
+{
+ NSOpenGLContext *ctx = [self openGLContext];
+ return (CGLContextObj)[ctx CGLContextObj];
+}
+
+- (CGLPixelFormatObj*)getCGLPixelFormatObj
+{
+ NSOpenGLPixelFormat *fmt = [self pixelFormat];
+ return (CGLPixelFormatObj*)[fmt CGLPixelFormatObj];
+}
+
+- (void) registerResizeCallback:(ResizeCallback)callback
+{
+ mResizeCallback = callback;
+}
+
+// Various events can be intercepted by our view, thus not reaching our window.
+// Intercept these events, and pass them to the window as needed. - Geenz
+
+- (void) mouseDragged:(NSEvent *)theEvent
+{
+ [super mouseDragged:theEvent];
+}
+
+- (void) scrollWheel:(NSEvent *)theEvent
+{
+ [super scrollWheel:theEvent];
+}
+
+- (void) mouseDown:(NSEvent *)theEvent
+{
+ [super mouseDown:theEvent];
+}
+
+- (void) mouseUp:(NSEvent *)theEvent
+{
+ [super mouseUp:theEvent];
+}
+
+- (void) rightMouseDown:(NSEvent *)theEvent
+{
+ [super rightMouseDown:theEvent];
+}
+
+- (void) rightMouseUp:(NSEvent *)theEvent
+{
+ [super rightMouseUp:theEvent];
+}
+
+- (void) keyUp:(NSEvent *)theEvent
+{
+ [super keyUp:theEvent];
+}
+
+- (void) keyDown:(NSEvent *)theEvent
+{
+ [super keyDown:theEvent];
+}
+
+- (void) mouseMoved:(NSEvent *)theEvent
+{
+ [super mouseMoved:theEvent];
+}
+
+- (void) flagsChanged:(NSEvent *)theEvent
+{
+ [super flagsChanged:theEvent];
+}
+
+@end
+
+// We use a custom NSWindow for our event handling.
+// Why not an NSWindowController you may ask?
+// Answer: this is easier.
+
+@implementation LLNSWindow
+
+- (id) init
+{
+ return self;
+}
+
+- (void) keyDown:(NSEvent *)theEvent {
+ mKeyDownCallback([theEvent keyCode], [theEvent modifierFlags]);
+
+ NSString *chars = [theEvent charactersIgnoringModifiers];
+ for (uint i = 0; i < [chars length]; i++)
+ {
+ mUnicodeCallback([chars characterAtIndex:i], [theEvent modifierFlags]);
+ }
+
+ // The viewer expects return to be submitted separately as a unicode character.
+ if ([theEvent keyCode] == 3 || [theEvent keyCode] == 13)
+ {
+ mUnicodeCallback([theEvent keyCode], [theEvent modifierFlags]);
+ }
+}
+
+- (void) keyUp:(NSEvent *)theEvent {
+ mKeyUpCallback([theEvent keyCode], [theEvent modifierFlags]);
+}
+
+- (void)flagsChanged:(NSEvent *)theEvent {
+ mModifiers = [theEvent modifierFlags];
+}
+
+- (void) mouseDown:(NSEvent *)theEvent
+{
+ if ([theEvent clickCount] == 2)
+ {
+ mMouseDoubleClickCallback(mMousePos, [theEvent modifierFlags]);
+ } else if ([theEvent clickCount] == 1) {
+ mMouseDownCallback(mMousePos, [theEvent modifierFlags]);
+ }
+}
+
+- (void) mouseUp:(NSEvent *)theEvent
+{
+ mMouseUpCallback(mMousePos, [theEvent modifierFlags]);
+}
+
+- (void) rightMouseDown:(NSEvent *)theEvent
+{
+ mRightMouseDownCallback(mMousePos, [theEvent modifierFlags]);
+}
+
+- (void) rightMouseUp:(NSEvent *)theEvent
+{
+ mRightMouseUpCallback(mMousePos, [theEvent modifierFlags]);
+}
+
+- (void)mouseMoved:(NSEvent *)theEvent {
+ float mouseDeltas[2] = {
+ [theEvent deltaX],
+ [theEvent deltaZ]
+ };
+
+ mDeltaUpdateCallback(mouseDeltas, 0);
+
+ NSPoint mPoint = [theEvent locationInWindow];
+ mMousePos[0] = mPoint.x;
+ mMousePos[1] = mPoint.y;
+ mMouseMovedCallback(mMousePos, 0);
+}
+
+// NSWindow doesn't trigger mouseMoved when the mouse is being clicked and dragged.
+// Use mouseDragged for situations like this to trigger our movement callback instead.
+
+- (void) mouseDragged:(NSEvent *)theEvent
+{
+ float mouseDeltas[2] = {
+ [theEvent deltaX],
+ [theEvent deltaZ]
+ };
+
+ mDeltaUpdateCallback(mouseDeltas, 0);
+
+ NSPoint mPoint = [theEvent locationInWindow];
+ mMousePos[0] = mPoint.x;
+ mMousePos[1] = mPoint.y;
+ mMouseMovedCallback(mMousePos, 0);
+}
+
+- (void) scrollWheel:(NSEvent *)theEvent
+{
+ mScrollWhellCallback(-[theEvent deltaY]);
+}
+
+- (void) mouseExited:(NSEvent *)theEvent
+{
+ mMouseExitCallback();
+}
+
+- (void) registerKeyDownCallback:(KeyCallback)callback
+{
+ mKeyDownCallback = callback;
+}
+
+- (void) registerKeyUpCallback:(KeyCallback)callback
+{
+ mKeyUpCallback = callback;
+}
+
+- (void) registerUnicodeCallback:(UnicodeCallback)callback
+{
+ mUnicodeCallback = callback;
+}
+
+- (void) registerModifierCallback:(ModifierCallback)callback
+{
+ mModifierCallback = callback;
+}
+
+- (void) registerMouseDownCallback:(MouseCallback)callback
+{
+ mMouseDownCallback = callback;
+}
+
+- (void) registerMouseUpCallback:(MouseCallback)callback
+{
+ mMouseUpCallback = callback;
+}
+
+- (void) registerRightMouseDownCallback:(MouseCallback)callback
+{
+ mRightMouseDownCallback = callback;
+}
+
+- (void) registerRightMouseUpCallback:(MouseCallback)callback
+{
+ mRightMouseUpCallback = callback;
+}
+
+- (void) registerDoubleClickCallback:(MouseCallback)callback
+{
+ mMouseDoubleClickCallback = callback;
+}
+
+- (void) registerMouseMovedCallback:(MouseCallback)callback
+{
+ mMouseMovedCallback = callback;
+}
+
+- (void) registerScrollCallback:(ScrollWheelCallback)callback
+{
+ mScrollWhellCallback = callback;
+}
+
+- (void) registerMouseExitCallback:(VoidCallback)callback
+{
+ mMouseExitCallback = callback;
+}
+
+- (void) registerDeltaUpdateCallback:(MouseCallback)callback
+{
+ mDeltaUpdateCallback = callback;
+}
+
+@end \ No newline at end of file
diff --git a/indra/llwindow/llwindowmacosx-objc.h b/indra/llwindow/llwindowmacosx-objc.h
index 7893dedda4..47ae13cb25 100644
--- a/indra/llwindow/llwindowmacosx-objc.h
+++ b/indra/llwindow/llwindowmacosx-objc.h
@@ -24,14 +24,61 @@
* Linden Research, Inc., 945 Battery Street, San Francisco, CA 94111 USA
* $/LicenseInfo$
*/
-
+#include <boost/tr1/functional.hpp>
+typedef std::tr1::function<void(unsigned short, unsigned int)> KeyCallback;
+typedef std::tr1::function<void(unsigned int)> ModifierCallback;
+typedef std::tr1::function<void(float*, unsigned int)> MouseCallback;
+typedef std::tr1::function<void(wchar_t, unsigned int)> UnicodeCallback;
+typedef std::tr1::function<void(unsigned int, unsigned int)> ResizeCallback;
+typedef std::tr1::function<void(float)> ScrollWheelCallback;
+typedef std::tr1::function<void()> VoidCallback;
// This will actually hold an NSCursor*, but that type is only available in objective C.
typedef void *CursorRef;
+typedef void *NSWindowRef;
+typedef void *GLViewRef;
/* Defined in llwindowmacosx-objc.mm: */
void setupCocoa();
CursorRef createImageCursor(const char *fullpath, int hotspotX, int hotspotY);
-OSErr releaseImageCursor(CursorRef ref);
-OSErr setImageCursor(CursorRef ref);
+short releaseImageCursor(CursorRef ref);
+short setImageCursor(CursorRef ref);
+void setArrowCursor();
+void setIBeamCursor();
+void setPointingHandCursor();
+void setCopyCursor();
+void setCrossCursor();
+void hideNSCursor();
+void showNSCursor();
+void hideNSCursorTillMove(bool hide);
+
+NSWindowRef createNSWindow(int x, int y, int width, int height);
+
+#include <OpenGL/OpenGL.h>
+GLViewRef createOpenGLView(NSWindowRef window);
+void glSwapBuffers(void* context);
+CGLContextObj getCGLContextObj(NSWindowRef window);
+void getContentViewBounds(NSWindowRef window, float* bounds);
+void getWindowSize(NSWindowRef window, float* size);
+void setWindowSize(NSWindowRef window, int width, int height);
+void getCursorPos(NSWindowRef window, float* pos);
+void makeWindowOrderFront(NSWindowRef window);
+void convertScreenToWindow(NSWindowRef window, float *coord);
+void convertWindowToScreen(NSWindowRef window, float *coord);
+void setWindowPos(NSWindowRef window, float* pos);
+
+void registerKeyUpCallback(NSWindowRef window, KeyCallback callback);
+void registerKeyDownCallback(NSWindowRef window, KeyCallback callback);
+void registerUnicodeCallback(NSWindowRef window, UnicodeCallback callback);
+void registerMouseUpCallback(NSWindowRef window, MouseCallback callback);
+void registerMouseDownCallback(NSWindowRef window, MouseCallback callback);
+void registerRightMouseUpCallback(NSWindowRef window, MouseCallback callback);
+void registerRightMouseDownCallback(NSWindowRef window, MouseCallback callback);
+void registerDoubleClickCallback(NSWindowRef window, MouseCallback callback);
+void registerResizeEventCallback(GLViewRef window, ResizeCallback callback);
+void registerMouseMovedCallback(NSWindowRef window, MouseCallback callback);
+void registerScrollCallback(NSWindowRef window, ScrollWheelCallback callback);
+void registerMouseExitCallback(NSWindowRef window, VoidCallback callback);
+void registerDeltaUpdateCallback(NSWindowRef window, MouseCallback callback);
+unsigned int getModifiers();
diff --git a/indra/llwindow/llwindowmacosx-objc.mm b/indra/llwindow/llwindowmacosx-objc.mm
index bebb537cd8..03c0f55883 100644
--- a/indra/llwindow/llwindowmacosx-objc.mm
+++ b/indra/llwindow/llwindowmacosx-objc.mm
@@ -26,6 +26,9 @@
*/
#include <AppKit/AppKit.h>
+#include <Cocoa/Cocoa.h>
+#include "llwindowmacosx-objc.h"
+#include "llopenglview-objc.h"
/*
* These functions are broken out into a separate file because the
@@ -34,8 +37,6 @@
* linden headers with any objective-C++ source.
*/
-#include "llwindowmacosx-objc.h"
-
void setupCocoa()
{
static bool inited = false;
@@ -83,6 +84,51 @@ CursorRef createImageCursor(const char *fullpath, int hotspotX, int hotspotY)
return (CursorRef)cursor;
}
+void setArrowCursor()
+{
+ NSCursor *cursor = [NSCursor arrowCursor];
+ [cursor set];
+}
+
+void setIBeamCursor()
+{
+ NSCursor *cursor = [NSCursor IBeamCursor];
+ [cursor set];
+}
+
+void setPointingHandCursor()
+{
+ NSCursor *cursor = [NSCursor pointingHandCursor];
+ [cursor set];
+}
+
+void setCopyCursor()
+{
+ NSCursor *cursor = [NSCursor dragCopyCursor];
+ [cursor set];
+}
+
+void setCrossCursor()
+{
+ NSCursor *cursor = [NSCursor crosshairCursor];
+ [cursor set];
+}
+
+void hideNSCursor()
+{
+ [NSCursor hide];
+}
+
+void showNSCursor()
+{
+ [NSCursor unhide];
+}
+
+void hideNSCursorTillMove(bool hide)
+{
+ [NSCursor setHiddenUntilMouseMoves:hide];
+}
+
// This is currently unused, since we want all our cursors to persist for the life of the app, but I've included it for completeness.
OSErr releaseImageCursor(CursorRef ref)
{
@@ -118,3 +164,174 @@ OSErr setImageCursor(CursorRef ref)
return noErr;
}
+// Now for some unholy juggling between generic pointers and casting them to Obj-C objects!
+// Note: things can get a bit hairy from here. This is not for the faint of heart.
+
+NSWindowRef createNSWindow(int x, int y, int width, int height)
+{
+ LLNSWindow *window = [[LLNSWindow alloc]initWithContentRect:NSMakeRect(x, y, width, height)
+ styleMask:NSTitledWindowMask | NSResizableWindowMask | NSClosableWindowMask | NSMiniaturizableWindowMask | NSTexturedBackgroundWindowMask backing:NSBackingStoreBuffered defer:NO];
+ [window makeKeyAndOrderFront:nil];
+ [window setAcceptsMouseMovedEvents:TRUE];
+ return window;
+}
+
+GLViewRef createOpenGLView(NSWindowRef window)
+{
+ LLOpenGLView *glview = [[LLOpenGLView alloc]initWithFrame:[(LLNSWindow*)window frame] withSamples:0 andVsync:FALSE];
+ [(LLNSWindow*)window setContentView:glview];
+ return glview;
+}
+
+void glSwapBuffers(void* context)
+{
+ [(NSOpenGLContext*)context flushBuffer];
+}
+
+CGLContextObj getCGLContextObj(NSWindowRef window)
+{
+ LLOpenGLView *glview = [(LLNSWindow*)window contentView];
+ return [glview getCGLContextObj];
+}
+
+CGLPixelFormatObj* getCGLPixelFormatObj(NSWindowRef window)
+{
+ LLOpenGLView *glview = [(LLNSWindow*)window contentView];
+ return [glview getCGLPixelFormatObj];
+}
+
+void getContentViewBounds(NSWindowRef window, float* bounds)
+{
+ bounds[0] = [[(LLNSWindow*)window contentView] bounds].origin.x;
+ bounds[1] = [[(LLNSWindow*)window contentView] bounds].origin.y;
+ bounds[2] = [[(LLNSWindow*)window contentView] bounds].size.width;
+ bounds[3] = [[(LLNSWindow*)window contentView] bounds].size.height;
+}
+
+void getWindowSize(NSWindowRef window, float* size)
+{
+ NSRect frame = [(LLNSWindow*)window frame];
+ size[0] = frame.origin.x;
+ size[1] = frame.origin.y;
+ size[2] = frame.size.width;
+ size[3] = frame.size.height;
+}
+
+void setWindowSize(NSWindowRef window, int width, int height)
+{
+ NSRect frame = [(LLNSWindow*)window frame];
+ frame.size.width = width;
+ frame.size.height = height;
+ [(LLNSWindow*)window setFrame:frame display:TRUE];
+}
+
+void setWindowPos(NSWindowRef window, float* pos)
+{
+ NSPoint point;
+ point.x = pos[0];
+ point.y = pos[1];
+ [(LLNSWindow*)window setFrameOrigin:point];
+}
+
+void getCursorPos(NSWindowRef window, float* pos)
+{
+ NSPoint mLoc;
+ mLoc = [(LLNSWindow*)window mouseLocationOutsideOfEventStream];
+ pos[0] = mLoc.x;
+ pos[1] = mLoc.y;
+}
+
+void makeWindowOrderFront(NSWindowRef window)
+{
+ [(LLNSWindow*)window makeKeyAndOrderFront:nil];
+}
+
+void convertScreenToWindow(NSWindowRef window, float *coord)
+{
+ NSPoint point;
+ point.x = coord[0];
+ point.y = coord[1];
+ point = [(LLNSWindow*)window convertScreenToBase:point];
+ coord[0] = point.x;
+ coord[1] = point.y;
+}
+
+void convertWindowToScreen(NSWindowRef window, float *coord)
+{
+ NSPoint point;
+ point.x = coord[0];
+ point.y = coord[1];
+ point = [(LLNSWindow*)window convertBaseToScreen:point];
+ coord[0] = point.x;
+ coord[1] = point.y;
+}
+
+void registerKeyUpCallback(NSWindowRef window, std::tr1::function<void(unsigned short, unsigned int)> callback)
+{
+ [(LLNSWindow*)window registerKeyUpCallback:callback];
+}
+
+void registerKeyDownCallback(NSWindowRef window, std::tr1::function<void(unsigned short, unsigned int)> callback)
+{
+ [(LLNSWindow*)window registerKeyDownCallback:callback];
+}
+
+void registerUnicodeCallback(NSWindowRef window, std::tr1::function<void(wchar_t, unsigned int)> callback)
+{
+ [(LLNSWindow*)window registerUnicodeCallback:callback];
+}
+
+void registerMouseUpCallback(NSWindowRef window, MouseCallback callback)
+{
+ [(LLNSWindow*)window registerMouseUpCallback:callback];
+}
+
+void registerMouseDownCallback(NSWindowRef window, MouseCallback callback)
+{
+ [(LLNSWindow*)window registerMouseDownCallback:callback];
+}
+
+void registerRightMouseUpCallback(NSWindowRef window, MouseCallback callback)
+{
+ [(LLNSWindow*)window registerRightMouseUpCallback:callback];
+}
+
+void registerRightMouseDownCallback(NSWindowRef window, MouseCallback callback)
+{
+ [(LLNSWindow*)window registerRightMouseDownCallback:callback];
+}
+
+void registerDoubleClickCallback(NSWindowRef window, MouseCallback callback)
+{
+ [(LLNSWindow*)window registerDoubleClickCallback:callback];
+}
+
+void registerResizeEventCallback(GLViewRef glview, ResizeCallback callback)
+{
+ [(LLOpenGLView*)glview registerResizeCallback:callback];
+}
+
+void registerMouseMovedCallback(NSWindowRef window, MouseCallback callback)
+{
+ [(LLNSWindow*)window registerMouseMovedCallback:callback];
+}
+
+void registerScrollCallback(NSWindowRef window, ScrollWheelCallback callback)
+{
+ [(LLNSWindow*)window registerScrollCallback:callback];
+}
+
+void registerMouseExitCallback(NSWindowRef window, VoidCallback callback)
+{
+ [(LLNSWindow*)window registerMouseExitCallback:callback];
+}
+
+void registerDeltaUpdateCallback(NSWindowRef window, MouseCallback callback)
+{
+ [(LLNSWindow*)window registerDeltaUpdateCallback:callback];
+}
+
+unsigned int getModifiers()
+{
+ return [NSEvent modifierFlags];
+}
diff --git a/indra/llwindow/llwindowmacosx.cpp b/indra/llwindow/llwindowmacosx.cpp
index 97637c937f..1fb8bea802 100644
--- a/indra/llwindow/llwindowmacosx.cpp
+++ b/indra/llwindow/llwindowmacosx.cpp
@@ -30,7 +30,6 @@
#include "llkeyboardmacosx.h"
#include "llwindowcallbacks.h"
-#include "llwindowmacosx-objc.h"
#include "llpreeditor.h"
#include "llerror.h"
@@ -58,7 +57,6 @@ const S32 MAX_NUM_RESOLUTIONS = 32;
//
BOOL LLWindowMacOSX::sUseMultGL = FALSE;
-WindowRef LLWindowMacOSX::sMediaWindow = NULL;
// Cross-platform bits:
@@ -98,105 +96,9 @@ BOOL check_for_card(const char* RENDERER, const char* bad_card)
// We may want to base this on the setting of _DEBUG...
#define CAPTURE_ALL_DISPLAYS 0
-static double getDictDouble (CFDictionaryRef refDict, CFStringRef key);
+//static double getDictDouble (CFDictionaryRef refDict, CFStringRef key);
static long getDictLong (CFDictionaryRef refDict, CFStringRef key);
-
-
-
-// CarbonEvents we're interested in.
-static EventTypeSpec WindowHandlerEventList[] =
-{
- // Window-related events
- { kEventClassWindow, kEventWindowActivated },
- { kEventClassWindow, kEventWindowDeactivated },
- { kEventClassWindow, kEventWindowShown },
- { kEventClassWindow, kEventWindowHidden },
- { kEventClassWindow, kEventWindowCollapsed },
- { kEventClassWindow, kEventWindowExpanded },
- { kEventClassWindow, kEventWindowGetClickActivation },
- { kEventClassWindow, kEventWindowClose },
- { kEventClassWindow, kEventWindowBoundsChanging },
- { kEventClassWindow, kEventWindowBoundsChanged },
- { kEventClassWindow, kEventWindowGetIdealSize },
-
- // Mouse events
- { kEventClassMouse, kEventMouseDown },
- { kEventClassMouse, kEventMouseUp },
- { kEventClassMouse, kEventMouseDragged },
- { kEventClassMouse, kEventMouseWheelMoved },
- { kEventClassMouse, kEventMouseMoved },
-
- // Keyboard events
- // No longer handle raw key down events directly.
- // When text input events come in, extract the raw key events from them and process at that point.
- // This allows input methods to eat keystrokes the way they're supposed to.
-// { kEventClassKeyboard, kEventRawKeyDown },
-// { kEventClassKeyboard, kEventRawKeyRepeat },
- { kEventClassKeyboard, kEventRawKeyUp },
- { kEventClassKeyboard, kEventRawKeyModifiersChanged },
-
- // Text input events
- { kEventClassTextInput, kEventTextInputUnicodeForKeyEvent },
- { kEventClassTextInput, kEventTextInputUpdateActiveInputArea },
- { kEventClassTextInput, kEventTextInputOffsetToPos },
- { kEventClassTextInput, kEventTextInputPosToOffset },
- { kEventClassTextInput, kEventTextInputShowHideBottomWindow },
- { kEventClassTextInput, kEventTextInputGetSelectedText },
- { kEventClassTextInput, kEventTextInputFilterText },
-
- // TSM Document Access events (advanced input method support)
- { kEventClassTSMDocumentAccess, kEventTSMDocumentAccessGetLength },
- { kEventClassTSMDocumentAccess, kEventTSMDocumentAccessGetSelectedRange },
- { kEventClassTSMDocumentAccess, kEventTSMDocumentAccessGetCharacters },
- { kEventClassTSMDocumentAccess, kEventTSMDocumentAccessGetFont },
- { kEventClassTSMDocumentAccess, kEventTSMDocumentAccessGetGlyphInfo },
- { kEventClassTSMDocumentAccess, kEventTSMDocumentAccessLockDocument },
- { kEventClassTSMDocumentAccess, kEventTSMDocumentAccessUnlockDocument }
-};
-
-static EventTypeSpec GlobalHandlerEventList[] =
-{
- // Mouse events
- { kEventClassMouse, kEventMouseDown },
- { kEventClassMouse, kEventMouseUp },
- { kEventClassMouse, kEventMouseDragged },
- { kEventClassMouse, kEventMouseWheelMoved },
- { kEventClassMouse, kEventMouseMoved },
-
- // Keyboard events
- // No longer handle raw key down events directly.
- // When text input events come in, extract the raw key events from them and process at that point.
- // This allows input methods to eat keystrokes the way they're supposed to.
-// { kEventClassKeyboard, kEventRawKeyDown },
-// { kEventClassKeyboard, kEventRawKeyRepeat },
- { kEventClassKeyboard, kEventRawKeyUp },
- { kEventClassKeyboard, kEventRawKeyModifiersChanged },
-
- // Text input events
- { kEventClassTextInput, kEventTextInputUpdateActiveInputArea },
- { kEventClassTextInput, kEventTextInputUnicodeForKeyEvent },
- { kEventClassTextInput, kEventTextInputOffsetToPos },
- { kEventClassTextInput, kEventTextInputPosToOffset },
- { kEventClassTextInput, kEventTextInputShowHideBottomWindow },
- { kEventClassTextInput, kEventTextInputGetSelectedText },
- { kEventClassTextInput, kEventTextInputFilterText },
-
- // TSM Document Access events (advanced input method support)
- { kEventClassTSMDocumentAccess, kEventTSMDocumentAccessGetLength },
- { kEventClassTSMDocumentAccess, kEventTSMDocumentAccessGetSelectedRange },
- { kEventClassTSMDocumentAccess, kEventTSMDocumentAccessGetCharacters },
- { kEventClassTSMDocumentAccess, kEventTSMDocumentAccessGetFont },
- { kEventClassTSMDocumentAccess, kEventTSMDocumentAccessGetGlyphInfo },
- { kEventClassTSMDocumentAccess, kEventTSMDocumentAccessLockDocument },
- { kEventClassTSMDocumentAccess, kEventTSMDocumentAccessUnlockDocument }
-};
-
-static EventTypeSpec CommandHandlerEventList[] =
-{
- { kEventClassCommand, kEventCommandProcess }
-};
-
// MBW -- HACK ALERT
// On the Mac, to put up an OS dialog in full screen mode, we must first switch OUT of full screen mode.
// The proper way to do this is to bracket the dialog with calls to beforeDialog() and afterDialog(), but these
@@ -204,8 +106,6 @@ static EventTypeSpec CommandHandlerEventList[] =
// This assumes that there will be only one object of this class at any time. Hopefully this is true.
static LLWindowMacOSX *gWindowImplementation = NULL;
-
-
LLWindowMacOSX::LLWindowMacOSX(LLWindowCallbacks* callbacks,
const std::string& title, const std::string& name, S32 x, S32 y, S32 width,
S32 height, U32 flags,
@@ -233,8 +133,6 @@ LLWindowMacOSX::LLWindowMacOSX(LLWindowCallbacks* callbacks,
mContext = NULL;
mPixelFormat = NULL;
mDisplay = CGMainDisplayID();
- mOldDisplayMode = NULL;
- mTimer = NULL;
mSimulatedRightClick = FALSE;
mLastModifiers = 0;
mHandsOffEvents = FALSE;
@@ -246,12 +144,8 @@ LLWindowMacOSX::LLWindowMacOSX(LLWindowCallbacks* callbacks,
mOverrideAspectRatio = 0.f;
mMaximized = FALSE;
mMinimized = FALSE;
- mTSMDocument = NULL; // Just in case.
mLanguageTextInputAllowed = FALSE;
- mTSMScriptCode = 0;
- mTSMLangCode = 0;
mPreeditor = NULL;
- mRawKeyEvent = NULL;
mFSAASamples = fsaa_samples;
mForceRebuild = FALSE;
@@ -263,43 +157,23 @@ LLWindowMacOSX::LLWindowMacOSX(LLWindowCallbacks* callbacks,
mOriginalAspectRatio = (double)CGDisplayPixelsWide(mDisplay) / (double)CGDisplayPixelsHigh(mDisplay);
// Stash the window title
- strcpy((char*)mWindowTitle + 1, title.c_str()); /* Flawfinder: ignore */
- mWindowTitle[0] = title.length();
-
- mEventHandlerUPP = NewEventHandlerUPP(staticEventHandler);
- mMoveEventCampartorUPP = NewEventComparatorUPP(staticMoveEventComparator);
- mGlobalHandlerRef = NULL;
- mWindowHandlerRef = NULL;
+ mWindowTitle = title;
+ //mWindowTitle[0] = title.length();
mDragOverrideCursor = -1;
- // We're not clipping yet
- SetRect( &mOldMouseClip, 0, 0, 0, 0 );
-
// Set up global event handlers (the fullscreen case needs this)
- InstallStandardEventHandler(GetApplicationEventTarget());
+ //InstallStandardEventHandler(GetApplicationEventTarget());
// Stash an object pointer for OSMessageBox()
gWindowImplementation = this;
-
// Create the GL context and set it up for windowed or fullscreen, as appropriate.
+ LL_INFOS("Window") << "Creating context..." << LL_ENDL;
if(createContext(x, y, width, height, 32, fullscreen, disable_vsync))
{
if(mWindow != NULL)
{
- // MBW -- XXX -- I think we can now do this here?
- // Constrain the window to the screen it's mostly on, resizing if necessary.
- ConstrainWindowToScreen(
- mWindow,
- kWindowStructureRgn,
- kWindowConstrainMayResize |
- // kWindowConstrainStandardOptions |
- 0,
- NULL,
- NULL);
-
- MacShowWindow(mWindow);
- BringToFront(mWindow);
+ makeWindowOrderFront(mWindow);
}
if (!gGLManager.initGL())
@@ -321,463 +195,193 @@ LLWindowMacOSX::LLWindowMacOSX(LLWindowCallbacks* callbacks,
mCallbacks = callbacks;
stop_glerror();
+
+
}
-BOOL LLWindowMacOSX::createContext(int x, int y, int width, int height, int bits, BOOL fullscreen, BOOL disable_vsync)
-{
- OSStatus err;
- BOOL glNeedsInit = FALSE;
-
- if(mGlobalHandlerRef == NULL)
- {
- InstallApplicationEventHandler(mEventHandlerUPP, GetEventTypeCount (CommandHandlerEventList), CommandHandlerEventList, (void*)this, &mGlobalHandlerRef);
- }
-
- mFullscreen = fullscreen;
+// These functions are used as callbacks for event handling within Cocoa.
+// It's a good idea to wrap these to avoid reworking more code than we need to within LLWindow.
- if (mFullscreen && (mOldDisplayMode == NULL))
- {
- LL_INFOS("Window") << "createContext: setting up fullscreen " << width << "x" << height << LL_ENDL;
-
- // NOTE: The refresh rate will be REPORTED AS 0 for many DVI and notebook displays. Plan accordingly.
- double refresh = getDictDouble (CGDisplayCurrentMode (mDisplay), kCGDisplayRefreshRate);
-
- // If the requested width or height is 0, find the best default for the monitor.
- if((width == 0) || (height == 0))
- {
- // Scan through the list of modes, looking for one which has:
- // height between 700 and 800
- // aspect ratio closest to the user's original mode
- S32 resolutionCount = 0;
- LLWindowResolution *resolutionList = getSupportedResolutions(resolutionCount);
+void callKeyUp(unsigned short key, unsigned int mask)
+{
+ gKeyboard->handleKeyUp(key, mask);
+}
- if(resolutionList != NULL)
- {
- F32 closestAspect = 0;
- U32 closestHeight = 0;
- U32 closestWidth = 0;
- int i;
+void callKeyDown(unsigned short key, unsigned int mask)
+{
+ gKeyboard->handleKeyDown(key, mask);
+}
- LL_DEBUGS("Window") << "createContext: searching for a display mode, original aspect is " << mOriginalAspectRatio << LL_ENDL;
+void callUnicodeCallback(wchar_t character, unsigned int mask)
+{
+ gWindowImplementation->getCallbacks()->handleUnicodeChar(character, mask);
+}
- for(i=0; i < resolutionCount; i++)
- {
- F32 aspect = (F32)resolutionList[i].mWidth / (F32)resolutionList[i].mHeight;
+void callModifierCallback(unsigned int mask)
+{
+
+}
- LL_DEBUGS("Window") << "createContext: width " << resolutionList[i].mWidth << " height " << resolutionList[i].mHeight << " aspect " << aspect << LL_ENDL;
+void callRightMouseDown(float *pos, MASK mask)
+{
+ LLCoordGL outCoords;
+ outCoords.mX = llround(pos[0]);
+ outCoords.mY = llround(pos[1]);
+ gWindowImplementation->getCallbacks()->handleRightMouseDown(gWindowImplementation, outCoords, gKeyboard->currentMask(TRUE));
+}
- if( (resolutionList[i].mHeight >= 700) && (resolutionList[i].mHeight <= 800) &&
- (fabs(aspect - mOriginalAspectRatio) < fabs(closestAspect - mOriginalAspectRatio)))
- {
- LL_DEBUGS("Window") << " (new closest mode) " << LL_ENDL;
+void callRightMouseUp(float *pos, MASK mask)
+{
+ LLCoordGL outCoords;
+ outCoords.mX = llround(pos[0]);
+ outCoords.mY = llround(pos[1]);
+ gWindowImplementation->getCallbacks()->handleRightMouseUp(gWindowImplementation, outCoords, gKeyboard->currentMask(TRUE));
+}
- // This is the closest mode we've seen yet.
- closestWidth = resolutionList[i].mWidth;
- closestHeight = resolutionList[i].mHeight;
- closestAspect = aspect;
- }
- }
+void callLeftMouseDown(float *pos, MASK mask)
+{
+ LLCoordGL outCoords;
+ outCoords.mX = llround(pos[0]);
+ outCoords.mY = llround(pos[1]);
+ gWindowImplementation->getCallbacks()->handleMouseDown(gWindowImplementation, outCoords, gKeyboard->currentMask(TRUE));
+ LL_INFOS("Window") << outCoords.mX << ", " << outCoords.mY << LL_ENDL;
+}
- width = closestWidth;
- height = closestHeight;
- }
- }
+void callLeftMouseUp(float *pos, MASK mask)
+{
+ LLCoordGL outCoords;
+ outCoords.mX = llround(pos[0]);
+ outCoords.mY = llround(pos[1]);
+ gWindowImplementation->getCallbacks()->handleMouseUp(gWindowImplementation, outCoords, gKeyboard->currentMask(TRUE));
+
+}
- if((width == 0) || (height == 0))
- {
- // Mode search failed for some reason. Use the old-school default.
- width = 1024;
- height = 768;
- }
+void callDoubleClick(float *pos, MASK mask)
+{
+ LLCoordGL outCoords;
+ outCoords.mX = llround(pos[0]);
+ outCoords.mY = llround(pos[1]);
+ gWindowImplementation->getCallbacks()->handleDoubleClick(gWindowImplementation, outCoords, gKeyboard->currentMask(TRUE));
+}
- if (true)
- {
- // Fullscreen support
- CFDictionaryRef refDisplayMode = 0;
- boolean_t exactMatch = false;
-
-#if CAPTURE_ALL_DISPLAYS
- // Capture all displays (may want to do this for final build)
- CGCaptureAllDisplays ();
-#else
- // Capture only the main display (useful for debugging)
- CGDisplayCapture (mDisplay);
-#endif
+void callResize(unsigned int width, unsigned int height)
+{
+ gWindowImplementation->getCallbacks()->handleResize(gWindowImplementation, width, height);
+}
- // Switch the display to the desired resolution and refresh
- refDisplayMode = CGDisplayBestModeForParametersAndRefreshRate(
- mDisplay,
- BITS_PER_PIXEL,
- width,
- height,
- refresh,
- &exactMatch);
+void callMouseMoved(float *pos, MASK mask)
+{
+ LLCoordGL outCoords;
+ outCoords.mX = llround(pos[0]);
+ outCoords.mY = llround(pos[1]);
+ float deltas[2];
+ gWindowImplementation->getMouseDeltas(deltas);
+ outCoords.mX += deltas[0];
+ outCoords.mY += deltas[1];
+ gWindowImplementation->getCallbacks()->handleMouseMove(gWindowImplementation, outCoords, gKeyboard->currentMask(TRUE));
+}
- if (refDisplayMode)
- {
- LL_DEBUGS("Window") << "createContext: switching display resolution" << LL_ENDL;
- mOldDisplayMode = CGDisplayCurrentMode (mDisplay);
- CGDisplaySwitchToMode (mDisplay, refDisplayMode);
- // CFRelease(refDisplayMode);
+void callScrollMoved(float delta)
+{
+ gWindowImplementation->getCallbacks()->handleScrollWheel(gWindowImplementation, delta);
+}
- AddEventTypesToHandler(mGlobalHandlerRef, GetEventTypeCount (GlobalHandlerEventList), GlobalHandlerEventList);
- }
+void callMouseExit()
+{
+ gWindowImplementation->getCallbacks()->handleMouseLeave(gWindowImplementation);
+}
+void callWindowFocus()
+{
+ gWindowImplementation->getCallbacks()->handleFocus(gWindowImplementation);
+}
- mFullscreen = TRUE;
- mFullscreenWidth = CGDisplayPixelsWide(mDisplay);
- mFullscreenHeight = CGDisplayPixelsHigh(mDisplay);
- mFullscreenBits = CGDisplayBitsPerPixel(mDisplay);
- mFullscreenRefresh = llround(getDictDouble (CGDisplayCurrentMode (mDisplay), kCGDisplayRefreshRate));
+void callWindowUnfocus()
+{
+ gWindowImplementation->getCallbacks()->handleFocusLost(gWindowImplementation);
+}
- LL_INFOS("Window") << "Running at " << mFullscreenWidth
- << "x" << mFullscreenHeight
- << "x" << mFullscreenBits
- << " @ " << mFullscreenRefresh
- << LL_ENDL;
- }
- else
- {
- // No fullscreen support
- mFullscreen = FALSE;
- mFullscreenWidth = -1;
- mFullscreenHeight = -1;
- mFullscreenBits = -1;
- mFullscreenRefresh = -1;
-
- std::string error= llformat("Unable to run fullscreen at %d x %d.\nRunning in window.", width, height);
- OSMessageBox(error, "Error", OSMB_OK);
- }
- }
+void callDeltaUpdate(float *delta, MASK mask)
+{
+ gWindowImplementation->updateMouseDeltas();
+}
- if(!mFullscreen && (mWindow == NULL))
+void LLWindowMacOSX::updateMouseDeltas()
+{
+ if (mCursorDecoupled)
{
- //int displayWidth = CGDisplayPixelsWide(mDisplay);
- //int displayHeight = CGDisplayPixelsHigh(mDisplay);
- //const int menuBarPlusTitleBar = 44; // Ugly magic number.
-
- LL_DEBUGS("Window") << "createContext: creating window" << LL_ENDL;
-
- mPreviousWindowRect.left = (long) x;
- mPreviousWindowRect.right = (long) x + width;
- mPreviousWindowRect.top = (long) y;
- mPreviousWindowRect.bottom = (long) y + height;
-
- //-----------------------------------------------------------------------
- // Create the window
- //-----------------------------------------------------------------------
- mWindow = NewCWindow(
- NULL,
- &mPreviousWindowRect,
- mWindowTitle,
- false, // Create the window invisible. Whoever calls createContext() should show it after any moving/resizing.
- // noGrowDocProc, // Window with no grow box and no zoom box
- zoomDocProc, // Window with a grow box and a zoom box
- // zoomNoGrow, // Window with a zoom box but no grow box
- kFirstWindowOfClass,
- true,
- (long)this);
-
- if (!mWindow)
+ CGMouseDelta x, y;
+ CGGetLastMouseDelta( &x, &y );
+ mCursorLastEventDeltaX = x;
+ mCursorLastEventDeltaY = y;
+
+ if (mCursorIgnoreNextDelta)
{
- setupFailure("Window creation error", "Error", OSMB_OK);
- return FALSE;
+ mCursorLastEventDeltaX = 0;
+ mCursorLastEventDeltaY = 0;
+ mCursorIgnoreNextDelta = FALSE;
}
+ } else {
+ mCursorLastEventDeltaX = 0;
+ mCursorLastEventDeltaY = 0;
+ }
+}
- // Turn on live resize.
- // For this to work correctly, we need to be able to call LLViewerWindow::draw from
- // the event handler for kEventWindowBoundsChanged. It's not clear that we have access from here.
- // err = ChangeWindowAttributes(mWindow, kWindowLiveResizeAttribute, 0);
+void LLWindowMacOSX::getMouseDeltas(float* delta)
+{
+ delta[0] = mCursorLastEventDeltaX;
+ delta[1] = mCursorLastEventDeltaY;
+}
- // Set up window event handlers (some window-related events ONLY go to window handlers.)
- InstallStandardEventHandler(GetWindowEventTarget(mWindow));
- InstallWindowEventHandler(mWindow, mEventHandlerUPP, GetEventTypeCount (WindowHandlerEventList), WindowHandlerEventList, (void*)this, &mWindowHandlerRef); // add event handler
-#if LL_OS_DRAGDROP_ENABLED
- InstallTrackingHandler( dragTrackingHandler, mWindow, (void*)this );
- InstallReceiveHandler( dragReceiveHandler, mWindow, (void*)this );
-#endif // LL_OS_DRAGDROP_ENABLED
- }
+BOOL LLWindowMacOSX::createContext(int x, int y, int width, int height, int bits, BOOL fullscreen, BOOL disable_vsync)
+{
+ BOOL glNeedsInit = FALSE;
- {
- // Create and initialize our TSM document for language text input.
- // If an error occured, we can do nothing better than simply ignore it.
- // mTSMDocument will be kept NULL in case.
- if (mTSMDocument)
- {
- DeactivateTSMDocument(mTSMDocument);
- DeleteTSMDocument(mTSMDocument);
- mTSMDocument = NULL;
- }
- static InterfaceTypeList types = { kUnicodeDocument };
- err = NewTSMDocument(1, types, &mTSMDocument, 0);
- if (err != noErr)
- {
- LL_WARNS("Window") << "createContext: couldn't create a TSMDocument (" << err << ")" << LL_ENDL;
- }
- if (mTSMDocument)
- {
- ActivateTSMDocument(mTSMDocument);
- allowLanguageTextInput(NULL, FALSE);
- }
+ mFullscreen = fullscreen;
+
+ if (mWindow == NULL)
+ {
+ LL_INFOS("Window") << "Creating window..." << LL_ENDL;
+ mWindow = createNSWindow(x, y, width, height);
+ LL_INFOS("Window") << "Registering key callbacks..." << LL_ENDL;
+ registerKeyDownCallback(mWindow, callKeyDown);
+ registerKeyUpCallback(mWindow, callKeyUp);
+ registerUnicodeCallback(mWindow, callUnicodeCallback);
+ registerMouseDownCallback(mWindow, callLeftMouseDown);
+ registerMouseUpCallback(mWindow, callLeftMouseUp);
+ registerRightMouseDownCallback(mWindow, callRightMouseDown);
+ registerRightMouseUpCallback(mWindow, callRightMouseUp);
+ registerDoubleClickCallback(mWindow, callDoubleClick);
+ registerMouseMovedCallback(mWindow, callMouseMoved);
+ registerScrollCallback(mWindow, callScrollMoved);
+ registerDeltaUpdateCallback(mWindow, callDeltaUpdate);
+ registerMouseExitCallback(mWindow, callMouseExit);
}
if(mContext == NULL)
{
- AGLRendererInfo rendererInfo = NULL;
-
- //-----------------------------------------------------------------------
- // Create GL drawing context
- //-----------------------------------------------------------------------
-
- if(mPixelFormat == NULL)
- {
- if(mFullscreen)
- {
- GLint fullscreenAttrib[] =
- {
- AGL_RGBA,
- AGL_FULLSCREEN,
- AGL_NO_RECOVERY,
- AGL_SAMPLE_BUFFERS_ARB, mFSAASamples > 0 ? 1 : 0,
- AGL_SAMPLES_ARB, mFSAASamples,
- AGL_DOUBLEBUFFER,
- AGL_CLOSEST_POLICY,
- AGL_ACCELERATED,
- AGL_RED_SIZE, 8,
- AGL_GREEN_SIZE, 8,
- AGL_BLUE_SIZE, 8,
- AGL_ALPHA_SIZE, 8,
- AGL_DEPTH_SIZE, 24,
- AGL_STENCIL_SIZE, 8,
- AGL_NONE
- };
-
- LL_DEBUGS("Window") << "createContext: creating fullscreen pixelformat" << LL_ENDL;
-
- GDHandle gdhDisplay = NULL;
- err = DMGetGDeviceByDisplayID ((DisplayIDType)mDisplay, &gdhDisplay, false);
-
- mPixelFormat = aglChoosePixelFormat(&gdhDisplay, 1, fullscreenAttrib);
- rendererInfo = aglQueryRendererInfo(&gdhDisplay, 1);
- }
- else
- {
- // NOTE from Leslie:
- //
- // AGL_NO_RECOVERY, when combined with AGL_ACCELERATED prevents software rendering
- // fallback which means we won't hvae shaders that compile and link but then don't
- // work. The drawback is that our shader compilation will be a bit more finicky though.
-
- GLint windowedAttrib[] =
- {
- AGL_RGBA,
- AGL_NO_RECOVERY,
- AGL_DOUBLEBUFFER,
- AGL_CLOSEST_POLICY,
- AGL_ACCELERATED,
- AGL_SAMPLE_BUFFERS_ARB, mFSAASamples > 0 ? 1 : 0,
- AGL_SAMPLES_ARB, mFSAASamples,
- AGL_RED_SIZE, 8,
- AGL_GREEN_SIZE, 8,
- AGL_BLUE_SIZE, 8,
- AGL_ALPHA_SIZE, 8,
- AGL_DEPTH_SIZE, 24,
- AGL_STENCIL_SIZE, 8,
- AGL_NONE
- };
-
- LL_DEBUGS("Window") << "createContext: creating windowed pixelformat" << LL_ENDL;
-
- mPixelFormat = aglChoosePixelFormat(NULL, 0, windowedAttrib);
-
- GDHandle gdhDisplay = GetMainDevice();
- rendererInfo = aglQueryRendererInfo(&gdhDisplay, 1);
- }
-
- // May want to get the real error text like this:
- // (char *) aglErrorString(aglGetError());
-
- if(aglGetError() != AGL_NO_ERROR)
- {
- setupFailure("Can't find suitable pixel format", "Error", OSMB_OK);
- return FALSE;
- }
- }
-
- if(mPixelFormat)
- {
- LL_DEBUGS("Window") << "createContext: creating GL context" << LL_ENDL;
- mContext = aglCreateContext(mPixelFormat, NULL);
- }
-
- if(mContext == NULL)
- {
- setupFailure("Can't make GL context", "Error", OSMB_OK);
- return FALSE;
- }
-
- gGLManager.mVRAM = 0;
-
- if(rendererInfo != NULL)
- {
- GLint result;
-
- if(aglDescribeRenderer(rendererInfo, AGL_VIDEO_MEMORY, &result))
- {
- // llinfos << "createContext: aglDescribeRenderer(AGL_VIDEO_MEMORY) returned " << result << llendl;
- gGLManager.mVRAM = result / (1024 * 1024);
- }
- else
- {
- // llinfos << "createContext: aglDescribeRenderer(AGL_VIDEO_MEMORY) failed." << llendl;
- }
-
- // This could be useful at some point, if it takes into account the memory already used by screen buffers, etc...
- if(aglDescribeRenderer(rendererInfo, AGL_TEXTURE_MEMORY, &result))
- {
- // llinfos << "createContext: aglDescribeRenderer(AGL_TEXTURE_MEMORY) returned " << result << llendl;
- }
- else
- {
- // llinfos << "createContext: aglDescribeRenderer(AGL_TEXTURE_MEMORY) failed." << llendl;
- }
-
- aglDestroyRendererInfo(rendererInfo);
- }
-
+ LL_INFOS("Window") << "Creating GL view..." << LL_ENDL;
+ mGLView = createOpenGLView(mWindow);
+ registerResizeEventCallback(mGLView, callResize);
+ mContext = getCGLContextObj(mWindow);
// Since we just created the context, it needs to be set up.
glNeedsInit = TRUE;
}
// Hook up the context to a drawable
- if (mFullscreen && (mOldDisplayMode != NULL))
- {
- // We successfully captured the display. Use a fullscreen drawable
-
- LL_DEBUGS("Window") << "createContext: attaching fullscreen drawable" << LL_ENDL;
-
-#if CAPTURE_ALL_DISPLAYS
- // Capture all displays (may want to do this for final build)
- aglDisable (mContext, AGL_FS_CAPTURE_SINGLE);
-#else
- // Capture only the main display (useful for debugging)
- aglEnable (mContext, AGL_FS_CAPTURE_SINGLE);
-#endif
-
- if (!aglSetFullScreen (mContext, 0, 0, 0, 0))
- {
- setupFailure("Can't set GL fullscreen", "Error", OSMB_OK);
- return FALSE;
- }
- }
- else if(!mFullscreen && (mWindow != NULL))
- {
- LL_DEBUGS("Window") << "createContext: attaching windowed drawable" << LL_ENDL;
-
- // We created a window. Use it as the drawable.
- if(!aglSetDrawable(mContext, GetWindowPort (mWindow)))
- {
- setupFailure("Can't set GL drawable", "Error", OSMB_OK);
- return FALSE;
- }
- }
- else
- {
- setupFailure("Can't get fullscreen or windowed drawable.", "Error", OSMB_OK);
- return FALSE;
- }
if(mContext != NULL)
{
+ LL_INFOS("Window") << "Setting CGL Context..." << LL_ENDL;
LL_DEBUGS("Window") << "createContext: setting current context" << LL_ENDL;
-
- if (!aglSetCurrentContext(mContext))
+ U32 err = CGLSetCurrentContext(mContext);
+ if (err != kCGLNoError)
{
setupFailure("Can't activate GL rendering context", "Error", OSMB_OK);
return FALSE;
}
}
- if(glNeedsInit)
- {
- // Check for some explicitly unsupported cards.
- const char* RENDERER = (const char*) glGetString(GL_RENDERER);
-
- const char* CARD_LIST[] =
- { "RAGE 128",
- "RIVA TNT2",
- "Intel 810",
- "3Dfx/Voodoo3",
- "Radeon 7000",
- "Radeon 7200",
- "Radeon 7500",
- "Radeon DDR",
- "Radeon VE",
- "GDI Generic" };
- const S32 CARD_COUNT = LL_ARRAY_SIZE(CARD_LIST);
-
- // Future candidates:
- // ProSavage/Twister
- // SuperSavage
-
- S32 i;
- for (i = 0; i < CARD_COUNT; i++)
- {
- if (check_for_card(RENDERER, CARD_LIST[i]))
- {
- close();
- return FALSE;
- }
- }
- }
-
- GLint colorBits, alphaBits, depthBits, stencilBits;
-
- if( !aglDescribePixelFormat(mPixelFormat, AGL_BUFFER_SIZE, &colorBits) ||
- !aglDescribePixelFormat(mPixelFormat, AGL_ALPHA_SIZE, &alphaBits) ||
- !aglDescribePixelFormat(mPixelFormat, AGL_DEPTH_SIZE, &depthBits) ||
- !aglDescribePixelFormat(mPixelFormat, AGL_STENCIL_SIZE, &stencilBits))
- {
- close();
- setupFailure("Can't get pixel format description", "Error", OSMB_OK);
- return FALSE;
- }
-
- LL_INFOS("GLInit") << "GL buffer: Color Bits " << S32(colorBits)
- << " Alpha Bits " << S32(alphaBits)
- << " Depth Bits " << S32(depthBits)
- << " Stencil Bits" << S32(stencilBits)
- << LL_ENDL;
-
- if (colorBits < 32)
- {
- close();
- setupFailure(
- "Second Life requires True Color (32-bit) to run in a window.\n"
- "Please go to Control Panels -> Display -> Settings and\n"
- "set the screen to 32-bit color.\n"
- "Alternately, if you choose to run fullscreen, Second Life\n"
- "will automatically adjust the screen each time it runs.",
- "Error",
- OSMB_OK);
- return FALSE;
- }
-
- if (alphaBits < 8)
- {
- close();
- setupFailure(
- "Second Life is unable to run because it can't get an 8 bit alpha\n"
- "channel. Usually this is due to video card driver issues.\n"
- "Please make sure you have the latest video card drivers installed.\n"
- "Also be sure your monitor is set to True Color (32-bit) in\n"
- "Control Panels -> Display -> Settings.\n"
- "If you continue to receive this message, contact customer service.",
- "Error",
- OSMB_OK);
- return FALSE;
- }
-
// Disable vertical sync for swap
GLint frames_per_swap = 0;
if (disable_vsync)
@@ -790,7 +394,8 @@ BOOL LLWindowMacOSX::createContext(int x, int y, int width, int height, int bits
LL_DEBUGS("GLinit") << "Keeping vertical sync" << LL_ENDL;
frames_per_swap = 1;
}
- aglSetInteger(mContext, AGL_SWAP_INTERVAL, &frames_per_swap);
+
+ CGLSetParameter(mContext, kCGLCPSwapInterval, &frames_per_swap);
//enable multi-threaded OpenGL
if (sUseMultGL)
@@ -809,109 +414,17 @@ BOOL LLWindowMacOSX::createContext(int x, int y, int width, int height, int bits
LL_DEBUGS("GLInit") << "Multi-threaded OpenGL enabled." << LL_ENDL;
}
}
-
+ LL_INFOS("Window") << "Completed context creation." << LL_ENDL;
// Don't need to get the current gamma, since there's a call that restores it to the system defaults.
return TRUE;
}
-// changing fullscreen resolution, or switching between windowed and fullscreen mode.
+// We only support OS X 10.7's fullscreen app mode which is literally a full screen window that fills a virtual desktop.
+// This makes this method obsolete.
BOOL LLWindowMacOSX::switchContext(BOOL fullscreen, const LLCoordScreen &size, BOOL disable_vsync, const LLCoordScreen * const posp)
{
- BOOL needsRebuild = FALSE;
- BOOL result = true;
-
- if(fullscreen)
- {
- if(mFullscreen)
- {
- // Switching resolutions in fullscreen mode. Don't need to rebuild for this.
- // Fullscreen support
- CFDictionaryRef refDisplayMode = 0;
- boolean_t exactMatch = false;
-
- // Switch the display to the desired resolution and refresh
- refDisplayMode = CGDisplayBestModeForParametersAndRefreshRate(
- mDisplay,
- BITS_PER_PIXEL,
- size.mX,
- size.mY,
- getDictDouble (CGDisplayCurrentMode (mDisplay), kCGDisplayRefreshRate),
- &exactMatch);
-
- if (refDisplayMode)
- {
- CGDisplaySwitchToMode (mDisplay, refDisplayMode);
- // CFRelease(refDisplayMode);
- }
-
- mFullscreenWidth = CGDisplayPixelsWide(mDisplay);
- mFullscreenHeight = CGDisplayPixelsHigh(mDisplay);
- mFullscreenBits = CGDisplayBitsPerPixel(mDisplay);
- mFullscreenRefresh = llround(getDictDouble (CGDisplayCurrentMode (mDisplay), kCGDisplayRefreshRate));
-
- LL_INFOS("Window") << "Switched resolution to " << mFullscreenWidth
- << "x" << mFullscreenHeight
- << "x" << mFullscreenBits
- << " @ " << mFullscreenRefresh
- << LL_ENDL;
-
- // Update the GL context to the new screen size
- if (!aglUpdateContext(mContext))
- {
- setupFailure("Can't set GL fullscreen", "Error", OSMB_OK);
- result = FALSE;
- }
- }
- else
- {
- // Switching from windowed to fullscreen
- needsRebuild = TRUE;
- }
- }
- else
- {
- if(mFullscreen)
- {
- // Switching from fullscreen to windowed
- needsRebuild = TRUE;
- }
- else
- {
- // Windowed to windowed -- not sure why we would be called like this. Just change the window size.
- // The bounds changed event handler will do the rest.
- if(mWindow != NULL)
- {
- ::SizeWindow(mWindow, size.mX, size.mY, true);
- }
- }
- }
-
- stop_glerror();
- if(needsRebuild || mForceRebuild)
- {
- mForceRebuild = FALSE;
- destroyContext();
- result = createContext(0, 0, size.mX, size.mY, 0, fullscreen, disable_vsync);
- if (result)
- {
- if(mWindow != NULL)
- {
- MacShowWindow(mWindow);
- BringToFront(mWindow);
- }
-
- llverify(gGLManager.initGL());
-
- //start with arrow cursor
- initCursors();
- setCursor( UI_CURSOR_ARROW );
- }
- }
-
- stop_glerror();
-
- return result;
+ return FALSE;
}
void LLWindowMacOSX::destroyContext()
@@ -926,31 +439,8 @@ void LLWindowMacOSX::destroyContext()
{
LL_DEBUGS("Window") << "destroyContext: unhooking drawable " << LL_ENDL;
- aglSetCurrentContext (NULL);
- aglSetDrawable(mContext, NULL);
- }
-
- // Make sure the display resolution gets restored
- if(mOldDisplayMode != NULL)
- {
- LL_DEBUGS("Window") << "destroyContext: restoring display resolution " << LL_ENDL;
-
- CGDisplaySwitchToMode (mDisplay, mOldDisplayMode);
-
-#if CAPTURE_ALL_DISPLAYS
- // Uncapture all displays (may want to do this for final build)
- CGReleaseAllDisplays ();
-#else
- // Uncapture only the main display (useful for debugging)
- CGDisplayRelease (mDisplay);
-#endif
-
- // CFRelease(mOldDisplayMode);
-
- mOldDisplayMode = NULL;
-
- // Remove the global event handlers the fullscreen case needed
- RemoveEventTypesFromHandler(mGlobalHandlerRef, GetEventTypeCount (GlobalHandlerEventList), GlobalHandlerEventList);
+ CGLSetCurrentContext(NULL);
+ mContext = NULL;
}
// Clean up remaining GL state before blowing away window
@@ -959,49 +449,19 @@ void LLWindowMacOSX::destroyContext()
// Clean up the pixel format
if(mPixelFormat != NULL)
{
- LL_DEBUGS("Window") << "destroyContext: destroying pixel format " << LL_ENDL;
- aglDestroyPixelFormat(mPixelFormat);
+ CGLDestroyPixelFormat(mPixelFormat);
mPixelFormat = NULL;
}
- // Remove any Carbon Event handlers we installed
- if(mGlobalHandlerRef != NULL)
- {
- LL_DEBUGS("Window") << "destroyContext: removing global event handler" << LL_ENDL;
- RemoveEventHandler(mGlobalHandlerRef);
- mGlobalHandlerRef = NULL;
- }
-
- if(mWindowHandlerRef != NULL)
- {
- LL_DEBUGS("Window") << "destroyContext: removing window event handler" << LL_ENDL;
- RemoveEventHandler(mWindowHandlerRef);
- mWindowHandlerRef = NULL;
- }
-
- // Cleanup any TSM document we created.
- if(mTSMDocument != NULL)
- {
- LL_DEBUGS("Window") << "destroyContext: deleting TSM document" << LL_ENDL;
- DeactivateTSMDocument(mTSMDocument);
- DeleteTSMDocument(mTSMDocument);
- mTSMDocument = NULL;
- }
-
// Close the window
if(mWindow != NULL)
{
- LL_DEBUGS("Window") << "destroyContext: disposing window" << LL_ENDL;
- DisposeWindow(mWindow);
- mWindow = NULL;
}
// Clean up the GL context
if(mContext != NULL)
{
- LL_DEBUGS("Window") << "destroyContext: destroying GL context" << LL_ENDL;
- aglDestroyContext(mContext);
- mContext = NULL;
+ CGLDestroyContext(mContext);
}
}
@@ -1022,17 +482,11 @@ LLWindowMacOSX::~LLWindowMacOSX()
void LLWindowMacOSX::show()
{
- if(IsWindowCollapsed(mWindow))
- CollapseWindow(mWindow, false);
-
- MacShowWindow(mWindow);
- BringToFront(mWindow);
}
void LLWindowMacOSX::hide()
{
setMouseClipping(FALSE);
- HideWindow(mWindow);
}
//virtual
@@ -1040,7 +494,6 @@ void LLWindowMacOSX::minimize()
{
setMouseClipping(FALSE);
showCursor();
- CollapseWindow(mWindow, true);
}
//virtual
@@ -1086,7 +539,6 @@ BOOL LLWindowMacOSX::getVisible()
result = TRUE;
}if (mWindow)
{
- if(MacIsWindowVisible(mWindow))
result = TRUE;
}
@@ -1107,7 +559,6 @@ BOOL LLWindowMacOSX::maximize()
{
if (mWindow && !mMaximized)
{
- ZoomWindow(mWindow, inContent, true);
}
return mMaximized;
@@ -1125,17 +576,14 @@ void LLWindowMacOSX::gatherInput()
{
stopDockTileBounce();
}
-
- // Use the old-school version so we get AppleEvent handler dispatch and menuselect handling.
- // Anything that has an event handler will get processed inside WaitNextEvent, so we only need to handle
- // the odd stuff here.
+
EventRecord evt;
while(WaitNextEvent(everyEvent, &evt, 0, NULL))
{
// printf("WaitNextEvent returned true, event is %d.\n", evt.what);
switch(evt.what)
{
- case mouseDown:
+ case mouseDown:
{
short part;
WindowRef window;
@@ -1143,35 +591,125 @@ void LLWindowMacOSX::gatherInput()
part = FindWindow(evt.where, &window);
switch ( part )
{
- case inMenuBar:
- selectResult = MenuSelect(evt.where);
-
- HiliteMenu(0);
- break;
+ case inMenuBar:
+ selectResult = MenuSelect(evt.where);
+
+ HiliteMenu(0);
+ break;
}
}
+ break;
+
+ case kHighLevelEvent:
+ AEProcessAppleEvent (&evt);
+ break;
+
+ case updateEvt:
+ // We shouldn't be getting these regularly (since our window will be buffered), but we need to handle them correctly...
+ BeginUpdate((WindowRef)evt.message);
+ EndUpdate((WindowRef)evt.message);
+ break;
+
+ }
+ }
+ /*
+ U32 event = getLatestEvent(mWindow);
+ switch (event) {
+ case 0:
+ // Nothing's happened since our last handled event.
break;
-
- case kHighLevelEvent:
- AEProcessAppleEvent (&evt);
+
+ case 1:
+ {
+ gKeyboard->handleKeyDown(getKeyDown(mWindow), getModifiers(mWindow));
+ mCallbacks->handleUnicodeChar(getLastCharacter(mWindow), gKeyboard->currentMask(FALSE)); // currentMask has the appropriately translated modifiers.
+ mLastModifiers = gKeyboard->currentMask(FALSE);
+ }
break;
-
- case updateEvt:
- // We shouldn't be getting these regularly (since our window will be buffered), but we need to handle them correctly...
- BeginUpdate((WindowRef)evt.message);
- EndUpdate((WindowRef)evt.message);
+
+ case 2:
+ gKeyboard->handleKeyUp(getKeyUp(mWindow), getModifiers(mWindow));
+ mLastModifiers = gKeyboard->currentMask(FALSE);
break;
-
+
+ case 3:
+ break;
+
+ case 4:
+ {
+ LLCoordScreen inCoords;
+ LLCoordGL outCoords;
+ float* mouseCoords = getMouseDown(mWindow);
+ inCoords.mX = llround(mouseCoords[0]);
+ inCoords.mY = llround(mouseCoords[1]);
+ convertCoords(inCoords, &outCoords);
+ mCallbacks->handleMouseDown(this, outCoords, getModifiers(mWindow));
+ mLastModifiers = gKeyboard->currentMask(FALSE);
}
- }
+ break;
+ case 5:
+ {
+ LLCoordScreen inCoords;
+ LLCoordGL outCoords;
+ float* mouseCoords = getMouseUp(mWindow);
+ inCoords.mX = llround(mouseCoords[0]);
+ inCoords.mY = llround(mouseCoords[1]);
+ convertCoords(inCoords, &outCoords);
+ mCallbacks->handleMouseUp(this, outCoords, getModifiers(mWindow));
+ mLastModifiers = gKeyboard->currentMask(FALSE);
+ }
+ break;
+ case 6:
+ {
+ LLCoordScreen inCoords;
+ LLCoordGL outCoords;
+ float* mouseCoords = getRightMouseDown(mWindow);
+ inCoords.mX = llround(mouseCoords[0]);
+ inCoords.mY = llround(mouseCoords[1]);
+ convertCoords(inCoords, &outCoords);
+ mCallbacks->handleRightMouseDown(this, outCoords, getModifiers(mWindow));
+ mLastModifiers = gKeyboard->currentMask(FALSE);
+ }
+ break;
+ case 7:
+ {
+ LLCoordScreen inCoords;
+ LLCoordGL outCoords;
+ float* mouseCoords = getRightMouseDown(mWindow);
+ inCoords.mX = llround(mouseCoords[0]);
+ inCoords.mY = llround(mouseCoords[1]);
+ convertCoords(inCoords, &outCoords);
+ mCallbacks->handleRightMouseDown(this, outCoords, getModifiers(mWindow));
+ mLastModifiers = gKeyboard->currentMask(FALSE);
+ }
+ break;
+ case 8: // Double click
+ {
+ LLCoordScreen inCoords;
+ LLCoordGL outCoords;
+ float* mouseCoords = getRightMouseDown(mWindow);
+ inCoords.mX = llround(mouseCoords[0]);
+ inCoords.mY = llround(mouseCoords[1]);
+ convertCoords(inCoords, &outCoords);
+ mCallbacks->handleDoubleClick(this, outCoords, getModifiers(mWindow));
+ mLastModifiers = gKeyboard->currentMask(FALSE);
+ }
+ break;
+ case 10: // Text input (for IMEs)
+
+ break;
+ default:
+ break;
+
+ }*/
updateCursor();
}
BOOL LLWindowMacOSX::getPosition(LLCoordScreen *position)
{
- Rect window_rect;
- OSStatus err = -1;
+ float rect[4];
+ S32 err = -1;
if(mFullscreen)
{
@@ -1181,10 +719,10 @@ BOOL LLWindowMacOSX::getPosition(LLCoordScreen *position)
}
else if(mWindow)
{
- err = GetWindowBounds(mWindow, kWindowContentRgn, &window_rect);
+ getContentViewBounds(mWindow, rect);
- position->mX = window_rect.left;
- position->mY = window_rect.top;
+ position->mX = rect[0];
+ position->mY = rect[1];
}
else
{
@@ -1196,8 +734,8 @@ BOOL LLWindowMacOSX::getPosition(LLCoordScreen *position)
BOOL LLWindowMacOSX::getSize(LLCoordScreen *size)
{
- Rect window_rect;
- OSStatus err = -1;
+ float rect[4];
+ S32 err = -1;
if(mFullscreen)
{
@@ -1207,10 +745,10 @@ BOOL LLWindowMacOSX::getSize(LLCoordScreen *size)
}
else if(mWindow)
{
- err = GetWindowBounds(mWindow, kWindowContentRgn, &window_rect);
+ getContentViewBounds(mWindow, rect);
- size->mX = window_rect.right - window_rect.left;
- size->mY = window_rect.bottom - window_rect.top;
+ size->mX = rect[2];
+ size->mY = rect[3];
}
else
{
@@ -1222,9 +760,9 @@ BOOL LLWindowMacOSX::getSize(LLCoordScreen *size)
BOOL LLWindowMacOSX::getSize(LLCoordWindow *size)
{
- Rect window_rect;
- OSStatus err = -1;
-
+ float rect[4];
+ S32 err = -1;
+
if(mFullscreen)
{
size->mX = mFullscreenWidth;
@@ -1233,16 +771,16 @@ BOOL LLWindowMacOSX::getSize(LLCoordWindow *size)
}
else if(mWindow)
{
- err = GetWindowBounds(mWindow, kWindowContentRgn, &window_rect);
-
- size->mX = window_rect.right - window_rect.left;
- size->mY = window_rect.bottom - window_rect.top;
+ getContentViewBounds(mWindow, rect);
+
+ size->mX = rect[2];
+ size->mY = rect[3];
}
else
{
llerrs << "LLWindowMacOSX::getPosition(): no window and not fullscreen!" << llendl;
}
-
+
return (err == noErr);
}
@@ -1250,7 +788,8 @@ BOOL LLWindowMacOSX::setPosition(const LLCoordScreen position)
{
if(mWindow)
{
- MacMoveWindow(mWindow, position.mX, position.mY, false);
+ float pos[2] = {position.mX, position.mY};
+ setWindowPos(mWindow, pos);
}
return TRUE;
@@ -1260,7 +799,7 @@ BOOL LLWindowMacOSX::setSizeImpl(const LLCoordScreen size)
{
if(mWindow)
{
- SizeWindow(mWindow, size.mX, size.mY, true);
+ setWindowSize(mWindow, size.mX, size.mY);
}
return TRUE;
@@ -1268,15 +807,16 @@ BOOL LLWindowMacOSX::setSizeImpl(const LLCoordScreen size)
BOOL LLWindowMacOSX::setSizeImpl(const LLCoordWindow size)
{
- Rect client_rect;
+ float client_rect[4];
if (mWindow)
{
- OSStatus err = GetWindowBounds(mWindow, kWindowContentRgn, &client_rect);
+ S32 err = noErr;
+ getContentViewBounds(mWindow, client_rect);
if (err == noErr)
{
- client_rect.right = client_rect.left + size.mX;
- client_rect.bottom = client_rect.top + size.mY;
- err = SetWindowBounds(mWindow, kWindowContentRgn, &client_rect);
+ client_rect[2] += size.mX;
+ client_rect[3] += size.mY;
+ setWindowSize(mWindow, client_rect[2], client_rect[3]);
}
if (err == noErr)
{
@@ -1293,7 +833,7 @@ BOOL LLWindowMacOSX::setSizeImpl(const LLCoordWindow size)
void LLWindowMacOSX::swapBuffers()
{
- aglSwapBuffers(mContext);
+ CGLFlushDrawable(mContext);
}
F32 LLWindowMacOSX::getGamma()
@@ -1453,7 +993,7 @@ BOOL LLWindowMacOSX::setCursorPosition(const LLCoordWindow position)
return result;
}
-
+/*
static void fixOrigin(void)
{
GrafPtr port;
@@ -1467,26 +1007,16 @@ static void fixOrigin(void)
::SetOrigin(0,0);
}
}
-
+*/
BOOL LLWindowMacOSX::getCursorPosition(LLCoordWindow *position)
{
- Point cursor_point;
+ float cursor_point[2];
LLCoordScreen screen_pos;
- GrafPtr save;
if(mWindow == NULL)
return FALSE;
-
- ::GetPort(&save);
- ::SetPort(GetWindowPort(mWindow));
- fixOrigin();
-
- // gets the mouse location in local coordinates
- ::GetMouse(&cursor_point);
-
-// lldebugs << "getCursorPosition(): cursor is at " << cursor_point.h << ", " << cursor_point.v << " port origin: " << portrect.left << ", " << portrect.top << llendl;
-
- ::SetPort(save);
+
+ getCursorPos(mWindow, cursor_point);
if(mCursorDecoupled)
{
@@ -1499,12 +1029,12 @@ BOOL LLWindowMacOSX::getCursorPosition(LLCoordWindow *position)
// CGGetLastMouseDelta may behave strangely when the cursor's first captured.
// Stash in the event handler instead.
- cursor_point.h += mCursorLastEventDeltaX;
- cursor_point.v += mCursorLastEventDeltaY;
+ cursor_point[0] += mCursorLastEventDeltaX;
+ cursor_point[1] += mCursorLastEventDeltaY;
}
- position->mX = cursor_point.h;
- position->mY = cursor_point.v;
+ position->mX = cursor_point[0];
+ position->mY = cursor_point[1];
return TRUE;
}
@@ -1521,7 +1051,6 @@ void LLWindowMacOSX::adjustCursorDecouple(bool warpingMouse)
// llinfos << "adjustCursorDecouple: decoupling cursor" << llendl;
CGAssociateMouseAndMouseCursorPosition(false);
mCursorDecoupled = true;
- FlushSpecificEventsFromQueue(GetCurrentEventQueue(), mMoveEventCampartorUPP, NULL);
mCursorIgnoreNextDelta = TRUE;
}
}
@@ -1568,52 +1097,13 @@ F32 LLWindowMacOSX::getPixelAspectRatio()
// MBW -- XXX -- There's got to be a better way than this. Find it, please...
+// Since we're no longer supporting the "typical" fullscreen mode with CGL or NSOpenGL anymore, these are unnecessary. -Geenz
void LLWindowMacOSX::beforeDialog()
{
- if(mFullscreen)
- {
-
-#if CAPTURE_ALL_DISPLAYS
- // Uncapture all displays (may want to do this for final build)
- CGReleaseAllDisplays ();
-#else
- // Uncapture only the main display (useful for debugging)
- CGDisplayRelease (mDisplay);
-#endif
- // kDocumentWindowClass
- // kMovableModalWindowClass
- // kAllWindowClasses
-
- // GLint order = 0;
- // aglSetInteger(mContext, AGL_ORDER_CONTEXT_TO_FRONT, &order);
- aglSetDrawable(mContext, NULL);
- // GetWindowGroupLevel(GetWindowGroupOfClass(kAllWindowClasses), &oldWindowLevel);
- // SetWindowGroupLevel(GetWindowGroupOfClass(kAllWindowClasses), CGShieldingWindowLevel());
-
- mHandsOffEvents = TRUE;
-
- }
}
void LLWindowMacOSX::afterDialog()
{
- if(mFullscreen)
- {
- mHandsOffEvents = FALSE;
-
- // SetWindowGroupLevel(GetWindowGroupOfClass(kAllWindowClasses), oldWindowLevel);
- aglSetFullScreen(mContext, 0, 0, 0, 0);
- // GLint order = 1;
- // aglSetInteger(mContext, AGL_ORDER_CONTEXT_TO_FRONT, &order);
-
-#if CAPTURE_ALL_DISPLAYS
- // Capture all displays (may want to do this for final build)
- CGCaptureAllDisplays ();
-#else
- // Capture only the main display (useful for debugging)
- CGDisplayCapture (mDisplay);
-#endif
- }
}
@@ -1622,14 +1112,10 @@ void LLWindowMacOSX::flashIcon(F32 seconds)
// Don't do this if we're already started, since this would try to install the NMRec twice.
if(!mBounceTimer.getStarted())
{
- OSErr err;
-
+ S32 err = 0;
+ // TODO: Implement icon bouncing
mBounceTime = seconds;
- memset(&mBounceRec, 0, sizeof(mBounceRec));
- mBounceRec.qType = nmType;
- mBounceRec.nmMark = 1;
- err = NMInstall(&mBounceRec);
- if(err == noErr)
+ if(err == 0)
{
mBounceTimer.start();
}
@@ -1643,104 +1129,25 @@ void LLWindowMacOSX::flashIcon(F32 seconds)
BOOL LLWindowMacOSX::isClipboardTextAvailable()
{
- OSStatus err;
- ScrapRef scrap;
- ScrapFlavorFlags flags;
BOOL result = false;
-
- err = GetCurrentScrap(&scrap);
-
- if(err == noErr)
- {
- err = GetScrapFlavorFlags(scrap, kScrapFlavorTypeUnicode, &flags);
- }
-
- if(err == noErr)
- result = true;
-
+ // TODO: Clipboard support.
return result;
}
BOOL LLWindowMacOSX::pasteTextFromClipboard(LLWString &dst)
{
- OSStatus err;
- ScrapRef scrap;
- Size len;
BOOL result = false;
-
- err = GetCurrentScrap(&scrap);
-
- if(err == noErr)
- {
- err = GetScrapFlavorSize(scrap, kScrapFlavorTypeUnicode, &len);
- }
-
- if((err == noErr) && (len > 0))
- {
- int u16len = len / sizeof(U16);
- U16 *temp = new U16[u16len + 1];
- if (temp)
- {
- memset(temp, 0, (u16len + 1) * sizeof(temp[0]));
- err = GetScrapFlavorData(scrap, kScrapFlavorTypeUnicode, &len, temp);
- if (err == noErr)
- {
- // convert \r\n to \n and \r to \n in the incoming text.
- U16 *s, *d;
- for(s = d = temp; s[0] != '\0'; s++, d++)
- {
- if(s[0] == '\r')
- {
- if(s[1] == '\n')
- {
- // CRLF, a.k.a. DOS newline. Collapse to a single '\n'.
- s++;
- }
-
- d[0] = '\n';
- }
- else
- {
- d[0] = s[0];
- }
- }
-
- d[0] = '\0';
-
- dst = utf16str_to_wstring(temp);
-
- result = true;
- }
- delete[] temp;
- }
- }
+
+ // TODO: Clipboard support.
return result;
}
BOOL LLWindowMacOSX::copyTextToClipboard(const LLWString &s)
{
- OSStatus err;
- ScrapRef scrap;
- //Size len;
- //char *temp;
BOOL result = false;
-
- if (!s.empty())
- {
- err = GetCurrentScrap(&scrap);
- if (err == noErr)
- err = ClearScrap(&scrap);
-
- if (err == noErr)
- {
- llutf16string utf16str = wstring_to_utf16str(s);
- size_t u16len = utf16str.length() * sizeof(U16);
- err = PutScrapFlavor(scrap, kScrapFlavorTypeUnicode, kScrapFlavorMaskNone, u16len, utf16str.data());
- if (err == noErr)
- result = true;
- }
- }
+
+ // TODO: Clipboard support.
return result;
}
@@ -1807,26 +1214,17 @@ LLWindow::LLWindowResolution* LLWindowMacOSX::getSupportedResolutions(S32 &num_r
BOOL LLWindowMacOSX::convertCoords(LLCoordGL from, LLCoordWindow *to)
{
S32 client_height;
- Rect client_rect;
-
- if(mFullscreen)
- {
- // In the fullscreen case, the "window" is the entire screen.
- client_rect.left = 0;
- client_rect.top = 0;
- client_rect.right = mFullscreenWidth;
- client_rect.bottom = mFullscreenHeight;
- }
- else if (!mWindow ||
- (GetWindowBounds(mWindow, kWindowContentRgn, &client_rect) != noErr) ||
+ float client_rect[4];
+ getContentViewBounds(mWindow, client_rect);
+ if (!mWindow ||
NULL == to)
{
return FALSE;
}
to->mX = from.mX;
- client_height = client_rect.bottom - client_rect.top;
- to->mY = client_height - from.mY - 1;
+ client_height = client_rect[3];
+ to->mY = from.mY - 1;
return TRUE;
}
@@ -1834,26 +1232,19 @@ BOOL LLWindowMacOSX::convertCoords(LLCoordGL from, LLCoordWindow *to)
BOOL LLWindowMacOSX::convertCoords(LLCoordWindow from, LLCoordGL* to)
{
S32 client_height;
- Rect client_rect;
-
- if(mFullscreen)
- {
- // In the fullscreen case, the "window" is the entire screen.
- client_rect.left = 0;
- client_rect.top = 0;
- client_rect.right = mFullscreenWidth;
- client_rect.bottom = mFullscreenHeight;
- }
- else if (!mWindow ||
- (GetWindowBounds(mWindow, kWindowContentRgn, &client_rect) != noErr) ||
+ float client_rect[4];
+
+ getContentViewBounds(mWindow, client_rect);
+
+ if (!mWindow ||
NULL == to)
{
return FALSE;
}
to->mX = from.mX;
- client_height = client_rect.bottom - client_rect.top;
- to->mY = client_height - from.mY - 1;
+ client_height = client_rect[3];
+ to->mY = from.mY - 1;
return TRUE;
}
@@ -1869,22 +1260,15 @@ BOOL LLWindowMacOSX::convertCoords(LLCoordScreen from, LLCoordWindow* to)
}
else if(mWindow)
{
- GrafPtr save;
- Point mouse_point;
-
- mouse_point.h = from.mX;
- mouse_point.v = from.mY;
-
- ::GetPort(&save);
- ::SetPort(GetWindowPort(mWindow));
- fixOrigin();
+ float mouse_point[2];
- ::GlobalToLocal(&mouse_point);
-
- to->mX = mouse_point.h;
- to->mY = mouse_point.v;
+ mouse_point[0] = from.mX;
+ mouse_point[1] = from.mY;
+
+ convertScreenToWindow(mWindow, mouse_point);
- ::SetPort(save);
+ to->mX = mouse_point[0];
+ to->mY = mouse_point[1];
return TRUE;
}
@@ -1903,21 +1287,14 @@ BOOL LLWindowMacOSX::convertCoords(LLCoordWindow from, LLCoordScreen *to)
}
else if(mWindow)
{
- GrafPtr save;
- Point mouse_point;
-
- mouse_point.h = from.mX;
- mouse_point.v = from.mY;
- ::GetPort(&save);
- ::SetPort(GetWindowPort(mWindow));
- fixOrigin();
+ float mouse_point[2];
- LocalToGlobal(&mouse_point);
+ mouse_point[0] = from.mX;
+ mouse_point[1] = from.mY;
+ convertWindowToScreen(mWindow, mouse_point);
- to->mX = mouse_point.h;
- to->mY = mouse_point.v;
-
- ::SetPort(save);
+ to->mX = mouse_point[0];
+ to->mY = mouse_point[1];
return TRUE;
}
@@ -1949,862 +1326,6 @@ void LLWindowMacOSX::setupFailure(const std::string& text, const std::string& ca
OSMessageBox(text, caption, type);
}
-pascal Boolean LLWindowMacOSX::staticMoveEventComparator( EventRef event, void* data)
-{
- UInt32 evtClass = GetEventClass (event);
- UInt32 evtKind = GetEventKind (event);
-
- if ((evtClass == kEventClassMouse) && ((evtKind == kEventMouseDragged) || (evtKind == kEventMouseMoved)))
- {
- return true;
- }
-
- else
- {
- return false;
- }
-}
-
-
-pascal OSStatus LLWindowMacOSX::staticEventHandler(EventHandlerCallRef myHandler, EventRef event, void* userData)
-{
- LLWindowMacOSX *self = (LLWindowMacOSX*)userData;
-
- return(self->eventHandler(myHandler, event));
-}
-
-OSStatus LLWindowMacOSX::eventHandler (EventHandlerCallRef myHandler, EventRef event)
-{
- OSStatus result = eventNotHandledErr;
- UInt32 evtClass = GetEventClass (event);
- UInt32 evtKind = GetEventKind (event);
-
- // Always handle command events, even in hands-off mode.
- if((evtClass == kEventClassCommand) && (evtKind == kEventCommandProcess))
- {
- HICommand command;
- GetEventParameter (event, kEventParamDirectObject, typeHICommand, NULL, sizeof(command), NULL, &command);
-
- switch(command.commandID)
- {
- case kHICommandQuit:
- if(mCallbacks->handleCloseRequest(this))
- {
- // Get the app to initiate cleanup.
- mCallbacks->handleQuit(this);
- // The app is responsible for calling destroyWindow when done with GL
- }
- result = noErr;
- break;
-
- default:
- // MBW -- XXX -- Should we handle other events here?
- break;
- }
- }
-
- if(mHandsOffEvents)
- {
- return(result);
- }
-
- switch (evtClass)
- {
- case kEventClassTextInput:
- {
- switch (evtKind)
- {
- case kEventTextInputUpdateActiveInputArea:
- {
- EventParamType param_type;
-
- long fix_len;
- UInt32 text_len;
- if (mPreeditor
- && (result = GetEventParameter(event, kEventParamTextInputSendFixLen,
- typeLongInteger, &param_type, sizeof(fix_len), NULL, &fix_len)) == noErr
- && typeLongInteger == param_type
- && (result = GetEventParameter(event, kEventParamTextInputSendText,
- typeUnicodeText, &param_type, 0, &text_len, NULL)) == noErr
- && typeUnicodeText == param_type)
- {
- // Handle an optional (but essential to facilitate TSMDA) ReplaceRange param.
- CFRange range;
- if (GetEventParameter(event, kEventParamTextInputSendReplaceRange,
- typeCFRange, &param_type, sizeof(range), NULL, &range) == noErr
- && typeCFRange == param_type)
- {
- // Although the spec. is unclear, replace range should
- // not present when there is an active preedit. We just
- // ignore the case. markAsPreedit will detect the case and warn it.
- const LLWString & text = mPreeditor->getPreeditString();
- const S32 location = wstring_wstring_length_from_utf16_length(text, 0, range.location);
- const S32 length = wstring_wstring_length_from_utf16_length(text, location, range.length);
- mPreeditor->markAsPreedit(location, length);
- }
- mPreeditor->resetPreedit();
-
- // Receive the text from input method.
- U16 *const text = new U16[text_len / sizeof(U16)];
- GetEventParameter(event, kEventParamTextInputSendText, typeUnicodeText, NULL, text_len, NULL, text);
- if (fix_len < 0)
- {
- // Do we still need this? Seems obsolete...
- fix_len = text_len;
- }
- const LLWString fix_string
- = utf16str_to_wstring(llutf16string(text, fix_len / sizeof(U16)));
- const LLWString preedit_string
- = utf16str_to_wstring(llutf16string(text + fix_len / sizeof(U16), (text_len - fix_len) / sizeof(U16)));
- delete[] text;
-
- // Handle fixed (comitted) string.
- if (fix_string.length() > 0)
- {
- for (LLWString::const_iterator i = fix_string.begin(); i != fix_string.end(); i++)
- {
- mPreeditor->handleUnicodeCharHere(*i);
- }
- }
-
- // Receive the segment info and caret position.
- LLPreeditor::segment_lengths_t preedit_segment_lengths;
- LLPreeditor::standouts_t preedit_standouts;
- S32 caret_position = preedit_string.length();
- UInt32 text_range_array_size;
- if (GetEventParameter(event, kEventParamTextInputSendHiliteRng, typeTextRangeArray,
- &param_type, 0, &text_range_array_size, NULL) == noErr
- && typeTextRangeArray == param_type
- && text_range_array_size > sizeof(TextRangeArray))
- {
- // TextRangeArray is a variable-length struct.
- TextRangeArray * const text_range_array = (TextRangeArray *) new char[text_range_array_size];
- GetEventParameter(event, kEventParamTextInputSendHiliteRng, typeTextRangeArray,
- NULL, text_range_array_size, NULL, text_range_array);
-
- // WARNING: We assume ranges are in ascending order,
- // although the condition is undocumented. It seems
- // OK to assume this. I also assumed
- // the ranges are contiguous in previous versions, but I
- // have heard a rumore that older versions os ATOK may
- // return ranges with some _gap_. I don't know whether
- // it is true, but I'm preparing my code for the case.
-
- const S32 ranges = text_range_array->fNumOfRanges;
- preedit_segment_lengths.reserve(ranges);
- preedit_standouts.reserve(ranges);
-
- S32 last_bytes = 0;
- S32 last_utf32 = 0;
- for (S32 i = 0; i < ranges; i++)
- {
- const TextRange &range = text_range_array->fRange[i];
- if (range.fStart > last_bytes)
- {
- const S32 length_utf16 = (range.fStart - last_bytes) / sizeof(U16);
- const S32 length_utf32 = wstring_wstring_length_from_utf16_length(preedit_string, last_utf32, length_utf16);
- preedit_segment_lengths.push_back(length_utf32);
- preedit_standouts.push_back(FALSE);
- last_utf32 += length_utf32;
- }
- if (range.fEnd > range.fStart)
- {
- const S32 length_utf16 = (range.fEnd - range.fStart) / sizeof(U16);
- const S32 length_utf32 = wstring_wstring_length_from_utf16_length(preedit_string, last_utf32, length_utf16);
- preedit_segment_lengths.push_back(length_utf32);
- preedit_standouts.push_back(
- kTSMHiliteSelectedRawText == range.fHiliteStyle
- || kTSMHiliteSelectedConvertedText == range.fHiliteStyle
- || kTSMHiliteSelectedText == range.fHiliteStyle);
- last_utf32 += length_utf32;
- }
- if (kTSMHiliteCaretPosition == range.fHiliteStyle)
- {
- caret_position = last_utf32;
- }
- last_bytes = range.fEnd;
- }
- if (preedit_string.length() > last_utf32)
- {
- preedit_segment_lengths.push_back(preedit_string.length() - last_utf32);
- preedit_standouts.push_back(FALSE);
- }
-
- delete[] (char *) text_range_array;
- }
-
- // Handle preedit string.
- if (preedit_string.length() == 0)
- {
- preedit_segment_lengths.clear();
- preedit_standouts.clear();
- }
- else if (preedit_segment_lengths.size() == 0)
- {
- preedit_segment_lengths.push_back(preedit_string.length());
- preedit_standouts.push_back(FALSE);
- }
- mPreeditor->updatePreedit(preedit_string, preedit_segment_lengths, preedit_standouts, caret_position);
-
- result = noErr;
- }
- }
- break;
-
- case kEventTextInputUnicodeForKeyEvent:
- {
- UInt32 modifiers = 0;
-
-
- // First, process the raw event.
- {
- EventRef rawEvent = NULL;
-
- // Get the original event and extract the modifier keys, so we can ignore command-key events.
- if (GetEventParameter(event, kEventParamTextInputSendKeyboardEvent, typeEventRef, NULL, sizeof(rawEvent), NULL, &rawEvent) == noErr)
- {
- // Grab the modifiers for later use in this function...
- GetEventParameter (rawEvent, kEventParamKeyModifiers, typeUInt32, NULL, sizeof(UInt32), NULL, &modifiers);
-
- // and call this function recursively to handle the raw key event.
- eventHandler (myHandler, rawEvent);
-
- // save the raw event until we're done processing the unicode input as well.
- mRawKeyEvent = rawEvent;
- }
- }
-
- OSStatus err = noErr;
- EventParamType actualType = typeUnicodeText;
- UInt32 actualSize = 0;
- size_t actualCount = 0;
- U16 *buffer = NULL;
-
- // Get the size of the unicode data
- err = GetEventParameter (event, kEventParamTextInputSendText, typeUnicodeText, &actualType, 0, &actualSize, NULL);
- if(err == noErr)
- {
- // allocate a buffer and get the actual data.
- actualCount = actualSize / sizeof(U16);
- buffer = new U16[actualCount];
- err = GetEventParameter (event, kEventParamTextInputSendText, typeUnicodeText, &actualType, actualSize, &actualSize, buffer);
- }
-
- if(err == noErr)
- {
- if(modifiers & (cmdKey | controlKey))
- {
- // This was a menu key equivalent. Ignore it.
- }
- else
- {
- MASK mask = LLWindowMacOSX::modifiersToMask(modifiers);
-
- llassert( actualType == typeUnicodeText );
-
- // The result is a UTF16 buffer. Pass the characters in turn to handleUnicodeChar.
-
- // Convert to UTF32 and go character-by-character.
- llutf16string utf16(buffer, actualCount);
- LLWString utf32 = utf16str_to_wstring(utf16);
- LLWString::iterator iter;
-
- for(iter = utf32.begin(); iter != utf32.end(); iter++)
- {
- mCallbacks->handleUnicodeChar(*iter, mask);
- }
- }
- }
-
- if(buffer != NULL)
- {
- delete[] buffer;
- }
-
- mRawKeyEvent = NULL;
- result = err;
- }
- break;
-
- case kEventTextInputOffsetToPos:
- {
- EventParamType param_type;
- long offset;
- if (mPreeditor
- && GetEventParameter(event, kEventParamTextInputSendTextOffset, typeLongInteger,
- &param_type, sizeof(offset), NULL, &offset) == noErr
- && typeLongInteger == param_type)
- {
- S32 preedit, preedit_length;
- mPreeditor->getPreeditRange(&preedit, &preedit_length);
- const LLWString & text = mPreeditor->getPreeditString();
-
- LLCoordGL caret_coord;
- LLRect preedit_bounds;
- if (0 <= offset
- && mPreeditor->getPreeditLocation(wstring_wstring_length_from_utf16_length(text, preedit, offset / sizeof(U16)),
- &caret_coord, &preedit_bounds, NULL))
- {
- LLCoordGL caret_base_coord(caret_coord.mX, preedit_bounds.mBottom);
- LLCoordScreen caret_base_coord_screen;
- convertCoords(caret_base_coord, &caret_base_coord_screen);
- Point qd_point;
- qd_point.h = caret_base_coord_screen.mX;
- qd_point.v = caret_base_coord_screen.mY;
- SetEventParameter(event, kEventParamTextInputReplyPoint, typeQDPoint, sizeof(qd_point), &qd_point);
-
- short line_height = (short) preedit_bounds.getHeight();
- SetEventParameter(event, kEventParamTextInputReplyLineHeight, typeShortInteger, sizeof(line_height), &line_height);
-
- result = noErr;
- }
- else
- {
- result = errOffsetInvalid;
- }
- }
- }
- break;
-
- case kEventTextInputGetSelectedText:
- {
- if (mPreeditor)
- {
- S32 selection, selection_length;
- mPreeditor->getSelectionRange(&selection, &selection_length);
- if (selection_length)
- {
- const LLWString text = mPreeditor->getPreeditString().substr(selection, selection_length);
- const llutf16string text_utf16 = wstring_to_utf16str(text);
- result = SetEventParameter(event, kEventParamTextInputReplyText, typeUnicodeText,
- text_utf16.length() * sizeof(U16), text_utf16.c_str());
- }
- }
- }
- break;
- }
- }
- break;
-
- case kEventClassKeyboard:
- {
- UInt32 keyCode = 0;
- char charCode = 0;
- UInt32 modifiers = 0;
-
- // Some of these may fail for some event types. That's fine.
- GetEventParameter (event, kEventParamKeyCode, typeUInt32, NULL, sizeof(UInt32), NULL, &keyCode);
- GetEventParameter (event, kEventParamKeyModifiers, typeUInt32, NULL, sizeof(UInt32), NULL, &modifiers);
-
- // save the raw event so getNativeKeyData can use it.
- mRawKeyEvent = event;
-
- // printf("key event, key code = 0x%08x, char code = 0x%02x (%c), modifiers = 0x%08x\n", keyCode, charCode, (char)charCode, modifiers);
- // fflush(stdout);
-
- switch (evtKind)
- {
- case kEventRawKeyDown:
- case kEventRawKeyRepeat:
- if (gDebugWindowProc)
- {
- printf("key down, key code = 0x%08x, char code = 0x%02x (%c), modifiers = 0x%08x\n",
- (unsigned int)keyCode, charCode, (char)charCode, (unsigned int)modifiers);
- fflush(stdout);
- }
- gKeyboard->handleKeyDown(keyCode, modifiers);
- result = eventNotHandledErr;
- break;
-
- case kEventRawKeyUp:
- if (gDebugWindowProc)
- {
- printf("key up, key code = 0x%08x, char code = 0x%02x (%c), modifiers = 0x%08x\n",
- (unsigned int)keyCode, charCode, (char)charCode, (unsigned int)modifiers);
- fflush(stdout);
- }
- gKeyboard->handleKeyUp(keyCode, modifiers);
- result = eventNotHandledErr;
- break;
-
- case kEventRawKeyModifiersChanged:
- // The keyboard input system wants key up/down events for modifier keys.
- // Mac OS doesn't supply these directly, but can supply events when the collective modifier state changes.
- // Use these events to generate up/down events for the modifiers.
-
- if((modifiers & shiftKey) && !(mLastModifiers & shiftKey))
- {
- if (gDebugWindowProc) printf("Shift key down event\n");
- gKeyboard->handleKeyDown(0x38, (modifiers & 0x00FFFFFF) | ((0x38 << 24) & 0xFF000000));
- }
- else if(!(modifiers & shiftKey) && (mLastModifiers & shiftKey))
- {
- if (gDebugWindowProc) printf("Shift key up event\n");
- gKeyboard->handleKeyUp(0x38, (modifiers & 0x00FFFFFF) | ((0x38 << 24) & 0xFF000000));
- }
-
- if((modifiers & alphaLock) && !(mLastModifiers & alphaLock))
- {
- if (gDebugWindowProc) printf("Caps lock down event\n");
- gKeyboard->handleKeyDown(0x39, (modifiers & 0x00FFFFFF) | ((0x39 << 24) & 0xFF000000));
- }
- else if(!(modifiers & alphaLock) && (mLastModifiers & alphaLock))
- {
- if (gDebugWindowProc) printf("Caps lock up event\n");
- gKeyboard->handleKeyUp(0x39, (modifiers & 0x00FFFFFF) | ((0x39 << 24) & 0xFF000000));
- }
-
- if((modifiers & controlKey) && !(mLastModifiers & controlKey))
- {
- if (gDebugWindowProc) printf("Control key down event\n");
- gKeyboard->handleKeyDown(0x3b, (modifiers & 0x00FFFFFF) | ((0x3b << 24) & 0xFF000000));
- }
- else if(!(modifiers & controlKey) && (mLastModifiers & controlKey))
- {
- if (gDebugWindowProc) printf("Control key up event\n");
- gKeyboard->handleKeyUp(0x3b, (modifiers & 0x00FFFFFF) | ((0x3b << 24) & 0xFF000000));
- }
-
- if((modifiers & optionKey) && !(mLastModifiers & optionKey))
- {
- if (gDebugWindowProc) printf("Option key down event\n");
- gKeyboard->handleKeyDown(0x3a, (modifiers & 0x00FFFFFF) | ((0x3a << 24) & 0xFF000000));
- }
- else if(!(modifiers & optionKey) && (mLastModifiers & optionKey))
- {
- if (gDebugWindowProc) printf("Option key up event\n");
- gKeyboard->handleKeyUp(0x3a, (modifiers & 0x00FFFFFF) | ((0x3a << 24) & 0xFF000000));
- }
-
- // When the state of the 'Fn' key (the one that changes some of the mappings on a powerbook/macbook keyboard
- // to an embedded keypad) changes, it may subsequently cause a key up event to be lost, which may lead to
- // a movement key getting "stuck" down. This is bad.
- // This is an OS bug -- even the GetKeys() API doesn't tell you the key has been released.
- // This workaround causes all held-down keys to be reset whenever the state of the Fn key changes. This isn't
- // exactly what we want, but it does avoid the case where you get stuck running forward.
- if((modifiers & kEventKeyModifierFnMask) != (mLastModifiers & kEventKeyModifierFnMask))
- {
- if (gDebugWindowProc) printf("Fn key state change event\n");
- gKeyboard->resetKeys();
- }
-
- if (gDebugWindowProc) fflush(stdout);
-
- mLastModifiers = modifiers;
- result = eventNotHandledErr;
- break;
- }
-
- mRawKeyEvent = NULL;
- }
- break;
-
- case kEventClassMouse:
- {
- result = CallNextEventHandler(myHandler, event);
- if (eventNotHandledErr == result)
- { // only handle events not already handled (prevents wierd resize interaction)
- EventMouseButton button = kEventMouseButtonPrimary;
- HIPoint location = {0.0f, 0.0f};
- UInt32 modifiers = 0;
- UInt32 clickCount = 1;
- long wheelDelta = 0;
- LLCoordScreen inCoords;
- LLCoordGL outCoords;
- MASK mask = 0;
-
- GetEventParameter(event, kEventParamMouseButton, typeMouseButton, NULL, sizeof(button), NULL, &button);
- GetEventParameter(event, kEventParamMouseLocation, typeHIPoint, NULL, sizeof(location), NULL, &location);
- GetEventParameter(event, kEventParamKeyModifiers, typeUInt32, NULL, sizeof(modifiers), NULL, &modifiers);
- GetEventParameter(event, kEventParamMouseWheelDelta, typeLongInteger, NULL, sizeof(wheelDelta), NULL, &wheelDelta);
- GetEventParameter(event, kEventParamClickCount, typeUInt32, NULL, sizeof(clickCount), NULL, &clickCount);
-
- inCoords.mX = llround(location.x);
- inCoords.mY = llround(location.y);
-
- if(modifiers & shiftKey) { mask |= MASK_SHIFT; }
- if(modifiers & controlKey) { mask |= MASK_CONTROL; }
- if(modifiers & optionKey) { mask |= MASK_ALT; }
-
- if(mCursorDecoupled)
- {
- CGMouseDelta x, y;
-
- // If the cursor's decoupled, we need to read the latest movement delta as well.
- CGGetLastMouseDelta( &x, &y );
- mCursorLastEventDeltaX = x;
- mCursorLastEventDeltaY = y;
-
- if(mCursorIgnoreNextDelta)
- {
- mCursorLastEventDeltaX = 0;
- mCursorLastEventDeltaY = 0;
- mCursorIgnoreNextDelta = FALSE;
- }
- }
- else
- {
- mCursorLastEventDeltaX = 0;
- mCursorLastEventDeltaY = 0;
- }
-
- inCoords.mX += mCursorLastEventDeltaX;
- inCoords.mY += mCursorLastEventDeltaY;
-
- convertCoords(inCoords, &outCoords);
-
- // printf("coords in: %d, %d; coords out: %d, %d\n", inCoords.mX, inCoords.mY, outCoords.mX, outCoords.mY);
- // fflush(stdout);
-
-
- switch (evtKind)
- {
- case kEventMouseDown:
- if (mLanguageTextInputAllowed)
- {
- // We need to interrupt before handling mouse events,
- // so that the fixed string from IM are delivered to
- // the currently focused UI component.
- interruptLanguageTextInput();
- }
- switch(button)
- {
- case kEventMouseButtonPrimary:
- if(modifiers & cmdKey)
- {
- // Simulate a right click
- mSimulatedRightClick = true;
- mCallbacks->handleRightMouseDown(this, outCoords, mask);
- }
- else if(clickCount == 2)
- {
- // Windows double-click events replace the second mousedown event in a double-click.
- mCallbacks->handleDoubleClick(this, outCoords, mask);
- }
- else
- {
- mCallbacks->handleMouseDown(this, outCoords, mask);
- }
- break;
- case kEventMouseButtonSecondary:
- mCallbacks->handleRightMouseDown(this, outCoords, mask);
- break;
-
- case kEventMouseButtonTertiary:
- mCallbacks->handleMiddleMouseDown(this, outCoords, mask);
- break;
- }
- result = noErr;
- break;
- case kEventMouseUp:
-
- switch(button)
- {
- case kEventMouseButtonPrimary:
- if(mSimulatedRightClick)
- {
- // End of simulated right click
- mSimulatedRightClick = false;
- mCallbacks->handleRightMouseUp(this, outCoords, mask);
- }
- else
- {
- mCallbacks->handleMouseUp(this, outCoords, mask);
- }
- break;
- case kEventMouseButtonSecondary:
- mCallbacks->handleRightMouseUp(this, outCoords, mask);
- break;
-
- case kEventMouseButtonTertiary:
- mCallbacks->handleMiddleMouseUp(this, outCoords, mask);
- break;
- }
- result = noErr;
- break;
-
- case kEventMouseWheelMoved:
- {
- static S32 z_delta = 0;
-
- z_delta += wheelDelta;
-
- if (z_delta <= -WHEEL_DELTA || WHEEL_DELTA <= z_delta)
- {
- mCallbacks->handleScrollWheel(this, -z_delta / WHEEL_DELTA);
- z_delta = 0;
- }
- }
- result = noErr;
- break;
-
- case kEventMouseDragged:
- case kEventMouseMoved:
- mCallbacks->handleMouseMove(this, outCoords, mask);
- result = noErr;
- break;
-
- }
- }
- }
- break;
-
- case kEventClassWindow:
- switch(evtKind)
- {
- case kEventWindowActivated:
- if (mTSMDocument)
- {
- ActivateTSMDocument(mTSMDocument);
- }
- mCallbacks->handleFocus(this);
- break;
- case kEventWindowDeactivated:
- if (mTSMDocument)
- {
- DeactivateTSMDocument(mTSMDocument);
- }
- mCallbacks->handleFocusLost(this);
- break;
-
- case kEventWindowBoundsChanging:
- {
- // This is where we would constrain move/resize to a particular screen
-
- const S32 MIN_WIDTH = mMinWindowWidth;
- const S32 MIN_HEIGHT = mMinWindowHeight;
-
- Rect currentBounds;
- Rect previousBounds;
-
- GetEventParameter(event, kEventParamCurrentBounds, typeQDRectangle, NULL, sizeof(Rect), NULL, &currentBounds);
- GetEventParameter(event, kEventParamPreviousBounds, typeQDRectangle, NULL, sizeof(Rect), NULL, &previousBounds);
-
- // Put an offset into window un-maximize operation since the kEventWindowGetIdealSize
- // event only allows the specification of size and not position.
- if (mMaximized)
- {
- short leftOffset = mPreviousWindowRect.left - currentBounds.left;
- currentBounds.left += leftOffset;
- currentBounds.right += leftOffset;
-
- short topOffset = mPreviousWindowRect.top - currentBounds.top;
- currentBounds.top += topOffset;
- currentBounds.bottom += topOffset;
- }
- else
- {
- // Store off the size for future un-maximize operations
- mPreviousWindowRect = previousBounds;
- }
-
- if ((currentBounds.right - currentBounds.left) < MIN_WIDTH)
- {
- currentBounds.right = currentBounds.left + MIN_WIDTH;
- }
-
- if ((currentBounds.bottom - currentBounds.top) < MIN_HEIGHT)
- {
- currentBounds.bottom = currentBounds.top + MIN_HEIGHT;
- }
-
- SetEventParameter(event, kEventParamCurrentBounds, typeQDRectangle, sizeof(Rect), &currentBounds);
- result = noErr;
- }
- break;
-
- case kEventWindowBoundsChanged:
- {
- // Get new window bounds
- Rect newBounds;
- GetEventParameter(event, kEventParamCurrentBounds, typeQDRectangle, NULL, sizeof(Rect), NULL, &newBounds);
-
- // Get previous window bounds
- Rect oldBounds;
- GetEventParameter(event, kEventParamPreviousBounds, typeQDRectangle, NULL, sizeof(Rect), NULL, &oldBounds);
-
- // Determine if the new size is larger than the old
- bool newBoundsLarger = ((newBounds.right - newBounds.left) >= (oldBounds.right - oldBounds.left));
- newBoundsLarger &= ((newBounds.bottom - newBounds.top) >= (oldBounds.bottom - oldBounds.top));
-
- // Check to see if this is a zoom event (+ button on window pane)
- unsigned int eventParams;
- GetEventParameter(event, kEventParamAttributes, typeUInt32, NULL, sizeof(int), NULL, &eventParams);
- bool isZoomEvent = ((eventParams & kWindowBoundsChangeZoom) != 0);
-
- // Maximized flag is if zoom event and increasing window size
- mMaximized = (isZoomEvent && newBoundsLarger);
-
- aglUpdateContext(mContext);
-
- mCallbacks->handleResize(this, newBounds.right - newBounds.left, newBounds.bottom - newBounds.top);
- }
- break;
-
- case kEventWindowGetIdealSize:
- // Only recommend a new ideal size when un-maximizing
- if (mMaximized == TRUE)
- {
- Point nonMaximizedSize;
-
- nonMaximizedSize.v = mPreviousWindowRect.bottom - mPreviousWindowRect.top;
- nonMaximizedSize.h = mPreviousWindowRect.right - mPreviousWindowRect.left;
-
- SetEventParameter(event, kEventParamDimensions, typeQDPoint, sizeof(Point), &nonMaximizedSize);
- result = noErr;
- }
- break;
-
- case kEventWindowClose:
- if(mCallbacks->handleCloseRequest(this))
- {
- // Get the app to initiate cleanup.
- mCallbacks->handleQuit(this);
- // The app is responsible for calling destroyWindow when done with GL
- }
- result = noErr;
- break;
-
- case kEventWindowHidden:
- // llinfos << "LLWindowMacOSX: Deactivating on hide" << llendl;
- mMinimized = TRUE;
- mCallbacks->handleActivate(this, false);
- // result = noErr;
- break;
-
- case kEventWindowShown:
- // llinfos << "LLWindowMacOSX: Activating on show" << llendl;
- mMinimized = FALSE;
- mCallbacks->handleActivate(this, true);
- // result = noErr;
- break;
-
- case kEventWindowCollapsed:
- // llinfos << "LLWindowMacOSX: Deactivating on collapse" << llendl;
- mMinimized = TRUE;
- mCallbacks->handleActivate(this, false);
- // result = noErr;
- break;
-
- case kEventWindowExpanded:
- // llinfos << "LLWindowMacOSX: Activating on expand" << llendl;
- mMinimized = FALSE;
- mCallbacks->handleActivate(this, true);
- // result = noErr;
- break;
-
- case kEventWindowGetClickActivation:
- // BringToFront(mWindow);
- // result = noErr;
- break;
- }
- break;
-
- case kEventClassTSMDocumentAccess:
- if (mPreeditor)
- {
- switch(evtKind)
- {
-
- case kEventTSMDocumentAccessGetLength:
- {
- // Return the number of UTF-16 units in the text, excluding those for preedit.
-
- S32 preedit, preedit_length;
- mPreeditor->getPreeditRange(&preedit, &preedit_length);
- const LLWString & text = mPreeditor->getPreeditString();
- const CFIndex length = wstring_utf16_length(text, 0, preedit)
- + wstring_utf16_length(text, preedit + preedit_length, text.length());
- result = SetEventParameter(event, kEventParamTSMDocAccessCharacterCount, typeCFIndex, sizeof(length), &length);
- }
- break;
-
- case kEventTSMDocumentAccessGetSelectedRange:
- {
- // Return the selected range, excluding preedit.
- // In our preeditor, preedit and selection are exclusive, so,
- // when it has a preedit, there is no selection and the
- // insertion point is on the preedit that corrupses into the
- // beginning of the preedit when the preedit was removed.
-
- S32 preedit, preedit_length;
- mPreeditor->getPreeditRange(&preedit, &preedit_length);
- const LLWString & text = mPreeditor->getPreeditString();
-
- CFRange range;
- if (preedit_length)
- {
- range.location = wstring_utf16_length(text, 0, preedit);
- range.length = 0;
- }
- else
- {
- S32 selection, selection_length;
- mPreeditor->getSelectionRange(&selection, &selection_length);
- range.location = wstring_utf16_length(text, 0, selection);
- range.length = wstring_utf16_length(text, selection, selection_length);
- }
-
- result = SetEventParameter(event, kEventParamTSMDocAccessReplyCharacterRange, typeCFRange, sizeof(range), &range);
- }
- break;
-
- case kEventTSMDocumentAccessGetCharacters:
- {
- UniChar *target_pointer;
- CFRange range;
- EventParamType param_type;
- if ((result = GetEventParameter(event, kEventParamTSMDocAccessSendCharacterRange,
- typeCFRange, &param_type, sizeof(range), NULL, &range)) == noErr
- && typeCFRange == param_type
- && (result = GetEventParameter(event, kEventParamTSMDocAccessSendCharactersPtr,
- typePtr, &param_type, sizeof(target_pointer), NULL, &target_pointer)) == noErr
- && typePtr == param_type)
- {
- S32 preedit, preedit_length;
- mPreeditor->getPreeditRange(&preedit, &preedit_length);
- const LLWString & text = mPreeditor->getPreeditString();
-
- // The GetCharacters event of TSMDA has a fundamental flaw;
- // An input method need to decide the starting offset and length
- // *before* it actually see the contents, so it is impossible
- // to guarantee the character-aligned access. The event reply
- // has no way to indicate a condition something like "Request
- // was not fulfilled due to unaligned access. Please retry."
- // Any error sent back to the input method stops use of TSMDA
- // entirely during the session...
- // We need to simulate very strictly the behaviour as if the
- // underlying *text engine* holds the contents in UTF-16.
- // I guess this is the reason why Apple repeats saying "all
- // text handling application should use UTF-16." They are
- // trying to _fix_ the flaw by changing the appliations...
- // ... or, domination of UTF-16 in the industry may be a part
- // of the company vision, and Apple is trying to force third
- // party developers to obey their vision. Remember that use
- // of 16 bits per _a_character_ was one of the very fundamental
- // Unicode design policy on its early days (during late 80s)
- // and the original Unicode design was by two Apple employees...
-
- const llutf16string text_utf16
- = wstring_to_utf16str(text, preedit)
- + wstring_to_utf16str(text.substr(preedit + preedit_length));
-
- llassert_always(sizeof(U16) == sizeof(UniChar));
- llassert(0 <= range.location && 0 <= range.length && range.location + range.length <= text_utf16.length());
- memcpy(target_pointer, text_utf16.c_str() + range.location, range.length * sizeof(UniChar));
-
- // Note that result has already been set above.
- }
- }
- break;
-
- }
- }
- break;
- }
- return result;
-}
-
const char* cursorIDToName(int id)
{
switch (id)
@@ -2876,7 +1397,7 @@ static void initPixmapCursor(int cursorid, int hotspotX, int hotspotY)
void LLWindowMacOSX::updateCursor()
{
- OSStatus result = noErr;
+ S32 result = 0;
if (mDragOverrideCursor != -1)
{
@@ -2913,7 +1434,7 @@ void LLWindowMacOSX::updateCursor()
if(mCursorHidden)
{
// Since InitCursor resets the hide level, correct for it here.
- ::HideCursor();
+ hideNSCursor();
}
break;
@@ -2921,12 +1442,12 @@ void LLWindowMacOSX::updateCursor()
// Find out what they look like and replicate them.
// These are essentially correct
- case UI_CURSOR_WAIT: SetThemeCursor(kThemeWatchCursor); break;
- case UI_CURSOR_IBEAM: SetThemeCursor(kThemeIBeamCursor); break;
- case UI_CURSOR_CROSS: SetThemeCursor(kThemeCrossCursor); break;
- case UI_CURSOR_HAND: SetThemeCursor(kThemePointingHandCursor); break;
+ case UI_CURSOR_WAIT: /* Apple purposely doesn't allow us to set the beachball cursor manually. */ break;
+ case UI_CURSOR_IBEAM: setIBeamCursor(); break;
+ case UI_CURSOR_CROSS: setCrossCursor(); break;
+ case UI_CURSOR_HAND: setPointingHandCursor(); break;
// case UI_CURSOR_NO: SetThemeCursor(kThemeNotAllowedCursor); break;
- case UI_CURSOR_ARROWCOPY: SetThemeCursor(kThemeCopyArrowCursor); break;
+ case UI_CURSOR_ARROWCOPY: setCopyCursor(); break;
// Double-check these
case UI_CURSOR_NO:
@@ -3039,7 +1560,7 @@ void LLWindowMacOSX::hideCursor()
// llinfos << "hideCursor: hiding" << llendl;
mCursorHidden = TRUE;
mHideCursorPermanent = TRUE;
- ::HideCursor();
+ hideNSCursor();
}
else
{
@@ -3056,7 +1577,7 @@ void LLWindowMacOSX::showCursor()
// llinfos << "showCursor: showing" << llendl;
mCursorHidden = FALSE;
mHideCursorPermanent = FALSE;
- ::ShowCursor();
+ showNSCursor();
}
else
{
@@ -3102,7 +1623,7 @@ void LLSplashScreenMacOSX::showImpl()
// This code _could_ be used to display a spash screen...
#if 0
IBNibRef nib = NULL;
- OSStatus err;
+ S32 err;
err = CreateNibReference(CFSTR("SecondLife"), &nib);
@@ -3127,25 +1648,6 @@ void LLSplashScreenMacOSX::updateImpl(const std::string& mesg)
CFStringRef string = NULL;
string = CFStringCreateWithCString(NULL, mesg.c_str(), kCFStringEncodingUTF8);
-
- if(string != NULL)
- {
- ControlRef progressText = NULL;
- ControlID id;
- OSStatus err;
-
- id.signature = 'what';
- id.id = 0;
-
- err = GetControlByID(mWindow, &id, &progressText);
- if(err == noErr)
- {
- err = SetControlData(progressText, kControlEntireControl, kControlStaticTextCFStringTag, sizeof(CFStringRef), (Ptr)&string);
- Draw1Control(progressText);
- }
-
- CFRelease(string);
- }
}
}
@@ -3154,7 +1656,6 @@ void LLSplashScreenMacOSX::hideImpl()
{
if(mWindow != NULL)
{
- DisposeWindow(mWindow);
mWindow = NULL;
}
}
@@ -3163,102 +1664,16 @@ void LLSplashScreenMacOSX::hideImpl()
S32 OSMessageBoxMacOSX(const std::string& text, const std::string& caption, U32 type)
{
- S32 result = OSBTN_CANCEL;
- SInt16 retval_mac = 1;
- AlertStdCFStringAlertParamRec params;
- CFStringRef errorString = NULL;
- CFStringRef explanationString = NULL;
- DialogRef alert = NULL;
- AlertType alertType = kAlertCautionAlert;
- OSStatus err;
-
- explanationString = CFStringCreateWithCString(NULL, text.c_str(), kCFStringEncodingUTF8);
- errorString = CFStringCreateWithCString(NULL, caption.c_str(), kCFStringEncodingUTF8);
-
- params.version = kStdCFStringAlertVersionOne;
- params.movable = false;
- params.helpButton = false;
- params.defaultText = (CFStringRef)kAlertDefaultOKText;
- params.cancelText = 0;
- params.otherText = 0;
- params.defaultButton = 1;
- params.cancelButton = 0;
- params.position = kWindowDefaultPosition;
- params.flags = 0;
-
- switch(type)
- {
- case OSMB_OK:
- default:
- break;
- case OSMB_OKCANCEL:
- params.cancelText = (CFStringRef)kAlertDefaultCancelText;
- params.cancelButton = 2;
- break;
- case OSMB_YESNO:
- alertType = kAlertNoteAlert;
- params.defaultText = CFSTR("Yes");
- params.cancelText = CFSTR("No");
- params.cancelButton = 2;
- break;
- }
-
- if(gWindowImplementation != NULL)
- gWindowImplementation->beforeDialog();
-
- err = CreateStandardAlert(
- alertType,
- errorString,
- explanationString,
- &params,
- &alert);
-
- if(err == noErr)
- {
- err = RunStandardAlert(
- alert,
- NULL,
- &retval_mac);
- }
-
- if(gWindowImplementation != NULL)
- gWindowImplementation->afterDialog();
-
- switch(type)
- {
- case OSMB_OK:
- case OSMB_OKCANCEL:
- default:
- if(retval_mac == 1)
- result = OSBTN_OK;
- else
- result = OSBTN_CANCEL;
- break;
- case OSMB_YESNO:
- if(retval_mac == 1)
- result = OSBTN_YES;
- else
- result = OSBTN_NO;
- break;
- }
-
- if(errorString != NULL)
- {
- CFRelease(errorString);
- }
-
- if(explanationString != NULL)
- {
- CFRelease(explanationString);
- }
-
- return result;
+ // TODO: Implement a native NSAlert function that replicates all of this.
+ return 0;
}
// Open a URL with the user's default web browser.
// Must begin with protocol identifier.
void LLWindowMacOSX::spawnWebBrowser(const std::string& escaped_url, bool async)
{
+ // I'm fairly certain that this is all legitimate under Apple's currently supported APIs.
+
bool found = false;
S32 i;
for (i = 0; i < gURLProtocolWhitelistCount; i++)
@@ -3276,7 +1691,7 @@ void LLWindowMacOSX::spawnWebBrowser(const std::string& escaped_url, bool async)
return;
}
- OSStatus result = noErr;
+ S32 result = 0;
CFURLRef urlRef = NULL;
llinfos << "Opening URL " << escaped_url << llendl;
@@ -3313,7 +1728,7 @@ void LLWindowMacOSX::spawnWebBrowser(const std::string& escaped_url, bool async)
LLSD LLWindowMacOSX::getNativeKeyData()
{
LLSD result = LLSD::emptyMap();
-
+#if 0
if(mRawKeyEvent)
{
char char_code = 0;
@@ -3335,7 +1750,7 @@ LLSD LLWindowMacOSX::getNativeKeyData()
// This causes trouble for control characters -- apparently character codes less than 32 (escape, control-A, etc)
// cause llsd serialization to create XML that the llsd deserializer won't parse!
std::string unicode;
- OSStatus err = noErr;
+ S32 err = noErr;
EventParamType actualType = typeUTF8Text;
UInt32 actualSize = 0;
char *buffer = NULL;
@@ -3357,7 +1772,7 @@ LLSD LLWindowMacOSX::getNativeKeyData()
#endif
}
-
+#endif
lldebugs << "native key data is: " << result << llendl;
@@ -3367,34 +1782,9 @@ LLSD LLWindowMacOSX::getNativeKeyData()
BOOL LLWindowMacOSX::dialogColorPicker( F32 *r, F32 *g, F32 *b)
{
+ // Is this even used anywhere? Do we really need an OS color picker?
BOOL retval = FALSE;
- OSErr error = noErr;
- NColorPickerInfo info;
-
- memset(&info, 0, sizeof(info));
- info.theColor.color.rgb.red = (UInt16)(*r * 65535.f);
- info.theColor.color.rgb.green = (UInt16)(*g * 65535.f);
- info.theColor.color.rgb.blue = (UInt16)(*b * 65535.f);
- info.placeWhere = kCenterOnMainScreen;
-
- if(gWindowImplementation != NULL)
- gWindowImplementation->beforeDialog();
-
- error = NPickColor(&info);
-
- if(gWindowImplementation != NULL)
- gWindowImplementation->afterDialog();
-
- if (error == noErr)
- {
- retval = info.newColorChosen;
- if (info.newColorChosen)
- {
- *r = ((float) info.theColor.color.rgb.red) / 65535.0;
- *g = ((float) info.theColor.color.rgb.green) / 65535.0;
- *b = ((float) info.theColor.color.rgb.blue) / 65535.0;
- }
- }
+ //S32 error = 0;
return (retval);
}
@@ -3405,44 +1795,13 @@ void *LLWindowMacOSX::getPlatformWindow()
return (void*)mWindow;
}
-void *LLWindowMacOSX::getMediaWindow()
-{
- /*
- Mozilla needs to be initialized with a WindowRef to function properly.
- (There's no good reason for this, since it shouldn't be interacting with our window in any way, but that's another issue.)
- If we're in windowed mode, we _could_ hand it our actual window pointer, but a subsequent switch to fullscreen will destroy that window,
- which trips up Mozilla.
- Instead of using our actual window, we create an invisible window which will persist for the lifetime of the application and pass that to Mozilla.
- This satisfies its deep-seated need to latch onto a WindowRef and solves the issue with switching between fullscreen and windowed modes.
-
- Note that we will never destroy this window (by design!), but since only one will ever be created per run of the application, that's okay.
- */
-
- if(sMediaWindow == NULL)
- {
- Rect window_rect = {100, 100, 200, 200};
-
- sMediaWindow = NewCWindow(
- NULL,
- &window_rect,
- (ConstStr255Param) "\p",
- false, // Create the window invisible.
- zoomDocProc, // Window with a grow box and a zoom box
- kLastWindowOfClass, // create it behind other windows
- false, // no close box
- 0);
- }
-
- return (void*)sMediaWindow;
-}
-
void LLWindowMacOSX::stopDockTileBounce()
{
- NMRemove(&mBounceRec);
mBounceTimer.stop();
}
// get a double value from a dictionary
+/*
static double getDictDouble (CFDictionaryRef refDict, CFStringRef key)
{
double double_value;
@@ -3452,7 +1811,7 @@ static double getDictDouble (CFDictionaryRef refDict, CFStringRef key)
if (!CFNumberGetValue(number_value, kCFNumberDoubleType, &double_value)) // or if cant convert it
return -1; // fail
return double_value; // otherwise return the long value
-}
+}*/
// get a long value from a dictionary
static long getDictLong (CFDictionaryRef refDict, CFStringRef key)
@@ -3468,71 +1827,12 @@ static long getDictLong (CFDictionaryRef refDict, CFStringRef key)
void LLWindowMacOSX::allowLanguageTextInput(LLPreeditor *preeditor, BOOL b)
{
- ScriptLanguageRecord script_language;
-
- if (preeditor != mPreeditor && !b)
- {
- // This condition may occur by a call to
- // setEnabled(BOOL) against LLTextEditor or LLLineEditor
- // when the control is not focused.
- // We need to silently ignore the case so that
- // the language input status of the focused control
- // is not disturbed.
- return;
- }
-
- UseInputWindow(mTSMDocument, !b);
-
- // Take care of old and new preeditors.
- if (preeditor != mPreeditor || !b)
- {
- // We need to interrupt before updating mPreeditor,
- // so that the fix string from input method goes to
- // the old preeditor.
- if (mLanguageTextInputAllowed)
- {
- interruptLanguageTextInput();
- }
- mPreeditor = (b ? preeditor : NULL);
- }
-
- if (b == mLanguageTextInputAllowed)
- {
- return;
- }
- mLanguageTextInputAllowed = b;
-
- if (b)
- {
- if (mTSMScriptCode != smRoman)
- {
- script_language.fScript = mTSMScriptCode;
- script_language.fLanguage = mTSMLangCode;
- SetTextServiceLanguage(&script_language);
- }
- }
- else
- {
- GetTextServiceLanguage(&script_language);
- mTSMScriptCode = script_language.fScript;
- mTSMLangCode = script_language.fLanguage;
- if (mTSMScriptCode != smRoman)
- {
- script_language.fScript = smRoman;
- script_language.fLanguage = langEnglish;
- SetTextServiceLanguage(&script_language);
- }
- }
+ // TODO: IME support
}
void LLWindowMacOSX::interruptLanguageTextInput()
{
- if (mTSMDocument)
- {
- FixTSMDocument(mTSMDocument);
- }
- // Don't we need to call resetPreedit here?
- // Well, if Apple's TSM document is correct, we don't.
+ // TODO: IME support
}
//static
@@ -3543,21 +1843,21 @@ std::vector<std::string> LLWindowMacOSX::getDynamicFallbackFontList()
}
// static
-MASK LLWindowMacOSX::modifiersToMask(SInt16 modifiers)
+MASK LLWindowMacOSX::modifiersToMask(S16 modifiers)
{
MASK mask = 0;
- if(modifiers & shiftKey) { mask |= MASK_SHIFT; }
- if(modifiers & (cmdKey | controlKey)) { mask |= MASK_CONTROL; }
- if(modifiers & optionKey) { mask |= MASK_ALT; }
+ if(modifiers & MAC_SHIFT_KEY) { mask |= MASK_SHIFT; }
+ if(modifiers & (MAC_CMD_KEY | MAC_CTRL_KEY)) { mask |= MASK_CONTROL; }
+ if(modifiers & MAC_ALT_KEY) { mask |= MASK_ALT; }
return mask;
}
#if LL_OS_DRAGDROP_ENABLED
-
-OSErr LLWindowMacOSX::dragTrackingHandler(DragTrackingMessage message, WindowRef theWindow,
+/*
+S16 LLWindowMacOSX::dragTrackingHandler(DragTrackingMessage message, WindowRef theWindow,
void * handlerRefCon, DragRef drag)
{
- OSErr result = noErr;
+ S16 result = 0;
LLWindowMacOSX *self = (LLWindowMacOSX*)handlerRefCon;
lldebugs << "drag tracking handler, message = " << message << llendl;
@@ -3711,5 +2011,5 @@ OSErr LLWindowMacOSX::handleDragNDrop(DragRef drag, LLWindowCallbacks::DragNDrop
return result;
}
-
+*/
#endif // LL_OS_DRAGDROP_ENABLED
diff --git a/indra/llwindow/llwindowmacosx.h b/indra/llwindow/llwindowmacosx.h
index af83b50097..a821dcabd8 100644
--- a/indra/llwindow/llwindowmacosx.h
+++ b/indra/llwindow/llwindowmacosx.h
@@ -29,11 +29,14 @@
#include "llwindow.h"
#include "llwindowcallbacks.h"
+#include "llwindowmacosx-objc.h"
#include "lltimer.h"
-#include <Carbon/Carbon.h>
-#include <AGL/agl.h>
+//#include <Carbon/Carbon.h>
+//#include <AGL/agl.h>
+#include <ApplicationServices/ApplicationServices.h>
+#include <OpenGL/OpenGL.h>
// AssertMacros.h does bad things.
#include "fix_macros.h"
@@ -106,7 +109,6 @@ public:
/*virtual*/ BOOL dialogColorPicker(F32 *r, F32 *g, F32 *b);
/*virtual*/ void *getPlatformWindow();
- /*virtual*/ void *getMediaWindow();
/*virtual*/ void bringToFront() {};
/*virtual*/ void allowLanguageTextInput(LLPreeditor *preeditor, BOOL b);
@@ -117,6 +119,12 @@ public:
// Provide native key event data
/*virtual*/ LLSD getNativeKeyData();
+
+ void* getWindow() { return mWindow; }
+ LLWindowCallbacks* getCallbacks() { return mCallbacks; }
+
+ void updateMouseDeltas();
+ void getMouseDeltas(float* delta);
protected:
@@ -153,40 +161,35 @@ protected:
BOOL createContext(int x, int y, int width, int height, int bits, BOOL fullscreen, BOOL disable_vsync);
void destroyContext();
void setupFailure(const std::string& text, const std::string& caption, U32 type);
- static pascal OSStatus staticEventHandler (EventHandlerCallRef myHandler, EventRef event, void* userData);
- static pascal Boolean staticMoveEventComparator( EventRef event, void* data);
- OSStatus eventHandler (EventHandlerCallRef myHandler, EventRef event);
void adjustCursorDecouple(bool warpingMouse = false);
void stopDockTileBounce();
- static MASK modifiersToMask(SInt16 modifiers);
+ static MASK modifiersToMask(S16 modifiers);
#if LL_OS_DRAGDROP_ENABLED
+ /*
static OSErr dragTrackingHandler(DragTrackingMessage message, WindowRef theWindow,
void * handlerRefCon, DragRef theDrag);
static OSErr dragReceiveHandler(WindowRef theWindow, void * handlerRefCon, DragRef theDrag);
OSErr handleDragNDrop(DragRef theDrag, LLWindowCallbacks::DragNDropAction action);
+ */
#endif // LL_OS_DRAGDROP_ENABLED
//
// Platform specific variables
//
- WindowRef mWindow;
- AGLContext mContext;
- AGLPixelFormat mPixelFormat;
+
+ // Use generic pointers here. This lets us do some funky Obj-C interop using Obj-C objects without having to worry about any compilation problems that may arise.
+ NSWindowRef mWindow;
+ GLViewRef mGLView;
+ CGLContextObj mContext;
+ CGLPixelFormatObj mPixelFormat;
CGDirectDisplayID mDisplay;
- CFDictionaryRef mOldDisplayMode;
- EventLoopTimerRef mTimer;
- EventHandlerUPP mEventHandlerUPP;
- EventHandlerRef mGlobalHandlerRef;
- EventHandlerRef mWindowHandlerRef;
- EventComparatorUPP mMoveEventCampartorUPP;
- Rect mOldMouseClip; // Screen rect to which the mouse cursor was globally constrained before we changed it in clipMouse()
- Rect mPreviousWindowRect; // Save previous window for un-maximize event
- Str255 mWindowTitle;
+ LLRect mOldMouseClip; // Screen rect to which the mouse cursor was globally constrained before we changed it in clipMouse()
+ std::string mWindowTitle;
double mOriginalAspectRatio;
BOOL mSimulatedRightClick;
- UInt32 mLastModifiers;
+ U32 mLastModifiers;
BOOL mHandsOffEvents; // When true, temporarially disable CarbonEvent processing.
// Used to allow event processing when putting up dialogs in fullscreen mode.
BOOL mCursorDecoupled;
@@ -204,22 +207,17 @@ protected:
S32 mDragOverrideCursor;
F32 mBounceTime;
- NMRec mBounceRec;
+ //NMRec mBounceRec;
LLTimer mBounceTimer;
// Input method management through Text Service Manager.
- TSMDocumentID mTSMDocument;
BOOL mLanguageTextInputAllowed;
- ScriptCode mTSMScriptCode;
- LangCode mTSMLangCode;
LLPreeditor* mPreeditor;
static BOOL sUseMultGL;
friend class LLWindowManager;
- static WindowRef sMediaWindow;
- EventRef mRawKeyEvent;
-
+
};
diff --git a/indra/newview/llviewerkeyboard.cpp b/indra/newview/llviewerkeyboard.cpp
index 1aa9fd8a45..6d91dad70e 100644
--- a/indra/newview/llviewerkeyboard.cpp
+++ b/indra/newview/llviewerkeyboard.cpp
@@ -653,6 +653,8 @@ BOOL LLViewerKeyboard::modeFromString(const std::string& string, S32 *mode)
BOOL LLViewerKeyboard::handleKey(KEY translated_key, MASK translated_mask, BOOL repeated)
{
+ LL_INFOS("Keyboard Handling") << "Handling key " << translated_key << LL_ENDL;
+ LL_INFOS("Keyboard Handling") << "Keyboard has focus? " << gFocusMgr.getKeyboardFocus() << LL_ENDL;
// check for re-map
EKeyboardMode mode = gViewerKeyboard.getMode();
U32 keyidx = (translated_mask<<16) | translated_key;
diff --git a/indra/newview/llviewerwindow.cpp b/indra/newview/llviewerwindow.cpp
index 1def2db829..7c0d49d1e2 100755
--- a/indra/newview/llviewerwindow.cpp
+++ b/indra/newview/llviewerwindow.cpp
@@ -2428,6 +2428,7 @@ void LLViewerWindow::draw()
// Takes a single keydown event, usually when UI is visible
BOOL LLViewerWindow::handleKey(KEY key, MASK mask)
{
+ LL_INFOS("Keyboard Handling") << "Handling key " << key << LL_ENDL;
// hide tooltips on keypress
LLToolTipMgr::instance().blockToolTips();
generated by cgit v1.2.3 (git 2.25.1) at 2024-11-25 03:36:21 +0000