Gdk¶

API reference for the Gdk namespace (version 4.0), generated from GObject-Introspection.

Classes¶

AppLaunchContext — Handles launching an application in a graphical context. It is an implementation of GAppLaunchContext that provides startup notification…
ButtonEvent — An event related to a button on a pointer device.
CairoContext — Represents the platform-specific draw context. GdkCairoContexts are created for a surface using Surface.create_cairo_context, and the…
CicpParams — Contains the parameters that define a colorstate with cicp parameters. Cicp parameters are specified in the ITU-T H.273 specification. See…
CicpParamsClass
Clipboard — Represents data shared between applications or inside an application. To get a GdkClipboard object, use Display.get_clipboard or…
ColorState — Provides information to interpret colors and pixels in a variety of ways. They are also known as color spaces. Crucially, GTK knows how…
ContentDeserializer — Deserializes content received via inter-application data transfers. The GdkContentDeserializer transforms serialized content that is…
ContentFormats — Used to advertise and negotiate the format of content. You will encounter GdkContentFormats when interacting with objects controlling…
ContentFormatsBuilder — Creates GdkContentFormats objects.
ContentProvider — Provides content for the clipboard or for drag-and-drop operations in a number of formats. To create a GdkContentProvider, use…
ContentProviderClass — Class structure for GdkContentProvider.
ContentSerializer — Serializes content for inter-application data transfers. The GdkContentSerializer transforms an object that is identified by a GType into…
CrossingEvent — An event caused by a pointing device moving between surfaces.
Cursor — Used to create and destroy cursors. Cursors are immutable objects, so once you created them, there is no way to modify them later. You…
DNDEvent — An event related to drag and drop operations.
DeleteEvent — An event related to closing a top-level surface.
Device — Represents an input device, such as a keyboard, mouse or touchpad. See the Seat documentation for more information about the various kinds…
DevicePad — An interface for tablet pad devices. It allows querying the features provided by the pad device. Tablet pads may contain one or more…
DevicePadInterface
DeviceTool — A physical tool associated to a GdkDevice.
Display — A representation of a workstation. Their purpose are two-fold: - To manage and provide information about input devices (pointers,…
DisplayManager — Offers notification when displays appear or disappear. GdkDisplayManager is a singleton object. You can use DisplayManager.get to obtain…
DmabufFormats — Provides information about supported DMA buffer formats. You can query whether a given format is supported with DmabufFormats.contains and…
DmabufTexture — A GdkTexture representing a DMA buffer. To create a GdkDmabufTexture, use the auxiliary DmabufTextureBuilder object. Dma-buf textures…
DmabufTextureBuilder — Constructs Texture objects from DMA buffers. DMA buffers are commonly called dma-bufs. DMA buffers are a feature of the Linux kernel…
DmabufTextureBuilderClass
DmabufTextureClass
Drag — Represents the source of an ongoing DND operation. A GdkDrag is created when a drag is started, and stays alive for duration of the DND…
DragSurface — A surface that is used during DND.
DragSurfaceInterface — The GdkDragSurfaceInterface implementation is private to GDK.
DragSurfaceSize — Contains information that is useful to compute the size of a drag surface.
DrawContext — Base class for objects implementing different rendering methods. GdkDrawContext is the base object used by contexts implementing…
Drop — Represents the target of an ongoing DND operation. Possible drop sites get informed about the status of the ongoing drag operation with…
Event — Represents windowing system events. In GTK applications the events are handled automatically by toplevel widgets and passed on to the event…
EventSequence — An opaque type representing a sequence of related events.
FileList — An opaque type representing a list of files.
FocusEvent — An event related to a keyboard focus change.
FrameClock — Tells the application when to update and repaint a surface. This may be synced to the vertical refresh rate of the monitor, for example.…
FrameClockClass
FrameClockPrivate
FrameTimings — Holds timing information for a single frame of the application’s displays. To retrieve GdkFrameTimings objects, use…
GLContext — Represents a platform-specific OpenGL draw context. GdkGLContexts are created for a surface using Surface.create_gl_context, and the…
GLTexture — A GdkTexture representing a GL texture object.
GLTextureBuilder — Constructs Texture objects from GL textures. The operation is quite simple: Create a texture builder, set all the necessary properties -…
GLTextureBuilderClass
GLTextureClass
GrabBrokenEvent — An event related to a broken windowing system grab.
KeyEvent — An event related to a key-based device.
KeymapKey — Represents a hardware key that can be mapped to a keyval.
MemoryTexture — A GdkTexture representing image data in memory.
MemoryTextureBuilder — Constructs Texture objects from system memory provided via GLib.Bytes. The operation is quite simple: Create a texture builder, set all the…
MemoryTextureBuilderClass
MemoryTextureClass
Monitor — Represents the individual outputs that are associated with a GdkDisplay. GdkDisplay keeps a GListModel to enumerate and monitor…
MonitorClass
MotionEvent — An event related to a pointer or touch device motion.
PadEvent — An event related to a pad-based device.
Paintable — An interface for content that can be painted. The content of a GdkPaintable can be painted anywhere at any size without requiring any…
PaintableInterface — The list of functions that can be implemented for the GdkPaintable interface. Note that apart from the Paintable.snapshot function, no…
Popup — A surface that is attached to another surface. The GdkPopup is positioned relative to its parent surface. GdkPopups are typically used…
PopupInterface
PopupLayout — Contains information that is necessary position a Popup relative to its parent. The positioning requires a negotiation with the windowing…
ProximityEvent — An event related to the proximity of a tool to a device.
RGBA — Represents a color, in a way that is compatible with cairo’s notion of color. GdkRGBA is a convenient way to pass colors around. It’s…
Rectangle — Represents a rectangle. GdkRectangle is identical to cairo_rectangle_t. Together with Cairo’s cairo_region_t data type, these are the…
ScrollEvent — An event related to a scrolling motion.
Seat — Represents a collection of input devices that belong to a user.
Snapshot — Base type for snapshot operations. The subclass of GdkSnapshot used by GTK is GtkSnapshot.
SnapshotClass
Surface — Represents a rectangular region on the screen. It’s a low-level object, used to implement high-level objects such as GtkWindow. The…
SurfaceClass
Texture — Refers to pixel data in various forms. It is primarily meant for pixel data that will not change over multiple frames, and will be used for…
TextureClass
TextureDownloader — Used to download the contents of a Texture. It is intended to be created as a short-term object for a single download, but can be used for…
TimeCoord — Stores a single event in a motion history. To check whether an axis is present, check whether the corresponding flag from the AxisFlags…
Toplevel — A freestanding toplevel surface. The GdkToplevel interface provides useful APIs for interacting with the windowing system, such as…
ToplevelInterface
ToplevelLayout — Contains information that is necessary to present a sovereign window on screen. The GdkToplevelLayout struct is necessary for using…
ToplevelSize — Contains information that is useful to compute the size of a toplevel.
TouchEvent — An event related to a touch-based device.
TouchpadEvent — An event related to a gesture on a touchpad device. Unlike touchscreens, where the windowing system sends basic sequences of begin, update,…
VulkanContext — Represents the platform-specific Vulkan draw context. GdkVulkanContexts are created for a surface using Surface.create_vulkan_context,…

Functions¶

cairo_draw_from_gl¶

def cairo_draw_from_gl(cr: cairo.Context[cairo.Surface], surface: Surface, source: int, source_type: int, buffer_scale: int, x: int, y: int, width: int, height: int) -> None

:::warning Deprecated since 4.6 This API is deprecated. :::

Draws GL content onto a cairo context.

It takes a render buffer ID (source_type == GL_RENDERBUFFER) or a texture id (source_type == GL_TEXTURE) and draws it onto cr with an OVER operation, respecting the current clip. The top left corner of the rectangle specified by x, y, width and height will be drawn at the current (0,0) position of the cairo_t.

This will work for all cairo_t, as long as surface is realized, but the fallback implementation that reads back the pixels from the buffer may be used in the general case. In the case of direct drawing to a surface with no special effects applied to cr it will however use a more efficient approach.

For GL_RENDERBUFFER the code will always fall back to software for buffers with alpha components, so make sure you use GL_TEXTURE if using alpha.

Calling this may change the current GL context.

Parameters:

cr — a cairo context
surface — The surface we're rendering for (not necessarily into)
source — The GL ID of the source buffer
source_type — The type of the source
buffer_scale — The scale-factor that the source buffer is allocated for
x — The source x position in source to start copying from in GL coordinates
y — The source y position in source to start copying from in GL coordinates
width — The width of the region to draw
height — The height of the region to draw

cairo_rectangle¶

def cairo_rectangle(cr: cairo.Context[cairo.Surface], rectangle: Rectangle) -> None

Adds the given rectangle to the current path of cr.

Parameters:

cr — a cairo context
rectangle — a GdkRectangle

cairo_region¶

def cairo_region(cr: cairo.Context[cairo.Surface], region: cairo.Region) -> None

Adds the given region to the current path of cr.

Parameters:

cr — a cairo context
region — a cairo_region_t

cairo_region_create_from_surface¶

def cairo_region_create_from_surface(surface: cairo.Surface) -> cairo.Region

Creates region that covers the area where the given surface is more than 50% opaque.

This function takes into account device offsets that might be set with cairo_surface_set_device_offset().

Parameters:

surface — a cairo surface

cairo_set_source_pixbuf¶

def cairo_set_source_pixbuf(cr: cairo.Context[cairo.Surface], pixbuf: GdkPixbuf.Pixbuf, pixbuf_x: float, pixbuf_y: float) -> None

:::warning Deprecated since 4.20 This API is deprecated. :::

Sets the given pixbuf as the source pattern for cr.

The pattern has an extend mode of CAIRO_EXTEND_NONE and is aligned so that the origin of pixbuf is pixbuf_x, pixbuf_y.

Parameters:

cr — a cairo context
pixbuf — a GdkPixbuf
pixbuf_x — X coordinate of location to place upper left corner of pixbuf
pixbuf_y — Y coordinate of location to place upper left corner of pixbuf

cairo_set_source_rgba¶

def cairo_set_source_rgba(cr: cairo.Context[cairo.Surface], rgba: RGBA) -> None

Sets the specified GdkRGBA as the source color of cr.

Parameters:

cr — a cairo context
rgba — a GdkRGBA

content_deserialize_async¶

def content_deserialize_async(stream: Gio.InputStream, mime_type: str, type: type | GObject.Type, io_priority: int, cancellable: Gio.Cancellable | None = ..., callback: Gio.AsyncReadyCallback | None = ...) -> None

Reads content from the given input stream and deserialize it, asynchronously.

The default I/O priority is G_PRIORITY_DEFAULT (i.e. 0), and lower numbers indicate a higher priority.

Parameters:

stream — a GInputStream to read the serialized content from
mime_type — the mime type to deserialize from
type — the GType to deserialize from
io_priority — the I/O priority of the operation
cancellable — optional GCancellable object
callback — callback to call when the operation is done

content_deserialize_finish¶

def content_deserialize_finish(result: Gio.AsyncResult) -> tuple[bool, GObject.Value]

Finishes a content deserialization operation.

Parameters:

result — the GAsyncResult

content_register_deserializer¶

def content_register_deserializer(mime_type: str, type: type | GObject.Type, deserialize: ContentDeserializeFunc) -> None

Registers a function to deserialize object of a given type.

Since 4.20, when looking up a deserializer to use, GTK will use the last registered deserializer for a given mime type, so applications can override the built-in deserializers.

Parameters:

mime_type — the mime type which the function can deserialize from
type — the type of objects that the function creates
deserialize — the callback

content_register_serializer¶

def content_register_serializer(type: type | GObject.Type, mime_type: str, serialize: ContentSerializeFunc) -> None

Registers a function to serialize objects of a given type.

Since 4.20, when looking up a serializer to use, GTK will use the last registered serializer for a given mime type, so applications can override the built-in serializers.

Parameters:

type — the type of objects that the function can serialize
mime_type — the mime type to serialize to
serialize — the callback

content_serialize_async¶

def content_serialize_async(stream: Gio.OutputStream, mime_type: str, value: GObject.Value, io_priority: int, cancellable: Gio.Cancellable | None = ..., callback: Gio.AsyncReadyCallback | None = ...) -> None

Serialize content and write it to the given output stream, asynchronously.

The default I/O priority is GLib.PRIORITY_DEFAULT (i.e. 0), and lower numbers indicate a higher priority.

Parameters:

stream — a GOutputStream to write the serialized content to
mime_type — the mime type to serialize to
value — the content to serialize
io_priority — the I/O priority of the operation
cancellable — optional GCancellable object
callback — callback to call when the operation is done

content_serialize_finish¶

def content_serialize_finish(result: Gio.AsyncResult) -> bool

Finishes a content serialization operation.

Parameters:

result — the GAsyncResult

events_get_angle¶

def events_get_angle(event1: Event, event2: Event) -> tuple[bool, float]

Returns the relative angle from event1 to event2.

The relative angle is the angle between the X axis and the line through both events' positions. The rotation direction for positive angles is from the positive X axis towards the positive Y axis.

This assumes that both events have X/Y information. If not, this function returns False.

Parameters:

event1 — first GdkEvent
event2 — second GdkEvent

events_get_center¶

def events_get_center(event1: Event, event2: Event) -> tuple[bool, float, float]

Returns the point halfway between the events' positions.

This assumes that both events have X/Y information. If not, this function returns False.

Parameters:

event1 — first GdkEvent
event2 — second GdkEvent

events_get_distance¶

def events_get_distance(event1: Event, event2: Event) -> tuple[bool, float]

Returns the distance between the event locations.

This assumes that both events have X/Y information. If not, this function returns False.

Parameters:

event1 — first GdkEvent
event2 — second GdkEvent

intern_mime_type¶

def intern_mime_type(string: str) -> str | None

Canonicalizes the given mime type and interns the result.

If string is not a valid mime type, None is returned instead. See RFC 2048 for the syntax if mime types.

Parameters:

string — string of a potential mime type

keyval_convert_case¶

def keyval_convert_case(symbol: int) -> tuple[int, int]

Obtains the upper- and lower-case versions of the keyval symbol.

Examples of keyvals are GDK_KEY_a, GDK_KEY_Enter, GDK_KEY_F1, etc.

Parameters:

symbol — a keyval

keyval_from_name¶

def keyval_from_name(keyval_name: str) -> int

Converts a key name to a key value.

The names are the same as those in the gdk/gdkkeysyms.h header file but without the leading “GDK_KEY_”.

Parameters:

keyval_name — a key name

keyval_is_lower¶

def keyval_is_lower(keyval: int) -> bool

Returns true if the given key value is in lower case.

Parameters:

keyval — a key value.

keyval_is_upper¶

def keyval_is_upper(keyval: int) -> bool

Returns true if the given key value is in upper case.

Parameters:

keyval — a key value.

keyval_name¶

def keyval_name(keyval: int) -> str | None

Converts a key value into a symbolic name.

The names are the same as those in the gdk/gdkkeysyms.h header file but without the leading “GDK_KEY_”.

Parameters:

keyval — a key value

keyval_to_lower¶

def keyval_to_lower(keyval: int) -> int

Converts a key value to lower case, if applicable.

Parameters:

keyval — a key value.

keyval_to_unicode¶

def keyval_to_unicode(keyval: int) -> int

Converts from a GDK key symbol to the corresponding Unicode character.

Note that the conversion does not take the current locale into consideration, which might be expected for particular keyvals, such as GDK_KEY_KP_Decimal.

Parameters:

keyval — a GDK key symbol

keyval_to_upper¶

def keyval_to_upper(keyval: int) -> int

Converts a key value to upper case, if applicable.

Parameters:

keyval — a key value.

pixbuf_get_from_surface¶

def pixbuf_get_from_surface(surface: cairo.Surface, src_x: int, src_y: int, width: int, height: int) -> GdkPixbuf.Pixbuf | None

:::warning Deprecated since 4.12 This API is deprecated. :::

Transfers image data from a cairo_surface_t and converts it to a GdkPixbuf.

This allows you to efficiently read individual pixels from cairo surfaces.

This function will create an RGB pixbuf with 8 bits per channel. The pixbuf will contain an alpha channel if the surface contains one.

Parameters:

surface — surface to copy from
src_x — Source X coordinate within surface
src_y — Source Y coordinate within surface
width — Width in pixels of region to get
height — Height in pixels of region to get

pixbuf_get_from_texture¶

def pixbuf_get_from_texture(texture: Texture) -> GdkPixbuf.Pixbuf | None

:::warning Deprecated since 4.12 This API is deprecated. :::

Creates a new pixbuf from texture.

This should generally not be used in newly written code as later stages will almost certainly convert the pixbuf back into a texture to draw it on screen.

Parameters:

texture — a GdkTexture

set_allowed_backends¶

def set_allowed_backends(backends: str) -> None

Sets a list of backends that GDK should try to use.

This can be useful if your application does not work with certain GDK backends.

By default, GDK tries all included backends.

For example:

gdk_set_allowed_backends ("wayland,macos,*");

instructs GDK to try the Wayland backend first, followed by the MacOs backend, and then all others.

If the GDK_BACKEND environment variable is set, it determines what backends are tried in what order, while still respecting the set of allowed backends that are specified by this function.

The possible backend names are:

broadway
macos
wayland.
win32
x11

You can also include a * in the list to try all remaining backends.

This call must happen prior to functions that open a display, such as Display.open, gtk_init(), or gtk_init_check() in order to take effect.

Parameters:

backends — a comma-separated list of backends

unicode_to_keyval¶

def unicode_to_keyval(wc: int) -> int

Converts from a Unicode character to a key symbol.

Parameters:

wc — a Unicode character

Enumerations¶

AnchorHints¶

Bit flags.

FLIP_X = 1 — allow flipping anchors horizontally
FLIP_Y = 2 — allow flipping anchors vertically
SLIDE_X = 4 — allow sliding surface horizontally
SLIDE_Y = 8 — allow sliding surface vertically
RESIZE_X = 16 — allow resizing surface horizontally
RESIZE_Y = 32 — allow resizing surface vertically
FLIP = 3 — allow flipping anchors on both axes
SLIDE = 12 — allow sliding surface on both axes
RESIZE = 48 — allow resizing surface on both axes

AxisFlags¶

Bit flags.

X = 2 — X axis is present
Y = 4 — Y axis is present
DELTA_X = 8 — Scroll X delta axis is present
DELTA_Y = 16 — Scroll Y delta axis is present
PRESSURE = 32 — Pressure axis is present
XTILT = 64 — X tilt axis is present
YTILT = 128 — Y tilt axis is present
WHEEL = 256 — Wheel axis is present
DISTANCE = 512 — Distance axis is present
ROTATION = 1024 — Z-axis rotation is present
SLIDER = 2048 — Slider axis is present

AxisUse¶

Enumeration.

IGNORE = 0 — the axis is ignored.
X = 1 — the axis is used as the x axis.
Y = 2 — the axis is used as the y axis.
DELTA_X = 3 — the axis is used as the scroll x delta
DELTA_Y = 4 — the axis is used as the scroll y delta
PRESSURE = 5 — the axis is used for pressure information.
XTILT = 6 — the axis is used for x tilt information.
YTILT = 7 — the axis is used for y tilt information.
WHEEL = 8 — the axis is used for wheel information.
DISTANCE = 9 — the axis is used for pen/tablet distance information
ROTATION = 10 — the axis is used for pen rotation information
SLIDER = 11 — the axis is used for pen slider information
LAST = 12 — a constant equal to the numerically highest axis value.

CicpRange¶

Enumeration.

NARROW = 0 — The values use the range of 16-235 (for Y) and 16-240 for u and v.
FULL = 1 — The values use the full range.

ColorChannel¶

Enumeration.

RED = 0 — The red color channel, aka 0
GREEN = 1 — The green color channel, aka 1
BLUE = 2 — The blue color channel, aka 2
ALPHA = 3 — The alpha color channel, aka 3

CrossingMode¶

Enumeration.

NORMAL = 0 — crossing because of pointer motion.
GRAB = 1 — crossing because a grab is activated.
UNGRAB = 2 — crossing because a grab is deactivated.
GTK_GRAB = 3 — crossing because a GTK grab is activated.
GTK_UNGRAB = 4 — crossing because a GTK grab is deactivated.
STATE_CHANGED = 5 — crossing because a GTK widget changed state (e.g. sensitivity).
TOUCH_BEGIN = 6 — crossing because a touch sequence has begun, this event is synthetic as the pointer might have not left the surface.
TOUCH_END = 7 — crossing because a touch sequence has ended, this event is synthetic as the pointer might have not left the surface.
DEVICE_SWITCH = 8 — crossing because of a device switch (i.e. a mouse taking control of the pointer after a touch device), this event is synthetic as the pointer didn’t leave the surface.

DevicePadFeature¶

Enumeration.

BUTTON = 0 — a button
RING = 1 — a ring-shaped interactive area
STRIP = 2 — a straight interactive area

DeviceToolType¶

Enumeration.

UNKNOWN = 0 — Tool is of an unknown type.
PEN = 1 — Tool is a standard tablet stylus.
ERASER = 2 — Tool is standard tablet eraser.
BRUSH = 3 — Tool is a brush stylus.
PENCIL = 4 — Tool is a pencil stylus.
AIRBRUSH = 5 — Tool is an airbrush stylus.
MOUSE = 6 — Tool is a mouse.
LENS = 7 — Tool is a lens cursor.

DmabufError¶

Enumeration.

NOT_AVAILABLE = 0 — Dmabuf support is not available, because the OS is not Linux, or it was explicitly disabled at compile- or runtime
UNSUPPORTED_FORMAT = 1 — The requested format is not supported
CREATION_FAILED = 2 — GTK failed to create the resource for other reasons

DragAction¶

Bit flags.

NONE = 0 — No action.
COPY = 1 — Copy the data.
MOVE = 2 — Move the data, i.e. first copy it, then delete it from the source using the DELETE target of the X selection protocol.
LINK = 4 — Add a link to the data. Note that this is only useful if source and destination agree on what it means, and is not supported on all platforms.
ASK = 8 — Ask the user what to do with the data.

DragCancelReason¶

Enumeration.

NO_TARGET = 0 — There is no suitable drop target.
USER_CANCELLED = 1 — Drag cancelled by the user
ERROR = 2 — Unspecified error.

EventType¶

Enumeration.

DELETE = 0 — the window manager has requested that the toplevel surface be hidden or destroyed, usually when the user clicks on a special icon in the title bar.
MOTION_NOTIFY = 1 — the pointer (usually a mouse) has moved.
BUTTON_PRESS = 2 — a mouse button has been pressed.
BUTTON_RELEASE = 3 — a mouse button has been released.
KEY_PRESS = 4 — a key has been pressed.
KEY_RELEASE = 5 — a key has been released.
ENTER_NOTIFY = 6 — the pointer has entered the surface.
LEAVE_NOTIFY = 7 — the pointer has left the surface.
FOCUS_CHANGE = 8 — the keyboard focus has entered or left the surface.
PROXIMITY_IN = 9 — an input device has moved into contact with a sensing surface (e.g. a touchscreen or graphics tablet).
PROXIMITY_OUT = 10 — an input device has moved out of contact with a sensing surface.
DRAG_ENTER = 11 — the mouse has entered the surface while a drag is in progress.
DRAG_LEAVE = 12 — the mouse has left the surface while a drag is in progress.
DRAG_MOTION = 13 — the mouse has moved in the surface while a drag is in progress.
DROP_START = 14 — a drop operation onto the surface has started.
SCROLL = 15 — the scroll wheel was turned
GRAB_BROKEN = 16 — a pointer or keyboard grab was broken.
TOUCH_BEGIN = 17 — A new touch event sequence has just started.
TOUCH_UPDATE = 18 — A touch event sequence has been updated.
TOUCH_END = 19 — A touch event sequence has finished.
TOUCH_CANCEL = 20 — A touch event sequence has been canceled.
TOUCHPAD_SWIPE = 21 — A touchpad swipe gesture event, the current state is determined by its phase field.
TOUCHPAD_PINCH = 22 — A touchpad pinch gesture event, the current state is determined by its phase field.
PAD_BUTTON_PRESS = 23 — A tablet pad button press event.
PAD_BUTTON_RELEASE = 24 — A tablet pad button release event.
PAD_RING = 25 — A tablet pad axis event from a "ring".
PAD_STRIP = 26 — A tablet pad axis event from a "strip".
PAD_GROUP_MODE = 27 — A tablet pad group mode change.
TOUCHPAD_HOLD = 28 — A touchpad hold gesture event, the current state is determined by its phase field.
PAD_DIAL = 29 — A tablet pad axis event from a "dial".
EVENT_LAST = 30 — marks the end of the GdkEventType enumeration.

FrameClockPhase¶

Bit flags.

NONE = 0 — no phase
FLUSH_EVENTS = 1 — corresponds to GdkFrameClock::flush-events. Should not be handled by applications.
BEFORE_PAINT = 2 — corresponds to GdkFrameClock::before-paint. Should not be handled by applications.
UPDATE = 4 — corresponds to GdkFrameClock::update.
LAYOUT = 8 — corresponds to GdkFrameClock::layout. Should not be handled by applications.
PAINT = 16 — corresponds to GdkFrameClock::paint.
RESUME_EVENTS = 32 — corresponds to GdkFrameClock::resume-events. Should not be handled by applications.
AFTER_PAINT = 64 — corresponds to GdkFrameClock::after-paint. Should not be handled by applications.

FullscreenMode¶

Enumeration.

CURRENT_MONITOR = 0 — Fullscreen on current monitor only.
ALL_MONITORS = 1 — Span across all monitors when fullscreen.

GLAPI¶

Bit flags.

GL = 1 — The OpenGL API
GLES = 2 — The OpenGL ES API

GLError¶

Enumeration.

NOT_AVAILABLE = 0 — OpenGL support is not available
UNSUPPORTED_FORMAT = 1 — The requested visual format is not supported
UNSUPPORTED_PROFILE = 2 — The requested profile is not supported
COMPILATION_FAILED = 3 — The shader compilation failed
LINK_FAILED = 4 — The shader linking failed

Gravity¶

Enumeration.

NORTH_WEST = 1 — the reference point is at the top left corner.
NORTH = 2 — the reference point is in the middle of the top edge.
NORTH_EAST = 3 — the reference point is at the top right corner.
WEST = 4 — the reference point is at the middle of the left edge.
CENTER = 5 — the reference point is at the center of the surface.
EAST = 6 — the reference point is at the middle of the right edge.
SOUTH_WEST = 7 — the reference point is at the lower left corner.
SOUTH = 8 — the reference point is at the middle of the lower edge.
SOUTH_EAST = 9 — the reference point is at the lower right corner.
STATIC = 10 — the reference point is at the top left corner of the surface itself, ignoring window manager decorations.

InputSource¶

Enumeration.

MOUSE = 0 — the device is a mouse. (This will be reported for the core pointer, even if it is something else, such as a trackball.)
PEN = 1 — the device is a stylus of a graphics tablet or similar device.
KEYBOARD = 2 — the device is a keyboard.
TOUCHSCREEN = 3 — the device is a direct-input touch device, such as a touchscreen or tablet
TOUCHPAD = 4 — the device is an indirect touch device, such as a touchpad
TRACKPOINT = 5 — the device is a trackpoint
TABLET_PAD = 6 — the device is a "pad", a collection of buttons, rings and strips found in drawing tablets

KeyMatch¶

Enumeration.

NONE = 0 — The key event does not match
PARTIAL = 1 — The key event matches if keyboard state (specifically, the currently active group) is ignored
EXACT = 2 — The key event matches

MemoryFormat¶

Enumeration.

B8G8R8A8_PREMULTIPLIED = 0 — 4 bytes; for blue, green, red, alpha. The color values are premultiplied with the alpha value.
A8R8G8B8_PREMULTIPLIED = 1 — 4 bytes; for alpha, red, green, blue. The color values are premultiplied with the alpha value.
R8G8B8A8_PREMULTIPLIED = 2 — 4 bytes; for red, green, blue, alpha The color values are premultiplied with the alpha value.
B8G8R8A8 = 3 — 4 bytes; for blue, green, red, alpha.
A8R8G8B8 = 4 — 4 bytes; for alpha, red, green, blue.
R8G8B8A8 = 5 — 4 bytes; for red, green, blue, alpha.
A8B8G8R8 = 6 — 4 bytes; for alpha, blue, green, red.
R8G8B8 = 7 — 3 bytes; for red, green, blue. The data is opaque.
B8G8R8 = 8 — 3 bytes; for blue, green, red. The data is opaque.
R16G16B16 = 9 — 3 guint16 values; for red, green, blue.
R16G16B16A16_PREMULTIPLIED = 10 — 4 guint16 values; for red, green, blue, alpha. The color values are premultiplied with the alpha value.
R16G16B16A16 = 11 — 4 guint16 values; for red, green, blue, alpha.
R16G16B16_FLOAT = 12 — 3 half-float values; for red, green, blue. The data is opaque.
R16G16B16A16_FLOAT_PREMULTIPLIED = 13 — 4 half-float values; for red, green, blue and alpha. The color values are premultiplied with the alpha value.
R16G16B16A16_FLOAT = 14 — 4 half-float values; for red, green, blue and alpha.
R32G32B32_FLOAT = 15 — 3 float values; for red, green, blue.
R32G32B32A32_FLOAT_PREMULTIPLIED = 16 — 4 float values; for red, green, blue and alpha. The color values are premultiplied with the alpha value.
R32G32B32A32_FLOAT = 17 — 4 float values; for red, green, blue and alpha.
G8A8_PREMULTIPLIED = 18 — 2 bytes; for grayscale, alpha. The color values are premultiplied with the alpha value.
G8A8 = 19 — 2 bytes; for grayscale, alpha.
G8 = 20 — One byte; for grayscale. The data is opaque.
G16A16_PREMULTIPLIED = 21 — 2 guint16 values; for grayscale, alpha. The color values are premultiplied with the alpha value.
G16A16 = 22 — 2 guint16 values; for grayscale, alpha.
G16 = 23 — One guint16 value; for grayscale. The data is opaque.
A8 = 24 — One byte; for alpha.
A16 = 25 — One guint16 value; for alpha.
A16_FLOAT = 26 — One half-float value; for alpha.
A32_FLOAT = 27 — One float value; for alpha.
A8B8G8R8_PREMULTIPLIED = 28 — 4 bytes; for alpha, blue, green, red, The color values are premultiplied with the alpha value.
B8G8R8X8 = 29 — 4 bytes; for blue, green, red, unused.
X8R8G8B8 = 30 — 4 bytes; for unused, red, green, blue.
R8G8B8X8 = 31 — 4 bytes; for red, green, blue, unused.
X8B8G8R8 = 32 — 4 bytes; for unused, blue, green, red.
G8_B8R8_420 = 33 — Multiplane format with 2 planes. The first plane contains the first channel, usually containing luma values. The second plane with interleaved chroma values, Cb followed by Cr. Subsampled in both the X and Y direction. Commonly known by the fourcc "NV12".
G8_R8B8_420 = 34 — Multiplane format with 2 planes. The first plane contains the first channel, usually containing luma values. The second plane with interleaved chroma values, Cr followed by Cb. Subsampled in both the X and Y direction. Commonly known by the fourcc "NV21".
G8_B8R8_422 = 35 — Multiplane format with 2 planes. The first plane contains the first channel, usually containing luma values. The second plane with interleaved chroma values, Cb followed by Cr. Subsampled in the X direction. Commonly known by the fourcc "NV16".
G8_R8B8_422 = 36 — Multiplane format with 2 planes. The first plane contains the first channel, usually containing luma values. The second plane with interleaved chroma values, Cr followed by Cb. Subsampled in the X direction. Commonly known by the fourcc "NV61".
G8_B8R8_444 = 37 — Multiplane format with 2 planes. The first plane contains the first channel, usually containing luma values. The second plane with interleaved chroma values, Cb followed by Cr. This format is not subsampled. Commonly known by the fourcc "NV24".
G8_R8B8_444 = 38 — Multiplane format with 2 planes. The first plane contains the first channel, usually containing luma values. The second plane with interleaved chroma values, Cr followed by Cb. This format is not subsampled. Commonly known by the fourcc "NV42".
G10X6_B10X6R10X6_420 = 39 — Multiplane format with 2 planes. Each channel is a 16 bit integer, but only the highest 10 bits are used. The first plane contains the first channel, usually containing luma values. The second plane with interleaved chroma values, Cr followed by Cb. This format is not subsampled. Commonly known by the fourcc "P010".
G12X4_B12X4R12X4_420 = 40 — Multiplane format with 2 planes. Each channel is a 16 bit integer, but only the highest 10 bits are used. The first plane contains the first channel, usually containing luma values. The second plane with interleaved chroma values, Cr followed by Cb. This format is not subsampled. Commonly known by the fourcc "P012".
G16_B16R16_420 = 41 — Multiplane format with 2 planes. Each channel is a 16 bit integer. The first plane contains the first channel, usually containing luma values. The second plane with interleaved chroma values, Cr followed by Cb. This format is not subsampled. Commonly known by the fourcc "P016".
G8_B8_R8_410 = 42 — Multiplane format with 3 planes. Each channel is a 8 bit integer. The first plane usually contains the luma channel. It is mapped into the 2nd channel. The second plane usually contains the first chroma chanel. Subsampled in both the X and Y direction with 4:1 ratio. It is mapped into the 3rd channel. The third plane usually contains the second chroma channel. Subsampled in both the X and Y direction with 4:1 ratio. It is mapped into the 1st channel. Commonly known by the fourcc "YUV410".
G8_R8_B8_410 = 43 — Multiplane format with 3 planes. Each channel is a 8 bit integer. The first plane usually contains the luma channel. It is mapped into the 2nd channel. The second plane usually contains the second chroma chanel. Subsampled in both the X and Y direction with 4:1 ratio. It is mapped into the 1st channel. The third plane usually contains the first chroma channel. Subsampled in both the X and Y direction with 4:1 ratio. It is mapped into the 3rd channel. Commonly known by the fourcc "YVU410".
G8_B8_R8_411 = 44 — Multiplane format with 3 planes. Each channel is a 8 bit integer. The first plane usually contains the luma channel. It is mapped into the 2nd channel. The second plane usually contains the first chroma chanel. Subsampled in the X direction with 4:1 ratio. It is mapped into the 3rd channel. The third plane usually contains the second chroma channel. Subsampled in the X direction with 4:1 ratio. It is mapped into the 1st channel. Commonly known by the fourcc "YUV411".
G8_R8_B8_411 = 45 — Multiplane format with 3 planes. Each channel is a 8 bit integer. The first plane usually contains the luma channel. It is mapped into the 2nd channel. The second plane usually contains the second chroma chanel. Subsampled in the X direction with 4:1 ratio. It is mapped into the 1st channel. The third plane usually contains the first chroma channel. Subsampled in the X direction with 4:1 ratio. It is mapped into the 3rd channel. Commonly known by the fourcc "YVU411".
G8_B8_R8_420 = 46 — Multiplane format with 3 planes. Each channel is a 8 bit integer. The first plane usually contains the luma channel. It is mapped into the 2nd channel. The second plane usually contains the first chroma chanel. Subsampled in both the X and Y direction. It is mapped into the 3rd channel. The third plane usually contains the second chroma channel. Subsampled in both the X and Y direction. It is mapped into the 1st channel. Commonly known by the fourcc "YUV420".
G8_R8_B8_420 = 47 — Multiplane format with 3 planes. Each channel is a 8 bit integer. The first plane usually contains the luma channel. It is mapped into the 2nd channel. The second plane usually contains the second chroma chanel. Subsampled in both the X and Y direction. It is mapped into the 1st channel. The third plane usually contains the first chroma channel. Subsampled in both the X and Y direction. It is mapped into the 3rd channel. Commonly known by the fourcc "YVU420".
G8_B8_R8_422 = 48 — Multiplane format with 3 planes. Each channel is a 8 bit integer. The first plane usually contains the luma channel. It is mapped into the 2nd channel. The second plane usually contains the first chroma chanel. Subsampled in the X direction. It is mapped into the 3rd channel. The third plane usually contains the second chroma channel. Subsampled in the X direction. It is mapped into the 1st channel. Commonly known by the fourcc "YUV422".
G8_R8_B8_422 = 49 — Multiplane format with 3 planes. Each channel is a 8 bit integer. The first plane usually contains the luma channel. It is mapped into the 2nd channel. The second plane usually contains the second chroma chanel. Subsampled in the X direction. It is mapped into the 1st channel. The third plane usually contains the first chroma channel. Subsampled in the X direction. It is mapped into the 3rd channel. Commonly known by the fourcc "YVU422".
G8_B8_R8_444 = 50 — Multiplane format with 3 planes. Each channel is a 8 bit integer. The first plane usually contains the luma channel. It is mapped into the 2nd channel. The second plane usually contains the first chroma chanel. It is mapped into the 3rd channel. The third plane usually contains the second chroma channel. It is mapped into the 1st channel. Commonly known by the fourcc "YUV444".
G8_R8_B8_444 = 51 — Multiplane format with 3 planes. Each channel is a 8 bit integer. The first plane usually contains the luma channel. It is mapped into the 2nd channel. The second plane usually contains the second chroma chanel. Subsampled in the X direction. It is mapped into the 1st channel. The third plane usually contains the first chroma channel. Subsampled in the X direction. It is mapped into the 3rd channel. Commonly known by the fourcc "YVU444".
G8B8G8R8_422 = 52 — Packed format with subsampled channels. Each channel is a 8 bit integer. The red and blue/chroma channels are subsampled and interleaved with the green/luma channel. Each block contains 2 pixels, so the width must be a multiple of 2. Commonly known by the fourcc "YUYV".
G8R8G8B8_422 = 53 — Packed format with subsampled channels. Each channel is a 8 bit integer. The red and blue/chroma channels are subsampled and interleaved with the green/luma channel. Each block contains 2 pixels, so the width must be a multiple of 2. Commonly known by the fourcc "YVYU".
R8G8B8G8_422 = 54 — Packed format with subsampled channels. Each channel is a 8 bit integer. The red and blue/chroma channels are subsampled and interleaved with the green/luma channel. Each block contains 2 pixels, so the width must be a multiple of 2. Commonly known by the fourcc "VYUY".
B8G8R8G8_422 = 55 — Packed format with subsampled channels. Each channel is a 8 bit integer. The red and blue/chroma channels are subsampled and interleaved with the green/luma channel. Each block contains 2 pixels, so the width must be a multiple of 2. Commonly known by the fourcc "UYVY".
X6G10_X6B10_X6R10_420 = 56 — Multiplane format with 3 planes. Each channel is a 16 bit integer. Only the 10 lower bits are used. The remaining ones must be set to 0 by the producer. The first plane usually contains the luma channel. It is mapped into the 2nd channel. The second plane usually contains the first chroma chanel. Subsampled in both the X and Y direction. It is mapped into the 3rd channel. The third plane usually contains the second chroma channel. Subsampled in both the X and Y direction. It is mapped into the 1st channel. Commonly known by the fourcc "S010".
X6G10_X6B10_X6R10_422 = 57 — Multiplane format with 3 planes. Each channel is a 16 bit integer. Only the 10 lower bits are used. The remaining ones must be set to 0 by the producer. The first plane usually contains the luma channel. It is mapped into the 2nd channel. The second plane usually contains the first chroma chanel. Subsampled in the X direction. It is mapped into the 3rd channel. The third plane usually contains the second chroma channel. Subsampled in the X direction. It is mapped into the 1st channel. Commonly known by the fourcc "S210".
X6G10_X6B10_X6R10_444 = 58 — Multiplane format with 3 planes. Each channel is a 16 bit integer. Only the 10 lower bits are used. The remaining ones must be set to 0 by the producer. The first plane usually contains the luma channel. It is mapped into the 2nd channel. The second plane usually contains the first chroma chanel. It is mapped into the 3rd channel. The third plane usually contains the second chroma channel. It is mapped into the 1st channel. Commonly known by the fourcc "S410".
X4G12_X4B12_X4R12_420 = 59 — Multiplane format with 3 planes. Each channel is a 16 bit integer. Only the 12 lower bits are used. The remaining ones must be set to 0 by the producer. The first plane usually contains the luma channel. It is mapped into the 2nd channel. The second plane usually contains the first chroma chanel. Subsampled in both the X and Y direction. It is mapped into the 3rd channel. The third plane usually contains the second chroma channel. Subsampled in both the X and Y direction. It is mapped into the 1st channel. Commonly known by the fourcc "S012".
X4G12_X4B12_X4R12_422 = 60 — Multiplane format with 3 planes. Each channel is a 16 bit integer. Only the 12 lower bits are used. The remaining ones must be set to 0 by the producer. The first plane usually contains the luma channel. It is mapped into the 2nd channel. The second plane usually contains the first chroma chanel. Subsampled in the X direction. It is mapped into the 3rd channel. The third plane usually contains the second chroma channel. Subsampled in the X direction. It is mapped into the 1st channel. Commonly known by the fourcc "S212".
X4G12_X4B12_X4R12_444 = 61 — Multiplane format with 3 planes. Each channel is a 16 bit integer. Only the 12 lower bits are used. The remaining ones must be set to 0 by the producer. The first plane usually contains the luma channel. It is mapped into the 2nd channel. The second plane usually contains the first chroma chanel. It is mapped into the 3rd channel. The third plane usually contains the second chroma channel. It is mapped into the 1st channel. Commonly known by the fourcc "S412".
G16_B16_R16_420 = 62 — Multiplane format with 3 planes. Each channel is a 16 bit integer. The first plane usually contains the luma channel. It is mapped into the 2nd channel. The second plane usually contains the first chroma chanel. Subsampled in both the X and Y direction. It is mapped into the 3rd channel. The third plane usually contains the second chroma channel. Subsampled in both the X and Y direction. It is mapped into the 1st channel. Commonly known by the fourcc "S016".
G16_B16_R16_422 = 63 — Multiplane format with 3 planes. Each channel is a 16 bit integer. The first plane usually contains the luma channel. It is mapped into the 2nd channel. The second plane usually contains the first chroma chanel. Subsampled in the X direction. It is mapped into the 3rd channel. The third plane usually contains the second chroma channel. Subsampled in the X direction. It is mapped into the 1st channel. Commonly known by the fourcc "S216".
G16_B16_R16_444 = 64 — Multiplane format with 3 planes. Each channel is a 16 bit integer. The first plane usually contains the luma channel. It is mapped into the 2nd channel. The second plane usually contains the first chroma chanel. It is mapped into the 3rd channel. The third plane usually contains the second chroma channel. It is mapped into the 1st channel. Commonly known by the fourcc "S416".
N_FORMATS = 65 — The number of formats. This value will change as more formats get added, so do not rely on its concrete integer.

ModifierType¶

Bit flags.

NO_MODIFIER_MASK = 0 — No modifier.
SHIFT_MASK = 1 — the Shift key.
LOCK_MASK = 2 — a Lock key (depending on the Windowing System configuration, this may either be <kbd>CapsLock</kbd> or <kbd>ShiftLock</kbd>).
CONTROL_MASK = 4 — the Control key.
ALT_MASK = 8 — the fourth modifier key (it depends on the Windowing System configuration which key is interpreted as this modifier, but normally it is the <kbd>Alt</kbd> key).
BUTTON1_MASK = 256 — the first mouse button.
BUTTON2_MASK = 512 — the second mouse button.
BUTTON3_MASK = 1024 — the third mouse button.
BUTTON4_MASK = 2048 — the fourth mouse button.
BUTTON5_MASK = 4096 — the fifth mouse button.
SUPER_MASK = 67108864 — the Super modifier.
HYPER_MASK = 134217728 — the Hyper modifier.
META_MASK = 268435456 — the Meta modifier. Maps to Command on macOS.

NotifyType¶

Enumeration.

ANCESTOR = 0 — the surface is entered from an ancestor or left towards an ancestor.
VIRTUAL = 1 — the pointer moves between an ancestor and an inferior of the surface.
INFERIOR = 2 — the surface is entered from an inferior or left towards an inferior.
NONLINEAR = 3 — the surface is entered from or left towards a surface which is neither an ancestor nor an inferior.
NONLINEAR_VIRTUAL = 4 — the pointer moves between two surfaces which are not ancestors of each other and the surface is part of the ancestor chain between one of these surfaces and their least common ancestor.
UNKNOWN = 5 — an unknown type of enter/leave event occurred.

PaintableFlags¶

Bit flags.

STATIC_SIZE = 1 — The size is immutable. The Paintable.invalidate-size signal will never be emitted.
STATIC_CONTENTS = 2 — The content is immutable. The Paintable.invalidate-contents signal will never be emitted.

ScrollDirection¶

Enumeration.

UP = 0 — the surface is scrolled up.
DOWN = 1 — the surface is scrolled down.
LEFT = 2 — the surface is scrolled to the left.
RIGHT = 3 — the surface is scrolled to the right.
SMOOTH = 4 — the scrolling is determined by the delta values in scroll events. See ScrollEvent.get_deltas

ScrollRelativeDirection¶

Enumeration.

IDENTICAL = 0 — Physical motion and event motion are the same
INVERTED = 1 — Physical motion is inverted relative to event motion
UNKNOWN = 2 — Relative motion is unknown on this device or backend

ScrollUnit¶

Enumeration.

WHEEL = 0 — The delta is in number of wheel clicks.
SURFACE = 1 — The delta is in surface pixels to scroll directly on screen.

SeatCapabilities¶

Bit flags.

NONE = 0 — No input capabilities
POINTER = 1 — The seat has a pointer (e.g. mouse)
TOUCH = 2 — The seat has touchscreen(s) attached
TABLET_STYLUS = 4 — The seat has drawing tablet(s) attached
KEYBOARD = 8 — The seat has keyboard(s) attached
TABLET_PAD = 16 — The seat has drawing tablet pad(s) attached
ALL_POINTING = 7 — The union of all pointing capabilities
ALL = 31 — The union of all capabilities

SubpixelLayout¶

Enumeration.

UNKNOWN = 0 — The layout is not known
NONE = 1 — Not organized in this way
HORIZONTAL_RGB = 2 — The layout is horizontal, the order is RGB
HORIZONTAL_BGR = 3 — The layout is horizontal, the order is BGR
VERTICAL_RGB = 4 — The layout is vertical, the order is RGB
VERTICAL_BGR = 5 — The layout is vertical, the order is BGR

SurfaceEdge¶

Enumeration.

NORTH_WEST = 0 — the top left corner.
NORTH = 1 — the top edge.
NORTH_EAST = 2 — the top right corner.
WEST = 3 — the left edge.
EAST = 4 — the right edge.
SOUTH_WEST = 5 — the lower left corner.
SOUTH = 6 — the lower edge.
SOUTH_EAST = 7 — the lower right corner.

TextureError¶

Enumeration.

TOO_LARGE = 0 — Not enough memory to handle this image
CORRUPT_IMAGE = 1 — The image data appears corrupted
UNSUPPORTED_CONTENT = 2 — The image contains features that cannot be loaded
UNSUPPORTED_FORMAT = 3 — The image format is not supported

TitlebarGesture¶

Enumeration.

DOUBLE_CLICK = 1 — double click gesture
RIGHT_CLICK = 2 — right click gesture
MIDDLE_CLICK = 3 — middle click gesture

ToplevelCapabilities¶

Bit flags.

EDGE_CONSTRAINTS = 1 — Whether tiled window states are supported.
INHIBIT_SHORTCUTS = 2 — Whether inhibiting system shortcuts is supported. See Toplevel.inhibit_system_shortcuts.
TITLEBAR_GESTURES = 4 — Whether titlebar gestures are supported. See Toplevel.titlebar_gesture.
WINDOW_MENU = 8 — Whether showing the window menu is supported. See Toplevel.show_window_menu.
MAXIMIZE = 16 — Whether the toplevel can be maximized.
FULLSCREEN = 32 — Whether the toplevel can be made fullscreen.
MINIMIZE = 64 — Whether the toplevel can be minimized. See Toplevel.minimize.
LOWER = 128 — Whether the toplevel can be lowered. See Toplevel.lower.

ToplevelState¶

Bit flags.

MINIMIZED = 1 — the surface is minimized
MAXIMIZED = 2 — the surface is maximized
STICKY = 4 — the surface is sticky
FULLSCREEN = 8 — the surface is maximized without decorations
ABOVE = 16 — the surface is kept above other surfaces
BELOW = 32 — the surface is kept below other surfaces
FOCUSED = 64 — the surface is presented as focused (with active decorations)
TILED = 128 — the surface is in a tiled state
TOP_TILED = 256 — whether the top edge is tiled
TOP_RESIZABLE = 512 — whether the top edge is resizable
RIGHT_TILED = 1024 — whether the right edge is tiled
RIGHT_RESIZABLE = 2048 — whether the right edge is resizable
BOTTOM_TILED = 4096 — whether the bottom edge is tiled
BOTTOM_RESIZABLE = 8192 — whether the bottom edge is resizable
LEFT_TILED = 16384 — whether the left edge is tiled
LEFT_RESIZABLE = 32768 — whether the left edge is resizable
SUSPENDED = 65536 — The surface is not visible to the user.

TouchpadGesturePhase¶

Enumeration.

BEGIN = 0 — The gesture has begun.
UPDATE = 1 — The gesture has been updated.
END = 2 — The gesture was finished, changes should be permanently applied.
CANCEL = 3 — The gesture was cancelled, all changes should be undone.

VulkanError¶

Enumeration.

UNSUPPORTED = 0 — Vulkan is not supported on this backend or has not been compiled in.
NOT_AVAILABLE = 1 — Vulkan support is not available on this Surface

Constants¶

ACTION_ALL¶

ACTION_ALL: int

Defines all possible DND actions.

This can be used in Drop.status messages when any drop can be accepted or a more specific drop method is not yet known.

BUTTON_MIDDLE¶

BUTTON_MIDDLE: int

The middle button.

BUTTON_PRIMARY¶

BUTTON_PRIMARY: int

The primary button. This is typically the left mouse button, or the right button in a left-handed setup.

BUTTON_SECONDARY¶

BUTTON_SECONDARY: int

The secondary button. This is typically the right mouse button, or the left button in a left-handed setup.

CURRENT_TIME¶

CURRENT_TIME: int

Represents the current time, and can be used anywhere a time is expected.

EVENT_PROPAGATE¶

EVENT_PROPAGATE: bool

Use this macro as the return value for continuing the propagation of an event handler.

EVENT_STOP¶

EVENT_STOP: bool

Use this macro as the return value for stopping the propagation of an event handler.

KEY_0¶

KEY_0: int

KEY_1¶

KEY_1: int

KEY_10ChannelsDown¶

KEY_10ChannelsDown: int

KEY_10ChannelsUp¶

KEY_10ChannelsUp: int

KEY_2¶

KEY_2: int

KEY_3¶

KEY_3: int

KEY_3270_AltCursor¶

KEY_3270_AltCursor: int

KEY_3270_Attn¶

KEY_3270_Attn: int

KEY_3270_BackTab¶

KEY_3270_BackTab: int

KEY_3270_ChangeScreen¶

KEY_3270_ChangeScreen: int

KEY_3270_Copy¶

KEY_3270_Copy: int

KEY_3270_CursorBlink¶

KEY_3270_CursorBlink: int

KEY_3270_CursorSelect¶

KEY_3270_CursorSelect: int

KEY_3270_DeleteWord¶

KEY_3270_DeleteWord: int

KEY_3270_Duplicate¶

KEY_3270_Duplicate: int

KEY_3270_Enter¶

KEY_3270_Enter: int

KEY_3270_EraseEOF¶

KEY_3270_EraseEOF: int

KEY_3270_EraseInput¶

KEY_3270_EraseInput: int

KEY_3270_ExSelect¶

KEY_3270_ExSelect: int

KEY_3270_FieldMark¶

KEY_3270_FieldMark: int

KEY_3270_Ident¶

KEY_3270_Ident: int

KEY_3270_Jump¶

KEY_3270_Jump: int

KEY_3270_KeyClick¶

KEY_3270_KeyClick: int

KEY_3270_Left2¶

KEY_3270_Left2: int

KEY_3270_PA1¶

KEY_3270_PA1: int

KEY_3270_PA2¶

KEY_3270_PA2: int

KEY_3270_PA3¶

KEY_3270_PA3: int

KEY_3270_Play¶

KEY_3270_Play: int

KEY_3270_PrintScreen¶

KEY_3270_PrintScreen: int

KEY_3270_Quit¶

KEY_3270_Quit: int

KEY_3270_Record¶

KEY_3270_Record: int

KEY_3270_Reset¶

KEY_3270_Reset: int

KEY_3270_Right2¶

KEY_3270_Right2: int

KEY_3270_Rule¶

KEY_3270_Rule: int

KEY_3270_Setup¶

KEY_3270_Setup: int

KEY_3270_Test¶

KEY_3270_Test: int

KEY_3DMode¶

KEY_3DMode: int

KEY_4¶

KEY_4: int

KEY_5¶

KEY_5: int

KEY_6¶

KEY_6: int

KEY_7¶

KEY_7: int

KEY_8¶

KEY_8: int

KEY_9¶

KEY_9: int

KEY_A¶

KEY_A: int

KEY_AE¶

KEY_AE: int

KEY_ALSToggle¶

KEY_ALSToggle: int

KEY_Aacute¶

KEY_Aacute: int

KEY_Abelowdot¶

KEY_Abelowdot: int

KEY_Abreve¶

KEY_Abreve: int

KEY_Abreveacute¶

KEY_Abreveacute: int

KEY_Abrevebelowdot¶

KEY_Abrevebelowdot: int

KEY_Abrevegrave¶

KEY_Abrevegrave: int

KEY_Abrevehook¶

KEY_Abrevehook: int

KEY_Abrevetilde¶

KEY_Abrevetilde: int

KEY_AccessX_Enable¶

KEY_AccessX_Enable: int

KEY_AccessX_Feedback_Enable¶

KEY_AccessX_Feedback_Enable: int

KEY_Accessibility¶

KEY_Accessibility: int

KEY_Acircumflex¶

KEY_Acircumflex: int

KEY_Acircumflexacute¶

KEY_Acircumflexacute: int

KEY_Acircumflexbelowdot¶

KEY_Acircumflexbelowdot: int

KEY_Acircumflexgrave¶

KEY_Acircumflexgrave: int

KEY_Acircumflexhook¶

KEY_Acircumflexhook: int

KEY_Acircumflextilde¶

KEY_Acircumflextilde: int

KEY_AddFavorite¶

KEY_AddFavorite: int

KEY_Addressbook¶

KEY_Addressbook: int

KEY_Adiaeresis¶

KEY_Adiaeresis: int

KEY_Agrave¶

KEY_Agrave: int

KEY_Ahook¶

KEY_Ahook: int

KEY_Alt_L¶

KEY_Alt_L: int

KEY_Alt_R¶

KEY_Alt_R: int

KEY_Amacron¶

KEY_Amacron: int

KEY_Aogonek¶

KEY_Aogonek: int

KEY_AppSelect¶

KEY_AppSelect: int

KEY_ApplicationLeft¶

KEY_ApplicationLeft: int

KEY_ApplicationRight¶

KEY_ApplicationRight: int

KEY_Arabic_0¶

KEY_Arabic_0: int

KEY_Arabic_1¶

KEY_Arabic_1: int

KEY_Arabic_2¶

KEY_Arabic_2: int

KEY_Arabic_3¶

KEY_Arabic_3: int

KEY_Arabic_4¶

KEY_Arabic_4: int

KEY_Arabic_5¶

KEY_Arabic_5: int

KEY_Arabic_6¶

KEY_Arabic_6: int

KEY_Arabic_7¶

KEY_Arabic_7: int

KEY_Arabic_8¶

KEY_Arabic_8: int

KEY_Arabic_9¶

KEY_Arabic_9: int

KEY_Arabic_ain¶

KEY_Arabic_ain: int

KEY_Arabic_alef¶

KEY_Arabic_alef: int

KEY_Arabic_alefmaksura¶

KEY_Arabic_alefmaksura: int

KEY_Arabic_beh¶

KEY_Arabic_beh: int

KEY_Arabic_comma¶

KEY_Arabic_comma: int

KEY_Arabic_dad¶

KEY_Arabic_dad: int

KEY_Arabic_dal¶

KEY_Arabic_dal: int

KEY_Arabic_damma¶

KEY_Arabic_damma: int

KEY_Arabic_dammatan¶

KEY_Arabic_dammatan: int

KEY_Arabic_ddal¶

KEY_Arabic_ddal: int

KEY_Arabic_farsi_yeh¶

KEY_Arabic_farsi_yeh: int

KEY_Arabic_fatha¶

KEY_Arabic_fatha: int

KEY_Arabic_fathatan¶

KEY_Arabic_fathatan: int

KEY_Arabic_feh¶

KEY_Arabic_feh: int

KEY_Arabic_fullstop¶

KEY_Arabic_fullstop: int

KEY_Arabic_gaf¶

KEY_Arabic_gaf: int

KEY_Arabic_ghain¶

KEY_Arabic_ghain: int

KEY_Arabic_ha¶

KEY_Arabic_ha: int

KEY_Arabic_hah¶

KEY_Arabic_hah: int

KEY_Arabic_hamza¶

KEY_Arabic_hamza: int

KEY_Arabic_hamza_above¶

KEY_Arabic_hamza_above: int

KEY_Arabic_hamza_below¶

KEY_Arabic_hamza_below: int

KEY_Arabic_hamzaonalef¶

KEY_Arabic_hamzaonalef: int

KEY_Arabic_hamzaonwaw¶

KEY_Arabic_hamzaonwaw: int

KEY_Arabic_hamzaonyeh¶

KEY_Arabic_hamzaonyeh: int

KEY_Arabic_hamzaunderalef¶

KEY_Arabic_hamzaunderalef: int

KEY_Arabic_heh¶

KEY_Arabic_heh: int

KEY_Arabic_heh_doachashmee¶

KEY_Arabic_heh_doachashmee: int

KEY_Arabic_heh_goal¶

KEY_Arabic_heh_goal: int

KEY_Arabic_jeem¶

KEY_Arabic_jeem: int

KEY_Arabic_jeh¶

KEY_Arabic_jeh: int

KEY_Arabic_kaf¶

KEY_Arabic_kaf: int

KEY_Arabic_kasra¶

KEY_Arabic_kasra: int

KEY_Arabic_kasratan¶

KEY_Arabic_kasratan: int

KEY_Arabic_keheh¶

KEY_Arabic_keheh: int

KEY_Arabic_khah¶

KEY_Arabic_khah: int

KEY_Arabic_lam¶

KEY_Arabic_lam: int

KEY_Arabic_madda_above¶

KEY_Arabic_madda_above: int

KEY_Arabic_maddaonalef¶

KEY_Arabic_maddaonalef: int

KEY_Arabic_meem¶

KEY_Arabic_meem: int

KEY_Arabic_noon¶

KEY_Arabic_noon: int

KEY_Arabic_noon_ghunna¶

KEY_Arabic_noon_ghunna: int

KEY_Arabic_peh¶

KEY_Arabic_peh: int

KEY_Arabic_percent¶

KEY_Arabic_percent: int

KEY_Arabic_qaf¶

KEY_Arabic_qaf: int

KEY_Arabic_question_mark¶

KEY_Arabic_question_mark: int

KEY_Arabic_ra¶

KEY_Arabic_ra: int

KEY_Arabic_rreh¶

KEY_Arabic_rreh: int

KEY_Arabic_sad¶

KEY_Arabic_sad: int

KEY_Arabic_seen¶

KEY_Arabic_seen: int

KEY_Arabic_semicolon¶

KEY_Arabic_semicolon: int

KEY_Arabic_shadda¶

KEY_Arabic_shadda: int

KEY_Arabic_sheen¶

KEY_Arabic_sheen: int

KEY_Arabic_sukun¶

KEY_Arabic_sukun: int

KEY_Arabic_superscript_alef¶

KEY_Arabic_superscript_alef: int

KEY_Arabic_switch¶

KEY_Arabic_switch: int

KEY_Arabic_tah¶

KEY_Arabic_tah: int

KEY_Arabic_tatweel¶

KEY_Arabic_tatweel: int

KEY_Arabic_tcheh¶

KEY_Arabic_tcheh: int

KEY_Arabic_teh¶

KEY_Arabic_teh: int

KEY_Arabic_tehmarbuta¶

KEY_Arabic_tehmarbuta: int

KEY_Arabic_thal¶

KEY_Arabic_thal: int

KEY_Arabic_theh¶

KEY_Arabic_theh: int

KEY_Arabic_tteh¶

KEY_Arabic_tteh: int

KEY_Arabic_veh¶

KEY_Arabic_veh: int

KEY_Arabic_waw¶

KEY_Arabic_waw: int

KEY_Arabic_yeh¶

KEY_Arabic_yeh: int

KEY_Arabic_yeh_baree¶

KEY_Arabic_yeh_baree: int

KEY_Arabic_zah¶

KEY_Arabic_zah: int

KEY_Arabic_zain¶

KEY_Arabic_zain: int

KEY_Aring¶

KEY_Aring: int

KEY_Armenian_AT¶

KEY_Armenian_AT: int

KEY_Armenian_AYB¶

KEY_Armenian_AYB: int

KEY_Armenian_BEN¶

KEY_Armenian_BEN: int

KEY_Armenian_CHA¶

KEY_Armenian_CHA: int

KEY_Armenian_DA¶

KEY_Armenian_DA: int

KEY_Armenian_DZA¶

KEY_Armenian_DZA: int

KEY_Armenian_E¶

KEY_Armenian_E: int

KEY_Armenian_FE¶

KEY_Armenian_FE: int

KEY_Armenian_GHAT¶

KEY_Armenian_GHAT: int

KEY_Armenian_GIM¶

KEY_Armenian_GIM: int

KEY_Armenian_HI¶

KEY_Armenian_HI: int

KEY_Armenian_HO¶

KEY_Armenian_HO: int

KEY_Armenian_INI¶

KEY_Armenian_INI: int

KEY_Armenian_JE¶

KEY_Armenian_JE: int

KEY_Armenian_KE¶

KEY_Armenian_KE: int

KEY_Armenian_KEN¶

KEY_Armenian_KEN: int

KEY_Armenian_KHE¶

KEY_Armenian_KHE: int

KEY_Armenian_LYUN¶

KEY_Armenian_LYUN: int

KEY_Armenian_MEN¶

KEY_Armenian_MEN: int

KEY_Armenian_NU¶

KEY_Armenian_NU: int

KEY_Armenian_O¶

KEY_Armenian_O: int

KEY_Armenian_PE¶

KEY_Armenian_PE: int

KEY_Armenian_PYUR¶

KEY_Armenian_PYUR: int

KEY_Armenian_RA¶

KEY_Armenian_RA: int

KEY_Armenian_RE¶

KEY_Armenian_RE: int

KEY_Armenian_SE¶

KEY_Armenian_SE: int

KEY_Armenian_SHA¶

KEY_Armenian_SHA: int

KEY_Armenian_TCHE¶

KEY_Armenian_TCHE: int

KEY_Armenian_TO¶

KEY_Armenian_TO: int

KEY_Armenian_TSA¶

KEY_Armenian_TSA: int

KEY_Armenian_TSO¶

KEY_Armenian_TSO: int

KEY_Armenian_TYUN¶

KEY_Armenian_TYUN: int

KEY_Armenian_VEV¶

KEY_Armenian_VEV: int

KEY_Armenian_VO¶

KEY_Armenian_VO: int

KEY_Armenian_VYUN¶

KEY_Armenian_VYUN: int

KEY_Armenian_YECH¶

KEY_Armenian_YECH: int

KEY_Armenian_ZA¶

KEY_Armenian_ZA: int

KEY_Armenian_ZHE¶

KEY_Armenian_ZHE: int

KEY_Armenian_accent¶

KEY_Armenian_accent: int

KEY_Armenian_amanak¶

KEY_Armenian_amanak: int

KEY_Armenian_apostrophe¶

KEY_Armenian_apostrophe: int

KEY_Armenian_at¶

KEY_Armenian_at: int

KEY_Armenian_ayb¶

KEY_Armenian_ayb: int

KEY_Armenian_ben¶

KEY_Armenian_ben: int

KEY_Armenian_but¶

KEY_Armenian_but: int

KEY_Armenian_cha¶

KEY_Armenian_cha: int

KEY_Armenian_da¶

KEY_Armenian_da: int

KEY_Armenian_dza¶

KEY_Armenian_dza: int

KEY_Armenian_e¶

KEY_Armenian_e: int

KEY_Armenian_exclam¶

KEY_Armenian_exclam: int

KEY_Armenian_fe¶

KEY_Armenian_fe: int

KEY_Armenian_full_stop¶

KEY_Armenian_full_stop: int

KEY_Armenian_ghat¶

KEY_Armenian_ghat: int

KEY_Armenian_gim¶

KEY_Armenian_gim: int

KEY_Armenian_hi¶

KEY_Armenian_hi: int

KEY_Armenian_ho¶

KEY_Armenian_ho: int

KEY_Armenian_hyphen¶

KEY_Armenian_hyphen: int

KEY_Armenian_ini¶

KEY_Armenian_ini: int

KEY_Armenian_je¶

KEY_Armenian_je: int

KEY_Armenian_ke¶

KEY_Armenian_ke: int

KEY_Armenian_ken¶

KEY_Armenian_ken: int

KEY_Armenian_khe¶

KEY_Armenian_khe: int

KEY_Armenian_ligature_ew¶

KEY_Armenian_ligature_ew: int

KEY_Armenian_lyun¶

KEY_Armenian_lyun: int

KEY_Armenian_men¶

KEY_Armenian_men: int

KEY_Armenian_nu¶

KEY_Armenian_nu: int

KEY_Armenian_o¶

KEY_Armenian_o: int

KEY_Armenian_paruyk¶

KEY_Armenian_paruyk: int

KEY_Armenian_pe¶

KEY_Armenian_pe: int

KEY_Armenian_pyur¶

KEY_Armenian_pyur: int

KEY_Armenian_question¶

KEY_Armenian_question: int

KEY_Armenian_ra¶

KEY_Armenian_ra: int

KEY_Armenian_re¶

KEY_Armenian_re: int

KEY_Armenian_se¶

KEY_Armenian_se: int

KEY_Armenian_separation_mark¶

KEY_Armenian_separation_mark: int

KEY_Armenian_sha¶

KEY_Armenian_sha: int

KEY_Armenian_shesht¶

KEY_Armenian_shesht: int

KEY_Armenian_tche¶

KEY_Armenian_tche: int

KEY_Armenian_to¶

KEY_Armenian_to: int

KEY_Armenian_tsa¶

KEY_Armenian_tsa: int

KEY_Armenian_tso¶

KEY_Armenian_tso: int

KEY_Armenian_tyun¶

KEY_Armenian_tyun: int

KEY_Armenian_verjaket¶

KEY_Armenian_verjaket: int

KEY_Armenian_vev¶

KEY_Armenian_vev: int

KEY_Armenian_vo¶

KEY_Armenian_vo: int

KEY_Armenian_vyun¶

KEY_Armenian_vyun: int

KEY_Armenian_yech¶

KEY_Armenian_yech: int

KEY_Armenian_yentamna¶

KEY_Armenian_yentamna: int

KEY_Armenian_za¶

KEY_Armenian_za: int

KEY_Armenian_zhe¶

KEY_Armenian_zhe: int

KEY_AspectRatio¶

KEY_AspectRatio: int

KEY_Assistant¶

KEY_Assistant: int

KEY_Atilde¶

KEY_Atilde: int

KEY_AttendantOff¶

KEY_AttendantOff: int

KEY_AttendantOn¶

KEY_AttendantOn: int

KEY_AttendantToggle¶

KEY_AttendantToggle: int

KEY_AudibleBell_Enable¶

KEY_AudibleBell_Enable: int

KEY_Audio¶

KEY_Audio: int

KEY_AudioCycleTrack¶

KEY_AudioCycleTrack: int

KEY_AudioDesc¶

KEY_AudioDesc: int

KEY_AudioForward¶

KEY_AudioForward: int

KEY_AudioLowerVolume¶

KEY_AudioLowerVolume: int

KEY_AudioMedia¶

KEY_AudioMedia: int

KEY_AudioMicMute¶

KEY_AudioMicMute: int

KEY_AudioMute¶

KEY_AudioMute: int

KEY_AudioNext¶

KEY_AudioNext: int

KEY_AudioPause¶

KEY_AudioPause: int

KEY_AudioPlay¶

KEY_AudioPlay: int

KEY_AudioPreset¶

KEY_AudioPreset: int

KEY_AudioPrev¶

KEY_AudioPrev: int

KEY_AudioRaiseVolume¶

KEY_AudioRaiseVolume: int

KEY_AudioRandomPlay¶

KEY_AudioRandomPlay: int

KEY_AudioRecord¶

KEY_AudioRecord: int

KEY_AudioRepeat¶

KEY_AudioRepeat: int

KEY_AudioRewind¶

KEY_AudioRewind: int

KEY_AudioStop¶

KEY_AudioStop: int

KEY_AutopilotEngageToggle¶

KEY_AutopilotEngageToggle: int

KEY_Away¶

KEY_Away: int

KEY_B¶

KEY_B: int

KEY_Babovedot¶

KEY_Babovedot: int

KEY_Back¶

KEY_Back: int

KEY_BackForward¶

KEY_BackForward: int

KEY_BackSpace¶

KEY_BackSpace: int

KEY_Battery¶

KEY_Battery: int

KEY_Begin¶

KEY_Begin: int

KEY_Blue¶

KEY_Blue: int

KEY_Bluetooth¶

KEY_Bluetooth: int

KEY_Book¶

KEY_Book: int

KEY_BounceKeys_Enable¶

KEY_BounceKeys_Enable: int

KEY_Break¶

KEY_Break: int

KEY_BrightnessAdjust¶

KEY_BrightnessAdjust: int

KEY_BrightnessAuto¶

KEY_BrightnessAuto: int

KEY_BrightnessMax¶

KEY_BrightnessMax: int

KEY_BrightnessMin¶

KEY_BrightnessMin: int

KEY_Buttonconfig¶

KEY_Buttonconfig: int

KEY_Byelorussian_SHORTU¶

KEY_Byelorussian_SHORTU: int

KEY_Byelorussian_shortu¶

KEY_Byelorussian_shortu: int

KEY_C¶

KEY_C: int

KEY_CD¶

KEY_CD: int

KEY_CH¶

KEY_CH: int

KEY_C_H¶

KEY_C_H: int

KEY_C_h¶

KEY_C_h: int

KEY_Cabovedot¶

KEY_Cabovedot: int

KEY_Cacute¶

KEY_Cacute: int

KEY_Calculator¶

KEY_Calculator: int

KEY_Calendar¶

KEY_Calendar: int

KEY_CameraAccessDisable¶

KEY_CameraAccessDisable: int

KEY_CameraAccessEnable¶

KEY_CameraAccessEnable: int

KEY_CameraAccessToggle¶

KEY_CameraAccessToggle: int

KEY_CameraDown¶

KEY_CameraDown: int

KEY_CameraFocus¶

KEY_CameraFocus: int

KEY_CameraLeft¶

KEY_CameraLeft: int

KEY_CameraRight¶

KEY_CameraRight: int

KEY_CameraUp¶

KEY_CameraUp: int

KEY_CameraZoomIn¶

KEY_CameraZoomIn: int

KEY_CameraZoomOut¶

KEY_CameraZoomOut: int

KEY_Cancel¶

KEY_Cancel: int

KEY_Caps_Lock¶

KEY_Caps_Lock: int

KEY_Ccaron¶

KEY_Ccaron: int

KEY_Ccedilla¶

KEY_Ccedilla: int

KEY_Ccircumflex¶

KEY_Ccircumflex: int

KEY_Ch¶

KEY_Ch: int

KEY_ChannelDown¶

KEY_ChannelDown: int

KEY_ChannelUp¶

KEY_ChannelUp: int

KEY_Clear¶

KEY_Clear: int

KEY_ClearGrab¶

KEY_ClearGrab: int

KEY_ClearvuSonar¶

KEY_ClearvuSonar: int

KEY_Close¶

KEY_Close: int

KEY_Codeinput¶

KEY_Codeinput: int

KEY_ColonSign¶

KEY_ColonSign: int

KEY_Community¶

KEY_Community: int

KEY_ContextMenu¶

KEY_ContextMenu: int

KEY_ContrastAdjust¶

KEY_ContrastAdjust: int

KEY_ControlPanel¶

KEY_ControlPanel: int

KEY_Control_L¶

KEY_Control_L: int

KEY_Control_R¶

KEY_Control_R: int

KEY_Copy¶

KEY_Copy: int

KEY_CruzeiroSign¶

KEY_CruzeiroSign: int

KEY_Cut¶

KEY_Cut: int

KEY_CycleAngle¶

KEY_CycleAngle: int

KEY_Cyrillic_A¶

KEY_Cyrillic_A: int

KEY_Cyrillic_BE¶

KEY_Cyrillic_BE: int

KEY_Cyrillic_CHE¶

KEY_Cyrillic_CHE: int

KEY_Cyrillic_CHE_descender¶

KEY_Cyrillic_CHE_descender: int

KEY_Cyrillic_CHE_vertstroke¶

KEY_Cyrillic_CHE_vertstroke: int

KEY_Cyrillic_DE¶

KEY_Cyrillic_DE: int

KEY_Cyrillic_DZHE¶

KEY_Cyrillic_DZHE: int

KEY_Cyrillic_E¶

KEY_Cyrillic_E: int

KEY_Cyrillic_EF¶

KEY_Cyrillic_EF: int

KEY_Cyrillic_EL¶

KEY_Cyrillic_EL: int

KEY_Cyrillic_EM¶

KEY_Cyrillic_EM: int

KEY_Cyrillic_EN¶

KEY_Cyrillic_EN: int

KEY_Cyrillic_EN_descender¶

KEY_Cyrillic_EN_descender: int

KEY_Cyrillic_ER¶

KEY_Cyrillic_ER: int

KEY_Cyrillic_ES¶

KEY_Cyrillic_ES: int

KEY_Cyrillic_GHE¶

KEY_Cyrillic_GHE: int

KEY_Cyrillic_GHE_bar¶

KEY_Cyrillic_GHE_bar: int

KEY_Cyrillic_HA¶

KEY_Cyrillic_HA: int

KEY_Cyrillic_HARDSIGN¶

KEY_Cyrillic_HARDSIGN: int

KEY_Cyrillic_HA_descender¶

KEY_Cyrillic_HA_descender: int

KEY_Cyrillic_I¶

KEY_Cyrillic_I: int

KEY_Cyrillic_IE¶

KEY_Cyrillic_IE: int

KEY_Cyrillic_IO¶

KEY_Cyrillic_IO: int

KEY_Cyrillic_I_macron¶

KEY_Cyrillic_I_macron: int

KEY_Cyrillic_JE¶

KEY_Cyrillic_JE: int

KEY_Cyrillic_KA¶

KEY_Cyrillic_KA: int

KEY_Cyrillic_KA_descender¶

KEY_Cyrillic_KA_descender: int

KEY_Cyrillic_KA_vertstroke¶

KEY_Cyrillic_KA_vertstroke: int

KEY_Cyrillic_LJE¶

KEY_Cyrillic_LJE: int

KEY_Cyrillic_NJE¶

KEY_Cyrillic_NJE: int

KEY_Cyrillic_O¶

KEY_Cyrillic_O: int

KEY_Cyrillic_O_bar¶

KEY_Cyrillic_O_bar: int

KEY_Cyrillic_PE¶

KEY_Cyrillic_PE: int

KEY_Cyrillic_SCHWA¶

KEY_Cyrillic_SCHWA: int

KEY_Cyrillic_SHA¶

KEY_Cyrillic_SHA: int

KEY_Cyrillic_SHCHA¶

KEY_Cyrillic_SHCHA: int

KEY_Cyrillic_SHHA¶

KEY_Cyrillic_SHHA: int

KEY_Cyrillic_SHORTI¶

KEY_Cyrillic_SHORTI: int

KEY_Cyrillic_SOFTSIGN¶

KEY_Cyrillic_SOFTSIGN: int

KEY_Cyrillic_TE¶

KEY_Cyrillic_TE: int

KEY_Cyrillic_TSE¶

KEY_Cyrillic_TSE: int

KEY_Cyrillic_U¶

KEY_Cyrillic_U: int

KEY_Cyrillic_U_macron¶

KEY_Cyrillic_U_macron: int

KEY_Cyrillic_U_straight¶

KEY_Cyrillic_U_straight: int

KEY_Cyrillic_U_straight_bar¶

KEY_Cyrillic_U_straight_bar: int

KEY_Cyrillic_VE¶

KEY_Cyrillic_VE: int

KEY_Cyrillic_YA¶

KEY_Cyrillic_YA: int

KEY_Cyrillic_YERU¶

KEY_Cyrillic_YERU: int

KEY_Cyrillic_YU¶

KEY_Cyrillic_YU: int

KEY_Cyrillic_ZE¶

KEY_Cyrillic_ZE: int

KEY_Cyrillic_ZHE¶

KEY_Cyrillic_ZHE: int

KEY_Cyrillic_ZHE_descender¶

KEY_Cyrillic_ZHE_descender: int

KEY_Cyrillic_a¶

KEY_Cyrillic_a: int

KEY_Cyrillic_be¶

KEY_Cyrillic_be: int

KEY_Cyrillic_che¶

KEY_Cyrillic_che: int

KEY_Cyrillic_che_descender¶

KEY_Cyrillic_che_descender: int

KEY_Cyrillic_che_vertstroke¶

KEY_Cyrillic_che_vertstroke: int

KEY_Cyrillic_de¶

KEY_Cyrillic_de: int

KEY_Cyrillic_dzhe¶

KEY_Cyrillic_dzhe: int

KEY_Cyrillic_e¶

KEY_Cyrillic_e: int

KEY_Cyrillic_ef¶

KEY_Cyrillic_ef: int

KEY_Cyrillic_el¶

KEY_Cyrillic_el: int

KEY_Cyrillic_em¶

KEY_Cyrillic_em: int

KEY_Cyrillic_en¶

KEY_Cyrillic_en: int

KEY_Cyrillic_en_descender¶

KEY_Cyrillic_en_descender: int

KEY_Cyrillic_er¶

KEY_Cyrillic_er: int

KEY_Cyrillic_es¶

KEY_Cyrillic_es: int

KEY_Cyrillic_ghe¶

KEY_Cyrillic_ghe: int

KEY_Cyrillic_ghe_bar¶

KEY_Cyrillic_ghe_bar: int

KEY_Cyrillic_ha¶

KEY_Cyrillic_ha: int

KEY_Cyrillic_ha_descender¶

KEY_Cyrillic_ha_descender: int

KEY_Cyrillic_hardsign¶

KEY_Cyrillic_hardsign: int

KEY_Cyrillic_i¶

KEY_Cyrillic_i: int

KEY_Cyrillic_i_macron¶

KEY_Cyrillic_i_macron: int

KEY_Cyrillic_ie¶

KEY_Cyrillic_ie: int

KEY_Cyrillic_io¶

KEY_Cyrillic_io: int

KEY_Cyrillic_je¶

KEY_Cyrillic_je: int

KEY_Cyrillic_ka¶

KEY_Cyrillic_ka: int

KEY_Cyrillic_ka_descender¶

KEY_Cyrillic_ka_descender: int

KEY_Cyrillic_ka_vertstroke¶

KEY_Cyrillic_ka_vertstroke: int

KEY_Cyrillic_lje¶

KEY_Cyrillic_lje: int

KEY_Cyrillic_nje¶

KEY_Cyrillic_nje: int

KEY_Cyrillic_o¶

KEY_Cyrillic_o: int

KEY_Cyrillic_o_bar¶

KEY_Cyrillic_o_bar: int

KEY_Cyrillic_pe¶

KEY_Cyrillic_pe: int

KEY_Cyrillic_schwa¶

KEY_Cyrillic_schwa: int

KEY_Cyrillic_sha¶

KEY_Cyrillic_sha: int

KEY_Cyrillic_shcha¶

KEY_Cyrillic_shcha: int

KEY_Cyrillic_shha¶

KEY_Cyrillic_shha: int

KEY_Cyrillic_shorti¶

KEY_Cyrillic_shorti: int

KEY_Cyrillic_softsign¶

KEY_Cyrillic_softsign: int

KEY_Cyrillic_te¶

KEY_Cyrillic_te: int

KEY_Cyrillic_tse¶

KEY_Cyrillic_tse: int

KEY_Cyrillic_u¶

KEY_Cyrillic_u: int

KEY_Cyrillic_u_macron¶

KEY_Cyrillic_u_macron: int

KEY_Cyrillic_u_straight¶

KEY_Cyrillic_u_straight: int

KEY_Cyrillic_u_straight_bar¶

KEY_Cyrillic_u_straight_bar: int

KEY_Cyrillic_ve¶

KEY_Cyrillic_ve: int

KEY_Cyrillic_ya¶

KEY_Cyrillic_ya: int

KEY_Cyrillic_yeru¶

KEY_Cyrillic_yeru: int

KEY_Cyrillic_yu¶

KEY_Cyrillic_yu: int

KEY_Cyrillic_ze¶

KEY_Cyrillic_ze: int

KEY_Cyrillic_zhe¶

KEY_Cyrillic_zhe: int

KEY_Cyrillic_zhe_descender¶

KEY_Cyrillic_zhe_descender: int

KEY_D¶

KEY_D: int

KEY_DOS¶

KEY_DOS: int

KEY_DVD¶

KEY_DVD: int

KEY_Dabovedot¶

KEY_Dabovedot: int

KEY_Data¶

KEY_Data: int

KEY_Database¶

KEY_Database: int

KEY_Dcaron¶

KEY_Dcaron: int

KEY_Delete¶

KEY_Delete: int

KEY_Dictate¶

KEY_Dictate: int

KEY_Display¶

KEY_Display: int

KEY_DisplayOff¶

KEY_DisplayOff: int

KEY_DisplayToggle¶

KEY_DisplayToggle: int

KEY_DoNotDisturb¶

KEY_DoNotDisturb: int

KEY_Documents¶

KEY_Documents: int

KEY_DongSign¶

KEY_DongSign: int

KEY_Down¶

KEY_Down: int

KEY_Dstroke¶

KEY_Dstroke: int

KEY_DualRangeRadar¶

KEY_DualRangeRadar: int

KEY_E¶

KEY_E: int

KEY_ENG¶

KEY_ENG: int

KEY_ETH¶

KEY_ETH: int

KEY_EZH¶

KEY_EZH: int

KEY_Eabovedot¶

KEY_Eabovedot: int

KEY_Eacute¶

KEY_Eacute: int

KEY_Ebelowdot¶

KEY_Ebelowdot: int

KEY_Ecaron¶

KEY_Ecaron: int

KEY_Ecircumflex¶

KEY_Ecircumflex: int

KEY_Ecircumflexacute¶

KEY_Ecircumflexacute: int

KEY_Ecircumflexbelowdot¶

KEY_Ecircumflexbelowdot: int

KEY_Ecircumflexgrave¶

KEY_Ecircumflexgrave: int

KEY_Ecircumflexhook¶

KEY_Ecircumflexhook: int

KEY_Ecircumflextilde¶

KEY_Ecircumflextilde: int

KEY_EcuSign¶

KEY_EcuSign: int

KEY_Ediaeresis¶

KEY_Ediaeresis: int

KEY_Editor¶

KEY_Editor: int

KEY_Egrave¶

KEY_Egrave: int

KEY_Ehook¶

KEY_Ehook: int

KEY_Eisu_Shift¶

KEY_Eisu_Shift: int

KEY_Eisu_toggle¶

KEY_Eisu_toggle: int

KEY_Eject¶

KEY_Eject: int

KEY_Emacron¶

KEY_Emacron: int

KEY_EmojiPicker¶

KEY_EmojiPicker: int

KEY_End¶

KEY_End: int

KEY_Eogonek¶

KEY_Eogonek: int

KEY_Escape¶

KEY_Escape: int

KEY_Eth¶

KEY_Eth: int

KEY_Etilde¶

KEY_Etilde: int

KEY_EuroSign¶

KEY_EuroSign: int

KEY_Excel¶

KEY_Excel: int

KEY_Execute¶

KEY_Execute: int

KEY_Explorer¶

KEY_Explorer: int

KEY_F¶

KEY_F: int

KEY_F1¶

KEY_F1: int

KEY_F10¶

KEY_F10: int

KEY_F11¶

KEY_F11: int

KEY_F12¶

KEY_F12: int

KEY_F13¶

KEY_F13: int

KEY_F14¶

KEY_F14: int

KEY_F15¶

KEY_F15: int

KEY_F16¶

KEY_F16: int

KEY_F17¶

KEY_F17: int

KEY_F18¶

KEY_F18: int

KEY_F19¶

KEY_F19: int

KEY_F2¶

KEY_F2: int

KEY_F20¶

KEY_F20: int

KEY_F21¶

KEY_F21: int

KEY_F22¶

KEY_F22: int

KEY_F23¶

KEY_F23: int

KEY_F24¶

KEY_F24: int

KEY_F25¶

KEY_F25: int

KEY_F26¶

KEY_F26: int

KEY_F27¶

KEY_F27: int

KEY_F28¶

KEY_F28: int

KEY_F29¶

KEY_F29: int

KEY_F3¶

KEY_F3: int

KEY_F30¶

KEY_F30: int

KEY_F31¶

KEY_F31: int

KEY_F32¶

KEY_F32: int

KEY_F33¶

KEY_F33: int

KEY_F34¶

KEY_F34: int

KEY_F35¶

KEY_F35: int

KEY_F4¶

KEY_F4: int

KEY_F5¶

KEY_F5: int

KEY_F6¶

KEY_F6: int

KEY_F7¶

KEY_F7: int

KEY_F8¶

KEY_F8: int

KEY_F9¶

KEY_F9: int

KEY_FFrancSign¶

KEY_FFrancSign: int

KEY_Fabovedot¶

KEY_Fabovedot: int

KEY_Farsi_0¶

KEY_Farsi_0: int

KEY_Farsi_1¶

KEY_Farsi_1: int

KEY_Farsi_2¶

KEY_Farsi_2: int

KEY_Farsi_3¶

KEY_Farsi_3: int

KEY_Farsi_4¶

KEY_Farsi_4: int

KEY_Farsi_5¶

KEY_Farsi_5: int

KEY_Farsi_6¶

KEY_Farsi_6: int

KEY_Farsi_7¶

KEY_Farsi_7: int

KEY_Farsi_8¶

KEY_Farsi_8: int

KEY_Farsi_9¶

KEY_Farsi_9: int

KEY_Farsi_yeh¶

KEY_Farsi_yeh: int

KEY_FastReverse¶

KEY_FastReverse: int

KEY_Favorites¶

KEY_Favorites: int

KEY_Finance¶

KEY_Finance: int

KEY_Find¶

KEY_Find: int

KEY_First_Virtual_Screen¶

KEY_First_Virtual_Screen: int

KEY_FishingChart¶

KEY_FishingChart: int

KEY_Fn¶

KEY_Fn: int

KEY_FnRightShift¶

KEY_FnRightShift: int

KEY_Fn_Esc¶

KEY_Fn_Esc: int

KEY_Forward¶

KEY_Forward: int

KEY_FrameBack¶

KEY_FrameBack: int

KEY_FrameForward¶

KEY_FrameForward: int

KEY_FullScreen¶

KEY_FullScreen: int

KEY_G¶

KEY_G: int

KEY_Gabovedot¶

KEY_Gabovedot: int

KEY_Game¶

KEY_Game: int

KEY_Gbreve¶

KEY_Gbreve: int

KEY_Gcaron¶

KEY_Gcaron: int

KEY_Gcedilla¶

KEY_Gcedilla: int

KEY_Gcircumflex¶

KEY_Gcircumflex: int

KEY_Georgian_an¶

KEY_Georgian_an: int

KEY_Georgian_ban¶

KEY_Georgian_ban: int

KEY_Georgian_can¶

KEY_Georgian_can: int

KEY_Georgian_char¶

KEY_Georgian_char: int

KEY_Georgian_chin¶

KEY_Georgian_chin: int

KEY_Georgian_cil¶

KEY_Georgian_cil: int

KEY_Georgian_don¶

KEY_Georgian_don: int

KEY_Georgian_en¶

KEY_Georgian_en: int

KEY_Georgian_fi¶

KEY_Georgian_fi: int

KEY_Georgian_gan¶

KEY_Georgian_gan: int

KEY_Georgian_ghan¶

KEY_Georgian_ghan: int

KEY_Georgian_hae¶

KEY_Georgian_hae: int

KEY_Georgian_har¶

KEY_Georgian_har: int

KEY_Georgian_he¶

KEY_Georgian_he: int

KEY_Georgian_hie¶

KEY_Georgian_hie: int

KEY_Georgian_hoe¶

KEY_Georgian_hoe: int

KEY_Georgian_in¶

KEY_Georgian_in: int

KEY_Georgian_jhan¶

KEY_Georgian_jhan: int

KEY_Georgian_jil¶

KEY_Georgian_jil: int

KEY_Georgian_kan¶

KEY_Georgian_kan: int

KEY_Georgian_khar¶

KEY_Georgian_khar: int

KEY_Georgian_las¶

KEY_Georgian_las: int

KEY_Georgian_man¶

KEY_Georgian_man: int

KEY_Georgian_nar¶

KEY_Georgian_nar: int

KEY_Georgian_on¶

KEY_Georgian_on: int

KEY_Georgian_par¶

KEY_Georgian_par: int

KEY_Georgian_phar¶

KEY_Georgian_phar: int

KEY_Georgian_qar¶

KEY_Georgian_qar: int

KEY_Georgian_rae¶

KEY_Georgian_rae: int

KEY_Georgian_san¶

KEY_Georgian_san: int

KEY_Georgian_shin¶

KEY_Georgian_shin: int

KEY_Georgian_tan¶

KEY_Georgian_tan: int

KEY_Georgian_tar¶

KEY_Georgian_tar: int

KEY_Georgian_un¶

KEY_Georgian_un: int

KEY_Georgian_vin¶

KEY_Georgian_vin: int

KEY_Georgian_we¶

KEY_Georgian_we: int

KEY_Georgian_xan¶

KEY_Georgian_xan: int

KEY_Georgian_zen¶

KEY_Georgian_zen: int

KEY_Georgian_zhar¶

KEY_Georgian_zhar: int

KEY_Go¶

KEY_Go: int

KEY_GraphicsEditor¶

KEY_GraphicsEditor: int

KEY_Greek_ALPHA¶

KEY_Greek_ALPHA: int

KEY_Greek_ALPHAaccent¶

KEY_Greek_ALPHAaccent: int

KEY_Greek_BETA¶

KEY_Greek_BETA: int

KEY_Greek_CHI¶

KEY_Greek_CHI: int

KEY_Greek_DELTA¶

KEY_Greek_DELTA: int

KEY_Greek_EPSILON¶

KEY_Greek_EPSILON: int

KEY_Greek_EPSILONaccent¶

KEY_Greek_EPSILONaccent: int

KEY_Greek_ETA¶

KEY_Greek_ETA: int

KEY_Greek_ETAaccent¶

KEY_Greek_ETAaccent: int

KEY_Greek_GAMMA¶

KEY_Greek_GAMMA: int

KEY_Greek_IOTA¶

KEY_Greek_IOTA: int

KEY_Greek_IOTAaccent¶

KEY_Greek_IOTAaccent: int

KEY_Greek_IOTAdiaeresis¶

KEY_Greek_IOTAdiaeresis: int

KEY_Greek_IOTAdieresis¶

KEY_Greek_IOTAdieresis: int

KEY_Greek_KAPPA¶

KEY_Greek_KAPPA: int

KEY_Greek_LAMBDA¶

KEY_Greek_LAMBDA: int

KEY_Greek_LAMDA¶

KEY_Greek_LAMDA: int

KEY_Greek_MU¶

KEY_Greek_MU: int

KEY_Greek_NU¶

KEY_Greek_NU: int

KEY_Greek_OMEGA¶

KEY_Greek_OMEGA: int

KEY_Greek_OMEGAaccent¶

KEY_Greek_OMEGAaccent: int

KEY_Greek_OMICRON¶

KEY_Greek_OMICRON: int

KEY_Greek_OMICRONaccent¶

KEY_Greek_OMICRONaccent: int

KEY_Greek_PHI¶

KEY_Greek_PHI: int

KEY_Greek_PI¶

KEY_Greek_PI: int

KEY_Greek_PSI¶

KEY_Greek_PSI: int

KEY_Greek_RHO¶

KEY_Greek_RHO: int

KEY_Greek_SIGMA¶

KEY_Greek_SIGMA: int

KEY_Greek_TAU¶

KEY_Greek_TAU: int

KEY_Greek_THETA¶

KEY_Greek_THETA: int

KEY_Greek_UPSILON¶

KEY_Greek_UPSILON: int

KEY_Greek_UPSILONaccent¶

KEY_Greek_UPSILONaccent: int

KEY_Greek_UPSILONdieresis¶

KEY_Greek_UPSILONdieresis: int

KEY_Greek_XI¶

KEY_Greek_XI: int

KEY_Greek_ZETA¶

KEY_Greek_ZETA: int

KEY_Greek_accentdieresis¶

KEY_Greek_accentdieresis: int

KEY_Greek_alpha¶

KEY_Greek_alpha: int

KEY_Greek_alphaaccent¶

KEY_Greek_alphaaccent: int

KEY_Greek_beta¶

KEY_Greek_beta: int

KEY_Greek_chi¶

KEY_Greek_chi: int

KEY_Greek_delta¶

KEY_Greek_delta: int

KEY_Greek_epsilon¶

KEY_Greek_epsilon: int

KEY_Greek_epsilonaccent¶

KEY_Greek_epsilonaccent: int

KEY_Greek_eta¶

KEY_Greek_eta: int

KEY_Greek_etaaccent¶

KEY_Greek_etaaccent: int

KEY_Greek_finalsmallsigma¶

KEY_Greek_finalsmallsigma: int

KEY_Greek_gamma¶

KEY_Greek_gamma: int

KEY_Greek_horizbar¶

KEY_Greek_horizbar: int

KEY_Greek_iota¶

KEY_Greek_iota: int

KEY_Greek_iotaaccent¶

KEY_Greek_iotaaccent: int

KEY_Greek_iotaaccentdieresis¶

KEY_Greek_iotaaccentdieresis: int

KEY_Greek_iotadieresis¶

KEY_Greek_iotadieresis: int

KEY_Greek_kappa¶

KEY_Greek_kappa: int

KEY_Greek_lambda¶

KEY_Greek_lambda: int

KEY_Greek_lamda¶

KEY_Greek_lamda: int

KEY_Greek_mu¶

KEY_Greek_mu: int

KEY_Greek_nu¶

KEY_Greek_nu: int

KEY_Greek_omega¶

KEY_Greek_omega: int

KEY_Greek_omegaaccent¶

KEY_Greek_omegaaccent: int

KEY_Greek_omicron¶

KEY_Greek_omicron: int

KEY_Greek_omicronaccent¶

KEY_Greek_omicronaccent: int

KEY_Greek_phi¶

KEY_Greek_phi: int

KEY_Greek_pi¶

KEY_Greek_pi: int

KEY_Greek_psi¶

KEY_Greek_psi: int

KEY_Greek_rho¶

KEY_Greek_rho: int

KEY_Greek_sigma¶

KEY_Greek_sigma: int

KEY_Greek_switch¶

KEY_Greek_switch: int

KEY_Greek_tau¶

KEY_Greek_tau: int

KEY_Greek_theta¶

KEY_Greek_theta: int

KEY_Greek_upsilon¶

KEY_Greek_upsilon: int

KEY_Greek_upsilonaccent¶

KEY_Greek_upsilonaccent: int

KEY_Greek_upsilonaccentdieresis¶

KEY_Greek_upsilonaccentdieresis: int

KEY_Greek_upsilondieresis¶

KEY_Greek_upsilondieresis: int

KEY_Greek_xi¶

KEY_Greek_xi: int

KEY_Greek_zeta¶

KEY_Greek_zeta: int

KEY_Green¶

KEY_Green: int

KEY_H¶

KEY_H: int

KEY_Hangul¶

KEY_Hangul: int

KEY_Hangul_A¶

KEY_Hangul_A: int

KEY_Hangul_AE¶

KEY_Hangul_AE: int

KEY_Hangul_AraeA¶

KEY_Hangul_AraeA: int

KEY_Hangul_AraeAE¶

KEY_Hangul_AraeAE: int

KEY_Hangul_Banja¶

KEY_Hangul_Banja: int

KEY_Hangul_Cieuc¶

KEY_Hangul_Cieuc: int

KEY_Hangul_Codeinput¶

KEY_Hangul_Codeinput: int

KEY_Hangul_Dikeud¶

KEY_Hangul_Dikeud: int

KEY_Hangul_E¶

KEY_Hangul_E: int

KEY_Hangul_EO¶

KEY_Hangul_EO: int

KEY_Hangul_EU¶

KEY_Hangul_EU: int

KEY_Hangul_End¶

KEY_Hangul_End: int

KEY_Hangul_Hanja¶

KEY_Hangul_Hanja: int

KEY_Hangul_Hieuh¶

KEY_Hangul_Hieuh: int

KEY_Hangul_I¶

KEY_Hangul_I: int

KEY_Hangul_Ieung¶

KEY_Hangul_Ieung: int

KEY_Hangul_J_Cieuc¶

KEY_Hangul_J_Cieuc: int

KEY_Hangul_J_Dikeud¶

KEY_Hangul_J_Dikeud: int

KEY_Hangul_J_Hieuh¶

KEY_Hangul_J_Hieuh: int

KEY_Hangul_J_Ieung¶

KEY_Hangul_J_Ieung: int

KEY_Hangul_J_Jieuj¶

KEY_Hangul_J_Jieuj: int

KEY_Hangul_J_Khieuq¶

KEY_Hangul_J_Khieuq: int

KEY_Hangul_J_Kiyeog¶

KEY_Hangul_J_Kiyeog: int

KEY_Hangul_J_KiyeogSios¶

KEY_Hangul_J_KiyeogSios: int

KEY_Hangul_J_KkogjiDalrinIeung¶

KEY_Hangul_J_KkogjiDalrinIeung: int

KEY_Hangul_J_Mieum¶

KEY_Hangul_J_Mieum: int

KEY_Hangul_J_Nieun¶

KEY_Hangul_J_Nieun: int

KEY_Hangul_J_NieunHieuh¶

KEY_Hangul_J_NieunHieuh: int

KEY_Hangul_J_NieunJieuj¶

KEY_Hangul_J_NieunJieuj: int

KEY_Hangul_J_PanSios¶

KEY_Hangul_J_PanSios: int

KEY_Hangul_J_Phieuf¶

KEY_Hangul_J_Phieuf: int

KEY_Hangul_J_Pieub¶

KEY_Hangul_J_Pieub: int

KEY_Hangul_J_PieubSios¶

KEY_Hangul_J_PieubSios: int

KEY_Hangul_J_Rieul¶

KEY_Hangul_J_Rieul: int

KEY_Hangul_J_RieulHieuh¶

KEY_Hangul_J_RieulHieuh: int

KEY_Hangul_J_RieulKiyeog¶

KEY_Hangul_J_RieulKiyeog: int

KEY_Hangul_J_RieulMieum¶

KEY_Hangul_J_RieulMieum: int

KEY_Hangul_J_RieulPhieuf¶

KEY_Hangul_J_RieulPhieuf: int

KEY_Hangul_J_RieulPieub¶

KEY_Hangul_J_RieulPieub: int

KEY_Hangul_J_RieulSios¶

KEY_Hangul_J_RieulSios: int

KEY_Hangul_J_RieulTieut¶

KEY_Hangul_J_RieulTieut: int

KEY_Hangul_J_Sios¶

KEY_Hangul_J_Sios: int

KEY_Hangul_J_SsangKiyeog¶

KEY_Hangul_J_SsangKiyeog: int

KEY_Hangul_J_SsangSios¶

KEY_Hangul_J_SsangSios: int

KEY_Hangul_J_Tieut¶

KEY_Hangul_J_Tieut: int

KEY_Hangul_J_YeorinHieuh¶

KEY_Hangul_J_YeorinHieuh: int

KEY_Hangul_Jamo¶

KEY_Hangul_Jamo: int

KEY_Hangul_Jeonja¶

KEY_Hangul_Jeonja: int

KEY_Hangul_Jieuj¶

KEY_Hangul_Jieuj: int

KEY_Hangul_Khieuq¶

KEY_Hangul_Khieuq: int

KEY_Hangul_Kiyeog¶

KEY_Hangul_Kiyeog: int

KEY_Hangul_KiyeogSios¶

KEY_Hangul_KiyeogSios: int

KEY_Hangul_KkogjiDalrinIeung¶

KEY_Hangul_KkogjiDalrinIeung: int

KEY_Hangul_Mieum¶

KEY_Hangul_Mieum: int

KEY_Hangul_MultipleCandidate¶

KEY_Hangul_MultipleCandidate: int

KEY_Hangul_Nieun¶

KEY_Hangul_Nieun: int

KEY_Hangul_NieunHieuh¶

KEY_Hangul_NieunHieuh: int

KEY_Hangul_NieunJieuj¶

KEY_Hangul_NieunJieuj: int

KEY_Hangul_O¶

KEY_Hangul_O: int

KEY_Hangul_OE¶

KEY_Hangul_OE: int

KEY_Hangul_PanSios¶

KEY_Hangul_PanSios: int

KEY_Hangul_Phieuf¶

KEY_Hangul_Phieuf: int

KEY_Hangul_Pieub¶

KEY_Hangul_Pieub: int

KEY_Hangul_PieubSios¶

KEY_Hangul_PieubSios: int

KEY_Hangul_PostHanja¶

KEY_Hangul_PostHanja: int

KEY_Hangul_PreHanja¶

KEY_Hangul_PreHanja: int

KEY_Hangul_PreviousCandidate¶

KEY_Hangul_PreviousCandidate: int

KEY_Hangul_Rieul¶

KEY_Hangul_Rieul: int

KEY_Hangul_RieulHieuh¶

KEY_Hangul_RieulHieuh: int

KEY_Hangul_RieulKiyeog¶

KEY_Hangul_RieulKiyeog: int

KEY_Hangul_RieulMieum¶

KEY_Hangul_RieulMieum: int

KEY_Hangul_RieulPhieuf¶

KEY_Hangul_RieulPhieuf: int

KEY_Hangul_RieulPieub¶

KEY_Hangul_RieulPieub: int

KEY_Hangul_RieulSios¶

KEY_Hangul_RieulSios: int

KEY_Hangul_RieulTieut¶

KEY_Hangul_RieulTieut: int

KEY_Hangul_RieulYeorinHieuh¶

KEY_Hangul_RieulYeorinHieuh: int

KEY_Hangul_Romaja¶

KEY_Hangul_Romaja: int

KEY_Hangul_SingleCandidate¶

KEY_Hangul_SingleCandidate: int

KEY_Hangul_Sios¶

KEY_Hangul_Sios: int

KEY_Hangul_Special¶

KEY_Hangul_Special: int

KEY_Hangul_SsangDikeud¶

KEY_Hangul_SsangDikeud: int

KEY_Hangul_SsangJieuj¶

KEY_Hangul_SsangJieuj: int

KEY_Hangul_SsangKiyeog¶

KEY_Hangul_SsangKiyeog: int

KEY_Hangul_SsangPieub¶

KEY_Hangul_SsangPieub: int

KEY_Hangul_SsangSios¶

KEY_Hangul_SsangSios: int

KEY_Hangul_Start¶

KEY_Hangul_Start: int

KEY_Hangul_SunkyeongeumMieum¶

KEY_Hangul_SunkyeongeumMieum: int

KEY_Hangul_SunkyeongeumPhieuf¶

KEY_Hangul_SunkyeongeumPhieuf: int

KEY_Hangul_SunkyeongeumPieub¶

KEY_Hangul_SunkyeongeumPieub: int

KEY_Hangul_Tieut¶

KEY_Hangul_Tieut: int

KEY_Hangul_U¶

KEY_Hangul_U: int

KEY_Hangul_WA¶

KEY_Hangul_WA: int

KEY_Hangul_WAE¶

KEY_Hangul_WAE: int

KEY_Hangul_WE¶

KEY_Hangul_WE: int

KEY_Hangul_WEO¶

KEY_Hangul_WEO: int

KEY_Hangul_WI¶

KEY_Hangul_WI: int

KEY_Hangul_YA¶

KEY_Hangul_YA: int

KEY_Hangul_YAE¶

KEY_Hangul_YAE: int

KEY_Hangul_YE¶

KEY_Hangul_YE: int

KEY_Hangul_YEO¶

KEY_Hangul_YEO: int

KEY_Hangul_YI¶

KEY_Hangul_YI: int

KEY_Hangul_YO¶

KEY_Hangul_YO: int

KEY_Hangul_YU¶

KEY_Hangul_YU: int

KEY_Hangul_YeorinHieuh¶

KEY_Hangul_YeorinHieuh: int

KEY_Hangul_switch¶

KEY_Hangul_switch: int

KEY_HangupPhone¶

KEY_HangupPhone: int

KEY_Hankaku¶

KEY_Hankaku: int

KEY_Hcircumflex¶

KEY_Hcircumflex: int

KEY_Hebrew_switch¶

KEY_Hebrew_switch: int

KEY_Help¶

KEY_Help: int

KEY_Henkan¶

KEY_Henkan: int

KEY_Henkan_Mode¶

KEY_Henkan_Mode: int

KEY_Hibernate¶

KEY_Hibernate: int

KEY_Hiragana¶

KEY_Hiragana: int

KEY_Hiragana_Katakana¶

KEY_Hiragana_Katakana: int

KEY_History¶

KEY_History: int

KEY_Home¶

KEY_Home: int

KEY_HomePage¶

KEY_HomePage: int

KEY_HotLinks¶

KEY_HotLinks: int

KEY_Hstroke¶

KEY_Hstroke: int

KEY_Hyper_L¶

KEY_Hyper_L: int

KEY_Hyper_R¶

KEY_Hyper_R: int

KEY_I¶

KEY_I: int

KEY_ISO_Center_Object¶

KEY_ISO_Center_Object: int

KEY_ISO_Continuous_Underline¶

KEY_ISO_Continuous_Underline: int

KEY_ISO_Discontinuous_Underline¶

KEY_ISO_Discontinuous_Underline: int

KEY_ISO_Emphasize¶

KEY_ISO_Emphasize: int

KEY_ISO_Enter¶

KEY_ISO_Enter: int

KEY_ISO_Fast_Cursor_Down¶

KEY_ISO_Fast_Cursor_Down: int

KEY_ISO_Fast_Cursor_Left¶

KEY_ISO_Fast_Cursor_Left: int

KEY_ISO_Fast_Cursor_Right¶

KEY_ISO_Fast_Cursor_Right: int

KEY_ISO_Fast_Cursor_Up¶

KEY_ISO_Fast_Cursor_Up: int

KEY_ISO_First_Group¶

KEY_ISO_First_Group: int

KEY_ISO_First_Group_Lock¶

KEY_ISO_First_Group_Lock: int

KEY_ISO_Group_Latch¶

KEY_ISO_Group_Latch: int

KEY_ISO_Group_Lock¶

KEY_ISO_Group_Lock: int

KEY_ISO_Group_Shift¶

KEY_ISO_Group_Shift: int

KEY_ISO_Last_Group¶

KEY_ISO_Last_Group: int

KEY_ISO_Last_Group_Lock¶

KEY_ISO_Last_Group_Lock: int

KEY_ISO_Left_Tab¶

KEY_ISO_Left_Tab: int

KEY_ISO_Level2_Latch¶

KEY_ISO_Level2_Latch: int

KEY_ISO_Level3_Latch¶

KEY_ISO_Level3_Latch: int

KEY_ISO_Level3_Lock¶

KEY_ISO_Level3_Lock: int

KEY_ISO_Level3_Shift¶

KEY_ISO_Level3_Shift: int

KEY_ISO_Level5_Latch¶

KEY_ISO_Level5_Latch: int

KEY_ISO_Level5_Lock¶

KEY_ISO_Level5_Lock: int

KEY_ISO_Level5_Shift¶

KEY_ISO_Level5_Shift: int

KEY_ISO_Lock¶

KEY_ISO_Lock: int

KEY_ISO_Move_Line_Down¶

KEY_ISO_Move_Line_Down: int

KEY_ISO_Move_Line_Up¶

KEY_ISO_Move_Line_Up: int

KEY_ISO_Next_Group¶

KEY_ISO_Next_Group: int

KEY_ISO_Next_Group_Lock¶

KEY_ISO_Next_Group_Lock: int

KEY_ISO_Partial_Line_Down¶

KEY_ISO_Partial_Line_Down: int

KEY_ISO_Partial_Line_Up¶

KEY_ISO_Partial_Line_Up: int

KEY_ISO_Partial_Space_Left¶

KEY_ISO_Partial_Space_Left: int

KEY_ISO_Partial_Space_Right¶

KEY_ISO_Partial_Space_Right: int

KEY_ISO_Prev_Group¶

KEY_ISO_Prev_Group: int

KEY_ISO_Prev_Group_Lock¶

KEY_ISO_Prev_Group_Lock: int

KEY_ISO_Release_Both_Margins¶

KEY_ISO_Release_Both_Margins: int

KEY_ISO_Release_Margin_Left¶

KEY_ISO_Release_Margin_Left: int

KEY_ISO_Release_Margin_Right¶

KEY_ISO_Release_Margin_Right: int

KEY_ISO_Set_Margin_Left¶

KEY_ISO_Set_Margin_Left: int

KEY_ISO_Set_Margin_Right¶

KEY_ISO_Set_Margin_Right: int

KEY_Iabovedot¶

KEY_Iabovedot: int

KEY_Iacute¶

KEY_Iacute: int

KEY_Ibelowdot¶

KEY_Ibelowdot: int

KEY_Ibreve¶

KEY_Ibreve: int

KEY_Icircumflex¶

KEY_Icircumflex: int

KEY_Idiaeresis¶

KEY_Idiaeresis: int

KEY_Igrave¶

KEY_Igrave: int

KEY_Ihook¶

KEY_Ihook: int

KEY_Imacron¶

KEY_Imacron: int

KEY_Images¶

KEY_Images: int

KEY_Info¶

KEY_Info: int

KEY_Insert¶

KEY_Insert: int

KEY_Iogonek¶

KEY_Iogonek: int

KEY_Itilde¶

KEY_Itilde: int

KEY_J¶

KEY_J: int

KEY_Jcircumflex¶

KEY_Jcircumflex: int

KEY_Journal¶

KEY_Journal: int

KEY_K¶

KEY_K: int

KEY_KP_0¶

KEY_KP_0: int

KEY_KP_1¶

KEY_KP_1: int

KEY_KP_2¶

KEY_KP_2: int

KEY_KP_3¶

KEY_KP_3: int

KEY_KP_4¶

KEY_KP_4: int

KEY_KP_5¶

KEY_KP_5: int

KEY_KP_6¶

KEY_KP_6: int

KEY_KP_7¶

KEY_KP_7: int

KEY_KP_8¶

KEY_KP_8: int

KEY_KP_9¶

KEY_KP_9: int

KEY_KP_Add¶

KEY_KP_Add: int

KEY_KP_Begin¶

KEY_KP_Begin: int

KEY_KP_Decimal¶

KEY_KP_Decimal: int

KEY_KP_Delete¶

KEY_KP_Delete: int

KEY_KP_Divide¶

KEY_KP_Divide: int

KEY_KP_Down¶

KEY_KP_Down: int

KEY_KP_End¶

KEY_KP_End: int

KEY_KP_Enter¶

KEY_KP_Enter: int

KEY_KP_Equal¶

KEY_KP_Equal: int

KEY_KP_F1¶

KEY_KP_F1: int

KEY_KP_F2¶

KEY_KP_F2: int

KEY_KP_F3¶

KEY_KP_F3: int

KEY_KP_F4¶

KEY_KP_F4: int

KEY_KP_Home¶

KEY_KP_Home: int

KEY_KP_Insert¶

KEY_KP_Insert: int

KEY_KP_Left¶

KEY_KP_Left: int

KEY_KP_Multiply¶

KEY_KP_Multiply: int

KEY_KP_Next¶

KEY_KP_Next: int

KEY_KP_Page_Down¶

KEY_KP_Page_Down: int

KEY_KP_Page_Up¶

KEY_KP_Page_Up: int

KEY_KP_Prior¶

KEY_KP_Prior: int

KEY_KP_Right¶

KEY_KP_Right: int

KEY_KP_Separator¶

KEY_KP_Separator: int

KEY_KP_Space¶

KEY_KP_Space: int

KEY_KP_Subtract¶

KEY_KP_Subtract: int

KEY_KP_Tab¶

KEY_KP_Tab: int

KEY_KP_Up¶

KEY_KP_Up: int

KEY_Kana_Lock¶

KEY_Kana_Lock: int

KEY_Kana_Shift¶

KEY_Kana_Shift: int

KEY_Kanji¶

KEY_Kanji: int

KEY_Kanji_Bangou¶

KEY_Kanji_Bangou: int

KEY_Katakana¶

KEY_Katakana: int

KEY_KbdBrightnessDown¶

KEY_KbdBrightnessDown: int

KEY_KbdBrightnessUp¶

KEY_KbdBrightnessUp: int

KEY_KbdInputAssistAccept¶

KEY_KbdInputAssistAccept: int

KEY_KbdInputAssistCancel¶

KEY_KbdInputAssistCancel: int

KEY_KbdInputAssistNext¶

KEY_KbdInputAssistNext: int

KEY_KbdInputAssistNextgroup¶

KEY_KbdInputAssistNextgroup: int

KEY_KbdInputAssistPrev¶

KEY_KbdInputAssistPrev: int

KEY_KbdInputAssistPrevgroup¶

KEY_KbdInputAssistPrevgroup: int

KEY_KbdLcdMenu1¶

KEY_KbdLcdMenu1: int

KEY_KbdLcdMenu2¶

KEY_KbdLcdMenu2: int

KEY_KbdLcdMenu3¶

KEY_KbdLcdMenu3: int

KEY_KbdLcdMenu4¶

KEY_KbdLcdMenu4: int

KEY_KbdLcdMenu5¶

KEY_KbdLcdMenu5: int

KEY_KbdLightOnOff¶

KEY_KbdLightOnOff: int

KEY_Kcedilla¶

KEY_Kcedilla: int

KEY_Keyboard¶

KEY_Keyboard: int

KEY_Korean_Won¶

KEY_Korean_Won: int

KEY_L¶

KEY_L: int

KEY_L1¶

KEY_L1: int

KEY_L10¶

KEY_L10: int

KEY_L2¶

KEY_L2: int

KEY_L3¶

KEY_L3: int

KEY_L4¶

KEY_L4: int

KEY_L5¶

KEY_L5: int

KEY_L6¶

KEY_L6: int

KEY_L7¶

KEY_L7: int

KEY_L8¶

KEY_L8: int

KEY_L9¶

KEY_L9: int

KEY_Lacute¶

KEY_Lacute: int

KEY_Last_Virtual_Screen¶

KEY_Last_Virtual_Screen: int

KEY_Launch0¶

KEY_Launch0: int

KEY_Launch1¶

KEY_Launch1: int

KEY_Launch2¶

KEY_Launch2: int

KEY_Launch3¶

KEY_Launch3: int

KEY_Launch4¶

KEY_Launch4: int

KEY_Launch5¶

KEY_Launch5: int

KEY_Launch6¶

KEY_Launch6: int

KEY_Launch7¶

KEY_Launch7: int

KEY_Launch8¶

KEY_Launch8: int

KEY_Launch9¶

KEY_Launch9: int

KEY_LaunchA¶

KEY_LaunchA: int

KEY_LaunchB¶

KEY_LaunchB: int

KEY_LaunchC¶

KEY_LaunchC: int

KEY_LaunchD¶

KEY_LaunchD: int

KEY_LaunchE¶

KEY_LaunchE: int

KEY_LaunchF¶

KEY_LaunchF: int

KEY_Lbelowdot¶

KEY_Lbelowdot: int

KEY_Lcaron¶

KEY_Lcaron: int

KEY_Lcedilla¶

KEY_Lcedilla: int

KEY_Left¶

KEY_Left: int

KEY_LeftDown¶

KEY_LeftDown: int

KEY_LeftUp¶

KEY_LeftUp: int

KEY_LightBulb¶

KEY_LightBulb: int

KEY_LightsToggle¶

KEY_LightsToggle: int

KEY_Linefeed¶

KEY_Linefeed: int

KEY_LiraSign¶

KEY_LiraSign: int

KEY_LogGrabInfo¶

KEY_LogGrabInfo: int

KEY_LogOff¶

KEY_LogOff: int

KEY_LogWindowTree¶

KEY_LogWindowTree: int

KEY_Lstroke¶

KEY_Lstroke: int

KEY_M¶

KEY_M: int

KEY_Mabovedot¶

KEY_Mabovedot: int

KEY_Macedonia_DSE¶

KEY_Macedonia_DSE: int

KEY_Macedonia_GJE¶

KEY_Macedonia_GJE: int

KEY_Macedonia_KJE¶

KEY_Macedonia_KJE: int

KEY_Macedonia_dse¶

KEY_Macedonia_dse: int

KEY_Macedonia_gje¶

KEY_Macedonia_gje: int

KEY_Macedonia_kje¶

KEY_Macedonia_kje: int

KEY_Macro1¶

KEY_Macro1: int

KEY_Macro10¶

KEY_Macro10: int

KEY_Macro11¶

KEY_Macro11: int

KEY_Macro12¶

KEY_Macro12: int

KEY_Macro13¶

KEY_Macro13: int

KEY_Macro14¶

KEY_Macro14: int

KEY_Macro15¶

KEY_Macro15: int

KEY_Macro16¶

KEY_Macro16: int

KEY_Macro17¶

KEY_Macro17: int

KEY_Macro18¶

KEY_Macro18: int

KEY_Macro19¶

KEY_Macro19: int

KEY_Macro2¶

KEY_Macro2: int

KEY_Macro20¶

KEY_Macro20: int

KEY_Macro21¶

KEY_Macro21: int

KEY_Macro22¶

KEY_Macro22: int

KEY_Macro23¶

KEY_Macro23: int

KEY_Macro24¶

KEY_Macro24: int

KEY_Macro25¶

KEY_Macro25: int

KEY_Macro26¶

KEY_Macro26: int

KEY_Macro27¶

KEY_Macro27: int

KEY_Macro28¶

KEY_Macro28: int

KEY_Macro29¶

KEY_Macro29: int

KEY_Macro3¶

KEY_Macro3: int

KEY_Macro30¶

KEY_Macro30: int

KEY_Macro4¶

KEY_Macro4: int

KEY_Macro5¶

KEY_Macro5: int

KEY_Macro6¶

KEY_Macro6: int

KEY_Macro7¶

KEY_Macro7: int

KEY_Macro8¶

KEY_Macro8: int

KEY_Macro9¶

KEY_Macro9: int

KEY_MacroPreset1¶

KEY_MacroPreset1: int

KEY_MacroPreset2¶

KEY_MacroPreset2: int

KEY_MacroPreset3¶

KEY_MacroPreset3: int

KEY_MacroPresetCycle¶

KEY_MacroPresetCycle: int

KEY_MacroRecordStart¶

KEY_MacroRecordStart: int

KEY_MacroRecordStop¶

KEY_MacroRecordStop: int

KEY_Mae_Koho¶

KEY_Mae_Koho: int

KEY_Mail¶

KEY_Mail: int

KEY_MailForward¶

KEY_MailForward: int

KEY_MarkWaypoint¶

KEY_MarkWaypoint: int

KEY_Market¶

KEY_Market: int

KEY_Massyo¶

KEY_Massyo: int

KEY_MediaRepeat¶

KEY_MediaRepeat: int

KEY_MediaTopMenu¶

KEY_MediaTopMenu: int

KEY_Meeting¶

KEY_Meeting: int

KEY_Memo¶

KEY_Memo: int

KEY_Menu¶

KEY_Menu: int

KEY_MenuKB¶

KEY_MenuKB: int

KEY_MenuPB¶

KEY_MenuPB: int

KEY_Messenger¶

KEY_Messenger: int

KEY_Meta_L¶

KEY_Meta_L: int

KEY_Meta_R¶

KEY_Meta_R: int

KEY_MillSign¶

KEY_MillSign: int

KEY_ModeLock¶

KEY_ModeLock: int

KEY_Mode_switch¶

KEY_Mode_switch: int

KEY_MonBrightnessCycle¶

KEY_MonBrightnessCycle: int

KEY_MonBrightnessDown¶

KEY_MonBrightnessDown: int

KEY_MonBrightnessUp¶

KEY_MonBrightnessUp: int

KEY_MouseKeys_Accel_Enable¶

KEY_MouseKeys_Accel_Enable: int

KEY_MouseKeys_Enable¶

KEY_MouseKeys_Enable: int

KEY_Muhenkan¶

KEY_Muhenkan: int

KEY_Multi_key¶

KEY_Multi_key: int

KEY_MultipleCandidate¶

KEY_MultipleCandidate: int

KEY_Music¶

KEY_Music: int

KEY_MyComputer¶

KEY_MyComputer: int

KEY_MySites¶

KEY_MySites: int

KEY_N¶

KEY_N: int

KEY_Nacute¶

KEY_Nacute: int

KEY_NairaSign¶

KEY_NairaSign: int

KEY_NavChart¶

KEY_NavChart: int

KEY_NavInfo¶

KEY_NavInfo: int

KEY_Ncaron¶

KEY_Ncaron: int

KEY_Ncedilla¶

KEY_Ncedilla: int

KEY_New¶

KEY_New: int

KEY_NewSheqelSign¶

KEY_NewSheqelSign: int

KEY_News¶

KEY_News: int

KEY_Next¶

KEY_Next: int

KEY_NextElement¶

KEY_NextElement: int

KEY_NextFavorite¶

KEY_NextFavorite: int

KEY_Next_VMode¶

KEY_Next_VMode: int

KEY_Next_Virtual_Screen¶

KEY_Next_Virtual_Screen: int

KEY_NotificationCenter¶

KEY_NotificationCenter: int

KEY_Ntilde¶

KEY_Ntilde: int

KEY_Num_Lock¶

KEY_Num_Lock: int

KEY_Numeric0¶

KEY_Numeric0: int

KEY_Numeric1¶

KEY_Numeric1: int

KEY_Numeric11¶

KEY_Numeric11: int

KEY_Numeric12¶

KEY_Numeric12: int

KEY_Numeric2¶

KEY_Numeric2: int

KEY_Numeric3¶

KEY_Numeric3: int

KEY_Numeric4¶

KEY_Numeric4: int

KEY_Numeric5¶

KEY_Numeric5: int

KEY_Numeric6¶

KEY_Numeric6: int

KEY_Numeric7¶

KEY_Numeric7: int

KEY_Numeric8¶

KEY_Numeric8: int

KEY_Numeric9¶

KEY_Numeric9: int

KEY_NumericA¶

KEY_NumericA: int

KEY_NumericB¶

KEY_NumericB: int

KEY_NumericC¶

KEY_NumericC: int

KEY_NumericD¶

KEY_NumericD: int

KEY_NumericPound¶

KEY_NumericPound: int

KEY_NumericStar¶

KEY_NumericStar: int

KEY_O¶

KEY_O: int

KEY_OE¶

KEY_OE: int

KEY_Oacute¶

KEY_Oacute: int

KEY_Obarred¶

KEY_Obarred: int

KEY_Obelowdot¶

KEY_Obelowdot: int

KEY_Ocaron¶

KEY_Ocaron: int

KEY_Ocircumflex¶

KEY_Ocircumflex: int

KEY_Ocircumflexacute¶

KEY_Ocircumflexacute: int

KEY_Ocircumflexbelowdot¶

KEY_Ocircumflexbelowdot: int

KEY_Ocircumflexgrave¶

KEY_Ocircumflexgrave: int

KEY_Ocircumflexhook¶

KEY_Ocircumflexhook: int

KEY_Ocircumflextilde¶

KEY_Ocircumflextilde: int

KEY_Odiaeresis¶

KEY_Odiaeresis: int

KEY_Odoubleacute¶

KEY_Odoubleacute: int

KEY_OfficeHome¶

KEY_OfficeHome: int

KEY_Ograve¶

KEY_Ograve: int

KEY_Ohook¶

KEY_Ohook: int

KEY_Ohorn¶

KEY_Ohorn: int

KEY_Ohornacute¶

KEY_Ohornacute: int

KEY_Ohornbelowdot¶

KEY_Ohornbelowdot: int

KEY_Ohorngrave¶

KEY_Ohorngrave: int

KEY_Ohornhook¶

KEY_Ohornhook: int

KEY_Ohorntilde¶

KEY_Ohorntilde: int

KEY_Omacron¶

KEY_Omacron: int

KEY_OnScreenKeyboard¶

KEY_OnScreenKeyboard: int

KEY_Ooblique¶

KEY_Ooblique: int

KEY_Open¶

KEY_Open: int

KEY_OpenURL¶

KEY_OpenURL: int

KEY_Option¶

KEY_Option: int

KEY_Oslash¶

KEY_Oslash: int

KEY_Otilde¶

KEY_Otilde: int

KEY_Overlay1_Enable¶

KEY_Overlay1_Enable: int

KEY_Overlay2_Enable¶

KEY_Overlay2_Enable: int

KEY_P¶

KEY_P: int

KEY_Pabovedot¶

KEY_Pabovedot: int

KEY_Page_Down¶

KEY_Page_Down: int

KEY_Page_Up¶

KEY_Page_Up: int

KEY_Paste¶

KEY_Paste: int

KEY_Pause¶

KEY_Pause: int

KEY_PauseRecord¶

KEY_PauseRecord: int

KEY_PesetaSign¶

KEY_PesetaSign: int

KEY_Phone¶

KEY_Phone: int

KEY_PickupPhone¶

KEY_PickupPhone: int

KEY_Pictures¶

KEY_Pictures: int

KEY_Pointer_Accelerate¶

KEY_Pointer_Accelerate: int

KEY_Pointer_Button1¶

KEY_Pointer_Button1: int

KEY_Pointer_Button2¶

KEY_Pointer_Button2: int

KEY_Pointer_Button3¶

KEY_Pointer_Button3: int

KEY_Pointer_Button4¶

KEY_Pointer_Button4: int

KEY_Pointer_Button5¶

KEY_Pointer_Button5: int

KEY_Pointer_Button_Dflt¶

KEY_Pointer_Button_Dflt: int

KEY_Pointer_DblClick1¶

KEY_Pointer_DblClick1: int

KEY_Pointer_DblClick2¶

KEY_Pointer_DblClick2: int

KEY_Pointer_DblClick3¶

KEY_Pointer_DblClick3: int

KEY_Pointer_DblClick4¶

KEY_Pointer_DblClick4: int

KEY_Pointer_DblClick5¶

KEY_Pointer_DblClick5: int

KEY_Pointer_DblClick_Dflt¶

KEY_Pointer_DblClick_Dflt: int

KEY_Pointer_DfltBtnNext¶

KEY_Pointer_DfltBtnNext: int

KEY_Pointer_DfltBtnPrev¶

KEY_Pointer_DfltBtnPrev: int

KEY_Pointer_Down¶

KEY_Pointer_Down: int

KEY_Pointer_DownLeft¶

KEY_Pointer_DownLeft: int

KEY_Pointer_DownRight¶

KEY_Pointer_DownRight: int

KEY_Pointer_Drag1¶

KEY_Pointer_Drag1: int

KEY_Pointer_Drag2¶

KEY_Pointer_Drag2: int

KEY_Pointer_Drag3¶

KEY_Pointer_Drag3: int

KEY_Pointer_Drag4¶

KEY_Pointer_Drag4: int

KEY_Pointer_Drag5¶

KEY_Pointer_Drag5: int

KEY_Pointer_Drag_Dflt¶

KEY_Pointer_Drag_Dflt: int

KEY_Pointer_EnableKeys¶

KEY_Pointer_EnableKeys: int

KEY_Pointer_Left¶

KEY_Pointer_Left: int

KEY_Pointer_Right¶

KEY_Pointer_Right: int

KEY_Pointer_Up¶

KEY_Pointer_Up: int

KEY_Pointer_UpLeft¶

KEY_Pointer_UpLeft: int

KEY_Pointer_UpRight¶

KEY_Pointer_UpRight: int

KEY_PowerDown¶

KEY_PowerDown: int

KEY_PowerOff¶

KEY_PowerOff: int

KEY_Presentation¶

KEY_Presentation: int

KEY_Prev_VMode¶

KEY_Prev_VMode: int

KEY_Prev_Virtual_Screen¶

KEY_Prev_Virtual_Screen: int

KEY_PreviousCandidate¶

KEY_PreviousCandidate: int

KEY_PreviousElement¶

KEY_PreviousElement: int

KEY_Print¶

KEY_Print: int

KEY_Prior¶

KEY_Prior: int

KEY_PrivacyScreenToggle¶

KEY_PrivacyScreenToggle: int

KEY_Q¶

KEY_Q: int

KEY_R¶

KEY_R: int

KEY_R1¶

KEY_R1: int

KEY_R10¶

KEY_R10: int

KEY_R11¶

KEY_R11: int

KEY_R12¶

KEY_R12: int

KEY_R13¶

KEY_R13: int

KEY_R14¶

KEY_R14: int

KEY_R15¶

KEY_R15: int

KEY_R2¶

KEY_R2: int

KEY_R3¶

KEY_R3: int

KEY_R4¶

KEY_R4: int

KEY_R5¶

KEY_R5: int

KEY_R6¶

KEY_R6: int

KEY_R7¶

KEY_R7: int

KEY_R8¶

KEY_R8: int

KEY_R9¶

KEY_R9: int

KEY_RFKill¶

KEY_RFKill: int

KEY_Racute¶

KEY_Racute: int

KEY_RadarOverlay¶

KEY_RadarOverlay: int

KEY_Rcaron¶

KEY_Rcaron: int

KEY_Rcedilla¶

KEY_Rcedilla: int

KEY_Red¶

KEY_Red: int

KEY_Redo¶

KEY_Redo: int

KEY_Refresh¶

KEY_Refresh: int

KEY_RefreshRateToggle¶

KEY_RefreshRateToggle: int

KEY_Reload¶

KEY_Reload: int

KEY_RepeatKeys_Enable¶

KEY_RepeatKeys_Enable: int

KEY_Reply¶

KEY_Reply: int

KEY_Return¶

KEY_Return: int

KEY_Right¶

KEY_Right: int

KEY_RightDown¶

KEY_RightDown: int

KEY_RightUp¶

KEY_RightUp: int

KEY_RockerDown¶

KEY_RockerDown: int

KEY_RockerEnter¶

KEY_RockerEnter: int

KEY_RockerUp¶

KEY_RockerUp: int

KEY_Romaji¶

KEY_Romaji: int

KEY_RootMenu¶

KEY_RootMenu: int

KEY_RotateWindows¶

KEY_RotateWindows: int

KEY_RotationKB¶

KEY_RotationKB: int

KEY_RotationLockToggle¶

KEY_RotationLockToggle: int

KEY_RotationPB¶

KEY_RotationPB: int

KEY_RupeeSign¶

KEY_RupeeSign: int

KEY_S¶

KEY_S: int

KEY_SCHWA¶

KEY_SCHWA: int

KEY_Sabovedot¶

KEY_Sabovedot: int

KEY_Sacute¶

KEY_Sacute: int

KEY_Save¶

KEY_Save: int

KEY_Scaron¶

KEY_Scaron: int

KEY_Scedilla¶

KEY_Scedilla: int

KEY_Scircumflex¶

KEY_Scircumflex: int

KEY_ScreenSaver¶

KEY_ScreenSaver: int

KEY_Screensaver¶

KEY_Screensaver: int

KEY_ScrollClick¶

KEY_ScrollClick: int

KEY_ScrollDown¶

KEY_ScrollDown: int

KEY_ScrollUp¶

KEY_ScrollUp: int

KEY_Scroll_Lock¶

KEY_Scroll_Lock: int

KEY_Search¶

KEY_Search: int

KEY_Select¶

KEY_Select: int

KEY_SelectButton¶

KEY_SelectButton: int

KEY_SelectiveScreenshot¶

KEY_SelectiveScreenshot: int

KEY_Send¶

KEY_Send: int

KEY_Serbian_DJE¶

KEY_Serbian_DJE: int

KEY_Serbian_DZE¶

KEY_Serbian_DZE: int

KEY_Serbian_JE¶

KEY_Serbian_JE: int

KEY_Serbian_LJE¶

KEY_Serbian_LJE: int

KEY_Serbian_NJE¶

KEY_Serbian_NJE: int

KEY_Serbian_TSHE¶

KEY_Serbian_TSHE: int

KEY_Serbian_dje¶

KEY_Serbian_dje: int

KEY_Serbian_dze¶

KEY_Serbian_dze: int

KEY_Serbian_je¶

KEY_Serbian_je: int

KEY_Serbian_lje¶

KEY_Serbian_lje: int

KEY_Serbian_nje¶

KEY_Serbian_nje: int

KEY_Serbian_tshe¶

KEY_Serbian_tshe: int

KEY_Shift_L¶

KEY_Shift_L: int

KEY_Shift_Lock¶

KEY_Shift_Lock: int

KEY_Shift_R¶

KEY_Shift_R: int

KEY_Shop¶

KEY_Shop: int

KEY_SidevuSonar¶

KEY_SidevuSonar: int

KEY_SingleCandidate¶

KEY_SingleCandidate: int

KEY_SingleRangeRadar¶

KEY_SingleRangeRadar: int

KEY_Sinh_a¶

KEY_Sinh_a: int

KEY_Sinh_aa¶

KEY_Sinh_aa: int

KEY_Sinh_aa2¶

KEY_Sinh_aa2: int

KEY_Sinh_ae¶

KEY_Sinh_ae: int

KEY_Sinh_ae2¶

KEY_Sinh_ae2: int

KEY_Sinh_aee¶

KEY_Sinh_aee: int

KEY_Sinh_aee2¶

KEY_Sinh_aee2: int

KEY_Sinh_ai¶

KEY_Sinh_ai: int

KEY_Sinh_ai2¶

KEY_Sinh_ai2: int

KEY_Sinh_al¶

KEY_Sinh_al: int

KEY_Sinh_au¶

KEY_Sinh_au: int

KEY_Sinh_au2¶

KEY_Sinh_au2: int

KEY_Sinh_ba¶

KEY_Sinh_ba: int

KEY_Sinh_bha¶

KEY_Sinh_bha: int

KEY_Sinh_ca¶

KEY_Sinh_ca: int

KEY_Sinh_cha¶

KEY_Sinh_cha: int

KEY_Sinh_dda¶

KEY_Sinh_dda: int

KEY_Sinh_ddha¶

KEY_Sinh_ddha: int

KEY_Sinh_dha¶

KEY_Sinh_dha: int

KEY_Sinh_dhha¶

KEY_Sinh_dhha: int

KEY_Sinh_e¶

KEY_Sinh_e: int

KEY_Sinh_e2¶

KEY_Sinh_e2: int

KEY_Sinh_ee¶

KEY_Sinh_ee: int

KEY_Sinh_ee2¶

KEY_Sinh_ee2: int

KEY_Sinh_fa¶

KEY_Sinh_fa: int

KEY_Sinh_ga¶

KEY_Sinh_ga: int

KEY_Sinh_gha¶

KEY_Sinh_gha: int

KEY_Sinh_h2¶

KEY_Sinh_h2: int

KEY_Sinh_ha¶

KEY_Sinh_ha: int

KEY_Sinh_i¶

KEY_Sinh_i: int

KEY_Sinh_i2¶

KEY_Sinh_i2: int

KEY_Sinh_ii¶

KEY_Sinh_ii: int

KEY_Sinh_ii2¶

KEY_Sinh_ii2: int

KEY_Sinh_ja¶

KEY_Sinh_ja: int

KEY_Sinh_jha¶

KEY_Sinh_jha: int

KEY_Sinh_jnya¶

KEY_Sinh_jnya: int

KEY_Sinh_ka¶

KEY_Sinh_ka: int

KEY_Sinh_kha¶

KEY_Sinh_kha: int

KEY_Sinh_kunddaliya¶

KEY_Sinh_kunddaliya: int

KEY_Sinh_la¶

KEY_Sinh_la: int

KEY_Sinh_lla¶

KEY_Sinh_lla: int

KEY_Sinh_lu¶

KEY_Sinh_lu: int

KEY_Sinh_lu2¶

KEY_Sinh_lu2: int

KEY_Sinh_luu¶

KEY_Sinh_luu: int

KEY_Sinh_luu2¶

KEY_Sinh_luu2: int

KEY_Sinh_ma¶

KEY_Sinh_ma: int

KEY_Sinh_mba¶

KEY_Sinh_mba: int

KEY_Sinh_na¶

KEY_Sinh_na: int

KEY_Sinh_ndda¶

KEY_Sinh_ndda: int

KEY_Sinh_ndha¶

KEY_Sinh_ndha: int

KEY_Sinh_ng¶

KEY_Sinh_ng: int

KEY_Sinh_ng2¶

KEY_Sinh_ng2: int

KEY_Sinh_nga¶

KEY_Sinh_nga: int

KEY_Sinh_nja¶

KEY_Sinh_nja: int

KEY_Sinh_nna¶

KEY_Sinh_nna: int

KEY_Sinh_nya¶

KEY_Sinh_nya: int

KEY_Sinh_o¶

KEY_Sinh_o: int

KEY_Sinh_o2¶

KEY_Sinh_o2: int

KEY_Sinh_oo¶

KEY_Sinh_oo: int

KEY_Sinh_oo2¶

KEY_Sinh_oo2: int

KEY_Sinh_pa¶

KEY_Sinh_pa: int

KEY_Sinh_pha¶

KEY_Sinh_pha: int

KEY_Sinh_ra¶

KEY_Sinh_ra: int

KEY_Sinh_ri¶

KEY_Sinh_ri: int

KEY_Sinh_rii¶

KEY_Sinh_rii: int

KEY_Sinh_ru2¶

KEY_Sinh_ru2: int

KEY_Sinh_ruu2¶

KEY_Sinh_ruu2: int

KEY_Sinh_sa¶

KEY_Sinh_sa: int

KEY_Sinh_sha¶

KEY_Sinh_sha: int

KEY_Sinh_ssha¶

KEY_Sinh_ssha: int

KEY_Sinh_tha¶

KEY_Sinh_tha: int

KEY_Sinh_thha¶

KEY_Sinh_thha: int

KEY_Sinh_tta¶

KEY_Sinh_tta: int

KEY_Sinh_ttha¶

KEY_Sinh_ttha: int

KEY_Sinh_u¶

KEY_Sinh_u: int

KEY_Sinh_u2¶

KEY_Sinh_u2: int

KEY_Sinh_uu¶

KEY_Sinh_uu: int

KEY_Sinh_uu2¶

KEY_Sinh_uu2: int

KEY_Sinh_va¶

KEY_Sinh_va: int

KEY_Sinh_ya¶

KEY_Sinh_ya: int

KEY_Sleep¶

KEY_Sleep: int

KEY_SlowKeys_Enable¶

KEY_SlowKeys_Enable: int

KEY_SlowReverse¶

KEY_SlowReverse: int

KEY_Sos¶

KEY_Sos: int

KEY_Spell¶

KEY_Spell: int

KEY_SpellCheck¶

KEY_SpellCheck: int

KEY_SplitScreen¶

KEY_SplitScreen: int

KEY_Standby¶

KEY_Standby: int

KEY_Start¶

KEY_Start: int

KEY_StickyKeys_Enable¶

KEY_StickyKeys_Enable: int

KEY_Stop¶

KEY_Stop: int

KEY_StopRecord¶

KEY_StopRecord: int

KEY_Subtitle¶

KEY_Subtitle: int

KEY_Super_L¶

KEY_Super_L: int

KEY_Super_R¶

KEY_Super_R: int

KEY_Support¶

KEY_Support: int

KEY_Suspend¶

KEY_Suspend: int

KEY_Switch_VT_1¶

KEY_Switch_VT_1: int

KEY_Switch_VT_10¶

KEY_Switch_VT_10: int

KEY_Switch_VT_11¶

KEY_Switch_VT_11: int

KEY_Switch_VT_12¶

KEY_Switch_VT_12: int

KEY_Switch_VT_2¶

KEY_Switch_VT_2: int

KEY_Switch_VT_3¶

KEY_Switch_VT_3: int

KEY_Switch_VT_4¶

KEY_Switch_VT_4: int

KEY_Switch_VT_5¶

KEY_Switch_VT_5: int

KEY_Switch_VT_6¶

KEY_Switch_VT_6: int

KEY_Switch_VT_7¶

KEY_Switch_VT_7: int

KEY_Switch_VT_8¶

KEY_Switch_VT_8: int

KEY_Switch_VT_9¶

KEY_Switch_VT_9: int

KEY_Sys_Req¶

KEY_Sys_Req: int

KEY_T¶

KEY_T: int

KEY_THORN¶

KEY_THORN: int

KEY_Tab¶

KEY_Tab: int

KEY_Tabovedot¶

KEY_Tabovedot: int

KEY_TaskPane¶

KEY_TaskPane: int

KEY_Taskmanager¶

KEY_Taskmanager: int

KEY_Tcaron¶

KEY_Tcaron: int

KEY_Tcedilla¶

KEY_Tcedilla: int

KEY_Terminal¶

KEY_Terminal: int

KEY_Terminate_Server¶

KEY_Terminate_Server: int

KEY_Thai_baht¶

KEY_Thai_baht: int

KEY_Thai_bobaimai¶

KEY_Thai_bobaimai: int

KEY_Thai_chochan¶

KEY_Thai_chochan: int

KEY_Thai_chochang¶

KEY_Thai_chochang: int

KEY_Thai_choching¶

KEY_Thai_choching: int

KEY_Thai_chochoe¶

KEY_Thai_chochoe: int

KEY_Thai_dochada¶

KEY_Thai_dochada: int

KEY_Thai_dodek¶

KEY_Thai_dodek: int

KEY_Thai_fofa¶

KEY_Thai_fofa: int

KEY_Thai_fofan¶

KEY_Thai_fofan: int

KEY_Thai_hohip¶

KEY_Thai_hohip: int

KEY_Thai_honokhuk¶

KEY_Thai_honokhuk: int

KEY_Thai_khokhai¶

KEY_Thai_khokhai: int

KEY_Thai_khokhon¶

KEY_Thai_khokhon: int

KEY_Thai_khokhuat¶

KEY_Thai_khokhuat: int

KEY_Thai_khokhwai¶

KEY_Thai_khokhwai: int

KEY_Thai_khorakhang¶

KEY_Thai_khorakhang: int

KEY_Thai_kokai¶

KEY_Thai_kokai: int

KEY_Thai_lakkhangyao¶

KEY_Thai_lakkhangyao: int

KEY_Thai_lekchet¶

KEY_Thai_lekchet: int

KEY_Thai_lekha¶

KEY_Thai_lekha: int

KEY_Thai_lekhok¶

KEY_Thai_lekhok: int

KEY_Thai_lekkao¶

KEY_Thai_lekkao: int

KEY_Thai_leknung¶

KEY_Thai_leknung: int

KEY_Thai_lekpaet¶

KEY_Thai_lekpaet: int

KEY_Thai_leksam¶

KEY_Thai_leksam: int

KEY_Thai_leksi¶

KEY_Thai_leksi: int

KEY_Thai_leksong¶

KEY_Thai_leksong: int

KEY_Thai_leksun¶

KEY_Thai_leksun: int

KEY_Thai_lochula¶

KEY_Thai_lochula: int

KEY_Thai_loling¶

KEY_Thai_loling: int

KEY_Thai_lu¶

KEY_Thai_lu: int

KEY_Thai_maichattawa¶

KEY_Thai_maichattawa: int

KEY_Thai_maiek¶

KEY_Thai_maiek: int

KEY_Thai_maihanakat¶

KEY_Thai_maihanakat: int

KEY_Thai_maihanakat_maitho¶

KEY_Thai_maihanakat_maitho: int

KEY_Thai_maitaikhu¶

KEY_Thai_maitaikhu: int

KEY_Thai_maitho¶

KEY_Thai_maitho: int

KEY_Thai_maitri¶

KEY_Thai_maitri: int

KEY_Thai_maiyamok¶

KEY_Thai_maiyamok: int

KEY_Thai_moma¶

KEY_Thai_moma: int

KEY_Thai_ngongu¶

KEY_Thai_ngongu: int

KEY_Thai_nikhahit¶

KEY_Thai_nikhahit: int

KEY_Thai_nonen¶

KEY_Thai_nonen: int

KEY_Thai_nonu¶

KEY_Thai_nonu: int

KEY_Thai_oang¶

KEY_Thai_oang: int

KEY_Thai_paiyannoi¶

KEY_Thai_paiyannoi: int

KEY_Thai_phinthu¶

KEY_Thai_phinthu: int

KEY_Thai_phophan¶

KEY_Thai_phophan: int

KEY_Thai_phophung¶

KEY_Thai_phophung: int

KEY_Thai_phosamphao¶

KEY_Thai_phosamphao: int

KEY_Thai_popla¶

KEY_Thai_popla: int

KEY_Thai_rorua¶

KEY_Thai_rorua: int

KEY_Thai_ru¶

KEY_Thai_ru: int

KEY_Thai_saraa¶

KEY_Thai_saraa: int

KEY_Thai_saraaa¶

KEY_Thai_saraaa: int

KEY_Thai_saraae¶

KEY_Thai_saraae: int

KEY_Thai_saraaimaimalai¶

KEY_Thai_saraaimaimalai: int

KEY_Thai_saraaimaimuan¶

KEY_Thai_saraaimaimuan: int

KEY_Thai_saraam¶

KEY_Thai_saraam: int

KEY_Thai_sarae¶

KEY_Thai_sarae: int

KEY_Thai_sarai¶

KEY_Thai_sarai: int

KEY_Thai_saraii¶

KEY_Thai_saraii: int

KEY_Thai_sarao¶

KEY_Thai_sarao: int

KEY_Thai_sarau¶

KEY_Thai_sarau: int

KEY_Thai_saraue¶

KEY_Thai_saraue: int

KEY_Thai_sarauee¶

KEY_Thai_sarauee: int

KEY_Thai_sarauu¶

KEY_Thai_sarauu: int

KEY_Thai_sorusi¶

KEY_Thai_sorusi: int

KEY_Thai_sosala¶

KEY_Thai_sosala: int

KEY_Thai_soso¶

KEY_Thai_soso: int

KEY_Thai_sosua¶

KEY_Thai_sosua: int

KEY_Thai_thanthakhat¶

KEY_Thai_thanthakhat: int

KEY_Thai_thonangmontho¶

KEY_Thai_thonangmontho: int

KEY_Thai_thophuthao¶

KEY_Thai_thophuthao: int

KEY_Thai_thothahan¶

KEY_Thai_thothahan: int

KEY_Thai_thothan¶

KEY_Thai_thothan: int

KEY_Thai_thothong¶

KEY_Thai_thothong: int

KEY_Thai_thothung¶

KEY_Thai_thothung: int

KEY_Thai_topatak¶

KEY_Thai_topatak: int

KEY_Thai_totao¶

KEY_Thai_totao: int

KEY_Thai_wowaen¶

KEY_Thai_wowaen: int

KEY_Thai_yoyak¶

KEY_Thai_yoyak: int

KEY_Thai_yoying¶

KEY_Thai_yoying: int

KEY_Thorn¶

KEY_Thorn: int

KEY_Time¶

KEY_Time: int

KEY_ToDoList¶

KEY_ToDoList: int

KEY_Tools¶

KEY_Tools: int

KEY_TopMenu¶

KEY_TopMenu: int

KEY_TouchpadOff¶

KEY_TouchpadOff: int

KEY_TouchpadOn¶

KEY_TouchpadOn: int

KEY_TouchpadToggle¶

KEY_TouchpadToggle: int

KEY_Touroku¶

KEY_Touroku: int

KEY_TraditionalSonar¶

KEY_TraditionalSonar: int

KEY_Travel¶

KEY_Travel: int

KEY_Tslash¶

KEY_Tslash: int

KEY_U¶

KEY_U: int

KEY_UWB¶

KEY_UWB: int

KEY_Uacute¶

KEY_Uacute: int

KEY_Ubelowdot¶

KEY_Ubelowdot: int

KEY_Ubreve¶

KEY_Ubreve: int

KEY_Ucircumflex¶

KEY_Ucircumflex: int

KEY_Udiaeresis¶

KEY_Udiaeresis: int

KEY_Udoubleacute¶

KEY_Udoubleacute: int

KEY_Ugrave¶

KEY_Ugrave: int

KEY_Uhook¶

KEY_Uhook: int

KEY_Uhorn¶

KEY_Uhorn: int

KEY_Uhornacute¶

KEY_Uhornacute: int

KEY_Uhornbelowdot¶

KEY_Uhornbelowdot: int

KEY_Uhorngrave¶

KEY_Uhorngrave: int

KEY_Uhornhook¶

KEY_Uhornhook: int

KEY_Uhorntilde¶

KEY_Uhorntilde: int

KEY_Ukrainian_GHE_WITH_UPTURN¶

KEY_Ukrainian_GHE_WITH_UPTURN: int

KEY_Ukrainian_I¶

KEY_Ukrainian_I: int

KEY_Ukrainian_IE¶

KEY_Ukrainian_IE: int

KEY_Ukrainian_YI¶

KEY_Ukrainian_YI: int

KEY_Ukrainian_ghe_with_upturn¶

KEY_Ukrainian_ghe_with_upturn: int

KEY_Ukrainian_i¶

KEY_Ukrainian_i: int

KEY_Ukrainian_ie¶

KEY_Ukrainian_ie: int

KEY_Ukrainian_yi¶

KEY_Ukrainian_yi: int

KEY_Ukranian_I¶

KEY_Ukranian_I: int

KEY_Ukranian_JE¶

KEY_Ukranian_JE: int

KEY_Ukranian_YI¶

KEY_Ukranian_YI: int

KEY_Ukranian_i¶

KEY_Ukranian_i: int

KEY_Ukranian_je¶

KEY_Ukranian_je: int

KEY_Ukranian_yi¶

KEY_Ukranian_yi: int

KEY_Umacron¶

KEY_Umacron: int

KEY_Undo¶

KEY_Undo: int

KEY_Ungrab¶

KEY_Ungrab: int

KEY_Unmute¶

KEY_Unmute: int

KEY_Uogonek¶

KEY_Uogonek: int

KEY_Up¶

KEY_Up: int

KEY_Uring¶

KEY_Uring: int

KEY_User1KB¶

KEY_User1KB: int

KEY_User2KB¶

KEY_User2KB: int

KEY_UserPB¶

KEY_UserPB: int

KEY_Utilde¶

KEY_Utilde: int

KEY_V¶

KEY_V: int

KEY_VOD¶

KEY_VOD: int

KEY_VendorHome¶

KEY_VendorHome: int

KEY_Video¶

KEY_Video: int

KEY_VideoPhone¶

KEY_VideoPhone: int

KEY_View¶

KEY_View: int

KEY_VoiceCommand¶

KEY_VoiceCommand: int

KEY_Voicemail¶

KEY_Voicemail: int

KEY_VoidSymbol¶

KEY_VoidSymbol: int

KEY_W¶

KEY_W: int

KEY_WLAN¶

KEY_WLAN: int

KEY_WPSButton¶

KEY_WPSButton: int

KEY_WWAN¶

KEY_WWAN: int

KEY_WWW¶

KEY_WWW: int

KEY_Wacute¶

KEY_Wacute: int

KEY_WakeUp¶

KEY_WakeUp: int

KEY_Wcircumflex¶

KEY_Wcircumflex: int

KEY_Wdiaeresis¶

KEY_Wdiaeresis: int

KEY_WebCam¶

KEY_WebCam: int

KEY_Wgrave¶

KEY_Wgrave: int

KEY_WheelButton¶

KEY_WheelButton: int

KEY_WindowClear¶

KEY_WindowClear: int

KEY_WonSign¶

KEY_WonSign: int

KEY_Word¶

KEY_Word: int

KEY_X¶

KEY_X: int

KEY_Xabovedot¶

KEY_Xabovedot: int

KEY_Xfer¶

KEY_Xfer: int

KEY_Y¶

KEY_Y: int

KEY_Yacute¶

KEY_Yacute: int

KEY_Ybelowdot¶

KEY_Ybelowdot: int

KEY_Ycircumflex¶

KEY_Ycircumflex: int

KEY_Ydiaeresis¶

KEY_Ydiaeresis: int

KEY_Yellow¶

KEY_Yellow: int

KEY_Ygrave¶

KEY_Ygrave: int

KEY_Yhook¶

KEY_Yhook: int

KEY_Ytilde¶

KEY_Ytilde: int

KEY_Z¶

KEY_Z: int

KEY_Zabovedot¶

KEY_Zabovedot: int

KEY_Zacute¶

KEY_Zacute: int

KEY_Zcaron¶

KEY_Zcaron: int

KEY_Zen_Koho¶

KEY_Zen_Koho: int

KEY_Zenkaku¶

KEY_Zenkaku: int

KEY_Zenkaku_Hankaku¶

KEY_Zenkaku_Hankaku: int

KEY_ZoomIn¶

KEY_ZoomIn: int

KEY_ZoomOut¶

KEY_ZoomOut: int

KEY_ZoomReset¶

KEY_ZoomReset: int

KEY_Zstroke¶

KEY_Zstroke: int

KEY_a¶

KEY_a: int

KEY_aacute¶

KEY_aacute: int

KEY_abelowdot¶

KEY_abelowdot: int

KEY_abovedot¶

KEY_abovedot: int

KEY_abreve¶

KEY_abreve: int

KEY_abreveacute¶

KEY_abreveacute: int

KEY_abrevebelowdot¶

KEY_abrevebelowdot: int

KEY_abrevegrave¶

KEY_abrevegrave: int

KEY_abrevehook¶

KEY_abrevehook: int

KEY_abrevetilde¶

KEY_abrevetilde: int

KEY_acircumflex¶

KEY_acircumflex: int

KEY_acircumflexacute¶

KEY_acircumflexacute: int

KEY_acircumflexbelowdot¶

KEY_acircumflexbelowdot: int

KEY_acircumflexgrave¶

KEY_acircumflexgrave: int

KEY_acircumflexhook¶

KEY_acircumflexhook: int

KEY_acircumflextilde¶

KEY_acircumflextilde: int

KEY_acute¶

KEY_acute: int

KEY_adiaeresis¶

KEY_adiaeresis: int

KEY_ae¶

KEY_ae: int

KEY_agrave¶

KEY_agrave: int

KEY_ahook¶

KEY_ahook: int

KEY_amacron¶

KEY_amacron: int

KEY_ampersand¶

KEY_ampersand: int

KEY_aogonek¶

KEY_aogonek: int

KEY_apostrophe¶

KEY_apostrophe: int

KEY_approxeq¶

KEY_approxeq: int

KEY_approximate¶

KEY_approximate: int

KEY_aring¶

KEY_aring: int

KEY_asciicircum¶

KEY_asciicircum: int

KEY_asciitilde¶

KEY_asciitilde: int

KEY_asterisk¶

KEY_asterisk: int

KEY_at¶

KEY_at: int

KEY_atilde¶

KEY_atilde: int

KEY_b¶

KEY_b: int

KEY_babovedot¶

KEY_babovedot: int

KEY_backslash¶

KEY_backslash: int

KEY_ballotcross¶

KEY_ballotcross: int

KEY_bar¶

KEY_bar: int

KEY_because¶

KEY_because: int

KEY_blank¶

KEY_blank: int

KEY_botintegral¶

KEY_botintegral: int

KEY_botleftparens¶

KEY_botleftparens: int

KEY_botleftsqbracket¶

KEY_botleftsqbracket: int

KEY_botleftsummation¶

KEY_botleftsummation: int

KEY_botrightparens¶

KEY_botrightparens: int

KEY_botrightsqbracket¶

KEY_botrightsqbracket: int

KEY_botrightsummation¶

KEY_botrightsummation: int

KEY_bott¶

KEY_bott: int

KEY_botvertsummationconnector¶

KEY_botvertsummationconnector: int

KEY_braceleft¶

KEY_braceleft: int

KEY_braceright¶

KEY_braceright: int

KEY_bracketleft¶

KEY_bracketleft: int

KEY_bracketright¶

KEY_bracketright: int

KEY_braille_blank¶

KEY_braille_blank: int

KEY_braille_dot_1¶

KEY_braille_dot_1: int

KEY_braille_dot_10¶

KEY_braille_dot_10: int

KEY_braille_dot_2¶

KEY_braille_dot_2: int

KEY_braille_dot_3¶

KEY_braille_dot_3: int

KEY_braille_dot_4¶

KEY_braille_dot_4: int

KEY_braille_dot_5¶

KEY_braille_dot_5: int

KEY_braille_dot_6¶

KEY_braille_dot_6: int

KEY_braille_dot_7¶

KEY_braille_dot_7: int

KEY_braille_dot_8¶

KEY_braille_dot_8: int

KEY_braille_dot_9¶

KEY_braille_dot_9: int

KEY_braille_dots_1¶

KEY_braille_dots_1: int

KEY_braille_dots_12¶

KEY_braille_dots_12: int

KEY_braille_dots_123¶

KEY_braille_dots_123: int

KEY_braille_dots_1234¶

KEY_braille_dots_1234: int

KEY_braille_dots_12345¶

KEY_braille_dots_12345: int

KEY_braille_dots_123456¶

KEY_braille_dots_123456: int

KEY_braille_dots_1234567¶

KEY_braille_dots_1234567: int

KEY_braille_dots_12345678¶

KEY_braille_dots_12345678: int

KEY_braille_dots_1234568¶

KEY_braille_dots_1234568: int

KEY_braille_dots_123457¶

KEY_braille_dots_123457: int

KEY_braille_dots_1234578¶

KEY_braille_dots_1234578: int

KEY_braille_dots_123458¶

KEY_braille_dots_123458: int

KEY_braille_dots_12346¶

KEY_braille_dots_12346: int

KEY_braille_dots_123467¶

KEY_braille_dots_123467: int

KEY_braille_dots_1234678¶

KEY_braille_dots_1234678: int

KEY_braille_dots_123468¶

KEY_braille_dots_123468: int

KEY_braille_dots_12347¶

KEY_braille_dots_12347: int

KEY_braille_dots_123478¶

KEY_braille_dots_123478: int

KEY_braille_dots_12348¶

KEY_braille_dots_12348: int

KEY_braille_dots_1235¶

KEY_braille_dots_1235: int

KEY_braille_dots_12356¶

KEY_braille_dots_12356: int

KEY_braille_dots_123567¶

KEY_braille_dots_123567: int

KEY_braille_dots_1235678¶

KEY_braille_dots_1235678: int

KEY_braille_dots_123568¶

KEY_braille_dots_123568: int

KEY_braille_dots_12357¶

KEY_braille_dots_12357: int

KEY_braille_dots_123578¶

KEY_braille_dots_123578: int

KEY_braille_dots_12358¶

KEY_braille_dots_12358: int

KEY_braille_dots_1236¶

KEY_braille_dots_1236: int

KEY_braille_dots_12367¶

KEY_braille_dots_12367: int

KEY_braille_dots_123678¶

KEY_braille_dots_123678: int

KEY_braille_dots_12368¶

KEY_braille_dots_12368: int

KEY_braille_dots_1237¶

KEY_braille_dots_1237: int

KEY_braille_dots_12378¶

KEY_braille_dots_12378: int

KEY_braille_dots_1238¶

KEY_braille_dots_1238: int

KEY_braille_dots_124¶

KEY_braille_dots_124: int

KEY_braille_dots_1245¶

KEY_braille_dots_1245: int

KEY_braille_dots_12456¶

KEY_braille_dots_12456: int

KEY_braille_dots_124567¶

KEY_braille_dots_124567: int

KEY_braille_dots_1245678¶

KEY_braille_dots_1245678: int

KEY_braille_dots_124568¶

KEY_braille_dots_124568: int

KEY_braille_dots_12457¶

KEY_braille_dots_12457: int

KEY_braille_dots_124578¶

KEY_braille_dots_124578: int

KEY_braille_dots_12458¶

KEY_braille_dots_12458: int

KEY_braille_dots_1246¶

KEY_braille_dots_1246: int

KEY_braille_dots_12467¶

KEY_braille_dots_12467: int

KEY_braille_dots_124678¶

KEY_braille_dots_124678: int

KEY_braille_dots_12468¶

KEY_braille_dots_12468: int

KEY_braille_dots_1247¶

KEY_braille_dots_1247: int

KEY_braille_dots_12478¶

KEY_braille_dots_12478: int

KEY_braille_dots_1248¶

KEY_braille_dots_1248: int

KEY_braille_dots_125¶

KEY_braille_dots_125: int

KEY_braille_dots_1256¶

KEY_braille_dots_1256: int

KEY_braille_dots_12567¶

KEY_braille_dots_12567: int

KEY_braille_dots_125678¶

KEY_braille_dots_125678: int

KEY_braille_dots_12568¶

KEY_braille_dots_12568: int

KEY_braille_dots_1257¶

KEY_braille_dots_1257: int

KEY_braille_dots_12578¶

KEY_braille_dots_12578: int

KEY_braille_dots_1258¶

KEY_braille_dots_1258: int

KEY_braille_dots_126¶

KEY_braille_dots_126: int

KEY_braille_dots_1267¶

KEY_braille_dots_1267: int

KEY_braille_dots_12678¶

KEY_braille_dots_12678: int

KEY_braille_dots_1268¶

KEY_braille_dots_1268: int

KEY_braille_dots_127¶

KEY_braille_dots_127: int

KEY_braille_dots_1278¶

KEY_braille_dots_1278: int

KEY_braille_dots_128¶

KEY_braille_dots_128: int

KEY_braille_dots_13¶

KEY_braille_dots_13: int

KEY_braille_dots_134¶

KEY_braille_dots_134: int

KEY_braille_dots_1345¶

KEY_braille_dots_1345: int

KEY_braille_dots_13456¶

KEY_braille_dots_13456: int

KEY_braille_dots_134567¶

KEY_braille_dots_134567: int

KEY_braille_dots_1345678¶

KEY_braille_dots_1345678: int

KEY_braille_dots_134568¶

KEY_braille_dots_134568: int

KEY_braille_dots_13457¶

KEY_braille_dots_13457: int

KEY_braille_dots_134578¶

KEY_braille_dots_134578: int

KEY_braille_dots_13458¶

KEY_braille_dots_13458: int

KEY_braille_dots_1346¶

KEY_braille_dots_1346: int

KEY_braille_dots_13467¶

KEY_braille_dots_13467: int

KEY_braille_dots_134678¶

KEY_braille_dots_134678: int

KEY_braille_dots_13468¶

KEY_braille_dots_13468: int

KEY_braille_dots_1347¶

KEY_braille_dots_1347: int

KEY_braille_dots_13478¶

KEY_braille_dots_13478: int

KEY_braille_dots_1348¶

KEY_braille_dots_1348: int

KEY_braille_dots_135¶

KEY_braille_dots_135: int

KEY_braille_dots_1356¶

KEY_braille_dots_1356: int

KEY_braille_dots_13567¶

KEY_braille_dots_13567: int

KEY_braille_dots_135678¶

KEY_braille_dots_135678: int

KEY_braille_dots_13568¶

KEY_braille_dots_13568: int

KEY_braille_dots_1357¶

KEY_braille_dots_1357: int

KEY_braille_dots_13578¶

KEY_braille_dots_13578: int

KEY_braille_dots_1358¶

KEY_braille_dots_1358: int

KEY_braille_dots_136¶

KEY_braille_dots_136: int

KEY_braille_dots_1367¶

KEY_braille_dots_1367: int

KEY_braille_dots_13678¶

KEY_braille_dots_13678: int

KEY_braille_dots_1368¶

KEY_braille_dots_1368: int

KEY_braille_dots_137¶

KEY_braille_dots_137: int

KEY_braille_dots_1378¶

KEY_braille_dots_1378: int

KEY_braille_dots_138¶

KEY_braille_dots_138: int

KEY_braille_dots_14¶

KEY_braille_dots_14: int

KEY_braille_dots_145¶

KEY_braille_dots_145: int

KEY_braille_dots_1456¶

KEY_braille_dots_1456: int

KEY_braille_dots_14567¶

KEY_braille_dots_14567: int

KEY_braille_dots_145678¶

KEY_braille_dots_145678: int

KEY_braille_dots_14568¶

KEY_braille_dots_14568: int

KEY_braille_dots_1457¶

KEY_braille_dots_1457: int

KEY_braille_dots_14578¶

KEY_braille_dots_14578: int

KEY_braille_dots_1458¶

KEY_braille_dots_1458: int

KEY_braille_dots_146¶

KEY_braille_dots_146: int

KEY_braille_dots_1467¶

KEY_braille_dots_1467: int

KEY_braille_dots_14678¶

KEY_braille_dots_14678: int

KEY_braille_dots_1468¶

KEY_braille_dots_1468: int

KEY_braille_dots_147¶

KEY_braille_dots_147: int

KEY_braille_dots_1478¶

KEY_braille_dots_1478: int

KEY_braille_dots_148¶

KEY_braille_dots_148: int

KEY_braille_dots_15¶

KEY_braille_dots_15: int

KEY_braille_dots_156¶

KEY_braille_dots_156: int

KEY_braille_dots_1567¶

KEY_braille_dots_1567: int

KEY_braille_dots_15678¶

KEY_braille_dots_15678: int

KEY_braille_dots_1568¶

KEY_braille_dots_1568: int

KEY_braille_dots_157¶

KEY_braille_dots_157: int

KEY_braille_dots_1578¶

KEY_braille_dots_1578: int

KEY_braille_dots_158¶

KEY_braille_dots_158: int

KEY_braille_dots_16¶

KEY_braille_dots_16: int

KEY_braille_dots_167¶

KEY_braille_dots_167: int

KEY_braille_dots_1678¶

KEY_braille_dots_1678: int

KEY_braille_dots_168¶

KEY_braille_dots_168: int

KEY_braille_dots_17¶

KEY_braille_dots_17: int

KEY_braille_dots_178¶

KEY_braille_dots_178: int

KEY_braille_dots_18¶

KEY_braille_dots_18: int

KEY_braille_dots_2¶

KEY_braille_dots_2: int

KEY_braille_dots_23¶

KEY_braille_dots_23: int

KEY_braille_dots_234¶

KEY_braille_dots_234: int

KEY_braille_dots_2345¶

KEY_braille_dots_2345: int

KEY_braille_dots_23456¶

KEY_braille_dots_23456: int

KEY_braille_dots_234567¶

KEY_braille_dots_234567: int

KEY_braille_dots_2345678¶

KEY_braille_dots_2345678: int

KEY_braille_dots_234568¶

KEY_braille_dots_234568: int

KEY_braille_dots_23457¶

KEY_braille_dots_23457: int

KEY_braille_dots_234578¶

KEY_braille_dots_234578: int

KEY_braille_dots_23458¶

KEY_braille_dots_23458: int

KEY_braille_dots_2346¶

KEY_braille_dots_2346: int

KEY_braille_dots_23467¶

KEY_braille_dots_23467: int

KEY_braille_dots_234678¶

KEY_braille_dots_234678: int

KEY_braille_dots_23468¶

KEY_braille_dots_23468: int

KEY_braille_dots_2347¶

KEY_braille_dots_2347: int

KEY_braille_dots_23478¶

KEY_braille_dots_23478: int

KEY_braille_dots_2348¶

KEY_braille_dots_2348: int

KEY_braille_dots_235¶

KEY_braille_dots_235: int

KEY_braille_dots_2356¶

KEY_braille_dots_2356: int

KEY_braille_dots_23567¶

KEY_braille_dots_23567: int

KEY_braille_dots_235678¶

KEY_braille_dots_235678: int

KEY_braille_dots_23568¶

KEY_braille_dots_23568: int

KEY_braille_dots_2357¶

KEY_braille_dots_2357: int

KEY_braille_dots_23578¶

KEY_braille_dots_23578: int

KEY_braille_dots_2358¶

KEY_braille_dots_2358: int

KEY_braille_dots_236¶

KEY_braille_dots_236: int

KEY_braille_dots_2367¶

KEY_braille_dots_2367: int

KEY_braille_dots_23678¶

KEY_braille_dots_23678: int

KEY_braille_dots_2368¶

KEY_braille_dots_2368: int

KEY_braille_dots_237¶

KEY_braille_dots_237: int

KEY_braille_dots_2378¶

KEY_braille_dots_2378: int

KEY_braille_dots_238¶

KEY_braille_dots_238: int

KEY_braille_dots_24¶

KEY_braille_dots_24: int

KEY_braille_dots_245¶

KEY_braille_dots_245: int

KEY_braille_dots_2456¶

KEY_braille_dots_2456: int

KEY_braille_dots_24567¶

KEY_braille_dots_24567: int

KEY_braille_dots_245678¶

KEY_braille_dots_245678: int

KEY_braille_dots_24568¶

KEY_braille_dots_24568: int

KEY_braille_dots_2457¶

KEY_braille_dots_2457: int

KEY_braille_dots_24578¶

KEY_braille_dots_24578: int

KEY_braille_dots_2458¶

KEY_braille_dots_2458: int

KEY_braille_dots_246¶

KEY_braille_dots_246: int

KEY_braille_dots_2467¶

KEY_braille_dots_2467: int

KEY_braille_dots_24678¶

KEY_braille_dots_24678: int

KEY_braille_dots_2468¶

KEY_braille_dots_2468: int

KEY_braille_dots_247¶

KEY_braille_dots_247: int

KEY_braille_dots_2478¶

KEY_braille_dots_2478: int

KEY_braille_dots_248¶

KEY_braille_dots_248: int

KEY_braille_dots_25¶

KEY_braille_dots_25: int

KEY_braille_dots_256¶

KEY_braille_dots_256: int

KEY_braille_dots_2567¶

KEY_braille_dots_2567: int

KEY_braille_dots_25678¶

KEY_braille_dots_25678: int

KEY_braille_dots_2568¶

KEY_braille_dots_2568: int

KEY_braille_dots_257¶

KEY_braille_dots_257: int

KEY_braille_dots_2578¶

KEY_braille_dots_2578: int

KEY_braille_dots_258¶

KEY_braille_dots_258: int

KEY_braille_dots_26¶

KEY_braille_dots_26: int

KEY_braille_dots_267¶

KEY_braille_dots_267: int

KEY_braille_dots_2678¶

KEY_braille_dots_2678: int

KEY_braille_dots_268¶

KEY_braille_dots_268: int

KEY_braille_dots_27¶

KEY_braille_dots_27: int

KEY_braille_dots_278¶

KEY_braille_dots_278: int

KEY_braille_dots_28¶

KEY_braille_dots_28: int

KEY_braille_dots_3¶

KEY_braille_dots_3: int

KEY_braille_dots_34¶

KEY_braille_dots_34: int

KEY_braille_dots_345¶

KEY_braille_dots_345: int

KEY_braille_dots_3456¶

KEY_braille_dots_3456: int

KEY_braille_dots_34567¶

KEY_braille_dots_34567: int

KEY_braille_dots_345678¶

KEY_braille_dots_345678: int

KEY_braille_dots_34568¶

KEY_braille_dots_34568: int

KEY_braille_dots_3457¶

KEY_braille_dots_3457: int

KEY_braille_dots_34578¶

KEY_braille_dots_34578: int

KEY_braille_dots_3458¶

KEY_braille_dots_3458: int

KEY_braille_dots_346¶

KEY_braille_dots_346: int

KEY_braille_dots_3467¶

KEY_braille_dots_3467: int

KEY_braille_dots_34678¶

KEY_braille_dots_34678: int

KEY_braille_dots_3468¶

KEY_braille_dots_3468: int

KEY_braille_dots_347¶

KEY_braille_dots_347: int

KEY_braille_dots_3478¶

KEY_braille_dots_3478: int

KEY_braille_dots_348¶

KEY_braille_dots_348: int

KEY_braille_dots_35¶

KEY_braille_dots_35: int

KEY_braille_dots_356¶

KEY_braille_dots_356: int

KEY_braille_dots_3567¶

KEY_braille_dots_3567: int

KEY_braille_dots_35678¶

KEY_braille_dots_35678: int

KEY_braille_dots_3568¶

KEY_braille_dots_3568: int

KEY_braille_dots_357¶

KEY_braille_dots_357: int

KEY_braille_dots_3578¶

KEY_braille_dots_3578: int

KEY_braille_dots_358¶

KEY_braille_dots_358: int

KEY_braille_dots_36¶

KEY_braille_dots_36: int

KEY_braille_dots_367¶

KEY_braille_dots_367: int

KEY_braille_dots_3678¶

KEY_braille_dots_3678: int

KEY_braille_dots_368¶

KEY_braille_dots_368: int

KEY_braille_dots_37¶

KEY_braille_dots_37: int

KEY_braille_dots_378¶

KEY_braille_dots_378: int

KEY_braille_dots_38¶

KEY_braille_dots_38: int

KEY_braille_dots_4¶

KEY_braille_dots_4: int

KEY_braille_dots_45¶

KEY_braille_dots_45: int

KEY_braille_dots_456¶

KEY_braille_dots_456: int

KEY_braille_dots_4567¶

KEY_braille_dots_4567: int

KEY_braille_dots_45678¶

KEY_braille_dots_45678: int

KEY_braille_dots_4568¶

KEY_braille_dots_4568: int

KEY_braille_dots_457¶

KEY_braille_dots_457: int

KEY_braille_dots_4578¶

KEY_braille_dots_4578: int

KEY_braille_dots_458¶

KEY_braille_dots_458: int

KEY_braille_dots_46¶

KEY_braille_dots_46: int

KEY_braille_dots_467¶

KEY_braille_dots_467: int

KEY_braille_dots_4678¶

KEY_braille_dots_4678: int

KEY_braille_dots_468¶

KEY_braille_dots_468: int

KEY_braille_dots_47¶

KEY_braille_dots_47: int

KEY_braille_dots_478¶

KEY_braille_dots_478: int

KEY_braille_dots_48¶

KEY_braille_dots_48: int

KEY_braille_dots_5¶

KEY_braille_dots_5: int

KEY_braille_dots_56¶

KEY_braille_dots_56: int

KEY_braille_dots_567¶

KEY_braille_dots_567: int

KEY_braille_dots_5678¶

KEY_braille_dots_5678: int

KEY_braille_dots_568¶

KEY_braille_dots_568: int

KEY_braille_dots_57¶

KEY_braille_dots_57: int

KEY_braille_dots_578¶

KEY_braille_dots_578: int

KEY_braille_dots_58¶

KEY_braille_dots_58: int

KEY_braille_dots_6¶

KEY_braille_dots_6: int

KEY_braille_dots_67¶

KEY_braille_dots_67: int

KEY_braille_dots_678¶

KEY_braille_dots_678: int

KEY_braille_dots_68¶

KEY_braille_dots_68: int

KEY_braille_dots_7¶

KEY_braille_dots_7: int

KEY_braille_dots_78¶

KEY_braille_dots_78: int

KEY_braille_dots_8¶

KEY_braille_dots_8: int

KEY_breve¶

KEY_breve: int

KEY_brokenbar¶

KEY_brokenbar: int

KEY_c¶

KEY_c: int

KEY_c_h¶

KEY_c_h: int

KEY_cabovedot¶

KEY_cabovedot: int

KEY_cacute¶

KEY_cacute: int

KEY_careof¶

KEY_careof: int

KEY_caret¶

KEY_caret: int

KEY_caron¶

KEY_caron: int

KEY_ccaron¶

KEY_ccaron: int

KEY_ccedilla¶

KEY_ccedilla: int

KEY_ccircumflex¶

KEY_ccircumflex: int

KEY_cedilla¶

KEY_cedilla: int

KEY_cent¶

KEY_cent: int

KEY_ch¶

KEY_ch: int

KEY_checkerboard¶

KEY_checkerboard: int

KEY_checkmark¶

KEY_checkmark: int

KEY_circle¶

KEY_circle: int

KEY_club¶

KEY_club: int

KEY_colon¶

KEY_colon: int

KEY_combining_acute¶

KEY_combining_acute: int

KEY_combining_belowdot¶

KEY_combining_belowdot: int

KEY_combining_grave¶

KEY_combining_grave: int

KEY_combining_hook¶

KEY_combining_hook: int

KEY_combining_tilde¶

KEY_combining_tilde: int

KEY_comma¶

KEY_comma: int

KEY_containsas¶

KEY_containsas: int

KEY_copyright¶

KEY_copyright: int

KEY_cr¶

KEY_cr: int

KEY_crossinglines¶

KEY_crossinglines: int

KEY_cuberoot¶

KEY_cuberoot: int

KEY_currency¶

KEY_currency: int

KEY_cursor¶

KEY_cursor: int

KEY_d¶

KEY_d: int

KEY_dabovedot¶

KEY_dabovedot: int

KEY_dagger¶

KEY_dagger: int

KEY_dcaron¶

KEY_dcaron: int

KEY_dead_A¶

KEY_dead_A: int

KEY_dead_E¶

KEY_dead_E: int

KEY_dead_I¶

KEY_dead_I: int

KEY_dead_O¶

KEY_dead_O: int

KEY_dead_SCHWA¶

KEY_dead_SCHWA: int

KEY_dead_U¶

KEY_dead_U: int

KEY_dead_a¶

KEY_dead_a: int

KEY_dead_abovecomma¶

KEY_dead_abovecomma: int

KEY_dead_abovedot¶

KEY_dead_abovedot: int

KEY_dead_abovereversedcomma¶

KEY_dead_abovereversedcomma: int

KEY_dead_abovering¶

KEY_dead_abovering: int

KEY_dead_aboveverticalline¶

KEY_dead_aboveverticalline: int

KEY_dead_acute¶

KEY_dead_acute: int

KEY_dead_belowbreve¶

KEY_dead_belowbreve: int

KEY_dead_belowcircumflex¶

KEY_dead_belowcircumflex: int

KEY_dead_belowcomma¶

KEY_dead_belowcomma: int

KEY_dead_belowdiaeresis¶

KEY_dead_belowdiaeresis: int

KEY_dead_belowdot¶

KEY_dead_belowdot: int

KEY_dead_belowmacron¶

KEY_dead_belowmacron: int

KEY_dead_belowring¶

KEY_dead_belowring: int

KEY_dead_belowtilde¶

KEY_dead_belowtilde: int

KEY_dead_belowverticalline¶

KEY_dead_belowverticalline: int

KEY_dead_breve¶

KEY_dead_breve: int

KEY_dead_capital_schwa¶

KEY_dead_capital_schwa: int

KEY_dead_caron¶

KEY_dead_caron: int

KEY_dead_cedilla¶

KEY_dead_cedilla: int

KEY_dead_circumflex¶

KEY_dead_circumflex: int

KEY_dead_currency¶

KEY_dead_currency: int

KEY_dead_dasia¶

KEY_dead_dasia: int

KEY_dead_diaeresis¶

KEY_dead_diaeresis: int

KEY_dead_doubleacute¶

KEY_dead_doubleacute: int

KEY_dead_doublegrave¶

KEY_dead_doublegrave: int

KEY_dead_e¶

KEY_dead_e: int

KEY_dead_grave¶

KEY_dead_grave: int

KEY_dead_greek¶

KEY_dead_greek: int

KEY_dead_hamza¶

KEY_dead_hamza: int

KEY_dead_hook¶

KEY_dead_hook: int

KEY_dead_horn¶

KEY_dead_horn: int

KEY_dead_i¶

KEY_dead_i: int

KEY_dead_invertedbreve¶

KEY_dead_invertedbreve: int

KEY_dead_iota¶

KEY_dead_iota: int

KEY_dead_longsolidusoverlay¶

KEY_dead_longsolidusoverlay: int

KEY_dead_lowline¶

KEY_dead_lowline: int

KEY_dead_macron¶

KEY_dead_macron: int

KEY_dead_o¶

KEY_dead_o: int

KEY_dead_ogonek¶

KEY_dead_ogonek: int

KEY_dead_perispomeni¶

KEY_dead_perispomeni: int

KEY_dead_psili¶

KEY_dead_psili: int

KEY_dead_schwa¶

KEY_dead_schwa: int

KEY_dead_semivoiced_sound¶

KEY_dead_semivoiced_sound: int

KEY_dead_small_schwa¶

KEY_dead_small_schwa: int

KEY_dead_stroke¶

KEY_dead_stroke: int

KEY_dead_tilde¶

KEY_dead_tilde: int

KEY_dead_u¶

KEY_dead_u: int

KEY_dead_voiced_sound¶

KEY_dead_voiced_sound: int

KEY_decimalpoint¶

KEY_decimalpoint: int

KEY_degree¶

KEY_degree: int

KEY_diaeresis¶

KEY_diaeresis: int

KEY_diamond¶

KEY_diamond: int

KEY_digitspace¶

KEY_digitspace: int

KEY_dintegral¶

KEY_dintegral: int

KEY_division¶

KEY_division: int

KEY_dollar¶

KEY_dollar: int

KEY_doubbaselinedot¶

KEY_doubbaselinedot: int

KEY_doubleacute¶

KEY_doubleacute: int

KEY_doubledagger¶

KEY_doubledagger: int

KEY_doublelowquotemark¶

KEY_doublelowquotemark: int

KEY_downarrow¶

KEY_downarrow: int

KEY_downcaret¶

KEY_downcaret: int

KEY_downshoe¶

KEY_downshoe: int

KEY_downstile¶

KEY_downstile: int

KEY_downtack¶

KEY_downtack: int

KEY_dstroke¶

KEY_dstroke: int

KEY_e¶

KEY_e: int

KEY_eabovedot¶

KEY_eabovedot: int

KEY_eacute¶

KEY_eacute: int

KEY_ebelowdot¶

KEY_ebelowdot: int

KEY_ecaron¶

KEY_ecaron: int

KEY_ecircumflex¶

KEY_ecircumflex: int

KEY_ecircumflexacute¶

KEY_ecircumflexacute: int

KEY_ecircumflexbelowdot¶

KEY_ecircumflexbelowdot: int

KEY_ecircumflexgrave¶

KEY_ecircumflexgrave: int

KEY_ecircumflexhook¶

KEY_ecircumflexhook: int

KEY_ecircumflextilde¶

KEY_ecircumflextilde: int

KEY_ediaeresis¶

KEY_ediaeresis: int

KEY_egrave¶

KEY_egrave: int

KEY_ehook¶

KEY_ehook: int

KEY_eightsubscript¶

KEY_eightsubscript: int

KEY_eightsuperior¶

KEY_eightsuperior: int

KEY_elementof¶

KEY_elementof: int

KEY_ellipsis¶

KEY_ellipsis: int

KEY_em3space¶

KEY_em3space: int

KEY_em4space¶

KEY_em4space: int

KEY_emacron¶

KEY_emacron: int

KEY_emdash¶

KEY_emdash: int

KEY_emfilledcircle¶

KEY_emfilledcircle: int

KEY_emfilledrect¶

KEY_emfilledrect: int

KEY_emopencircle¶

KEY_emopencircle: int

KEY_emopenrectangle¶

KEY_emopenrectangle: int

KEY_emptyset¶

KEY_emptyset: int

KEY_emspace¶

KEY_emspace: int

KEY_endash¶

KEY_endash: int

KEY_enfilledcircbullet¶

KEY_enfilledcircbullet: int

KEY_enfilledsqbullet¶

KEY_enfilledsqbullet: int

KEY_eng¶

KEY_eng: int

KEY_enopencircbullet¶

KEY_enopencircbullet: int

KEY_enopensquarebullet¶

KEY_enopensquarebullet: int

KEY_enspace¶

KEY_enspace: int

KEY_eogonek¶

KEY_eogonek: int

KEY_equal¶

KEY_equal: int

KEY_eth¶

KEY_eth: int

KEY_etilde¶

KEY_etilde: int

KEY_exclam¶

KEY_exclam: int

KEY_exclamdown¶

KEY_exclamdown: int

KEY_ezh¶

KEY_ezh: int

KEY_f¶

KEY_f: int

KEY_fabovedot¶

KEY_fabovedot: int

KEY_femalesymbol¶

KEY_femalesymbol: int

KEY_ff¶

KEY_ff: int

KEY_figdash¶

KEY_figdash: int

KEY_filledlefttribullet¶

KEY_filledlefttribullet: int

KEY_filledrectbullet¶

KEY_filledrectbullet: int

KEY_filledrighttribullet¶

KEY_filledrighttribullet: int

KEY_filledtribulletdown¶

KEY_filledtribulletdown: int

KEY_filledtribulletup¶

KEY_filledtribulletup: int

KEY_fiveeighths¶

KEY_fiveeighths: int

KEY_fivesixths¶

KEY_fivesixths: int

KEY_fivesubscript¶

KEY_fivesubscript: int

KEY_fivesuperior¶

KEY_fivesuperior: int

KEY_fourfifths¶

KEY_fourfifths: int

KEY_foursubscript¶

KEY_foursubscript: int

KEY_foursuperior¶

KEY_foursuperior: int

KEY_fourthroot¶

KEY_fourthroot: int

KEY_function¶

KEY_function: int

KEY_g¶

KEY_g: int

KEY_gabovedot¶

KEY_gabovedot: int

KEY_gbreve¶

KEY_gbreve: int

KEY_gcaron¶

KEY_gcaron: int

KEY_gcedilla¶

KEY_gcedilla: int

KEY_gcircumflex¶

KEY_gcircumflex: int

KEY_grave¶

KEY_grave: int

KEY_greater¶

KEY_greater: int

KEY_greaterthanequal¶

KEY_greaterthanequal: int

KEY_guillemetleft¶

KEY_guillemetleft: int

KEY_guillemetright¶

KEY_guillemetright: int

KEY_guillemotleft¶

KEY_guillemotleft: int

KEY_guillemotright¶

KEY_guillemotright: int

KEY_h¶

KEY_h: int

KEY_hairspace¶

KEY_hairspace: int

KEY_hcircumflex¶

KEY_hcircumflex: int

KEY_heart¶

KEY_heart: int

KEY_hebrew_aleph¶

KEY_hebrew_aleph: int

KEY_hebrew_ayin¶

KEY_hebrew_ayin: int

KEY_hebrew_bet¶

KEY_hebrew_bet: int

KEY_hebrew_beth¶

KEY_hebrew_beth: int

KEY_hebrew_chet¶

KEY_hebrew_chet: int

KEY_hebrew_dalet¶

KEY_hebrew_dalet: int

KEY_hebrew_daleth¶

KEY_hebrew_daleth: int

KEY_hebrew_doublelowline¶

KEY_hebrew_doublelowline: int

KEY_hebrew_finalkaph¶

KEY_hebrew_finalkaph: int

KEY_hebrew_finalmem¶

KEY_hebrew_finalmem: int

KEY_hebrew_finalnun¶

KEY_hebrew_finalnun: int

KEY_hebrew_finalpe¶

KEY_hebrew_finalpe: int

KEY_hebrew_finalzade¶

KEY_hebrew_finalzade: int

KEY_hebrew_finalzadi¶

KEY_hebrew_finalzadi: int

KEY_hebrew_gimel¶

KEY_hebrew_gimel: int

KEY_hebrew_gimmel¶

KEY_hebrew_gimmel: int

KEY_hebrew_he¶

KEY_hebrew_he: int

KEY_hebrew_het¶

KEY_hebrew_het: int

KEY_hebrew_kaph¶

KEY_hebrew_kaph: int

KEY_hebrew_kuf¶

KEY_hebrew_kuf: int

KEY_hebrew_lamed¶

KEY_hebrew_lamed: int

KEY_hebrew_mem¶

KEY_hebrew_mem: int

KEY_hebrew_nun¶

KEY_hebrew_nun: int

KEY_hebrew_pe¶

KEY_hebrew_pe: int

KEY_hebrew_qoph¶

KEY_hebrew_qoph: int

KEY_hebrew_resh¶

KEY_hebrew_resh: int

KEY_hebrew_samech¶

KEY_hebrew_samech: int

KEY_hebrew_samekh¶

KEY_hebrew_samekh: int

KEY_hebrew_shin¶

KEY_hebrew_shin: int

KEY_hebrew_taf¶

KEY_hebrew_taf: int

KEY_hebrew_taw¶

KEY_hebrew_taw: int

KEY_hebrew_tet¶

KEY_hebrew_tet: int

KEY_hebrew_teth¶

KEY_hebrew_teth: int

KEY_hebrew_waw¶

KEY_hebrew_waw: int

KEY_hebrew_yod¶

KEY_hebrew_yod: int

KEY_hebrew_zade¶

KEY_hebrew_zade: int

KEY_hebrew_zadi¶

KEY_hebrew_zadi: int

KEY_hebrew_zain¶

KEY_hebrew_zain: int

KEY_hebrew_zayin¶

KEY_hebrew_zayin: int

KEY_hexagram¶

KEY_hexagram: int

KEY_horizconnector¶

KEY_horizconnector: int

KEY_horizlinescan1¶

KEY_horizlinescan1: int

KEY_horizlinescan3¶

KEY_horizlinescan3: int

KEY_horizlinescan5¶

KEY_horizlinescan5: int

KEY_horizlinescan7¶

KEY_horizlinescan7: int

KEY_horizlinescan9¶

KEY_horizlinescan9: int

KEY_hstroke¶

KEY_hstroke: int

KEY_ht¶

KEY_ht: int

KEY_hyphen¶

KEY_hyphen: int

KEY_i¶

KEY_i: int

KEY_iTouch¶

KEY_iTouch: int

KEY_iacute¶

KEY_iacute: int

KEY_ibelowdot¶

KEY_ibelowdot: int

KEY_ibreve¶

KEY_ibreve: int

KEY_icircumflex¶

KEY_icircumflex: int

KEY_identical¶

KEY_identical: int

KEY_idiaeresis¶

KEY_idiaeresis: int

KEY_idotless¶

KEY_idotless: int

KEY_ifonlyif¶

KEY_ifonlyif: int

KEY_igrave¶

KEY_igrave: int

KEY_ihook¶

KEY_ihook: int

KEY_imacron¶

KEY_imacron: int

KEY_implies¶

KEY_implies: int

KEY_includedin¶

KEY_includedin: int

KEY_includes¶

KEY_includes: int

KEY_infinity¶

KEY_infinity: int

KEY_integral¶

KEY_integral: int

KEY_intersection¶

KEY_intersection: int

KEY_iogonek¶

KEY_iogonek: int

KEY_itilde¶

KEY_itilde: int

KEY_j¶

KEY_j: int

KEY_jcircumflex¶

KEY_jcircumflex: int

KEY_jot¶

KEY_jot: int

KEY_k¶

KEY_k: int

KEY_kana_A¶

KEY_kana_A: int

KEY_kana_CHI¶

KEY_kana_CHI: int

KEY_kana_E¶

KEY_kana_E: int

KEY_kana_FU¶

KEY_kana_FU: int

KEY_kana_HA¶

KEY_kana_HA: int

KEY_kana_HE¶

KEY_kana_HE: int

KEY_kana_HI¶

KEY_kana_HI: int

KEY_kana_HO¶

KEY_kana_HO: int

KEY_kana_HU¶

KEY_kana_HU: int

KEY_kana_I¶

KEY_kana_I: int

KEY_kana_KA¶

KEY_kana_KA: int

KEY_kana_KE¶

KEY_kana_KE: int

KEY_kana_KI¶

KEY_kana_KI: int

KEY_kana_KO¶

KEY_kana_KO: int

KEY_kana_KU¶

KEY_kana_KU: int

KEY_kana_MA¶

KEY_kana_MA: int

KEY_kana_ME¶

KEY_kana_ME: int

KEY_kana_MI¶

KEY_kana_MI: int

KEY_kana_MO¶

KEY_kana_MO: int

KEY_kana_MU¶

KEY_kana_MU: int

KEY_kana_N¶

KEY_kana_N: int

KEY_kana_NA¶

KEY_kana_NA: int

KEY_kana_NE¶

KEY_kana_NE: int

KEY_kana_NI¶

KEY_kana_NI: int

KEY_kana_NO¶

KEY_kana_NO: int

KEY_kana_NU¶

KEY_kana_NU: int

KEY_kana_O¶

KEY_kana_O: int

KEY_kana_RA¶

KEY_kana_RA: int

KEY_kana_RE¶

KEY_kana_RE: int

KEY_kana_RI¶

KEY_kana_RI: int

KEY_kana_RO¶

KEY_kana_RO: int

KEY_kana_RU¶

KEY_kana_RU: int

KEY_kana_SA¶

KEY_kana_SA: int

KEY_kana_SE¶

KEY_kana_SE: int

KEY_kana_SHI¶

KEY_kana_SHI: int

KEY_kana_SO¶

KEY_kana_SO: int

KEY_kana_SU¶

KEY_kana_SU: int

KEY_kana_TA¶

KEY_kana_TA: int

KEY_kana_TE¶

KEY_kana_TE: int

KEY_kana_TI¶

KEY_kana_TI: int

KEY_kana_TO¶

KEY_kana_TO: int

KEY_kana_TSU¶

KEY_kana_TSU: int

KEY_kana_TU¶

KEY_kana_TU: int

KEY_kana_U¶

KEY_kana_U: int

KEY_kana_WA¶

KEY_kana_WA: int

KEY_kana_WO¶

KEY_kana_WO: int

KEY_kana_YA¶

KEY_kana_YA: int

KEY_kana_YO¶

KEY_kana_YO: int

KEY_kana_YU¶

KEY_kana_YU: int

KEY_kana_a¶

KEY_kana_a: int

KEY_kana_closingbracket¶

KEY_kana_closingbracket: int

KEY_kana_comma¶

KEY_kana_comma: int

KEY_kana_conjunctive¶

KEY_kana_conjunctive: int

KEY_kana_e¶

KEY_kana_e: int

KEY_kana_fullstop¶

KEY_kana_fullstop: int

KEY_kana_i¶

KEY_kana_i: int

KEY_kana_middledot¶

KEY_kana_middledot: int

KEY_kana_o¶

KEY_kana_o: int

KEY_kana_openingbracket¶

KEY_kana_openingbracket: int

KEY_kana_switch¶

KEY_kana_switch: int

KEY_kana_tsu¶

KEY_kana_tsu: int

KEY_kana_tu¶

KEY_kana_tu: int

KEY_kana_u¶

KEY_kana_u: int

KEY_kana_ya¶

KEY_kana_ya: int

KEY_kana_yo¶

KEY_kana_yo: int

KEY_kana_yu¶

KEY_kana_yu: int

KEY_kappa¶

KEY_kappa: int

KEY_kcedilla¶

KEY_kcedilla: int

KEY_kra¶

KEY_kra: int

KEY_l¶

KEY_l: int

KEY_lacute¶

KEY_lacute: int

KEY_latincross¶

KEY_latincross: int

KEY_lbelowdot¶

KEY_lbelowdot: int

KEY_lcaron¶

KEY_lcaron: int

KEY_lcedilla¶

KEY_lcedilla: int

KEY_leftanglebracket¶

KEY_leftanglebracket: int

KEY_leftarrow¶

KEY_leftarrow: int

KEY_leftcaret¶

KEY_leftcaret: int

KEY_leftdoublequotemark¶

KEY_leftdoublequotemark: int

KEY_leftmiddlecurlybrace¶

KEY_leftmiddlecurlybrace: int

KEY_leftopentriangle¶

KEY_leftopentriangle: int

KEY_leftpointer¶

KEY_leftpointer: int

KEY_leftradical¶

KEY_leftradical: int

KEY_leftshoe¶

KEY_leftshoe: int

KEY_leftsinglequotemark¶

KEY_leftsinglequotemark: int

KEY_leftt¶

KEY_leftt: int

KEY_lefttack¶

KEY_lefttack: int

KEY_less¶

KEY_less: int

KEY_lessthanequal¶

KEY_lessthanequal: int

KEY_lf¶

KEY_lf: int

KEY_logicaland¶

KEY_logicaland: int

KEY_logicalor¶

KEY_logicalor: int

KEY_lowleftcorner¶

KEY_lowleftcorner: int

KEY_lowrightcorner¶

KEY_lowrightcorner: int

KEY_lstroke¶

KEY_lstroke: int

KEY_m¶

KEY_m: int

KEY_mabovedot¶

KEY_mabovedot: int

KEY_macron¶

KEY_macron: int

KEY_malesymbol¶

KEY_malesymbol: int

KEY_maltesecross¶

KEY_maltesecross: int

KEY_marker¶

KEY_marker: int

KEY_masculine¶

KEY_masculine: int

KEY_minus¶

KEY_minus: int

KEY_minutes¶

KEY_minutes: int

KEY_mu¶

KEY_mu: int

KEY_multiply¶

KEY_multiply: int

KEY_musicalflat¶

KEY_musicalflat: int

KEY_musicalsharp¶

KEY_musicalsharp: int

KEY_n¶

KEY_n: int

KEY_nabla¶

KEY_nabla: int

KEY_nacute¶

KEY_nacute: int

KEY_ncaron¶

KEY_ncaron: int

KEY_ncedilla¶

KEY_ncedilla: int

KEY_ninesubscript¶

KEY_ninesubscript: int

KEY_ninesuperior¶

KEY_ninesuperior: int

KEY_nl¶

KEY_nl: int

KEY_nobreakspace¶

KEY_nobreakspace: int

KEY_notapproxeq¶

KEY_notapproxeq: int

KEY_notelementof¶

KEY_notelementof: int

KEY_notequal¶

KEY_notequal: int

KEY_notidentical¶

KEY_notidentical: int

KEY_notsign¶

KEY_notsign: int

KEY_ntilde¶

KEY_ntilde: int

KEY_numbersign¶

KEY_numbersign: int

KEY_numerosign¶

KEY_numerosign: int

KEY_o¶

KEY_o: int

KEY_oacute¶

KEY_oacute: int

KEY_obarred¶

KEY_obarred: int

KEY_obelowdot¶

KEY_obelowdot: int

KEY_ocaron¶

KEY_ocaron: int

KEY_ocircumflex¶

KEY_ocircumflex: int

KEY_ocircumflexacute¶

KEY_ocircumflexacute: int

KEY_ocircumflexbelowdot¶

KEY_ocircumflexbelowdot: int

KEY_ocircumflexgrave¶

KEY_ocircumflexgrave: int

KEY_ocircumflexhook¶

KEY_ocircumflexhook: int

KEY_ocircumflextilde¶

KEY_ocircumflextilde: int

KEY_odiaeresis¶

KEY_odiaeresis: int

KEY_odoubleacute¶

KEY_odoubleacute: int

KEY_oe¶

KEY_oe: int

KEY_ogonek¶

KEY_ogonek: int

KEY_ograve¶

KEY_ograve: int

KEY_ohook¶

KEY_ohook: int

KEY_ohorn¶

KEY_ohorn: int

KEY_ohornacute¶

KEY_ohornacute: int

KEY_ohornbelowdot¶

KEY_ohornbelowdot: int

KEY_ohorngrave¶

KEY_ohorngrave: int

KEY_ohornhook¶

KEY_ohornhook: int

KEY_ohorntilde¶

KEY_ohorntilde: int

KEY_omacron¶

KEY_omacron: int

KEY_oneeighth¶

KEY_oneeighth: int

KEY_onefifth¶

KEY_onefifth: int

KEY_onehalf¶

KEY_onehalf: int

KEY_onequarter¶

KEY_onequarter: int

KEY_onesixth¶

KEY_onesixth: int

KEY_onesubscript¶

KEY_onesubscript: int

KEY_onesuperior¶

KEY_onesuperior: int

KEY_onethird¶

KEY_onethird: int

KEY_ooblique¶

KEY_ooblique: int

KEY_openrectbullet¶

KEY_openrectbullet: int

KEY_openstar¶

KEY_openstar: int

KEY_opentribulletdown¶

KEY_opentribulletdown: int

KEY_opentribulletup¶

KEY_opentribulletup: int

KEY_ordfeminine¶

KEY_ordfeminine: int

KEY_ordmasculine¶

KEY_ordmasculine: int

KEY_oslash¶

KEY_oslash: int

KEY_otilde¶

KEY_otilde: int

KEY_overbar¶

KEY_overbar: int

KEY_overline¶

KEY_overline: int

KEY_p¶

KEY_p: int

KEY_pabovedot¶

KEY_pabovedot: int

KEY_paragraph¶

KEY_paragraph: int

KEY_parenleft¶

KEY_parenleft: int

KEY_parenright¶

KEY_parenright: int

KEY_partdifferential¶

KEY_partdifferential: int

KEY_partialderivative¶

KEY_partialderivative: int

KEY_percent¶

KEY_percent: int

KEY_period¶

KEY_period: int

KEY_periodcentered¶

KEY_periodcentered: int

KEY_permille¶

KEY_permille: int

KEY_phonographcopyright¶

KEY_phonographcopyright: int

KEY_plus¶

KEY_plus: int

KEY_plusminus¶

KEY_plusminus: int

KEY_prescription¶

KEY_prescription: int

KEY_prolongedsound¶

KEY_prolongedsound: int

KEY_punctspace¶

KEY_punctspace: int

KEY_q¶

KEY_q: int

KEY_quad¶

KEY_quad: int

KEY_question¶

KEY_question: int

KEY_questiondown¶

KEY_questiondown: int

KEY_quotedbl¶

KEY_quotedbl: int

KEY_quoteleft¶

KEY_quoteleft: int

KEY_quoteright¶

KEY_quoteright: int

KEY_r¶

KEY_r: int

KEY_racute¶

KEY_racute: int

KEY_radical¶

KEY_radical: int

KEY_rcaron¶

KEY_rcaron: int

KEY_rcedilla¶

KEY_rcedilla: int

KEY_registered¶

KEY_registered: int

KEY_rightanglebracket¶

KEY_rightanglebracket: int

KEY_rightarrow¶

KEY_rightarrow: int

KEY_rightcaret¶

KEY_rightcaret: int

KEY_rightdoublequotemark¶

KEY_rightdoublequotemark: int

KEY_rightmiddlecurlybrace¶

KEY_rightmiddlecurlybrace: int

KEY_rightmiddlesummation¶

KEY_rightmiddlesummation: int

KEY_rightopentriangle¶

KEY_rightopentriangle: int

KEY_rightpointer¶

KEY_rightpointer: int

KEY_rightshoe¶

KEY_rightshoe: int

KEY_rightsinglequotemark¶

KEY_rightsinglequotemark: int

KEY_rightt¶

KEY_rightt: int

KEY_righttack¶

KEY_righttack: int

KEY_s¶

KEY_s: int

KEY_sabovedot¶

KEY_sabovedot: int

KEY_sacute¶

KEY_sacute: int

KEY_scaron¶

KEY_scaron: int

KEY_scedilla¶

KEY_scedilla: int

KEY_schwa¶

KEY_schwa: int

KEY_scircumflex¶

KEY_scircumflex: int

KEY_script_switch¶

KEY_script_switch: int

KEY_seconds¶

KEY_seconds: int

KEY_section¶

KEY_section: int

KEY_semicolon¶

KEY_semicolon: int

KEY_semivoicedsound¶

KEY_semivoicedsound: int

KEY_seveneighths¶

KEY_seveneighths: int

KEY_sevensubscript¶

KEY_sevensubscript: int

KEY_sevensuperior¶

KEY_sevensuperior: int

KEY_signaturemark¶

KEY_signaturemark: int

KEY_signifblank¶

KEY_signifblank: int

KEY_similarequal¶

KEY_similarequal: int

KEY_singlelowquotemark¶

KEY_singlelowquotemark: int

KEY_sixsubscript¶

KEY_sixsubscript: int

KEY_sixsuperior¶

KEY_sixsuperior: int

KEY_slash¶

KEY_slash: int

KEY_soliddiamond¶

KEY_soliddiamond: int

KEY_space¶

KEY_space: int

KEY_squareroot¶

KEY_squareroot: int

KEY_ssharp¶

KEY_ssharp: int

KEY_sterling¶

KEY_sterling: int

KEY_stricteq¶

KEY_stricteq: int

KEY_t¶

KEY_t: int

KEY_tabovedot¶

KEY_tabovedot: int

KEY_tcaron¶

KEY_tcaron: int

KEY_tcedilla¶

KEY_tcedilla: int

KEY_telephone¶

KEY_telephone: int

KEY_telephonerecorder¶

KEY_telephonerecorder: int

KEY_therefore¶

KEY_therefore: int

KEY_thinspace¶

KEY_thinspace: int

KEY_thorn¶

KEY_thorn: int

KEY_threeeighths¶

KEY_threeeighths: int

KEY_threefifths¶

KEY_threefifths: int

KEY_threequarters¶

KEY_threequarters: int

KEY_threesubscript¶

KEY_threesubscript: int

KEY_threesuperior¶

KEY_threesuperior: int

KEY_tintegral¶

KEY_tintegral: int

KEY_topintegral¶

KEY_topintegral: int

KEY_topleftparens¶

KEY_topleftparens: int

KEY_topleftradical¶

KEY_topleftradical: int

KEY_topleftsqbracket¶

KEY_topleftsqbracket: int

KEY_topleftsummation¶

KEY_topleftsummation: int

KEY_toprightparens¶

KEY_toprightparens: int

KEY_toprightsqbracket¶

KEY_toprightsqbracket: int

KEY_toprightsummation¶

KEY_toprightsummation: int

KEY_topt¶

KEY_topt: int

KEY_topvertsummationconnector¶

KEY_topvertsummationconnector: int

KEY_trademark¶

KEY_trademark: int

KEY_trademarkincircle¶

KEY_trademarkincircle: int

KEY_tslash¶

KEY_tslash: int

KEY_twofifths¶

KEY_twofifths: int

KEY_twosubscript¶

KEY_twosubscript: int

KEY_twosuperior¶

KEY_twosuperior: int

KEY_twothirds¶

KEY_twothirds: int

KEY_u¶

KEY_u: int

KEY_uacute¶

KEY_uacute: int

KEY_ubelowdot¶

KEY_ubelowdot: int

KEY_ubreve¶

KEY_ubreve: int

KEY_ucircumflex¶

KEY_ucircumflex: int

KEY_udiaeresis¶

KEY_udiaeresis: int

KEY_udoubleacute¶

KEY_udoubleacute: int

KEY_ugrave¶

KEY_ugrave: int

KEY_uhook¶

KEY_uhook: int

KEY_uhorn¶

KEY_uhorn: int

KEY_uhornacute¶

KEY_uhornacute: int

KEY_uhornbelowdot¶

KEY_uhornbelowdot: int

KEY_uhorngrave¶

KEY_uhorngrave: int

KEY_uhornhook¶

KEY_uhornhook: int

KEY_uhorntilde¶

KEY_uhorntilde: int

KEY_umacron¶

KEY_umacron: int

KEY_underbar¶

KEY_underbar: int

KEY_underscore¶

KEY_underscore: int

KEY_union¶

KEY_union: int

KEY_uogonek¶

KEY_uogonek: int

KEY_uparrow¶

KEY_uparrow: int

KEY_upcaret¶

KEY_upcaret: int

KEY_upleftcorner¶

KEY_upleftcorner: int

KEY_uprightcorner¶

KEY_uprightcorner: int

KEY_upshoe¶

KEY_upshoe: int

KEY_upstile¶

KEY_upstile: int

KEY_uptack¶

KEY_uptack: int

KEY_uring¶

KEY_uring: int

KEY_utilde¶

KEY_utilde: int

KEY_v¶

KEY_v: int

KEY_variation¶

KEY_variation: int

KEY_vertbar¶

KEY_vertbar: int

KEY_vertconnector¶

KEY_vertconnector: int

KEY_voicedsound¶

KEY_voicedsound: int

KEY_vt¶

KEY_vt: int

KEY_w¶

KEY_w: int

KEY_wacute¶

KEY_wacute: int

KEY_wcircumflex¶

KEY_wcircumflex: int

KEY_wdiaeresis¶

KEY_wdiaeresis: int

KEY_wgrave¶

KEY_wgrave: int

KEY_x¶

KEY_x: int

KEY_xabovedot¶

KEY_xabovedot: int

KEY_y¶

KEY_y: int

KEY_yacute¶

KEY_yacute: int

KEY_ybelowdot¶

KEY_ybelowdot: int

KEY_ycircumflex¶

KEY_ycircumflex: int

KEY_ydiaeresis¶

KEY_ydiaeresis: int

KEY_yen¶

KEY_yen: int

KEY_ygrave¶

KEY_ygrave: int

KEY_yhook¶

KEY_yhook: int

KEY_ytilde¶

KEY_ytilde: int

KEY_z¶

KEY_z: int

KEY_zabovedot¶

KEY_zabovedot: int

KEY_zacute¶

KEY_zacute: int

KEY_zcaron¶

KEY_zcaron: int

KEY_zerosubscript¶

KEY_zerosubscript: int

KEY_zerosuperior¶

KEY_zerosuperior: int

KEY_zstroke¶

KEY_zstroke: int

MODIFIER_MASK¶

MODIFIER_MASK: int

A mask covering all entries in GdkModifierType.

PRIORITY_REDRAW¶

PRIORITY_REDRAW: int

This is the priority that the idle handler processing surface updates is given in the main loop.

Callbacks¶

ContentDeserializeFunc¶

ContentDeserializeFunc = Callable[[deserializer: ContentDeserializer], None]

ContentSerializeFunc¶

ContentSerializeFunc = Callable[[serializer: ContentSerializer], None]

CursorGetTextureCallback¶

CursorGetTextureCallback = Callable[[cursor: Cursor, cursor_size: int, scale: float], Texture]