/* -*- Mode: objc; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ /* This Source Code Form is subject to the terms of the Mozilla Public * License, v. 2.0. If a copy of the MPL was not distributed with this * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ #include "mozilla/ArrayUtils.h" #include "mozilla/Logging.h" #include #include #include "nsChildView.h" #include "nsCocoaWindow.h" #include "mozilla/MiscEvents.h" #include "mozilla/MouseEvents.h" #include "mozilla/TextEvents.h" #include "mozilla/TouchEvents.h" #include "nsObjCExceptions.h" #include "nsCOMPtr.h" #include "nsToolkit.h" #include "nsCRT.h" #include "nsFontMetrics.h" #include "nsIRollupListener.h" #include "nsViewManager.h" #include "nsIInterfaceRequestor.h" #include "nsIFile.h" #include "nsILocalFileMac.h" #include "nsGfxCIID.h" #include "nsIDOMSimpleGestureEvent.h" #include "nsThemeConstants.h" #include "nsIWidgetListener.h" #include "nsIPresShell.h" #include "nsDragService.h" #include "nsClipboard.h" #include "nsCursorManager.h" #include "nsWindowMap.h" #include "nsCocoaFeatures.h" #include "nsCocoaUtils.h" #include "nsMenuUtilsX.h" #include "nsMenuBarX.h" #include "NativeKeyBindings.h" #include "ComplexTextInputPanel.h" #include "gfxContext.h" #include "gfxQuartzSurface.h" #include "gfxUtils.h" #include "nsRegion.h" #include "Layers.h" #include "ClientLayerManager.h" #include "mozilla/layers/LayerManagerComposite.h" #include "GLTextureImage.h" #include "GLContextProvider.h" #include "GLContextCGL.h" #include "GLUploadHelpers.h" #include "ScopedGLHelpers.h" #include "HeapCopyOfStackArray.h" #include "mozilla/layers/APZCTreeManager.h" #include "mozilla/layers/APZThreadUtils.h" #include "mozilla/layers/GLManager.h" #include "mozilla/layers/CompositorOGL.h" #include "mozilla/layers/CompositorParent.h" #include "mozilla/layers/BasicCompositor.h" #include "mozilla/layers/InputAPZContext.h" #include "gfxUtils.h" #include "gfxPrefs.h" #include "mozilla/gfx/2D.h" #include "mozilla/gfx/BorrowedContext.h" #ifdef ACCESSIBILITY #include "nsAccessibilityService.h" #include "mozilla/a11y/Platform.h" #endif #ifdef MOZ_CRASHREPORTER #include "nsExceptionHandler.h" #endif #include "mozilla/Preferences.h" #include #include #include "GeckoProfiler.h" #include "nsIDOMWheelEvent.h" #include "mozilla/layers/ChromeProcessController.h" #include "nsLayoutUtils.h" #include "InputData.h" #include "SwipeTracker.h" #include "VibrancyManager.h" #include "nsNativeThemeCocoa.h" #include "nsIDOMWindowUtils.h" #include "Units.h" #include "UnitTransforms.h" using namespace mozilla; using namespace mozilla::layers; using namespace mozilla::gl; using namespace mozilla::widget; using mozilla::gfx::Matrix4x4; #undef DEBUG_UPDATE #undef INVALIDATE_DEBUGGING // flash areas as they are invalidated // Don't put more than this many rects in the dirty region, just fluff // out to the bounding-box if there are more #define MAX_RECTS_IN_REGION 100 PRLogModuleInfo* sCocoaLog = nullptr; extern "C" { CG_EXTERN void CGContextResetCTM(CGContextRef); CG_EXTERN void CGContextSetCTM(CGContextRef, CGAffineTransform); CG_EXTERN void CGContextResetClip(CGContextRef); typedef CFTypeRef CGSRegionObj; CGError CGSNewRegionWithRect(const CGRect *rect, CGSRegionObj *outRegion); CGError CGSNewRegionWithRectList(const CGRect *rects, int rectCount, CGSRegionObj *outRegion); // CGSPrivate.h typedef NSInteger CGSConnection; typedef NSInteger CGSWindow; extern CGSConnection _CGSDefaultConnection(); extern CGError CGSGetScreenRectForWindow(const CGSConnection cid, CGSWindow wid, CGRect *outRect); extern CGError CGSGetWindowLevel(const CGSConnection cid, CGSWindow wid, CGWindowLevel *level); extern CGError CGSGetWindowAlpha(const CGSConnection cid, const CGSWindow wid, float* alpha); } #ifndef NS_LEOPARD_AND_LATER struct __TISInputSource; typedef __TISInputSource* TISInputSourceRef; TISInputSourceRef (*Leopard_TISCopyCurrentKeyboardInputSource)() = NULL; TISInputSourceRef (*Leopard_TISCopyCurrentKeyboardLayoutInputSource)() = NULL; void* (*Leopard_TISGetInputSourceProperty)(TISInputSourceRef inputSource, CFStringRef propertyKey) = NULL; CFArrayRef (*Leopard_TISCreateInputSourceList)(CFDictionaryRef properties, Boolean includeAllInstalled) = NULL; CFStringRef kOurTISPropertyUnicodeKeyLayoutData = NULL; CFStringRef kOurTISPropertyInputSourceID = NULL; CFStringRef kOurTISPropertyInputSourceLanguages = NULL; bool nsTSMManager::sIsIMEEnabled = true; bool nsTSMManager::sIsRomanKeyboardsOnly = false; bool nsTSMManager::sIgnoreCommit = false; NSView* nsTSMManager::sComposingView = nullptr; TSMDocumentID nsTSMManager::sDocumentID = nullptr; NSString* nsTSMManager::sComposingString = nullptr; nsITimer* nsTSMManager::sSyncKeyScriptTimer = nullptr; uint32_t nsTSMManager::sIMEEnabledStatus = IMEState::ENABLED; #endif // NS_LEOPARD_AND_LATER uint32_t nsChildView::sSecureEventInputCount = 0; // defined in nsMenuBarX.mm extern NSMenu* sApplicationMenu; // Application menu shared by all menubars static bool gChildViewMethodsSwizzled = false; extern nsISupportsArray *gDraggedTransferables; ChildView* ChildViewMouseTracker::sLastMouseEventView = nil; NSEvent* ChildViewMouseTracker::sLastMouseMoveEvent = nil; NSWindow* ChildViewMouseTracker::sWindowUnderMouse = nil; NSPoint ChildViewMouseTracker::sLastScrollEventScreenLocation = NSZeroPoint; #ifdef INVALIDATE_DEBUGGING static void blinkRect(Rect* r); static void blinkRgn(RgnHandle rgn); #endif #ifndef NS_LEOPARD_AND_LATER // used by nsAppShell.mm uint32_t gLastModifierState = 0; #endif nsString mLastDispatchedCompositionString; // bug 543789. NOT NSString *! bool gUserCancelledDrag = false; uint32_t nsChildView::sLastInputEventCount = 0; static uint32_t gNumberOfWidgetsNeedingEventThread = 0; @interface ChildView(Private) // sets up our view, attaching it to its owning gecko view - (id)initWithFrame:(NSRect)inFrame geckoChild:(nsChildView*)inChild; - (void)forceRefreshOpenGL; // set up a gecko mouse event based on a cocoa mouse event - (void) convertCocoaMouseWheelEvent:(NSEvent*)aMouseEvent toGeckoEvent:(WidgetWheelEvent*)outWheelEvent; - (void) convertCocoaMouseEvent:(NSEvent*)aMouseEvent toGeckoEvent:(WidgetInputEvent*)outGeckoEvent; - (NSMenu*)contextMenu; - (BOOL)isRectObscuredBySubview:(NSRect)inRect; - (void)processPendingRedraws; - (void)drawRect:(NSRect)aRect inContext:(CGContextRef)aContext; - (LayoutDeviceIntRegion)nativeDirtyRegionWithBoundingRect:(NSRect)aRect; - (BOOL)isUsingMainThreadOpenGL; - (BOOL)isUsingOpenGL; - (void)drawUsingOpenGL; - (void)drawUsingOpenGLCallback; - (BOOL)hasRoundedBottomCorners; - (CGFloat)cornerRadius; - (void)clearCorners; // Overlay drawing functions for traditional CGContext drawing - (void)drawTitleString; - (void)drawTitlebarHighlight; - (void)maskTopCornersInContext:(CGContextRef)aContext; // Called using performSelector:withObject:afterDelay:0 to release // aWidgetArray (and its contents) the next time through the run loop. - (void)releaseWidgets:(NSArray*)aWidgetArray; #if USE_CLICK_HOLD_CONTEXTMENU // called on a timer two seconds after a mouse down to see if we should display // a context menu (click-hold) - (void)clickHoldCallback:(id)inEvent; #endif #ifdef ACCESSIBILITY - (id)accessible; #endif - (LayoutDeviceIntPoint)convertWindowCoordinates:(NSPoint)aPoint; - (APZCTreeManager*)apzctm; - (BOOL)inactiveWindowAcceptsMouseEvent:(NSEvent*)aEvent; - (void)updateWindowDraggableState; - (bool)shouldConsiderStartingSwipeFromEvent:(NSEvent*)aEvent; @end @interface EventThreadRunner : NSObject { NSThread* mThread; } - (id)init; + (void)start; + (void)stop; @end @interface NSView(NSThemeFrameCornerRadius) - (float)roundedCornerRadius; @end @interface NSView(DraggableRegion) - (CGSRegionObj)_regionForOpaqueDescendants:(NSRect)aRect forMove:(BOOL)aForMove; - (CGSRegionObj)_regionForOpaqueDescendants:(NSRect)aRect forMove:(BOOL)aForMove forUnderTitlebar:(BOOL)aForUnderTitlebar; @end @interface NSWindow(NSWindowShouldZoomOnDoubleClick) + (BOOL)_shouldZoomOnDoubleClick; // present on 10.7 and above @end // Starting with 10.7 the bottom corners of all windows are rounded. // Unfortunately, the standard rounding that OS X applies to OpenGL views // does not use anti-aliasing and looks very crude. Since we want a smooth, // anti-aliased curve, we'll draw it ourselves. // Additionally, we need to turn off the OS-supplied rounding because it // eats into our corner's curve. We do that by overriding an NSSurface method. @interface NSSurface @end @implementation NSSurface(DontCutOffCorners) - (CGSRegionObj)_createRoundedBottomRegionForRect:(CGRect)rect { // Create a normal rect region without rounded bottom corners. CGSRegionObj region; CGSNewRegionWithRect(&rect, ®ion); return region; } @end #pragma mark - // Key code constants enum { kEscapeKeyCode = 0x35, kRCommandKeyCode = 0x36, // right command key kCommandKeyCode = 0x37, kShiftKeyCode = 0x38, kCapsLockKeyCode = 0x39, kOptionKeyCode = 0x3A, kControlKeyCode = 0x3B, kRShiftKeyCode = 0x3C, // right shift key kROptionKeyCode = 0x3D, // right option key kRControlKeyCode = 0x3E, // right control key kFnKeyCode = 0x3F, // fn key kClearKeyCode = 0x47, // function keys kF1KeyCode = 0x7A, kF2KeyCode = 0x78, kF3KeyCode = 0x63, kF4KeyCode = 0x76, kF5KeyCode = 0x60, kF6KeyCode = 0x61, kF7KeyCode = 0x62, kF8KeyCode = 0x64, kF9KeyCode = 0x65, kF10KeyCode = 0x6D, kF11KeyCode = 0x67, kF12KeyCode = 0x6F, kF13KeyCode = 0x69, kF14KeyCode = 0x6B, kF15KeyCode = 0x71, kF16KeyCode = 0x6A, kF17KeyCode = 0x40, kF18KeyCode = 0x4F, kF19KeyCode = 0x50, kF20KeyCode = 0x5A, kPrintScreenKeyCode = kF13KeyCode, kScrollLockKeyCode = kF14KeyCode, kPauseKeyCode = kF15KeyCode, // keypad kKeypad0KeyCode = 0x52, kKeypad1KeyCode = 0x53, kKeypad2KeyCode = 0x54, kKeypad3KeyCode = 0x55, kKeypad4KeyCode = 0x56, kKeypad5KeyCode = 0x57, kKeypad6KeyCode = 0x58, kKeypad7KeyCode = 0x59, kKeypad8KeyCode = 0x5B, kKeypad9KeyCode = 0x5C, // The following key codes are not defined until Mac OS X 10.5 #if MAC_OS_X_VERSION_MAX_ALLOWED <= MAC_OS_X_VERSION_10_4 kVK_ANSI_1 = 0x12, kVK_ANSI_2 = 0x13, kVK_ANSI_3 = 0x14, kVK_ANSI_4 = 0x15, kVK_ANSI_5 = 0x17, kVK_ANSI_6 = 0x16, kVK_ANSI_7 = 0x1A, kVK_ANSI_8 = 0x1C, kVK_ANSI_9 = 0x19, kVK_ANSI_0 = 0x1D, kVK_JIS_Yen = 0x5D, kVK_JIS_Underscore = 0x5E, kVK_JIS_KeypadComma = 0x5F, kVK_JIS_Eisu = 0x66, kVK_JIS_Kana = 0x68, kVK_PC_ContextMenu = 0x6E, #endif kKeypadMultiplyKeyCode = 0x43, kKeypadAddKeyCode = 0x45, kKeypadSubtractKeyCode = 0x4E, kKeypadDecimalKeyCode = 0x41, kKeypadDivideKeyCode = 0x4B, kKeypadEqualsKeyCode = 0x51, // no corresponding gecko key code kEnterKeyCode = 0x4C, kReturnKeyCode = 0x24, kPowerbookEnterKeyCode = 0x34, // Enter on Powerbook's keyboard is different kInsertKeyCode = 0x72, // also help key kDeleteKeyCode = 0x75, // also forward delete key kTabKeyCode = 0x30, kTildeKeyCode = 0x32, kBackspaceKeyCode = 0x33, kHomeKeyCode = 0x73, kEndKeyCode = 0x77, kPageUpKeyCode = 0x74, kPageDownKeyCode = 0x79, kLeftArrowKeyCode = 0x7B, kRightArrowKeyCode = 0x7C, kUpArrowKeyCode = 0x7E, kDownArrowKeyCode = 0x7D }; #define unsignedIntegerValue unsignedIntValue #define numberWithUnsignedInteger numberWithUnsignedInt #pragma mark - /* Convenience routine to go from a Gecko rect to Cocoa NSRect. * (Restored for TenFourFox 43.) * * Gecko rects (nsRect) contain an origin (x,y) in a coordinate * system with (0,0) in the top-left of the screen. Cocoa rects * (NSRect) contain an origin (x,y) in a coordinate system with * (0,0) in the bottom-left of the screen. Both nsRect and NSRect * contain width/height info, with no difference in their use. * If a Cocoa rect is from a flipped view, there is no need to * convert coordinate systems. */ #ifndef __LP64__ static inline void ConvertGeckoRectToMacRect(const nsIntRect& aRect, Rect& outMacRect) { outMacRect.left = aRect.x; outMacRect.top = aRect.y; outMacRect.right = aRect.x + aRect.width; outMacRect.bottom = aRect.y + aRect.height; } #endif // Flips a screen coordinate from a point in the cocoa coordinate system (bottom-left rect) to a point // that is a "flipped" cocoa coordinate system (starts in the top-left). static inline void FlipCocoaScreenCoordinate(NSPoint &inPoint) { inPoint.y = nsCocoaUtils::FlippedScreenY(inPoint.y); } #ifndef NS_LEOPARD_AND_LATER // Functions that we had to restore for 10.4. Damn you, Mozilla! // Maybe move these to nsCocoaUtils at some point ... static inline void GeckoRectToNSRect(const nsIntRect & inGeckoRect, NSRect & outCocoaRect) { outCocoaRect.origin.x = inGeckoRect.x; outCocoaRect.origin.y = inGeckoRect.y; outCocoaRect.size.width = inGeckoRect.width; outCocoaRect.size.height = inGeckoRect.height; } /* static inline void InitPluginEvent(nsPluginEvent &aEvent, NPCocoaEvent &aCocoaEvent) { aEvent.time = PR_IntervalNow(); aEvent.pluginEvent = (void*)&aCocoaEvent; aEvent.retargetToFocusedDocument = false; } */ static uint32_t UnderlineAttributeToTextRangeType(PRUint32 aUnderlineStyle, NSRange selRange) { #ifdef DEBUG_IME NSLog(@"****in underlineAttributeToTextRangeType = %d", aUnderlineStyle); #endif // For more info on the underline attribute, please see: // http://developer.apple.com/techpubs/macosx/Cocoa/TasksAndConcepts/ProgrammingTopics/AttributedStrings/Tasks/AccessingAttrs.html // We are not clear where the define for value 2 is right now. // To see this value in japanese ime, type 'aaaaaaaaa' and hit space to make the // ime send you some part of text in 1 (NSSingleUnderlineStyle) and some part in 2. // ftang will ask apple for more details // // It probably means show 1-pixel thickness underline vs 2-pixel thickness. uint32_t attr; if (selRange.length == 0) { switch (aUnderlineStyle) { case 1: attr = NS_TEXTRANGE_RAWINPUT; break; case 2: default: attr = NS_TEXTRANGE_SELECTEDRAWTEXT; break; } } else { switch (aUnderlineStyle) { case 1: attr = NS_TEXTRANGE_CONVERTEDTEXT; break; case 2: default: attr = NS_TEXTRANGE_SELECTEDCONVERTEDTEXT; break; } } return attr; } static uint32_t CountRanges(NSAttributedString *aString) { NS_OBJC_BEGIN_TRY_ABORT_BLOCK_RETURN; // Iterate through aString for the NSUnderlineStyleAttributeName and count the // different segments adjusting limitRange as we go. uint32_t count = 0; NSRange effectiveRange; NSRange limitRange = NSMakeRange(0, [aString length]); while (limitRange.length > 0) { [aString attribute:NSUnderlineStyleAttributeName atIndex:limitRange.location longestEffectiveRange:&effectiveRange inRange:limitRange]; limitRange = NSMakeRange(NSMaxRange(effectiveRange), NSMaxRange(limitRange) - NSMaxRange(effectiveRange)); count++; } return count; NS_OBJC_END_TRY_ABORT_BLOCK_RETURN(0); } static already_AddRefed ConvertAttributeToGeckoRange(NSAttributedString *aString, NSRange markRange, NSRange selRange, uint32_t inCount) { NS_OBJC_BEGIN_TRY_ABORT_BLOCK_NSNULL; // Convert the Cocoa range into the TextRange Array used in Gecko. // Iterate through the attributed string and map the underline attribute to Gecko IME textrange attributes. // We may need to change the code here if we change the implementation of validAttributesForMarkedText. uint32_t i = 0; NSRange effectiveRange; NSRange limitRange = NSMakeRange(0, [aString length]); RefPtr textRangeArray = new mozilla::TextRangeArray(); while ((limitRange.length > 0) && (i < inCount)) { id attributeValue = [aString attribute:NSUnderlineStyleAttributeName atIndex:limitRange.location longestEffectiveRange:&effectiveRange inRange:limitRange]; mozilla::TextRange range; range.mStartOffset = effectiveRange.location; range.mEndOffset = NSMaxRange(effectiveRange); range.mRangeType = UnderlineAttributeToTextRangeType([attributeValue intValue], selRange); textRangeArray->AppendElement(range); limitRange = NSMakeRange(NSMaxRange(effectiveRange), NSMaxRange(limitRange) - NSMaxRange(effectiveRange)); i++; } // Get current caret position. mozilla::TextRange range; range.mStartOffset = selRange.location + selRange.length; range.mEndOffset = range.mStartOffset; range.mRangeType = NS_TEXTRANGE_CARETPOSITION; textRangeArray->AppendElement(range); return textRangeArray.forget(); NS_OBJC_END_TRY_ABORT_BLOCK_NSNULL; } #endif void EnsureLogInitialized() { if (!sCocoaLog) { sCocoaLog = PR_NewLogModule("nsCocoaWidgets"); } } namespace { // Manages a texture which can resize dynamically, binds to the // LOCAL_GL_TEXTURE_RECTANGLE_ARB texture target and is automatically backed // by a power-of-two size GL texture. The latter two features are used for // compatibility with older Mac hardware which we block GL layers on. // RectTextureImages are used both for accelerated GL layers drawing and for // OMTC BasicLayers drawing. class RectTextureImage { public: explicit RectTextureImage(GLContext* aGLContext) : mGLContext(aGLContext) , mTexture(0) , mInUpdate(false) {} virtual ~RectTextureImage(); already_AddRefed BeginUpdate(const LayoutDeviceIntSize& aNewSize, const LayoutDeviceIntRegion& aDirtyRegion = LayoutDeviceIntRegion()); void EndUpdate(bool aKeepSurface = false); void UpdateIfNeeded(const LayoutDeviceIntSize& aNewSize, const LayoutDeviceIntRegion& aDirtyRegion, void (*aCallback)(gfx::DrawTarget*, const LayoutDeviceIntRegion&)) { RefPtr drawTarget = BeginUpdate(aNewSize, aDirtyRegion); if (drawTarget) { aCallback(drawTarget, GetUpdateRegion()); EndUpdate(); } } void UpdateFromCGContext(const LayoutDeviceIntSize& aNewSize, const LayoutDeviceIntRegion& aDirtyRegion, CGContextRef aCGContext); LayoutDeviceIntRegion GetUpdateRegion() { MOZ_ASSERT(mInUpdate, "update region only valid during update"); return mUpdateRegion; } void Draw(mozilla::layers::GLManager* aManager, const LayoutDeviceIntPoint& aLocation, const Matrix4x4& aTransform = Matrix4x4()); static LayoutDeviceIntSize TextureSizeForSize( const LayoutDeviceIntSize& aSize); protected: RefPtr mUpdateDrawTarget; GLContext* mGLContext; LayoutDeviceIntRegion mUpdateRegion; LayoutDeviceIntSize mUsedSize; LayoutDeviceIntSize mBufferSize; LayoutDeviceIntSize mTextureSize; GLuint mTexture; bool mInUpdate; }; // Used for OpenGL drawing from the compositor thread for OMTC BasicLayers. // We need to use OpenGL for this because there seems to be no other robust // way of drawing from a secondary thread without locking, which would cause // deadlocks in our setup. See bug 882523. class GLPresenter : public GLManager { public: static GLPresenter* CreateForWindow(nsIWidget* aWindow) { // Contrary to CompositorOGL, we allow unaccelerated OpenGL contexts to be // used. BasicCompositor only requires very basic GL functionality. RefPtr context = gl::GLContextProvider::CreateForWindow(aWindow, false); return context ? new GLPresenter(context) : nullptr; } explicit GLPresenter(GLContext* aContext); virtual ~GLPresenter(); virtual GLContext* gl() const override { return mGLContext; } virtual ShaderProgramOGL* GetProgram(GLenum aTarget, gfx::SurfaceFormat aFormat) override { MOZ_ASSERT(aTarget == LOCAL_GL_TEXTURE_RECTANGLE_ARB); MOZ_ASSERT(aFormat == gfx::SurfaceFormat::R8G8B8A8); return mRGBARectProgram; } virtual const gfx::Matrix4x4& GetProjMatrix() const override { return mProjMatrix; } virtual void ActivateProgram(ShaderProgramOGL *aProg) override { mGLContext->fUseProgram(aProg->GetProgram()); } virtual void BindAndDrawQuad(ShaderProgramOGL *aProg, const gfx::Rect& aLayerRect, const gfx::Rect& aTextureRect) override; void BeginFrame(LayoutDeviceIntSize aRenderSize); void EndFrame(); NSOpenGLContext* GetNSOpenGLContext() { return GLContextCGL::Cast(mGLContext)->GetNSOpenGLContext(); } protected: RefPtr mGLContext; nsAutoPtr mRGBARectProgram; gfx::Matrix4x4 mProjMatrix; GLuint mQuadVBO; }; } // unnamed namespace namespace mozilla { struct SwipeEventQueue { SwipeEventQueue(uint32_t aAllowedDirections, uint64_t aInputBlockId) : allowedDirections(aAllowedDirections) , inputBlockId(aInputBlockId) {} nsTArray queuedEvents; uint32_t allowedDirections; uint64_t inputBlockId; }; } // namespace mozilla #pragma mark - nsChildView::nsChildView() : nsBaseWidget() , mView(nullptr) , mParentView(nullptr) , mParentWidget(nullptr) , mViewTearDownLock("ChildViewTearDown") , mEffectsLock("WidgetEffects") , mShowsResizeIndicator(false) , mHasRoundedBottomCorners(false) , mIsCoveringTitlebar(false) , mIsFullscreen(false) , mTitlebarCGContext(nullptr) , mBackingScaleFactor(0.0) , mVisible(false) , mDrawing(false) , mIsDispatchPaint(false) { EnsureLogInitialized(); if (nsCocoaFeatures::OnLeopardOrLater() && !Leopard_TISCopyCurrentKeyboardLayoutInputSource) { // This library would already be open for LMGetKbdType (and probably other // symbols), so merely using RTLD_DEFAULT in dlsym would be sufficient, // but man dlsym says: "all mach-o images in the process (except ...) are // searched in the order they were loaded. This can be a costly search // and should be avoided." void* hitoolboxHandle = dlopen("/System/Library/Frameworks/Carbon.framework/Frameworks/HIToolbox.framework/Versions/A/HIToolbox", RTLD_LAZY); if (hitoolboxHandle) { *(void **)(&Leopard_TISCopyCurrentKeyboardInputSource) = dlsym(hitoolboxHandle, "TISCopyCurrentKeyboardInputSource"); *(void **)(&Leopard_TISCopyCurrentKeyboardLayoutInputSource) = dlsym(hitoolboxHandle, "TISCopyCurrentKeyboardLayoutInputSource"); *(void **)(&Leopard_TISGetInputSourceProperty) = dlsym(hitoolboxHandle, "TISGetInputSourceProperty"); *(void **)(&Leopard_TISCreateInputSourceList) = dlsym(hitoolboxHandle, "TISCreateInputSourceList"); kOurTISPropertyUnicodeKeyLayoutData = *static_cast(dlsym(hitoolboxHandle, "kTISPropertyUnicodeKeyLayoutData")); kOurTISPropertyInputSourceID = *static_cast(dlsym(hitoolboxHandle, "kTISPropertyInputSourceID")); kOurTISPropertyInputSourceLanguages = *static_cast(dlsym(hitoolboxHandle, "kTISPropertyInputSourceLanguages")); } } } nsChildView::~nsChildView() { ReleaseTitlebarCGContext(); if (mSwipeTracker) { mSwipeTracker->Destroy(); mSwipeTracker = nullptr; } // Notify the children that we're gone. childView->ResetParent() can change // our list of children while it's being iterated, so the way we iterate the // list must allow for this. for (nsIWidget* kid = mLastChild; kid;) { nsChildView* childView = static_cast(kid); kid = kid->GetPrevSibling(); childView->ResetParent(); } NS_WARN_IF_FALSE(mOnDestroyCalled, "nsChildView object destroyed without calling Destroy()"); DestroyCompositor(); if (mAPZC && gfxPrefs::AsyncPanZoomSeparateEventThread()) { gNumberOfWidgetsNeedingEventThread--; if (gNumberOfWidgetsNeedingEventThread == 0) { [EventThreadRunner stop]; } } // An nsChildView object that was in use can be destroyed without Destroy() // ever being called on it. So we also need to do a quick, safe cleanup // here (it's too late to just call Destroy(), which can cause crashes). // It's particularly important to make sure widgetDestroyed is called on our // mView -- this method NULLs mView's mGeckoChild, and NULL checks on // mGeckoChild are used throughout the ChildView class to tell if it's safe // to use a ChildView object. [mView widgetDestroyed]; // Safe if mView is nil. mParentWidget = nil; TearDownView(); // Safe if called twice. } void nsChildView::ReleaseTitlebarCGContext() { if (mTitlebarCGContext) { CGContextRelease(mTitlebarCGContext); mTitlebarCGContext = nullptr; } } nsresult nsChildView::Create(nsIWidget* aParent, nsNativeWidget aNativeParent, const LayoutDeviceIntRect& aRect, nsWidgetInitData* aInitData) { NS_OBJC_BEGIN_TRY_ABORT_BLOCK_NSRESULT; // Because the hidden window is created outside of an event loop, // we need to provide an autorelease pool to avoid leaking cocoa objects // (see bug 559075). nsAutoreleasePool localPool; // See NSView (MethodSwizzling) below. if (nsCocoaFeatures::OnLeopardOrLater() && !gChildViewMethodsSwizzled) { nsToolkit::SwizzleMethods([NSView class], @selector(mouseDownCanMoveWindow), @selector(nsChildView_NSView_mouseDownCanMoveWindow)); #ifdef __LP64__ if (nsCocoaFeatures::OnLionOrLater()) { nsToolkit::SwizzleMethods([NSEvent class], @selector(addLocalMonitorForEventsMatchingMask:handler:), @selector(nsChildView_NSEvent_addLocalMonitorForEventsMatchingMask:handler:), true); nsToolkit::SwizzleMethods([NSEvent class], @selector(removeMonitor:), @selector(nsChildView_NSEvent_removeMonitor:), true); } #endif gChildViewMethodsSwizzled = true; } mBounds = aRect.ToUnknownRect(); // Ensure that the toolkit is created. nsToolkit::GetToolkit(); BaseCreate(aParent, aRect, aInitData); // inherit things from the parent view and create our parallel // NSView in the Cocoa display system mParentView = nil; if (aParent) { // inherit the top-level window. NS_NATIVE_WIDGET is always a NSView // regardless of if we're asking a window or a view (for compatibility // with windows). mParentView = (NSView*)aParent->GetNativeData(NS_NATIVE_WIDGET); mParentWidget = aParent; } else { // This is the normal case. When we're the root widget of the view hiararchy, // aNativeParent will be the contentView of our window, since that's what // nsCocoaWindow returns when asked for an NS_NATIVE_VIEW. mParentView = reinterpret_cast*>(aNativeParent); } // create our parallel NSView and hook it up to our parent. Recall // that NS_NATIVE_WIDGET is the NSView. CGFloat scaleFactor = 1.0f; //nsCocoaUtils::GetBackingScaleFactor(mParentView); NSRect r = nsCocoaUtils::DevPixelsToCocoaPoints( LayoutDeviceIntRect::FromUnknownRect(mBounds)); mView = [(NSView*)CreateCocoaView(r) retain]; if (!mView) { return NS_ERROR_FAILURE; } // If this view was created in a Gecko view hierarchy, the initial state // is hidden. If the view is attached only to a native NSView but has // no Gecko parent (as in embedding), the initial state is visible. if (mParentWidget) [mView setHidden:YES]; else mVisible = true; // Hook it up in the NSView hierarchy. if (mParentView) { [mParentView addSubview:mView]; } // if this is a ChildView, make sure that our per-window data // is set up if ([mView isKindOfClass:[ChildView class]]) [[WindowDataMap sharedWindowDataMap] ensureDataForWindow:[mView window]]; #if(0) NS_ASSERTION(!mTextInputHandler, "mTextInputHandler has already existed"); mTextInputHandler = new TextInputHandler(this, mView); #endif mPluginFocused = false; return NS_OK; NS_OBJC_END_TRY_ABORT_BLOCK_NSRESULT; } // Creates the appropriate child view. Override to create something other than // our |ChildView| object. Autoreleases, so caller must retain. NSView* nsChildView::CreateCocoaView(NSRect inFrame) { NS_OBJC_BEGIN_TRY_ABORT_BLOCK_NIL; return [[[ChildView alloc] initWithFrame:inFrame geckoChild:this] autorelease]; NS_OBJC_END_TRY_ABORT_BLOCK_NIL; } void nsChildView::TearDownView() { NS_OBJC_BEGIN_TRY_ABORT_BLOCK; if (!mView) return; NSWindow* win = [mView window]; NSResponder* responder = [win firstResponder]; // We're being unhooked from the view hierarchy, don't leave our view // or a child view as the window first responder. if (responder && [responder isKindOfClass:[NSView class]] && [(NSView*)responder isDescendantOf:mView]) { [win makeFirstResponder:[mView superview]]; } // If mView is win's contentView, win (mView's NSWindow) "owns" mView -- // win has retained mView, and will detach it from the view hierarchy and // release it when necessary (when win is itself destroyed (in a call to // [win dealloc])). So all we need to do here is call [mView release] (to // match the call to [mView retain] in nsChildView::StandardCreate()). // Also calling [mView removeFromSuperviewWithoutNeedingDisplay] causes // mView to be released again and dealloced, while remaining win's // contentView. So if we do that here, win will (for a short while) have // an invalid contentView (for the consequences see bmo bugs 381087 and // 374260). if ([mView isEqual:[win contentView]]) { [mView release]; } else { // Stop NSView hierarchy being changed during [ChildView drawRect:] [mView performSelectorOnMainThread:@selector(delayedTearDown) withObject:nil waitUntilDone:false]; } mView = nil; NS_OBJC_END_TRY_ABORT_BLOCK; } nsCocoaWindow* nsChildView::GetXULWindowWidget() const { id windowDelegate = [[mView window] delegate]; if (windowDelegate && [windowDelegate isKindOfClass:[WindowDelegate class]]) { return [(WindowDelegate *)windowDelegate geckoWidget]; } return nullptr; } NS_IMETHODIMP nsChildView::Destroy() { NS_OBJC_BEGIN_TRY_ABORT_BLOCK_NSRESULT; // Make sure that no composition is in progress while disconnecting // ourselves from the view. MutexAutoLock lock(mViewTearDownLock); if (mOnDestroyCalled) return NS_OK; mOnDestroyCalled = true; [mView widgetDestroyed]; nsBaseWidget::Destroy(); NotifyWindowDestroyed(); mParentWidget = nil; TearDownView(); nsBaseWidget::OnDestroy(); return NS_OK; NS_OBJC_END_TRY_ABORT_BLOCK_NSRESULT; } #pragma mark - #if 0 static void PrintViewHierarchy(NSView *view) { while (view) { NSLog(@" view is %x, frame %@", view, NSStringFromRect([view frame])); view = [view superview]; } } #endif // Return native data according to aDataType void* nsChildView::GetNativeData(uint32_t aDataType) { NS_OBJC_BEGIN_TRY_ABORT_BLOCK_NSNULL; void* retVal = nullptr; switch (aDataType) { case NS_NATIVE_WIDGET: case NS_NATIVE_DISPLAY: retVal = (void*)mView; break; case NS_NATIVE_WINDOW: retVal = [mView window]; break; case NS_NATIVE_GRAPHIC: NS_ERROR("Requesting NS_NATIVE_GRAPHIC on a Mac OS X child view!"); retVal = nullptr; break; case NS_NATIVE_OFFSETX: retVal = 0; break; case NS_NATIVE_OFFSETY: retVal = 0; break; case NS_RAW_NATIVE_IME_CONTEXT: retVal = [mView inputContext]; // If input context isn't available on this widget, we should set |this| // instead of nullptr since if this returns nullptr, IMEStateManager // cannot manage composition with TextComposition instance. Although, // this case shouldn't occur. if (NS_WARN_IF(!retVal)) { retVal = this; } break; } return retVal; NS_OBJC_END_TRY_ABORT_BLOCK_NSNULL; } #pragma mark - nsTransparencyMode nsChildView::GetTransparencyMode() { NS_OBJC_BEGIN_TRY_ABORT_BLOCK_RETURN; nsCocoaWindow* windowWidget = GetXULWindowWidget(); return windowWidget ? windowWidget->GetTransparencyMode() : eTransparencyOpaque; NS_OBJC_END_TRY_ABORT_BLOCK_RETURN(eTransparencyOpaque); } // This is called by nsContainerFrame on the root widget for all window types // except popup windows (when nsCocoaWindow::SetTransparencyMode is used instead). void nsChildView::SetTransparencyMode(nsTransparencyMode aMode) { NS_OBJC_BEGIN_TRY_ABORT_BLOCK; nsCocoaWindow* windowWidget = GetXULWindowWidget(); if (windowWidget) { windowWidget->SetTransparencyMode(aMode); } NS_OBJC_END_TRY_ABORT_BLOCK; } bool nsChildView::IsVisible() const { NS_OBJC_BEGIN_TRY_ABORT_BLOCK_RETURN; if (MOZ_UNLIKELY(!mVisible || !GetXULWindowWidget()->IsVisible())) { return false; } // mVisible does not accurately reflect the state of a hidden tabbed view // so verify that the view has a window as well // then check native widget hierarchy visibility return ([mView window] != nil) && !NSIsEmptyRect([mView visibleRect]); NS_OBJC_END_TRY_ABORT_BLOCK_RETURN(false); } // Some NSView methods (e.g. setFrame and setHidden) invalidate the view's // bounds in our window. However, we don't want these invalidations because // they are unnecessary and because they actually slow us down since we // block on the compositor inside drawRect. // When we actually need something invalidated, there will be an explicit call // to Invalidate from Gecko, so turning these automatic invalidations off // won't hurt us in the non-OMTC case. // The invalidations inside these NSView methods happen via a call to the // private method -[NSWindow _setNeedsDisplayInRect:]. Our BaseWindow // implementation of that method is augmented to let us ignore those calls // using -[BaseWindow disable/enableSetNeedsDisplay]. // For 10.4, we just wrap calls to this together. #if(0) static void ManipulateViewWithoutNeedingDisplay(NSView* aView, void (^aCallback)()) { BaseWindow* win = nil; if ([[aView window] isKindOfClass:[BaseWindow class]]) { win = (BaseWindow*)[aView window]; } [win disableSetNeedsDisplay]; aCallback(); [win enableSetNeedsDisplay]; } #else #define MVWND(x,y) { BaseWindow* win = nil; if ([[x window] isKindOfClass:[BaseWindow class]]) { win = (BaseWindow*)[x window]; } [win disableSetNeedsDisplay]; y; [win enableSetNeedsDisplay]; } #endif // Hide or show this component NS_IMETHODIMP nsChildView::Show(bool aState) { NS_OBJC_BEGIN_TRY_ABORT_BLOCK_NSRESULT; if (aState != mVisible) { // Provide an autorelease pool because this gets called during startup // on the "hidden window", resulting in cocoa object leakage if there's // no pool in place. nsAutoreleasePool localPool; #if(0) ManipulateViewWithoutNeedingDisplay(mView, ^{ [mView setHidden:!aState]; }); #else MVWND(mView, [mView setHidden:!aState]); #endif mVisible = aState; } return NS_OK; NS_OBJC_END_TRY_ABORT_BLOCK_NSRESULT; } // Change the parent of this widget NS_IMETHODIMP nsChildView::SetParent(nsIWidget* aNewParent) { NS_OBJC_BEGIN_TRY_ABORT_BLOCK_NSRESULT; if (mOnDestroyCalled) return NS_OK; nsCOMPtr kungFuDeathGrip(this); if (mParentWidget) { mParentWidget->RemoveChild(this); } if (aNewParent) { ReparentNativeWidget(aNewParent); } else { [mView removeFromSuperview]; mParentView = nil; } mParentWidget = aNewParent; if (mParentWidget) { mParentWidget->AddChild(this); } return NS_OK; NS_OBJC_END_TRY_ABORT_BLOCK_NSRESULT; } NS_IMETHODIMP nsChildView::ReparentNativeWidget(nsIWidget* aNewParent) { NS_OBJC_BEGIN_TRY_ABORT_BLOCK_NSRESULT; NS_PRECONDITION(aNewParent, ""); if (mOnDestroyCalled) return NS_OK; NSView* newParentView = (NSView*)aNewParent->GetNativeData(NS_NATIVE_WIDGET); NS_ENSURE_TRUE(newParentView, NS_ERROR_FAILURE); // we hold a ref to mView, so this is safe [mView removeFromSuperview]; mParentView = newParentView; [mParentView addSubview:mView]; return NS_OK; NS_OBJC_END_TRY_ABORT_BLOCK_NSRESULT; } void nsChildView::ResetParent() { if (!mOnDestroyCalled) { if (mParentWidget) mParentWidget->RemoveChild(this); if (mView) [mView removeFromSuperview]; } mParentWidget = nullptr; } nsIWidget* nsChildView::GetParent() { return mParentWidget; } float nsChildView::GetDPI() { NSWindow* window = [mView window]; if (window && [window isKindOfClass:[BaseWindow class]]) { return [(BaseWindow*)window getDPI]; } return 96.0; } NS_IMETHODIMP nsChildView::Enable(bool aState) { return NS_OK; } bool nsChildView::IsEnabled() const { return true; } NS_IMETHODIMP nsChildView::SetFocus(bool aRaise) { NS_OBJC_BEGIN_TRY_ABORT_BLOCK_NSRESULT; NSWindow* window = [mView window]; if (window) [window makeFirstResponder:mView]; return NS_OK; NS_OBJC_END_TRY_ABORT_BLOCK_NSRESULT; } // Override to set the cursor on the mac NS_IMETHODIMP nsChildView::SetCursor(nsCursor aCursor) { NS_OBJC_BEGIN_TRY_ABORT_BLOCK_NSRESULT; // this should nop out (Cameron) if ([mView isDragInProgress]) return NS_OK; // Don't change the cursor during dragging. nsBaseWidget::SetCursor(aCursor); return [[nsCursorManager sharedInstance] setCursor:aCursor]; NS_OBJC_END_TRY_ABORT_BLOCK_NSRESULT; } // implement to fix "hidden virtual function" warning NS_IMETHODIMP nsChildView::SetCursor(imgIContainer* aCursor, uint32_t aHotspotX, uint32_t aHotspotY) { NS_OBJC_BEGIN_TRY_ABORT_BLOCK_NSRESULT; nsBaseWidget::SetCursor(aCursor, aHotspotX, aHotspotY); return [[nsCursorManager sharedInstance] setCursorWithImage:aCursor hotSpotX:aHotspotX hotSpotY:aHotspotY]; NS_OBJC_END_TRY_ABORT_BLOCK_NSRESULT; } #pragma mark - // Get this component dimension NS_IMETHODIMP nsChildView::GetBounds(LayoutDeviceIntRect& aRect) { aRect = !mView ? LayoutDeviceIntRect::FromUnknownRect(mBounds) : CocoaPointsToDevPixels([mView frame]); return NS_OK; } NS_IMETHODIMP nsChildView::GetClientBounds(mozilla::LayoutDeviceIntRect& aRect) { GetBounds(aRect); if (!mParentWidget) { // For top level widgets we want the position on screen, not the position // of this view inside the window. aRect.MoveTo(WidgetToScreenOffset()); } return NS_OK; } NS_IMETHODIMP nsChildView::GetScreenBounds(LayoutDeviceIntRect& aRect) { GetBounds(aRect); aRect.MoveTo(WidgetToScreenOffset()); return NS_OK; } #if(0) double nsChildView::GetDefaultScaleInternal() { return BackingScaleFactor(); } CGFloat nsChildView::BackingScaleFactor() const { if (mBackingScaleFactor > 0.0) { return mBackingScaleFactor; } if (!mView) { return 1.0; } mBackingScaleFactor = nsCocoaUtils::GetBackingScaleFactor(mView); return mBackingScaleFactor; } void nsChildView::BackingScaleFactorChanged() { CGFloat newScale = nsCocoaUtils::GetBackingScaleFactor(mView); // ignore notification if it hasn't really changed (or maybe we have // disabled HiDPI mode via prefs) if (mBackingScaleFactor == newScale) { return; } mBackingScaleFactor = newScale; if (mWidgetListener && !mWidgetListener->GetXULWindow()) { nsIPresShell* presShell = mWidgetListener->GetPresShell(); if (presShell) { presShell->BackingScaleFactorChanged(); } } } int32_t nsChildView::RoundsWidgetCoordinatesTo() { if (BackingScaleFactor() == 2.0) { return 2; } return 1; } #endif NS_IMETHODIMP nsChildView::ConstrainPosition(bool aAllowSlop, int32_t *aX, int32_t *aY) { return NS_OK; } // Move this component, aX and aY are in the parent widget coordinate system NS_IMETHODIMP nsChildView::Move(double aX, double aY) { NS_OBJC_BEGIN_TRY_ABORT_BLOCK_NSRESULT; int32_t x = NSToIntRound(aX); int32_t y = NSToIntRound(aY); if (!mView || (mBounds.x == x && mBounds.y == y)) return NS_OK; mBounds.x = x; mBounds.y = y; #if(0) ManipulateViewWithoutNeedingDisplay(mView, ^{ [mView setFrame:UntypedDevPixelsToCocoaPoints(mBounds)]; }); #else MVWND(mView, [mView setFrame:UntypedDevPixelsToCocoaPoints(mBounds)]); #endif NotifyRollupGeometryChange(); ReportMoveEvent(); return NS_OK; NS_OBJC_END_TRY_ABORT_BLOCK_NSRESULT; } NS_IMETHODIMP nsChildView::Resize(double aWidth, double aHeight, bool aRepaint) { NS_OBJC_BEGIN_TRY_ABORT_BLOCK_NSRESULT; int32_t width = NSToIntRound(aWidth); int32_t height = NSToIntRound(aHeight); if (!mView || (mBounds.width == width && mBounds.height == height)) return NS_OK; mBounds.width = width; mBounds.height = height; #if(0) ManipulateViewWithoutNeedingDisplay(mView, ^{ [mView setFrame:UntypedDevPixelsToCocoaPoints(mBounds)]; }); #else MVWND(mView, [mView setFrame:UntypedDevPixelsToCocoaPoints(mBounds)]); #endif if (mVisible && aRepaint) [mView setNeedsDisplay:YES]; NotifyRollupGeometryChange(); ReportSizeEvent(); return NS_OK; NS_OBJC_END_TRY_ABORT_BLOCK_NSRESULT; } NS_IMETHODIMP nsChildView::Resize(double aX, double aY, double aWidth, double aHeight, bool aRepaint) { NS_OBJC_BEGIN_TRY_ABORT_BLOCK_NSRESULT; int32_t x = NSToIntRound(aX); int32_t y = NSToIntRound(aY); int32_t width = NSToIntRound(aWidth); int32_t height = NSToIntRound(aHeight); BOOL isMoving = (mBounds.x != x || mBounds.y != y); BOOL isResizing = (mBounds.width != width || mBounds.height != height); if (!mView || (!isMoving && !isResizing)) return NS_OK; if (isMoving) { mBounds.x = x; mBounds.y = y; } if (isResizing) { mBounds.width = width; mBounds.height = height; } #if(0) ManipulateViewWithoutNeedingDisplay(mView, ^{ [mView setFrame:UntypedDevPixelsToCocoaPoints(mBounds)]; }); #else MVWND(mView, [mView setFrame:UntypedDevPixelsToCocoaPoints(mBounds)]); #endif if (mVisible && aRepaint) [mView setNeedsDisplay:YES]; NotifyRollupGeometryChange(); if (isMoving) { ReportMoveEvent(); if (mOnDestroyCalled) return NS_OK; } if (isResizing) ReportSizeEvent(); return NS_OK; NS_OBJC_END_TRY_ABORT_BLOCK_NSRESULT; } static const int32_t resizeIndicatorWidth = 15; static const int32_t resizeIndicatorHeight = 15; bool nsChildView::ShowsResizeIndicator(LayoutDeviceIntRect* aResizerRect) { NSView *topLevelView = mView, *superView = nil; while ((superView = [topLevelView superview])) topLevelView = superView; if (![[topLevelView window] showsResizeIndicator] || !([[topLevelView window] styleMask] & NSResizableWindowMask)) return false; if (aResizerRect) { NSSize bounds = [topLevelView bounds].size; NSPoint corner = NSMakePoint(bounds.width, [topLevelView isFlipped] ? bounds.height : 0); corner = [topLevelView convertPoint:corner toView:mView]; aResizerRect->SetRect(NSToIntRound(corner.x) - resizeIndicatorWidth, NSToIntRound(corner.y) - resizeIndicatorHeight, resizeIndicatorWidth, resizeIndicatorHeight); } return true; } // This is needed for 10.4's SynthesizeNativeKeyEvent. static NSString* ToNSString(const nsAString& aString) { return [NSString stringWithCharacters:aString.BeginReading() length:aString.Length()]; } struct KeyboardLayoutOverride { int32_t mKeyboardLayout; bool mOverrideEnabled; }; static KeyboardLayoutOverride gOverrideKeyboardLayout; static const uint32_t sModifierFlagMap[][2] = { { nsIWidget::CAPS_LOCK, NSAlphaShiftKeyMask }, { nsIWidget::SHIFT_L, NSShiftKeyMask }, { nsIWidget::SHIFT_R, NSShiftKeyMask }, { nsIWidget::CTRL_L, NSControlKeyMask }, { nsIWidget::CTRL_R, NSControlKeyMask }, { nsIWidget::ALT_L, NSAlternateKeyMask }, { nsIWidget::ALT_R, NSAlternateKeyMask }, { nsIWidget::COMMAND_L, NSCommandKeyMask }, { nsIWidget::COMMAND_R, NSCommandKeyMask }, { nsIWidget::NUMERIC_KEY_PAD, NSNumericPadKeyMask }, { nsIWidget::HELP, NSHelpKeyMask }, { nsIWidget::FUNCTION, NSFunctionKeyMask } }; nsresult nsChildView::SynthesizeNativeKeyEvent(int32_t aNativeKeyboardLayout, int32_t aNativeKeyCode, uint32_t aModifierFlags, const nsAString& aCharacters, const nsAString& aUnmodifiedCharacters, nsIObserver* aObserver) { AutoObserverNotifier notifier(aObserver, "keyevent"); #if(0) return mTextInputHandler->SynthesizeNativeKeyEvent(aNativeKeyboardLayout, aNativeKeyCode, aModifierFlags, aCharacters, aUnmodifiedCharacters); #else // Use the Mozilla 7 code. NS_OBJC_BEGIN_TRY_ABORT_BLOCK_NSRESULT; uint32_t modifierFlags = 0; for (uint32_t i = 0; i < 12; ++i) { // NS_ARRAY_LENGTH(sModifierFlagMap); ++i) { if (aModifierFlags & sModifierFlagMap[i][0]) { modifierFlags |= sModifierFlagMap[i][1]; } } int windowNumber = [[mView window] windowNumber]; BOOL sendFlagsChangedEvent = NO; switch (aNativeKeyCode) { case kCapsLockKeyCode: case kRCommandKeyCode: case kCommandKeyCode: case kShiftKeyCode: case kOptionKeyCode: case kControlKeyCode: case kRShiftKeyCode: case kROptionKeyCode: case kRControlKeyCode: // XXX: kFnKeyCode probably should NOT be here? sendFlagsChangedEvent = YES; } NSEventType eventType = sendFlagsChangedEvent ? NSFlagsChanged : NSKeyDown; NSEvent* downEvent = [NSEvent keyEventWithType:eventType location:NSMakePoint(0,0) modifierFlags:modifierFlags timestamp:0 windowNumber:windowNumber context:[NSGraphicsContext currentContext] characters:ToNSString(aCharacters) charactersIgnoringModifiers:ToNSString(aUnmodifiedCharacters) isARepeat:NO keyCode:aNativeKeyCode]; NSEvent* upEvent = sendFlagsChangedEvent ? nil : [ChildView makeNewCocoaEventWithType:NSKeyUp fromEvent:downEvent]; if (downEvent && (sendFlagsChangedEvent || upEvent)) { KeyboardLayoutOverride currentLayout = gOverrideKeyboardLayout; gOverrideKeyboardLayout.mKeyboardLayout = aNativeKeyboardLayout; gOverrideKeyboardLayout.mOverrideEnabled = true; [NSApp sendEvent:downEvent]; if (upEvent) [NSApp sendEvent:upEvent]; // processKeyDownEvent and keyUp block exceptions so we're sure to // reach here to restore gOverrideKeyboardLayout gOverrideKeyboardLayout = currentLayout; } return NS_OK; NS_OBJC_END_TRY_ABORT_BLOCK_NSRESULT; #endif } nsresult nsChildView::SynthesizeNativeMouseEvent(LayoutDeviceIntPoint aPoint, uint32_t aNativeMessage, uint32_t aModifierFlags, nsIObserver* aObserver) { NS_OBJC_BEGIN_TRY_ABORT_BLOCK_NSRESULT; AutoObserverNotifier notifier(aObserver, "mouseevent"); #if(0) NSPoint pt = nsCocoaUtils::DevPixelsToCocoaPoints(aPoint, BackingScaleFactor()); // Move the mouse cursor to the requested position and reconnect it to the mouse. CGWarpMouseCursorPosition(NSPointToCGPoint(pt)); CGAssociateMouseAndMouseCursorPosition(true); // aPoint is given with the origin on the top left, but convertScreenToBase // expects a point in a coordinate system that has its origin on the bottom left. NSPoint screenPoint = NSMakePoint(pt.x, nsCocoaUtils::FlippedScreenY(pt.y)); #else // Use the simpler code from before; it's slightly faster. #ifdef DEBUG fprintf(stderr, "Sending Mouse event %i to %i\n", aNativeMessage, [[mView window] windowNumber]); #endif // Move the mouse cursor to the requested position and reconnect it to // the mouse. CGWarpMouseCursorPosition(CGPointMake(aPoint.x, aPoint.y)); CGAssociateMouseAndMouseCursorPosition(true); // aPoint is given with the origin on the top left, but convertScreenToBase // expects a point in a coordinate system that has its origin on the bottom // left. NSPoint screenPoint = NSMakePoint(aPoint.x, [[NSScreen mainScreen] frame].size.height - aPoint.y); #endif NSPoint windowPoint = [[mView window] convertScreenToBase:screenPoint]; NSEvent* event = [NSEvent mouseEventWithType:(NSEventType)aNativeMessage location:windowPoint modifierFlags:aModifierFlags #if(0) timestamp:[[NSProcessInfo processInfo] systemUptime] #else timestamp:[NSDate timeIntervalSinceReferenceDate] #endif windowNumber:[[mView window] windowNumber] context:nil eventNumber:0 clickCount:1 pressure:0.0]; if (!event) return NS_ERROR_FAILURE; // We don't have NSTrackingArea in 10.4. #if(0) if ([[mView window] isKindOfClass:[BaseWindow class]]) { // Tracking area events don't end up in their tracking areas when sent // through [NSApp sendEvent:], so pass them directly to the right methods. BaseWindow* window = (BaseWindow*)[mView window]; if (aNativeMessage == NSMouseEntered) { [window mouseEntered:event]; return NS_OK; } if (aNativeMessage == NSMouseExited) { [window mouseExited:event]; return NS_OK; } if (aNativeMessage == NSMouseMoved) { [window mouseMoved:event]; return NS_OK; } } #endif [NSApp sendEvent:event]; return NS_OK; NS_OBJC_END_TRY_ABORT_BLOCK_NSRESULT; } nsresult nsChildView::SynthesizeNativeMouseScrollEvent(mozilla::LayoutDeviceIntPoint aPoint, uint32_t aNativeMessage, double aDeltaX, double aDeltaY, double aDeltaZ, uint32_t aModifierFlags, uint32_t aAdditionalFlags, nsIObserver* aObserver) { NS_OBJC_BEGIN_TRY_ABORT_BLOCK_NSRESULT; AutoObserverNotifier notifier(aObserver, "mousescrollevent"); NSPoint pt = nsCocoaUtils::DevPixelsToCocoaPoints(aPoint); // Move the mouse cursor to the requested position and reconnect it to the mouse. #if(0) CGWarpMouseCursorPosition(NSPointToCGPoint(pt)); CGAssociateMouseAndMouseCursorPosition(true); // Mostly copied from http://stackoverflow.com/a/6130349 CGScrollEventUnit units = (aAdditionalFlags & nsIDOMWindowUtils::MOUSESCROLL_SCROLL_LINES) ? kCGScrollEventUnitLine : kCGScrollEventUnitPixel; CGEventRef cgEvent = CGEventCreateScrollWheelEvent(NULL, units, 3, aDeltaY, aDeltaX, aDeltaZ); if (!cgEvent) { return NS_ERROR_FAILURE; } CGEventPost(kCGHIDEventTap, cgEvent); CFRelease(cgEvent); #else CGWarpMouseCursorPosition(CGPointMake(aPoint.x, aPoint.y)); CGAssociateMouseAndMouseCursorPosition(true); // Use the deprecated 10.4 CGPostScrollWheelEvent. // Note that this can't cope with pixel scrolling, but we shouldn't // generate such events with the 10.4 SDK either. if (aAdditionalFlags & nsIDOMWindowUtils::MOUSESCROLL_SCROLL_LINES) { // We don't support deltaZ, so report only two axes. (It might work?) NS_ASSERTION((aDeltaZ == 0.0), "Generated a Z-delta scroll event"); if (CGPostScrollWheelEvent(2, aDeltaY, aDeltaX) != kCGErrorSuccess) return NS_ERROR_FAILURE; } else { NS_WARNING("Received/ignored a pixel scrolling event to SynthesizeNativeMouseScrollEvent"); } #endif return NS_OK; NS_OBJC_END_TRY_ABORT_BLOCK_NSRESULT; } // First argument has to be an NSMenu representing the application's top-level // menu bar. The returned item is *not* retained. static NSMenuItem* NativeMenuItemWithLocation(NSMenu* menubar, NSString* locationString) { NSArray* indexes = [locationString componentsSeparatedByString:@"|"]; unsigned int indexCount = [indexes count]; if (indexCount == 0) return nil; NSMenu* currentSubmenu = [NSApp mainMenu]; for (unsigned int i = 0; i < indexCount; i++) { int targetIndex; // We remove the application menu from consideration for the top-level menu if (i == 0) targetIndex = [[indexes objectAtIndex:i] intValue] + 1; else targetIndex = [[indexes objectAtIndex:i] intValue]; int itemCount = [currentSubmenu numberOfItems]; if (targetIndex < itemCount) { NSMenuItem* menuItem = [currentSubmenu itemAtIndex:targetIndex]; // if this is the last index just return the menu item if (i == (indexCount - 1)) return menuItem; // if this is not the last index find the submenu and keep going if ([menuItem hasSubmenu]) currentSubmenu = [menuItem submenu]; else return nil; } } return nil; } // Used for testing native menu system structure and event handling. NS_IMETHODIMP nsChildView::ActivateNativeMenuItemAt(const nsAString& indexString) { NS_OBJC_BEGIN_TRY_ABORT_BLOCK_NSRESULT; NSString* locationString = [NSString stringWithCharacters:reinterpret_cast(indexString.BeginReading()) length:indexString.Length()]; NSMenuItem* item = NativeMenuItemWithLocation([NSApp mainMenu], locationString); // We can't perform an action on an item with a submenu, that will raise // an obj-c exception. if (item && ![item hasSubmenu]) { NSMenu* parent = [item menu]; if (parent) { // NSLog(@"Performing action for native menu item titled: %@\n", // [[currentSubmenu itemAtIndex:targetIndex] title]); [parent performActionForItemAtIndex:[parent indexOfItem:item]]; return NS_OK; } } return NS_ERROR_FAILURE; NS_OBJC_END_TRY_ABORT_BLOCK_NSRESULT; } // Used for testing native menu system structure and event handling. NS_IMETHODIMP nsChildView::ForceUpdateNativeMenuAt(const nsAString& indexString) { NS_OBJC_BEGIN_TRY_ABORT_BLOCK_NSRESULT; nsCocoaWindow *widget = GetXULWindowWidget(); if (widget) { nsMenuBarX* mb = widget->GetMenuBar(); if (mb) { if (indexString.IsEmpty()) mb->ForceNativeMenuReload(); else mb->ForceUpdateNativeMenuAt(indexString); } } return NS_OK; NS_OBJC_END_TRY_ABORT_BLOCK_NSRESULT; } #pragma mark - #ifdef INVALIDATE_DEBUGGING static Boolean KeyDown(const UInt8 theKey) { KeyMap map; GetKeys(map); return ((*((UInt8 *)map + (theKey >> 3)) >> (theKey & 7)) & 1) != 0; } static Boolean caps_lock() { return KeyDown(0x39); } static void blinkRect(Rect* r) { StRegionFromPool oldClip; if (oldClip != NULL) ::GetClip(oldClip); ::ClipRect(r); ::InvertRect(r); UInt32 end = ::TickCount() + 5; while (::TickCount() < end) ; ::InvertRect(r); if (oldClip != NULL) ::SetClip(oldClip); } static void blinkRgn(RgnHandle rgn) { StRegionFromPool oldClip; if (oldClip != NULL) ::GetClip(oldClip); ::SetClip(rgn); ::InvertRgn(rgn); UInt32 end = ::TickCount() + 5; while (::TickCount() < end) ; ::InvertRgn(rgn); if (oldClip != NULL) ::SetClip(oldClip); } #endif // Invalidate this component's visible area NS_IMETHODIMP nsChildView::Invalidate(const LayoutDeviceIntRect& aRect) { NS_OBJC_BEGIN_TRY_ABORT_BLOCK_NSRESULT; if (!mView || !mVisible) return NS_OK; NS_ASSERTION(GetLayerManager()->GetBackendType() != LayersBackend::LAYERS_CLIENT, "Shouldn't need to invalidate with accelerated OMTC layers!"); if ([NSView focusView]) { // if a view is focussed (i.e. being drawn), then postpone the invalidate so that we // don't lose it. [mView setNeedsPendingDisplayInRect:DevPixelsToCocoaPoints(aRect)]; } else { [mView setNeedsDisplayInRect:DevPixelsToCocoaPoints(aRect)]; } return NS_OK; NS_OBJC_END_TRY_ABORT_BLOCK_NSRESULT; } bool nsChildView::ComputeShouldAccelerate() { // Don't use OpenGL for transparent windows or for popup windows. if (!mView || ![[mView window] isOpaque] || [[mView window] isKindOfClass:[PopupWindow class]]) return false; return nsBaseWidget::ComputeShouldAccelerate(); } bool nsChildView::ShouldUseOffMainThreadCompositing() { // Don't use OMTC for transparent windows or for popup windows. if (!mView || ![[mView window] isOpaque] || [[mView window] isKindOfClass:[PopupWindow class]]) return false; return nsBaseWidget::ShouldUseOffMainThreadCompositing(); } inline uint16_t COLOR8TOCOLOR16(uint8_t color8) { // return (color8 == 0xFF ? 0xFFFF : (color8 << 8)); return (color8 << 8) | color8; /* (color8 * 257) == (color8 * 0x0101) */ } #pragma mark - nsresult nsChildView::ConfigureChildren(const nsTArray& aConfigurations) { return NS_OK; } // Invokes callback and ProcessEvent methods on Event Listener object NS_IMETHODIMP nsChildView::DispatchEvent(WidgetGUIEvent* event, nsEventStatus& aStatus) { #ifdef DEBUG debug_DumpEvent(stdout, event->widget, event, nsAutoCString("something"), 0); #endif #if(0) NS_ASSERTION(!(mTextInputHandler && mTextInputHandler->IsIMEComposing() && event->HasKeyEventMessage()), "Any key events should not be fired during IME composing"); if (event->mFlags.mIsSynthesizedForTests) { WidgetKeyboardEvent* keyEvent = event->AsKeyboardEvent(); if (keyEvent) { nsresult rv = mTextInputHandler->AttachNativeKeyEvent(*keyEvent); NS_ENSURE_SUCCESS(rv, rv); } } #else NS_ASSERTION(!(nsTSMManager::IsComposing() && event->HasKeyEventMessage()), "Any key events should not be fired during IME composing"); if (event->mFlags.mIsSynthesizedForTests && event->HasKeyEventMessage()) { NS_WARNING("XXX Need TextInputHandlerBase::AttachNativeKeyEvent\n"); return NS_ERROR_FAILURE; } #endif aStatus = nsEventStatus_eIgnore; nsIWidgetListener* listener = mWidgetListener; // If the listener is NULL, check if the parent is a popup. If it is, then // this child is the popup content view attached to a popup. Get the // listener from the parent popup instead. nsCOMPtr kungFuDeathGrip = do_QueryInterface(mParentWidget ? mParentWidget : this); if (!listener && mParentWidget) { if (mParentWidget->WindowType() == eWindowType_popup) { // Check just in case event->widget isn't this widget if (event->widget) listener = event->widget->GetWidgetListener(); if (!listener) { event->widget = mParentWidget; listener = mParentWidget->GetWidgetListener(); } } } if (listener) aStatus = listener->HandleEvent(event, mUseAttachedEvents); return NS_OK; } bool nsChildView::DispatchWindowEvent(WidgetGUIEvent& event) { nsEventStatus status; DispatchEvent(&event, status); return ConvertStatus(status); } nsIWidget* nsChildView::GetWidgetForListenerEvents() { // If there is no listener, use the parent popup's listener if that exists. if (!mWidgetListener && mParentWidget && mParentWidget->WindowType() == eWindowType_popup) { return mParentWidget; } return this; } void nsChildView::WillPaintWindow() { nsCOMPtr widget = GetWidgetForListenerEvents(); nsIWidgetListener* listener = widget->GetWidgetListener(); if (listener) { listener->WillPaintWindow(widget); } } bool nsChildView::PaintWindow(LayoutDeviceIntRegion aRegion) { nsCOMPtr widget = GetWidgetForListenerEvents(); nsIWidgetListener* listener = widget->GetWidgetListener(); if (!listener) return false; bool returnValue = false; bool oldDispatchPaint = mIsDispatchPaint; mIsDispatchPaint = true; returnValue = listener->PaintWindow(widget, aRegion); listener = widget->GetWidgetListener(); if (listener) { listener->DidPaintWindow(); } mIsDispatchPaint = oldDispatchPaint; return returnValue; } #pragma mark - void nsChildView::ReportMoveEvent() { NotifyWindowMoved(mBounds.x, mBounds.y); } void nsChildView::ReportSizeEvent() { if (mWidgetListener) mWidgetListener->WindowResized(this, mBounds.width, mBounds.height); } #pragma mark - LayoutDeviceIntPoint nsChildView::GetClientOffset() { NS_OBJC_BEGIN_TRY_ABORT_BLOCK_RETURN; NSPoint origin = [mView convertPoint:NSMakePoint(0, 0) toView:nil]; origin.y = [[mView window] frame].size.height - origin.y; return CocoaPointsToDevPixels(origin); NS_OBJC_END_TRY_ABORT_BLOCK_RETURN(LayoutDeviceIntPoint(0, 0)); } // Return the offset between this child view and the screen. // @return -- widget origin in device-pixel coords LayoutDeviceIntPoint nsChildView::WidgetToScreenOffset() { NS_OBJC_BEGIN_TRY_ABORT_BLOCK_RETURN; NSPoint origin = NSMakePoint(0, 0); // 1. First translate view origin point into window coords. // The returned point is in bottom-left coordinates. origin = [mView convertPoint:origin toView:nil]; // 2. We turn the window-coord rect's origin into screen (still bottom-left) coords. origin = [[mView window] convertBaseToScreen:origin]; // 3. Since we're dealing in bottom-left coords, we need to make it top-left coords // before we pass it back to Gecko. FlipCocoaScreenCoordinate(origin); // convert to device pixels return CocoaPointsToDevPixels(origin); NS_OBJC_END_TRY_ABORT_BLOCK_RETURN(LayoutDeviceIntPoint(0,0)); } NS_IMETHODIMP nsChildView::CaptureRollupEvents(nsIRollupListener * aListener, bool aDoCapture) { // this never gets called, only top-level windows can be rollup widgets return NS_OK; } NS_IMETHODIMP nsChildView::SetTitle(const nsAString& title) { // child views don't have titles return NS_OK; } NS_IMETHODIMP nsChildView::GetAttention(int32_t aCycleCount) { NS_OBJC_BEGIN_TRY_ABORT_BLOCK_NSRESULT; [NSApp requestUserAttention:NSInformationalRequest]; return NS_OK; NS_OBJC_END_TRY_ABORT_BLOCK_NSRESULT; } /* static */ bool nsChildView::DoHasPendingInputEvent() { return sLastInputEventCount != GetCurrentInputEventCount(); } /* static */ uint32_t nsChildView::GetCurrentInputEventCount() { // Can't use kCGAnyInputEventType because that updates too rarely for us (and // always in increments of 30+!) and because apparently it's sort of broken // on Tiger. So just go ahead and query the counters we care about. static const CGEventType eventTypes[] = { kCGEventLeftMouseDown, kCGEventLeftMouseUp, kCGEventRightMouseDown, kCGEventRightMouseUp, kCGEventMouseMoved, kCGEventLeftMouseDragged, kCGEventRightMouseDragged, kCGEventKeyDown, kCGEventKeyUp, kCGEventScrollWheel, kCGEventTabletPointer, kCGEventOtherMouseDown, kCGEventOtherMouseUp, kCGEventOtherMouseDragged }; uint32_t eventCount = 0; for (uint32_t i = 0; i < ArrayLength(eventTypes); ++i) { eventCount += CGEventSourceCounterForEventType(kCGEventSourceStateCombinedSessionState, eventTypes[i]); } return eventCount; } /* static */ void nsChildView::UpdateCurrentInputEventCount() { sLastInputEventCount = GetCurrentInputEventCount(); } bool nsChildView::HasPendingInputEvent() { return DoHasPendingInputEvent(); } #pragma mark - // Added for bug 807893 static int32_t sSecureEventInputCount = 0; static void ChildViewEnableSecureEventInput() { sSecureEventInputCount++; ::EnableSecureEventInput(); } static void ChildViewDisableSecureEventInput() { if (!sSecureEventInputCount) return; sSecureEventInputCount--; ::DisableSecureEventInput(); } static bool ChildViewIsSecureEventInputEnabled() { return !!sSecureEventInputCount; } static void ChildViewEnsureSecureEventInputDisabled() { while (sSecureEventInputCount) ChildViewDisableSecureEventInput(); } nsresult nsChildView::NotifyIMEInternal(const IMENotification& aIMENotification) { #if(0) switch (aIMENotification.mMessage) { case REQUEST_TO_COMMIT_COMPOSITION: NS_ENSURE_TRUE(mTextInputHandler, NS_ERROR_NOT_AVAILABLE); mTextInputHandler->CommitIMEComposition(); return NS_OK; case REQUEST_TO_CANCEL_COMPOSITION: NS_ENSURE_TRUE(mTextInputHandler, NS_ERROR_NOT_AVAILABLE); mTextInputHandler->CancelIMEComposition(); return NS_OK; case NOTIFY_IME_OF_FOCUS: if (mTextInputHandler->IsFocused()) { if (mInputContext.IsPasswordEditor()) { TextInputHandler::EnableSecureEventInput(); } else { TextInputHandler::EnsureSecureEventInputDisabled(); } } NS_ENSURE_TRUE(mTextInputHandler, NS_ERROR_NOT_AVAILABLE); mTextInputHandler->OnFocusChangeInGecko(true); return NS_OK; case NOTIFY_IME_OF_BLUR: NS_ENSURE_TRUE(mTextInputHandler, NS_ERROR_NOT_AVAILABLE); mTextInputHandler->OnFocusChangeInGecko(false); return NS_OK; case NOTIFY_IME_OF_SELECTION_CHANGE: NS_ENSURE_TRUE(mTextInputHandler, NS_ERROR_NOT_AVAILABLE); mTextInputHandler->OnSelectionChange(aIMENotification); return NS_OK; default: return NS_ERROR_NOT_IMPLEMENTED; } #else switch (aIMENotification.mMessage) { case REQUEST_TO_COMMIT_COMPOSITION: nsTSMManager::CommitIME(); return NS_OK; case REQUEST_TO_CANCEL_COMPOSITION: nsTSMManager::CancelIME(); return NS_OK; case NOTIFY_IME_OF_FOCUS: if (mInputContext.IsPasswordEditor()) ChildViewEnableSecureEventInput(); else ChildViewEnsureSecureEventInputDisabled(); // XXX mTextInputHandler->OnFocusChangeInGecko(true); return NS_OK; case NOTIFY_IME_OF_BLUR: // When we're going to be deactivated, we must disable the secure // event input mode; see the Carbon Event Manager Reference. ChildViewEnsureSecureEventInputDisabled(); // XXX mTextInputHandler->OnFocusChangeInGecko(false); return NS_OK; case NOTIFY_IME_OF_SELECTION_CHANGE: // XXX mTextInputHandler->OnSelectionChange(aIMENotification); return NS_OK; default: return NS_ERROR_NOT_IMPLEMENTED; } #endif } NS_IMETHODIMP nsChildView::StartPluginIME(const mozilla::WidgetKeyboardEvent& aKeyboardEvent, int32_t aPanelX, int32_t aPanelY, nsString& aCommitted) { NS_ENSURE_TRUE(mView, NS_ERROR_NOT_AVAILABLE); ComplexTextInputPanel* ctiPanel = ComplexTextInputPanel::GetSharedComplexTextInputPanel(); ctiPanel->PlacePanel(aPanelX, aPanelY); // We deliberately don't use TextInputHandler::GetCurrentKeyEvent() to // obtain the NSEvent* we pass to InterpretKeyEvent(). This works fine in // non-e10s mode. But in e10s mode TextInputHandler::HandleKeyDownEvent() // has already returned, so the relevant KeyEventState* (and its NSEvent*) // is already out of scope. Furthermore we don't *need* to use it. // StartPluginIME() is only ever called to start a new IME session when none // currently exists. So nested IME should never reach here, and so it should // be fine to use the last key-down event received by -[ChildView keyDown:] // (as we currently do). ctiPanel->InterpretKeyEvent([(ChildView*)mView lastKeyDownEvent], aCommitted); return NS_OK; } NS_IMETHODIMP nsChildView::SetPluginFocused(bool& aFocused) { if (aFocused == mPluginFocused) { return NS_OK; } if (!aFocused) { ComplexTextInputPanel* ctiPanel = ComplexTextInputPanel::GetSharedComplexTextInputPanel(); if (ctiPanel) { ctiPanel->CancelComposition(); } } mPluginFocused = aFocused; return NS_OK; } NS_IMETHODIMP_(void) nsChildView::SetInputContext(const InputContext& aContext, const InputContextAction& aAction) { #ifdef DEBUG_IME //NSLog(@"**** SetInputMode mStatus = %d", aContext.mStatus); #endif #if(0) NS_ENSURE_TRUE_VOID(mTextInputHandler); if (mTextInputHandler->IsFocused()) { if (aContext.IsPasswordEditor()) { TextInputHandler::EnableSecureEventInput(); } else { TextInputHandler::EnsureSecureEventInputDisabled(); } } mInputContext = aContext; switch (aContext.mIMEState.mEnabled) { case IMEState::ENABLED: case IMEState::PLUGIN: mTextInputHandler->SetASCIICapableOnly(false); mTextInputHandler->EnableIME(true); if (mInputContext.mIMEState.mOpen != IMEState::DONT_CHANGE_OPEN_STATE) { mTextInputHandler->SetIMEOpenState( mInputContext.mIMEState.mOpen == IMEState::OPEN); } break; case IMEState::DISABLED: mTextInputHandler->SetASCIICapableOnly(false); mTextInputHandler->EnableIME(false); break; case IMEState::PASSWORD: mTextInputHandler->SetASCIICapableOnly(true); mTextInputHandler->EnableIME(false); break; default: NS_ERROR("not implemented!"); } #else // Bug 807893 requires that we juggle the secure status ourselves. // Bug 893973 needs focus checking, but our 10.4-compatible code does not. if (aContext.IsPasswordEditor()) ChildViewEnableSecureEventInput(); else ChildViewDisableSecureEventInput(); mInputContext = aContext; switch (aContext.mIMEState.mEnabled) { case IMEState::ENABLED: case IMEState::PLUGIN: if (mInputContext.mIMEState.mOpen != IMEState::DONT_CHANGE_OPEN_STATE) { nsTSMManager::SetIMEOpenState( mInputContext.mIMEState.mOpen == IMEState::OPEN); } break; case IMEState::DISABLED: case IMEState::PASSWORD: // handled by nsTSMManager::SetIMEEnabled break; default: NS_ERROR("not implemented!"); return; } (void)nsTSMManager::SetIMEEnabled(aContext.mIMEState.mEnabled); #endif } NS_IMETHODIMP_(InputContext) nsChildView::GetInputContext() { #if(0) switch (mInputContext.mIMEState.mEnabled) { case IMEState::ENABLED: case IMEState::PLUGIN: if (mTextInputHandler) { mInputContext.mIMEState.mOpen = mTextInputHandler->IsIMEOpened() ? IMEState::OPEN : IMEState::CLOSED; break; } // If mTextInputHandler is null, set CLOSED instead... MOZ_FALLTHROUGH; default: mInputContext.mIMEState.mOpen = IMEState::CLOSED; break; } #else switch (mInputContext.mIMEState.mEnabled) { case IMEState::ENABLED: case IMEState::PLUGIN: // The nsTSMManager is always available in 10.4. mInputContext.mIMEState.mOpen = nsTSMManager::GetIMEOpenState() ? IMEState::OPEN : IMEState::CLOSED; break; default: mInputContext.mIMEState.mOpen = IMEState::CLOSED; break; } #endif return mInputContext; } NS_IMETHODIMP nsChildView::AttachNativeKeyEvent(mozilla::WidgetKeyboardEvent& aEvent) { #if(0) NS_ENSURE_TRUE(mTextInputHandler, NS_ERROR_NOT_AVAILABLE); return mTextInputHandler->AttachNativeKeyEvent(aEvent); #else NS_OBJC_BEGIN_TRY_ABORT_BLOCK_NSRESULT; // Don't try to replace a native event if one already exists. // OS X doesn't have an OS modifier, so we can't make a native event. if (aEvent.mNativeKeyEvent || aEvent.modifiers & MODIFIER_OS) { return NS_OK; } #if(0) PR_LOG(sCocoaLog, PR_LOG_ALWAYS, ("%p nsChildView::AttachNativeKeyEvent, key=0x%X, char=0x%X, " "mod=0x%X", this, aEvent.keyCode, aEvent.charCode, aEvent.modifiers)); #endif NSEventType eventType; if (aEvent.mMessage == eKeyUp) { eventType = NSKeyUp; } else { eventType = NSKeyDown; } static const uint32_t sModifierFlagMap[][2] = { { MODIFIER_SHIFT, NSShiftKeyMask }, { MODIFIER_CONTROL, NSControlKeyMask }, { MODIFIER_ALT, NSAlternateKeyMask }, { MODIFIER_ALTGRAPH, NSAlternateKeyMask }, { MODIFIER_META, NSCommandKeyMask }, { MODIFIER_CAPSLOCK, NSAlphaShiftKeyMask }, { MODIFIER_NUMLOCK, NSNumericPadKeyMask } }; uint32_t modifierFlags = 0; for (uint32_t i = 0; i < ArrayLength(sModifierFlagMap); ++i) { if (aEvent.modifiers & sModifierFlagMap[i][0]) { modifierFlags |= sModifierFlagMap[i][1]; } } // We probably don't need nsCocoaUtils to adjust the modifier flags. ??? int32_t windowNumber = [[mView window] windowNumber]; NSString* characters; if (aEvent.charCode) { characters = [NSString stringWithCharacters: reinterpret_cast(&(aEvent.charCode)) length:1]; } else { uint32_t cocoaCharCode = nsCocoaUtils::ConvertGeckoKeyCodeToMacCharCode(aEvent.keyCode); characters = [NSString stringWithCharacters: reinterpret_cast(&cocoaCharCode) length:1]; } aEvent.mNativeKeyEvent = [NSEvent keyEventWithType:eventType location:NSMakePoint(0,0) modifierFlags:modifierFlags timestamp:0 windowNumber:windowNumber context:[NSGraphicsContext currentContext] characters:characters charactersIgnoringModifiers:characters isARepeat:NO keyCode:0]; // Native key code not currently needed return NS_OK; NS_OBJC_END_TRY_ABORT_BLOCK_NSRESULT; #endif } bool nsChildView::ExecuteNativeKeyBindingRemapped(NativeKeyBindingsType aType, const WidgetKeyboardEvent& aEvent, DoCommandCallback aCallback, void* aCallbackData, uint32_t aGeckoKeyCode, uint32_t aCocoaKeyCode) { NSEvent *originalEvent = reinterpret_cast(aEvent.mNativeKeyEvent); WidgetKeyboardEvent modifiedEvent(aEvent); modifiedEvent.keyCode = aGeckoKeyCode; unichar ch = nsCocoaUtils::ConvertGeckoKeyCodeToMacCharCode(aGeckoKeyCode); NSString *chars = [[[NSString alloc] initWithCharacters:&ch length:1] autorelease]; modifiedEvent.mNativeKeyEvent = [NSEvent keyEventWithType:[originalEvent type] location:[originalEvent locationInWindow] modifierFlags:[originalEvent modifierFlags] timestamp:[originalEvent timestamp] windowNumber:[originalEvent windowNumber] context:[originalEvent context] characters:chars charactersIgnoringModifiers:chars isARepeat:[originalEvent isARepeat] keyCode:aCocoaKeyCode]; NativeKeyBindings* keyBindings = NativeKeyBindings::GetInstance(aType); return keyBindings->Execute(modifiedEvent, aCallback, aCallbackData); } NS_IMETHODIMP_(bool) nsChildView::ExecuteNativeKeyBinding(NativeKeyBindingsType aType, const WidgetKeyboardEvent& aEvent, DoCommandCallback aCallback, void* aCallbackData) { // If the key is a cursor-movement arrow, and the current selection has // vertical writing-mode, we'll remap so that the movement command // generated (in terms of characters/lines) will be appropriate for // the physical direction of the arrow. if (aEvent.keyCode >= nsIDOMKeyEvent::DOM_VK_LEFT && aEvent.keyCode <= nsIDOMKeyEvent::DOM_VK_DOWN) { WidgetQueryContentEvent query(true, eQuerySelectedText, this); DispatchWindowEvent(query); if (query.mSucceeded && query.mReply.mWritingMode.IsVertical()) { uint32_t geckoKey = 0; uint32_t cocoaKey = 0; switch (aEvent.keyCode) { case nsIDOMKeyEvent::DOM_VK_LEFT: if (query.mReply.mWritingMode.IsVerticalLR()) { geckoKey = nsIDOMKeyEvent::DOM_VK_UP; cocoaKey = kVK_UpArrow; } else { geckoKey = nsIDOMKeyEvent::DOM_VK_DOWN; cocoaKey = kVK_DownArrow; } break; case nsIDOMKeyEvent::DOM_VK_RIGHT: if (query.mReply.mWritingMode.IsVerticalLR()) { geckoKey = nsIDOMKeyEvent::DOM_VK_DOWN; cocoaKey = kVK_DownArrow; } else { geckoKey = nsIDOMKeyEvent::DOM_VK_UP; cocoaKey = kVK_UpArrow; } break; case nsIDOMKeyEvent::DOM_VK_UP: geckoKey = nsIDOMKeyEvent::DOM_VK_LEFT; cocoaKey = kVK_LeftArrow; break; case nsIDOMKeyEvent::DOM_VK_DOWN: geckoKey = nsIDOMKeyEvent::DOM_VK_RIGHT; cocoaKey = kVK_RightArrow; break; } return ExecuteNativeKeyBindingRemapped(aType, aEvent, aCallback, aCallbackData, geckoKey, cocoaKey); } } NativeKeyBindings* keyBindings = NativeKeyBindings::GetInstance(aType); return keyBindings->Execute(aEvent, aCallback, aCallbackData); } nsIMEUpdatePreference nsChildView::GetIMEUpdatePreference() { // While a plugin has focus, IMEInputHandler doesn't need any notifications. if (mInputContext.mIMEState.mEnabled == IMEState::PLUGIN) { return nsIMEUpdatePreference(); } return nsIMEUpdatePreference(nsIMEUpdatePreference::NOTIFY_SELECTION_CHANGE); } #if(0) NSView* nsChildView::GetEditorView() { NSView* editorView = mView; // We need to get editor's view. E.g., when the focus is in the bookmark // dialog, the view is element of the dialog. At this time, the key // events are processed the parent window's view that has native focus. WidgetQueryContentEvent textContent(true, eQueryTextContent, this); textContent.InitForQueryTextContent(0, 0); DispatchWindowEvent(textContent); if (textContent.mSucceeded && textContent.mReply.mFocusedWidget) { NSView* view = static_cast*>( textContent.mReply.mFocusedWidget->GetNativeData(NS_NATIVE_WIDGET)); if (view) editorView = view; } return editorView; } #endif // no Tiger equivalent. #pragma mark - void nsChildView::CreateCompositor() { nsBaseWidget::CreateCompositor(); if (mCompositorChild) { [(ChildView *)mView setUsingOMTCompositor:true]; } } void nsChildView::ConfigureAPZCTreeManager() { nsBaseWidget::ConfigureAPZCTreeManager(); if (gfxPrefs::AsyncPanZoomSeparateEventThread()) { if (gNumberOfWidgetsNeedingEventThread == 0) { [EventThreadRunner start]; } gNumberOfWidgetsNeedingEventThread++; } } void nsChildView::ConfigureAPZControllerThread() { if (gfxPrefs::AsyncPanZoomSeparateEventThread()) { // The EventThreadRunner is the controller thread, but it doesn't // have a MessageLoop. APZThreadUtils::SetControllerThread(nullptr); } else { nsBaseWidget::ConfigureAPZControllerThread(); } } LayoutDeviceIntRect nsChildView::RectContainingTitlebarControls() { #if(0) // Start with a thin strip at the top of the window for the highlight line. NSRect rect = NSMakeRect(0, 0, [mView bounds].size.width, [(ChildView*)mView cornerRadius]); // Add the rects of the titlebar controls. for (id view in [(BaseWindow*)[mView window] titlebarControls]) { rect = NSUnionRect(rect, [mView convertRect:[view bounds] fromView:view]); } return CocoaPointsToDevPixels(rect); #else // Actually, stuff all that. We've gotta get on with these. // Gotta compete with a whiny Mozilla that broke 10.4 compatibilit-ee. // Use the manual gradient patch in 880620 for perf and no NSGradient. NSRect rect = NSMakeRect(0, 0, [mView bounds].size.width, [(ChildView*)mView cornerRadius]); // Now we can add the rects of the titlebar controls. Oi! Where's the bar! // XXX: NSEnumerator *e = [a objectEnumerator]; while(id = [e nextObject]) int i; NSArray *a = [(BaseWindow*)[mView window] titlebarControls]; for (i=0; i < [a count]; i++) { id view = [a objectAtIndex:i]; rect = NSUnionRect(rect, [mView convertRect:[view bounds] fromView:view]); } return CocoaPointsToDevPixels(rect); #endif } void nsChildView::PrepareWindowEffects() { MutexAutoLock lock(mEffectsLock); mShowsResizeIndicator = ShowsResizeIndicator(&mResizeIndicatorRect); mHasRoundedBottomCorners = [(ChildView*)mView hasRoundedBottomCorners]; CGFloat cornerRadius = [(ChildView*)mView cornerRadius]; mDevPixelCornerRadius = cornerRadius; // * BackingScaleFactor(); mIsCoveringTitlebar = [(ChildView*)mView isCoveringTitlebar]; NSInteger styleMask = [[mView window] styleMask]; mIsFullscreen = (styleMask & NSFullScreenWindowMask) || !(styleMask & NSTitledWindowMask); if (mIsCoveringTitlebar) { mTitlebarRect = RectContainingTitlebarControls(); UpdateTitlebarCGContext(); } } void nsChildView::CleanupWindowEffects() { mResizerImage = nullptr; mCornerMaskImage = nullptr; mTitlebarImage = nullptr; } bool nsChildView::PreRender(LayerManagerComposite* aManager) { nsAutoPtr manager(GLManager::CreateGLManager(aManager)); if (!manager) { return true; } // The lock makes sure that we don't attempt to tear down the view while // compositing. That would make us unable to call postRender on it when the // composition is done, thus keeping the GL context locked forever. mViewTearDownLock.Lock(); NSOpenGLContext *glContext = GLContextCGL::Cast(manager->gl())->GetNSOpenGLContext(); if (![(ChildView*)mView preRender:glContext]) { mViewTearDownLock.Unlock(); return false; } return true; } void nsChildView::PostRender(LayerManagerComposite* aManager) { nsAutoPtr manager(GLManager::CreateGLManager(aManager)); if (!manager) { return; } NSOpenGLContext *glContext = GLContextCGL::Cast(manager->gl())->GetNSOpenGLContext(); [(ChildView*)mView postRender:glContext]; mViewTearDownLock.Unlock(); } void nsChildView::DrawWindowOverlay(LayerManagerComposite* aManager, LayoutDeviceIntRect aRect) { nsAutoPtr manager(GLManager::CreateGLManager(aManager)); if (manager) { DrawWindowOverlay(manager, aRect); } } void nsChildView::DrawWindowOverlay(GLManager* aManager, LayoutDeviceIntRect aRect) { GLContext* gl = aManager->gl(); ScopedGLState scopedScissorTestState(gl, LOCAL_GL_SCISSOR_TEST, false); MaybeDrawTitlebar(aManager); MaybeDrawResizeIndicator(aManager); MaybeDrawRoundedCorners(aManager, aRect); } static void ClearRegion(gfx::DrawTarget *aDT, LayoutDeviceIntRegion aRegion) { gfxUtils::ClipToRegion(aDT, aRegion.ToUnknownRegion()); aDT->ClearRect(gfx::Rect(0, 0, aDT->GetSize().width, aDT->GetSize().height)); aDT->PopClip(); } static void DrawResizer(CGContextRef aCtx) { CGContextSetShouldAntialias(aCtx, false); CGPoint points[6]; points[0] = CGPointMake(13.0f, 4.0f); points[1] = CGPointMake(3.0f, 14.0f); points[2] = CGPointMake(13.0f, 8.0f); points[3] = CGPointMake(7.0f, 14.0f); points[4] = CGPointMake(13.0f, 12.0f); points[5] = CGPointMake(11.0f, 14.0f); CGContextSetRGBStrokeColor(aCtx, 0.00f, 0.00f, 0.00f, 0.15f); CGContextStrokeLineSegments(aCtx, points, 6); points[0] = CGPointMake(13.0f, 5.0f); points[1] = CGPointMake(4.0f, 14.0f); points[2] = CGPointMake(13.0f, 9.0f); points[3] = CGPointMake(8.0f, 14.0f); points[4] = CGPointMake(13.0f, 13.0f); points[5] = CGPointMake(12.0f, 14.0f); CGContextSetRGBStrokeColor(aCtx, 0.13f, 0.13f, 0.13f, 0.54f); CGContextStrokeLineSegments(aCtx, points, 6); points[0] = CGPointMake(13.0f, 6.0f); points[1] = CGPointMake(5.0f, 14.0f); points[2] = CGPointMake(13.0f, 10.0f); points[3] = CGPointMake(9.0f, 14.0f); points[5] = CGPointMake(13.0f, 13.9f); points[4] = CGPointMake(13.0f, 14.0f); CGContextSetRGBStrokeColor(aCtx, 0.84f, 0.84f, 0.84f, 0.55f); CGContextStrokeLineSegments(aCtx, points, 6); } static void MaybeDrawResizeIndicatorCallback(gfx::DrawTarget* drawTarget, const LayoutDeviceIntRegion& updateRegion) { ClearRegion(drawTarget, updateRegion); gfx::BorrowedCGContext borrow(drawTarget); DrawResizer(borrow.cg); borrow.Finish(); } void nsChildView::MaybeDrawResizeIndicator(GLManager* aManager) { MutexAutoLock lock(mEffectsLock); if (!mShowsResizeIndicator) { return; } if (!mResizerImage) { mResizerImage = new RectTextureImage(aManager->gl()); } LayoutDeviceIntSize size = mResizeIndicatorRect.Size(); #if(0) mResizerImage->UpdateIfNeeded(size, LayoutDeviceIntRegion(), ^(gfx::DrawTarget* drawTarget, const LayoutDeviceIntRegion& updateRegion) { ClearRegion(drawTarget, updateRegion); gfx::BorrowedCGContext borrow(drawTarget); DrawResizer(borrow.cg); borrow.Finish(); }); #else mResizerImage->UpdateIfNeeded(size, LayoutDeviceIntRegion(), &MaybeDrawResizeIndicatorCallback); #endif mResizerImage->Draw(aManager, mResizeIndicatorRect.TopLeft()); } // Draw the highlight line at the top of the titlebar. // This function draws into the current NSGraphicsContext and assumes flippedness. static void DrawTitlebarHighlight(NSSize aWindowSize, CGFloat aRadius, CGFloat aDevicePixelWidth) { [NSGraphicsContext saveGraphicsState]; // Set up the clip path. We start with the outer rectangle and cut out a // slightly smaller inner rectangle with rounded corners. // The outer corners of the resulting path will be square, but they will be // masked away in a later step. NSBezierPath* path = [NSBezierPath bezierPath]; [path setWindingRule:NSEvenOddWindingRule]; NSRect pathRect = NSMakeRect(0, 0, aWindowSize.width, aRadius + 2); [path appendBezierPathWithRect:pathRect]; pathRect = NSInsetRect(pathRect, aDevicePixelWidth, aDevicePixelWidth); CGFloat innerRadius = aRadius - aDevicePixelWidth; #if(0) [path appendBezierPathWithRoundedRect:pathRect xRadius:innerRadius yRadius:innerRadius]; #else // Only 10.5 has this; 10.4 needs an approximation. // http://lists.apple.com/archives/cocoa-dev/2008/Dec/msg00263.html /* [path appendBezierPathWithRoundedRect:pathRect xRadius:innerRadius yRadius:innerRadius]; */ float clampedRadius = MIN(innerRadius, 0.5 * MIN(pathRect.size.width, pathRect.size.height)); NSPoint topLeft = NSMakePoint(NSMinX(pathRect), NSMaxY(pathRect)); NSPoint topRight = NSMakePoint(NSMaxX(pathRect), NSMaxY(pathRect)); NSPoint bottomRight = NSMakePoint(NSMaxX(pathRect), NSMinY(pathRect)); [path moveToPoint:NSMakePoint(NSMidX(pathRect), NSMaxY(pathRect))]; [path appendBezierPathWithArcFromPoint:topLeft toPoint:pathRect.origin radius:clampedRadius]; [path appendBezierPathWithArcFromPoint:pathRect.origin toPoint:bottomRight radius:clampedRadius]; [path appendBezierPathWithArcFromPoint:bottomRight toPoint:topRight radius:clampedRadius]; [path appendBezierPathWithArcFromPoint:topRight toPoint:topLeft radius:clampedRadius]; #endif [path addClip]; // Now we fill the path with a subtle highlight gradient. // We don't use NSGradient because it's 5x to 15x slower than the manual fill, // as indicated by the performance test in bug 880620. for (CGFloat y = 0; y < aRadius; y += aDevicePixelWidth) { CGFloat t = y / aRadius; [[NSColor colorWithDeviceWhite:1.0 alpha:0.4 * (1.0 - t)] set]; NSRectFillUsingOperation(NSMakeRect(0, y, aWindowSize.width, aDevicePixelWidth), NSCompositeSourceOver); } [NSGraphicsContext restoreGraphicsState]; } static CGContextRef CreateCGContext(const LayoutDeviceIntSize& aSize) { CGColorSpaceRef cs = CGColorSpaceCreateDeviceRGB(); CGContextRef ctx = CGBitmapContextCreate(NULL, aSize.width, aSize.height, 8 /* bitsPerComponent */, aSize.width * 4, cs, kCGBitmapByteOrder32Host | kCGImageAlphaPremultipliedFirst); CGColorSpaceRelease(cs); CGContextTranslateCTM(ctx, 0, aSize.height); CGContextScaleCTM(ctx, 1, -1); CGContextSetInterpolationQuality(ctx, kCGInterpolationLow); return ctx; } // When this method is entered, mEffectsLock is already being held. void nsChildView::UpdateTitlebarCGContext() { if (mTitlebarRect.IsEmpty()) { ReleaseTitlebarCGContext(); return; } NSRect titlebarRect = DevPixelsToCocoaPoints(mTitlebarRect); NSRect dirtyRect = [mView convertRect:[(BaseWindow*)[mView window] getAndResetNativeDirtyRect] fromView:nil]; NSRect dirtyTitlebarRect = NSIntersectionRect(titlebarRect, dirtyRect); LayoutDeviceIntSize texSize = RectTextureImage::TextureSizeForSize(mTitlebarRect.Size()); if (!mTitlebarCGContext || CGBitmapContextGetWidth(mTitlebarCGContext) != size_t(texSize.width) || CGBitmapContextGetHeight(mTitlebarCGContext) != size_t(texSize.height)) { dirtyTitlebarRect = titlebarRect; ReleaseTitlebarCGContext(); mTitlebarCGContext = CreateCGContext(texSize); } if (NSIsEmptyRect(dirtyTitlebarRect)) { return; } CGContextRef ctx = mTitlebarCGContext; CGContextSaveGState(ctx); #if(0) double scale = BackingScaleFactor(); CGContextScaleCTM(ctx, scale, scale); #else CGContextScaleCTM(ctx, 1.0, 1.0); #endif //CGContextClipToRect(ctx, NSRectToCGRect(dirtyTitlebarRect)); CGRect dgr = *(CGRect*)&dirtyTitlebarRect; CGContextClipToRect(ctx, dgr); //CGContextClearRect(ctx, NSRectToCGRect(dirtyTitlebarRect)); CGContextClearRect(ctx, dgr); NSGraphicsContext* oldContext = [NSGraphicsContext currentContext]; CGContextSaveGState(ctx); BaseWindow* window = (BaseWindow*)[mView window]; NSView* frameView = [[window contentView] superview]; if (![frameView isFlipped]) { CGContextTranslateCTM(ctx, 0, [frameView bounds].size.height); CGContextScaleCTM(ctx, 1, -1); } NSGraphicsContext* context = [NSGraphicsContext graphicsContextWithGraphicsPort:ctx flipped:[frameView isFlipped]]; [NSGraphicsContext setCurrentContext:context]; // Draw the title string. if ([window wantsTitleDrawn] && [frameView respondsToSelector:@selector(_drawTitleBar:)]) { [frameView _drawTitleBar:[frameView bounds]]; } // Draw the titlebar controls into the titlebar image. //for (id view in [window titlebarControls]) { int i; NSArray *a = [window titlebarControls]; for(i=0; i<[a count]; i++) { id view = [a objectAtIndex:i]; NSRect viewFrame = [view frame]; NSRect viewRect = [mView convertRect:viewFrame fromView:frameView]; if (!NSIntersectsRect(dirtyTitlebarRect, viewRect)) { continue; } // All of the titlebar controls we're interested in are subclasses of // NSButton. if (![view isKindOfClass:[NSButton class]]) { continue; } NSButton *button = (NSButton *) view; id cellObject = [button cell]; if (![cellObject isKindOfClass:[NSCell class]]) { continue; } NSCell *cell = (NSCell *) cellObject; CGContextSaveGState(ctx); CGContextTranslateCTM(ctx, viewFrame.origin.x, viewFrame.origin.y); if ([context isFlipped] != [view isFlipped]) { CGContextTranslateCTM(ctx, 0, viewFrame.size.height); CGContextScaleCTM(ctx, 1, -1); } [NSGraphicsContext setCurrentContext:[NSGraphicsContext graphicsContextWithGraphicsPort:ctx flipped:[view isFlipped]]]; #if(0) if ([window useBrightTitlebarForeground] && !nsCocoaFeatures::OnYosemiteOrLater() && view == [window standardWindowButton:NSWindowFullScreenButton]) { // Make the fullscreen button visible on dark titlebar backgrounds by // drawing it into a new transparency layer and turning it white. CGRect r = NSRectToCGRect([view bounds]); CGContextBeginTransparencyLayerWithRect(ctx, r, nullptr); // Draw twice for double opacity. [cell drawWithFrame:[button bounds] inView:button]; [cell drawWithFrame:[button bounds] inView:button]; // Make it white. CGContextSetBlendMode(ctx, kCGBlendModeSourceIn); CGContextSetRGBFillColor(ctx, 1, 1, 1, 1); CGContextFillRect(ctx, r); CGContextSetBlendMode(ctx, kCGBlendModeNormal); CGContextEndTransparencyLayer(ctx); } else { [cell drawWithFrame:[button bounds] inView:button]; } #else [cell drawWithFrame:[button bounds] inView:button]; #endif [NSGraphicsContext setCurrentContext:context]; CGContextRestoreGState(ctx); } CGContextRestoreGState(ctx); DrawTitlebarHighlight([frameView bounds].size, [(ChildView*)mView cornerRadius], DevPixelsToCocoaPoints(1)); [NSGraphicsContext setCurrentContext:oldContext]; CGContextRestoreGState(ctx); mUpdatedTitlebarRegion.OrWith(CocoaPointsToDevPixels(dirtyTitlebarRect)); } // This method draws an overlay in the top of the window which contains the // titlebar controls (e.g. close, min, zoom, fullscreen) and the titlebar // highlight effect. // This is necessary because the real titlebar controls are covered by our // OpenGL context. Note that in terms of the NSView hierarchy, our ChildView // is actually below the titlebar controls - that's why hovering and clicking // them works as expected - but their visual representation is only drawn into // the normal window buffer, and the window buffer surface lies below the // GLContext surface. In order to make the titlebar controls visible, we have // to redraw them inside the OpenGL context surface. void nsChildView::MaybeDrawTitlebar(GLManager* aManager) { MutexAutoLock lock(mEffectsLock); if (!mIsCoveringTitlebar || mIsFullscreen) { return; } LayoutDeviceIntRegion updatedTitlebarRegion; updatedTitlebarRegion.And(mUpdatedTitlebarRegion, mTitlebarRect); mUpdatedTitlebarRegion.SetEmpty(); if (!mTitlebarImage) { mTitlebarImage = new RectTextureImage(aManager->gl()); } mTitlebarImage->UpdateFromCGContext(mTitlebarRect.Size(), updatedTitlebarRegion, mTitlebarCGContext); mTitlebarImage->Draw(aManager, mTitlebarRect.TopLeft()); } static void DrawTopLeftCornerMask(CGContextRef aCtx, int aRadius) { CGContextSetRGBFillColor(aCtx, 1.0, 1.0, 1.0, 1.0); CGContextFillEllipseInRect(aCtx, CGRectMake(0, 0, aRadius * 2, aRadius * 2)); } static void MaybeDrawRoundedCornersCallback(gfx::DrawTarget* drawTarget, const LayoutDeviceIntRegion& updateRegion) { ClearRegion(drawTarget, updateRegion); gfx::BorrowedCGContext borrow(drawTarget); /* DrawTopLeftCornerMask(borrow.cg, mDevPixelCornerRadius); */ borrow.Finish(); } void nsChildView::MaybeDrawRoundedCorners(GLManager* aManager, const LayoutDeviceIntRect& aRect) { MutexAutoLock lock(mEffectsLock); if (!mCornerMaskImage) { mCornerMaskImage = new RectTextureImage(aManager->gl()); } LayoutDeviceIntSize size(mDevPixelCornerRadius, mDevPixelCornerRadius); #if(0) mCornerMaskImage->UpdateIfNeeded(size, LayoutDeviceIntRegion(), ^(gfx::DrawTarget* drawTarget, const LayoutDeviceIntRegion& updateRegion) { ClearRegion(drawTarget, updateRegion); RefPtr builder = drawTarget->CreatePathBuilder(); builder->Arc(gfx::Point(mDevPixelCornerRadius, mDevPixelCornerRadius), mDevPixelCornerRadius, 0, 2.0f * M_PI); RefPtr path = builder->Finish(); drawTarget->Fill(path, gfx::ColorPattern(gfx::Color(1.0, 1.0, 1.0, 1.0)), gfx::DrawOptions(1.0f, gfx::CompositionOp::OP_SOURCE)); }); #else mCornerMaskImage->UpdateIfNeeded(size, LayoutDeviceIntRegion(), &MaybeDrawRoundedCornersCallback); #endif // Use operator destination in: multiply all 4 channels with source alpha. aManager->gl()->fBlendFuncSeparate(LOCAL_GL_ZERO, LOCAL_GL_SRC_ALPHA, LOCAL_GL_ZERO, LOCAL_GL_SRC_ALPHA); Matrix4x4 flipX = Matrix4x4::Scaling(-1, 1, 1); Matrix4x4 flipY = Matrix4x4::Scaling(1, -1, 1); if (mIsCoveringTitlebar && !mIsFullscreen) { // Mask the top corners. mCornerMaskImage->Draw(aManager, aRect.TopLeft()); mCornerMaskImage->Draw(aManager, aRect.TopRight(), flipX); } if (mHasRoundedBottomCorners && !mIsFullscreen) { // Mask the bottom corners. mCornerMaskImage->Draw(aManager, aRect.BottomLeft(), flipY); mCornerMaskImage->Draw(aManager, aRect.BottomRight(), flipY * flipX); } // Reset blend mode. aManager->gl()->fBlendFuncSeparate(LOCAL_GL_ONE, LOCAL_GL_ONE_MINUS_SRC_ALPHA, LOCAL_GL_ONE, LOCAL_GL_ONE); } static int32_t FindTitlebarBottom(const nsTArray& aThemeGeometries, int32_t aWindowWidth) { int32_t titlebarBottom = 0; for (uint32_t i = 0; i < aThemeGeometries.Length(); ++i) { const nsIWidget::ThemeGeometry& g = aThemeGeometries[i]; if ((g.mType == nsNativeThemeCocoa::eThemeGeometryTypeTitlebar) && g.mRect.X() <= 0 && g.mRect.XMost() >= aWindowWidth && g.mRect.Y() <= 0) { titlebarBottom = std::max(titlebarBottom, g.mRect.YMost()); } } return titlebarBottom; } static int32_t FindUnifiedToolbarBottom(const nsTArray& aThemeGeometries, int32_t aWindowWidth, int32_t aTitlebarBottom) { int32_t unifiedToolbarBottom = aTitlebarBottom; for (uint32_t i = 0; i < aThemeGeometries.Length(); ++i) { const nsIWidget::ThemeGeometry& g = aThemeGeometries[i]; if ((g.mType == nsNativeThemeCocoa::eThemeGeometryTypeToolbar) && g.mRect.X() <= 0 && g.mRect.XMost() >= aWindowWidth && g.mRect.Y() <= aTitlebarBottom) { unifiedToolbarBottom = std::max(unifiedToolbarBottom, g.mRect.YMost()); } } return unifiedToolbarBottom; } static LayoutDeviceIntRect FindFirstRectOfType(const nsTArray& aThemeGeometries, nsITheme::ThemeGeometryType aThemeGeometryType) { for (uint32_t i = 0; i < aThemeGeometries.Length(); ++i) { const nsIWidget::ThemeGeometry& g = aThemeGeometries[i]; if (g.mType == aThemeGeometryType) { return g.mRect; } } return LayoutDeviceIntRect(); } void nsChildView::UpdateThemeGeometries(const nsTArray& aThemeGeometries) { if (![mView window]) return; UpdateVibrancy(aThemeGeometries); if (![[mView window] isKindOfClass:[ToolbarWindow class]]) return; // Update unified toolbar height and sheet attachment position. int32_t windowWidth = mBounds.width; int32_t titlebarBottom = FindTitlebarBottom(aThemeGeometries, windowWidth); int32_t unifiedToolbarBottom = FindUnifiedToolbarBottom(aThemeGeometries, windowWidth, titlebarBottom); int32_t toolboxBottom = FindFirstRectOfType(aThemeGeometries, nsNativeThemeCocoa::eThemeGeometryTypeToolbox).YMost(); ToolbarWindow* win = (ToolbarWindow*)[mView window]; bool drawsContentsIntoWindowFrame = [win drawsContentsIntoWindowFrame]; int32_t titlebarHeight = CocoaPointsToDevPixels([win titlebarHeight]); int32_t contentOffset = drawsContentsIntoWindowFrame ? titlebarHeight : 0; int32_t devUnifiedHeight = titlebarHeight + unifiedToolbarBottom - contentOffset; [win setUnifiedToolbarHeight:DevPixelsToCocoaPoints(devUnifiedHeight)]; #if(0) // This gets called a lot, and is useless spinning on 10.4. int32_t devSheetPosition = titlebarHeight + std::max(toolboxBottom, unifiedToolbarBottom) - contentOffset; [win setSheetAttachmentPosition:DevPixelsToCocoaPoints(devSheetPosition)]; #endif // Update titlebar control offsets. LayoutDeviceIntRect windowButtonRect = FindFirstRectOfType(aThemeGeometries, nsNativeThemeCocoa::eThemeGeometryTypeWindowButtons); [win placeWindowButtons:[mView convertRect:DevPixelsToCocoaPoints(windowButtonRect) toView:nil]]; LayoutDeviceIntRect fullScreenButtonRect = FindFirstRectOfType(aThemeGeometries, nsNativeThemeCocoa::eThemeGeometryTypeFullscreenButton); [win placeFullScreenButton:[mView convertRect:DevPixelsToCocoaPoints(fullScreenButtonRect) toView:nil]]; } static LayoutDeviceIntRegion GatherThemeGeometryRegion(const nsTArray& aThemeGeometries, nsITheme::ThemeGeometryType aThemeGeometryType) { LayoutDeviceIntRegion region; for (size_t i = 0; i < aThemeGeometries.Length(); ++i) { const nsIWidget::ThemeGeometry& g = aThemeGeometries[i]; if (g.mType == aThemeGeometryType) { region.OrWith(g.mRect); } } return region; } template static void MakeRegionsNonOverlappingImpl(Region& aOutUnion) { } template static void MakeRegionsNonOverlappingImpl(Region& aOutUnion, Region& aFirst, Regions& ... aRest) { MakeRegionsNonOverlappingImpl(aOutUnion, aRest...); aFirst.SubOut(aOutUnion); aOutUnion.OrWith(aFirst); } // Subtracts parts from regions in such a way that they don't have any overlap. // Each region in the argument list will have the union of all the regions // *following* it subtracted from itself. In other words, the arguments are // sorted low priority to high priority. template static void MakeRegionsNonOverlapping(Region& aFirst, Regions& ... aRest) { Region unionOfAll; MakeRegionsNonOverlappingImpl(unionOfAll, aFirst, aRest...); } void nsChildView::UpdateVibrancy(const nsTArray& aThemeGeometries) { if (!VibrancyManager::SystemSupportsVibrancy()) { return; } LayoutDeviceIntRegion sheetRegion = GatherThemeGeometryRegion(aThemeGeometries, nsNativeThemeCocoa::eThemeGeometryTypeSheet); LayoutDeviceIntRegion vibrantLightRegion = GatherThemeGeometryRegion(aThemeGeometries, nsNativeThemeCocoa::eThemeGeometryTypeVibrancyLight); LayoutDeviceIntRegion vibrantDarkRegion = GatherThemeGeometryRegion(aThemeGeometries, nsNativeThemeCocoa::eThemeGeometryTypeVibrancyDark); LayoutDeviceIntRegion menuRegion = GatherThemeGeometryRegion(aThemeGeometries, nsNativeThemeCocoa::eThemeGeometryTypeMenu); LayoutDeviceIntRegion tooltipRegion = GatherThemeGeometryRegion(aThemeGeometries, nsNativeThemeCocoa::eThemeGeometryTypeTooltip); LayoutDeviceIntRegion highlightedMenuItemRegion = GatherThemeGeometryRegion(aThemeGeometries, nsNativeThemeCocoa::eThemeGeometryTypeHighlightedMenuItem); MakeRegionsNonOverlapping(sheetRegion, vibrantLightRegion, vibrantDarkRegion, menuRegion, tooltipRegion, highlightedMenuItemRegion); auto& vm = EnsureVibrancyManager(); vm.UpdateVibrantRegion(VibrancyType::LIGHT, vibrantLightRegion); vm.UpdateVibrantRegion(VibrancyType::TOOLTIP, tooltipRegion); vm.UpdateVibrantRegion(VibrancyType::MENU, menuRegion); vm.UpdateVibrantRegion(VibrancyType::HIGHLIGHTED_MENUITEM, highlightedMenuItemRegion); vm.UpdateVibrantRegion(VibrancyType::SHEET, sheetRegion); vm.UpdateVibrantRegion(VibrancyType::DARK, vibrantDarkRegion); } void nsChildView::ClearVibrantAreas() { if (VibrancyManager::SystemSupportsVibrancy()) { EnsureVibrancyManager().ClearVibrantAreas(); } } static VibrancyType ThemeGeometryTypeToVibrancyType(nsITheme::ThemeGeometryType aThemeGeometryType) { switch (aThemeGeometryType) { case nsNativeThemeCocoa::eThemeGeometryTypeVibrancyLight: return VibrancyType::LIGHT; case nsNativeThemeCocoa::eThemeGeometryTypeVibrancyDark: return VibrancyType::DARK; case nsNativeThemeCocoa::eThemeGeometryTypeTooltip: return VibrancyType::TOOLTIP; case nsNativeThemeCocoa::eThemeGeometryTypeMenu: return VibrancyType::MENU; case nsNativeThemeCocoa::eThemeGeometryTypeHighlightedMenuItem: return VibrancyType::HIGHLIGHTED_MENUITEM; case nsNativeThemeCocoa::eThemeGeometryTypeSheet: return VibrancyType::SHEET; default: MOZ_CRASH(); } } NSColor* nsChildView::VibrancyFillColorForThemeGeometryType(nsITheme::ThemeGeometryType aThemeGeometryType) { if (VibrancyManager::SystemSupportsVibrancy()) { return EnsureVibrancyManager().VibrancyFillColorForType( ThemeGeometryTypeToVibrancyType(aThemeGeometryType)); } return [NSColor whiteColor]; } NSColor* nsChildView::VibrancyFontSmoothingBackgroundColorForThemeGeometryType(nsITheme::ThemeGeometryType aThemeGeometryType) { if (VibrancyManager::SystemSupportsVibrancy()) { return EnsureVibrancyManager().VibrancyFontSmoothingBackgroundColorForType( ThemeGeometryTypeToVibrancyType(aThemeGeometryType)); } return [NSColor clearColor]; } mozilla::VibrancyManager& nsChildView::EnsureVibrancyManager() { MOZ_ASSERT(mView, "Only call this once we have a view!"); if (!mVibrancyManager) { mVibrancyManager = MakeUnique(*this, mView); } return *mVibrancyManager; } nsChildView::SwipeInfo nsChildView::SendMayStartSwipe(const mozilla::PanGestureInput& aSwipeStartEvent) { nsCOMPtr kungFuDeathGrip(this); uint32_t direction = (aSwipeStartEvent.mPanDisplacement.x > 0.0) ? (uint32_t)nsIDOMSimpleGestureEvent::DIRECTION_RIGHT : (uint32_t)nsIDOMSimpleGestureEvent::DIRECTION_LEFT; // We're ready to start the animation. Tell Gecko about it, and at the same // time ask it if it really wants to start an animation for this event. // This event also reports back the directions that we can swipe in. LayoutDeviceIntPoint position = RoundedToInt(aSwipeStartEvent.mPanStartPoint * ScreenToLayoutDeviceScale(1)); WidgetSimpleGestureEvent geckoEvent = SwipeTracker::CreateSwipeGestureEvent(eSwipeGestureMayStart, this, position); geckoEvent.direction = direction; geckoEvent.delta = 0.0; geckoEvent.allowedDirections = 0; bool shouldStartSwipe = DispatchWindowEvent(geckoEvent); // event cancelled == swipe should start SwipeInfo result = { shouldStartSwipe, geckoEvent.allowedDirections }; return result; } void nsChildView::TrackScrollEventAsSwipe(const mozilla::PanGestureInput& aSwipeStartEvent, uint32_t aAllowedDirections) { // If a swipe is currently being tracked kill it -- it's been interrupted // by another gesture event. if (mSwipeTracker) { mSwipeTracker->CancelSwipe(); mSwipeTracker->Destroy(); mSwipeTracker = nullptr; } uint32_t direction = (aSwipeStartEvent.mPanDisplacement.x > 0.0) ? (uint32_t)nsIDOMSimpleGestureEvent::DIRECTION_RIGHT : (uint32_t)nsIDOMSimpleGestureEvent::DIRECTION_LEFT; mSwipeTracker = new SwipeTracker(*this, aSwipeStartEvent, aAllowedDirections, direction); if (!mAPZC) { mCurrentPanGestureBelongsToSwipe = true; } } void nsChildView::SwipeFinished() { mSwipeTracker = nullptr; } already_AddRefed nsChildView::StartRemoteDrawingInRegion(nsIntRegion& aInvalidRegion) { // should have created the GLPresenter in InitCompositor. MOZ_ASSERT(mGLPresenter); if (!mGLPresenter) { mGLPresenter = GLPresenter::CreateForWindow(this); if (!mGLPresenter) { return nullptr; } } LayoutDeviceIntRegion dirtyRegion(LayoutDeviceIntRegion::FromUnknownRegion(aInvalidRegion)); LayoutDeviceIntSize renderSize = LayoutDeviceIntSize::FromUnknownSize(mBounds.Size()); if (!mBasicCompositorImage) { mBasicCompositorImage = new RectTextureImage(mGLPresenter->gl()); } RefPtr drawTarget = mBasicCompositorImage->BeginUpdate(renderSize, dirtyRegion); if (!drawTarget) { // Composite unchanged textures. DoRemoteComposition(LayoutDeviceIntRect::FromUnknownRect(mBounds)); return nullptr; } aInvalidRegion = mBasicCompositorImage->GetUpdateRegion().ToUnknownRegion(); return drawTarget.forget(); } void nsChildView::EndRemoteDrawing() { mBasicCompositorImage->EndUpdate(true); DoRemoteComposition(LayoutDeviceIntRect::FromUnknownRect(mBounds)); } void nsChildView::CleanupRemoteDrawing() { mBasicCompositorImage = nullptr; mCornerMaskImage = nullptr; mResizerImage = nullptr; mTitlebarImage = nullptr; mGLPresenter = nullptr; } bool nsChildView::InitCompositor(Compositor* aCompositor) { if (aCompositor->GetBackendType() == LayersBackend::LAYERS_BASIC) { if (!mGLPresenter) { mGLPresenter = GLPresenter::CreateForWindow(this); } return !!mGLPresenter; } return true; } void nsChildView::DoRemoteComposition(const LayoutDeviceIntRect& aRenderRect) { if (![(ChildView*)mView preRender:mGLPresenter->GetNSOpenGLContext()]) { return; } mGLPresenter->BeginFrame(aRenderRect.Size()); // Draw the result from the basic compositor. mBasicCompositorImage->Draw(mGLPresenter, LayoutDeviceIntPoint(0, 0)); // DrawWindowOverlay doesn't do anything for non-GL, so it didn't paint // anything during the basic compositor transaction. Draw the overlay now. DrawWindowOverlay(mGLPresenter, aRenderRect); mGLPresenter->EndFrame(); [(ChildView*)mView postRender:mGLPresenter->GetNSOpenGLContext()]; } void nsChildView::UpdateWindowDraggingRegion(const LayoutDeviceIntRegion& aRegion) { if (mDraggableRegion != aRegion) { mDraggableRegion = aRegion; [(ChildView*)mView updateWindowDraggableState]; } } void nsChildView::ReportSwipeStarted(uint64_t aInputBlockId, bool aStartSwipe) { if (mSwipeEventQueue && mSwipeEventQueue->inputBlockId == aInputBlockId) { if (aStartSwipe) { PanGestureInput& startEvent = mSwipeEventQueue->queuedEvents[0]; TrackScrollEventAsSwipe(startEvent, mSwipeEventQueue->allowedDirections); for (size_t i = 1; i < mSwipeEventQueue->queuedEvents.Length(); i++) { mSwipeTracker->ProcessEvent(mSwipeEventQueue->queuedEvents[i]); } } mSwipeEventQueue = nullptr; } } void nsChildView::DispatchAPZWheelInputEvent(InputData& aEvent, bool aCanTriggerSwipe) { if (mSwipeTracker && aEvent.mInputType == PANGESTURE_INPUT) { // Give the swipe tracker a first pass at the event. If a new pan gesture // has been started since the beginning of the swipe, the swipe tracker // will know to ignore the event. nsEventStatus status = mSwipeTracker->ProcessEvent(aEvent.AsPanGestureInput()); if (status == nsEventStatus_eConsumeNoDefault) { return; } } WidgetWheelEvent event(true, eWheel, this); if (mAPZC) { uint64_t inputBlockId = 0; ScrollableLayerGuid guid; nsEventStatus result = mAPZC->ReceiveInputEvent(aEvent, &guid, &inputBlockId); if (result == nsEventStatus_eConsumeNoDefault) { return; } switch(aEvent.mInputType) { case PANGESTURE_INPUT: { PanGestureInput& panInput = aEvent.AsPanGestureInput(); event = panInput.ToWidgetWheelEvent(this); if (aCanTriggerSwipe) { SwipeInfo swipeInfo = SendMayStartSwipe(panInput); event.mCanTriggerSwipe = swipeInfo.wantsSwipe; if (swipeInfo.wantsSwipe) { if (result == nsEventStatus_eIgnore) { // APZ has determined and that scrolling horizontally in the // requested direction is impossible, so it didn't do any // scrolling for the event. // We know now that MayStartSwipe wants a swipe, so we can start // the swipe now. TrackScrollEventAsSwipe(panInput, swipeInfo.allowedDirections); } else { // We don't know whether this event can start a swipe, so we need // to queue up events and wait for a call to ReportSwipeStarted. // APZ might already have started scrolling in response to the // event if it knew that it's the right thing to do. In that case // we'll still get a call to ReportSwipeStarted, and we will // discard the queued events at that point. mSwipeEventQueue = MakeUnique(swipeInfo.allowedDirections, inputBlockId); } } } if (mSwipeEventQueue && mSwipeEventQueue->inputBlockId == inputBlockId) { mSwipeEventQueue->queuedEvents.AppendElement(panInput); } break; } case SCROLLWHEEL_INPUT: { event = aEvent.AsScrollWheelInput().ToWidgetWheelEvent(this); break; }; default: MOZ_CRASH("unsupported event type"); return; } if (event.mMessage == eWheel && (event.deltaX != 0 || event.deltaY != 0)) { ProcessUntransformedAPZEvent(&event, guid, inputBlockId, result); } return; } nsEventStatus status; switch(aEvent.mInputType) { case PANGESTURE_INPUT: { PanGestureInput panInput = aEvent.AsPanGestureInput(); if (panInput.mType == PanGestureInput::PANGESTURE_MAYSTART || panInput.mType == PanGestureInput::PANGESTURE_START) { mCurrentPanGestureBelongsToSwipe = false; } if (mCurrentPanGestureBelongsToSwipe) { // Ignore this event. It's a momentum event from a scroll gesture // that was processed as a swipe, and the swipe animation has // already finished (so mSwipeTracker is already null). MOZ_ASSERT(panInput.IsMomentum(), "If the fingers are still on the touchpad, we should still have a SwipeTracker, and it should have consumed this event."); return; } event = panInput.ToWidgetWheelEvent(this); if (aCanTriggerSwipe) { SwipeInfo swipeInfo = SendMayStartSwipe(panInput); // We're in the non-APZ case here, but we still want to know whether // the event was routed to a child process, so we use InputAPZContext // to get that piece of information. ScrollableLayerGuid guid; InputAPZContext context(guid, 0, nsEventStatus_eIgnore); event.mCanTriggerSwipe = swipeInfo.wantsSwipe; DispatchEvent(&event, status); if (swipeInfo.wantsSwipe) { if (context.WasRoutedToChildProcess()) { // We don't know whether this event can start a swipe, so we need // to queue up events and wait for a call to ReportSwipeStarted. mSwipeEventQueue = MakeUnique(swipeInfo.allowedDirections, 0); } else if (event.TriggersSwipe()) { TrackScrollEventAsSwipe(panInput, swipeInfo.allowedDirections); } } if (mSwipeEventQueue && mSwipeEventQueue->inputBlockId == 0) { mSwipeEventQueue->queuedEvents.AppendElement(panInput); } return; } break; } case SCROLLWHEEL_INPUT: { event = aEvent.AsScrollWheelInput().ToWidgetWheelEvent(this); break; } default: MOZ_CRASH("unexpected event type"); return; } if (event.mMessage == eWheel && (event.deltaX != 0 || event.deltaY != 0)) { DispatchEvent(&event, status); } } #ifdef ACCESSIBILITY already_AddRefed nsChildView::GetDocumentAccessible() { if (!mozilla::a11y::ShouldA11yBeEnabled()) return nullptr; if (mAccessible) { RefPtr ret; CallQueryReferent(mAccessible.get(), static_cast(getter_AddRefs(ret))); return ret.forget(); } // need to fetch the accessible anew, because it has gone away. // cache the accessible in our weak ptr RefPtr acc = GetRootAccessible(); mAccessible = do_GetWeakReference(acc.get()); return acc.forget(); } #endif // RectTextureImage implementation RectTextureImage::~RectTextureImage() { if (mTexture) { mGLContext->MakeCurrent(); mGLContext->fDeleteTextures(1, &mTexture); mTexture = 0; } } LayoutDeviceIntSize RectTextureImage::TextureSizeForSize(const LayoutDeviceIntSize& aSize) { return LayoutDeviceIntSize(gfx::NextPowerOfTwo(aSize.width), gfx::NextPowerOfTwo(aSize.height)); } already_AddRefed RectTextureImage::BeginUpdate(const LayoutDeviceIntSize& aNewSize, const LayoutDeviceIntRegion& aDirtyRegion) { MOZ_ASSERT(!mInUpdate, "Beginning update during update!"); mUpdateRegion = aDirtyRegion; if (aNewSize != mUsedSize) { mUsedSize = aNewSize; mUpdateRegion = LayoutDeviceIntRect(LayoutDeviceIntPoint(0, 0), aNewSize); } if (mUpdateRegion.IsEmpty()) { return nullptr; } LayoutDeviceIntSize neededBufferSize = TextureSizeForSize(mUsedSize); if (!mUpdateDrawTarget || mBufferSize != neededBufferSize) { gfx::IntSize size(neededBufferSize.width, neededBufferSize.height); mUpdateDrawTarget = gfx::Factory::CreateDrawTarget(gfx::BackendType::COREGRAPHICS, size, gfx::SurfaceFormat::B8G8R8A8); mBufferSize = neededBufferSize; } mInUpdate = true; RefPtr drawTarget = mUpdateDrawTarget; return drawTarget.forget(); } #define NSFoundationVersionWithProperStrideSupportForSubtextureUpload NSFoundationVersionNumber10_6_3 static bool CanUploadSubtextures() { return false; /* return NSFoundationVersionNumber >= NSFoundationVersionWithProperStrideSupportForSubtextureUpload; */ } void RectTextureImage::EndUpdate(bool aKeepSurface) { MOZ_ASSERT(mInUpdate, "Ending update while not in update"); bool overwriteTexture = false; LayoutDeviceIntRegion updateRegion = mUpdateRegion; if (!mTexture || (mTextureSize != mBufferSize)) { overwriteTexture = true; mTextureSize = mBufferSize; } if (overwriteTexture || !CanUploadSubtextures()) { updateRegion = LayoutDeviceIntRect(LayoutDeviceIntPoint(0, 0), mTextureSize); } RefPtr snapshot = mUpdateDrawTarget->Snapshot(); RefPtr dataSnapshot = snapshot->GetDataSurface(); UploadSurfaceToTexture(mGLContext, dataSnapshot, updateRegion.ToUnknownRegion(), mTexture, overwriteTexture, updateRegion.GetBounds().TopLeft().ToUnknownPoint(), false, LOCAL_GL_TEXTURE0, LOCAL_GL_TEXTURE_RECTANGLE_ARB); if (!aKeepSurface) { mUpdateDrawTarget = nullptr; } mInUpdate = false; } void RectTextureImage::UpdateFromCGContext(const LayoutDeviceIntSize& aNewSize, const LayoutDeviceIntRegion& aDirtyRegion, CGContextRef aCGContext) { gfx::IntSize size = gfx::IntSize(CGBitmapContextGetWidth(aCGContext), CGBitmapContextGetHeight(aCGContext)); mBufferSize.SizeTo(size.width, size.height); RefPtr dt = BeginUpdate(aNewSize, aDirtyRegion); if (dt) { gfx::Rect rect(0, 0, size.width, size.height); gfxUtils::ClipToRegion(dt, GetUpdateRegion().ToUnknownRegion()); RefPtr sourceSurface = dt->CreateSourceSurfaceFromData(static_cast(CGBitmapContextGetData(aCGContext)), size, CGBitmapContextGetBytesPerRow(aCGContext), gfx::SurfaceFormat::B8G8R8A8); dt->DrawSurface(sourceSurface, rect, rect, gfx::DrawSurfaceOptions(), gfx::DrawOptions(1.0, gfx::CompositionOp::OP_SOURCE)); dt->PopClip(); EndUpdate(); } } void RectTextureImage::Draw(GLManager* aManager, const LayoutDeviceIntPoint& aLocation, const Matrix4x4& aTransform) { ShaderProgramOGL* program = aManager->GetProgram(LOCAL_GL_TEXTURE_RECTANGLE_ARB, gfx::SurfaceFormat::R8G8B8A8); aManager->gl()->fActiveTexture(LOCAL_GL_TEXTURE0); aManager->gl()->fBindTexture(LOCAL_GL_TEXTURE_RECTANGLE_ARB, mTexture); aManager->ActivateProgram(program); program->SetProjectionMatrix(aManager->GetProjMatrix()); program->SetLayerTransform(Matrix4x4(aTransform).PostTranslate(aLocation.x, aLocation.y, 0)); program->SetTextureTransform(gfx::Matrix4x4()); program->SetRenderOffset(nsIntPoint(0, 0)); program->SetTexCoordMultiplier(mUsedSize.width, mUsedSize.height); program->SetTextureUnit(0); aManager->BindAndDrawQuad(program, gfx::Rect(0.0, 0.0, mUsedSize.width, mUsedSize.height), gfx::Rect(0.0, 0.0, 1.0f, 1.0f)); aManager->gl()->fBindTexture(LOCAL_GL_TEXTURE_RECTANGLE_ARB, 0); } // GLPresenter implementation GLPresenter::GLPresenter(GLContext* aContext) : mGLContext(aContext) { mGLContext->MakeCurrent(); ShaderConfigOGL config; config.SetTextureTarget(LOCAL_GL_TEXTURE_RECTANGLE_ARB); mRGBARectProgram = new ShaderProgramOGL(mGLContext, ProgramProfileOGL::GetProfileFor(config)); // Create mQuadVBO. mGLContext->fGenBuffers(1, &mQuadVBO); mGLContext->fBindBuffer(LOCAL_GL_ARRAY_BUFFER, mQuadVBO); // 1 quad, with the number of the quad (vertexID) encoded in w. GLfloat vertices[] = { 0.0f, 0.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f, 1.0f, 1.0f, 0.0f, 0.0f, }; HeapCopyOfStackArray verticesOnHeap(vertices); mGLContext->fBufferData(LOCAL_GL_ARRAY_BUFFER, verticesOnHeap.ByteLength(), verticesOnHeap.Data(), LOCAL_GL_STATIC_DRAW); mGLContext->fBindBuffer(LOCAL_GL_ARRAY_BUFFER, 0); } GLPresenter::~GLPresenter() { if (mQuadVBO) { mGLContext->MakeCurrent(); mGLContext->fDeleteBuffers(1, &mQuadVBO); mQuadVBO = 0; } } void GLPresenter::BindAndDrawQuad(ShaderProgramOGL *aProgram, const gfx::Rect& aLayerRect, const gfx::Rect& aTextureRect) { mGLContext->MakeCurrent(); gfx::Rect layerRects[4]; gfx::Rect textureRects[4]; layerRects[0] = aLayerRect; textureRects[0] = aTextureRect; aProgram->SetLayerRects(layerRects); aProgram->SetTextureRects(textureRects); const GLuint coordAttribIndex = 0; mGLContext->fBindBuffer(LOCAL_GL_ARRAY_BUFFER, mQuadVBO); mGLContext->fVertexAttribPointer(coordAttribIndex, 4, LOCAL_GL_FLOAT, LOCAL_GL_FALSE, 0, (GLvoid*)0); mGLContext->fEnableVertexAttribArray(coordAttribIndex); mGLContext->fDrawArrays(LOCAL_GL_TRIANGLES, 0, 6); mGLContext->fDisableVertexAttribArray(coordAttribIndex); } void GLPresenter::BeginFrame(LayoutDeviceIntSize aRenderSize) { mGLContext->MakeCurrent(); mGLContext->fViewport(0, 0, aRenderSize.width, aRenderSize.height); // Matrix to transform (0, 0, width, height) to viewport space (-1.0, 1.0, // 2, 2) and flip the contents. gfx::Matrix viewMatrix = gfx::Matrix::Translation(-1.0, 1.0); viewMatrix.PreScale(2.0f / float(aRenderSize.width), 2.0f / float(aRenderSize.height)); viewMatrix.PreScale(1.0f, -1.0f); gfx::Matrix4x4 matrix3d = gfx::Matrix4x4::From2D(viewMatrix); matrix3d._33 = 0.0f; // set the projection matrix for the next time the program is activated mProjMatrix = matrix3d; // Default blend function implements "OVER" mGLContext->fBlendFuncSeparate(LOCAL_GL_ONE, LOCAL_GL_ONE_MINUS_SRC_ALPHA, LOCAL_GL_ONE, LOCAL_GL_ONE); mGLContext->fEnable(LOCAL_GL_BLEND); mGLContext->fClearColor(0.0, 0.0, 0.0, 0.0); mGLContext->fClear(LOCAL_GL_COLOR_BUFFER_BIT | LOCAL_GL_DEPTH_BUFFER_BIT); mGLContext->fEnable(LOCAL_GL_TEXTURE_RECTANGLE_ARB); } void GLPresenter::EndFrame() { mGLContext->SwapBuffers(); mGLContext->fBindBuffer(LOCAL_GL_ARRAY_BUFFER, 0); } #pragma mark - @implementation ChildView // globalDragPboard is non-null during native drag sessions that did not originate // in our native NSView (it is set in |draggingEntered:|). It is unset when the // drag session ends for this view, either with the mouse exiting or when a drop // occurs in this view. // restore bug 966986 NSPasteboardWrapper* globalDragPboard = nil; // gLastDragView and gLastDragMouseDownEvent are used to communicate information // to the drag service during drag invocation (starting a drag in from the view). // gLastDragView is only non-null while mouseDragged is on the call stack. NSView* gLastDragView = nil; NSEvent* gLastDragMouseDownEvent = nil; + (void)initialize { static BOOL initialized = NO; if (!initialized) { // Inform the OS about the types of services (from the "Services" menu) // that we can handle. NSArray *sendTypes = [[NSArray alloc] initWithObjects:NSStringPboardType,NSHTMLPboardType,nil]; NSArray *returnTypes = [[NSArray alloc] initWithObjects:NSStringPboardType,NSHTMLPboardType,nil]; [NSApp registerServicesMenuSendTypes:sendTypes returnTypes:returnTypes]; [sendTypes release]; [returnTypes release]; initialized = YES; } } + (void)registerViewForDraggedTypes:(NSView*)aView { [aView registerForDraggedTypes:[NSArray arrayWithObjects:NSFilenamesPboardType, NSStringPboardType, NSHTMLPboardType, NSURLPboardType, NSFilesPromisePboardType, kWildcardPboardType, kCorePboardType_url, kCorePboardType_urld, kCorePboardType_urln, nil]]; } // initWithFrame:geckoChild: - (id)initWithFrame:(NSRect)inFrame geckoChild:(nsChildView*)inChild { NS_OBJC_BEGIN_TRY_ABORT_BLOCK_NIL; if ((self = [super initWithFrame:inFrame])) { mGeckoChild = inChild; mPendingDisplay = NO; mBlockedLastMouseDown = NO; mExpectingWheelStop = NO; mLastMouseDownEvent = nil; mLastKeyDownEvent = nil; mClickThroughMouseDownEvent = nil; mDragService = nullptr; mGestureState = eGestureState_None; mCumulativeMagnification = 0.0; mCumulativeRotation = 0.0; mCurKeyEvent = nil; mKeyDownHandled = false; mKeyPressHandled = NO; mKeyPressSent = NO; mIgnoreNextKeyUpEvent = NO; // initialization for NSTextInput mMarkedRange.location = NSNotFound; mMarkedRange.length = 0; // We can't call forceRefreshOpenGL here because, in order to work around // the bug, it seems we need to have a draw already happening. Therefore, // we call it in drawRect:inContext:, when we know that a draw is in // progress. mDidForceRefreshOpenGL = NO; [self setFocusRingType:NSFocusRingTypeNone]; #ifdef __LP64__ mCancelSwipeAnimation = nil; #endif mTopLeftCornerMask = NULL; } // register for things we'll take from other applications [ChildView registerViewForDraggedTypes:self]; [[NSNotificationCenter defaultCenter] addObserver:self selector:@selector(systemMetricsChanged) name:NSControlTintDidChangeNotification object:nil]; [[NSNotificationCenter defaultCenter] addObserver:self selector:@selector(systemMetricsChanged) name:NSSystemColorsDidChangeNotification object:nil]; // TODO: replace the string with the constant once we build with the 10.7 SDK [[NSNotificationCenter defaultCenter] addObserver:self selector:@selector(scrollbarSystemMetricChanged) name:@"NSPreferredScrollerStyleDidChangeNotification" object:nil]; [[NSDistributedNotificationCenter defaultCenter] addObserver:self selector:@selector(systemMetricsChanged) name:@"AppleAquaScrollBarVariantChanged" object:nil suspensionBehavior:NSNotificationSuspensionBehaviorDeliverImmediately]; [[NSNotificationCenter defaultCenter] addObserver:self selector:@selector(_surfaceNeedsUpdate:) name:NSViewGlobalFrameDidChangeNotification object:self]; return self; NS_OBJC_END_TRY_ABORT_BLOCK_NIL; } // NEVER define this in pre-10.6 builds. If you do, NSTextInput doesn't work // properly (see http://prod.lists.apple.com/archives/cocoa-dev/2013/Dec/msg00068.html ). // It seems to have something to do with the secret underlying NSInputContext // and NSTSMInputContext, which became NSTextInputContext in 10.6. #if(0) // ComplexTextInputPanel's interpretKeyEvent hack won't work without this. // It makes calls to +[NSTextInputContext currentContext], deep in system // code, return the appropriate context. - (NSTextInputContext *)inputContext { NSTextInputContext* pluginContext = NULL; if (mGeckoChild && mGeckoChild->IsPluginFocused()) { ComplexTextInputPanel* ctiPanel = ComplexTextInputPanel::GetSharedComplexTextInputPanel(); if (ctiPanel) { pluginContext = (NSTextInputContext*) ctiPanel->GetInputContext(); } } if (pluginContext) { return pluginContext; } else { return [super inputContext]; } } #endif - (void)installTextInputHandler:(TextInputHandler*)aHandler { #if(0) mTextInputHandler = aHandler; #endif } - (void)uninstallTextInputHandler { #if(0) mTextInputHandler = nullptr; #endif } // Work around bug 603134. // OS X has a bug that causes new OpenGL windows to only paint once or twice, // then stop painting altogether. By clearing the drawable from the GL context, // and then resetting the view to ourselves, we convince OS X to start updating // again. // This can cause a flash in new windows - bug 631339 - but it's very hard to // fix that while maintaining this workaround. - (void)forceRefreshOpenGL { NS_OBJC_BEGIN_TRY_ABORT_BLOCK; [mGLContext clearDrawable]; [self updateGLContext]; NS_OBJC_END_TRY_ABORT_BLOCK; } - (void)setGLContext:(NSOpenGLContext *)aGLContext { NS_OBJC_BEGIN_TRY_ABORT_BLOCK; mGLContext = aGLContext; [mGLContext retain]; NS_OBJC_END_TRY_ABORT_BLOCK; } - (bool)preRender:(NSOpenGLContext *)aGLContext { NS_OBJC_BEGIN_TRY_ABORT_BLOCK_RETURN; if (![self window] || ([[self window] isKindOfClass:[BaseWindow class]] && ![(BaseWindow*)[self window] isVisibleOrBeingShown])) { // Before the window is shown, our GL context's front FBO is not // framebuffer complete, so we refuse to render. return false; } if (!mGLContext) { [self setGLContext:aGLContext]; [self updateGLContext]; } CGLLockContext((CGLContextObj)[aGLContext CGLContextObj]); return true; NS_OBJC_END_TRY_ABORT_BLOCK_RETURN(false); } - (void)postRender:(NSOpenGLContext *)aGLContext { NS_OBJC_BEGIN_TRY_ABORT_BLOCK; CGLUnlockContext((CGLContextObj)[aGLContext CGLContextObj]); NS_OBJC_END_TRY_ABORT_BLOCK; } - (void)dealloc { NS_OBJC_BEGIN_TRY_ABORT_BLOCK; [mGLContext release]; [mPendingDirtyRects release]; [mLastMouseDownEvent release]; [mLastKeyDownEvent release]; [mClickThroughMouseDownEvent release]; CGImageRelease(mTopLeftCornerMask); ChildViewMouseTracker::OnDestroyView(self); [[NSNotificationCenter defaultCenter] removeObserver:self]; [[NSDistributedNotificationCenter defaultCenter] removeObserver:self]; [super dealloc]; NS_OBJC_END_TRY_ABORT_BLOCK; } - (void)widgetDestroyed { #ifdef NS_LEOPARD_AND_LATER if (mTextInputHandler) { mTextInputHandler->OnDestroyWidget(mGeckoChild); mTextInputHandler = nullptr; } #else nsTSMManager::OnDestroyView(self); #endif mGeckoChild = nullptr; // Just in case we're destroyed abruptly and missed the draggingExited // or performDragOperation message. NS_IF_RELEASE(mDragService); } // mozView method, return our gecko child view widget. Note this does not AddRef. - (nsIWidget*) widget { return static_cast(mGeckoChild); } - (void)systemMetricsChanged { if (mGeckoChild) mGeckoChild->NotifyThemeChanged(); } - (void)scrollbarSystemMetricChanged { [self systemMetricsChanged]; if (mGeckoChild) { nsIWidgetListener* listener = mGeckoChild->GetWidgetListener(); if (listener) { nsIPresShell* presShell = listener->GetPresShell(); if (presShell) { presShell->ReconstructFrames(); } } } } - (void)setNeedsPendingDisplay { NS_OBJC_BEGIN_TRY_ABORT_BLOCK; mPendingFullDisplay = YES; if (!mPendingDisplay) { [self performSelector:@selector(processPendingRedraws) withObject:nil afterDelay:0]; mPendingDisplay = YES; } NS_OBJC_END_TRY_ABORT_BLOCK; } - (void)setNeedsPendingDisplayInRect:(NSRect)invalidRect { NS_OBJC_BEGIN_TRY_ABORT_BLOCK; if (!mPendingDirtyRects) mPendingDirtyRects = [[NSMutableArray alloc] initWithCapacity:1]; [mPendingDirtyRects addObject:[NSValue valueWithRect:invalidRect]]; if (!mPendingDisplay) { [self performSelector:@selector(processPendingRedraws) withObject:nil afterDelay:0]; mPendingDisplay = YES; } NS_OBJC_END_TRY_ABORT_BLOCK; } // Clears the queue of any pending invalides - (void)processPendingRedraws { NS_OBJC_BEGIN_TRY_ABORT_BLOCK; if (mPendingFullDisplay) { [self setNeedsDisplay:YES]; } else if (mPendingDirtyRects) { unsigned int count = [mPendingDirtyRects count]; for (unsigned int i = 0; i < count; ++i) { [self setNeedsDisplayInRect:[[mPendingDirtyRects objectAtIndex:i] rectValue]]; } } mPendingFullDisplay = NO; mPendingDisplay = NO; [mPendingDirtyRects release]; mPendingDirtyRects = nil; NS_OBJC_END_TRY_ABORT_BLOCK; } - (void)setNeedsDisplayInRect:(NSRect)aRect { if (![self isUsingOpenGL]) { [super setNeedsDisplayInRect:aRect]; return; } if ([[self window] isVisible] && [self isUsingMainThreadOpenGL]) { // Draw without calling drawRect. This prevent us from // needing to access the normal window buffer surface unnecessarily, so we // waste less time synchronizing the two surfaces. (These synchronizations // show up in a profiler as CGSDeviceLock / _CGSLockWindow / // _CGSSynchronizeWindowBackingStore.) It also means that Cocoa doesn't // have any potentially expensive invalid rect management for us. if (!mWaitingForPaint) { // 10.4 doesn't implement NSRunLoopCommonModes, and we never draw with // OpenGL anyway. #if(0) mWaitingForPaint = YES; // Use NSRunLoopCommonModes instead of the default NSDefaultRunLoopMode // so that the timer also fires while a native menu is open. [self performSelector:@selector(drawUsingOpenGLCallback) withObject:nil afterDelay:0 inModes:[NSArray arrayWithObject:NSRunLoopCommonModes]]; #else fprintf(stderr, "setNeedsDisplayInRect thinks we're using OpenGL!!\n"); #endif } } } - (NSString*)description { NS_OBJC_BEGIN_TRY_ABORT_BLOCK_NIL; return [NSString stringWithFormat:@"ChildView %p, gecko child %p, frame %@", self, mGeckoChild, NSStringFromRect([self frame])]; NS_OBJC_END_TRY_ABORT_BLOCK_NIL; } // Make the origin of this view the topLeft corner (gecko origin) rather // than the bottomLeft corner (standard cocoa origin). - (BOOL)isFlipped { return YES; } - (BOOL)isOpaque { return [[self window] isOpaque]; } - (void)sendFocusEvent:(EventMessage)eventMessage { if (!mGeckoChild) return; nsEventStatus status = nsEventStatus_eIgnore; WidgetGUIEvent focusGuiEvent(true, eventMessage, mGeckoChild); focusGuiEvent.time = PR_IntervalNow(); mGeckoChild->DispatchEvent(&focusGuiEvent, status); } // We accept key and mouse events, so don't keep passing them up the chain. Allow // this to be a 'focused' widget for event dispatch. - (BOOL)acceptsFirstResponder { return YES; } // Accept mouse down events on background windows - (BOOL)acceptsFirstMouse:(NSEvent*)aEvent { if (![[self window] isKindOfClass:[PopupWindow class]]) { // We rely on this function to tell us that the mousedown was on a // background window. Inside mouseDown we can't tell whether we were // inactive because at that point we've already been made active. // Unfortunately, acceptsFirstMouse is called for PopupWindows even when // their parent window is active, so ignore this on them for now. mClickThroughMouseDownEvent = [aEvent retain]; } return YES; } - (void)scrollRect:(NSRect)aRect by:(NSSize)offset { NS_OBJC_BEGIN_TRY_ABORT_BLOCK; // Update any pending dirty rects to reflect the new scroll position if (mPendingDirtyRects) { unsigned int count = [mPendingDirtyRects count]; for (unsigned int i = 0; i < count; ++i) { NSRect oldRect = [[mPendingDirtyRects objectAtIndex:i] rectValue]; NSRect newRect = NSOffsetRect(oldRect, offset.width, offset.height); [mPendingDirtyRects replaceObjectAtIndex:i withObject:[NSValue valueWithRect:newRect]]; } } [super scrollRect:aRect by:offset]; NS_OBJC_END_TRY_ABORT_BLOCK; } - (BOOL)mouseDownCanMoveWindow { // Return YES so that _regionForOpaqueDescendants gets called, where the // actual draggable region will be assembled. return YES; } -(void)updateGLContext { if (mGLContext) { CGLLockContext((CGLContextObj)[mGLContext CGLContextObj]); [mGLContext setView:self]; [mGLContext update]; CGLUnlockContext((CGLContextObj)[mGLContext CGLContextObj]); } } - (void)_surfaceNeedsUpdate:(NSNotification*)notification { [self updateGLContext]; } - (BOOL)wantsBestResolutionOpenGLSurface { return nsCocoaUtils::HiDPIEnabled() ? YES : NO; } - (void)viewDidChangeBackingProperties { [super viewDidChangeBackingProperties]; #if(0) if (mGeckoChild) { // actually, it could be the color space that's changed, // but we can't tell the difference here except by retrieving // the backing scale factor and comparing to the old value mGeckoChild->BackingScaleFactorChanged(); } #endif } - (BOOL)isCoveringTitlebar { return [[self window] isKindOfClass:[BaseWindow class]] && [(BaseWindow*)[self window] mainChildView] == self && [(BaseWindow*)[self window] drawsContentsIntoWindowFrame]; } - (void)viewWillStartLiveResize { nsCOMPtr observerService = mozilla::services::GetObserverService(); if (!observerService) { return; } observerService->NotifyObservers(nullptr, "live-resize-start", nullptr); } - (void)viewDidEndLiveResize { nsCOMPtr observerService = mozilla::services::GetObserverService(); if (!observerService) { return; } observerService->NotifyObservers(nullptr, "live-resize-end", nullptr); } - (NSColor*)vibrancyFillColorForThemeGeometryType:(nsITheme::ThemeGeometryType)aThemeGeometryType { if (!mGeckoChild) { return [NSColor whiteColor]; } return mGeckoChild->VibrancyFillColorForThemeGeometryType(aThemeGeometryType); } - (NSColor*)vibrancyFontSmoothingBackgroundColorForThemeGeometryType:(nsITheme::ThemeGeometryType)aThemeGeometryType { if (!mGeckoChild) { return [NSColor clearColor]; } return mGeckoChild->VibrancyFontSmoothingBackgroundColorForThemeGeometryType(aThemeGeometryType); } - (LayoutDeviceIntRegion)nativeDirtyRegionWithBoundingRect:(NSRect)aRect { LayoutDeviceIntRect boundingRect = mGeckoChild->CocoaPointsToDevPixels(aRect); const NSRect *rects; NSInteger count; [self getRectsBeingDrawn:&rects count:&count]; if (count > MAX_RECTS_IN_REGION) { return boundingRect; } LayoutDeviceIntRegion region; for (NSInteger i = 0; i < count; ++i) { region.Or(region, mGeckoChild->CocoaPointsToDevPixels(rects[i])); } region.And(region, boundingRect); return region; } // The display system has told us that a portion of our view is dirty. Tell // gecko to paint it - (void)drawRect:(NSRect)aRect { CGContextRef cgContext = (CGContextRef)[[NSGraphicsContext currentContext] graphicsPort]; [self drawRect:aRect inContext:cgContext]; // If we're a transparent window and our contents have changed, we need // to make sure the shadow is updated to the new contents. if ([[self window] isKindOfClass:[BaseWindow class]]) { [(BaseWindow*)[self window] deferredInvalidateShadow]; } } - (void)drawRect:(NSRect)aRect inContext:(CGContextRef)aContext { if (!mGeckoChild || !mGeckoChild->IsVisible()) return; #ifdef DEBUG_UPDATE LayoutDeviceIntRect geckoBounds; mGeckoChild->GetBounds(geckoBounds); fprintf (stderr, "---- Update[%p][%p] [%f %f %f %f] cgc: %p\n gecko bounds: [%d %d %d %d]\n", self, mGeckoChild, aRect.origin.x, aRect.origin.y, aRect.size.width, aRect.size.height, aContext, geckoBounds.x, geckoBounds.y, geckoBounds.width, geckoBounds.height); CGAffineTransform xform = CGContextGetCTM(aContext); fprintf (stderr, " xform in: [%f %f %f %f %f %f]\n", xform.a, xform.b, xform.c, xform.d, xform.tx, xform.ty); #endif if ([self isUsingOpenGL]) { // For Gecko-initiated repaints in OpenGL mode, drawUsingOpenGL is // directly called from a delayed perform callback - without going through // drawRect. // Paints that come through here are triggered by something that Cocoa // controls, for example by window resizing or window focus changes. // Since this view is usually declared as opaque, the window's pixel // buffer may now contain garbage which we need to prevent from reaching // the screen. The only place where garbage can show is in the window // corners and the vibrant regions of the window - the rest of the window // is covered by opaque content in our OpenGL surface. // So we need to clear the pixel buffer contents in these areas. mGeckoChild->ClearVibrantAreas(); [self clearCorners]; // Do GL composition and return. [self drawUsingOpenGL]; return; } PROFILER_LABEL("ChildView", "drawRect", js::ProfileEntry::Category::GRAPHICS); // The CGContext that drawRect supplies us with comes with a transform that // scales one user space unit to one Cocoa point, which can consist of // multiple dev pixels. But Gecko expects its supplied context to be scaled // to device pixels, so we need to reverse the scaling. //double scale = mGeckoChild->BackingScaleFactor(); CGContextSaveGState(aContext); CGContextScaleCTM(aContext, 1.0, 1.0); //CGContextScaleCTM(aContext, 1.0 / scale, 1.0 / scale); NSSize viewSize = [self bounds].size; //nsIntSize backingSize(viewSize.width * scale, viewSize.height * scale); nsIntSize backingSize(viewSize.width, viewSize.height); CGContextSaveGState(aContext); LayoutDeviceIntRegion region = [self nativeDirtyRegionWithBoundingRect:aRect]; // Create Cairo objects. RefPtr targetSurface; RefPtr dt = gfx::Factory::CreateDrawTargetForCairoCGContext(aContext, gfx::IntSize(backingSize.width, backingSize.height)); MOZ_ASSERT(dt); // see implementation dt->AddUserData(&gfxContext::sDontUseAsSourceKey, dt, nullptr); RefPtr targetContext = new gfxContext(dt); // Set up the clip region. LayoutDeviceIntRegion::RectIterator iter(region); targetContext->NewPath(); for (;;) { const LayoutDeviceIntRect* r = iter.Next(); if (!r) break; targetContext->Rectangle(gfxRect(r->x, r->y, r->width, r->height)); } targetContext->Clip(); nsAutoRetainCocoaObject kungFuDeathGrip(self); bool painted = false; if (mGeckoChild->GetLayerManager()->GetBackendType() == LayersBackend::LAYERS_BASIC) { nsBaseWidget::AutoLayerManagerSetup setupLayerManager(mGeckoChild, targetContext, BufferMode::BUFFER_NONE); painted = mGeckoChild->PaintWindow(region); } else if (mGeckoChild->GetLayerManager()->GetBackendType() == LayersBackend::LAYERS_CLIENT) { // We only need this so that we actually get DidPaintWindow fired painted = mGeckoChild->PaintWindow(region); } targetContext = nullptr; targetSurface = nullptr; CGContextRestoreGState(aContext); // Undo the scale transform so that from now on the context is in // CocoaPoints again. CGContextRestoreGState(aContext); if (!painted && [self isOpaque]) { // Gecko refused to draw, but we've claimed to be opaque, so we have to // draw something--fill with white. CGContextSetRGBFillColor(aContext, 1, 1, 1, 1); //CGContextFillRect(aContext, NSRectToCGRect(aRect)); CGRect cgr = *(CGRect*)&aRect; CGContextFillRect(aContext, cgr); } if ([self isCoveringTitlebar]) { [self drawTitleString]; [self drawTitlebarHighlight]; [self maskTopCornersInContext:aContext]; } #ifdef DEBUG_UPDATE fprintf (stderr, "---- update done ----\n"); #if 0 CGContextSetRGBStrokeColor (aContext, ((((unsigned long)self) & 0xff)) / 255.0, ((((unsigned long)self) & 0xff00) >> 8) / 255.0, ((((unsigned long)self) & 0xff0000) >> 16) / 255.0, 0.5); #endif CGContextSetRGBStrokeColor(aContext, 1, 0, 0, 0.8); CGContextSetLineWidth(aContext, 4.0); CGContextStrokeRect(aContext, NSRectToCGRect(aRect)); #endif } - (BOOL)isUsingMainThreadOpenGL { if (!mGeckoChild || ![self window]) return NO; return mGeckoChild->GetLayerManager(nullptr)->GetBackendType() == mozilla::layers::LayersBackend::LAYERS_OPENGL; } - (BOOL)isUsingOpenGL { return NO; // 10.4 doesn't support it. if (!mGeckoChild || ![self window]) return NO; return mGLContext || mUsingOMTCompositor || [self isUsingMainThreadOpenGL]; } - (void)drawUsingOpenGL { PROFILER_LABEL("ChildView", "drawUsingOpenGL", js::ProfileEntry::Category::GRAPHICS); if (![self isUsingOpenGL] || !mGeckoChild->IsVisible()) return; mWaitingForPaint = NO; LayoutDeviceIntRect geckoBounds; mGeckoChild->GetBounds(geckoBounds); LayoutDeviceIntRegion region(geckoBounds); mGeckoChild->PaintWindow(region); // Force OpenGL to refresh the very first time we draw. This works around a // Mac OS X bug that stops windows updating on OS X when we use OpenGL. if (!mDidForceRefreshOpenGL) { [self performSelector:@selector(forceRefreshOpenGL) withObject:nil afterDelay:0]; mDidForceRefreshOpenGL = YES; } } // Called asynchronously after setNeedsDisplay in order to avoid entering the // normal drawing machinery. - (void)drawUsingOpenGLCallback { if (mWaitingForPaint) { [self drawUsingOpenGL]; } } - (BOOL)hasRoundedBottomCorners { return [[self window] respondsToSelector:@selector(bottomCornerRounded)] && [[self window] bottomCornerRounded]; } - (CGFloat)cornerRadius { NSView* frameView = [[[self window] contentView] superview]; if (!frameView || ![frameView respondsToSelector:@selector(roundedCornerRadius)]) return 4.0f; return [frameView roundedCornerRadius]; } // Accelerated windows have two NSSurfaces: // (1) The window's pixel buffer in the back and // (2) the OpenGL view in the front. // These two surfaces are composited by the window manager. Drawing into the // CGContext which is provided by drawRect ends up in (1). // When our window has rounded corners, the OpenGL view has transparent pixels // in the corners. In these places the contents of the window's pixel buffer // can show through. So we need to make sure that the pixel buffer is // transparent in the corners so that no garbage reaches the screen. // The contents of the pixel buffer in the rest of the window don't matter // because they're covered by opaque pixels of the OpenGL context. // Making the corners transparent works even though our window is // declared "opaque" (in the NSWindow's isOpaque method). - (void)clearCorners { CGFloat radius = [self cornerRadius]; CGFloat w = [self bounds].size.width, h = [self bounds].size.height; [[NSColor clearColor] set]; if ([self isCoveringTitlebar]) { NSRectFill(NSMakeRect(0, 0, radius, radius)); NSRectFill(NSMakeRect(w - radius, 0, radius, radius)); } if ([self hasRoundedBottomCorners]) { NSRectFill(NSMakeRect(0, h - radius, radius, radius)); NSRectFill(NSMakeRect(w - radius, h - radius, radius, radius)); } } // 10.4 needs this (below). extern "C" { enum PrivateCGCompositeMode { kPrivateCGCompositeClear = 0, kPrivateCGCompositeCopy = 1, kPrivateCGCompositeSourceOver = 2, kPrivateCGCompositeSourceIn = 3, kPrivateCGCompositeSourceOut = 4, kPrivateCGCompositeSourceAtop = 5, kPrivateCGCompositeDestinationOver = 6, kPrivateCGCompositeDestinationIn = 7, kPrivateCGCompositeDestinationOut = 8, kPrivateCGCompositeDestinationAtop = 9, kPrivateCGCompositeXOR = 10, kPrivateCGCompositePlusDarker = 11, // (max (0, (1-d) + (1-s))) kPrivateCGCompositePlusLighter = 12, // (min (1, s + d)) }; } extern "C" void CGContextSetCompositeOperation (CGContextRef, PrivateCGCompositeMode); // This is the analog of nsChildView::MaybeDrawRoundedCorners for CGContexts. // We only need to mask the top corners here because Cocoa does the masking // for the window's bottom corners automatically (starting with 10.7). - (void)maskTopCornersInContext:(CGContextRef)aContext { CGFloat radius = [self cornerRadius]; int32_t devPixelCornerRadius = mGeckoChild->CocoaPointsToDevPixels(radius); // First make sure that mTopLeftCornerMask is set up. if (!mTopLeftCornerMask || int32_t(CGImageGetWidth(mTopLeftCornerMask)) != devPixelCornerRadius) { CGImageRelease(mTopLeftCornerMask); CGColorSpaceRef rgb = CGColorSpaceCreateDeviceRGB(); CGContextRef imgCtx = CGBitmapContextCreate(NULL, devPixelCornerRadius, devPixelCornerRadius, 8, devPixelCornerRadius * 4, rgb, kCGImageAlphaPremultipliedFirst); CGColorSpaceRelease(rgb); DrawTopLeftCornerMask(imgCtx, devPixelCornerRadius); mTopLeftCornerMask = CGBitmapContextCreateImage(imgCtx); CGContextRelease(imgCtx); } #if NS_LEOPARD_AND_LATER // kCGBlendModeDestinationIn is the secret sauce which allows us to erase // already painted pixels. It's defined as R = D * Sa: multiply all channels // of the destination pixel with the alpha of the source pixel. In our case, // the source is mTopLeftCornerMask. CGContextSaveGState(aContext); CGContextSetBlendMode(aContext, kCGBlendModeDestinationIn); #else // But 10.4 doesn't have that. Its equivalent is // kPrivateCGCompositeDestinationIn (which has existed since at least // 10.3.9); see gfx/2d/DrawTargetCG.cpp CGContextSaveGState(aContext); CGContextSetCompositeOperation(aContext, kPrivateCGCompositeDestinationIn); #endif CGRect destRect = CGRectMake(0, 0, radius, radius); // Erase the top left corner... CGContextDrawImage(aContext, destRect, mTopLeftCornerMask); // ... and the top right corner. CGContextTranslateCTM(aContext, [self bounds].size.width, 0); CGContextScaleCTM(aContext, -1, 1); CGContextDrawImage(aContext, destRect, mTopLeftCornerMask); CGContextRestoreGState(aContext); } - (void)drawTitleString { BaseWindow* window = (BaseWindow*)[self window]; if (![window wantsTitleDrawn]) { return; } NSView* frameView = [[window contentView] superview]; if (![frameView respondsToSelector:@selector(_drawTitleBar:)]) { return; } NSGraphicsContext* oldContext = [NSGraphicsContext currentContext]; CGContextRef ctx = (CGContextRef)[oldContext graphicsPort]; CGContextSaveGState(ctx); if ([oldContext isFlipped] != [frameView isFlipped]) { CGContextTranslateCTM(ctx, 0, [self bounds].size.height); CGContextScaleCTM(ctx, 1, -1); } [NSGraphicsContext setCurrentContext:[NSGraphicsContext graphicsContextWithGraphicsPort:ctx flipped:[frameView isFlipped]]]; [frameView _drawTitleBar:[frameView bounds]]; CGContextRestoreGState(ctx); [NSGraphicsContext setCurrentContext:oldContext]; } - (void)drawTitlebarHighlight { DrawTitlebarHighlight([self bounds].size, [self cornerRadius], mGeckoChild->DevPixelsToCocoaPoints(1)); } - (void)releaseWidgets:(NSArray*)aWidgetArray { if (!aWidgetArray) { return; } NSInteger count = [aWidgetArray count]; for (NSInteger i = 0; i < count; ++i) { NSNumber* pointer = (NSNumber*) [aWidgetArray objectAtIndex:i]; nsIWidget* widget = (nsIWidget*) [pointer unsignedIntegerValue]; NS_RELEASE(widget); } } - (void)viewWillDraw { nsAutoRetainCocoaObject kungFuDeathGrip(self); if (mGeckoChild) { // The OS normally *will* draw our NSWindow, no matter what we do here. // But Gecko can delete our parent widget(s) (along with mGeckoChild) // while processing a paint request, which closes our NSWindow and // makes the OS throw an NSInternalInconsistencyException assertion when // it tries to draw it. Sometimes the OS also aborts the browser process. // So we need to retain our parent(s) here and not release it/them until // the next time through the main thread's run loop. When we do this we // also need to retain and release mGeckoChild, which holds a strong // reference to us (otherwise we might have been deleted by the time // releaseWidgets: is called on us). See bug 550392. nsIWidget* parent = mGeckoChild->GetParent(); if (parent) { NSMutableArray* widgetArray = [NSMutableArray arrayWithCapacity:3]; while (parent) { NS_ADDREF(parent); [widgetArray addObject:[NSNumber numberWithUnsignedInteger:(NSUInteger)parent]]; parent = parent->GetParent(); } NS_ADDREF(mGeckoChild); [widgetArray addObject:[NSNumber numberWithUnsignedInteger:(NSUInteger)mGeckoChild]]; [self performSelector:@selector(releaseWidgets:) withObject:widgetArray afterDelay:0]; } if ([self isUsingOpenGL]) { if (mGeckoChild->GetLayerManager()->GetBackendType() == LayersBackend::LAYERS_CLIENT) { ClientLayerManager *manager = static_cast(mGeckoChild->GetLayerManager()); manager->AsShadowForwarder()->WindowOverlayChanged(); } } mGeckoChild->WillPaintWindow(); } [super viewWillDraw]; } #if USE_CLICK_HOLD_CONTEXTMENU // // -clickHoldCallback: // // called from a timer two seconds after a mouse down to see if we should display // a context menu (click-hold). |anEvent| is the original mouseDown event. If we're // still in that mouseDown by this time, put up the context menu, otherwise just // fuhgeddaboutit. |anEvent| has been retained by the OS until after this callback // fires so we're ok there. // // This code currently messes in a bunch of edge cases (bugs 234751, 232964, 232314) // so removing it until we get it straightened out. // - (void)clickHoldCallback:(id)theEvent; { NS_OBJC_BEGIN_TRY_ABORT_BLOCK; if( theEvent == [NSApp currentEvent] ) { // we're still in the middle of the same mousedown event here, activate // click-hold context menu by triggering the right mouseDown action. NSEvent* clickHoldEvent = [NSEvent mouseEventWithType:NSRightMouseDown location:[theEvent locationInWindow] #ifdef NS_LEOPARD_AND_LATER modifierFlags:[theEvent modifierFlags] #else modifierFlags:nsCocoaUtils::GetCocoaEventModifierFlags(theEvent) #endif timestamp:[theEvent timestamp] windowNumber:[theEvent windowNumber] context:[theEvent context] eventNumber:[theEvent eventNumber] clickCount:[theEvent clickCount] pressure:[theEvent pressure]]; [self rightMouseDown:clickHoldEvent]; } NS_OBJC_END_TRY_ABORT_BLOCK; } #endif // If we've just created a non-native context menu, we need to mark it as // such and let the OS (and other programs) know when it opens and closes // (this is how the OS knows to close other programs' context menus when // ours open). We send the initial notification here, but others are sent // in nsCocoaWindow::Show(). - (void)maybeInitContextMenuTracking { NS_OBJC_BEGIN_TRY_ABORT_BLOCK; #ifdef MOZ_USE_NATIVE_POPUP_WINDOWS return; #endif /* MOZ_USE_NATIVE_POPUP_WINDOWS */ nsIRollupListener* rollupListener = nsBaseWidget::GetActiveRollupListener(); NS_ENSURE_TRUE_VOID(rollupListener); nsCOMPtr widget = rollupListener->GetRollupWidget(); NS_ENSURE_TRUE_VOID(widget); NSWindow *popupWindow = (NSWindow*)widget->GetNativeData(NS_NATIVE_WINDOW); if (!popupWindow || ![popupWindow isKindOfClass:[PopupWindow class]]) return; [[NSDistributedNotificationCenter defaultCenter] postNotificationName:@"com.apple.HIToolbox.beginMenuTrackingNotification" object:@"org.mozilla.gecko.PopupWindow"]; [(PopupWindow*)popupWindow setIsContextMenu:YES]; NS_OBJC_END_TRY_ABORT_BLOCK; } // Returns true if the event should no longer be processed, false otherwise. // This does not return whether or not anything was rolled up. - (BOOL)maybeRollup:(NSEvent*)theEvent { NS_OBJC_BEGIN_TRY_ABORT_BLOCK_RETURN; BOOL consumeEvent = NO; nsIRollupListener* rollupListener = nsBaseWidget::GetActiveRollupListener(); NS_ENSURE_TRUE(rollupListener, false); nsCOMPtr rollupWidget = rollupListener->GetRollupWidget(); if (rollupWidget) { NSWindow* currentPopup = static_cast(rollupWidget->GetNativeData(NS_NATIVE_WINDOW)); if (!nsCocoaUtils::IsEventOverWindow(theEvent, currentPopup)) { // event is not over the rollup window, default is to roll up bool shouldRollup = true; // check to see if scroll events should roll up the popup if ([theEvent type] == NSScrollWheel) { shouldRollup = rollupListener->ShouldRollupOnMouseWheelEvent(); // consume scroll events that aren't over the popup // unless the popup is an arrow panel consumeEvent = rollupListener->ShouldConsumeOnMouseWheelEvent(); } // if we're dealing with menus, we probably have submenus and // we don't want to rollup if the click is in a parent menu of // the current submenu uint32_t popupsToRollup = UINT32_MAX; nsAutoTArray widgetChain; uint32_t sameTypeCount = rollupListener->GetSubmenuWidgetChain(&widgetChain); for (uint32_t i = 0; i < widgetChain.Length(); i++) { nsIWidget* widget = widgetChain[i]; NSWindow* currWindow = (NSWindow*)widget->GetNativeData(NS_NATIVE_WINDOW); if (nsCocoaUtils::IsEventOverWindow(theEvent, currWindow)) { // don't roll up if the mouse event occurred within a menu of the // same type. If the mouse event occurred in a menu higher than // that, roll up, but pass the number of popups to Rollup so // that only those of the same type close up. if (i < sameTypeCount) { shouldRollup = false; } else { popupsToRollup = sameTypeCount; } break; } } if (shouldRollup) { if ([theEvent type] == NSLeftMouseDown) { NSPoint point = [NSEvent mouseLocation]; FlipCocoaScreenCoordinate(point); nsIntPoint pos(point.x, point.y); consumeEvent = (BOOL)rollupListener->Rollup(popupsToRollup, true, &pos, nullptr); } else { consumeEvent = (BOOL)rollupListener->Rollup(popupsToRollup, true, nullptr, nullptr); } } } } return consumeEvent; NS_OBJC_END_TRY_ABORT_BLOCK_RETURN(NO); } /* * In OS X Mountain Lion and above, smart zoom gestures are implemented in * smartMagnifyWithEvent. In OS X Lion, they are implemented in * magnifyWithEvent. See inline comments for more info. * * The prototypes swipeWithEvent, beginGestureWithEvent, magnifyWithEvent, * smartMagnifyWithEvent, rotateWithEvent, and endGestureWithEvent were * obtained from the following links: * https://developer.apple.com/library/mac/#documentation/Cocoa/Reference/ApplicationKit/Classes/NSResponder_Class/Reference/Reference.html * https://developer.apple.com/library/mac/#releasenotes/Cocoa/AppKit.html */ - (void)swipeWithEvent:(NSEvent *)anEvent { NS_OBJC_BEGIN_TRY_ABORT_BLOCK; if (!anEvent || !mGeckoChild) return; nsAutoRetainCocoaObject kungFuDeathGrip(self); float deltaX = [anEvent deltaX]; // left=1.0, right=-1.0 float deltaY = [anEvent deltaY]; // up=1.0, down=-1.0 // Setup the "swipe" event. WidgetSimpleGestureEvent geckoEvent(true, eSwipeGesture, mGeckoChild); [self convertCocoaMouseEvent:anEvent toGeckoEvent:&geckoEvent]; // Record the left/right direction. if (deltaX > 0.0) geckoEvent.direction |= nsIDOMSimpleGestureEvent::DIRECTION_LEFT; else if (deltaX < 0.0) geckoEvent.direction |= nsIDOMSimpleGestureEvent::DIRECTION_RIGHT; // Record the up/down direction. if (deltaY > 0.0) geckoEvent.direction |= nsIDOMSimpleGestureEvent::DIRECTION_UP; else if (deltaY < 0.0) geckoEvent.direction |= nsIDOMSimpleGestureEvent::DIRECTION_DOWN; // Send the event. mGeckoChild->DispatchWindowEvent(geckoEvent); NS_OBJC_END_TRY_ABORT_BLOCK; } - (void)beginGestureWithEvent:(NSEvent *)anEvent { if (!anEvent) return; mGestureState = eGestureState_StartGesture; mCumulativeMagnification = 0; mCumulativeRotation = 0.0; } - (void)magnifyWithEvent:(NSEvent *)anEvent { NS_OBJC_BEGIN_TRY_ABORT_BLOCK; if (!anEvent || !mGeckoChild) return; /* * In OS X 10.7.* (Lion), smart zoom events come through magnifyWithEvent, * instead of smartMagnifyWithEvent. See bug 863841. */ if ([ChildView isLionSmartMagnifyEvent: anEvent]) { [self smartMagnifyWithEvent: anEvent]; return; } nsAutoRetainCocoaObject kungFuDeathGrip(self); float deltaZ = [anEvent deltaZ]; EventMessage msg; switch (mGestureState) { case eGestureState_StartGesture: msg = eMagnifyGestureStart; mGestureState = eGestureState_MagnifyGesture; break; case eGestureState_MagnifyGesture: msg = eMagnifyGestureUpdate; break; case eGestureState_None: case eGestureState_RotateGesture: default: return; } // Setup the event. WidgetSimpleGestureEvent geckoEvent(true, msg, mGeckoChild); geckoEvent.delta = deltaZ; [self convertCocoaMouseEvent:anEvent toGeckoEvent:&geckoEvent]; // Send the event. mGeckoChild->DispatchWindowEvent(geckoEvent); // Keep track of the cumulative magnification for the final "magnify" event. mCumulativeMagnification += deltaZ; NS_OBJC_END_TRY_ABORT_BLOCK; } - (void)smartMagnifyWithEvent:(NSEvent *)anEvent { NS_OBJC_BEGIN_TRY_ABORT_BLOCK; if (!anEvent || !mGeckoChild) { return; } nsAutoRetainCocoaObject kungFuDeathGrip(self); // Setup the "double tap" event. WidgetSimpleGestureEvent geckoEvent(true, eTapGesture, mGeckoChild); [self convertCocoaMouseEvent:anEvent toGeckoEvent:&geckoEvent]; geckoEvent.clickCount = 1; // Send the event. mGeckoChild->DispatchWindowEvent(geckoEvent); // Clear the gesture state mGestureState = eGestureState_None; NS_OBJC_END_TRY_ABORT_BLOCK; } - (void)rotateWithEvent:(NSEvent *)anEvent { NS_OBJC_BEGIN_TRY_ABORT_BLOCK; if (!anEvent || !mGeckoChild) return; nsAutoRetainCocoaObject kungFuDeathGrip(self); float rotation = [anEvent rotation]; EventMessage msg; switch (mGestureState) { case eGestureState_StartGesture: msg = eRotateGestureStart; mGestureState = eGestureState_RotateGesture; break; case eGestureState_RotateGesture: msg = eRotateGestureUpdate; break; case eGestureState_None: case eGestureState_MagnifyGesture: default: return; } // Setup the event. WidgetSimpleGestureEvent geckoEvent(true, msg, mGeckoChild); [self convertCocoaMouseEvent:anEvent toGeckoEvent:&geckoEvent]; geckoEvent.delta = -rotation; if (rotation > 0.0) { geckoEvent.direction = nsIDOMSimpleGestureEvent::ROTATION_COUNTERCLOCKWISE; } else { geckoEvent.direction = nsIDOMSimpleGestureEvent::ROTATION_CLOCKWISE; } // Send the event. mGeckoChild->DispatchWindowEvent(geckoEvent); // Keep track of the cumulative rotation for the final "rotate" event. mCumulativeRotation += rotation; NS_OBJC_END_TRY_ABORT_BLOCK; } - (void)endGestureWithEvent:(NSEvent *)anEvent { NS_OBJC_BEGIN_TRY_ABORT_BLOCK; if (!anEvent || !mGeckoChild) { // Clear the gestures state if we cannot send an event. mGestureState = eGestureState_None; mCumulativeMagnification = 0.0; mCumulativeRotation = 0.0; return; } nsAutoRetainCocoaObject kungFuDeathGrip(self); switch (mGestureState) { case eGestureState_MagnifyGesture: { // Setup the "magnify" event. WidgetSimpleGestureEvent geckoEvent(true, eMagnifyGesture, mGeckoChild); geckoEvent.delta = mCumulativeMagnification; [self convertCocoaMouseEvent:anEvent toGeckoEvent:&geckoEvent]; // Send the event. mGeckoChild->DispatchWindowEvent(geckoEvent); } break; case eGestureState_RotateGesture: { // Setup the "rotate" event. WidgetSimpleGestureEvent geckoEvent(true, eRotateGesture, mGeckoChild); [self convertCocoaMouseEvent:anEvent toGeckoEvent:&geckoEvent]; geckoEvent.delta = -mCumulativeRotation; if (mCumulativeRotation > 0.0) { geckoEvent.direction = nsIDOMSimpleGestureEvent::ROTATION_COUNTERCLOCKWISE; } else { geckoEvent.direction = nsIDOMSimpleGestureEvent::ROTATION_CLOCKWISE; } // Send the event. mGeckoChild->DispatchWindowEvent(geckoEvent); } break; case eGestureState_None: case eGestureState_StartGesture: default: break; } // Clear the gestures state. mGestureState = eGestureState_None; mCumulativeMagnification = 0.0; mCumulativeRotation = 0.0; NS_OBJC_END_TRY_ABORT_BLOCK; } + (BOOL)isLionSmartMagnifyEvent:(NSEvent*)anEvent { #ifndef __LP64__ // Lion SUCKS! return NO; #else /* * On Lion, smart zoom events have type NSEventTypeGesture, subtype 0x16, * whereas pinch zoom events have type NSEventTypeMagnify. So, use that to * discriminate between the two. Smart zoom gestures do not call * beginGestureWithEvent or endGestureWithEvent, so mGestureState is not * changed. Documentation couldn't be found for the meaning of the subtype * 0x16, but it will probably never change. See bug 863841. */ return nsCocoaFeatures::OnLionOrLater() && !nsCocoaFeatures::OnMountainLionOrLater() && [anEvent type] == NSEventTypeGesture && [anEvent subtype] == 0x16; #endif } - (bool)shouldConsiderStartingSwipeFromEvent:(NSEvent*)anEvent { return false; // never on 10.6 or earlier #if(0) if (!nsCocoaFeatures::OnLionOrLater()) { return false; } // This method checks whether the AppleEnableSwipeNavigateWithScrolls global // preference is set. If it isn't, fluid swipe tracking is disabled, and a // horizontal two-finger gesture is always a scroll (even in Safari). This // preference can't (currently) be set from the Preferences UI -- only using // 'defaults write'. if (![NSEvent isSwipeTrackingFromScrollEventsEnabled]) { return false; } // Only initiate horizontal tracking for gestures that have just begun -- // otherwise a scroll to one side of the page can have a swipe tacked on // to it. NSEventPhase eventPhase = nsCocoaUtils::EventPhase(anEvent); if ([anEvent type] != NSScrollWheel || eventPhase != NSEventPhaseBegan || ![anEvent hasPreciseScrollingDeltas]) { return false; } // Only initiate horizontal tracking for events whose horizontal element is // at least eight times larger than its vertical element. This minimizes // performance problems with vertical scrolls (by minimizing the possibility // that they'll be misinterpreted as horizontal swipes), while still // tolerating a small vertical element to a true horizontal swipe. The number // '8' was arrived at by trial and error. CGFloat deltaX = [anEvent scrollingDeltaX]; CGFloat deltaY = [anEvent scrollingDeltaY]; return std::abs(deltaX) > std::abs(deltaY) * 8; #endif } - (void)setUsingOMTCompositor:(BOOL)aUseOMTC { mUsingOMTCompositor = aUseOMTC; } // Returning NO from this method only disallows ordering on mousedown - in order // to prevent it for mouseup too, we need to call [NSApp preventWindowOrdering] // when handling the mousedown event. - (BOOL)shouldDelayWindowOrderingForEvent:(NSEvent*)aEvent { // Always using system-provided window ordering for normal windows. if (![[self window] isKindOfClass:[PopupWindow class]]) return NO; // Don't reorder when we don't have a parent window, like when we're a // context menu or a tooltip. return ![[self window] parentWindow]; } - (void)mouseDown:(NSEvent*)theEvent { NS_OBJC_BEGIN_TRY_ABORT_BLOCK; if ([self shouldDelayWindowOrderingForEvent:theEvent]) { [NSApp preventWindowOrdering]; } // If we've already seen this event due to direct dispatch from menuForEvent: // just bail; if not, remember it. if (mLastMouseDownEvent == theEvent) { [mLastMouseDownEvent release]; mLastMouseDownEvent = nil; return; } else { [mLastMouseDownEvent release]; mLastMouseDownEvent = [theEvent retain]; } [gLastDragMouseDownEvent release]; gLastDragMouseDownEvent = [theEvent retain]; // We need isClickThrough because at this point the window we're in might // already have become main, so the check for isMainWindow in // WindowAcceptsEvent isn't enough. It also has to check isClickThrough. BOOL isClickThrough = (theEvent == mClickThroughMouseDownEvent); [mClickThroughMouseDownEvent release]; mClickThroughMouseDownEvent = nil; nsAutoRetainCocoaObject kungFuDeathGrip(self); if ([self maybeRollup:theEvent] || !ChildViewMouseTracker::WindowAcceptsEvent([self window], theEvent, self, isClickThrough)) { // Remember blocking because that means we want to block mouseup as well. mBlockedLastMouseDown = YES; return; } #if USE_CLICK_HOLD_CONTEXTMENU // fire off timer to check for click-hold after two seconds. retains |theEvent| [self performSelector:@selector(clickHoldCallback:) withObject:theEvent afterDelay:2.0]; #endif // in order to send gecko events we'll need a gecko widget if (!mGeckoChild) return; #if(0) NSUInteger modifierFlags = [theEvent modifierFlags]; #else NSUInteger modifierFlags = nsCocoaUtils::GetCocoaEventModifierFlags(theEvent); #endif WidgetMouseEvent geckoEvent(true, eMouseDown, mGeckoChild, WidgetMouseEvent::eReal); [self convertCocoaMouseEvent:theEvent toGeckoEvent:&geckoEvent]; NSInteger clickCount = [theEvent clickCount]; if (mBlockedLastMouseDown && clickCount > 1) { // Don't send a double click if the first click of the double click was // blocked. clickCount--; } geckoEvent.clickCount = clickCount; if (modifierFlags & NSControlKeyMask) geckoEvent.button = WidgetMouseEvent::eRightButton; else geckoEvent.button = WidgetMouseEvent::eLeftButton; mGeckoChild->DispatchAPZAwareEvent(&geckoEvent); mBlockedLastMouseDown = NO; // XXX maybe call markedTextSelectionChanged:client: here? NS_OBJC_END_TRY_ABORT_BLOCK; } - (void)mouseUp:(NSEvent *)theEvent { NS_OBJC_BEGIN_TRY_ABORT_BLOCK; if (!mGeckoChild || mBlockedLastMouseDown) return; nsAutoRetainCocoaObject kungFuDeathGrip(self); WidgetMouseEvent geckoEvent(true, eMouseUp, mGeckoChild, WidgetMouseEvent::eReal); [self convertCocoaMouseEvent:theEvent toGeckoEvent:&geckoEvent]; if (nsCocoaUtils::GetCocoaEventModifierFlags(theEvent) & NSControlKeyMask) geckoEvent.button = WidgetMouseEvent::eRightButton; else geckoEvent.button = WidgetMouseEvent::eLeftButton; // This might destroy our widget (and null out mGeckoChild). bool defaultPrevented = (mGeckoChild->DispatchAPZAwareEvent(&geckoEvent) == nsEventStatus_eConsumeNoDefault); // Check to see if we are double-clicking in the titlebar. CGFloat locationInTitlebar = [[self window] frame].size.height - [theEvent locationInWindow].y; LayoutDeviceIntPoint pos = geckoEvent.refPoint; if (!defaultPrevented && [theEvent clickCount] == 2 && mGeckoChild->GetDraggableRegion().Contains(pos.x, pos.y) && [[self window] isKindOfClass:[ToolbarWindow class]] && (locationInTitlebar < [(ToolbarWindow*)[self window] titlebarHeight] || locationInTitlebar < [(ToolbarWindow*)[self window] unifiedToolbarHeight])) { if ([self shouldZoomOnDoubleClick]) { [[self window] performZoom:nil]; } else if ([self shouldMinimizeOnTitlebarDoubleClick]) { NSButton *minimizeButton = [[self window] standardWindowButton:NSWindowMiniaturizeButton]; [minimizeButton performClick:self]; } } NS_OBJC_END_TRY_ABORT_BLOCK; } - (void)sendMouseEnterOrExitEvent:(NSEvent*)aEvent enter:(BOOL)aEnter type:(WidgetMouseEvent::exitType)aType { if (!mGeckoChild) return; NSPoint windowEventLocation = nsCocoaUtils::EventLocationForWindow(aEvent, [self window]); NSPoint localEventLocation = [self convertPoint:windowEventLocation fromView:nil]; EventMessage msg = aEnter ? eMouseEnterIntoWidget : eMouseExitFromWidget; WidgetMouseEvent event(true, msg, mGeckoChild, WidgetMouseEvent::eReal); event.refPoint = mGeckoChild->CocoaPointsToDevPixels(localEventLocation); event.exit = aType; nsEventStatus status; // ignored mGeckoChild->DispatchEvent(&event, status); } - (void)updateWindowDraggableState { // Trigger update to the window server. [[self window] setMovableByWindowBackground:NO]; [[self window] setMovableByWindowBackground:YES]; } // aRect is in view coordinates relative to this NSView. - (CGRect)convertToFlippedWindowCoordinates:(NSRect)aRect { // First, convert the rect to regular window coordinates... NSRect inWindowCoords = [self convertRect:aRect toView:nil]; // ... and then flip it again because window coordinates have their origin // in the bottom left corner, and we need it to be in the top left corner. inWindowCoords.origin.y = [[self window] frame].size.height - NSMaxY(inWindowCoords); //return NSRectToCGRect(inWindowCoords); return *(CGRect*)&inWindowCoords; } #if(0) static CGSRegionObj NewCGSRegionFromRegion(const LayoutDeviceIntRegion& aRegion, CGRect (^aRectConverter)(const LayoutDeviceIntRect&)) { nsTArray rects; LayoutDeviceIntRegion::RectIterator iter(aRegion); for (;;) { const LayoutDeviceIntRect* r = iter.Next(); if (!r) { break; } rects.AppendElement(aRectConverter(*r)); } CGSRegionObj region; CGSNewRegionWithRectList(rects.Elements(), rects.Length(), ®ion); return region; } // This function is called with forMove:YES to calculate the draggable region // of the window which will be submitted to the window server. Window dragging // is handled on the window server without calling back into our process, so it // also works while our app is unresponsive. - (CGSRegionObj)_regionForOpaqueDescendants:(NSRect)aRect forMove:(BOOL)aForMove { if (!aForMove || !mGeckoChild) { return [super _regionForOpaqueDescendants:aRect forMove:aForMove]; } LayoutDeviceIntRect boundingRect = mGeckoChild->CocoaPointsToDevPixels(aRect); LayoutDeviceIntRegion opaqueRegion; opaqueRegion.Sub(boundingRect, mGeckoChild->GetDraggableRegion()); return NewCGSRegionFromRegion(opaqueRegion, ^(const LayoutDeviceIntRect& r) { return [self convertToFlippedWindowCoordinates:mGeckoChild->DevPixelsToCocoaPoints(r)]; }); } #else // 10.4 (non-block) version. - (CGSRegionObj)_regionForOpaqueDescendants:(NSRect)aRect forMove:(BOOL)aForMove { if (!aForMove || !mGeckoChild) { return [super _regionForOpaqueDescendants:aRect forMove:aForMove]; } LayoutDeviceIntRect boundingRect = mGeckoChild->CocoaPointsToDevPixels(aRect); LayoutDeviceIntRegion opaqueRegion; opaqueRegion.Sub(boundingRect, mGeckoChild->GetDraggableRegion()); nsTArray rects; LayoutDeviceIntRegion::RectIterator iter(opaqueRegion); for (;;) { const LayoutDeviceIntRect* r = iter.Next(); if (!r) break; // We can cheat here if needed, because the backing scale is always 1. NSRect n = mGeckoChild->DevPixelsToCocoaPoints(*r); rects.AppendElement([self convertToFlippedWindowCoordinates:n]); } CGSRegionObj region; CGSNewRegionWithRectList(rects.Elements(), rects.Length(), ®ion); return region; } #endif // Starting with 10.10, in addition to the traditional // -[NSView _regionForOpaqueDescendants:forMove:] method, there's a new form with // an additional forUnderTitlebar argument, which is sometimes called instead of // the old form. We need to override the new variant as well. - (CGSRegionObj)_regionForOpaqueDescendants:(NSRect)aRect forMove:(BOOL)aForMove forUnderTitlebar:(BOOL)aForUnderTitlebar { if (!aForMove || !mGeckoChild) { return [super _regionForOpaqueDescendants:aRect forMove:aForMove forUnderTitlebar:aForUnderTitlebar]; } return [self _regionForOpaqueDescendants:aRect forMove:aForMove]; } - (void)mouseMoved:(NSEvent*)aEvent { ChildViewMouseTracker::MouseMoved(aEvent); } - (void)handleMouseMoved:(NSEvent*)theEvent { NS_OBJC_BEGIN_TRY_ABORT_BLOCK; if (!mGeckoChild) return; WidgetMouseEvent geckoEvent(true, eMouseMove, mGeckoChild, WidgetMouseEvent::eReal); [self convertCocoaMouseEvent:theEvent toGeckoEvent:&geckoEvent]; mGeckoChild->DispatchAPZAwareEvent(&geckoEvent); NS_OBJC_END_TRY_ABORT_BLOCK; } - (void)mouseDragged:(NSEvent*)theEvent { NS_OBJC_BEGIN_TRY_ABORT_BLOCK; if (!mGeckoChild) return; gLastDragView = self; WidgetMouseEvent geckoEvent(true, eMouseMove, mGeckoChild, WidgetMouseEvent::eReal); [self convertCocoaMouseEvent:theEvent toGeckoEvent:&geckoEvent]; mGeckoChild->DispatchInputEvent(&geckoEvent); // Note, sending the above event might have destroyed our widget since we didn't retain. // Fine so long as we don't access any local variables from here on. gLastDragView = nil; // XXX maybe call markedTextSelectionChanged:client: here? NS_OBJC_END_TRY_ABORT_BLOCK; } - (void)rightMouseDown:(NSEvent *)theEvent { NS_OBJC_BEGIN_TRY_ABORT_BLOCK; nsAutoRetainCocoaObject kungFuDeathGrip(self); [self maybeRollup:theEvent]; if (!mGeckoChild) return; // The right mouse went down, fire off a right mouse down event to gecko WidgetMouseEvent geckoEvent(true, eMouseDown, mGeckoChild, WidgetMouseEvent::eReal); [self convertCocoaMouseEvent:theEvent toGeckoEvent:&geckoEvent]; geckoEvent.button = WidgetMouseEvent::eRightButton; geckoEvent.clickCount = [theEvent clickCount]; mGeckoChild->DispatchAPZAwareEvent(&geckoEvent); if (!mGeckoChild) return; // Let the superclass do the context menu stuff. [super rightMouseDown:theEvent]; NS_OBJC_END_TRY_ABORT_BLOCK; } - (void)rightMouseUp:(NSEvent *)theEvent { NS_OBJC_BEGIN_TRY_ABORT_BLOCK; if (!mGeckoChild) return; WidgetMouseEvent geckoEvent(true, eMouseUp, mGeckoChild, WidgetMouseEvent::eReal); [self convertCocoaMouseEvent:theEvent toGeckoEvent:&geckoEvent]; geckoEvent.button = WidgetMouseEvent::eRightButton; geckoEvent.clickCount = [theEvent clickCount]; nsAutoRetainCocoaObject kungFuDeathGrip(self); mGeckoChild->DispatchAPZAwareEvent(&geckoEvent); NS_OBJC_END_TRY_ABORT_BLOCK; } - (void)rightMouseDragged:(NSEvent*)theEvent { if (!mGeckoChild) return; WidgetMouseEvent geckoEvent(true, eMouseMove, mGeckoChild, WidgetMouseEvent::eReal); [self convertCocoaMouseEvent:theEvent toGeckoEvent:&geckoEvent]; geckoEvent.button = WidgetMouseEvent::eRightButton; // send event into Gecko by going directly to the // the widget. mGeckoChild->DispatchInputEvent(&geckoEvent); } - (void)otherMouseDown:(NSEvent *)theEvent { NS_OBJC_BEGIN_TRY_ABORT_BLOCK; nsAutoRetainCocoaObject kungFuDeathGrip(self); if ([self maybeRollup:theEvent] || !ChildViewMouseTracker::WindowAcceptsEvent([self window], theEvent, self)) return; if (!mGeckoChild) return; WidgetMouseEvent geckoEvent(true, eMouseDown, mGeckoChild, WidgetMouseEvent::eReal); [self convertCocoaMouseEvent:theEvent toGeckoEvent:&geckoEvent]; geckoEvent.button = WidgetMouseEvent::eMiddleButton; geckoEvent.clickCount = [theEvent clickCount]; mGeckoChild->DispatchInputEvent(&geckoEvent); NS_OBJC_END_TRY_ABORT_BLOCK; } - (void)otherMouseUp:(NSEvent *)theEvent { if (!mGeckoChild) return; WidgetMouseEvent geckoEvent(true, eMouseUp, mGeckoChild, WidgetMouseEvent::eReal); [self convertCocoaMouseEvent:theEvent toGeckoEvent:&geckoEvent]; geckoEvent.button = WidgetMouseEvent::eMiddleButton; nsAutoRetainCocoaObject kungFuDeathGrip(self); mGeckoChild->DispatchInputEvent(&geckoEvent); } - (void)otherMouseDragged:(NSEvent*)theEvent { if (!mGeckoChild) return; WidgetMouseEvent geckoEvent(true, eMouseMove, mGeckoChild, WidgetMouseEvent::eReal); [self convertCocoaMouseEvent:theEvent toGeckoEvent:&geckoEvent]; geckoEvent.button = WidgetMouseEvent::eMiddleButton; // send event into Gecko by going directly to the // the widget. mGeckoChild->DispatchInputEvent(&geckoEvent); } static int32_t RoundUp(double aDouble) { return aDouble < 0 ? static_cast(floor(aDouble)) : static_cast(ceil(aDouble)); } - (void)sendWheelStartOrStop:(EventMessage)msg forEvent:(NSEvent *)theEvent { WidgetWheelEvent wheelEvent(true, msg, mGeckoChild); [self convertCocoaMouseWheelEvent:theEvent toGeckoEvent:&wheelEvent]; mExpectingWheelStop = (msg == eWheelOperationStart); mGeckoChild->DispatchAPZAwareEvent(wheelEvent.AsInputEvent()); } - (void)sendWheelCondition:(BOOL)condition first:(EventMessage)first second:(EventMessage)second forEvent:(NSEvent *)theEvent { if (mExpectingWheelStop == condition) { [self sendWheelStartOrStop:first forEvent:theEvent]; } [self sendWheelStartOrStop:second forEvent:theEvent]; } static PanGestureInput::PanGestureType PanGestureTypeForEvent(NSEvent* aEvent) { switch (nsCocoaUtils::EventPhase(aEvent)) { case NSEventPhaseMayBegin: return PanGestureInput::PANGESTURE_MAYSTART; case NSEventPhaseCancelled: return PanGestureInput::PANGESTURE_CANCELLED; case NSEventPhaseBegan: return PanGestureInput::PANGESTURE_START; case NSEventPhaseChanged: return PanGestureInput::PANGESTURE_PAN; case NSEventPhaseEnded: return PanGestureInput::PANGESTURE_END; case NSEventPhaseNone: switch (nsCocoaUtils::EventMomentumPhase(aEvent)) { case NSEventPhaseBegan: return PanGestureInput::PANGESTURE_MOMENTUMSTART; case NSEventPhaseChanged: return PanGestureInput::PANGESTURE_MOMENTUMPAN; case NSEventPhaseEnded: return PanGestureInput::PANGESTURE_MOMENTUMEND; default: NS_ERROR("unexpected event phase"); return PanGestureInput::PANGESTURE_PAN; } default: NS_ERROR("unexpected event phase"); return PanGestureInput::PANGESTURE_PAN; } } - (void)scrollWheel:(NSEvent*)theEvent { NS_OBJC_BEGIN_TRY_ABORT_BLOCK; if (gfxPrefs::AsyncPanZoomSeparateEventThread() && [self apzctm]) { // Disable main-thread scrolling completely when using APZ with the // separate event thread. This is bug 1013412. return; } nsAutoRetainCocoaObject kungFuDeathGrip(self); ChildViewMouseTracker::MouseScrolled(theEvent); if ([self maybeRollup:theEvent]) { return; } if (!mGeckoChild) { return; } NSEventPhase phase = nsCocoaUtils::EventPhase(theEvent); // Fire eWheelOperationStart/End events when 2 fingers touch/release the // touchpad. if (phase & NSEventPhaseMayBegin) { [self sendWheelCondition:YES first:eWheelOperationEnd second:eWheelOperationStart forEvent:theEvent]; } else if (phase & (NSEventPhaseEnded | NSEventPhaseCancelled)) { [self sendWheelCondition:NO first:eWheelOperationStart second:eWheelOperationEnd forEvent:theEvent]; } NSPoint locationInWindow = nsCocoaUtils::EventLocationForWindow(theEvent, [self window]); ScreenPoint position = ViewAs( [self convertWindowCoordinates:locationInWindow], PixelCastJustification::LayoutDeviceIsScreenForUntransformedEvent); bool usePreciseDeltas = nsCocoaUtils::HasPreciseScrollingDeltas(theEvent) && Preferences::GetBool("mousewheel.enable_pixel_scrolling", true); bool hasPhaseInformation = nsCocoaUtils::EventHasPhaseInformation(theEvent); int32_t lineOrPageDeltaX = RoundUp(-[theEvent deltaX]); int32_t lineOrPageDeltaY = RoundUp(-[theEvent deltaY]); Modifiers modifiers = nsCocoaUtils::ModifiersForEvent(theEvent); #if(0) NSTimeInterval beforeNow = [[NSProcessInfo processInfo] systemUptime] - [theEvent timestamp]; #else // NSProcessInfo in 10.4 doesn't have systemUptime, so we have to gyrate a bit in Carbon. Nanoseconds nano = AbsoluteToNanoseconds(UpTime()); NSTimeInterval systemUptime = nano.hi * 4.294967296 + nano.lo * 1e-9; NSTimeInterval beforeNow = systemUptime - [theEvent timestamp]; #endif PRIntervalTime eventIntervalTime = PR_IntervalNow() - PR_MillisecondsToInterval(beforeNow * 1000); TimeStamp eventTimeStamp = TimeStamp::Now() - TimeDuration::FromSeconds(beforeNow); ScreenPoint preciseDelta; if (usePreciseDeltas) { CGFloat pixelDeltaX = 0, pixelDeltaY = 0; nsCocoaUtils::GetScrollingDeltas(theEvent, &pixelDeltaX, &pixelDeltaY); //double scale = mGeckoChild->BackingScaleFactor(); //preciseDelta = ScreenPoint(-pixelDeltaX * scale, -pixelDeltaY * scale); preciseDelta = ScreenPoint(-pixelDeltaX, -pixelDeltaY); } #if(0) if (usePreciseDeltas && hasPhaseInformation) { PanGestureInput panEvent(PanGestureTypeForEvent(theEvent), eventIntervalTime, eventTimeStamp, position, preciseDelta, modifiers); panEvent.mLineOrPageDeltaX = lineOrPageDeltaX; panEvent.mLineOrPageDeltaY = lineOrPageDeltaY; bool canTriggerSwipe = [self shouldConsiderStartingSwipeFromEvent:theEvent]; panEvent.mRequiresContentResponseIfCannotScrollHorizontallyInStartDirection = canTriggerSwipe; mGeckoChild->DispatchAPZWheelInputEvent(panEvent, canTriggerSwipe); } else if (usePreciseDeltas) { #else if (usePreciseDeltas) { #endif // This is on 10.6 or old touchpads that don't have any phase information. ScrollWheelInput wheelEvent(eventIntervalTime, eventTimeStamp, modifiers, ScrollWheelInput::SCROLLMODE_INSTANT, ScrollWheelInput::SCROLLDELTA_PIXEL, position, preciseDelta.x, preciseDelta.y); wheelEvent.mLineOrPageDeltaX = lineOrPageDeltaX; wheelEvent.mLineOrPageDeltaY = lineOrPageDeltaY; wheelEvent.mIsMomentum = nsCocoaUtils::IsMomentumScrollEvent(theEvent); mGeckoChild->DispatchAPZWheelInputEvent(wheelEvent, false); } else { ScrollWheelInput::ScrollMode scrollMode = ScrollWheelInput::SCROLLMODE_INSTANT; if (gfxPrefs::SmoothScrollEnabled() && gfxPrefs::WheelSmoothScrollEnabled()) { scrollMode = ScrollWheelInput::SCROLLMODE_SMOOTH; } ScrollWheelInput wheelEvent(eventIntervalTime, eventTimeStamp, modifiers, scrollMode, ScrollWheelInput::SCROLLDELTA_LINE, position, lineOrPageDeltaX, lineOrPageDeltaY); wheelEvent.mLineOrPageDeltaX = lineOrPageDeltaX; wheelEvent.mLineOrPageDeltaY = lineOrPageDeltaY; mGeckoChild->DispatchAPZWheelInputEvent(wheelEvent, false); } NS_OBJC_END_TRY_ABORT_BLOCK; } - (void)handleAsyncScrollEvent:(CGEventRef)cgEvent ofType:(CGEventType)type { #if(1) // Unfortunately there is no way to support APZC yet because there is // no documented way to convert a CGEventRef into an NSEvent on 10.4. #else APZCTreeManager* apzctm = [self apzctm]; if (!apzctm) { return; } CGPoint loc = CGEventGetLocation(cgEvent); loc.y = nsCocoaUtils::FlippedScreenY(loc.y); NSPoint locationInWindow = [[self window] convertScreenToBase:NSPointFromCGPoint(loc)]; ScreenIntPoint location = ViewAs( [self convertWindowCoordinates:locationInWindow], PixelCastJustification::LayoutDeviceIsScreenForUntransformedEvent); static NSTimeInterval sStartTime = [NSDate timeIntervalSinceReferenceDate]; static TimeStamp sStartTimeStamp = TimeStamp::Now(); if (type == kCGEventScrollWheel) { NSEvent* event = [NSEvent eventWithCGEvent:cgEvent]; NSEventPhase phase = nsCocoaUtils::EventPhase(event); NSEventPhase momentumPhase = nsCocoaUtils::EventMomentumPhase(event); CGFloat pixelDeltaX = 0, pixelDeltaY = 0; nsCocoaUtils::GetScrollingDeltas(event, &pixelDeltaX, &pixelDeltaY); uint32_t eventTime = ([event timestamp] - sStartTime) * 1000; TimeStamp eventTimeStamp = sStartTimeStamp + TimeDuration::FromSeconds([event timestamp] - sStartTime); NSPoint locationInWindowMoved = NSMakePoint( locationInWindow.x + pixelDeltaX, locationInWindow.y - pixelDeltaY); ScreenIntPoint locationMoved = ViewAs( [self convertWindowCoordinates:locationInWindowMoved], PixelCastJustification::LayoutDeviceIsScreenForUntransformedEvent); ScreenPoint delta = ScreenPoint(locationMoved - location); ScrollableLayerGuid guid; // MayBegin and Cancelled are dispatched when the fingers start or stop // touching the touchpad before any scrolling has occurred. These events // can be used to control scrollbar visibility or interrupt scroll // animations. They are only dispatched on 10.8 or later, and only by // relatively modern devices. if (phase == NSEventPhaseMayBegin) { PanGestureInput panInput(PanGestureInput::PANGESTURE_MAYSTART, eventTime, eventTimeStamp, location, ScreenPoint(0, 0), 0); apzctm->ReceiveInputEvent(panInput, &guid, nullptr); return; } if (phase == NSEventPhaseCancelled) { PanGestureInput panInput(PanGestureInput::PANGESTURE_CANCELLED, eventTime, eventTimeStamp, location, ScreenPoint(0, 0), 0); apzctm->ReceiveInputEvent(panInput, &guid, nullptr); return; } // Legacy scroll events are dispatched by devices that do not have a // concept of a scroll gesture, for example by USB mice with // traditional mouse wheels. // For these kinds of scrolls, we want to surround every single scroll // event with a PANGESTURE_START and a PANGESTURE_END event. The APZC // needs to know that the real scroll gesture can end abruptly after any // one of these events. bool isLegacyScroll = (phase == NSEventPhaseNone && momentumPhase == NSEventPhaseNone && delta != ScreenPoint(0, 0)); if (phase == NSEventPhaseBegan || isLegacyScroll) { PanGestureInput panInput(PanGestureInput::PANGESTURE_START, eventTime, eventTimeStamp, location, ScreenPoint(0, 0), 0); apzctm->ReceiveInputEvent(panInput, &guid, nullptr); } if (momentumPhase == NSEventPhaseNone && delta != ScreenPoint(0, 0)) { PanGestureInput panInput(PanGestureInput::PANGESTURE_PAN, eventTime, eventTimeStamp, location, delta, 0); apzctm->ReceiveInputEvent(panInput, &guid, nullptr); } if (phase == NSEventPhaseEnded || isLegacyScroll) { PanGestureInput panInput(PanGestureInput::PANGESTURE_END, eventTime, eventTimeStamp, location, ScreenPoint(0, 0), 0); apzctm->ReceiveInputEvent(panInput, &guid, nullptr); } // Any device that can dispatch momentum events supports all three momentum phases. if (momentumPhase == NSEventPhaseBegan) { PanGestureInput panInput(PanGestureInput::PANGESTURE_MOMENTUMSTART, eventTime, eventTimeStamp, location, ScreenPoint(0, 0), 0); apzctm->ReceiveInputEvent(panInput, &guid, nullptr); } if (momentumPhase == NSEventPhaseChanged && delta != ScreenPoint(0, 0)) { PanGestureInput panInput(PanGestureInput::PANGESTURE_MOMENTUMPAN, eventTime, eventTimeStamp, location, delta, 0); apzctm->ReceiveInputEvent(panInput, &guid, nullptr); } if (momentumPhase == NSEventPhaseEnded) { PanGestureInput panInput(PanGestureInput::PANGESTURE_MOMENTUMEND, eventTime, eventTimeStamp, location, ScreenPoint(0, 0), 0); apzctm->ReceiveInputEvent(panInput, &guid, nullptr); } } #endif } -(NSMenu*)menuForEvent:(NSEvent*)theEvent { NS_OBJC_BEGIN_TRY_ABORT_BLOCK_NIL; if (!mGeckoChild) return nil; #ifdef DEBUG fprintf(stderr, "MenuForEvent\n"); #endif nsAutoRetainCocoaObject kungFuDeathGrip(self); [self maybeRollup:theEvent]; if (!mGeckoChild) return nil; // Cocoa doesn't always dispatch a mouseDown: for a control-click event, // depends on what we return from menuForEvent:. Gecko always expects one // and expects the mouse down event before the context menu event, so // get that event sent first if this is a left mouse click. if ([theEvent type] == NSLeftMouseDown) { [self mouseDown:theEvent]; if (!mGeckoChild) return nil; } WidgetMouseEvent geckoEvent(true, eContextMenu, mGeckoChild, WidgetMouseEvent::eReal); [self convertCocoaMouseEvent:theEvent toGeckoEvent:&geckoEvent]; geckoEvent.button = WidgetMouseEvent::eRightButton; mGeckoChild->DispatchInputEvent(&geckoEvent); if (!mGeckoChild) return nil; [self maybeInitContextMenuTracking]; // Go up our view chain to fetch the correct menu to return. return [self contextMenu]; NS_OBJC_END_TRY_ABORT_BLOCK_NIL; } - (NSMenu*)contextMenu { NS_OBJC_BEGIN_TRY_ABORT_BLOCK_NIL; NSView* superView = [self superview]; if ([superView respondsToSelector:@selector(contextMenu)]) return [(NSView*)superView contextMenu]; return nil; NS_OBJC_END_TRY_ABORT_BLOCK_NIL; } - (void) convertCocoaMouseWheelEvent:(NSEvent*)aMouseEvent toGeckoEvent:(WidgetWheelEvent*)outWheelEvent { [self convertCocoaMouseEvent:aMouseEvent toGeckoEvent:outWheelEvent]; #ifdef __LP64__ bool usePreciseDeltas = nsCocoaUtils::HasPreciseScrollingDeltas(aMouseEvent) && Preferences::GetBool("mousewheel.enable_pixel_scrolling", true); outWheelEvent->deltaMode = usePreciseDeltas ? nsIDOMWheelEvent::DOM_DELTA_PIXEL : nsIDOMWheelEvent::DOM_DELTA_LINE; outWheelEvent->isMomentum = nsCocoaUtils::IsMomentumScrollEvent(aMouseEvent); #else // Pixel scrolling and phases/momentum aren't supported until 10.7. // We don't support 10.7, so let's save some overhead. outWheelEvent->deltaMode = nsIDOMWheelEvent::DOM_DELTA_LINE; outWheelEvent->isMomentum = false; #endif } - (void) convertCocoaMouseEvent:(NSEvent*)aMouseEvent toGeckoEvent:(WidgetInputEvent*)outGeckoEvent { NS_OBJC_BEGIN_TRY_ABORT_BLOCK; NS_ASSERTION(outGeckoEvent, "convertCocoaMouseEvent:toGeckoEvent: requires non-null aoutGeckoEvent"); if (!outGeckoEvent) return; nsCocoaUtils::InitInputEvent(*outGeckoEvent, aMouseEvent); // convert point to view coordinate system NSPoint locationInWindow = nsCocoaUtils::EventLocationForWindow(aMouseEvent, [self window]); outGeckoEvent->refPoint = [self convertWindowCoordinates:locationInWindow]; WidgetMouseEventBase* mouseEvent = outGeckoEvent->AsMouseEventBase(); mouseEvent->buttons = 0; #if(0) NSUInteger mouseButtons = [NSEvent pressedMouseButtons]; if (mouseButtons & 0x01) { mouseEvent->buttons |= WidgetMouseEvent::eLeftButtonFlag; } if (mouseButtons & 0x02) { mouseEvent->buttons |= WidgetMouseEvent::eRightButtonFlag; } if (mouseButtons & 0x04) { mouseEvent->buttons |= WidgetMouseEvent::eMiddleButtonFlag; } if (mouseButtons & 0x08) { mouseEvent->buttons |= WidgetMouseEvent::e4thButtonFlag; } if (mouseButtons & 0x10) { mouseEvent->buttons |= WidgetMouseEvent::e5thButtonFlag; } #endif switch ([aMouseEvent type]) { case NSLeftMouseDown: case NSLeftMouseUp: case NSLeftMouseDragged: case NSRightMouseDown: case NSRightMouseUp: case NSRightMouseDragged: case NSOtherMouseDown: case NSOtherMouseUp: case NSOtherMouseDragged: { // pressedMouseButtons: doesn't exist in the 10.4 SDK, so use the // additional code below (TenFourFox issue 507). NSInteger mouseButtons = [aMouseEvent buttonNumber]; if (mouseButtons == 0) mouseEvent->buttons |= WidgetMouseEvent::eLeftButtonFlag; else if (mouseButtons == 1) mouseEvent->buttons |= WidgetMouseEvent::eRightButtonFlag; else if (mouseButtons == 2) mouseEvent->buttons |= WidgetMouseEvent::eMiddleButtonFlag; else if (mouseButtons == 3) mouseEvent->buttons |= WidgetMouseEvent::e4thButtonFlag; else if (mouseButtons >= 4) // WRONG! but close enough mouseEvent->buttons |= WidgetMouseEvent::e5thButtonFlag; if ([aMouseEvent subtype] == NSTabletPointEventSubtype) { mouseEvent->pressure = [aMouseEvent pressure]; MOZ_ASSERT(mouseEvent->pressure >= 0.0 && mouseEvent->pressure <= 1.0); } break; } default: // Don't check other NSEvents for pressure. break; } NS_OBJC_END_TRY_ABORT_BLOCK; } #if(0) - (BOOL)shouldZoomOnDoubleClick { if ([NSWindow respondsToSelector:@selector(_shouldZoomOnDoubleClick)]) { return [NSWindow _shouldZoomOnDoubleClick]; } return nsCocoaFeatures::OnYosemiteOrLater(); } - (BOOL)shouldMinimizeOnTitlebarDoubleClick { NSString *MDAppleMiniaturizeOnDoubleClickKey = @"AppleMiniaturizeOnDoubleClick"; NSUserDefaults *userDefaults = [NSUserDefaults standardUserDefaults]; bool shouldMinimize = [[userDefaults objectForKey:MDAppleMiniaturizeOnDoubleClickKey] boolValue]; return shouldMinimize; } #else - (BOOL)shouldZoomOnDoubleClick { return false; } - (BOOL)shouldMinimizeOnTitlebarDoubleClick { // It's not clear that 10.4 has this key (it doesn't seem to). // It doesn't have [NSWindow _shouldMiniaturizeOnDoubleClick] either, // so to always minimize seems the safest approach. if (!nsCocoaFeatures::OnLeopardOrLater()) return true; NSString *MDAppleMiniaturizeOnDoubleClickKey = @"AppleMiniaturizeOnDoubleClick"; NSUserDefaults *userDefaults = [NSUserDefaults standardUserDefaults]; bool shouldMinimize = [[userDefaults objectForKey:MDAppleMiniaturizeOnDoubleClickKey] boolValue]; return shouldMinimize; } #endif // Backout bug 519972 // This is a big one! // Damn you, Masayuki and Steven! // Consolidated for Mozilla 17 static void ConvertCocoaKeyEventToNPCocoaEvent(NSEvent* cocoaEvent, NPCocoaEvent& pluginEvent, uint32_t keyType = 0) { nsCocoaUtils::InitNPCocoaEvent(&pluginEvent); NSEventType nativeType = [cocoaEvent type]; switch (nativeType) { case NSKeyDown: pluginEvent.type = NPCocoaEventKeyDown; break; case NSKeyUp: pluginEvent.type = NPCocoaEventKeyUp; break; case NSFlagsChanged: pluginEvent.type = NPCocoaEventFlagsChanged; break; default: printf("Asked to convert key event of unknown type to Cocoa plugin event!"); } #ifdef NS_LEOPARD_AND_LATER pluginEvent.data.key.modifierFlags = [cocoaEvent modifierFlags]; #else pluginEvent.data.key.modifierFlags = nsCocoaUtils::GetCocoaEventModifierFlags(cocoaEvent); #endif pluginEvent.data.key.keyCode = [cocoaEvent keyCode]; // don't try to access character data for flags changed events, it will raise an exception if (nativeType != NSFlagsChanged) { pluginEvent.data.key.characters = (NPNSString*)[cocoaEvent characters]; pluginEvent.data.key.charactersIgnoringModifiers = (NPNSString*)[cocoaEvent charactersIgnoringModifiers]; pluginEvent.data.key.isARepeat = [cocoaEvent isARepeat]; } } static bool IsPrintableChar(char16_t aChar) { return (aChar >= 0x20 && aChar <= 0x7E) || aChar >= 0xA0; } static uint32_t GetGeckoKeyCodeFromChar(char16_t aChar) { // We don't support the key code for non-ASCII characters if (aChar > 0x7E) return 0; if (aChar >= 'a' && aChar <= 'z') // lowercase return uint32_t(toupper(aChar)); else if (aChar >= 'A' && aChar <= 'Z') // uppercase return uint32_t(aChar); else if (aChar >= '0' && aChar <= '9') return uint32_t(aChar - '0' + NS_VK_0); switch (aChar) { case kReturnCharCode: case kEnterCharCode: case '\n': return NS_VK_RETURN; case '{': case '[': return NS_VK_OPEN_BRACKET; case '}': case ']': return NS_VK_CLOSE_BRACKET; case '\'': case '"': return NS_VK_QUOTE; case '\\': return NS_VK_BACK_SLASH; case ' ': return NS_VK_SPACE; case ';': return NS_VK_SEMICOLON; case '=': return NS_VK_EQUALS; case ',': return NS_VK_COMMA; case '.': return NS_VK_PERIOD; case '/': return NS_VK_SLASH; case '`': return NS_VK_BACK_QUOTE; case '\t': return NS_VK_TAB; case '-': return NS_VK_SUBTRACT; case '+': return NS_VK_ADD; default: if (!IsPrintableChar(aChar)) NS_WARNING("GetGeckoKeyCodeFromChar has failed."); return 0; } } // Tabular functions for TenFourFox issue 497 static uint32_t ConvertMacToGeckoKeyLocation(UInt32 keyCode) { NS_OBJC_BEGIN_TRY_ABORT_BLOCK_RETURN; uint32_t location = nsIDOMKeyEvent::DOM_KEY_LOCATION_STANDARD; switch (keyCode) { case kCommandKeyCode: case kShiftKeyCode: case kOptionKeyCode: case kControlKeyCode: case kFnKeyCode: case kVK_PC_ContextMenu: location = nsIDOMKeyEvent::DOM_KEY_LOCATION_LEFT; break; case kRCommandKeyCode: case kRShiftKeyCode: case kROptionKeyCode: case kRControlKeyCode: location = nsIDOMKeyEvent::DOM_KEY_LOCATION_RIGHT; break; case kKeypad0KeyCode: case kKeypad1KeyCode: case kKeypad2KeyCode: case kKeypad3KeyCode: case kKeypad4KeyCode: case kKeypad5KeyCode: case kKeypad6KeyCode: case kKeypad7KeyCode: case kKeypad8KeyCode: case kKeypad9KeyCode: case kKeypadMultiplyKeyCode: case kKeypadAddKeyCode: case kKeypadSubtractKeyCode: case kKeypadDecimalKeyCode: case kKeypadDivideKeyCode: case kKeypadEqualsKeyCode: case kVK_JIS_KeypadComma: case kEnterKeyCode: case kClearKeyCode: location = nsIDOMKeyEvent::DOM_KEY_LOCATION_NUMPAD; break; } return location; NS_OBJC_END_TRY_ABORT_BLOCK_RETURN(0); } static KeyNameIndex ConvertMacToDOMKeyName(UInt32 keyCode) { #define K(y,x) case y: return KEY_NAME_INDEX_ ## x; // This replaces the code in TextInputHandler that we don't use. // Based on NativeKeyToDOMKeyName.h. switch (keyCode) { K(kOptionKeyCode, Alt) K(kROptionKeyCode, Alt) K(kCapsLockKeyCode, CapsLock) K(kFnKeyCode, Fn) K(kVK_PC_ContextMenu, ContextMenu) K(kControlKeyCode, Control) K(kRControlKeyCode, Control) K(kCommandKeyCode, Meta) K(kRCommandKeyCode, Meta) K(kShiftKeyCode, Shift) K(kRShiftKeyCode, Shift) case kReturnKeyCode: case kEnterKeyCode: case kPowerbookEnterKeyCode: return KEY_NAME_INDEX_Enter; K(kTabKeyCode, Tab) K(kLeftArrowKeyCode, ArrowLeft) K(kRightArrowKeyCode, ArrowRight) K(kDownArrowKeyCode, ArrowDown) K(kUpArrowKeyCode, ArrowUp) K(kEndKeyCode, End) K(kHomeKeyCode, Home) K(kPageDownKeyCode, PageDown) K(kPageUpKeyCode, PageUp) K(kBackspaceKeyCode, Backspace) K(kDeleteKeyCode, Delete) K(kClearKeyCode, Clear) K(kEscapeKeyCode, Escape) K(kInsertKeyCode, Help) // XXX?! K(kF1KeyCode, F1) K(kF2KeyCode, F2) K(kF3KeyCode, F3) K(kF4KeyCode, F4) K(kF5KeyCode, F5) K(kF6KeyCode, F6) K(kF7KeyCode, F7) K(kF8KeyCode, F8) K(kF9KeyCode, F9) K(kF10KeyCode, F10) K(kF11KeyCode, F11) K(kF12KeyCode, F12) K(kF13KeyCode, F13) K(kF14KeyCode, F14) K(kF15KeyCode, F15) K(kF16KeyCode, F16) K(kF17KeyCode, F17) K(kF18KeyCode, F18) K(kF19KeyCode, F19) K(kF20KeyCode, F20) K(kVK_JIS_Eisu, Eisu) K(kVK_JIS_Kana, KanjiMode) // We are missing volume and media keys, // but the OS seems to intercept these, so I // didn't bother assigning them symbols. } return KEY_NAME_INDEX_Unidentified; #undef K } #define K(x) CODE_NAME_INDEX_ ## x , static const CodeNameIndex MacKeyCodeToDOMCode[] = { /* It is not at all clear if all of these keys actually work! */ K(KeyA) // 0x00 K(KeyS) K(KeyD) K(KeyF) K(KeyH) K(KeyG) K(KeyZ) K(KeyX) K(KeyC) // 0x08 K(KeyV) K(IntlBackslash) // XXX: 0x0a K(KeyB) K(KeyQ) K(KeyW) K(KeyE) K(KeyR) K(KeyY) // 0x10 K(KeyT) K(Digit1) K(Digit2) K(Digit3) K(Digit4) K(Digit6) K(Digit5) K(Equal) // 0x18 K(Digit9) K(Digit7) K(Minus) K(Digit8) K(Digit0) K(BracketRight) K(KeyO) K(KeyU) // 0x20 K(BracketLeft) K(KeyI) K(KeyP) K(Enter) K(KeyL) K(KeyJ) K(Quote) K(KeyK) // 0x28 K(Semicolon) K(Backslash) K(Comma) K(Slash) K(KeyN) K(KeyM) K(Period) K(Tab) // 0x30 K(Space) K(Backquote) K(Backspace) K(NumpadEnter) // XXX: 0x34, kPowerbookEnterKeyCode. Just a guess. K(Escape) K(OSRight) K(OSLeft) K(ShiftLeft) // 0x38 K(CapsLock) K(AltLeft) K(ControlLeft) K(ShiftRight) K(AltRight) // huhuhu K(ControlRight) K(Fn) K(F17) // 0x40 K(NumpadDecimal) K(UNKNOWN) // 0x42 K(NumpadMultiply) K(UNKNOWN) // 0x44 K(NumpadAdd) K(UNKNOWN) // 0x46 K(NumpadClear) K(VolumeUp) // 0x48 K(VolumeDown) K(VolumeMute) K(NumpadDivide) K(NumpadEnter) K(UNKNOWN) // 0x4d K(NumpadSubtract) K(F18) K(F19) // 0x50 K(NumpadEqual) K(Numpad0) K(Numpad1) K(Numpad2) K(Numpad3) K(Numpad4) K(Numpad5) K(Numpad6) // 0x58 K(Numpad7) K(F20) K(Numpad8) K(Numpad9) K(IntlYen) K(IntlRo) K(NumpadComma) K(F5) // 0x60 K(F6) K(F7) K(F3) K(F8) K(F9) K(Lang2) // Eisu K(F11) K(Lang1) // 0x68 // Kana K(F13) K(F16) K(F14) K(UNKNOWN) // 0x6c K(F10) K(ContextMenu) K(F12) K(UNKNOWN) // 0x70 K(F15) K(Help) K(Home) K(PageUp) K(Delete) K(F4) K(End) K(F2) // 0x78 K(PageDown) K(F1) K(ArrowLeft) K(ArrowRight) K(ArrowDown) K(ArrowUp) K(UNKNOWN) // 0x7f }; #undef K inline static CodeNameIndex ConvertMacToDOMCode(UInt32 keyCode) { MOZ_ASSERT(keyCode < 0x80); return MacKeyCodeToDOMCode[keyCode]; } // End issue 497 static uint32_t ConvertMacToGeckoKeyCode(UInt32 keyCode, NSString* characters) { NS_OBJC_BEGIN_TRY_ABORT_BLOCK_RETURN; uint32_t geckoKeyCode = 0; switch (keyCode) { // modifiers. We don't get separate events for these case kEscapeKeyCode: geckoKeyCode = NS_VK_ESCAPE; break; case kRCommandKeyCode: case kCommandKeyCode: geckoKeyCode = NS_VK_META; break; case kRShiftKeyCode: case kShiftKeyCode: geckoKeyCode = NS_VK_SHIFT; break; case kCapsLockKeyCode: geckoKeyCode = NS_VK_CAPS_LOCK; break; case kRControlKeyCode: case kControlKeyCode: geckoKeyCode = NS_VK_CONTROL; break; case kROptionKeyCode: case kOptionKeyCode: geckoKeyCode = NS_VK_ALT; break; // function keys case kF1KeyCode: geckoKeyCode = NS_VK_F1; break; case kF2KeyCode: geckoKeyCode = NS_VK_F2; break; case kF3KeyCode: geckoKeyCode = NS_VK_F3; break; case kF4KeyCode: geckoKeyCode = NS_VK_F4; break; case kF5KeyCode: geckoKeyCode = NS_VK_F5; break; case kF6KeyCode: geckoKeyCode = NS_VK_F6; break; case kF7KeyCode: geckoKeyCode = NS_VK_F7; break; case kF8KeyCode: geckoKeyCode = NS_VK_F8; break; case kF9KeyCode: geckoKeyCode = NS_VK_F9; break; case kF10KeyCode: geckoKeyCode = NS_VK_F10; break; case kF11KeyCode: geckoKeyCode = NS_VK_F11; break; case kF12KeyCode: geckoKeyCode = NS_VK_F12; break; // these three are aliases for the ones below, so use the canonical ones. // case kF13KeyCode: geckoKeyCode = NS_VK_F13; break; // case kF14KeyCode: geckoKeyCode = NS_VK_F14; break; // case kF15KeyCode: geckoKeyCode = NS_VK_F15; break; // XXX: F16 through F20? case kPauseKeyCode: geckoKeyCode = NS_VK_PAUSE; break; case kScrollLockKeyCode: geckoKeyCode = NS_VK_SCROLL_LOCK; break; case kPrintScreenKeyCode: geckoKeyCode = NS_VK_PRINTSCREEN; break; // keypad case kKeypad0KeyCode: geckoKeyCode = NS_VK_NUMPAD0; break; case kKeypad1KeyCode: geckoKeyCode = NS_VK_NUMPAD1; break; case kKeypad2KeyCode: geckoKeyCode = NS_VK_NUMPAD2; break; case kKeypad3KeyCode: geckoKeyCode = NS_VK_NUMPAD3; break; case kKeypad4KeyCode: geckoKeyCode = NS_VK_NUMPAD4; break; case kKeypad5KeyCode: geckoKeyCode = NS_VK_NUMPAD5; break; case kKeypad6KeyCode: geckoKeyCode = NS_VK_NUMPAD6; break; case kKeypad7KeyCode: geckoKeyCode = NS_VK_NUMPAD7; break; case kKeypad8KeyCode: geckoKeyCode = NS_VK_NUMPAD8; break; case kKeypad9KeyCode: geckoKeyCode = NS_VK_NUMPAD9; break; case kClearKeyCode: geckoKeyCode = NS_VK_CLEAR; break; case kKeypadMultiplyKeyCode: geckoKeyCode = NS_VK_MULTIPLY; break; case kKeypadAddKeyCode: geckoKeyCode = NS_VK_ADD; break; case kKeypadSubtractKeyCode: geckoKeyCode = NS_VK_SUBTRACT; break; case kKeypadDecimalKeyCode: geckoKeyCode = NS_VK_DECIMAL; break; case kKeypadDivideKeyCode: geckoKeyCode = NS_VK_DIVIDE; break; // these may clash with forward delete and help case kInsertKeyCode: geckoKeyCode = NS_VK_INSERT; break; case kDeleteKeyCode: geckoKeyCode = NS_VK_DELETE; break; case kBackspaceKeyCode: geckoKeyCode = NS_VK_BACK; break; case kTabKeyCode: geckoKeyCode = NS_VK_TAB; break; case kHomeKeyCode: geckoKeyCode = NS_VK_HOME; break; case kEndKeyCode: geckoKeyCode = NS_VK_END; break; case kPageUpKeyCode: geckoKeyCode = NS_VK_PAGE_UP; break; case kPageDownKeyCode: geckoKeyCode = NS_VK_PAGE_DOWN; break; case kLeftArrowKeyCode: geckoKeyCode = NS_VK_LEFT; break; case kRightArrowKeyCode: geckoKeyCode = NS_VK_RIGHT; break; case kUpArrowKeyCode: geckoKeyCode = NS_VK_UP; break; case kDownArrowKeyCode: geckoKeyCode = NS_VK_DOWN; break; case kVK_ANSI_1: geckoKeyCode = NS_VK_1; break; case kVK_ANSI_2: geckoKeyCode = NS_VK_2; break; case kVK_ANSI_3: geckoKeyCode = NS_VK_3; break; case kVK_ANSI_4: geckoKeyCode = NS_VK_4; break; case kVK_ANSI_5: geckoKeyCode = NS_VK_5; break; case kVK_ANSI_6: geckoKeyCode = NS_VK_6; break; case kVK_ANSI_7: geckoKeyCode = NS_VK_7; break; case kVK_ANSI_8: geckoKeyCode = NS_VK_8; break; case kVK_ANSI_9: geckoKeyCode = NS_VK_9; break; case kVK_ANSI_0: geckoKeyCode = NS_VK_0; break; default: // if we haven't gotten the key code already, look at the char code if ([characters length]) geckoKeyCode = GetGeckoKeyCodeFromChar([characters characterAtIndex:0]); } return geckoKeyCode; NS_OBJC_END_TRY_ABORT_BLOCK_RETURN(0); } static bool IsSpecialGeckoKey(UInt32 macKeyCode) { bool isSpecial; // this table is used to determine which keys are special and should not generate a charCode switch (macKeyCode) { // modifiers - we don't get separate events for these yet case kEscapeKeyCode: case kShiftKeyCode: case kRShiftKeyCode: case kCommandKeyCode: case kRCommandKeyCode: case kCapsLockKeyCode: case kControlKeyCode: case kRControlKeyCode: case kOptionKeyCode: case kROptionKeyCode: case kClearKeyCode: case kFnKeyCode: // function keys case kF1KeyCode: case kF2KeyCode: case kF3KeyCode: case kF4KeyCode: case kF5KeyCode: case kF6KeyCode: case kF7KeyCode: case kF8KeyCode: case kF9KeyCode: case kF10KeyCode: case kF11KeyCode: case kF12KeyCode: // case kF13KeyCode: // clashes with PrintScreen // case kF14KeyCode: // clashes with ScrollLock // case kF15KeyCode: // clashes with Pause case kF16KeyCode: case kF17KeyCode: case kF18KeyCode: case kF19KeyCode: case kF20KeyCode: case kPauseKeyCode: case kScrollLockKeyCode: case kPrintScreenKeyCode: case kVK_PC_ContextMenu: case kInsertKeyCode: case kDeleteKeyCode: case kTabKeyCode: case kBackspaceKeyCode: case kHomeKeyCode: case kEndKeyCode: case kPageUpKeyCode: case kPageDownKeyCode: case kLeftArrowKeyCode: case kRightArrowKeyCode: case kUpArrowKeyCode: case kDownArrowKeyCode: case kReturnKeyCode: case kEnterKeyCode: case kPowerbookEnterKeyCode: isSpecial = true; break; default: isSpecial = false; break; } return isSpecial; } static bool IsNormalCharInputtingEvent(const WidgetKeyboardEvent& aEvent) { // this is not a character event. if (!aEvent.isChar || !aEvent.charCode || aEvent.IsMeta()) return false; // if this is a unicode char input event, we don't need to check // ctrl/alt/command keys. if (aEvent.charCode > 0x7F) return true; // ASCII chars should be input without ctrl/alt/command keys return !aEvent.IsControl() && !aEvent.IsAlt(); } #define CHARCODE_MASK_1 0x00FF0000 #define CHARCODE_MASK_2 0x000000FF #define CHARCODE_MASK 0x00FF00FF static uint32_t KeyTranslateToUnicode(Handle aHandle, UInt32 aKeyCode, UInt32 aModifiers, TextEncoding aEncoding) { #ifdef DEBUG_KB NSLog(@"**** KeyTranslateToUnicode: aHandle: %p, aKeyCode: %X, aModifiers: %X, aEncoding: %X", aHandle, aKeyCode, aModifiers, aEncoding); bool isShift = aModifiers & shiftKey; bool isCtrl = aModifiers & controlKey; bool isOpt = aModifiers & optionKey; bool isCmd = aModifiers & cmdKey; bool isCL = aModifiers & alphaLock; bool isNL = aModifiers & kEventKeyModifierNumLockMask; NSLog(@" Shift: %s, Ctrl: %s, Opt: %s, Cmd: %s, CapsLock: %s, NumLock: %s", isShift ? "ON" : "off", isCtrl ? "ON" : "off", isOpt ? "ON" : "off", isCmd ? "ON" : "off", isCL ? "ON" : "off", isNL ? "ON" : "off"); #endif UInt32 state = 0; UInt32 val = ::KeyTranslate(aHandle, aKeyCode | aModifiers, &state) & CHARCODE_MASK; // If state is not zero, it is in dead key state. Then, we need to recall // KeyTranslate for getting the actual character. if (state) { val = ::KeyTranslate(aHandle, aKeyCode | aModifiers, &state) & CHARCODE_MASK; } uint32_t ch = 0; UInt8 buf[2]; CFIndex len = 0; if (val & CHARCODE_MASK_1) buf[len++] = (val & CHARCODE_MASK_1) >> 16; buf[len++] = val & CHARCODE_MASK_2; CFStringRef str = ::CFStringCreateWithBytes(kCFAllocatorDefault, buf, len, (CFStringEncoding)aEncoding, false); ch = ::CFStringGetLength(str) == 1 ? ::CFStringGetCharacterAtIndex(str, 0) : 0; ::CFRelease(str); #ifdef DEBUG_KB NSLog(@" result: %X(%C)", ch, ch > ' ' ? ch : ' '); #endif return ch; } static uint32_t UCKeyTranslateToUnicode(const UCKeyboardLayout* aHandle, UInt32 aKeyCode, UInt32 aModifiers, UInt32 aKbType) { #ifdef DEBUG_KB NSLog(@"**** UCKeyTranslateToUnicode: aHandle: %p, aKeyCode: %X, aModifiers: %X, aKbType: %X", aHandle, aKeyCode, aModifiers, aKbType); bool isShift = aModifiers & shiftKey; bool isCtrl = aModifiers & controlKey; bool isOpt = aModifiers & optionKey; bool isCmd = aModifiers & cmdKey; bool isCL = aModifiers & alphaLock; bool isNL = aModifiers & kEventKeyModifierNumLockMask; NSLog(@" Shift: %s, Ctrl: %s, Opt: %s, Cmd: %s, CapsLock: %s, NumLock: %s", isShift ? "ON" : "off", isCtrl ? "ON" : "off", isOpt ? "ON" : "off", isCmd ? "ON" : "off", isCL ? "ON" : "off", isNL ? "ON" : "off"); #endif UInt32 deadKeyState = 0; UniCharCount len; UniChar chars[5]; OSStatus err = ::UCKeyTranslate(aHandle, aKeyCode, kUCKeyActionDown, aModifiers >> 8, aKbType, kUCKeyTranslateNoDeadKeysMask, &deadKeyState, 5, &len, chars); uint32_t ch = (err == noErr && len == 1) ? uint32_t(chars[0]) : 0; #ifdef DEBUG_KB NSLog(@" result: %X(%C)", ch, ch > ' ' ? ch : ' '); #endif return ch; } struct KeyTranslateData { KeyTranslateData() { mUchr.mLayout = nullptr; mUchr.mKbType = 0; mKchr.mHandle = nullptr; mKchr.mEncoding = NULL; // TextEncoding won't accept nullptr } // The script of the layout determines the encoding of characters obtained // from kchr resources. SInt16 mScript; // The keyboard layout identifier SInt32 mLayoutID; struct { const UCKeyboardLayout* mLayout; UInt32 mKbType; } mUchr; struct { Handle mHandle; TextEncoding mEncoding; } mKchr; }; static uint32_t GetUniCharFromKeyTranslate(KeyTranslateData& aData, UInt32 aKeyCode, UInt32 aModifiers) { if (aData.mUchr.mLayout) { return UCKeyTranslateToUnicode(aData.mUchr.mLayout, aKeyCode, aModifiers, aData.mUchr.mKbType); } if (aData.mKchr.mHandle) { return KeyTranslateToUnicode(aData.mKchr.mHandle, aKeyCode, aModifiers, aData.mKchr.mEncoding); } return 0; } static SInt32 GetScriptFromKeyboardLayout(SInt32 aLayoutID) { switch (aLayoutID) { case 0: // US case 3: // German case 224: // Swedish case -2: return smRoman; // US-Extended case -18944: return smGreek; // Greek default: NS_NOTREACHED("unknown keyboard layout"); } return smRoman; } static CFStringRef GetInputSourceIDFromKeyboardLayout(SInt32 aLayoutID) { NS_ASSERTION(nsCocoaFeatures::OnLeopardOrLater() && Leopard_TISCopyCurrentKeyboardLayoutInputSource && Leopard_TISGetInputSourceProperty && Leopard_TISCreateInputSourceList && kOurTISPropertyUnicodeKeyLayoutData && kOurTISPropertyInputSourceID, "GetInputSourceIDFromKeyboardLayout should only be used on Leopard or later."); KeyboardLayoutRef keylayout; if (KLGetKeyboardLayoutWithIdentifier(aLayoutID, &keylayout) != noErr) return nullptr; const void* uchrFromID; if (KLGetKeyboardLayoutProperty(keylayout, kKLuchrData, &uchrFromID) != noErr) return nullptr; CFDictionaryRef dict = CFDictionaryCreate(kCFAllocatorDefault, NULL, NULL, 0, NULL, NULL); CFArrayRef inputSources = Leopard_TISCreateInputSourceList(dict, true); CFRelease(dict); CFStringRef sourceID = nullptr; for (CFIndex i = 0; i < CFArrayGetCount(inputSources); ++i) { TISInputSourceRef tis = static_cast(const_cast(CFArrayGetValueAtIndex(inputSources, i))); CFDataRef data = static_cast(Leopard_TISGetInputSourceProperty(tis, kOurTISPropertyUnicodeKeyLayoutData)); if (!data) continue; const UCKeyboardLayout* uchr = reinterpret_cast(CFDataGetBytePtr(data)); if (uchr == uchrFromID) { sourceID = static_cast(Leopard_TISGetInputSourceProperty(tis, kOurTISPropertyInputSourceID)); break; } } CFRelease(inputSources); return sourceID; } static void GetKCHRData(KeyTranslateData &aKT) { KeyboardLayoutRef kbRef; OSStatus err = ::KLGetKeyboardLayoutWithIdentifier(aKT.mLayoutID, &kbRef); if (err != noErr) return; err = ::KLGetKeyboardLayoutProperty(kbRef, kKLKCHRData, (const void**)&aKT.mKchr.mHandle); if (err != noErr || !aKT.mKchr.mHandle) return; err = ::GetTextEncodingFromScriptInfo(aKT.mScript, kTextLanguageDontCare, kTextRegionDontCare, &aKT.mKchr.mEncoding); if (err != noErr) aKT.mKchr.mHandle = nullptr; } static uint32_t GetUSLayoutCharFromKeyTranslate(UInt32 aKeyCode, UInt32 aModifiers) { KeyboardLayoutRef kbRef = nullptr; OSStatus err = ::KLGetKeyboardLayoutWithIdentifier(kKLUSKeyboard, &kbRef); NS_ENSURE_TRUE(err == noErr && kbRef, 0); const UCKeyboardLayout* layout = nullptr; err = ::KLGetKeyboardLayoutProperty(kbRef, kKLuchrData, (const void**)&layout); NS_ENSURE_TRUE(err == noErr && layout, 0); UInt32 kbType = 40; // ANSI, don't use actual layout return UCKeyTranslateToUnicode(layout, aKeyCode, aModifiers, kbType); } - (void) convertCocoaKeyEvent:(NSEvent*)aKeyEvent toGeckoEvent:(WidgetKeyboardEvent*)outGeckoEvent { NS_OBJC_BEGIN_TRY_ABORT_BLOCK; NS_ASSERTION(aKeyEvent && outGeckoEvent, "convertCocoaKeyEvent:toGeckoEvent: requires non-null arguments"); if (!aKeyEvent || !outGeckoEvent) return; unsigned short keyCode = nsCocoaUtils::GetCocoaEventKeyCode(aKeyEvent); nsCocoaUtils::InitInputEvent(*outGeckoEvent, aKeyEvent); // coords for key events are always 0,0 outGeckoEvent->refPoint.x = outGeckoEvent->refPoint.y = 0; // Initialize whether or not we are using charCodes to false. outGeckoEvent->isChar = false; // Check to see if the message is a key press that does not involve // one of our special key codes. // (This can also be generated by insertText:, so look there for a similar // but abbreviated pathway.) if (outGeckoEvent->mMessage == eKeyPress && !IsSpecialGeckoKey(keyCode)) { outGeckoEvent->isChar = true; // this is not a special key outGeckoEvent->charCode = 0; outGeckoEvent->keyCode = 0; // not set for key press events outGeckoEvent->location = ConvertMacToGeckoKeyLocation(keyCode); NSString* chars = [aKeyEvent characters]; if ([chars length] > 0) outGeckoEvent->charCode = [chars characterAtIndex:0]; // convert control-modified charCode to raw charCode (with appropriate case) if (outGeckoEvent->IsControl() && outGeckoEvent->charCode <= 26) outGeckoEvent->charCode += (outGeckoEvent->IsShift()) ? ('A' - 1) : ('a' - 1); // Accel and access key handling needs to know the characters that this // key produces with Shift up or down. So, provide this information // when Ctrl or Command or Alt is pressed. if (outGeckoEvent->IsControl() || outGeckoEvent->IsMeta() || outGeckoEvent->IsAlt()) { KeyTranslateData kt; bool isRomanKeyboardLayout; if (gOverrideKeyboardLayout.mOverrideEnabled) { kt.mLayoutID = gOverrideKeyboardLayout.mKeyboardLayout; kt.mScript = GetScriptFromKeyboardLayout(kt.mLayoutID); } else { // GetScriptManagerVariable and GetScriptVariable are both deprecated. // KLGetCurrentKeyboardLayout is newer but also deprecated in OS X // 10.5. It's not clear from the documentation but it seems that // KLGetKeyboardLayoutProperty with kKLGroupIdentifier may provide the // script identifier for a KeyboardLayoutRef (bug 432388 comment 6). // The "Text Input Source Services" API is not available prior to OS X // 10.5. kt.mScript = ::GetScriptManagerVariable(smKeyScript); kt.mLayoutID = ::GetScriptVariable(kt.mScript, smScriptKeys); } isRomanKeyboardLayout = (kt.mScript == smRoman); bool isUchrKeyboardLayout = false; // GetResource('uchr', kt.mLayoutID) fails on OS X 10.5 if (nsCocoaFeatures::OnLeopardOrLater() && Leopard_TISCopyCurrentKeyboardLayoutInputSource && Leopard_TISGetInputSourceProperty && Leopard_TISCreateInputSourceList && kOurTISPropertyUnicodeKeyLayoutData && kOurTISPropertyInputSourceID) { CFDataRef uchr = NULL; if (gOverrideKeyboardLayout.mOverrideEnabled) { CFStringRef sourceID = GetInputSourceIDFromKeyboardLayout(kt.mLayoutID); NS_ASSERTION(sourceID, "unable to map keyboard layout ID to input source ID"); const void* keys[] = { kOurTISPropertyInputSourceID }; const void* vals[] = { sourceID }; CFDictionaryRef dict = CFDictionaryCreate(kCFAllocatorDefault, keys, vals, 1, NULL, NULL); CFArrayRef inputSources = Leopard_TISCreateInputSourceList(dict, true); CFRelease(dict); if (CFArrayGetCount(inputSources) == 1) { TISInputSourceRef tis = static_cast(const_cast(CFArrayGetValueAtIndex(inputSources, 0))); uchr = static_cast(Leopard_TISGetInputSourceProperty(tis, kOurTISPropertyUnicodeKeyLayoutData)); } CFRelease(inputSources); } else { TISInputSourceRef tis = Leopard_TISCopyCurrentKeyboardLayoutInputSource(); uchr = static_cast(Leopard_TISGetInputSourceProperty(tis, kOurTISPropertyUnicodeKeyLayoutData)); } if (uchr) { // We should be here on OS X 10.5 for any Apple provided layout, as // they are all uchr. It may be possible to still use kchr resources // from elsewhere, so they may be picked by GetKCHRData below kt.mUchr.mLayout = reinterpret_cast (CFDataGetBytePtr(uchr)); isUchrKeyboardLayout = true; } } else { // 10.4 KeyboardLayoutRef kbRef = nullptr; OSStatus err = ::KLGetKeyboardLayoutWithIdentifier(kt.mLayoutID, &kbRef); if (err == noErr && kbRef) { SInt32 kind; err = ::KLGetKeyboardLayoutProperty(kbRef, kKLKind, (const void **)&kind); if (err == noErr && kind != kKLKCHRKind) { err = ::KLGetKeyboardLayoutProperty(kbRef, kKLuchrData, (const void**)&kt.mUchr.mLayout); if (err != noErr) { kt.mUchr.mLayout = nullptr; // if the kind is kKLKCHRuchrKind, we can retry by KCHR. isUchrKeyboardLayout = kind != kKLKCHRuchrKind; } else { isUchrKeyboardLayout = true; } } } } if (!isUchrKeyboardLayout) { GetKCHRData(kt); } // If a keyboard layout override is set, we also need to force the // keyboard type to something ANSI to avoid test failures on machines // with JIS keyboards (since the pair of keyboard layout and physical // keyboard type form the actual key layout). This assumes that the // test setting the override was written assuming an ANSI keyboard. if (kt.mUchr.mLayout) kt.mUchr.mKbType = gOverrideKeyboardLayout.mOverrideEnabled ? 40 : ::LMGetKbdType(); UInt32 key = nsCocoaUtils::GetCocoaEventKeyCode(aKeyEvent); // Caps lock and num lock modifier state: UInt32 lockState = 0; if (nsCocoaUtils::GetCocoaEventModifierFlags(aKeyEvent) & NSAlphaShiftKeyMask) lockState |= alphaLock; if (nsCocoaUtils::GetCocoaEventModifierFlags(aKeyEvent) & NSNumericPadKeyMask) lockState |= kEventKeyModifierNumLockMask; // normal chars uint32_t unshiftedChar = GetUniCharFromKeyTranslate(kt, key, lockState); UInt32 shiftLockMod = shiftKey | lockState; uint32_t shiftedChar = GetUniCharFromKeyTranslate(kt, key, shiftLockMod); // characters generated with Cmd key // XXX we should remove CapsLock state, which changes characters from // Latin to Cyrillic with Russian layout on 10.4 only when Cmd key // is pressed. UInt32 numState = (lockState & ~alphaLock); // only num lock state uint32_t uncmdedChar = GetUniCharFromKeyTranslate(kt, key, numState); UInt32 shiftNumMod = numState | shiftKey; uint32_t uncmdedShiftChar = GetUniCharFromKeyTranslate(kt, key, shiftNumMod); uint32_t uncmdedUSChar = GetUSLayoutCharFromKeyTranslate(key, numState); UInt32 cmdNumMod = cmdKey | numState; uint32_t cmdedChar = GetUniCharFromKeyTranslate(kt, key, cmdNumMod); UInt32 cmdShiftNumMod = shiftKey | cmdNumMod; uint32_t cmdedShiftChar = GetUniCharFromKeyTranslate(kt, key, cmdShiftNumMod); // Is the keyboard layout changed by Cmd key? // E.g., Arabic, Russian, Hebrew, Greek and Dvorak-QWERTY. bool isCmdSwitchLayout = uncmdedChar != cmdedChar; // Is the keyboard layout for Latin, but Cmd key switches the layout? // I.e., Dvorak-QWERTY bool isDvorakQWERTY = isCmdSwitchLayout && isRomanKeyboardLayout; // If the current keyboard is not Dvorak-QWERTY or Cmd is not pressed, // we should append unshiftedChar and shiftedChar for handling the // normal characters. These are the characters that the user is most // likely to associate with this key. if ((unshiftedChar || shiftedChar) && (!outGeckoEvent->IsMeta() || !isDvorakQWERTY)) { AlternativeCharCode altCharCodes(unshiftedChar, shiftedChar); outGeckoEvent->alternativeCharCodes.AppendElement(altCharCodes); } // Most keyboard layouts provide the same characters in the NSEvents // with Command+Shift as with Command. However, with Command+Shift we // want the character on the second level. e.g. With a US QWERTY // layout, we want "?" when the "/","?" key is pressed with // Command+Shift. // On a German layout, the OS gives us '/' with Cmd+Shift+SS(eszett) // even though Cmd+SS is 'SS' and Shift+'SS' is '?'. This '/' seems // like a hack to make the Cmd+"?" event look the same as the Cmd+"?" // event on a US keyboard. The user thinks they are typing Cmd+"?", so // we'll prefer the "?" character, replacing charCode with shiftedChar // when Shift is pressed. However, in case there is a layout where the // character unique to Cmd+Shift is the character that the user expects, // we'll send it as an alternative char. bool hasCmdShiftOnlyChar = cmdedChar != cmdedShiftChar && uncmdedShiftChar != cmdedShiftChar; uint32_t originalCmdedShiftChar = cmdedShiftChar; // If we can make a good guess at the characters that the user would // expect this key combination to produce (with and without Shift) then // use those characters. This also corrects for CapsLock, which was // ignored above. if (!isCmdSwitchLayout) { // The characters produced with Command seem similar to those without // Command. if (unshiftedChar) cmdedChar = unshiftedChar; if (shiftedChar) cmdedShiftChar = shiftedChar; } else if (uncmdedUSChar == cmdedChar) { // It looks like characters from a US layout are provided when Command // is down. uint32_t ch = GetUSLayoutCharFromKeyTranslate(key, lockState); if (ch) cmdedChar = ch; ch = GetUSLayoutCharFromKeyTranslate(key, shiftLockMod); if (ch) cmdedShiftChar = ch; } // Only charCode (not alternativeCharCodes) is available to javascript, // so attempt to set this to the most likely intended (or most useful) // character. Note that cmdedChar and cmdedShiftChar are usually // Latin/ASCII characters and that is what is wanted here as accel // keys are expected to be Latin characters. // // XXX We should do something similar when Control is down (bug 429510). if (outGeckoEvent->IsMeta() && !(outGeckoEvent->IsControl() || outGeckoEvent->IsAlt())) { // The character to use for charCode. uint32_t preferredCharCode = 0; preferredCharCode = outGeckoEvent->IsShift() ? cmdedShiftChar : cmdedChar; if (preferredCharCode) { #ifdef DEBUG_KB if (outGeckoEvent->charCode != preferredCharCode) { NSLog(@" charCode replaced: %X(%C) to %X(%C)", outGeckoEvent->charCode, outGeckoEvent->charCode > ' ' ? outGeckoEvent->charCode : ' ', preferredCharCode, preferredCharCode > ' ' ? preferredCharCode : ' '); } #endif outGeckoEvent->charCode = preferredCharCode; } } // If the current keyboard layout is switched by the Cmd key, // we should append cmdedChar and shiftedCmdChar that are // Latin char for the key. But don't append at Dvorak-QWERTY. if ((cmdedChar || cmdedShiftChar) && isCmdSwitchLayout && !isDvorakQWERTY) { AlternativeCharCode altCharCodes(cmdedChar, cmdedShiftChar); outGeckoEvent->alternativeCharCodes.AppendElement(altCharCodes); } // Special case for 'SS' key of German layout. See the comment of // hasCmdShiftOnlyChar definition for the detail. if (hasCmdShiftOnlyChar && originalCmdedShiftChar) { AlternativeCharCode altCharCodes(0, originalCmdedShiftChar); outGeckoEvent->alternativeCharCodes.AppendElement(altCharCodes); } } // Now that we have a charCode defined, use that as a KeyNameIndex // for TenFourFox issue 497. outGeckoEvent->mKeyNameIndex = KEY_NAME_INDEX_USE_STRING; outGeckoEvent->mKeyValue = (uint32_t)outGeckoEvent->charCode; } else { NSString* characters = nil; if ([aKeyEvent type] != NSFlagsChanged) characters = [aKeyEvent charactersIgnoringModifiers]; outGeckoEvent->keyCode = ConvertMacToGeckoKeyCode(keyCode, characters); outGeckoEvent->charCode = 0; // Add extra DOM fields for TenFourFox issue 497. // XXX: Should this be based on the Gecko key code for consistency? outGeckoEvent->location = ConvertMacToGeckoKeyLocation(keyCode); outGeckoEvent->mKeyNameIndex = ConvertMacToDOMKeyName(keyCode); // If the KeyNameIndex is still Unidentified, look at [characters] to see if // we can maybe extract it from there. if (outGeckoEvent->mKeyNameIndex == KEY_NAME_INDEX_Unidentified && characters && [characters length]) { outGeckoEvent->mKeyNameIndex = KEY_NAME_INDEX_USE_STRING; outGeckoEvent->mKeyValue = (uint32_t)[characters characterAtIndex:0]; } } // Convert the KeyName to a CodeName. We don't use CODE_NAME_INDEX_STRING; every // key has a code, or else it's CODE_NAME_INDEX_UNKNOWN. // This concludes TenFourFox issue 497. outGeckoEvent->mCodeNameIndex = ConvertMacToDOMCode(keyCode); // For NativeKeyBindings outGeckoEvent->mNativeKeyEvent = aKeyEvent; if (outGeckoEvent->mMessage == eKeyPress && !outGeckoEvent->IsMeta()) [NSCursor setHiddenUntilMouseMoves:YES]; NS_OBJC_END_TRY_ABORT_BLOCK; } // Mozilla 6 removed this code, but we still need it for TenFourFox. - (void)sendCompositionEvent:(int32_t) aEventType { #ifdef DEBUG_IME NSLog(@"****in sendCompositionEvent; type = %d", aEventType); #endif if (!mGeckoChild) return; if (aEventType == eCompositionStart) [self initTSMDocument]; // static void init_composition_event( *aEvent, int aType) WidgetCompositionEvent event(true, aEventType, mGeckoChild); event.time = PR_IntervalNow(); if (aEventType == eCompositionEnd) event.mData = mLastDispatchedCompositionString; mGeckoChild->DispatchWindowEvent(event); mLastDispatchedCompositionString.Truncate(); } - (void)sendTextEvent:(char16_t*) aBuffer attributedString:(NSAttributedString*) aString selectedRange:(NSRange) selRange markedRange:(NSRange) markRange doCommit:(BOOL) doCommit { #ifdef DEBUG_IME NSLog(@"****in sendTextEvent; string = '%@'", aString); NSLog(@" markRange = %d, %d; selRange = %d, %d", markRange.location, markRange.length, selRange.location, selRange.length); #endif if (!mGeckoChild) return; WidgetCompositionEvent textEvent(true, eCompositionChange, mGeckoChild); textEvent.time = PR_IntervalNow(); textEvent.mData = aBuffer; if (!doCommit) textEvent.mRanges = ConvertAttributeToGeckoRange(aString, markRange, selRange, CountRanges(aString)); // harmonize bug 974318 // Do everything here that TextInputHandler's // DispatchCompositionChangeEvent does. mLastDispatchedCompositionString = textEvent.mData; mGeckoChild->DispatchWindowEvent(textEvent); } // Whew! #pragma mark - #if(0) // NSTextInputClient implementation - (NSRange)markedRange { NS_OBJC_BEGIN_TRY_ABORT_BLOCK_RETURN; NS_ENSURE_TRUE(mTextInputHandler, NSMakeRange(NSNotFound, 0)); return mTextInputHandler->MarkedRange(); NS_OBJC_END_TRY_ABORT_BLOCK_RETURN(NSMakeRange(0, 0)); } - (NSRange)selectedRange { NS_OBJC_BEGIN_TRY_ABORT_BLOCK_RETURN; NS_ENSURE_TRUE(mTextInputHandler, NSMakeRange(NSNotFound, 0)); return mTextInputHandler->SelectedRange(); NS_OBJC_END_TRY_ABORT_BLOCK_RETURN(NSMakeRange(0, 0)); } - (BOOL)drawsVerticallyForCharacterAtIndex:(NSUInteger)charIndex { NS_ENSURE_TRUE(mTextInputHandler, NO); if (charIndex == NSNotFound) { return NO; } return mTextInputHandler->DrawsVerticallyForCharacterAtIndex(charIndex); } - (NSUInteger)characterIndexForPoint:(NSPoint)thePoint { NS_ENSURE_TRUE(mTextInputHandler, 0); return mTextInputHandler->CharacterIndexForPoint(thePoint); } - (NSArray*)validAttributesForMarkedText { NS_OBJC_BEGIN_TRY_ABORT_BLOCK_NIL; NS_ENSURE_TRUE(mTextInputHandler, [NSArray array]); return mTextInputHandler->GetValidAttributesForMarkedText(); NS_OBJC_END_TRY_ABORT_BLOCK_NIL; } - (void)insertText:(id)aString replacementRange:(NSRange)replacementRange { NS_OBJC_BEGIN_TRY_ABORT_BLOCK; NS_ENSURE_TRUE_VOID(mGeckoChild); nsAutoRetainCocoaObject kungFuDeathGrip(self); NSAttributedString* attrStr; if ([aString isKindOfClass:[NSAttributedString class]]) { attrStr = static_cast(aString); } else { attrStr = [[[NSAttributedString alloc] initWithString:aString] autorelease]; } mTextInputHandler->InsertText(attrStr, &replacementRange); NS_OBJC_END_TRY_ABORT_BLOCK; } - (void)doCommandBySelector:(SEL)aSelector { NS_OBJC_BEGIN_TRY_ABORT_BLOCK; if (!mGeckoChild || !mTextInputHandler) { return; } const char* sel = reinterpret_cast(aSelector); if (!mTextInputHandler->DoCommandBySelector(sel)) { [super doCommandBySelector:aSelector]; } NS_OBJC_END_TRY_ABORT_BLOCK; } - (void)unmarkText { NS_ENSURE_TRUE_VOID(mTextInputHandler); mTextInputHandler->CommitIMEComposition(); } - (BOOL) hasMarkedText { NS_ENSURE_TRUE(mTextInputHandler, NO); return mTextInputHandler->HasMarkedText(); } - (void)setMarkedText:(id)aString selectedRange:(NSRange)selectedRange replacementRange:(NSRange)replacementRange { NS_OBJC_BEGIN_TRY_ABORT_BLOCK; NS_ENSURE_TRUE_VOID(mTextInputHandler); nsAutoRetainCocoaObject kungFuDeathGrip(self); NSAttributedString* attrStr; if ([aString isKindOfClass:[NSAttributedString class]]) { attrStr = static_cast(aString); } else { attrStr = [[[NSAttributedString alloc] initWithString:aString] autorelease]; } mTextInputHandler->SetMarkedText(attrStr, selectedRange, &replacementRange); NS_OBJC_END_TRY_ABORT_BLOCK; } - (NSAttributedString*)attributedSubstringForProposedRange:(NSRange)aRange actualRange:(NSRangePointer)actualRange { NS_ENSURE_TRUE(mTextInputHandler, nil); return mTextInputHandler->GetAttributedSubstringFromRange(aRange, actualRange); } - (NSRect)firstRectForCharacterRange:(NSRange)aRange actualRange:(NSRangePointer)actualRange { NS_ENSURE_TRUE(mTextInputHandler, NSMakeRect(0.0, 0.0, 0.0, 0.0)); return mTextInputHandler->FirstRectForCharacterRange(aRange, actualRange); } - (NSInteger)windowLevel { NS_OBJC_BEGIN_TRY_ABORT_BLOCK_RETURN; NS_ENSURE_TRUE(mTextInputHandler, [[self window] level]); return mTextInputHandler->GetWindowLevel(); NS_OBJC_END_TRY_ABORT_BLOCK_RETURN(NSNormalWindowLevel); } #else // NSTextInput and partial NSTextInputClient implementation - (void)insertText:(id)insertString { NS_OBJC_BEGIN_TRY_ABORT_BLOCK; NS_ENSURE_TRUE_VOID(mGeckoChild); nsAutoRetainCocoaObject kungFuDeathGrip(self); if (![insertString isKindOfClass:[NSAttributedString class]]) insertString = [[[NSAttributedString alloc] initWithString:insertString] autorelease]; NSString *tmpStr = [insertString string]; unsigned int len = [tmpStr length]; if (!nsTSMManager::IsComposing() && len == 0) return; // nothing to do #define MAX_BUFFER_SIZE 32 char16_t buffer[MAX_BUFFER_SIZE]; char16_t *bufPtr = (len >= MAX_BUFFER_SIZE) ? new char16_t[len + 1] : buffer; [tmpStr getCharacters:bufPtr]; bufPtr[len] = char16_t('\0'); if (len == 1 && !nsTSMManager::IsComposing()) { // don't let the same event be fired twice when hitting // enter/return! (Bug 420502) if (mKeyPressSent) return; // dispatch keypress event with char instead of textEvent // this is mostly the same as in convertCocoaKeyEvent: WidgetKeyboardEvent geckoEvent(true, eKeyPress, mGeckoChild); geckoEvent.charCode = bufPtr[0]; // gecko expects OS-translated unicode geckoEvent.keyCode = 0; geckoEvent.isChar = true; // TenFourFox issue 497 geckoEvent.mKeyNameIndex = KEY_NAME_INDEX_USE_STRING; geckoEvent.mKeyValue = (uint32_t)bufPtr[0]; if (mKeyDownHandled) geckoEvent.mFlags.mDefaultPrevented = true; // Don't set other modifiers from the current event, because here in // -insertText: they've already been taken into account in creating // the input string. if (mCurKeyEvent) { nsCocoaUtils::InitInputEvent(geckoEvent, mCurKeyEvent); uint32_t keyCode = nsCocoaUtils::GetCocoaEventKeyCode(mCurKeyEvent); // XXX The ASCII characters inputting mode of egbridge (Japanese IME) // might send the keyDown event with wrong keyboard layout if other // keyboard layouts are already loaded. In that case, the native event // doesn't match to this gecko event... if (!IsPrintableChar(geckoEvent.charCode)) { geckoEvent.keyCode = ConvertMacToGeckoKeyCode(keyCode, [mCurKeyEvent charactersIgnoringModifiers]); geckoEvent.charCode = 0; geckoEvent.mKeyValue = (uint32_t)geckoEvent.keyCode; } geckoEvent.mCodeNameIndex = ConvertMacToDOMCode(keyCode); geckoEvent.location = ConvertMacToGeckoKeyLocation(keyCode); } else { nsCocoaUtils::InitInputEvent(geckoEvent, static_cast(nullptr)); // Note that insertText is not called only at key pressing. if (!IsPrintableChar(geckoEvent.charCode)) { geckoEvent.keyCode = GetGeckoKeyCodeFromChar(geckoEvent.charCode); geckoEvent.charCode = 0; geckoEvent.mKeyValue = (uint32_t)geckoEvent.keyCode; } // If the event does not have a native key event, we can't determine the // actual scan code. In that case, hope for the best -- it would be worse // if we weren't using a QWERTY layout and guessed the wrong key instead // of just saying we don't know. geckoEvent.mCodeNameIndex = CODE_NAME_INDEX_UNKNOWN; geckoEvent.location = nsIDOMKeyEvent::DOM_KEY_LOCATION_STANDARD; } // Remove basic modifiers from keypress event because if they are included, // nsPlaintextEditor ignores the event. geckoEvent.modifiers &= ~(mozilla::MODIFIER_CONTROL | mozilla::MODIFIER_ALT | mozilla::MODIFIER_META); // TODO: // If mCurrentKeyEvent.mKeyEvent is null and when we implement textInput // event of DOM3 Events, we should dispatch it instead of keypress event. bool keyPressHandled = mGeckoChild->DispatchWindowEvent(geckoEvent); // Note: mGeckoChild might have become null here. Don't count on it from here on. // Only record the results of dispatching geckoEvent if we're currently // processing a keyDown event. if (mCurKeyEvent) { mKeyPressHandled = keyPressHandled; mKeyPressSent = YES; } } else { if (!nsTSMManager::IsComposing()) { [self sendCompositionEvent:eCompositionStart]; // Note: mGeckoChild might have become null here. Don't count on it from here on. nsTSMManager::StartComposing(self); } if (nsTSMManager::IgnoreCommit()) { tmpStr = [tmpStr init]; len = 0; bufPtr[0] = char16_t('\0'); insertString = [[[NSAttributedString alloc] initWithString:tmpStr] autorelease]; } [self sendTextEvent:bufPtr attributedString:insertString selectedRange:NSMakeRange(0, len) markedRange:mMarkedRange doCommit:YES]; [self sendCompositionEvent:eCompositionEnd]; nsTSMManager::EndComposing(); mMarkedRange = NSMakeRange(NSNotFound, 0); } if (bufPtr != buffer) delete[] bufPtr; NS_OBJC_END_TRY_ABORT_BLOCK; } - (void)insertNewline:(id)sender { [self insertText:@"\n"]; } - (void) doCommandBySelector:(SEL)aSelector { NS_OBJC_BEGIN_TRY_ABORT_BLOCK; #if DEBUG_IME NSLog(@"**** in doCommandBySelector %s (ignore %d)", aSelector, mKeyPressHandled); #endif if (!mKeyPressHandled) [super doCommandBySelector:aSelector]; NS_OBJC_END_TRY_ABORT_BLOCK; } - (void) setMarkedText:(id)aString selectedRange:(NSRange)selRange { NS_OBJC_BEGIN_TRY_ABORT_BLOCK; if (!mGeckoChild) return; nsAutoRetainCocoaObject kungFuDeathGrip(self); if (![aString isKindOfClass:[NSAttributedString class]]) aString = [[[NSAttributedString alloc] initWithString:aString] autorelease]; NSMutableAttributedString *mutableAttribStr = aString; NSString *tmpStr = [mutableAttribStr string]; unsigned int len = [tmpStr length]; char16_t buffer[MAX_BUFFER_SIZE]; char16_t *bufPtr = (len >= MAX_BUFFER_SIZE) ? new char16_t[len + 1] : buffer; [tmpStr getCharacters:bufPtr]; bufPtr[len] = char16_t('\0'); mMarkedRange.length = len; if (!nsTSMManager::IsComposing() && len > 0) { WidgetQueryContentEvent selection(true, eQuerySelectedText, mGeckoChild); mGeckoChild->DispatchWindowEvent(selection); mMarkedRange.location = selection.mSucceeded ? selection.mReply.mOffset : 0; [self sendCompositionEvent:eCompositionStart]; // Note: mGeckoChild might have become null here. Don't count on it from here on. nsTSMManager::StartComposing(self); } if (nsTSMManager::IsComposing()) { nsTSMManager::UpdateComposing(tmpStr); BOOL commit = len == 0; [self sendTextEvent:bufPtr attributedString:aString selectedRange:selRange markedRange:mMarkedRange doCommit:commit]; // Note: mGeckoChild might have become null here. Don't count on it from here on. if (commit) { [self sendCompositionEvent:eCompositionEnd]; // Note: mGeckoChild might have become null here. Don't count on it from here on. nsTSMManager::EndComposing(); } } if (bufPtr != buffer) delete[] bufPtr; NS_OBJC_END_TRY_ABORT_BLOCK; } - (void) unmarkText { nsTSMManager::CommitIME(); } - (BOOL) hasMarkedText { return (mMarkedRange.location != NSNotFound) && (mMarkedRange.length != 0); } - (NSInteger) conversationIdentifier { if (!mGeckoChild) return (long)self; WidgetQueryContentEvent textContent(true, eQueryTextContent, mGeckoChild); textContent.InitForQueryTextContent(0, 0); mGeckoChild->DispatchWindowEvent(textContent); if (!textContent.mSucceeded) return (long)self; return (long)textContent.mReply.mContentsRoot; } - (NSAttributedString *) attributedSubstringFromRange:(NSRange)theRange { NS_OBJC_BEGIN_TRY_ABORT_BLOCK_NIL; if (!mGeckoChild || theRange.length == 0) return nil; nsAutoString str; WidgetQueryContentEvent textContent(true, eQueryTextContent, mGeckoChild); textContent.InitForQueryTextContent(theRange.location, theRange.length); mGeckoChild->DispatchWindowEvent(textContent); if (!textContent.mSucceeded || textContent.mReply.mString.IsEmpty()) return nil; NSString* nsstr = ToNSString(textContent.mReply.mString); NSAttributedString* result = [[[NSAttributedString alloc] initWithString:nsstr attributes:nil] autorelease]; return result; NS_OBJC_END_TRY_ABORT_BLOCK_NIL; } - (NSRange) markedRange { NS_OBJC_BEGIN_TRY_ABORT_BLOCK_RETURN; if (![self hasMarkedText]) return NSMakeRange(NSNotFound, 0); return mMarkedRange; NS_OBJC_END_TRY_ABORT_BLOCK_RETURN(NSMakeRange(0, 0)); } - (NSRange) selectedRange { NS_OBJC_BEGIN_TRY_ABORT_BLOCK_RETURN; if (!mGeckoChild) return NSMakeRange(NSNotFound, 0); WidgetQueryContentEvent selection(true, eQuerySelectedText, mGeckoChild); mGeckoChild->DispatchWindowEvent(selection); if (!selection.mSucceeded) return NSMakeRange(NSNotFound, 0); return NSMakeRange(selection.mReply.mOffset, selection.mReply.mString.Length()); NS_OBJC_END_TRY_ABORT_BLOCK_RETURN(NSMakeRange(0, 0)); } - (BOOL)drawsVerticallyForCharacterAtIndex:(NSUInteger)charIndex { return NO; // XXX. See bug 1076657 if we need to support this. } - (NSRect) firstRectForCharacterRange:(NSRange)theRange { NS_OBJC_BEGIN_TRY_ABORT_BLOCK_RETURN; // XXX // This only returns the first character rect or caret rect right // now, not the first line rect, but this is sufficient for IME. NSRect rect; if (!mGeckoChild || theRange.location == NSNotFound) return rect; LayoutDeviceIntRect r; bool useCaretRect = theRange.length == 0; if (!useCaretRect) { WidgetQueryContentEvent charRect(true, eQueryTextRect, mGeckoChild); charRect.InitForQueryTextRect(theRange.location, 1); mGeckoChild->DispatchWindowEvent(charRect); if (charRect.mSucceeded) r = charRect.mReply.mRect; // XXX: actualRange code from TextInputHandler should be added here. else useCaretRect = true; } if (useCaretRect) { WidgetQueryContentEvent caretRect(true, eQueryCaretRect, mGeckoChild); caretRect.InitForQueryCaretRect(theRange.location); mGeckoChild->DispatchWindowEvent(caretRect); if (!caretRect.mSucceeded) return rect; r = caretRect.mReply.mRect; r.width = 0; // XXX: actualRange code from TextInputHandler should be added here. } nsIWidget* rootWidget = mGeckoChild->GetTopLevelWidget(); NSWindow* rootWindow = static_cast(rootWidget->GetNativeData(NS_NATIVE_WINDOW)); NSView* rootView = static_cast(rootWidget->GetNativeData(NS_NATIVE_WIDGET)); if (!rootWindow || !rootView) return rect; rect = nsCocoaUtils::DevPixelsToCocoaPoints(r); rect = [rootView convertRect:rect toView:nil]; rect.origin = [rootWindow convertBaseToScreen:rect.origin]; return rect; NS_OBJC_END_TRY_ABORT_BLOCK_RETURN(NSMakeRect(0.0, 0.0, 0.0, 0.0)); } - (NSUInteger)characterIndexForPoint:(NSPoint)thePoint { NS_WARNING("characterIndexForPoint not supported on 10.4"); // this requires much mucking around with text frames. no thanks. // if we need this, implement it from TextInputHandler.mm and pray. return 0; } - (NSArray*) validAttributesForMarkedText { NS_OBJC_BEGIN_TRY_ABORT_BLOCK_NIL; NS_WARNING("validAttributesForMarkedText not supported on 10.4"); return [NSArray array]; // empty array, no attributes supported NS_OBJC_END_TRY_ABORT_BLOCK_NIL; } #endif #pragma mark - // More backouts for TenFourFox + (NSEvent*)makeNewCocoaEventWithType:(NSEventType)type fromEvent:(NSEvent*)theEvent { NS_OBJC_BEGIN_TRY_ABORT_BLOCK_NIL; NSEvent* newEvent = [NSEvent keyEventWithType:type location:[theEvent locationInWindow] modifierFlags:nsCocoaUtils::GetCocoaEventModifierFlags(theEvent) timestamp:[theEvent timestamp] windowNumber:[theEvent windowNumber] context:[theEvent context] characters:[theEvent characters] charactersIgnoringModifiers:[theEvent charactersIgnoringModifiers] isARepeat:[theEvent isARepeat] keyCode:nsCocoaUtils::GetCocoaEventKeyCode(theEvent)]; return newEvent; NS_OBJC_END_TRY_ABORT_BLOCK_NIL; } #ifdef PR_LOGGING static const char* ToEscapedString(NSString* aString, nsAutoCString& aBuf) { for (uint32_t i = 0; i < [aString length]; ++i) { unichar ch = [aString characterAtIndex:i]; if (ch >= 32 && ch < 128) { aBuf.Append(char(ch)); } else { //aBuf += nsPrintfCString("\\u%04x", ch); aBuf += "."; } } return aBuf.get(); } #endif // This is a better solution to our menu problem on 10.4, and properly handles // the case of Cmd-equivalents that are not menu shortcuts (10.4Fx issue 22). - (BOOL)performKeyEquivalent:(NSEvent*)theEvent { UInt32 mf = nsCocoaUtils::GetCocoaEventModifierFlags(theEvent) & NSDeviceIndependentModifierFlagsMask; // Only bother if a Cmd-combination. The rest, we use the regular event // processing routines. Otherwise we get doubled events for certain keys, // most notoriously anything with NSFunctionKeyMask (arrow keys, Fn, etc.). // But don't do this for Cmd-~ (10.4Fx issue 33). if (mf & NSCommandKeyMask) { UInt32 kc = nsCocoaUtils::GetCocoaEventKeyCode(theEvent); if (kc != kTildeKeyCode) { [self keyDown:theEvent]; // this calls processKeyDownEvent too return YES; } } return NO; // handlers take over } // end issue // Returns true if Gecko claims to have handled the event, false otherwise. - (bool)processKeyDownEvent:(NSEvent*)theEvent { NS_OBJC_BEGIN_TRY_ABORT_BLOCK_RETURN; if (!mGeckoChild) return NO; #ifdef PR_LOGGING nsAutoCString str1; nsAutoCString str2; #endif #if(0) PR_LOG(sCocoaLog, PR_LOG_ALWAYS, ("ChildView processKeyDownEvent: keycode=%d,modifiers=%x,chars=%s,charsIgnoringModifiers=%s IMEopenstate=%s\n", nsCocoaUtils::GetCocoaEventKeyCode(theEvent), nsCocoaUtils::GetCocoaEventModifierFlags(theEvent), ToEscapedString([theEvent characters], str1), ToEscapedString([theEvent charactersIgnoringModifiers], str2), ((nsTSMManager::GetIMEOpenState()) ? "TRUE" : "false"))); #endif nsAutoRetainCocoaObject kungFuDeathGrip(self); mCurKeyEvent = theEvent; BOOL nonDeadKeyPress = [[theEvent characters] length] > 0; if (nonDeadKeyPress && !nsTSMManager::IsComposing()) { NSResponder* firstResponder = [[self window] firstResponder]; WidgetKeyboardEvent geckoKeydown(true, eKeyDown, mGeckoChild); [self convertCocoaKeyEvent:theEvent toGeckoEvent:&geckoKeydown]; mKeyDownHandled = mGeckoChild->DispatchWindowEvent(geckoKeydown); if (!mGeckoChild) { return mKeyDownHandled; } // The key down event may have shifted the focus, in which // case we should not fire the key press. if (firstResponder != [[self window] firstResponder]) { bool handled = mKeyDownHandled; mCurKeyEvent = nil; mKeyDownHandled = false; return handled; } // If this is the context menu key command, send a context menu key event. unsigned int modifierFlags = nsCocoaUtils::GetCocoaEventModifierFlags(theEvent) & NSDeviceIndependentModifierFlagsMask; if (modifierFlags == NSControlKeyMask && [[theEvent charactersIgnoringModifiers] isEqualToString:@" "]) { WidgetMouseEvent contextMenuEvent(true, eContextMenu, [self widget], WidgetMouseEvent::eReal, WidgetMouseEvent::eContextMenuKey); contextMenuEvent.modifiers = 0; bool cmEventHandled = mGeckoChild->DispatchWindowEvent(contextMenuEvent); [self maybeInitContextMenuTracking]; // Bail, there is nothing else to do here. bool handled = (cmEventHandled || mKeyDownHandled); mCurKeyEvent = nil; mKeyDownHandled = false; return handled; } WidgetKeyboardEvent geckoKeypress(true, eKeyPress, mGeckoChild); [self convertCocoaKeyEvent:theEvent toGeckoEvent:&geckoKeypress]; // if this is a non-letter keypress, or the control key is down, // dispatch the keydown to gecko, so that we trap delete, // control-letter combinations etc before Cocoa tries to use // them for keybindings. if ((!geckoKeypress.isChar || geckoKeypress.IsControl()) && !nsTSMManager::IsComposing()) { if (mKeyDownHandled) geckoKeypress.mFlags.mDefaultPrevented = true; mKeyPressHandled = mGeckoChild->DispatchWindowEvent(geckoKeypress); mKeyPressSent = YES; if (!mGeckoChild) return (mKeyDownHandled || mKeyPressHandled); } } // Let Cocoa interpret the key events, caching IsIMEComposing first. // We don't do it if this came from performKeyEquivalent because // interpretKeyEvents isn't set up to handle those key combinations. // XXX? bool wasComposing = nsTSMManager::IsComposing(); bool interpretKeyEventsCalled = false; if (//!isKeyEquiv && // XXX? Cameron (nsTSMManager::IsIMEEnabled() || nsTSMManager::IsRomanKeyboardsOnly())) { [super interpretKeyEvents:[NSArray arrayWithObject:theEvent]]; interpretKeyEventsCalled = true; } if (!mGeckoChild) { return (mKeyDownHandled || mKeyPressHandled); } if (!mKeyPressSent && nonDeadKeyPress && !wasComposing && !nsTSMManager::IsComposing()) { WidgetKeyboardEvent geckoKeypress(true, eKeyPress, mGeckoChild); [self convertCocoaKeyEvent:theEvent toGeckoEvent:&geckoKeypress]; // If we called interpretKeyEvents and this isn't normal character input // then IME probably ate the event for some reason. We do not want to // send a key press event in that case. if (!(interpretKeyEventsCalled && IsNormalCharInputtingEvent(geckoKeypress))) { if (mKeyDownHandled) { geckoKeypress.mFlags.mDefaultPrevented = true; } mKeyPressHandled = mGeckoChild->DispatchWindowEvent(geckoKeypress); } } // Note: mGeckoChild might have become null here. Don't count on it from here on. bool handled = (mKeyDownHandled || mKeyPressHandled); // See note about nested event loops where these variables are declared in header. mKeyPressHandled = false; mKeyPressSent = NO; mCurKeyEvent = nil; mKeyDownHandled = false; return handled; NS_OBJC_END_TRY_ABORT_BLOCK_RETURN(NO); } - (void)initTSMDocument { if (!mGeckoChild) return; // We need to get actual focused view. E.g., the view is in bookmark dialog // that is element. Then, the key events are processed the parent // window's view that has native focus. WidgetQueryContentEvent textContent(true, eQueryTextContent, mGeckoChild); textContent.InitForQueryTextContent(0, 0); mGeckoChild->DispatchWindowEvent(textContent); NSView* focusedView = self; if (textContent.mSucceeded && textContent.mReply.mFocusedWidget) { NSView* view = static_cast*>(textContent.mReply.mFocusedWidget-> GetNativeData(NS_NATIVE_WIDGET)); if (view) focusedView = view; } nsTSMManager::InitTSMDocument(focusedView); } // Double whew! // End of NSTextInput #pragma mark - // This is a private API that Cocoa uses. // Cocoa will call this after the menu system returns "NO" for "performKeyEquivalent:". // We want all they key events we can get so just return YES. In particular, this fixes // ctrl-tab - we don't get a "keyDown:" call for that without this. - (BOOL)_wantsKeyDownForEvent:(NSEvent*)event { return YES; } - (NSEvent*)lastKeyDownEvent { return mLastKeyDownEvent; } // This is Leopard-specific. #if(0) - (void)keyDown:(NSEvent*)theEvent { NS_OBJC_BEGIN_TRY_ABORT_BLOCK; [mLastKeyDownEvent release]; mLastKeyDownEvent = [theEvent retain]; // Weird things can happen on keyboard input if the key window isn't in the // current space. For example see bug 1056251. To get around this, always // make sure that, if our window is key, it's also made frontmost. Doing // this automatically switches to whatever space our window is in. Safari // does something similar. Our window should normally always be key -- // otherwise why is the OS sending us a key down event? But it's just // possible we're in Gecko's hidden window, so we check first. NSWindow *viewWindow = [self window]; if (viewWindow && [viewWindow isKeyWindow]) { [viewWindow orderWindow:NSWindowAbove relativeTo:0]; } #if !defined(RELEASE_BUILD) || defined(DEBUG) if (!Preferences::GetBool("intl.allow-insecure-text-input", false) && mGeckoChild && mTextInputHandler && mTextInputHandler->IsFocused()) { #ifdef MOZ_CRASHREPORTER NSWindow* window = [self window]; NSString* info = [NSString stringWithFormat:@"\nview [%@], window [%@], window is key %i, is fullscreen %i, app is active %i", self, window, [window isKeyWindow], ([window styleMask] & (1 << 14)) != 0, [NSApp isActive]]; nsAutoCString additionalInfo([info UTF8String]); #endif if (mGeckoChild->GetInputContext().IsPasswordEditor() && !TextInputHandler::IsSecureEventInputEnabled()) { #define CRASH_MESSAGE "A password editor has focus, but not in secure input mode" #ifdef MOZ_CRASHREPORTER CrashReporter::AppendAppNotesToCrashReport(NS_LITERAL_CSTRING("\nBug 893973: ") + NS_LITERAL_CSTRING(CRASH_MESSAGE)); CrashReporter::AppendAppNotesToCrashReport(additionalInfo); #endif MOZ_CRASH(CRASH_MESSAGE); #undef CRASH_MESSAGE } else if (!mGeckoChild->GetInputContext().IsPasswordEditor() && TextInputHandler::IsSecureEventInputEnabled()) { #define CRASH_MESSAGE "A non-password editor has focus, but in secure input mode" #ifdef MOZ_CRASHREPORTER CrashReporter::AppendAppNotesToCrashReport(NS_LITERAL_CSTRING("\nBug 893973: ") + NS_LITERAL_CSTRING(CRASH_MESSAGE)); CrashReporter::AppendAppNotesToCrashReport(additionalInfo); #endif MOZ_CRASH(CRASH_MESSAGE); #undef CRASH_MESSAGE } } #endif // #if !defined(RELEASE_BUILD) || defined(DEBUG) nsAutoRetainCocoaObject kungFuDeathGrip(self); bool handled = false; if (mGeckoChild && mTextInputHandler) { handled = mTextInputHandler->HandleKeyDownEvent(theEvent); } // We always allow keyboard events to propagate to keyDown: but if they are not // handled we give special Application menu items a chance to act. if (!handled && sApplicationMenu) { [sApplicationMenu performKeyEquivalent:theEvent]; } NS_OBJC_END_TRY_ABORT_BLOCK; } - (void)keyUp:(NSEvent*)theEvent { NS_OBJC_BEGIN_TRY_ABORT_BLOCK; NS_ENSURE_TRUE(mGeckoChild, ); nsAutoRetainCocoaObject kungFuDeathGrip(self); mTextInputHandler->HandleKeyUpEvent(theEvent); NS_OBJC_END_TRY_ABORT_BLOCK; } - (void)insertNewline:(id)sender { if (mTextInputHandler) { NSAttributedString *attrStr = [[NSAttributedString alloc] initWithString:@"\n"]; mTextInputHandler->InsertText(attrStr); [attrStr release]; } } - (void)flagsChanged:(NSEvent*)theEvent { NS_OBJC_BEGIN_TRY_ABORT_BLOCK; NS_ENSURE_TRUE(mGeckoChild, ); nsAutoRetainCocoaObject kungFuDeathGrip(self); mTextInputHandler->HandleFlagsChanged(theEvent); NS_OBJC_END_TRY_ABORT_BLOCK; } #else // Use the 7.0 code. - (void)keyDown:(NSEvent*)theEvent { NS_OBJC_BEGIN_TRY_ABORT_BLOCK; bool handled = [self processKeyDownEvent:theEvent]; // We always allow keyboard events to propagate to keyDown: but if they are not // handled we give special Application menu items a chance to act. if (!handled && sApplicationMenu) { [sApplicationMenu performKeyEquivalent:theEvent]; } NS_OBJC_END_TRY_ABORT_BLOCK; } static BOOL keyUpAlreadySentKeyDown = NO; - (void)keyUp:(NSEvent*)theEvent { NS_OBJC_BEGIN_TRY_ABORT_BLOCK; #ifdef PR_LOGGING nsAutoCString str1; nsAutoCString str2; #endif #if(0) PR_LOG(sCocoaLog, PR_LOG_ALWAYS, ("ChildView keyUp: keycode=%d,modifiers=%x,chars=%s,charsIgnoringModifiers=%s\n", nsCocoaUtils::GetCocoaEventKeyCode(theEvent), nsCocoaUtils::GetCocoaEventModifierFlags(theEvent), ToEscapedString([theEvent characters], str1), ToEscapedString([theEvent charactersIgnoringModifiers], str2))); #endif if (!mGeckoChild) return; if (mIgnoreNextKeyUpEvent) { mIgnoreNextKeyUpEvent = NO; return; } nsAutoRetainCocoaObject kungFuDeathGrip(self); // if we don't have any characters we can't generate a keyUp event if ([[theEvent characters] length] == 0 || nsTSMManager::IsComposing()) { return; } // Cocoa doesn't send an NSKeyDown event for control-tab on 10.4, so if this // is an NSKeyUp event for control-tab, send a down event to gecko first. if (!nsCocoaFeatures::OnLeopardOrLater() && !keyUpAlreadySentKeyDown && nsCocoaUtils::GetCocoaEventModifierFlags(theEvent) & NSControlKeyMask && nsCocoaUtils::GetCocoaEventKeyCode(theEvent) == kTabKeyCode) { // We'll need an NSKeyDown copy of our native event so we convert to a gecko event correctly. NSEvent* nativeKeyDownEvent = [ChildView makeNewCocoaEventWithType:NSKeyDown fromEvent:theEvent]; // send a key down event if we should bool keyDownHandled = false; if (![nativeKeyDownEvent isARepeat]) { WidgetKeyboardEvent geckoEvent(true, eKeyDown, mGeckoChild); [self convertCocoaKeyEvent:nativeKeyDownEvent toGeckoEvent:&geckoEvent]; keyDownHandled = mGeckoChild->DispatchWindowEvent(geckoEvent); if (!mGeckoChild) return; } // Check to see if we are still the first responder. // The key down event may have shifted the focus, in which // case we should not fire the key press. NSResponder* resp = [[self window] firstResponder]; if (resp != (NSResponder*)self) { keyUpAlreadySentKeyDown = YES; [resp keyUp:theEvent]; keyUpAlreadySentKeyDown = NO; return; } // now send a key press event if we should WidgetKeyboardEvent geckoEvent(true, eKeyPress, mGeckoChild); [self convertCocoaKeyEvent:nativeKeyDownEvent toGeckoEvent:&geckoEvent]; if (keyDownHandled) geckoEvent.mFlags.mDefaultPrevented = true; mGeckoChild->DispatchWindowEvent(geckoEvent); if (!mGeckoChild) return; } WidgetKeyboardEvent geckoEvent(true, eKeyUp, mGeckoChild); [self convertCocoaKeyEvent:theEvent toGeckoEvent:&geckoEvent]; mGeckoChild->DispatchWindowEvent(geckoEvent); NS_OBJC_END_TRY_ABORT_BLOCK; } - (void)flagsChanged:(NSEvent*)theEvent { NS_OBJC_BEGIN_TRY_ABORT_BLOCK; if (!mGeckoChild) return; nsAutoRetainCocoaObject kungFuDeathGrip(self); // CapsLock state and other modifier states are different: // CapsLock state does not revert when the CapsLock key goes up, as the // modifier state does for other modifier keys on key up. if ([theEvent keyCode] == kCapsLockKeyCode) { // Fire key down event for caps lock. [self fireKeyEventForFlagsChanged:theEvent keyDown:YES]; if (!mGeckoChild) return; // XXX should we fire keyup event too? The keyup event for CapsLock key // is never sent to gecko. } else if ([theEvent type] == NSFlagsChanged) { // Fire key up/down events for the modifier keys (shift, alt, ctrl, command). unsigned int modifiers = nsCocoaUtils::GetCocoaEventModifierFlags(theEvent) & NSDeviceIndependentModifierFlagsMask; const uint32_t kModifierMaskTable[] = { NSShiftKeyMask, NSControlKeyMask, NSAlternateKeyMask, NSCommandKeyMask }; const uint32_t kModifierCount = sizeof(kModifierMaskTable) / sizeof(kModifierMaskTable[0]); for (uint32_t i = 0; i < kModifierCount; i++) { uint32_t modifierBit = kModifierMaskTable[i]; if ((modifiers & modifierBit) != (gLastModifierState & modifierBit)) { BOOL isKeyDown = (modifiers & modifierBit) != 0 ? YES : NO; [self fireKeyEventForFlagsChanged:theEvent keyDown:isKeyDown]; if (!mGeckoChild) return; // Stop if focus has changed. // Check to see if we are still the first responder. if (![self isFirstResponder]) break; } } gLastModifierState = modifiers; } NS_OBJC_END_TRY_ABORT_BLOCK; } - (void)fireKeyEventForFlagsChanged:(NSEvent*)theEvent keyDown:(BOOL)isKeyDown { NS_OBJC_BEGIN_TRY_ABORT_BLOCK; if (!mGeckoChild || [theEvent type] != NSFlagsChanged || nsTSMManager::IsComposing()) return; nsAutoRetainCocoaObject kungFuDeathGrip(self); uint32_t message = isKeyDown ? eKeyDown : eKeyUp; NPCocoaEvent cocoaEvent; // Fire a key event. WidgetKeyboardEvent geckoEvent(true, message, mGeckoChild); [self convertCocoaKeyEvent:theEvent toGeckoEvent:&geckoEvent]; mGeckoChild->DispatchWindowEvent(geckoEvent); NS_OBJC_END_TRY_ABORT_BLOCK; } #endif - (BOOL) isFirstResponder { NS_OBJC_BEGIN_TRY_ABORT_BLOCK_RETURN; NSResponder* resp = [[self window] firstResponder]; return (resp == (NSResponder*)self); NS_OBJC_END_TRY_ABORT_BLOCK_RETURN(NO); } - (BOOL)isDragInProgress { if (!mDragService) return NO; nsCOMPtr dragSession; mDragService->GetCurrentSession(getter_AddRefs(dragSession)); return dragSession != nullptr; } - (BOOL)inactiveWindowAcceptsMouseEvent:(NSEvent*)aEvent { // 10.4Fx issue 19, see below OSStatus err; ProcessSerialNumber psn = { 0, kCurrentProcess }; // If we're being destroyed assume the default -- return YES. if (!mGeckoChild) return YES; // Do not accept non-click events, because we get tooltips and other things. // 10.4Fx issue 19, issue 168 if (([aEvent type] != NSLeftMouseDown && [aEvent type] != NSRightMouseDown)) return NO; // Activate just this window, if we're not foreground. 10.4Fx issue 19. err = SetFrontProcessWithOptions(&psn, kSetFrontProcessFrontWindowOnly); nsWindowType wType = mGeckoChild->WindowType(); NSWindow *swin = [self window]; if (swin && ![swin parentWindow] && ![swin attachedSheet] && wType != eWindowType_popup && wType != eWindowType_dialog && wType != eWindowType_sheet) { // Make it main, then make it key. This dance seems reliable. // Note, however, that most of the time we are NOT entering this code. // Most of our window stuff goes through ::WindowAcceptsEvent, even // if the window is "inactive." [swin makeMainWindow]; [swin makeKeyWindow]; [swin orderFrontRegardless]; // safe, because we are the // front app, the main window *and* the key window. } WidgetMouseEvent geckoEvent(true, eMouseActivate, mGeckoChild, WidgetMouseEvent::eReal); [self convertCocoaMouseEvent:aEvent toGeckoEvent:&geckoEvent]; return (mGeckoChild->DispatchInputEvent(&geckoEvent) != nsEventStatus_eConsumeNoDefault); } // We must always call through to our superclass, even when mGeckoChild is // nil -- otherwise the keyboard focus can end up in the wrong NSView. - (BOOL)becomeFirstResponder { NS_OBJC_BEGIN_TRY_ABORT_BLOCK_RETURN; return [super becomeFirstResponder]; NS_OBJC_END_TRY_ABORT_BLOCK_RETURN(YES); } - (void)viewsWindowDidBecomeKey { NS_OBJC_BEGIN_TRY_ABORT_BLOCK; if (!mGeckoChild) return; nsAutoRetainCocoaObject kungFuDeathGrip(self); // check to see if the window implements the mozWindow protocol. This // allows embedders to avoid re-entrant calls to -makeKeyAndOrderFront, // which can happen because these activate calls propagate out // to the embedder via nsIEmbeddingSiteWindow::SetFocus(). BOOL isMozWindow = [[self window] respondsToSelector:@selector(setSuppressMakeKeyFront:)]; if (isMozWindow) [[self window] setSuppressMakeKeyFront:YES]; nsIWidgetListener* listener = mGeckoChild->GetWidgetListener(); if (listener) listener->WindowActivated(); if (isMozWindow) [[self window] setSuppressMakeKeyFront:NO]; #if(0) if (mGeckoChild->GetInputContext().IsPasswordEditor()) { TextInputHandler::EnableSecureEventInput(); } else { TextInputHandler::EnsureSecureEventInputDisabled(); } #else if (mGeckoChild->GetInputContext().IsPasswordEditor()) ChildViewEnableSecureEventInput(); else ChildViewEnsureSecureEventInputDisabled(); #endif NS_OBJC_END_TRY_ABORT_BLOCK; } - (void)viewsWindowDidResignKey { if (!mGeckoChild) return; nsAutoRetainCocoaObject kungFuDeathGrip(self); nsIWidgetListener* listener = mGeckoChild->GetWidgetListener(); if (listener) listener->WindowDeactivated(); #if(0) TextInputHandler::EnsureSecureEventInputDisabled(); #else ChildViewEnsureSecureEventInputDisabled(); #endif } // If the call to removeFromSuperview isn't delayed from nsChildView:: // TearDownView(), the NSView hierarchy might get changed during calls to // [ChildView drawRect:], which leads to "beyond bounds" exceptions in // NSCFArray. For more info see bmo bug 373122. Apple's docs claim that // removeFromSuperviewWithoutNeedingDisplay "can be safely invoked during // display" (whatever "display" means). But it's _not_ true that it can be // safely invoked during calls to [NSView drawRect:]. We use // removeFromSuperview here because there's no longer any danger of being // "invoked during display", and because doing do clears up bmo bug 384343. - (void)delayedTearDown { NS_OBJC_BEGIN_TRY_ABORT_BLOCK; [self removeFromSuperview]; [self release]; NS_OBJC_END_TRY_ABORT_BLOCK; } #pragma mark - // drag'n'drop stuff #define kDragServiceContractID "@mozilla.org/widget/dragservice;1" - (NSDragOperation)dragOperationFromDragAction:(int32_t)aDragAction { if (nsIDragService::DRAGDROP_ACTION_LINK & aDragAction) return NSDragOperationLink; if (nsIDragService::DRAGDROP_ACTION_COPY & aDragAction) return NSDragOperationCopy; if (nsIDragService::DRAGDROP_ACTION_MOVE & aDragAction) return NSDragOperationGeneric; return NSDragOperationNone; } - (LayoutDeviceIntPoint)convertWindowCoordinates:(NSPoint)aPoint { if (!mGeckoChild) { return LayoutDeviceIntPoint(0, 0); } NSPoint localPoint = [self convertPoint:aPoint fromView:nil]; return mGeckoChild->CocoaPointsToDevPixels(localPoint); } - (APZCTreeManager*)apzctm { return mGeckoChild ? mGeckoChild->APZCTM() : nullptr; } // This is a utility function used by NSView drag event methods // to send events. It contains all of the logic needed for Gecko // dragging to work. Returns the appropriate cocoa drag operation code. - (NSDragOperation)doDragAction:(EventMessage)aMessage sender:(id)aSender { NS_OBJC_BEGIN_TRY_ABORT_BLOCK_RETURN; if (!mGeckoChild) return NSDragOperationNone; MOZ_LOG(sCocoaLog, LogLevel::Info, ("ChildView doDragAction: entered\n")); if (!mDragService) { CallGetService(kDragServiceContractID, &mDragService); NS_ASSERTION(mDragService, "Couldn't get a drag service - big problem!"); if (!mDragService) return NSDragOperationNone; } if (aMessage == eDragEnter) { mDragService->StartDragSession(); } nsCOMPtr dragSession; mDragService->GetCurrentSession(getter_AddRefs(dragSession)); if (dragSession) { if (aMessage == eDragOver) { // fire the drag event at the source. Just ignore whether it was // cancelled or not as there isn't actually a means to stop the drag mDragService->FireDragEventAtSource(eDrag); dragSession->SetCanDrop(false); } else if (aMessage == eDrop) { // We make the assumption that the dragOver handlers have correctly set // the |canDrop| property of the Drag Session. bool canDrop = false; if (!NS_SUCCEEDED(dragSession->GetCanDrop(&canDrop)) || !canDrop) { [self doDragAction:eDragExit sender:aSender]; nsCOMPtr sourceNode; dragSession->GetSourceNode(getter_AddRefs(sourceNode)); if (!sourceNode) { mDragService->EndDragSession(false); } return NSDragOperationNone; } } unsigned int modifierFlags = nsCocoaUtils::GetCocoaEventModifierFlags([NSApp currentEvent]); uint32_t action = nsIDragService::DRAGDROP_ACTION_MOVE; // force copy = option, alias = cmd-option, default is move if (modifierFlags & NSAlternateKeyMask) { if (modifierFlags & NSCommandKeyMask) action = nsIDragService::DRAGDROP_ACTION_LINK; else action = nsIDragService::DRAGDROP_ACTION_COPY; } dragSession->SetDragAction(action); } // set up gecko event WidgetDragEvent geckoEvent(true, aMessage, mGeckoChild); nsCocoaUtils::InitInputEvent(geckoEvent, [NSApp currentEvent]); // Use our own coordinates in the gecko event. // Convert event from gecko global coords to gecko view coords. NSPoint draggingLoc = [aSender draggingLocation]; geckoEvent.refPoint = [self convertWindowCoordinates:draggingLoc]; nsAutoRetainCocoaObject kungFuDeathGrip(self); mGeckoChild->DispatchInputEvent(&geckoEvent); if (!mGeckoChild) return NSDragOperationNone; if (dragSession) { switch (aMessage) { case eDragEnter: case eDragOver: { uint32_t dragAction; dragSession->GetDragAction(&dragAction); // If TakeChildProcessDragAction returns something other than // DRAGDROP_ACTION_UNINITIALIZED, it means that the last event was sent // to the child process and this event is also being sent to the child // process. In this case, use the last event's action instead. nsDragService* dragService = static_cast(mDragService); int32_t childDragAction = dragService->TakeChildProcessDragAction(); if (childDragAction != nsIDragService::DRAGDROP_ACTION_UNINITIALIZED) { dragAction = childDragAction; } return [self dragOperationFromDragAction:dragAction]; } case eDragExit: case eDrop: { nsCOMPtr sourceNode; dragSession->GetSourceNode(getter_AddRefs(sourceNode)); if (!sourceNode) { // We're leaving a window while doing a drag that was // initiated in a different app. End the drag session, // since we're done with it for now (until the user // drags back into mozilla). mDragService->EndDragSession(false); } } default: break; } } return NSDragOperationGeneric; NS_OBJC_END_TRY_ABORT_BLOCK_RETURN(NSDragOperationNone); } - (NSDragOperation)draggingEntered:(id )sender { NS_OBJC_BEGIN_TRY_ABORT_BLOCK_RETURN; MOZ_LOG(sCocoaLog, LogLevel::Info, ("ChildView draggingEntered: entered\n")); // there should never be a globalDragPboard when "draggingEntered:" is // called, but just in case we'll take care of it here. [globalDragPboard release]; // Set the global drag pasteboard that will be used for this drag session. // This will be set back to nil when the drag session ends (mouse exits // the view or a drop happens within the view). // restore bug 966986 #if(0) globalDragPboard = [[sender draggingPasteboard] retain]; #else globalDragPboard = [[NSPasteboardWrapper alloc] initWithPasteboard:[sender draggingPasteboard]]; #endif return [self doDragAction:eDragEnter sender:sender]; NS_OBJC_END_TRY_ABORT_BLOCK_RETURN(NSDragOperationNone); } - (NSDragOperation)draggingUpdated:(id )sender { MOZ_LOG(sCocoaLog, LogLevel::Info, ("ChildView draggingUpdated: entered\n")); return [self doDragAction:eDragOver sender:sender]; } - (void)draggingExited:(id )sender { MOZ_LOG(sCocoaLog, LogLevel::Info, ("ChildView draggingExited: entered\n")); nsAutoRetainCocoaObject kungFuDeathGrip(self); [self doDragAction:eDragExit sender:sender]; NS_IF_RELEASE(mDragService); } - (BOOL)performDragOperation:(id )sender { nsAutoRetainCocoaObject kungFuDeathGrip(self); BOOL handled = [self doDragAction:eDrop sender:sender] != NSDragOperationNone; NS_IF_RELEASE(mDragService); return handled; } // NSDraggingSource - (void)draggedImage:(NSImage *)anImage movedTo:(NSPoint)aPoint { // Get the drag service if it isn't already cached. The drag service // isn't cached when dragging over a different application. nsCOMPtr dragService = mDragService; if (!dragService) { dragService = do_GetService(kDragServiceContractID); } if (dragService) { NSPoint pnt = [NSEvent mouseLocation]; FlipCocoaScreenCoordinate(pnt); LayoutDeviceIntPoint devPoint = mGeckoChild->CocoaPointsToDevPixels(pnt); dragService->DragMoved(devPoint.x, devPoint.y); } } // NSDraggingSource - (void)draggedImage:(NSImage *)anImage endedAt:(NSPoint)aPoint operation:(NSDragOperation)operation { NS_OBJC_BEGIN_TRY_ABORT_BLOCK; gDraggedTransferables = nullptr; NSEvent *currentEvent = [NSApp currentEvent]; gUserCancelledDrag = ([currentEvent type] == NSKeyDown && [currentEvent keyCode] == kEscapeKeyCode); // kVK_Escape); // we use the old key constants; see bug 764285 if (!mDragService) { CallGetService(kDragServiceContractID, &mDragService); NS_ASSERTION(mDragService, "Couldn't get a drag service - big problem!"); } if (mDragService) { // set the dragend point from the current mouse location nsDragService* dragService = static_cast(mDragService); NSPoint pnt = [NSEvent mouseLocation]; FlipCocoaScreenCoordinate(pnt); dragService->SetDragEndPoint(nsIntPoint(NSToIntRound(pnt.x), NSToIntRound(pnt.y))); // XXX: dropEffect should be updated per |operation|. // As things stand though, |operation| isn't well handled within "our" // events, that is, when the drop happens within the window: it is set // either to NSDragOperationGeneric or to NSDragOperationNone. // For that reason, it's not yet possible to override dropEffect per the // given OS value, and it's also unclear what's the correct dropEffect // value for NSDragOperationGeneric that is passed by other applications. // All that said, NSDragOperationNone is still reliable. if (operation == NSDragOperationNone) { nsCOMPtr dataTransfer; dragService->GetDataTransfer(getter_AddRefs(dataTransfer)); if (dataTransfer) dataTransfer->SetDropEffectInt(nsIDragService::DRAGDROP_ACTION_NONE); } mDragService->EndDragSession(true); NS_RELEASE(mDragService); } [globalDragPboard release]; globalDragPboard = nil; [gLastDragMouseDownEvent release]; gLastDragMouseDownEvent = nil; NS_OBJC_END_TRY_ABORT_BLOCK; } // NSDraggingSource // this is just implemented so we comply with the NSDraggingSource informal protocol - (NSDragOperation)draggingSourceOperationMaskForLocal:(BOOL)isLocal { return UINT_MAX; } // This method is a callback typically invoked in response to a drag ending on the desktop // or a Findow folder window; the argument passed is a path to the drop location, to be used // in constructing a complete pathname for the file(s) we want to create as a result of // the drag. - (NSArray *)namesOfPromisedFilesDroppedAtDestination:(NSURL*)dropDestination { NS_OBJC_BEGIN_TRY_ABORT_BLOCK_NIL; nsresult rv; MOZ_LOG(sCocoaLog, LogLevel::Info, ("ChildView namesOfPromisedFilesDroppedAtDestination: entering callback for promised files\n")); nsCOMPtr targFile; NS_NewLocalFile(EmptyString(), true, getter_AddRefs(targFile)); nsCOMPtr macLocalFile = do_QueryInterface(targFile); if (!macLocalFile) { NS_ERROR("No Mac local file"); return nil; } if (!NS_SUCCEEDED(macLocalFile->InitWithCFURL((CFURLRef)dropDestination))) { NS_ERROR("failed InitWithCFURL"); return nil; } if (!gDraggedTransferables) return nil; uint32_t transferableCount; rv = gDraggedTransferables->Count(&transferableCount); if (NS_FAILED(rv)) return nil; for (uint32_t i = 0; i < transferableCount; i++) { nsCOMPtr genericItem; gDraggedTransferables->GetElementAt(i, getter_AddRefs(genericItem)); nsCOMPtr item(do_QueryInterface(genericItem)); if (!item) { NS_ERROR("no transferable"); return nil; } item->SetTransferData(kFilePromiseDirectoryMime, macLocalFile, sizeof(nsIFile*)); // now request the kFilePromiseMime data, which will invoke the data provider // If successful, the returned data is a reference to the resulting file. nsCOMPtr fileDataPrimitive; uint32_t dataSize = 0; item->GetTransferData(kFilePromiseMime, getter_AddRefs(fileDataPrimitive), &dataSize); } NSPasteboard* generalPboard = [NSPasteboard pasteboardWithName:NSDragPboard]; NSData* data = [generalPboard dataForType:@"application/x-moz-file-promise-dest-filename"]; NSString* name = [[NSString alloc] initWithData:data encoding:NSUTF8StringEncoding]; NSArray* rslt = [NSArray arrayWithObject:name]; [name release]; return rslt; NS_OBJC_END_TRY_ABORT_BLOCK_NIL; } #pragma mark - // Support for the "Services" menu. We currently only support sending strings // and HTML to system services. - (id)validRequestorForSendType:(NSString *)sendType returnType:(NSString *)returnType { NS_OBJC_BEGIN_TRY_ABORT_BLOCK_NIL; // sendType contains the type of data that the service would like this // application to send to it. sendType is nil if the service is not // requesting any data. // // returnType contains the type of data the the service would like to // return to this application (e.g., to overwrite the selection). // returnType is nil if the service will not return any data. // // The following condition thus triggers when the service expects a string // or HTML from us or no data at all AND when the service will either not // send back any data to us or will send a string or HTML back to us. #define IsSupportedType(typeStr) ([typeStr isEqual:NSStringPboardType] || [typeStr isEqual:NSHTMLPboardType]) id result = nil; if ((!sendType || IsSupportedType(sendType)) && (!returnType || IsSupportedType(returnType))) { if (mGeckoChild) { // Assume that this object will be able to handle this request. result = self; // Keep the ChildView alive during this operation. nsAutoRetainCocoaObject kungFuDeathGrip(self); // Determine if there is a selection (if sending to the service). if (sendType) { WidgetQueryContentEvent event(true, eQueryContentState, mGeckoChild); // This might destroy our widget (and null out mGeckoChild). mGeckoChild->DispatchWindowEvent(event); if (!mGeckoChild || !event.mSucceeded || !event.mReply.mHasSelection) result = nil; } // Determine if we can paste (if receiving data from the service). if (mGeckoChild && returnType) { WidgetContentCommandEvent command(true, eContentCommandPasteTransferable, mGeckoChild, true); // This might possibly destroy our widget (and null out mGeckoChild). mGeckoChild->DispatchWindowEvent(command); if (!mGeckoChild || !command.mSucceeded || !command.mIsEnabled) result = nil; } } } #undef IsSupportedType // Give the superclass a chance if this object will not handle this request. if (!result) result = [super validRequestorForSendType:sendType returnType:returnType]; return result; NS_OBJC_END_TRY_ABORT_BLOCK_NIL; } - (BOOL)writeSelectionToPasteboard:(NSPasteboard *)pboard types:(NSArray *)types { NS_OBJC_BEGIN_TRY_ABORT_BLOCK_RETURN; nsAutoRetainCocoaObject kungFuDeathGrip(self); // Make sure that the service will accept strings or HTML. if ([types containsObject:NSStringPboardType] == NO && [types containsObject:NSHTMLPboardType] == NO) return NO; // Bail out if there is no Gecko object. if (!mGeckoChild) return NO; // Obtain the current selection. WidgetQueryContentEvent event(true, eQuerySelectionAsTransferable, mGeckoChild); mGeckoChild->DispatchWindowEvent(event); if (!event.mSucceeded || !event.mReply.mTransferable) return NO; // Transform the transferable to an NSDictionary. NSDictionary* pasteboardOutputDict = nsClipboard::PasteboardDictFromTransferable(event.mReply.mTransferable); if (!pasteboardOutputDict) return NO; // Declare the pasteboard types. unsigned int typeCount = [pasteboardOutputDict count]; NSMutableArray* declaredTypes = [NSMutableArray arrayWithCapacity:typeCount]; [declaredTypes addObjectsFromArray:[pasteboardOutputDict allKeys]]; [pboard declareTypes:declaredTypes owner:nil]; // Write the data to the pasteboard. for (unsigned int i = 0; i < typeCount; i++) { NSString* currentKey = [declaredTypes objectAtIndex:i]; id currentValue = [pasteboardOutputDict valueForKey:currentKey]; if (currentKey == NSStringPboardType || currentKey == kCorePboardType_url || currentKey == kCorePboardType_urld || currentKey == kCorePboardType_urln) { [pboard setString:currentValue forType:currentKey]; } else if (currentKey == NSHTMLPboardType) { [pboard setString:(nsClipboard::WrapHtmlForSystemPasteboard(currentValue)) forType:currentKey]; } else if (currentKey == NSTIFFPboardType) { [pboard setData:currentValue forType:currentKey]; } else if (currentKey == NSFilesPromisePboardType) { [pboard setPropertyList:currentValue forType:currentKey]; } } return YES; NS_OBJC_END_TRY_ABORT_BLOCK_RETURN(NO); } // Called if the service wants us to replace the current selection. - (BOOL)readSelectionFromPasteboard:(NSPasteboard *)pboard { nsresult rv; nsCOMPtr trans = do_CreateInstance("@mozilla.org/widget/transferable;1", &rv); if (NS_FAILED(rv)) return NO; trans->Init(nullptr); trans->AddDataFlavor(kUnicodeMime); trans->AddDataFlavor(kHTMLMime); rv = nsClipboard::TransferableFromPasteboard(trans, pboard); if (NS_FAILED(rv)) return NO; NS_ENSURE_TRUE(mGeckoChild, false); WidgetContentCommandEvent command(true, eContentCommandPasteTransferable, mGeckoChild); command.mTransferable = trans; mGeckoChild->DispatchWindowEvent(command); return command.mSucceeded && command.mIsEnabled; } #pragma mark - #ifdef ACCESSIBILITY /* Every ChildView has a corresponding mozDocAccessible object that is doing all the heavy lifting. The topmost ChildView corresponds to a mozRootAccessible object. All ChildView needs to do is to route all accessibility calls (from the NSAccessibility APIs) down to its object, pretending that they are the same. */ - (id)accessible { if (!mGeckoChild) return nil; id nativeAccessible = nil; nsAutoRetainCocoaObject kungFuDeathGrip(self); nsCOMPtr kungFuDeathGrip2(mGeckoChild); RefPtr accessible = mGeckoChild->GetDocumentAccessible(); if (!accessible) return nil; accessible->GetNativeInterface((void**)&nativeAccessible); #ifdef DEBUG_hakan NSAssert(![nativeAccessible isExpired], @"native acc is expired!!!"); #endif return nativeAccessible; } /* Implementation of formal mozAccessible formal protocol (enabling mozViews to talk to mozAccessible objects in the accessibility module). */ - (BOOL)hasRepresentedView { return YES; } - (id)representedView { return self; } - (BOOL)isRoot { return [[self accessible] isRoot]; } #ifdef DEBUG - (void)printHierarchy { [[self accessible] printHierarchy]; } #endif #pragma mark - // general - (BOOL)accessibilityIsIgnored { if (!mozilla::a11y::ShouldA11yBeEnabled()) return [super accessibilityIsIgnored]; return [[self accessible] accessibilityIsIgnored]; } - (id)accessibilityHitTest:(NSPoint)point { if (!mozilla::a11y::ShouldA11yBeEnabled()) return [super accessibilityHitTest:point]; return [[self accessible] accessibilityHitTest:point]; } - (id)accessibilityFocusedUIElement { if (!mozilla::a11y::ShouldA11yBeEnabled()) return [super accessibilityFocusedUIElement]; return [[self accessible] accessibilityFocusedUIElement]; } // actions - (NSArray*)accessibilityActionNames { if (!mozilla::a11y::ShouldA11yBeEnabled()) return [super accessibilityActionNames]; return [[self accessible] accessibilityActionNames]; } - (NSString*)accessibilityActionDescription:(NSString*)action { if (!mozilla::a11y::ShouldA11yBeEnabled()) return [super accessibilityActionDescription:action]; return [[self accessible] accessibilityActionDescription:action]; } - (void)accessibilityPerformAction:(NSString*)action { if (!mozilla::a11y::ShouldA11yBeEnabled()) return [super accessibilityPerformAction:action]; return [[self accessible] accessibilityPerformAction:action]; } // attributes - (NSArray*)accessibilityAttributeNames { if (!mozilla::a11y::ShouldA11yBeEnabled()) return [super accessibilityAttributeNames]; return [[self accessible] accessibilityAttributeNames]; } - (BOOL)accessibilityIsAttributeSettable:(NSString*)attribute { if (!mozilla::a11y::ShouldA11yBeEnabled()) return [super accessibilityIsAttributeSettable:attribute]; return [[self accessible] accessibilityIsAttributeSettable:attribute]; } - (id)accessibilityAttributeValue:(NSString*)attribute { NS_OBJC_BEGIN_TRY_ABORT_BLOCK_NIL; if (!mozilla::a11y::ShouldA11yBeEnabled()) return [super accessibilityAttributeValue:attribute]; id accessible = [self accessible]; // if we're the root (topmost) accessible, we need to return our native AXParent as we // traverse outside to the hierarchy of whoever embeds us. thus, fall back on NSView's // default implementation for this attribute. if ([attribute isEqualToString:NSAccessibilityParentAttribute] && [accessible isRoot]) { id parentAccessible = [super accessibilityAttributeValue:attribute]; return parentAccessible; } return [accessible accessibilityAttributeValue:attribute]; NS_OBJC_END_TRY_ABORT_BLOCK_NIL; } #endif /* ACCESSIBILITY */ @end #ifndef NS_LEOPARD_AND_LATER #pragma mark - void nsTSMManager::OnDestroyView(NSView* aDestroyingView) { if (aDestroyingView != sComposingView) return; if (IsComposing()) { CancelIME(); // XXX Might CancelIME() fail because sComposingView is being destroyed? EndComposing(); } } bool nsTSMManager::GetIMEOpenState() { return GetScriptManagerVariable(smKeyScript) != smRoman ? true : false; } static const NSString* GetCurrentIMELanguage() { if (!nsCocoaFeatures::OnLeopardOrLater()) { // XXX [[NSInputManager currentInputManager] language] doesn't work fine. switch (::GetScriptManagerVariable(smKeyScript)) { case smJapanese: return @"ja"; default: return nil; } } NS_PRECONDITION(Leopard_TISCopyCurrentKeyboardInputSource, "Leopard_TISCopyCurrentKeyboardInputSource is not initialized"); TISInputSourceRef inputSource = Leopard_TISCopyCurrentKeyboardInputSource(); if (!inputSource) { NS_ERROR("Leopard_TISCopyCurrentKeyboardInputSource failed"); return nil; } NS_PRECONDITION(Leopard_TISGetInputSourceProperty, "Leopard_TISGetInputSourceProperty is not initialized"); CFArrayRef langs = static_cast( Leopard_TISGetInputSourceProperty(inputSource, kOurTISPropertyInputSourceLanguages)); return static_cast(CFArrayGetValueAtIndex(langs, 0)); } void nsTSMManager::InitTSMDocument(NSView* aViewForCaret) { NS_OBJC_BEGIN_TRY_ABORT_BLOCK; sDocumentID = ::TSMGetActiveDocument(); if (!sDocumentID) return; // We need to set the focused window level to TSMDocument. Then, the popup // windows of IME (E.g., a candidate list window) will be over the focused // view. See http://developer.apple.com/technotes/tn2005/tn2128.html#TNTAG1 NSInteger TSMLevel, windowLevel; UInt32 size = sizeof(TSMLevel); OSStatus err = ::TSMGetDocumentProperty(sDocumentID, kTSMDocumentWindowLevelPropertyTag, size, &size, &TSMLevel); windowLevel = [[aViewForCaret window] level]; // Chinese IMEs on 10.5 don't work fine if the level is NSNormalWindowLevel, // then, we need to increment the value. if (windowLevel == NSNormalWindowLevel) windowLevel++; if (err == noErr && TSMLevel >= windowLevel) return; ::TSMSetDocumentProperty(sDocumentID, kTSMDocumentWindowLevelPropertyTag, sizeof(windowLevel), &windowLevel); // ATOK (Japanese IME) updates the window level at activating, // we need to notify the change with this hack. const NSString* lang = ::GetCurrentIMELanguage(); if (lang && [lang isEqualToString:@"ja"]) { ::DeactivateTSMDocument(sDocumentID); ::ActivateTSMDocument(sDocumentID); } NS_OBJC_END_TRY_ABORT_BLOCK; } void nsTSMManager::StartComposing(NSView* aComposingView) { if (sComposingView && sComposingView != sComposingView) CommitIME(); sComposingView = aComposingView; NS_ASSERTION(::TSMGetActiveDocument() == sDocumentID, "We didn't initialize the TSMDocument"); } void nsTSMManager::UpdateComposing(NSString* aComposingString) { NS_OBJC_BEGIN_TRY_ABORT_BLOCK; if (sComposingString) [sComposingString release]; sComposingString = [aComposingString retain]; NS_OBJC_END_TRY_ABORT_BLOCK; } void nsTSMManager::EndComposing() { NS_OBJC_BEGIN_TRY_ABORT_BLOCK; sComposingView = nullptr; if (sComposingString) { [sComposingString release]; sComposingString = nullptr; } NS_OBJC_END_TRY_ABORT_BLOCK; } void nsTSMManager::EnableIME(bool aEnable) { if (aEnable == sIsIMEEnabled) return; CommitIME(); sIsIMEEnabled = aEnable; } void nsTSMManager::SetIMEOpenState(bool aOpen) { if (aOpen == GetIMEOpenState()) return; CommitIME(); KeyScript(aOpen ? smKeySwapScript : smKeyRoman); } nsresult nsTSMManager::SetIMEEnabled(uint32_t aEnabled) { switch (aEnabled) { case IMEState::ENABLED: case IMEState::PLUGIN: SetRomanKeyboardsOnly(false); EnableIME(true); break; case IMEState::DISABLED: SetRomanKeyboardsOnly(false); EnableIME(false); break; case IMEState::PASSWORD: SetRomanKeyboardsOnly(true); EnableIME(false); break; default: NS_ERROR("not implemented!"); return NS_ERROR_UNEXPECTED; } sIMEEnabledStatus = aEnabled; return NS_OK; } #define ENABLE_ROMAN_KYBDS_ONLY -23 void nsTSMManager::SetRomanKeyboardsOnly(bool aRomanOnly) { CommitIME(); if (sIMEEnabledStatus != IMEState::PLUGIN && sIsRomanKeyboardsOnly == aRomanOnly) { return; } sIsRomanKeyboardsOnly = aRomanOnly; CallKeyScriptAPI(); } void nsTSMManager::CallKeyScriptAPI() { // If timer has been alreay enabled, we don't need to recreate it. if (sSyncKeyScriptTimer) { return; } nsCOMPtr timer = do_CreateInstance(NS_TIMER_CONTRACTID); NS_ENSURE_TRUE(timer, ); NS_ADDREF(sSyncKeyScriptTimer = timer); sSyncKeyScriptTimer->InitWithFuncCallback(SyncKeyScript, nullptr, 0, nsITimer::TYPE_ONE_SHOT); } void nsTSMManager::SyncKeyScript(nsITimer* aTimer, void* aClosure) { // This is a workaround of Bug 548480 for Snow Leopard. // // KeyScript may cause the crash in CFHash. We need call // [NSInputManager currentInputManager] before it. [NSInputManager currentInputManager]; KeyScript(sIsRomanKeyboardsOnly ? ENABLE_ROMAN_KYBDS_ONLY : smKeyEnableKybds); NS_RELEASE(sSyncKeyScriptTimer); } void nsTSMManager::Shutdown() { if (!sSyncKeyScriptTimer) { return; } sSyncKeyScriptTimer->Cancel(); NS_RELEASE(sSyncKeyScriptTimer); } void nsTSMManager::KillComposing() { NS_OBJC_BEGIN_TRY_ABORT_BLOCK; // Force commit the current composition // XXX Don't use NSInputManager. Because it cannot control the non-forcused // input manager, therefore, on deactivating a window, it does not work fine. NS_ASSERTION(sDocumentID, "The TSMDocumentID is null"); ::FixTSMDocument(sDocumentID); NS_OBJC_END_TRY_ABORT_BLOCK; } void nsTSMManager::CommitIME() { NS_OBJC_BEGIN_TRY_ABORT_BLOCK; if (!IsComposing()) return; KillComposing(); if (!IsComposing()) return; // If the composing transaction is still there, KillComposing only kills the // composing in TSM. We also need to kill the our composing transaction too. NSAttributedString* str = [[NSAttributedString alloc] initWithString:sComposingString]; [sComposingView insertText:str]; [str release]; NS_OBJC_END_TRY_ABORT_BLOCK; } void nsTSMManager::CancelIME() { NS_OBJC_BEGIN_TRY_ABORT_BLOCK; if (!IsComposing()) return; // For canceling the current composing, we need to ignore the param of // insertText. But this code is ugly... sIgnoreCommit = true; KillComposing(); sIgnoreCommit = false; if (!IsComposing()) return; // If the composing transaction is still there, KillComposing only kills the // composing in TSM. We also need to kill the our composing transaction too. NSAttributedString* str = [[NSAttributedString alloc] initWithString:@""]; [sComposingView insertText:str]; [str release]; NS_OBJC_END_TRY_ABORT_BLOCK; } #endif // NS_LEOPARD_AND_LATER #pragma mark - void ChildViewMouseTracker::OnDestroyView(ChildView* aView) { if (sLastMouseEventView == aView) { sLastMouseEventView = nil; [sLastMouseMoveEvent release]; sLastMouseMoveEvent = nil; } } void ChildViewMouseTracker::OnDestroyWindow(NSWindow* aWindow) { if (sWindowUnderMouse == aWindow) { sWindowUnderMouse = nil; } } void ChildViewMouseTracker::MouseEnteredWindow(NSEvent* aEvent) { sWindowUnderMouse = [aEvent window]; ReEvaluateMouseEnterState(aEvent); } void ChildViewMouseTracker::MouseExitedWindow(NSEvent* aEvent) { if (sWindowUnderMouse == [aEvent window]) { sWindowUnderMouse = nil; ReEvaluateMouseEnterState(aEvent); } } void ChildViewMouseTracker::ReEvaluateMouseEnterState(NSEvent* aEvent, ChildView* aOldView) { ChildView* oldView = aOldView ? aOldView : sLastMouseEventView; sLastMouseEventView = ViewForEvent(aEvent); if (sLastMouseEventView != oldView) { // Send enter and / or exit events. WidgetMouseEvent::exitType type = [sLastMouseEventView window] == [oldView window] ? WidgetMouseEvent::eChild : WidgetMouseEvent::eTopLevel; [oldView sendMouseEnterOrExitEvent:aEvent enter:NO type:type]; // After the cursor exits the window set it to a visible regular arrow cursor. if (type == WidgetMouseEvent::eTopLevel) { [[nsCursorManager sharedInstance] setCursor:eCursor_standard]; } [sLastMouseEventView sendMouseEnterOrExitEvent:aEvent enter:YES type:type]; } } void ChildViewMouseTracker::ResendLastMouseMoveEvent() { if (sLastMouseMoveEvent) { MouseMoved(sLastMouseMoveEvent); } } void ChildViewMouseTracker::MouseMoved(NSEvent* aEvent) { ReEvaluateMouseEnterState(aEvent); // undoing bug 675208 //MouseEnteredWindow(aEvent); [sLastMouseEventView handleMouseMoved:aEvent]; if (sLastMouseMoveEvent != aEvent) { [sLastMouseMoveEvent release]; sLastMouseMoveEvent = [aEvent retain]; } } void ChildViewMouseTracker::MouseScrolled(NSEvent* aEvent) { if (!nsCocoaUtils::IsMomentumScrollEvent(aEvent)) { // Store the position so we can pin future momentum scroll events. sLastScrollEventScreenLocation = nsCocoaUtils::ScreenLocationForEvent(aEvent); } } ChildView* ChildViewMouseTracker::ViewForEvent(NSEvent* aEvent) { //NSWindow* window = sWindowUnderMouse; NSWindow* window = WindowForEvent(aEvent); // undoing bug 675208 if (!window) return nil; NSPoint windowEventLocation = nsCocoaUtils::EventLocationForWindow(aEvent, window); NSView* view = [[[window contentView] superview] hitTest:windowEventLocation]; if (![view isKindOfClass:[ChildView class]]) return nil; ChildView* childView = (ChildView*)view; // If childView is being destroyed return nil. if (![childView widget]) return nil; return WindowAcceptsEvent(window, aEvent, childView) ? childView : nil; } // added back from bug 675208 static CGWindowLevel kDockWindowLevel = 0; static CGWindowLevel kPopupWindowLevel = 0; static BOOL WindowNumberIsUnderPoint(NSInteger aWindowNumber, NSPoint aPoint) { NSWindow* window = [NSApp windowWithWindowNumber:aWindowNumber]; if (window) { // This is one of our own windows. return NSMouseInRect(aPoint, [window frame], NO); } CGSConnection cid = _CGSDefaultConnection(); if (!kDockWindowLevel) { // These constants are in fact function calls, so cache them. kDockWindowLevel = kCGDockWindowLevel; kPopupWindowLevel = kCGPopUpMenuWindowLevel; } // Some things put transparent windows on top of everything. Ignore them. CGWindowLevel level; if ((kCGErrorSuccess == CGSGetWindowLevel(cid, aWindowNumber, &level)) && (level == kDockWindowLevel || // Transparent layer, spanning the whole screen level > kPopupWindowLevel)) // Snapz Pro X while recording a screencast return false; // Ignore transparent windows. float alpha; if ((kCGErrorSuccess == CGSGetWindowAlpha(cid, aWindowNumber, &alpha)) && alpha < 0.1f) return false; CGRect rect; if (kCGErrorSuccess != CGSGetScreenRectForWindow(cid, aWindowNumber, &rect)) return false; CGPoint point = { aPoint.x, nsCocoaUtils::FlippedScreenY(aPoint.y) }; return CGRectContainsPoint(rect, point); } // Find the window number of the window under the given point, regardless of // which app the window belongs to. Returns 0 if no window was found. static NSInteger WindowNumberAtPoint(NSPoint aPoint) { // We'd like to use the new windowNumberAtPoint API on 10.6 but we can't rely // on it being up-to-date. For example, if we've just opened a window, // windowNumberAtPoint might not know about it yet, so we'd send events to the // wrong window. See bug 557986. // So we'll have to find the right window manually by iterating over all // windows on the screen and testing whether the mouse is inside the window's // rect. We do this using private CGS functions. // Another way of doing it would be to use tracking rects, but those are // view-controlled, so they need to be reset whenever an NSView changes its // size or position, which is expensive. See bug 300904 comment 20. // A problem with using the CGS functions is that we only look at the windows' // rects, not at the transparency of the actual pixel the mouse is over. This // means that we won't treat transparent pixels as transparent to mouse // events, which is a disadvantage over using tracking rects and leads to the // crummy window level workarounds in WindowNumberIsUnderPoint. // But speed is more important. // Get the window list. NSInteger windowCount; NSCountWindows(&windowCount); NSInteger* windowList = (NSInteger*)malloc(sizeof(NSInteger) * windowCount); if (!windowList) return nil; // The list we get back here is in order from front to back. NSWindowList(windowCount, windowList); for (NSInteger i = 0; i < windowCount; i++) { NSInteger windowNumber = windowList[i]; if (WindowNumberIsUnderPoint(windowNumber, aPoint)) { free(windowList); return windowNumber; } } free(windowList); return 0; } // Find Gecko window under the mouse. Returns nil if the mouse isn't over // any of our windows. NSWindow* ChildViewMouseTracker::WindowForEvent(NSEvent* anEvent) { NS_OBJC_BEGIN_TRY_ABORT_BLOCK_NIL; NSPoint screenPoint = nsCocoaUtils::ScreenLocationForEvent(anEvent); NSInteger windowNumber = WindowNumberAtPoint(screenPoint); // This will return nil if windowNumber belongs to a window that we don't own. return [NSApp windowWithWindowNumber:windowNumber]; NS_OBJC_END_TRY_ABORT_BLOCK_NIL; } BOOL ChildViewMouseTracker::WindowAcceptsEvent(NSWindow* aWindow, NSEvent* aEvent, ChildView* aView, BOOL aIsClickThrough) { // Force us forward if we were not. 10.4Fx issue 19. if ([aEvent type] == NSLeftMouseDown || [aEvent type] == NSRightMouseDown) { ProcessSerialNumber psn = { 0, kCurrentProcess }; OSStatus err = SetFrontProcessWithOptions(&psn, kSetFrontProcessFrontWindowOnly); } // Right mouse down events may get through to all windows, even to a top level // window with an open sheet. if (!aWindow) // || [aEvent type] == NSRightMouseDown) return YES; id delegate = [aWindow delegate]; if (!delegate || ![delegate isKindOfClass:[WindowDelegate class]]) return YES; nsIWidget *windowWidget = [(WindowDelegate *)delegate geckoWidget]; if (!windowWidget) return YES; NSWindow* topLevelWindow = nil; nsWindowType windowType = windowWidget->WindowType(); // Make us the main window as long as we are not a popup, dialogue or sheet // if we click on it. if (windowType != eWindowType_popup && windowType != eWindowType_dialog && windowType != eWindowType_sheet && ![aWindow attachedSheet] && ([aEvent type] == NSLeftMouseDown || [aEvent type] == NSRightMouseDown)) { [aWindow makeMainWindow]; [aWindow makeKeyWindow]; [aWindow orderFrontRegardless]; // safe, because we are the // front app, the main window *and* the key window. // 10.4Fx issue 19 etc. } switch (windowWidget->WindowType()) { case eWindowType_popup: // If this is a context menu, it won't have a parent. So we'll always // accept mouse move events on context menus even when none of our windows // is active, which is the right thing to do. // For panels, the parent window is the XUL window that owns the panel. return WindowAcceptsEvent([aWindow parentWindow], aEvent, aView, aIsClickThrough); case eWindowType_toplevel: case eWindowType_dialog: if ([aWindow attachedSheet]) return NO; topLevelWindow = aWindow; break; case eWindowType_sheet: { if ([aEvent type] == NSRightMouseDown) return YES; nsIWidget* parentWidget = windowWidget->GetSheetWindowParent(); if (!parentWidget) return YES; topLevelWindow = (NSWindow*)parentWidget->GetNativeData(NS_NATIVE_WINDOW); break; } default: return YES; } if (!topLevelWindow || ([topLevelWindow isMainWindow] && !aIsClickThrough) || [aEvent type] == NSOtherMouseDown || (([aEvent modifierFlags] & NSCommandKeyMask) != 0 && [aEvent type] != NSMouseMoved)) return YES; // If we're here then we're dealing with a left click or mouse move on an // inactive window or something similar. Ask Gecko what to do. return [aView inactiveWindowAcceptsMouseEvent:aEvent]; } #pragma mark - @interface EventThreadRunner(Private) - (void)runEventThread; - (void)shutdownAndReleaseCalledOnEventThread; - (void)shutdownAndReleaseCalledOnAnyThread; - (void)handleEvent:(CGEventRef)cgEvent type:(CGEventType)type; @end static EventThreadRunner* sEventThreadRunner = nil; @implementation EventThreadRunner + (void)start { sEventThreadRunner = [[EventThreadRunner alloc] init]; } + (void)stop { if (sEventThreadRunner) { [sEventThreadRunner shutdownAndReleaseCalledOnAnyThread]; sEventThreadRunner = nil; } } - (id)init { if ((self = [super init])) { mThread = nil; [NSThread detachNewThreadSelector:@selector(runEventThread) toTarget:self withObject:nil]; } return self; } static CGEventRef HandleEvent(CGEventTapProxy aProxy, CGEventType aType, CGEventRef aEvent, void* aClosure) { [(EventThreadRunner*)aClosure handleEvent:aEvent type:aType]; return aEvent; } - (void)runEventThread { char aLocal; profiler_register_thread("APZC Event Thread", &aLocal); PR_SetCurrentThreadName("APZC Event Thread"); mThread = [NSThread currentThread]; ProcessSerialNumber currentProcess; GetCurrentProcess(¤tProcess); CFMachPortRef eventPort = CGEventTapCreateForPSN(¤tProcess, kCGHeadInsertEventTap, kCGEventTapOptionListenOnly, CGEventMaskBit(kCGEventScrollWheel), HandleEvent, self); CFRunLoopSourceRef eventPortSource = CFMachPortCreateRunLoopSource(kCFAllocatorSystemDefault, eventPort, 0); CFRunLoopAddSource(CFRunLoopGetCurrent(), eventPortSource, kCFRunLoopCommonModes); CFRunLoopRun(); CFRunLoopRemoveSource(CFRunLoopGetCurrent(), eventPortSource, kCFRunLoopCommonModes); CFRelease(eventPortSource); CFRelease(eventPort); [self release]; } - (void)shutdownAndReleaseCalledOnEventThread { CFRunLoopStop(CFRunLoopGetCurrent()); } - (void)shutdownAndReleaseCalledOnAnyThread { [self performSelector:@selector(shutdownAndReleaseCalledOnEventThread) onThread:mThread withObject:nil waitUntilDone:NO]; } static const CGEventField kCGWindowNumberField = (const CGEventField) 51; // Called on scroll thread - (void)handleEvent:(CGEventRef)cgEvent type:(CGEventType)type { if (type != kCGEventScrollWheel) { return; } int windowNumber = CGEventGetIntegerValueField(cgEvent, kCGWindowNumberField); NSWindow* window = [NSApp windowWithWindowNumber:windowNumber]; if (!window || ![window isKindOfClass:[BaseWindow class]]) { return; } ChildView* childView = [(BaseWindow*)window mainChildView]; [childView handleAsyncScrollEvent:cgEvent ofType:type]; } @end @interface NSView (MethodSwizzling) - (BOOL)nsChildView_NSView_mouseDownCanMoveWindow; @end @implementation NSView (MethodSwizzling) // All top-level browser windows belong to the ToolbarWindow class and have // NSTexturedBackgroundWindowMask turned on in their "style" (see particularly // [ToolbarWindow initWithContentRect:...] in nsCocoaWindow.mm). This style // normally means the window "may be moved by clicking and dragging anywhere // in the window background", but we've suppressed this by giving the // ChildView class a mouseDownCanMoveWindow method that always returns NO. // Normally a ToolbarWindow's contentView (not a ChildView) returns YES when // NSTexturedBackgroundWindowMask is turned on. But normally this makes no // difference. However, under some (probably very unusual) circumstances // (and only on Leopard) it *does* make a difference -- for example it // triggers bmo bugs 431902 and 476393. So here we make sure that a // ToolbarWindow's contentView always returns NO from the // mouseDownCanMoveWindow method. - (BOOL)nsChildView_NSView_mouseDownCanMoveWindow { NSWindow *ourWindow = [self window]; NSView *contentView = [ourWindow contentView]; if ([ourWindow isKindOfClass:[ToolbarWindow class]] && (self == contentView)) return [ourWindow isMovableByWindowBackground]; return [self nsChildView_NSView_mouseDownCanMoveWindow]; } @end #ifdef __LP64__ // When using blocks, at least on OS X 10.7, the OS sometimes calls // +[NSEvent removeMonitor:] more than once on a single event monitor, which // causes crashes. See bug 678607. We hook these methods to work around // the problem. @interface NSEvent (MethodSwizzling) + (id)nsChildView_NSEvent_addLocalMonitorForEventsMatchingMask:(unsigned long long)mask handler:(id)block; + (void)nsChildView_NSEvent_removeMonitor:(id)eventMonitor; @end // This is a local copy of the AppKit frameworks sEventObservers hashtable. // It only stores "local monitors". We use it to ensure that +[NSEvent // removeMonitor:] is never called more than once on the same local monitor. static NSHashTable *sLocalEventObservers = nil; @implementation NSEvent (MethodSwizzling) + (id)nsChildView_NSEvent_addLocalMonitorForEventsMatchingMask:(unsigned long long)mask handler:(id)block { if (!sLocalEventObservers) { sLocalEventObservers = [[NSHashTable hashTableWithOptions: NSHashTableStrongMemory | NSHashTableObjectPointerPersonality] retain]; } id retval = [self nsChildView_NSEvent_addLocalMonitorForEventsMatchingMask:mask handler:block]; if (sLocalEventObservers && retval && ![sLocalEventObservers containsObject:retval]) { [sLocalEventObservers addObject:retval]; } return retval; } + (void)nsChildView_NSEvent_removeMonitor:(id)eventMonitor { if (sLocalEventObservers && [eventMonitor isKindOfClass: ::NSClassFromString(@"_NSLocalEventObserver")]) { if (![sLocalEventObservers containsObject:eventMonitor]) { return; } [sLocalEventObservers removeObject:eventMonitor]; } [self nsChildView_NSEvent_removeMonitor:eventMonitor]; } @end #endif // #ifdef __LP64__