void SVGAElement::defaultEventHandler(Event* evt)
{
if (isLink() && (evt->type() == eventNames().clickEvent || (evt->type() == eventNames().keydownEvent && focused()))) {
MouseEvent* e = 0;
if (evt->type() == eventNames().clickEvent && evt->isMouseEvent())
e = static_cast<MouseEvent*>(evt);
KeyboardEvent* k = 0;
if (evt->type() == eventNames().keydownEvent && evt->isKeyboardEvent())
k = static_cast<KeyboardEvent*>(evt);
if (e && e->button() == RightButton) {
SVGStyledTransformableElement::defaultEventHandler(evt);
return;
}
if (k) {
if (k->keyIdentifier() != "Enter") {
SVGStyledTransformableElement::defaultEventHandler(evt);
return;
}
evt->setDefaultHandled();
dispatchSimulatedClick(evt);
return;
}
String target = this->target();
if (e && e->button() == MiddleButton)
target = "_blank";
else if (target.isEmpty()) // if target is empty, default to "_self" or use xlink:target if set
target = (getAttribute(XLinkNames::showAttr) == "new") ? "_blank" : "_self";
if (!evt->defaultPrevented()) {
String url = deprecatedParseURL(href());
#if ENABLE(SVG_ANIMATION)
if (url.startsWith("#")) {
Element* targetElement = document()->getElementById(url.substring(1));
if (SVGSMILElement::isSMILElement(targetElement)) {
SVGSMILElement* timed = static_cast<SVGSMILElement*>(targetElement);
timed->beginByLinkActivation();
evt->setDefaultHandled();
SVGStyledTransformableElement::defaultEventHandler(evt);
return;
}
}
#endif
if (document()->frame())
document()->frame()->loader()->urlSelected(document()->completeURL(url), target, evt, false, false, true, SendReferrer);
}
evt->setDefaultHandled();
}
SVGStyledTransformableElement::defaultEventHandler(evt);
}
KeyboardEvent* EventHandler::createKeyboardEvent(const int key, const KEY_TYPE type, Action* a)
{
EventToAction ea;
KeyboardEvent* k = new KeyboardEvent();
k->setKey(key);
k->setType(type);
ea.e = k;
ea.a = a;
m_events.push_back(ea);
return k;
}
bool Play::keyReleaseEvent(const KeyboardEvent& event)
{
if(_isPlaying)
{
_synchronousKeyboard->setIsAsciiPressed(event.getAscii(), false);
_synchronousKeyboard->setIsNonAsciiPressed(event.getNonAscii(), false);
KeyReleaseDispatcher krVisitor( event );
(*_currentAct)->welcome( krVisitor );
return krVisitor.eventConsumed();
}
return false;
}
void CheckboxInputType::handleKeyupEvent(KeyboardEvent& event)
{
const String& key = event.keyIdentifier();
if (key != "U+0020")
return;
dispatchSimulatedClickIfActive(event);
}
void MediaDocument::defaultEventHandler(Event* event)
{
#if !(PLATFORM(BLACKBERRY) && OS(QNX))
// Match the default Quicktime plugin behavior to allow
// clicking and double-clicking to pause and play the media.
Node* targetNode = event->target()->toNode();
if (targetNode && targetNode->hasTagName(videoTag)) {
HTMLVideoElement* video = static_cast<HTMLVideoElement*>(targetNode);
if (event->type() == eventNames().clickEvent) {
if (!video->canPlay()) {
video->pause(event->fromUserGesture());
event->setDefaultHandled();
}
} else if (event->type() == eventNames().dblclickEvent) {
if (video->canPlay()) {
video->play(event->fromUserGesture());
event->setDefaultHandled();
}
}
}
if (event->type() == eventNames().keydownEvent && event->isKeyboardEvent()) {
HTMLVideoElement* video = 0;
if (targetNode) {
if (targetNode->hasTagName(videoTag))
video = static_cast<HTMLVideoElement*>(targetNode);
else {
RefPtr<NodeList> nodeList = targetNode->getElementsByTagName("video");
if (nodeList.get()->length() > 0)
video = static_cast<HTMLVideoElement*>(nodeList.get()->item(0));
}
}
if (video) {
KeyboardEvent* keyboardEvent = static_cast<KeyboardEvent*>(event);
if (keyboardEvent->keyIdentifier() == "U+0020") { // space
if (video->paused()) {
if (video->canPlay())
video->play(event->fromUserGesture());
} else
video->pause(event->fromUserGesture());
event->setDefaultHandled();
}
}
}
#endif
}
void EventPropertyWidgetQt::setButtonText() {
std::string text = eventproperty_->getEvent()->modifierNames();
if (text != "") text.append("+");
KeyboardEvent* keyboardEvent = dynamic_cast<KeyboardEvent*>(eventproperty_->getEvent());
if (keyboardEvent) {
text += std::string(1, static_cast<char>(keyboardEvent->button()));
}
MouseEvent* mouseEvent = dynamic_cast<MouseEvent*>(eventproperty_->getEvent());
if (mouseEvent) {
text += mouseEvent->buttonName();
}
button_->setText(QString::fromStdString(text));
}
void
keyboard_callback (const KeyboardEvent& event,
void* /*cookie*/)
{
if (event.keyUp ())
{
return;
}
}
void MediaDocument::defaultEventHandler(Event* event)
{
Node* targetNode = event->target()->toNode();
if (!targetNode)
return;
if (event->type() == EventTypeNames::keydown && event->isKeyboardEvent()) {
HTMLVideoElement* video = Traversal<HTMLVideoElement>::firstWithin(*targetNode);
if (!video)
return;
KeyboardEvent* keyboardEvent = toKeyboardEvent(event);
if (keyboardEvent->key() == " " || keyboardEvent->keyCode() == VKEY_MEDIA_PLAY_PAUSE) {
// space or media key (play/pause)
video->togglePlayState();
event->setDefaultHandled();
}
}
}
int userMain (int argc, char* argv[])
{
TName producerName = "producerx";
BoundedBuffer *buff;
Consumer *con;
intLock
buff = new BoundedBuffer(atoi(argv[1]));
N = atoi(argv[2]);
N = N>19 ? 19 : N;
TIME_SLICE = atoi(argv[3]);
Producer **pro = new Producer*[N];
KeyboardEvent* kev;
int i;
con = new Consumer(buff);
con->start();
for (i=0; i<N; i++){
producerName[8]='0'+i;
pro[i] = new Producer(buff, producerName ,'0'+i, TIME_SLICE);
pro[i]->start();
}
kev = new KeyboardEvent(buff);
intUnlock
kev->start();
for (i=0; i<N; i++){
delete pro[i];
}
delete [] pro;
delete kev;
delete con;
intLock
cout<<"Kraj userMain"<<endl;
intUnlock
return 0;
}
bool EditingBehavior::shouldInsertCharacter(const KeyboardEvent& event) const
{
if (event.keyEvent()->text().length() != 1)
return true;
// On Gtk/Linux, it emits key events with ASCII text and ctrl on for ctrl-<x>.
// In Webkit, EditorClient::handleKeyboardEvent in
// WebKit/gtk/WebCoreSupport/EditorClientGtk.cpp drop such events.
// On Mac, it emits key events with ASCII text and meta on for Command-<x>.
// These key events should not emit text insert event.
// Alt key would be used to insert alternative character, so we should let
// through. Also note that Ctrl-Alt combination equals to AltGr key which is
// also used to insert alternative character.
// http://code.google.com/p/chromium/issues/detail?id=10846
// Windows sets both alt and meta are on when "Alt" key pressed.
// http://code.google.com/p/chromium/issues/detail?id=2215
// Also, we should not rely on an assumption that keyboards don't
// send ASCII characters when pressing a control key on Windows,
// which may be configured to do it so by user.
// See also http://en.wikipedia.org/wiki/Keyboard_Layout
// FIXME(ukai): investigate more detail for various keyboard layout.
UChar ch = event.keyEvent()->text()[0U];
// Don't insert null or control characters as they can result in
// unexpected behaviour
if (ch < ' ')
return false;
#if !OS(WIN)
// Don't insert ASCII character if ctrl w/o alt or meta is on.
// On Mac, we should ignore events when meta is on (Command-<x>).
if (ch < 0x80) {
if (event.keyEvent()->ctrlKey() && !event.keyEvent()->altKey())
return false;
#if OS(MACOSX)
if (event.keyEvent()->metaKey())
return false;
#endif
}
#endif
return true;
}
void DateTimeFieldElement::defaultEventHandler(Event* event)
{
if (event->type() == eventNames().blurEvent)
didBlur();
if (event->type() == eventNames().focusEvent)
didFocus();
if (event->isKeyboardEvent()) {
KeyboardEvent* keyboardEvent = static_cast<KeyboardEvent*>(event);
handleKeyboardEvent(keyboardEvent);
if (keyboardEvent->defaultHandled())
return;
defaultKeyboardEventHandler(keyboardEvent);
if (keyboardEvent->defaultHandled())
return;
}
HTMLElement::defaultEventHandler(event);
}
void Event::SysEvent::Loop()
{
_xbox = new XboxManager();
_leap = new LeapManager();
_leap->Connect();
wait_systen();
while (G_GameSettings && G_GameSettings->gameState != Settings::END)
{
if (_ogl->IsInit() && _ogl->IsClose() == false)
{
_sdl = _ogl->GetContext();
_input = _ogl->GetInput();
_ogl->Lock();
_sdl->updateInputs(*_input);
_ogl->Unlock();
_keymanager.updateValue(*_input);
_xbox->Reset();
_xbox->Update();
if (G_EvDispatcher)
{
if (_keymanager.isUpdated() == true)
{
G_EvDispatcher->SendEvent(new KeyboardEvent(_keymanager.getKeyboard()), COMMON);
KeyboardEvent *sysev = new KeyboardEvent(_keymanager.getKeyboard());
sysev->SetScope(ENGINE);
G_EvDispatcher->SendEvent(sysev, SYS);
}
if (_leap->HasUpdate())
G_EvDispatcher->SendEvent(new LeapEvent(_leap->GetLeapData()), COMMON);
if (_xbox->HasUpdate())
G_EvDispatcher->SendEvent(new XboxEvent(_xbox->GetInput(),
_xbox->NumJoystick()),
COMMON);
}
}
usleep(5000);
}
_leap->Disconnect();
delete _xbox;
delete _leap;
}
void MediaDocument::defaultEventHandler(Event* event)
{
// Match the default Quicktime plugin behavior to allow
// clicking and double-clicking to pause and play the media.
Node* targetNode = event->target()->toNode();
if (!targetNode)
return;
if (HTMLVideoElement* video = ancestorVideoElement(targetNode)) {
if (event->type() == eventNames().clickEvent) {
if (!video->canPlay()) {
video->pause();
event->setDefaultHandled();
}
} else if (event->type() == eventNames().dblclickEvent) {
if (video->canPlay()) {
video->play();
event->setDefaultHandled();
}
}
}
if (!targetNode->isContainerNode())
return;
ContainerNode& targetContainer = toContainerNode(*targetNode);
if (event->type() == eventNames().keydownEvent && event->isKeyboardEvent()) {
HTMLVideoElement* video = descendentVideoElement(targetContainer);
if (!video)
return;
KeyboardEvent* keyboardEvent = static_cast<KeyboardEvent*>(event);
if (keyboardEvent->keyIdentifier() == "U+0020") { // space
if (video->paused()) {
if (video->canPlay())
video->play();
} else
video->pause();
event->setDefaultHandled();
}
}
}
JSValue* jsKeyboardEventPrototypeFunctionInitKeyboardEvent(ExecState* exec, JSObject*, JSValue* thisValue, const ArgList& args)
{
if (!thisValue->isObject(&JSKeyboardEvent::s_info))
return throwError(exec, TypeError);
JSKeyboardEvent* castedThisObj = static_cast<JSKeyboardEvent*>(thisValue);
KeyboardEvent* imp = static_cast<KeyboardEvent*>(castedThisObj->impl());
const UString& type = args[0]->toString(exec);
bool canBubble = args[1]->toBoolean(exec);
bool cancelable = args[2]->toBoolean(exec);
DOMWindow* view = toDOMWindow(args[3]);
const UString& keyIdentifier = args[4]->toString(exec);
unsigned keyLocation = args[5]->toInt32(exec);
bool ctrlKey = args[6]->toBoolean(exec);
bool altKey = args[7]->toBoolean(exec);
bool shiftKey = args[8]->toBoolean(exec);
bool metaKey = args[9]->toBoolean(exec);
bool altGraphKey = args[10]->toBoolean(exec);
imp->initKeyboardEvent(type, canBubble, cancelable, view, keyIdentifier, keyLocation, ctrlKey, altKey, shiftKey, metaKey, altGraphKey);
return jsUndefined();
}
void DateTimeFieldElement::defaultEventHandler(Event* event)
{
if (event->isKeyboardEvent()) {
KeyboardEvent* keyboardEvent = toKeyboardEvent(event);
if (!isDisabled() && !isFieldOwnerDisabled() && !isFieldOwnerReadOnly()) {
handleKeyboardEvent(keyboardEvent);
if (keyboardEvent->defaultHandled()) {
if (m_fieldOwner)
m_fieldOwner->fieldDidChangeValueByKeyboard();
return;
}
}
defaultKeyboardEventHandler(keyboardEvent);
if (m_fieldOwner)
m_fieldOwner->fieldDidChangeValueByKeyboard();
if (keyboardEvent->defaultHandled())
return;
}
HTMLElement::defaultEventHandler(event);
}
static void handleKeyPress(Frame& frame, KeyboardEvent& event, const PlatformKeyboardEvent& platformEvent)
{
String commandName = interpretKeyEvent(event);
if (!commandName.isEmpty()) {
frame.editor().command(commandName).execute();
event.setDefaultHandled();
return;
}
// Don't insert null or control characters as they can result in unexpected behaviour
if (event.charCode() < ' ')
return;
// Don't insert anything if a modifier is pressed and it has not been handled yet
if (platformEvent.ctrlKey() || platformEvent.altKey())
return;
if (frame.editor().insertText(platformEvent.text(), &event))
event.setDefaultHandled();
}
void DateTimeFieldElement::defaultEventHandler(Event* event)
{
if (event->type() == EventTypeNames::blur)
didBlur();
if (event->type() == EventTypeNames::focus)
didFocus();
if (event->isKeyboardEvent()) {
KeyboardEvent* keyboardEvent = toKeyboardEvent(event);
if (!isDisabled() && !isFieldOwnerDisabled() && !isFieldOwnerReadOnly()) {
handleKeyboardEvent(keyboardEvent);
if (keyboardEvent->defaultHandled())
return;
}
defaultKeyboardEventHandler(keyboardEvent);
if (keyboardEvent->defaultHandled())
return;
}
HTMLElement::defaultEventHandler(event);
}
void SelectElement::defaultEventHandler(SelectElementData& data, Element* element, Event* event, HTMLFormElement* htmlForm)
{
if (!element->renderer())
return;
if (data.usesMenuList())
menuListDefaultEventHandler(data, element, event, htmlForm);
else
listBoxDefaultEventHandler(data, element, event, htmlForm);
if (event->defaultHandled())
return;
if (event->type() == eventNames().keypressEvent && event->isKeyboardEvent()) {
KeyboardEvent* keyboardEvent = static_cast<KeyboardEvent*>(event);
if (!keyboardEvent->ctrlKey() && !keyboardEvent->altKey() && !keyboardEvent->metaKey() && isPrintableChar(keyboardEvent->charCode())) {
typeAheadFind(data, element, keyboardEvent);
event->setDefaultHandled();
return;
}
}
}
JSValue JSC_HOST_CALL jsKeyboardEventPrototypeFunctionInitKeyboardEvent(ExecState* exec, JSObject*, JSValue thisValue, const ArgList& args)
{
UNUSED_PARAM(args);
if (!thisValue.inherits(&JSKeyboardEvent::s_info))
return throwError(exec, TypeError);
JSKeyboardEvent* castedThisObj = static_cast<JSKeyboardEvent*>(asObject(thisValue));
KeyboardEvent* imp = static_cast<KeyboardEvent*>(castedThisObj->impl());
const UString& type = args.at(0).toString(exec);
bool canBubble = args.at(1).toBoolean(exec);
bool cancelable = args.at(2).toBoolean(exec);
DOMWindow* view = toDOMWindow(args.at(3));
const UString& keyIdentifier = args.at(4).toString(exec);
unsigned keyLocation = args.at(5).toInt32(exec);
bool ctrlKey = args.at(6).toBoolean(exec);
bool altKey = args.at(7).toBoolean(exec);
bool shiftKey = args.at(8).toBoolean(exec);
bool metaKey = args.at(9).toBoolean(exec);
bool altGraphKey = args.at(10).toBoolean(exec);
imp->initKeyboardEvent(type, canBubble, cancelable, view, keyIdentifier, keyLocation, ctrlKey, altKey, shiftKey, metaKey, altGraphKey);
return jsUndefined();
}
bool onKeyboardEvent(const KeyboardEvent& event)
{
switch (event.state())
{
case KeyboardEvent::PRESSED:
switch (event.key())
{
case KeyboardEvent::LEFT:
m_left = 1;
return true;
case KeyboardEvent::RIGHT:
m_right = 1;
return true;
default:
break;
}
break;
case KeyboardEvent::RELEASED:
switch (event.key())
{
case KeyboardEvent::LEFT:
m_left = 0;
return true;
case KeyboardEvent::RIGHT:
m_right = 0;
return true;
default:
break;
}
break;
}
return false;
}
// Dispatch a keyboard event to any registered handlers
void EventDispatcher::handleKeyboard(KeyboardEvent& evt)
{
HANDLE dev = evt.getDeviceHandle();
{
// Set the device info if it's available
ScopedCriticalSection kMutex(&kdLock);
if(keyboardDevices.count(dev) > 0)
{
evt.setDeviceInfo(keyboardDevices[dev]);
}
else
{
// It's an unknown device, let's see what we can find out about it.
ScopedNonCriticalSection unlock(&kdLock);
KeyboardInfo *kbd = unknownKeyboardDevice(dev);
if(kbd)
{
evt.setDeviceInfo(kbd);
}
}
}
{
// Run the chain, let someone make a decision about this event
ScopedCriticalSection kecMutex(&kecLock);
if(kbdEventChains.count(dev) > 0 && kbdEventChains[dev]->chainSize() > 0)
{
// We've got a real handler, give it to them (and hard)
kbdEventChains[dev]->runKeyboardEventChain(evt);
}
else
{
// Ain't nobody here. Do something?
}
}
}
void EditCtrl::OnKeyDown( KeyboardEvent const & p_event )
{
if ( !p_event.IsCtrlDown() && !p_event.IsAltDown() )
{
eKEYBOARD_KEY l_code = p_event.GetKey();
if ( l_code == eKEY_BACKSPACE )
{
DoDeleteCharBeforeCaret();
m_signals[eEDIT_EVENT_UPDATED]( m_caption );
}
else if ( l_code == eKEY_DELETE )
{
DoDeleteCharAtCaret();
m_signals[eEDIT_EVENT_UPDATED]( m_caption );
}
else if ( l_code == eKEY_LEFT && m_caretIt != m_caption.begin() )
{
m_caretIt--;
DoUpdateCaption();
}
else if ( l_code == eKEY_RIGHT && m_caretIt != m_caption.end() )
{
m_caretIt++;
DoUpdateCaption();
}
else if ( l_code == eKEY_HOME && m_caretIt != m_caption.begin() )
{
m_caretIt = m_caption.begin();
DoUpdateCaption();
}
else if ( l_code == eKEY_END && m_caretIt != m_caption.end() )
{
m_caretIt = m_caption.end();
DoUpdateCaption();
}
}
}
void WMLAElement::defaultEventHandler(Event* event)
{
if (isLink() && (event->type() == eventNames().clickEvent || (event->type() == eventNames().keydownEvent && focused()))) {
MouseEvent* e = 0;
if (event->type() == eventNames().clickEvent && event->isMouseEvent())
e = static_cast<MouseEvent*>(event);
KeyboardEvent* k = 0;
if (event->type() == eventNames().keydownEvent && event->isKeyboardEvent())
k = static_cast<KeyboardEvent*>(event);
if (e && e->button() == RightButton) {
WMLElement::defaultEventHandler(event);
return;
}
if (k) {
if (k->keyIdentifier() != "Enter") {
WMLElement::defaultEventHandler(event);
return;
}
event->setDefaultHandled();
dispatchSimulatedClick(event);
return;
}
if (!event->defaultPrevented() && document()->frame()) {
KURL url = document()->completeURL(parseURL(getAttribute(HTMLNames::hrefAttr)));
document()->frame()->loader()->urlSelected(url, target(), event, false, true);
}
event->setDefaultHandled();
}
WMLElement::defaultEventHandler(event);
}
static void handleKeyDown(Frame& frame, KeyboardEvent& event, const PlatformKeyboardEvent&)
{
String commandName = interpretKeyEvent(event);
if (commandName.isEmpty())
return;
// We shouldn't insert text through the editor. Let WebCore decide
// how to handle that (say, Tab, which could also be used to
// change focus).
Editor::Command command = frame.editor().command(commandName);
if (command.isTextInsertion())
return;
command.execute();
event.setDefaultHandled();
}
void HTMLAnchorElement::defaultEventHandler(Event* evt)
{
// React on clicks and on keypresses.
// Don't make this KEYUP_EVENT again, it makes khtml follow links it shouldn't,
// when pressing Enter in the combo.
if (isLink() && (evt->type() == eventNames().clickEvent || (evt->type() == eventNames().keydownEvent && focused()))) {
MouseEvent* e = 0;
if (evt->type() == eventNames().clickEvent && evt->isMouseEvent())
e = static_cast<MouseEvent*>(evt);
KeyboardEvent* k = 0;
if (evt->type() == eventNames().keydownEvent && evt->isKeyboardEvent())
k = static_cast<KeyboardEvent*>(evt);
if (e && e->button() == RightButton) {
HTMLElement::defaultEventHandler(evt);
return;
}
// If the link is editable, then we need to check the settings to see whether or not to follow the link
if (isContentEditable()) {
EditableLinkBehavior editableLinkBehavior = EditableLinkDefaultBehavior;
if (Settings* settings = document()->settings())
editableLinkBehavior = settings->editableLinkBehavior();
switch (editableLinkBehavior) {
// Always follow the link (Safari 2.0 behavior)
default:
case EditableLinkDefaultBehavior:
case EditableLinkAlwaysLive:
break;
case EditableLinkNeverLive:
HTMLElement::defaultEventHandler(evt);
return;
// If the selection prior to clicking on this link resided in the same editable block as this link,
// and the shift key isn't pressed, we don't want to follow the link
case EditableLinkLiveWhenNotFocused:
if (e && !e->shiftKey() && m_rootEditableElementForSelectionOnMouseDown == rootEditableElement()) {
HTMLElement::defaultEventHandler(evt);
return;
}
break;
// Only follow the link if the shift key is down (WinIE/Firefox behavior)
case EditableLinkOnlyLiveWithShiftKey:
if (e && !e->shiftKey()) {
HTMLElement::defaultEventHandler(evt);
return;
}
break;
}
}
if (k) {
if (k->keyIdentifier() != "Enter") {
HTMLElement::defaultEventHandler(evt);
return;
}
evt->setDefaultHandled();
dispatchSimulatedClick(evt);
return;
}
String url = parseURL(getAttribute(hrefAttr));
ASSERT(evt->target());
ASSERT(evt->target()->toNode());
if (evt->target()->toNode()->hasTagName(imgTag)) {
HTMLImageElement* img = static_cast<HTMLImageElement*>(evt->target()->toNode());
if (img && img->isServerMap()) {
RenderImage* r = static_cast<RenderImage*>(img->renderer());
if (r && e) {
// FIXME: broken with transforms
FloatPoint absPos = r->localToAbsolute();
int x = e->pageX() - absPos.x();
int y = e->pageY() - absPos.y();
url += "?";
url += String::number(x);
url += ",";
url += String::number(y);
} else {
evt->setDefaultHandled();
HTMLElement::defaultEventHandler(evt);
return;
}
}
}
if (!evt->defaultPrevented() && document()->frame())
document()->frame()->loader()->urlSelected(document()->completeURL(url), getAttribute(targetAttr), evt, false, false, true);
evt->setDefaultHandled();
} else if (isLink() && isContentEditable()) {
// This keeps track of the editable block that the selection was in (if it was in one) just before the link was clicked
// for the LiveWhenNotFocused editable link behavior
if (evt->type() == eventNames().mousedownEvent && evt->isMouseEvent() && static_cast<MouseEvent*>(evt)->button() != RightButton && document()->frame() && document()->frame()->selection()) {
MouseEvent* e = static_cast<MouseEvent*>(evt);
m_rootEditableElementForSelectionOnMouseDown = document()->frame()->selection()->rootEditableElement();
m_wasShiftKeyDownOnMouseDown = e && e->shiftKey();
} else if (evt->type() == eventNames().mouseoverEvent) {
// These are cleared on mouseover and not mouseout because their values are needed for drag events, but these happen
// after mouse out events.
m_rootEditableElementForSelectionOnMouseDown = 0;
m_wasShiftKeyDownOnMouseDown = false;
}
}
HTMLElement::defaultEventHandler(evt);
}
WebKeyboardEventBuilder::WebKeyboardEventBuilder(const KeyboardEvent& event)
{
if (event.type() == EventTypeNames::keydown)
type = KeyDown;
else if (event.type() == EventTypeNames::keyup)
type = WebInputEvent::KeyUp;
else if (event.type() == EventTypeNames::keypress)
type = WebInputEvent::Char;
else
return; // Skip all other keyboard events.
modifiers = getWebInputModifiers(event);
if (event.location() == KeyboardEvent::DOM_KEY_LOCATION_NUMPAD)
modifiers |= WebInputEvent::IsKeyPad;
else if (event.location() == KeyboardEvent::DOM_KEY_LOCATION_LEFT)
modifiers |= WebInputEvent::IsLeft;
else if (event.location() == KeyboardEvent::DOM_KEY_LOCATION_RIGHT)
modifiers |= WebInputEvent::IsRight;
timeStampSeconds = event.timeStamp() / millisPerSecond;
windowsKeyCode = event.keyCode();
// The platform keyevent does not exist if the event was created using
// initKeyboardEvent.
if (!event.keyEvent())
return;
nativeKeyCode = event.keyEvent()->nativeVirtualKeyCode();
unsigned numberOfCharacters = std::min(event.keyEvent()->text().length(), static_cast<unsigned>(textLengthCap));
for (unsigned i = 0; i < numberOfCharacters; ++i) {
text[i] = event.keyEvent()->text()[i];
unmodifiedText[i] = event.keyEvent()->unmodifiedText()[i];
}
memcpy(keyIdentifier, event.keyIdentifier().ascii().data(), event.keyIdentifier().length());
}
virtual void HandleKeyEvent(KeyboardEvent& evt)
{
// Decide whether or not to consume the keystroke
if(evt.getVkey() == VK_SPACE)
evt.setDecision(CONSUME);
}
void OsuScreenBackable::onChar(KeyboardEvent &e)
{
if (!m_bVisible) return;
e.consume();
}
void InputType::dispatchSimulatedClickIfActive(KeyboardEvent& event) const
{
if (element().active())
element().dispatchSimulatedClick(&event);
event.setDefaultHandled();
}
void OsuPauseMenu::onChar(KeyboardEvent &e)
{
if (!m_bVisible) return;
e.consume();
}
