blob: 2c1b161ba4d97e19895902ca0fc1493a4b28c48f [file] [log] [blame]
// Copyright 2017 The Cobalt Authors. All Rights Reserved.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
#ifndef COBALT_SYSTEM_WINDOW_INPUT_EVENT_H_
#define COBALT_SYSTEM_WINDOW_INPUT_EVENT_H_
#include <string>
#include "cobalt/base/event.h"
#include "cobalt/math/point_f.h"
#include "starboard/event.h"
#include "starboard/time.h"
namespace cobalt {
namespace system_window {
class InputEvent : public base::Event {
public:
enum Type {
kKeyDown,
kKeyUp,
kKeyMove,
kInput,
kPointerDown,
kPointerUp,
kPointerMove,
kTouchpadDown,
kTouchpadUp,
kTouchpadMove,
kTouchscreenDown,
kTouchscreenUp,
kTouchscreenMove,
kWheel,
};
// Bit-mask of key modifiers. These correspond to the |SbKeyModifiers| values
// defined in Starboard.
enum Modifiers {
kNoModifier = 0,
kAltKey = 1 << 0,
kCtrlKey = 1 << 1,
kMetaKey = 1 << 2,
kShiftKey = 1 << 3,
kLeftButton = 1 << 4,
kRightButton = 1 << 5,
kMiddleButton = 1 << 6,
kBackButton = 1 << 7,
kForwardButton = 1 << 8,
};
InputEvent(SbTimeMonotonic timestamp, Type type, int device_id, int key_code,
uint32 modifiers, bool is_repeat,
const math::PointF& position = math::PointF(),
const math::PointF& delta = math::PointF(), float pressure = 0,
const math::PointF& size = math::PointF(),
const math::PointF& tilt = math::PointF()
#if SB_API_VERSION >= 12 || SB_HAS(ON_SCREEN_KEYBOARD)
,
const std::string& input_text = "", bool is_composing = false
#endif // SB_API_VERSION >= 12 ||
// SB_HAS(ON_SCREEN_KEYBOARD)
)
: timestamp_(timestamp),
type_(type),
device_id_(device_id),
key_code_(key_code),
modifiers_(modifiers),
is_repeat_(is_repeat),
position_(position),
delta_(delta),
pressure_(pressure),
size_(size),
tilt_(tilt)
#if SB_API_VERSION >= 12 || SB_HAS(ON_SCREEN_KEYBOARD)
,
input_text_(input_text),
is_composing_(is_composing)
#endif // SB_API_VERSION >= 12 ||
// SB_HAS(ON_SCREEN_KEYBOARD)
{
}
~InputEvent() {}
SbTimeMonotonic timestamp() const { return timestamp_; }
Type type() const { return type_; }
int key_code() const { return key_code_; }
int device_id() const { return device_id_; }
uint32 modifiers() const { return modifiers_; }
bool is_repeat() const { return is_repeat_; }
const math::PointF& position() const { return position_; }
const math::PointF& delta() const { return delta_; }
float pressure() const { return pressure_; }
const math::PointF& size() const { return size_; }
const math::PointF& tilt() const { return tilt_; }
#if SB_API_VERSION >= 12 || SB_HAS(ON_SCREEN_KEYBOARD)
const std::string& input_text() const { return input_text_; }
bool is_composing() const { return is_composing_; }
#endif // SB_API_VERSION >= 12 ||
// SB_HAS(ON_SCREEN_KEYBOARD)
BASE_EVENT_SUBCLASS(InputEvent);
private:
SbTimeMonotonic timestamp_;
Type type_;
int device_id_;
int key_code_;
uint32 modifiers_;
bool is_repeat_;
math::PointF position_;
math::PointF delta_;
float pressure_;
math::PointF size_;
math::PointF tilt_;
#if SB_API_VERSION >= 12 || SB_HAS(ON_SCREEN_KEYBOARD)
std::string input_text_;
bool is_composing_;
#endif // SB_API_VERSION >= 12 ||
// SB_HAS(ON_SCREEN_KEYBOARD)
};
// The Starboard Event handler SbHandleEvent should call this function on
// unrecognized events. It will extract Input events and dispatch them to the
// appropriate SystemWindow for further routing.
void HandleInputEvent(const SbEvent* event);
} // namespace system_window
} // namespace cobalt
#endif // COBALT_SYSTEM_WINDOW_INPUT_EVENT_H_