mirror of
https://github.com/cappuccino/cappuccino.git
synced 2026-08-25 13:07:02 +00:00
531 lines
19 KiB
Plaintext
531 lines
19 KiB
Plaintext
/*
|
|
* CPPlatformPasteboard.j
|
|
* AppKit
|
|
*
|
|
* Created by Alexander Ljungberg.
|
|
* Copyright 2013, SlevenBits Ltd.
|
|
*
|
|
* This library is free software; you can redistribute it and/or
|
|
* modify it under the terms of the GNU Lesser General Public
|
|
* License as published by the Free Software Foundation; either
|
|
* version 2.1 of the License, or (at your option) any later version.
|
|
*
|
|
* This library is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
|
* Lesser General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU Lesser General Public
|
|
* License along with this library; if not, write to the Free Software
|
|
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
|
|
*/
|
|
|
|
@import <Foundation/CPObject.j>
|
|
@import <Foundation/CPRunLoop.j>
|
|
|
|
@import "CPCompatibility.j"
|
|
@import "CPEvent.j"
|
|
@import "CPPasteboard.j"
|
|
@import "CPPlatform.j"
|
|
@import "CPPlatformWindow+DOMKeys.j"
|
|
|
|
@global CPApp
|
|
@global CPPlatformWindow
|
|
|
|
// From CPPlatformWindow+DOM.j
|
|
@global _CPDOMEventStop
|
|
|
|
#if PLATFORM(DOM)
|
|
|
|
#define SUPPRESS_CAPPUCCINO_CUT_FOR_EVENT(anEvent) anEvent._suppressCappuccinoCut = YES
|
|
#define SUPPRESS_CAPPUCCINO_PASTE_FOR_EVENT(anEvent) anEvent._suppressCappuccinoPaste = YES
|
|
|
|
var hasEditableTarget = function(aDOMEvent)
|
|
{
|
|
var target = aDOMEvent.target || aDOMEvent.srcElement;
|
|
|
|
if (!target)
|
|
return NO;
|
|
|
|
if (target.contentEditable == "true")
|
|
return YES;
|
|
|
|
var nodeName = target.nodeName.toUpperCase();
|
|
|
|
return nodeName === "INPUT" || nodeName == "TEXTAREA";
|
|
}
|
|
|
|
/*
|
|
* This class encapsulates copy and paste related functionality for the
|
|
* DOM environment. While originally all of this code was apread out in a
|
|
* dozen places in CPPlatformWindow+DOM.j, this class serves to collect
|
|
* and isolate that code for easier testing and maintenance.
|
|
*/
|
|
@implementation CPPlatformPasteboard : CPObject
|
|
{
|
|
DOMWindow _DOMWindow;
|
|
|
|
DOMElement _DOMPasteboardElement;
|
|
|
|
BOOL supportsNativeCopyAndPaste;
|
|
BOOL hasBugWhichPreventsNonEditablePaste;
|
|
BOOL hasBugWhichPreventsNonEditablePasteRedirect;
|
|
|
|
BOOL currentEventIsNativePasteEvent;
|
|
BOOL currentEventIsNativeCopyOrCutEvent;
|
|
BOOL currentEventShouldBeSuppressed;
|
|
BOOL currentEventShouldDefinitelyBubble;
|
|
BOOL currentEventShouldDefinitelyNotBubble;
|
|
|
|
BOOL _ignoreNativeCopyOrCutEvent;
|
|
BOOL _ignoreNativePastePreparation;
|
|
}
|
|
|
|
- (id)init
|
|
{
|
|
if (self = [super init])
|
|
{
|
|
supportsNativeCopyAndPaste = CPFeatureIsCompatible(CPJavaScriptClipboardEventsFeature);
|
|
hasBugWhichPreventsNonEditablePaste = CPPlatformHasBug(CPJavaScriptPasteRequiresEditableTarget);
|
|
hasBugWhichPreventsNonEditablePasteRedirect = CPPlatformHasBug(CPJavaScriptPasteCantRefocus);
|
|
}
|
|
|
|
return self;
|
|
}
|
|
|
|
- (void)setDOMWindow:(DOMWindow)aDOMWindow
|
|
{
|
|
if (_DOMWindow === aDOMWindow)
|
|
return;
|
|
|
|
if (_DOMWindow)
|
|
[self destroyDOMElements];
|
|
|
|
_DOMWindow = aDOMWindow;
|
|
|
|
if (_DOMWindow)
|
|
[self createDOMElements];
|
|
}
|
|
|
|
- (void)createDOMElements
|
|
{
|
|
var theDocument = _DOMWindow.document,
|
|
_DOMBodyElement = theDocument.getElementById("cappuccino-body") || theDocument.body;
|
|
|
|
// Create Native Pasteboard handler.
|
|
_DOMPasteboardElement = theDocument.createElement("textarea");
|
|
|
|
_DOMPasteboardElement.style.position = "absolute";
|
|
_DOMPasteboardElement.style.top = "-10000px";
|
|
_DOMPasteboardElement.style.zIndex = "999";
|
|
_DOMPasteboardElement.className = "cpdontremove";
|
|
|
|
_DOMBodyElement.appendChild(_DOMPasteboardElement);
|
|
|
|
_DOMPasteboardElement.blur();
|
|
|
|
var copyEventCallback = function (anEvent) { return [self beforeCopyEvent:anEvent]; },
|
|
nativeBeforeClipboardEventCallback = function (anEvent) { return [self nativeBeforeClipboardEvent:anEvent]; },
|
|
nativeCopyOrCutEventCallback = function (anEvent) { return [self nativeCopyOrCutEvent:anEvent]; },
|
|
pasteEventCallback = function (anEvent) { return [self beforePasteEvent:anEvent]; },
|
|
nativePasteEventCallback = function (anEvent) { return [self nativePasteEvent:anEvent]; };
|
|
|
|
if (theDocument.addEventListener)
|
|
{
|
|
if (supportsNativeCopyAndPaste)
|
|
{
|
|
_DOMWindow.addEventListener("beforecopy", nativeBeforeClipboardEventCallback, NO);
|
|
_DOMWindow.addEventListener("beforecut", nativeBeforeClipboardEventCallback, NO);
|
|
_DOMWindow.addEventListener("beforepaste", nativeBeforeClipboardEventCallback, NO);
|
|
_DOMWindow.addEventListener("copy", nativeCopyOrCutEventCallback, NO);
|
|
_DOMWindow.addEventListener("cut", nativeCopyOrCutEventCallback, NO);
|
|
_DOMWindow.addEventListener("paste", nativePasteEventCallback, NO);
|
|
}
|
|
else
|
|
{
|
|
theDocument.addEventListener("beforepaste", pasteEventCallback, NO);
|
|
theDocument.addEventListener("beforecopy", copyEventCallback, NO);
|
|
theDocument.addEventListener("beforecut", copyEventCallback, NO);
|
|
}
|
|
|
|
_DOMWindow.addEventListener("unload", function()
|
|
{
|
|
if (supportsNativeCopyAndPaste)
|
|
{
|
|
_DOMWindow.removeEventListener("beforecopy", nativeBeforeClipboardEventCallback, NO);
|
|
_DOMWindow.removeEventListener("beforecut", nativeBeforeClipboardEventCallback, NO);
|
|
_DOMWindow.removeEventListener("beforepaste", nativeBeforeClipboardEventCallback, NO);
|
|
_DOMWindow.removeEventListener("copy", nativeCopyOrCutEventCallback, NO);
|
|
_DOMWindow.removeEventListener("cut", nativeCopyOrCutEventCallback, NO);
|
|
_DOMWindow.removeEventListener("paste", nativePasteEventCallback, NO);
|
|
}
|
|
else
|
|
{
|
|
theDocument.removeEventListener("beforepaste", pasteEventCallback, NO);
|
|
theDocument.removeEventListener("beforecopy", copyEventCallback, NO);
|
|
theDocument.removeEventListener("beforecut", copyEventCallback, NO);
|
|
}
|
|
}, NO);
|
|
}
|
|
else
|
|
{
|
|
// TODO If we wanted IE 8 and lower copy and paste it'd go here.
|
|
}
|
|
}
|
|
|
|
- (void)destroyDOMElements
|
|
{
|
|
var theDocument = _DOMWindow.document,
|
|
_DOMBodyElement = theDocument.getElementById("cappuccino-body") || theDocument.body;
|
|
|
|
_DOMBodyElement.removeChild(_DOMPasteboardElement);
|
|
_DOMPasteboardElement = nil;
|
|
}
|
|
|
|
- (void)windowMaySendKeyEvent:(CPEvent)anEvent
|
|
{
|
|
// Reset our opinions.
|
|
currentEventIsNativePasteEvent = NO;
|
|
currentEventIsNativeCopyOrCutEvent = NO;
|
|
currentEventShouldBeSuppressed = NO;
|
|
currentEventShouldDefinitelyNotBubble = NO;
|
|
currentEventShouldDefinitelyBubble = NO;
|
|
|
|
if (!anEvent)
|
|
return;
|
|
|
|
if ([anEvent type] !== CPKeyDown)
|
|
{
|
|
// Reset these flags on key up.
|
|
_ignoreNativePastePreparation = NO;
|
|
_ignoreNativeCopyOrCutEvent = NO;
|
|
return;
|
|
}
|
|
|
|
var modifierFlags = [anEvent modifierFlags];
|
|
|
|
if (!(modifierFlags & (CPControlKeyMask | CPCommandKeyMask)))
|
|
return;
|
|
|
|
var aDOMEvent = anEvent._DOMEvent,
|
|
characters = [anEvent characters],
|
|
mayRequireDOMPasteboardElement = [self _mayRequireDOMPasteboardElementHack:aDOMEvent flags:modifierFlags];
|
|
|
|
if (characters === "v" && mayRequireDOMPasteboardElement)
|
|
{
|
|
if (supportsNativeCopyAndPaste && hasBugWhichPreventsNonEditablePaste && hasBugWhichPreventsNonEditablePasteRedirect && !hasEditableTarget(aDOMEvent))
|
|
{
|
|
// You can't paste from the system clipboard into a non-editable area in Safari, neither using native
|
|
// copy and paste nor our _DOMPasteboardElement hack. We will paste from the Cappuccino pasteboard only
|
|
// and allow Safari to "beep" to indicate something went wrong.
|
|
|
|
// The key down will not result in a paste event being sent by Safari, so it's not a paste event.
|
|
currentEventIsNativePasteEvent = NO;
|
|
// Yes to get the beep.
|
|
currentEventShouldDefinitelyBubble = YES;
|
|
}
|
|
else if (!(supportsNativeCopyAndPaste || hasBugWhichPreventsNonEditablePaste) && !_ignoreNativePastePreparation)
|
|
{
|
|
// We don't support native copy and paste so we must focus the _DOMPasteboardElement to receive the
|
|
// paste content. This needs to be done at keyDown time (or in the case of modern Safari, before the keyDown,
|
|
// which unfortunately isn't possible. See above.)
|
|
_DOMPasteboardElement.focus();
|
|
_DOMPasteboardElement.select();
|
|
_DOMPasteboardElement.value = "";
|
|
_DOMWindow.setNativeTimeout(function () { [self _checkDOMPasteboardElement]; }, 0);
|
|
|
|
currentEventIsNativePasteEvent = YES;
|
|
}
|
|
else if (supportsNativeCopyAndPaste)
|
|
currentEventIsNativePasteEvent = YES;
|
|
|
|
if (currentEventIsNativePasteEvent)
|
|
{
|
|
// We need the event to propagate or nothing will be pasted.
|
|
currentEventShouldDefinitelyBubble = YES;
|
|
|
|
// And we don't send the keydown because either our native paste envent handler will send it,
|
|
// or the _checkDOMPasteboardElement check will.
|
|
currentEventShouldBeSuppressed = YES;
|
|
}
|
|
}
|
|
else if ((characters == "c" || characters == "x") && mayRequireDOMPasteboardElement)
|
|
{
|
|
currentEventIsNativeCopyOrCutEvent = YES;
|
|
|
|
// If _ignoreNativeCopyOrCutEvent, we already handled the copy/cut in beforeCopyEvent:.
|
|
// If supportsNativeCopyAndPaste, we will be handling it in the nativebeforeCopyEvent: handler.
|
|
// In both of those cases we don't want to send the event on keydown too, or we'll get 2X copy/cut operations.
|
|
if (supportsNativeCopyAndPaste || _ignoreNativeCopyOrCutEvent)
|
|
currentEventShouldBeSuppressed = YES;
|
|
}
|
|
|
|
if (CPFeatureIsCompatible(CPBackspaceTriggersPageBack) && characters === CPDeleteCharacter && !hasEditableTarget(aDOMEvent))
|
|
currentEventShouldBeSuppressed = YES;
|
|
|
|
if (!currentEventShouldBeSuppressed)
|
|
{
|
|
if (characters === "v")
|
|
SUPPRESS_CAPPUCCINO_PASTE_FOR_EVENT(anEvent);
|
|
else if (characters === "x")
|
|
SUPPRESS_CAPPUCCINO_CUT_FOR_EVENT(anEvent);
|
|
}
|
|
}
|
|
|
|
- (BOOL)windowShouldSuppressKeyEvent
|
|
{
|
|
return currentEventShouldBeSuppressed;
|
|
}
|
|
|
|
- (void)windowDidSendKeyEvent:(CPEvent)anEvent
|
|
{
|
|
// Now that the copy event has been sent through the Cappuccino event stack, we can load any Cappuccino
|
|
// pasteboard string into our DOMPasteboardElement hack, if necessary.
|
|
if (!supportsNativeCopyAndPaste && currentEventIsNativeCopyOrCutEvent)
|
|
[self _primeDOMPasteboardElement];
|
|
}
|
|
|
|
- (BOOL)windowShouldStopPropagation
|
|
{
|
|
return currentEventShouldDefinitelyNotBubble;
|
|
}
|
|
|
|
- (BOOL)windowShouldNotStopPropagation
|
|
{
|
|
return currentEventShouldDefinitelyBubble;
|
|
}
|
|
|
|
- (CPEvent)_fakeClipboardEvent:(DOMEvent)aDOMEvent type:(CPString)aType
|
|
{
|
|
var keyCode = aType === "x" ? CPKeyCodes.X : (aType === "c" ? CPKeyCodes.C : CPKeyCodes.V),
|
|
characters = aType,
|
|
timestamp = [CPEvent currentTimestamp], // fake event, might as well use current timestamp
|
|
windowNumber = [[CPApp keyWindow] windowNumber],
|
|
modifierFlags = CPPlatformActionKeyMask,
|
|
location = [[CPApp currentEvent] locationInWindow],
|
|
anEvent = [CPEvent keyEventWithType:CPKeyDown location:location modifierFlags:modifierFlags
|
|
timestamp:timestamp windowNumber:windowNumber context:nil
|
|
characters:characters charactersIgnoringModifiers:characters isARepeat:NO keyCode:keyCode];
|
|
|
|
anEvent._data1 = @{ "simulated": YES };
|
|
anEvent._DOMEvent = aDOMEvent;
|
|
|
|
return anEvent;
|
|
}
|
|
|
|
- (void)beforeCopyEvent:(DOMEvent)aDOMEvent
|
|
{
|
|
if ([self _mayRequireDOMPasteboardElementHack:aDOMEvent flags:CPPlatformActionKeyMask] && !_ignoreNativeCopyOrCutEvent)
|
|
{
|
|
// we have to send out a fake copy or cut event so that we can force the copy/cut mechanisms to take place
|
|
var anEvent = [self _fakeClipboardEvent:aDOMEvent type:(aDOMEvent.type === "beforecut" ? "x" : "c")];
|
|
|
|
[CPApp sendEvent:anEvent];
|
|
|
|
// Once we've sent it, we can load the copy information into the pasteboard hack.
|
|
[self _primeDOMPasteboardElement];
|
|
|
|
//then we have to IGNORE the real keyboard event to prevent a double copy
|
|
//safari also sends the beforecopy event twice, so we additionally check here and prevent two events
|
|
_ignoreNativeCopyOrCutEvent = YES;
|
|
}
|
|
|
|
[[CPRunLoop currentRunLoop] limitDateForMode:CPDefaultRunLoopMode];
|
|
}
|
|
|
|
- (BOOL)beforePasteEvent:(DOMEvent)aDOMEvent
|
|
{
|
|
// Set up to capture the paste in a temporary input field. We'll send the event after capture.
|
|
if ([self _mayRequireDOMPasteboardElementHack:aDOMEvent flags:CPPlatformActionKeyMask])
|
|
{
|
|
_DOMPasteboardElement.focus();
|
|
_DOMPasteboardElement.select();
|
|
_DOMPasteboardElement.value = "";
|
|
|
|
_ignoreNativePastePreparation = YES;
|
|
}
|
|
|
|
[[CPRunLoop currentRunLoop] limitDateForMode:CPDefaultRunLoopMode];
|
|
}
|
|
|
|
/*
|
|
Return true if the event may be a copy and paste event, but the target is not an input or text area.
|
|
*/
|
|
- (BOOL)_mayRequireDOMPasteboardElementHack:(DOMEvent)aDOMEvent flags:(unsigned)modifierFlags
|
|
{
|
|
return !hasEditableTarget(aDOMEvent) && (modifierFlags & CPPlatformActionKeyMask);
|
|
}
|
|
|
|
- (void)_primeDOMPasteboardElement
|
|
{
|
|
var pasteboard = [CPPasteboard generalPasteboard],
|
|
types = [pasteboard types];
|
|
|
|
if (types.length)
|
|
{
|
|
if ([types indexOfObjectIdenticalTo:CPStringPboardType] !== CPNotFound)
|
|
_DOMPasteboardElement.value = [pasteboard stringForType:CPStringPboardType];
|
|
else
|
|
_DOMPasteboardElement.value = [pasteboard _generateStateUID];
|
|
|
|
_DOMPasteboardElement.focus();
|
|
_DOMPasteboardElement.select();
|
|
|
|
window.setNativeTimeout(function() { [self _clearDOMPasteboardElement]; }, 0);
|
|
}
|
|
}
|
|
|
|
- (void)_checkDOMPasteboardElement
|
|
{
|
|
if (supportsNativeCopyAndPaste)
|
|
{
|
|
[self _clearDOMPasteboardElement];
|
|
return;
|
|
}
|
|
|
|
var value = _DOMPasteboardElement.value;
|
|
|
|
if ([value length])
|
|
{
|
|
var pasteboard = [CPPasteboard generalPasteboard],
|
|
cappString = [pasteboard stringForType:CPStringPboardType];
|
|
|
|
if (cappString != value)
|
|
{
|
|
[pasteboard declareTypes:[CPStringPboardType] owner:self];
|
|
[pasteboard setString:value forType:CPStringPboardType];
|
|
}
|
|
}
|
|
|
|
[self _clearDOMPasteboardElement];
|
|
|
|
[CPApp sendEvent:[self _fakeClipboardEvent:nil type:@"v"]];
|
|
|
|
[[CPRunLoop currentRunLoop] limitDateForMode:CPDefaultRunLoopMode];
|
|
}
|
|
|
|
- (void)_clearDOMPasteboardElement
|
|
{
|
|
_DOMPasteboardElement.value = "";
|
|
_DOMPasteboardElement.blur();
|
|
}
|
|
|
|
- (BOOL)nativeBeforeClipboardEvent:(DOMEvent)aDOMEvent
|
|
{
|
|
// Our job here is to return "false" if the given clipboard operation should be enabled even in a situation where
|
|
// the browser might normally grey the option out.
|
|
|
|
// Allow these fields to do their own thing.
|
|
if (hasEditableTarget(aDOMEvent))
|
|
return true;
|
|
|
|
var returnValue = YES;
|
|
|
|
switch (aDOMEvent.type)
|
|
{
|
|
case "beforecopy":
|
|
returnValue = !([CPApp targetForAction:@selector(copy:)]);
|
|
break;
|
|
case "beforecut":
|
|
returnValue = !([CPApp targetForAction:@selector(cut:)]);
|
|
break;
|
|
case "beforepaste":
|
|
returnValue = !([CPApp targetForAction:@selector(paste:)]);
|
|
break;
|
|
}
|
|
|
|
if (!returnValue)
|
|
_CPDOMEventStop(aDOMEvent, self);
|
|
|
|
return returnValue;
|
|
}
|
|
|
|
- (BOOL)nativePasteEvent:(DOMEvent)aDOMEvent
|
|
{
|
|
// This shouldn't happen.
|
|
if (!supportsNativeCopyAndPaste)
|
|
return;
|
|
|
|
var value;
|
|
if (aDOMEvent.clipboardData && aDOMEvent.clipboardData.setData)
|
|
value = aDOMEvent.clipboardData.getData('text/plain');
|
|
else
|
|
value = _DOMWindow.clipboardData.getData("Text");
|
|
|
|
if ([value length])
|
|
{
|
|
var pasteboard = [CPPasteboard generalPasteboard],
|
|
cappString = [pasteboard stringForType:CPStringPboardType];
|
|
|
|
if (cappString != value)
|
|
{
|
|
[pasteboard declareTypes:[CPStringPboardType] owner:self];
|
|
[pasteboard setString:value forType:CPStringPboardType];
|
|
}
|
|
}
|
|
|
|
var anEvent = [self _fakeClipboardEvent:aDOMEvent type:"v"],
|
|
platformWindow = [[anEvent window] platformWindow];
|
|
|
|
SUPPRESS_CAPPUCCINO_PASTE_FOR_EVENT(anEvent);
|
|
|
|
// By default we'll stop the native handling of the event since we're handling it ourselves. However, we need to
|
|
// stop it before we send the event so that the event can overrule our choice. CPTextField for instance wants the
|
|
// default handling when focused (which is to insert into the field).
|
|
[platformWindow _propagateCurrentDOMEvent:NO];
|
|
|
|
[CPApp sendEvent:anEvent];
|
|
|
|
[[CPRunLoop currentRunLoop] limitDateForMode:CPDefaultRunLoopMode];
|
|
|
|
if (![platformWindow _willPropagateCurrentDOMEvent])
|
|
_CPDOMEventStop(aDOMEvent, self);
|
|
|
|
return false;
|
|
}
|
|
|
|
- (BOOL)nativeCopyOrCutEvent:(DOMEvent)aDOMEvent
|
|
{
|
|
// This shouldn't happen.
|
|
if (!supportsNativeCopyAndPaste)
|
|
return;
|
|
|
|
var anEvent = [self _fakeClipboardEvent:aDOMEvent type:(aDOMEvent.type.indexOf("cut") != CPNotFound ? "x" : "c")],
|
|
platformWindow = [[anEvent window] platformWindow];
|
|
|
|
SUPPRESS_CAPPUCCINO_CUT_FOR_EVENT(anEvent);
|
|
|
|
[platformWindow _propagateCurrentDOMEvent:NO];
|
|
|
|
// Let the app react through copy: and cut: actions.
|
|
[CPApp sendEvent:anEvent];
|
|
[[CPRunLoop currentRunLoop] limitDateForMode:CPDefaultRunLoopMode];
|
|
|
|
// If StopDOMEventPropagation was set to NO, we don't try to write to the system clipboard. The control that did this
|
|
// wants to use the default copy/cut functionality.
|
|
if (![platformWindow _willPropagateCurrentDOMEvent])
|
|
{
|
|
// Now the app should have written whatever it wants to have copied to the Cappuccino clipboard. So now we need
|
|
// to write it to the system board.
|
|
_CPDOMEventStop(aDOMEvent, self);
|
|
|
|
var pasteboard = [CPPasteboard generalPasteboard];
|
|
|
|
if ([[pasteboard types] containsObject:CPStringPboardType])
|
|
{
|
|
var stringValue = [pasteboard stringForType:CPStringPboardType];
|
|
|
|
if (aDOMEvent.clipboardData && aDOMEvent.clipboardData.setData)
|
|
aDOMEvent.clipboardData.setData('text/plain', stringValue);
|
|
else
|
|
_DOMWindow.clipboardData.setData('Text', stringValue);
|
|
}
|
|
}
|
|
|
|
return ![platformWindow _willPropagateCurrentDOMEvent];
|
|
}
|
|
|
|
@end
|
|
|
|
#endif
|