diff --git a/docs/html/Wayland.proc b/docs/html/Wayland.proc new file mode 100644 index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391 diff --git a/docs/html/apa.html b/docs/html/apa.html new file mode 100644 index 0000000000000000000000000000000000000000..efe03c9092ff6ffe0376c962ab901368b7265089 --- /dev/null +++ b/docs/html/apa.html @@ -0,0 +1,2051 @@ +Appendix A. Wayland Protocol Specification

Appendix A. Wayland Protocol Specification

Table of Contents

wl_display + - core global object
wl_registry + - global registry object
wl_callback + - callback object
wl_compositor + - the compositor singleton
wl_shm_pool + - a shared memory pool
wl_shm + - shared memory support
wl_buffer + - content for a wl_surface
wl_data_offer + - offer to transfer data
wl_data_source + - offer to transfer data
wl_data_device + - data transfer device
wl_data_device_manager + - data transfer interface
wl_shell + - create desktop-style surfaces
wl_shell_surface + - desktop-style metadata interface
wl_surface + - an onscreen surface
wl_seat + - group of input devices
wl_pointer + - pointer input device
wl_keyboard + - keyboard input device
wl_touch + - touchscreen input device
wl_output + - compositor output region
wl_region + - region interface
wl_subcompositor + - sub-surface compositing
wl_subsurface + - sub-surface interface to a wl_surface

+


+    Copyright © 2008-2011 Kristian Høgsberg
+    Copyright © 2010-2011 Intel Corporation
+    Copyright © 2012-2013 Collabora, Ltd.
+
+    Permission is hereby granted, free of charge, to any person
+    obtaining a copy of this software and associated documentation files
+    (the "Software"), to deal in the Software without restriction,
+    including without limitation the rights to use, copy, modify, merge,
+    publish, distribute, sublicense, and/or sell copies of the Software,
+    and to permit persons to whom the Software is furnished to do so,
+    subject to the following conditions:
+
+    The above copyright notice and this permission notice (including the
+    next paragraph) shall be included in all copies or substantial
+    portions of the Software.
+
+    THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+    EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+    MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+    NONINFRINGEMENT.  IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
+    BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
+    ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+    CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+    SOFTWARE.
+  

+

wl_display + - core global object

+ The core global object. This is a special singleton object. It + is used for internal Wayland protocol features. +

Requests provided by wl_display

wl_display::sync + - asynchronous roundtrip

+

callback
+ id for the new + wl_callback + - callback object for the sync request

+

+ The sync request asks the server to emit the 'done' event + on the returned wl_callback object. Since requests are + handled in-order and events are delivered in-order, this can + be used as a barrier to ensure all previous requests and the + resulting events have been handled.

The object returned by this request will be destroyed by the + compositor after the callback is fired and as such the client must not + attempt to use it after that point.

The callback_data passed in the callback is the event serial. +

wl_display::get_registry + - get global registry object

+

registry
+ id for the new + wl_registry + - global registry object

+

+ This request creates a registry object that allows the client + to list and bind the global objects available from the + compositor.

It should be noted that the server side resources consumed in + response to a get_registry request can only be released when the + client disconnects, not when the client side proxy is destroyed. + Therefore, clients should invoke get_registry as infrequently as + possible to avoid wasting memory. +

Events provided by wl_display

wl_display::error + - fatal error event

+

object_id
object + - object where the error occurred
code
uint + - error code
message
string + - error description

+

+ The error event is sent out when a fatal (non-recoverable) + error has occurred. The object_id argument is the object + where the error occurred, most often in response to a request + to that object. The code identifies the error and is defined + by the object interface. As such, each interface defines its + own set of error codes. The message is a brief description + of the error, for (debugging) convenience. +

wl_display::delete_id + - acknowledge object ID deletion

+

id
uint + - deleted object ID

+

+ This event is used internally by the object ID management + logic. When a client deletes an object, the server will send + this event to acknowledge that it has seen the delete request. + When the client receives this event, it will know that it can + safely reuse the object ID. +

Enums provided by wl_display

wl_display::error + - global error values

+ These errors are global and can be emitted in response to any + server request. +

invalid_object
0 + - server couldn't find object
invalid_method
1 + - method doesn't exist on the specified interface
no_memory
2 + - server is out of memory

wl_registry + - global registry object

+ The singleton global registry object. The server has a number of + global objects that are available to all clients. These objects + typically represent an actual object in the server (for example, + an input device) or they are singleton objects that provide + extension functionality.

When a client creates a registry object, the registry object + will emit a global event for each global currently in the + registry. Globals come and go as a result of device or + monitor hotplugs, reconfiguration or other events, and the + registry will send out global and global_remove events to + keep the client up to date with the changes. To mark the end + of the initial burst of events, the client can use the + wl_display.sync request immediately after calling + wl_display.get_registry.

A client can bind to a global object by using the bind + request. This creates a client-side handle that lets the object + emit events to the client and lets the client invoke requests on + the object. +

Requests provided by wl_registry

wl_registry::bind + - bind an object to the display

+

name
uint + - unique numeric name of the object
id
new_id + - bounded object

+

+ Binds a new, client-created object to the server using the + specified name as the identifier. +

Events provided by wl_registry

wl_registry::global + - announce global object

+

name
uint + - numeric name of the global object
interface
string + - interface implemented by the object
version
uint + - interface version

+

+ Notify the client of global objects.

The event notifies the client that a global object with + the given name is now available, and it implements the + given version of the given interface. +

wl_registry::global_remove + - announce removal of global object

+

name
uint + - numeric name of the global object

+

+ Notify the client of removed global objects.

This event notifies the client that the global identified + by name is no longer available. If the client bound to + the global using the bind request, the client should now + destroy that object.

The object remains valid and requests to the object will be + ignored until the client destroys it, to avoid races between + the global going away and a client sending a request to it. +

wl_callback + - callback object

+ Clients can handle the 'done' event to get notified when + the related request is done. +

Events provided by wl_callback

wl_callback::done + - done event

+

callback_data
uint + - request-specific data for the callback

+

+ Notify the client when the related request is done. +

wl_compositor + - the compositor singleton

+ A compositor. This object is a singleton global. The + compositor is in charge of combining the contents of multiple + surfaces into one displayable output. +

Requests provided by wl_compositor

wl_compositor::create_surface + - create new surface

+

id
+ id for the new + wl_surface + - the new surface

+

+ Ask the compositor to create a new surface. +

wl_compositor::create_region + - create new region

+

id
+ id for the new + wl_region + - the new region

+

+ Ask the compositor to create a new region. +

wl_shm_pool + - a shared memory pool

+ The wl_shm_pool object encapsulates a piece of memory shared + between the compositor and client. Through the wl_shm_pool + object, the client can allocate shared memory wl_buffer objects. + All objects created through the same pool share the same + underlying mapped memory. Reusing the mapped memory avoids the + setup/teardown overhead and is useful when interactively resizing + a surface or for many small buffers. +

Requests provided by wl_shm_pool

wl_shm_pool::create_buffer + - create a buffer from the pool

+

id
+ id for the new + wl_buffer + - buffer to create
offset
int + - buffer byte offset within the pool
width
int + - buffer width, in pixels
height
int + - buffer height, in pixels
stride
int + - number of bytes from the beginning of one row to the beginning of the next row
format
wl_shm::format + (uint) + + - buffer pixel format

+

+ Create a wl_buffer object from the pool.

The buffer is created offset bytes into the pool and has + width and height as specified. The stride argument specifies + the number of bytes from the beginning of one row to the beginning + of the next. The format is the pixel format of the buffer and + must be one of those advertised through the wl_shm.format event.

A buffer will keep a reference to the pool it was created from + so it is valid to destroy the pool immediately after creating + a buffer from it. +

wl_shm_pool::destroy + - destroy the pool

+

+

+ Destroy the shared memory pool.

The mmapped memory will be released when all + buffers that have been created from this pool + are gone. +

wl_shm_pool::resize + - change the size of the pool mapping

+

size
int + - new size of the pool, in bytes

+

+ This request will cause the server to remap the backing memory + for the pool from the file descriptor passed when the pool was + created, but using the new size. This request can only be + used to make the pool bigger. +

wl_shm + - shared memory support

+ A singleton global object that provides support for shared + memory.

Clients can create wl_shm_pool objects using the create_pool + request.

At connection setup time, the wl_shm object emits one or more + format events to inform clients about the valid pixel formats + that can be used for buffers. +

Requests provided by wl_shm

wl_shm::create_pool + - create a shm pool

+

id
+ id for the new + wl_shm_pool + - pool to create
fd
fd + - file descriptor for the pool
size
int + - pool size, in bytes

+

+ Create a new wl_shm_pool object.

The pool can be used to create shared memory based buffer + objects. The server will mmap size bytes of the passed file + descriptor, to use as backing memory for the pool. +

Events provided by wl_shm

wl_shm::format + - pixel format description

+

format
wl_shm::format + (uint) + + - buffer pixel format

+

+ Informs the client about a valid pixel format that + can be used for buffers. Known formats include + argb8888 and xrgb8888. +

Enums provided by wl_shm

wl_shm::error + - wl_shm error values

+ These errors can be emitted in response to wl_shm requests. +

invalid_format
0 + - buffer format is not known
invalid_stride
1 + - invalid size or stride during pool or buffer creation
invalid_fd
2 + - mmapping the file descriptor failed

wl_shm::format + - pixel formats

+ This describes the memory layout of an individual pixel.

All renderers should support argb8888 and xrgb8888 but any other + formats are optional and may not be supported by the particular + renderer in use.

The drm format codes match the macros defined in drm_fourcc.h. + The formats actually supported by the compositor will be + reported by the format event. +

argb8888
0 + - 32-bit ARGB format, [31:0] A:R:G:B 8:8:8:8 little endian
xrgb8888
1 + - 32-bit RGB format, [31:0] x:R:G:B 8:8:8:8 little endian
c8
0x20203843 + - 8-bit color index format, [7:0] C
rgb332
0x38424752 + - 8-bit RGB format, [7:0] R:G:B 3:3:2
bgr233
0x38524742 + - 8-bit BGR format, [7:0] B:G:R 2:3:3
xrgb4444
0x32315258 + - 16-bit xRGB format, [15:0] x:R:G:B 4:4:4:4 little endian
xbgr4444
0x32314258 + - 16-bit xBGR format, [15:0] x:B:G:R 4:4:4:4 little endian
rgbx4444
0x32315852 + - 16-bit RGBx format, [15:0] R:G:B:x 4:4:4:4 little endian
bgrx4444
0x32315842 + - 16-bit BGRx format, [15:0] B:G:R:x 4:4:4:4 little endian
argb4444
0x32315241 + - 16-bit ARGB format, [15:0] A:R:G:B 4:4:4:4 little endian
abgr4444
0x32314241 + - 16-bit ABGR format, [15:0] A:B:G:R 4:4:4:4 little endian
rgba4444
0x32314152 + - 16-bit RBGA format, [15:0] R:G:B:A 4:4:4:4 little endian
bgra4444
0x32314142 + - 16-bit BGRA format, [15:0] B:G:R:A 4:4:4:4 little endian
xrgb1555
0x35315258 + - 16-bit xRGB format, [15:0] x:R:G:B 1:5:5:5 little endian
xbgr1555
0x35314258 + - 16-bit xBGR 1555 format, [15:0] x:B:G:R 1:5:5:5 little endian
rgbx5551
0x35315852 + - 16-bit RGBx 5551 format, [15:0] R:G:B:x 5:5:5:1 little endian
bgrx5551
0x35315842 + - 16-bit BGRx 5551 format, [15:0] B:G:R:x 5:5:5:1 little endian
argb1555
0x35315241 + - 16-bit ARGB 1555 format, [15:0] A:R:G:B 1:5:5:5 little endian
abgr1555
0x35314241 + - 16-bit ABGR 1555 format, [15:0] A:B:G:R 1:5:5:5 little endian
rgba5551
0x35314152 + - 16-bit RGBA 5551 format, [15:0] R:G:B:A 5:5:5:1 little endian
bgra5551
0x35314142 + - 16-bit BGRA 5551 format, [15:0] B:G:R:A 5:5:5:1 little endian
rgb565
0x36314752 + - 16-bit RGB 565 format, [15:0] R:G:B 5:6:5 little endian
bgr565
0x36314742 + - 16-bit BGR 565 format, [15:0] B:G:R 5:6:5 little endian
rgb888
0x34324752 + - 24-bit RGB format, [23:0] R:G:B little endian
bgr888
0x34324742 + - 24-bit BGR format, [23:0] B:G:R little endian
xbgr8888
0x34324258 + - 32-bit xBGR format, [31:0] x:B:G:R 8:8:8:8 little endian
rgbx8888
0x34325852 + - 32-bit RGBx format, [31:0] R:G:B:x 8:8:8:8 little endian
bgrx8888
0x34325842 + - 32-bit BGRx format, [31:0] B:G:R:x 8:8:8:8 little endian
abgr8888
0x34324241 + - 32-bit ABGR format, [31:0] A:B:G:R 8:8:8:8 little endian
rgba8888
0x34324152 + - 32-bit RGBA format, [31:0] R:G:B:A 8:8:8:8 little endian
bgra8888
0x34324142 + - 32-bit BGRA format, [31:0] B:G:R:A 8:8:8:8 little endian
xrgb2101010
0x30335258 + - 32-bit xRGB format, [31:0] x:R:G:B 2:10:10:10 little endian
xbgr2101010
0x30334258 + - 32-bit xBGR format, [31:0] x:B:G:R 2:10:10:10 little endian
rgbx1010102
0x30335852 + - 32-bit RGBx format, [31:0] R:G:B:x 10:10:10:2 little endian
bgrx1010102
0x30335842 + - 32-bit BGRx format, [31:0] B:G:R:x 10:10:10:2 little endian
argb2101010
0x30335241 + - 32-bit ARGB format, [31:0] A:R:G:B 2:10:10:10 little endian
abgr2101010
0x30334241 + - 32-bit ABGR format, [31:0] A:B:G:R 2:10:10:10 little endian
rgba1010102
0x30334152 + - 32-bit RGBA format, [31:0] R:G:B:A 10:10:10:2 little endian
bgra1010102
0x30334142 + - 32-bit BGRA format, [31:0] B:G:R:A 10:10:10:2 little endian
yuyv
0x56595559 + - packed YCbCr format, [31:0] Cr0:Y1:Cb0:Y0 8:8:8:8 little endian
yvyu
0x55595659 + - packed YCbCr format, [31:0] Cb0:Y1:Cr0:Y0 8:8:8:8 little endian
uyvy
0x59565955 + - packed YCbCr format, [31:0] Y1:Cr0:Y0:Cb0 8:8:8:8 little endian
vyuy
0x59555956 + - packed YCbCr format, [31:0] Y1:Cb0:Y0:Cr0 8:8:8:8 little endian
ayuv
0x56555941 + - packed AYCbCr format, [31:0] A:Y:Cb:Cr 8:8:8:8 little endian
nv12
0x3231564e + - 2 plane YCbCr Cr:Cb format, 2x2 subsampled Cr:Cb plane
nv21
0x3132564e + - 2 plane YCbCr Cb:Cr format, 2x2 subsampled Cb:Cr plane
nv16
0x3631564e + - 2 plane YCbCr Cr:Cb format, 2x1 subsampled Cr:Cb plane
nv61
0x3136564e + - 2 plane YCbCr Cb:Cr format, 2x1 subsampled Cb:Cr plane
yuv410
0x39565559 + - 3 plane YCbCr format, 4x4 subsampled Cb (1) and Cr (2) planes
yvu410
0x39555659 + - 3 plane YCbCr format, 4x4 subsampled Cr (1) and Cb (2) planes
yuv411
0x31315559 + - 3 plane YCbCr format, 4x1 subsampled Cb (1) and Cr (2) planes
yvu411
0x31315659 + - 3 plane YCbCr format, 4x1 subsampled Cr (1) and Cb (2) planes
yuv420
0x32315559 + - 3 plane YCbCr format, 2x2 subsampled Cb (1) and Cr (2) planes
yvu420
0x32315659 + - 3 plane YCbCr format, 2x2 subsampled Cr (1) and Cb (2) planes
yuv422
0x36315559 + - 3 plane YCbCr format, 2x1 subsampled Cb (1) and Cr (2) planes
yvu422
0x36315659 + - 3 plane YCbCr format, 2x1 subsampled Cr (1) and Cb (2) planes
yuv444
0x34325559 + - 3 plane YCbCr format, non-subsampled Cb (1) and Cr (2) planes
yvu444
0x34325659 + - 3 plane YCbCr format, non-subsampled Cr (1) and Cb (2) planes

wl_buffer + - content for a wl_surface

+ A buffer provides the content for a wl_surface. Buffers are + created through factory interfaces such as wl_drm, wl_shm or + similar. It has a width and a height and can be attached to a + wl_surface, but the mechanism by which a client provides and + updates the contents is defined by the buffer factory interface. +

Requests provided by wl_buffer

wl_buffer::destroy + - destroy a buffer

+

+

+ Destroy a buffer. If and how you need to release the backing + storage is defined by the buffer factory interface.

For possible side-effects to a surface, see wl_surface.attach. +

Events provided by wl_buffer

wl_buffer::release + - compositor releases buffer

+

+

+ Sent when this wl_buffer is no longer used by the compositor. + The client is now free to reuse or destroy this buffer and its + backing storage.

If a client receives a release event before the frame callback + requested in the same wl_surface.commit that attaches this + wl_buffer to a surface, then the client is immediately free to + reuse the buffer and its backing storage, and does not need a + second buffer for the next surface content update. Typically + this is possible, when the compositor maintains a copy of the + wl_surface contents, e.g. as a GL texture. This is an important + optimization for GL(ES) compositors with wl_shm clients. +

wl_data_offer + - offer to transfer data

+ A wl_data_offer represents a piece of data offered for transfer + by another client (the source client). It is used by the + copy-and-paste and drag-and-drop mechanisms. The offer + describes the different mime types that the data can be + converted to and provides the mechanism for transferring the + data directly from the source client. +

Requests provided by wl_data_offer

wl_data_offer::accept + - accept one of the offered mime types

+

serial
uint + - serial number of the accept request
mime_type
string + - mime type accepted by the client

+

+ Indicate that the client can accept the given mime type, or + NULL for not accepted.

For objects of version 2 or older, this request is used by the + client to give feedback whether the client can receive the given + mime type, or NULL if none is accepted; the feedback does not + determine whether the drag-and-drop operation succeeds or not.

For objects of version 3 or newer, this request determines the + final result of the drag-and-drop operation. If the end result + is that no mime types were accepted, the drag-and-drop operation + will be cancelled and the corresponding drag source will receive + wl_data_source.cancelled. Clients may still use this event in + conjunction with wl_data_source.action for feedback. +

wl_data_offer::receive + - request that the data is transferred

+

mime_type
string + - mime type desired by receiver
fd
fd + - file descriptor for data transfer

+

+ To transfer the offered data, the client issues this request + and indicates the mime type it wants to receive. The transfer + happens through the passed file descriptor (typically created + with the pipe system call). The source client writes the data + in the mime type representation requested and then closes the + file descriptor.

The receiving client reads from the read end of the pipe until + EOF and then closes its end, at which point the transfer is + complete.

This request may happen multiple times for different mime types, + both before and after wl_data_device.drop. Drag-and-drop destination + clients may preemptively fetch data or examine it more closely to + determine acceptance. +

wl_data_offer::destroy + - destroy data offer

+

+

+ Destroy the data offer. +

wl_data_offer::finish + - the offer will no longer be used

+

+

+ Notifies the compositor that the drag destination successfully + finished the drag-and-drop operation.

Upon receiving this request, the compositor will emit + wl_data_source.dnd_finished on the drag source client.

It is a client error to perform other requests than + wl_data_offer.destroy after this one. It is also an error to perform + this request after a NULL mime type has been set in + wl_data_offer.accept or no action was received through + wl_data_offer.action. +

wl_data_offer::set_actions + - set the available/preferred drag-and-drop actions

+

dnd_actions
uint + - actions supported by the destination client
preferred_action
uint + - action preferred by the destination client

+

+ Sets the actions that the destination side client supports for + this operation. This request may trigger the emission of + wl_data_source.action and wl_data_offer.action events if the compositor + needs to change the selected action.

This request can be called multiple times throughout the + drag-and-drop operation, typically in response to wl_data_device.enter + or wl_data_device.motion events.

This request determines the final result of the drag-and-drop + operation. If the end result is that no action is accepted, + the drag source will receive wl_drag_source.cancelled.

The dnd_actions argument must contain only values expressed in the + wl_data_device_manager.dnd_actions enum, and the preferred_action + argument must only contain one of those values set, otherwise it + will result in a protocol error.

While managing an "ask" action, the destination drag-and-drop client + may perform further wl_data_offer.receive requests, and is expected + to perform one last wl_data_offer.set_actions request with a preferred + action other than "ask" (and optionally wl_data_offer.accept) before + requesting wl_data_offer.finish, in order to convey the action selected + by the user. If the preferred action is not in the + wl_data_offer.source_actions mask, an error will be raised.

If the "ask" action is dismissed (e.g. user cancellation), the client + is expected to perform wl_data_offer.destroy right away.

This request can only be made on drag-and-drop offers, a protocol error + will be raised otherwise. +

Events provided by wl_data_offer

wl_data_offer::offer + - advertise offered mime type

+

mime_type
string + - offered mime type

+

+ Sent immediately after creating the wl_data_offer object. One + event per offered mime type. +

wl_data_offer::source_actions + - notify the source-side available actions

+

source_actions
uint + - actions offered by the data source

+

+ This event indicates the actions offered by the data source. It + will be sent right after wl_data_device.enter, or anytime the source + side changes its offered actions through wl_data_source.set_actions. +

wl_data_offer::action + - notify the selected action

+

dnd_action
uint + - action selected by the compositor

+

+ This event indicates the action selected by the compositor after + matching the source/destination side actions. Only one action (or + none) will be offered here.

This event can be emitted multiple times during the drag-and-drop + operation in response to destination side action changes through + wl_data_offer.set_actions.

This event will no longer be emitted after wl_data_device.drop + happened on the drag-and-drop destination, the client must + honor the last action received, or the last preferred one set + through wl_data_offer.set_actions when handling an "ask" action.

Compositors may also change the selected action on the fly, mainly + in response to keyboard modifier changes during the drag-and-drop + operation.

The most recent action received is always the valid one. Prior to + receiving wl_data_device.drop, the chosen action may change (e.g. + due to keyboard modifiers being pressed). At the time of receiving + wl_data_device.drop the drag-and-drop destination must honor the + last action received.

Action changes may still happen after wl_data_device.drop, + especially on "ask" actions, where the drag-and-drop destination + may choose another action afterwards. Action changes happening + at this stage are always the result of inter-client negotiation, the + compositor shall no longer be able to induce a different action.

Upon "ask" actions, it is expected that the drag-and-drop destination + may potentially choose a different action and/or mime type, + based on wl_data_offer.source_actions and finally chosen by the + user (e.g. popping up a menu with the available options). The + final wl_data_offer.set_actions and wl_data_offer.accept requests + must happen before the call to wl_data_offer.finish. +

Enums provided by wl_data_offer

wl_data_offer::error

invalid_finish
0 + - finish request was called untimely
invalid_action_mask
1 + - action mask contains invalid values
invalid_action
2 + - action argument has an invalid value
invalid_offer
3 + - offer doesn't accept this request

wl_data_source + - offer to transfer data

+ The wl_data_source object is the source side of a wl_data_offer. + It is created by the source client in a data transfer and + provides a way to describe the offered data and a way to respond + to requests to transfer the data. +

Requests provided by wl_data_source

wl_data_source::offer + - add an offered mime type

+

mime_type
string + - mime type offered by the data source

+

+ This request adds a mime type to the set of mime types + advertised to targets. Can be called several times to offer + multiple types. +

wl_data_source::destroy + - destroy the data source

+

+

+ Destroy the data source. +

wl_data_source::set_actions + - set the available drag-and-drop actions

+

dnd_actions
uint + - actions supported by the data source

+

+ Sets the actions that the source side client supports for this + operation. This request may trigger wl_data_source.action and + wl_data_offer.action events if the compositor needs to change the + selected action.

The dnd_actions argument must contain only values expressed in the + wl_data_device_manager.dnd_actions enum, otherwise it will result + in a protocol error.

This request must be made once only, and can only be made on sources + used in drag-and-drop, so it must be performed before + wl_data_device.start_drag. Attempting to use the source other than + for drag-and-drop will raise a protocol error. +

Events provided by wl_data_source

wl_data_source::target + - a target accepts an offered mime type

+

mime_type
string + - mime type accepted by the target

+

+ Sent when a target accepts pointer_focus or motion events. If + a target does not accept any of the offered types, type is NULL.

Used for feedback during drag-and-drop. +

wl_data_source::send + - send the data

+

mime_type
string + - mime type for the data
fd
fd + - file descriptor for the data

+

+ Request for data from the client. Send the data as the + specified mime type over the passed file descriptor, then + close it. +

wl_data_source::cancelled + - selection was cancelled

+

+

+ This data source is no longer valid. There are several reasons why + this could happen:

- The data source has been replaced by another data source. + - The drag-and-drop operation was performed, but the drop destination + did not accept any of the mime types offered through + wl_data_source.target. + - The drag-and-drop operation was performed, but the drop destination + did not select any of the actions present in the mask offered through + wl_data_source.action. + - The drag-and-drop operation was performed but didn't happen over a + surface. + - The compositor cancelled the drag-and-drop operation (e.g. compositor + dependent timeouts to avoid stale drag-and-drop transfers).

The client should clean up and destroy this data source.

For objects of version 2 or older, wl_data_source.cancelled will + only be emitted if the data source was replaced by another data + source. +

wl_data_source::dnd_drop_performed + - the drag-and-drop operation physically finished

+

+

+ The user performed the drop action. This event does not indicate + acceptance, wl_data_source.cancelled may still be emitted afterwards + if the drop destination does not accept any mime type.

However, this event might however not be received if the compositor + cancelled the drag-and-drop operation before this event could happen.

Note that the data_source may still be used in the future and should + not be destroyed here. +

wl_data_source::dnd_finished + - the drag-and-drop operation concluded

+

+

+ The drop destination finished interoperating with this data + source, so the client is now free to destroy this data source and + free all associated data.

If the action used to perform the operation was "move", the + source can now delete the transferred data. +

wl_data_source::action + - notify the selected action

+

dnd_action
uint + - action selected by the compositor

+

+ This event indicates the action selected by the compositor after + matching the source/destination side actions. Only one action (or + none) will be offered here.

This event can be emitted multiple times during the drag-and-drop + operation, mainly in response to destination side changes through + wl_data_offer.set_actions, and as the data device enters/leaves + surfaces.

It is only possible to receive this event after + wl_data_source.dnd_drop_performed if the drag-and-drop operation + ended in an "ask" action, in which case the final wl_data_source.action + event will happen immediately before wl_data_source.dnd_finished.

Compositors may also change the selected action on the fly, mainly + in response to keyboard modifier changes during the drag-and-drop + operation.

The most recent action received is always the valid one. The chosen + action may change alongside negotiation (e.g. an "ask" action can turn + into a "move" operation), so the effects of the final action must + always be applied in wl_data_offer.dnd_finished.

Clients can trigger cursor surface changes from this point, so + they reflect the current action. +

Enums provided by wl_data_source

wl_data_source::error

invalid_action_mask
0 + - action mask contains invalid values
invalid_source
1 + - source doesn't accept this request

wl_data_device + - data transfer device

+ There is one wl_data_device per seat which can be obtained + from the global wl_data_device_manager singleton.

A wl_data_device provides access to inter-client data transfer + mechanisms such as copy-and-paste and drag-and-drop. +

Requests provided by wl_data_device

wl_data_device::start_drag + - start drag-and-drop operation

+

source
wl_data_source + - data source for the eventual transfer
origin
wl_surface + - surface where the drag originates
icon
wl_surface + - drag-and-drop icon surface
serial
uint + - serial number of the implicit grab on the origin

+

+ This request asks the compositor to start a drag-and-drop + operation on behalf of the client.

The source argument is the data source that provides the data + for the eventual data transfer. If source is NULL, enter, leave + and motion events are sent only to the client that initiated the + drag and the client is expected to handle the data passing + internally.

The origin surface is the surface where the drag originates and + the client must have an active implicit grab that matches the + serial.

The icon surface is an optional (can be NULL) surface that + provides an icon to be moved around with the cursor. Initially, + the top-left corner of the icon surface is placed at the cursor + hotspot, but subsequent wl_surface.attach request can move the + relative position. Attach requests must be confirmed with + wl_surface.commit as usual. The icon surface is given the role of + a drag-and-drop icon. If the icon surface already has another role, + it raises a protocol error.

The current and pending input regions of the icon wl_surface are + cleared, and wl_surface.set_input_region is ignored until the + wl_surface is no longer used as the icon surface. When the use + as an icon ends, the current and pending input regions become + undefined, and the wl_surface is unmapped. +

wl_data_device::set_selection + - copy data to the selection

+

source
wl_data_source + - data source for the selection
serial
uint + - serial number of the event that triggered this request

+

+ This request asks the compositor to set the selection + to the data from the source on behalf of the client.

To unset the selection, set the source to NULL. +

wl_data_device::release + - destroy data device

+

+

+ This request destroys the data device. +

Events provided by wl_data_device

wl_data_device::data_offer + - introduce a new wl_data_offer

+

id
+ id for the new + wl_data_offer + - the new data_offer object

+

+ The data_offer event introduces a new wl_data_offer object, + which will subsequently be used in either the + data_device.enter event (for drag-and-drop) or the + data_device.selection event (for selections). Immediately + following the data_device_data_offer event, the new data_offer + object will send out data_offer.offer events to describe the + mime types it offers. +

wl_data_device::enter + - initiate drag-and-drop session

+

serial
uint + - serial number of the enter event
surface
wl_surface + - client surface entered
x
fixed + - surface-local x coordinate
y
fixed + - surface-local y coordinate
id
wl_data_offer + - source data_offer object

+

+ This event is sent when an active drag-and-drop pointer enters + a surface owned by the client. The position of the pointer at + enter time is provided by the x and y arguments, in surface-local + coordinates. +

wl_data_device::leave + - end drag-and-drop session

+

+

+ This event is sent when the drag-and-drop pointer leaves the + surface and the session ends. The client must destroy the + wl_data_offer introduced at enter time at this point. +

wl_data_device::motion + - drag-and-drop session motion

+

time
uint + - timestamp with millisecond granularity
x
fixed + - surface-local x coordinate
y
fixed + - surface-local y coordinate

+

+ This event is sent when the drag-and-drop pointer moves within + the currently focused surface. The new position of the pointer + is provided by the x and y arguments, in surface-local + coordinates. +

wl_data_device::drop + - end drag-and-drop session successfully

+

+

+ The event is sent when a drag-and-drop operation is ended + because the implicit grab is removed.

The drag-and-drop destination is expected to honor the last action + received through wl_data_offer.action, if the resulting action is + "copy" or "move", the destination can still perform + wl_data_offer.receive requests, and is expected to end all + transfers with a wl_data_offer.finish request.

If the resulting action is "ask", the action will not be considered + final. The drag-and-drop destination is expected to perform one last + wl_data_offer.set_actions request, or wl_data_offer.destroy in order + to cancel the operation. +

wl_data_device::selection + - advertise new selection

+

id
wl_data_offer + - selection data_offer object

+

+ The selection event is sent out to notify the client of a new + wl_data_offer for the selection for this device. The + data_device.data_offer and the data_offer.offer events are + sent out immediately before this event to introduce the data + offer object. The selection event is sent to a client + immediately before receiving keyboard focus and when a new + selection is set while the client has keyboard focus. The + data_offer is valid until a new data_offer or NULL is received + or until the client loses keyboard focus. The client must + destroy the previous selection data_offer, if any, upon receiving + this event. +

Enums provided by wl_data_device

wl_data_device::error

role
0 + - given wl_surface has another role

wl_data_device_manager + - data transfer interface

+ The wl_data_device_manager is a singleton global object that + provides access to inter-client data transfer mechanisms such as + copy-and-paste and drag-and-drop. These mechanisms are tied to + a wl_seat and this interface lets a client get a wl_data_device + corresponding to a wl_seat.

Depending on the version bound, the objects created from the bound + wl_data_device_manager object will have different requirements for + functioning properly. See wl_data_source.set_actions, + wl_data_offer.accept and wl_data_offer.finish for details. +

Requests provided by wl_data_device_manager

wl_data_device_manager::create_data_source + - create a new data source

+

id
+ id for the new + wl_data_source + - data source to create

+

+ Create a new data source. +

wl_data_device_manager::get_data_device + - create a new data device

+

id
+ id for the new + wl_data_device + - data device to create
seat
wl_seat + - seat associated with the data device

+

+ Create a new data device for a given seat. +

Enums provided by wl_data_device_manager

wl_data_device_manager::dnd_action + - bitfield + + - drag and drop actions

+ This is a bitmask of the available/preferred actions in a + drag-and-drop operation.

In the compositor, the selected action is a result of matching the + actions offered by the source and destination sides. "action" events + with a "none" action will be sent to both source and destination if + there is no match. All further checks will effectively happen on + (source actions ∩ destination actions).

In addition, compositors may also pick different actions in + reaction to key modifiers being pressed. One common design that + is used in major toolkits (and the behavior recommended for + compositors) is:

- If no modifiers are pressed, the first match (in bit order) + will be used. + - Pressing Shift selects "move", if enabled in the mask. + - Pressing Control selects "copy", if enabled in the mask.

Behavior beyond that is considered implementation-dependent. + Compositors may for example bind other modifiers (like Alt/Meta) + or drags initiated with other buttons than BTN_LEFT to specific + actions (e.g. "ask"). +

none
0 + - no action
copy
1 + - copy action
move
2 + - move action
ask
4 + - ask action

wl_shell + - create desktop-style surfaces

+ This interface is implemented by servers that provide + desktop-style user interfaces.

It allows clients to associate a wl_shell_surface with + a basic surface.

Note! This protocol is deprecated and not intended for production use. + For desktop-style user interfaces, use xdg_shell. +

Requests provided by wl_shell

wl_shell::get_shell_surface + - create a shell surface from a surface

+

id
+ id for the new + wl_shell_surface + - shell surface to create
surface
wl_surface + - surface to be given the shell surface role

+

+ Create a shell surface for an existing surface. This gives + the wl_surface the role of a shell surface. If the wl_surface + already has another role, it raises a protocol error.

Only one shell surface can be associated with a given surface. +

Enums provided by wl_shell

wl_shell::error

role
0 + - given wl_surface has another role

wl_shell_surface + - desktop-style metadata interface

+ An interface that may be implemented by a wl_surface, for + implementations that provide a desktop-style user interface.

It provides requests to treat surfaces like toplevel, fullscreen + or popup windows, move, resize or maximize them, associate + metadata like title and class, etc.

On the server side the object is automatically destroyed when + the related wl_surface is destroyed. On the client side, + wl_shell_surface_destroy() must be called before destroying + the wl_surface object. +

Requests provided by wl_shell_surface

wl_shell_surface::pong + - respond to a ping event

+

serial
uint + - serial number of the ping event

+

+ A client must respond to a ping event with a pong request or + the client may be deemed unresponsive. +

wl_shell_surface::move + - start an interactive move

+

seat
wl_seat + - seat whose pointer is used
serial
uint + - serial number of the implicit grab on the pointer

+

+ Start a pointer-driven move of the surface.

This request must be used in response to a button press event. + The server may ignore move requests depending on the state of + the surface (e.g. fullscreen or maximized). +

wl_shell_surface::resize + - start an interactive resize

+

seat
wl_seat + - seat whose pointer is used
serial
uint + - serial number of the implicit grab on the pointer
edges
wl_shell_surface::resize + (uint) + + - which edge or corner is being dragged

+

+ Start a pointer-driven resizing of the surface.

This request must be used in response to a button press event. + The server may ignore resize requests depending on the state of + the surface (e.g. fullscreen or maximized). +

wl_shell_surface::set_toplevel + - make the surface a toplevel surface

+

+

+ Map the surface as a toplevel surface.

A toplevel surface is not fullscreen, maximized or transient. +

wl_shell_surface::set_transient + - make the surface a transient surface

+

parent
wl_surface + - parent surface
x
int + - surface-local x coordinate
y
int + - surface-local y coordinate
flags
wl_shell_surface::transient + (uint) + + - transient surface behavior

+

+ Map the surface relative to an existing surface.

The x and y arguments specify the location of the upper left + corner of the surface relative to the upper left corner of the + parent surface, in surface-local coordinates.

The flags argument controls details of the transient behaviour. +

wl_shell_surface::set_fullscreen + - make the surface a fullscreen surface

+

method
wl_shell_surface::fullscreen_method + (uint) + + - method for resolving size conflict
framerate
uint + - framerate in mHz
output
wl_output + - output on which the surface is to be fullscreen

+

+ Map the surface as a fullscreen surface.

If an output parameter is given then the surface will be made + fullscreen on that output. If the client does not specify the + output then the compositor will apply its policy - usually + choosing the output on which the surface has the biggest surface + area.

The client may specify a method to resolve a size conflict + between the output size and the surface size - this is provided + through the method parameter.

The framerate parameter is used only when the method is set + to "driver", to indicate the preferred framerate. A value of 0 + indicates that the client does not care about framerate. The + framerate is specified in mHz, that is framerate of 60000 is 60Hz.

A method of "scale" or "driver" implies a scaling operation of + the surface, either via a direct scaling operation or a change of + the output mode. This will override any kind of output scaling, so + that mapping a surface with a buffer size equal to the mode can + fill the screen independent of buffer_scale.

A method of "fill" means we don't scale up the buffer, however + any output scale is applied. This means that you may run into + an edge case where the application maps a buffer with the same + size of the output mode but buffer_scale 1 (thus making a + surface larger than the output). In this case it is allowed to + downscale the results to fit the screen.

The compositor must reply to this request with a configure event + with the dimensions for the output on which the surface will + be made fullscreen. +

wl_shell_surface::set_popup + - make the surface a popup surface

+

seat
wl_seat + - seat whose pointer is used
serial
uint + - serial number of the implicit grab on the pointer
parent
wl_surface + - parent surface
x
int + - surface-local x coordinate
y
int + - surface-local y coordinate
flags
wl_shell_surface::transient + (uint) + + - transient surface behavior

+

+ Map the surface as a popup.

A popup surface is a transient surface with an added pointer + grab.

An existing implicit grab will be changed to owner-events mode, + and the popup grab will continue after the implicit grab ends + (i.e. releasing the mouse button does not cause the popup to + be unmapped).

The popup grab continues until the window is destroyed or a + mouse button is pressed in any other client's window. A click + in any of the client's surfaces is reported as normal, however, + clicks in other clients' surfaces will be discarded and trigger + the callback.

The x and y arguments specify the location of the upper left + corner of the surface relative to the upper left corner of the + parent surface, in surface-local coordinates. +

wl_shell_surface::set_maximized + - make the surface a maximized surface

+

output
wl_output + - output on which the surface is to be maximized

+

+ Map the surface as a maximized surface.

If an output parameter is given then the surface will be + maximized on that output. If the client does not specify the + output then the compositor will apply its policy - usually + choosing the output on which the surface has the biggest surface + area.

The compositor will reply with a configure event telling + the expected new surface size. The operation is completed + on the next buffer attach to this surface.

A maximized surface typically fills the entire output it is + bound to, except for desktop elements such as panels. This is + the main difference between a maximized shell surface and a + fullscreen shell surface.

The details depend on the compositor implementation. +

wl_shell_surface::set_title + - set surface title

+

title
string + - surface title

+

+ Set a short title for the surface.

This string may be used to identify the surface in a task bar, + window list, or other user interface elements provided by the + compositor.

The string must be encoded in UTF-8. +

wl_shell_surface::set_class + - set surface class

+

class_
string + - surface class

+

+ Set a class for the surface.

The surface class identifies the general class of applications + to which the surface belongs. A common convention is to use the + file name (or the full path if it is a non-standard location) of + the application's .desktop file as the class. +

Events provided by wl_shell_surface

wl_shell_surface::ping + - ping client

+

serial
uint + - serial number of the ping

+

+ Ping a client to check if it is receiving events and sending + requests. A client is expected to reply with a pong request. +

wl_shell_surface::configure + - suggest resize

+

edges
wl_shell_surface::resize + (uint) + + - how the surface was resized
width
int + - new width of the surface
height
int + - new height of the surface

+

+ The configure event asks the client to resize its surface.

The size is a hint, in the sense that the client is free to + ignore it if it doesn't resize, pick a smaller size (to + satisfy aspect ratio or resize in steps of NxM pixels).

The edges parameter provides a hint about how the surface + was resized. The client may use this information to decide + how to adjust its content to the new size (e.g. a scrolling + area might adjust its content position to leave the viewable + content unmoved).

The client is free to dismiss all but the last configure + event it received.

The width and height arguments specify the size of the window + in surface-local coordinates. +

wl_shell_surface::popup_done + - popup interaction is done

+

+

+ The popup_done event is sent out when a popup grab is broken, + that is, when the user clicks a surface that doesn't belong + to the client owning the popup surface. +

Enums provided by wl_shell_surface

wl_shell_surface::resize + - bitfield + + - edge values for resizing

+ These values are used to indicate which edge of a surface + is being dragged in a resize operation. The server may + use this information to adapt its behavior, e.g. choose + an appropriate cursor image. +

none
0 + - no edge
top
1 + - top edge
bottom
2 + - bottom edge
left
4 + - left edge
top_left
5 + - top and left edges
bottom_left
6 + - bottom and left edges
right
8 + - right edge
top_right
9 + - top and right edges
bottom_right
10 + - bottom and right edges

wl_shell_surface::transient + - bitfield + + - details of transient behaviour

+ These flags specify details of the expected behaviour + of transient surfaces. Used in the set_transient request. +

inactive
0x1 + - do not set keyboard focus

wl_shell_surface::fullscreen_method + - different method to set the surface fullscreen

+ Hints to indicate to the compositor how to deal with a conflict + between the dimensions of the surface and the dimensions of the + output. The compositor is free to ignore this parameter. +

default
0 + - no preference, apply default policy
scale
1 + - scale, preserve the surface's aspect ratio and center on output
driver
2 + - switch output mode to the smallest mode that can fit the surface, add black borders to compensate size mismatch
fill
3 + - no upscaling, center on output and add black borders to compensate size mismatch

wl_surface + - an onscreen surface

+ A surface is a rectangular area that is displayed on the screen. + It has a location, size and pixel contents.

The size of a surface (and relative positions on it) is described + in surface-local coordinates, which may differ from the buffer + coordinates of the pixel content, in case a buffer_transform + or a buffer_scale is used.

A surface without a "role" is fairly useless: a compositor does + not know where, when or how to present it. The role is the + purpose of a wl_surface. Examples of roles are a cursor for a + pointer (as set by wl_pointer.set_cursor), a drag icon + (wl_data_device.start_drag), a sub-surface + (wl_subcompositor.get_subsurface), and a window as defined by a + shell protocol (e.g. wl_shell.get_shell_surface).

A surface can have only one role at a time. Initially a + wl_surface does not have a role. Once a wl_surface is given a + role, it is set permanently for the whole lifetime of the + wl_surface object. Giving the current role again is allowed, + unless explicitly forbidden by the relevant interface + specification.

Surface roles are given by requests in other interfaces such as + wl_pointer.set_cursor. The request should explicitly mention + that this request gives a role to a wl_surface. Often, this + request also creates a new protocol object that represents the + role and adds additional functionality to wl_surface. When a + client wants to destroy a wl_surface, they must destroy this 'role + object' before the wl_surface.

Destroying the role object does not remove the role from the + wl_surface, but it may stop the wl_surface from "playing the role". + For instance, if a wl_subsurface object is destroyed, the wl_surface + it was created for will be unmapped and forget its position and + z-order. It is allowed to create a wl_subsurface for the same + wl_surface again, but it is not allowed to use the wl_surface as + a cursor (cursor is a different role than sub-surface, and role + switching is not allowed). +

Requests provided by wl_surface

wl_surface::destroy + - delete surface

+

+

+ Deletes the surface and invalidates its object ID. +

wl_surface::attach + - set the surface contents

+

buffer
wl_buffer + - buffer of surface contents
x
int + - surface-local x coordinate
y
int + - surface-local y coordinate

+

+ Set a buffer as the content of this surface.

The new size of the surface is calculated based on the buffer + size transformed by the inverse buffer_transform and the + inverse buffer_scale. This means that the supplied buffer + must be an integer multiple of the buffer_scale.

The x and y arguments specify the location of the new pending + buffer's upper left corner, relative to the current buffer's upper + left corner, in surface-local coordinates. In other words, the + x and y, combined with the new surface size define in which + directions the surface's size changes.

Surface contents are double-buffered state, see wl_surface.commit.

The initial surface contents are void; there is no content. + wl_surface.attach assigns the given wl_buffer as the pending + wl_buffer. wl_surface.commit makes the pending wl_buffer the new + surface contents, and the size of the surface becomes the size + calculated from the wl_buffer, as described above. After commit, + there is no pending buffer until the next attach.

Committing a pending wl_buffer allows the compositor to read the + pixels in the wl_buffer. The compositor may access the pixels at + any time after the wl_surface.commit request. When the compositor + will not access the pixels anymore, it will send the + wl_buffer.release event. Only after receiving wl_buffer.release, + the client may reuse the wl_buffer. A wl_buffer that has been + attached and then replaced by another attach instead of committed + will not receive a release event, and is not used by the + compositor.

Destroying the wl_buffer after wl_buffer.release does not change + the surface contents. However, if the client destroys the + wl_buffer before receiving the wl_buffer.release event, the surface + contents become undefined immediately.

If wl_surface.attach is sent with a NULL wl_buffer, the + following wl_surface.commit will remove the surface content. +

wl_surface::damage + - mark part of the surface damaged

+

x
int + - surface-local x coordinate
y
int + - surface-local y coordinate
width
int + - width of damage rectangle
height
int + - height of damage rectangle

+

+ This request is used to describe the regions where the pending + buffer is different from the current surface contents, and where + the surface therefore needs to be repainted. The compositor + ignores the parts of the damage that fall outside of the surface.

Damage is double-buffered state, see wl_surface.commit.

The damage rectangle is specified in surface-local coordinates, + where x and y specify the upper left corner of the damage rectangle.

The initial value for pending damage is empty: no damage. + wl_surface.damage adds pending damage: the new pending damage + is the union of old pending damage and the given rectangle.

wl_surface.commit assigns pending damage as the current damage, + and clears pending damage. The server will clear the current + damage as it repaints the surface.

Alternatively, damage can be posted with wl_surface.damage_buffer + which uses buffer coordinates instead of surface coordinates, + and is probably the preferred and intuitive way of doing this. +

wl_surface::frame + - request a frame throttling hint

+

callback
+ id for the new + wl_callback + - callback object for the frame request

+

+ Request a notification when it is a good time to start drawing a new + frame, by creating a frame callback. This is useful for throttling + redrawing operations, and driving animations.

When a client is animating on a wl_surface, it can use the 'frame' + request to get notified when it is a good time to draw and commit the + next frame of animation. If the client commits an update earlier than + that, it is likely that some updates will not make it to the display, + and the client is wasting resources by drawing too often.

The frame request will take effect on the next wl_surface.commit. + The notification will only be posted for one frame unless + requested again. For a wl_surface, the notifications are posted in + the order the frame requests were committed.

The server must send the notifications so that a client + will not send excessive updates, while still allowing + the highest possible update rate for clients that wait for the reply + before drawing again. The server should give some time for the client + to draw and commit after sending the frame callback events to let it + hit the next output refresh.

A server should avoid signaling the frame callbacks if the + surface is not visible in any way, e.g. the surface is off-screen, + or completely obscured by other opaque surfaces.

The object returned by this request will be destroyed by the + compositor after the callback is fired and as such the client must not + attempt to use it after that point.

The callback_data passed in the callback is the current time, in + milliseconds, with an undefined base. +

wl_surface::set_opaque_region + - set opaque region

+

region
wl_region + - opaque region of the surface

+

+ This request sets the region of the surface that contains + opaque content.

The opaque region is an optimization hint for the compositor + that lets it optimize the redrawing of content behind opaque + regions. Setting an opaque region is not required for correct + behaviour, but marking transparent content as opaque will result + in repaint artifacts.

The opaque region is specified in surface-local coordinates.

The compositor ignores the parts of the opaque region that fall + outside of the surface.

Opaque region is double-buffered state, see wl_surface.commit.

wl_surface.set_opaque_region changes the pending opaque region. + wl_surface.commit copies the pending region to the current region. + Otherwise, the pending and current regions are never changed.

The initial value for an opaque region is empty. Setting the pending + opaque region has copy semantics, and the wl_region object can be + destroyed immediately. A NULL wl_region causes the pending opaque + region to be set to empty. +

wl_surface::set_input_region + - set input region

+

region
wl_region + - input region of the surface

+

+ This request sets the region of the surface that can receive + pointer and touch events.

Input events happening outside of this region will try the next + surface in the server surface stack. The compositor ignores the + parts of the input region that fall outside of the surface.

The input region is specified in surface-local coordinates.

Input region is double-buffered state, see wl_surface.commit.

wl_surface.set_input_region changes the pending input region. + wl_surface.commit copies the pending region to the current region. + Otherwise the pending and current regions are never changed, + except cursor and icon surfaces are special cases, see + wl_pointer.set_cursor and wl_data_device.start_drag.

The initial value for an input region is infinite. That means the + whole surface will accept input. Setting the pending input region + has copy semantics, and the wl_region object can be destroyed + immediately. A NULL wl_region causes the input region to be set + to infinite. +

wl_surface::commit + - commit pending surface state

+

+

+ Surface state (input, opaque, and damage regions, attached buffers, + etc.) is double-buffered. Protocol requests modify the pending state, + as opposed to the current state in use by the compositor. A commit + request atomically applies all pending state, replacing the current + state. After commit, the new pending state is as documented for each + related request.

On commit, a pending wl_buffer is applied first, and all other state + second. This means that all coordinates in double-buffered state are + relative to the new wl_buffer coming into use, except for + wl_surface.attach itself. If there is no pending wl_buffer, the + coordinates are relative to the current surface contents.

All requests that need a commit to become effective are documented + to affect double-buffered state.

Other interfaces may add further double-buffered surface state. +

wl_surface::set_buffer_transform + - sets the buffer transformation

+

transform
wl_output::transform + (int) + + - transform for interpreting buffer contents

+

+ This request sets an optional transformation on how the compositor + interprets the contents of the buffer attached to the surface. The + accepted values for the transform parameter are the values for + wl_output.transform.

Buffer transform is double-buffered state, see wl_surface.commit.

A newly created surface has its buffer transformation set to normal.

wl_surface.set_buffer_transform changes the pending buffer + transformation. wl_surface.commit copies the pending buffer + transformation to the current one. Otherwise, the pending and current + values are never changed.

The purpose of this request is to allow clients to render content + according to the output transform, thus permitting the compositor to + use certain optimizations even if the display is rotated. Using + hardware overlays and scanning out a client buffer for fullscreen + surfaces are examples of such optimizations. Those optimizations are + highly dependent on the compositor implementation, so the use of this + request should be considered on a case-by-case basis.

Note that if the transform value includes 90 or 270 degree rotation, + the width of the buffer will become the surface height and the height + of the buffer will become the surface width.

If transform is not one of the values from the + wl_output.transform enum the invalid_transform protocol error + is raised. +

wl_surface::set_buffer_scale + - sets the buffer scaling factor

+

scale
int + - positive scale for interpreting buffer contents

+

+ This request sets an optional scaling factor on how the compositor + interprets the contents of the buffer attached to the window.

Buffer scale is double-buffered state, see wl_surface.commit.

A newly created surface has its buffer scale set to 1.

wl_surface.set_buffer_scale changes the pending buffer scale. + wl_surface.commit copies the pending buffer scale to the current one. + Otherwise, the pending and current values are never changed.

The purpose of this request is to allow clients to supply higher + resolution buffer data for use on high resolution outputs. It is + intended that you pick the same buffer scale as the scale of the + output that the surface is displayed on. This means the compositor + can avoid scaling when rendering the surface on that output.

Note that if the scale is larger than 1, then you have to attach + a buffer that is larger (by a factor of scale in each dimension) + than the desired surface size.

If scale is not positive the invalid_scale protocol error is + raised. +

wl_surface::damage_buffer + - mark part of the surface damaged using buffer coordinates

+

x
int + - buffer-local x coordinate
y
int + - buffer-local y coordinate
width
int + - width of damage rectangle
height
int + - height of damage rectangle

+

+ This request is used to describe the regions where the pending + buffer is different from the current surface contents, and where + the surface therefore needs to be repainted. The compositor + ignores the parts of the damage that fall outside of the surface.

Damage is double-buffered state, see wl_surface.commit.

The damage rectangle is specified in buffer coordinates, + where x and y specify the upper left corner of the damage rectangle.

The initial value for pending damage is empty: no damage. + wl_surface.damage_buffer adds pending damage: the new pending + damage is the union of old pending damage and the given rectangle.

wl_surface.commit assigns pending damage as the current damage, + and clears pending damage. The server will clear the current + damage as it repaints the surface.

This request differs from wl_surface.damage in only one way - it + takes damage in buffer coordinates instead of surface-local + coordinates. While this generally is more intuitive than surface + coordinates, it is especially desirable when using wp_viewport + or when a drawing library (like EGL) is unaware of buffer scale + and buffer transform.

Note: Because buffer transformation changes and damage requests may + be interleaved in the protocol stream, it is impossible to determine + the actual mapping between surface and buffer damage until + wl_surface.commit time. Therefore, compositors wishing to take both + kinds of damage into account will have to accumulate damage from the + two requests separately and only transform from one to the other + after receiving the wl_surface.commit. +

Events provided by wl_surface

wl_surface::enter + - surface enters an output

+

output
wl_output + - output entered by the surface

+

+ This is emitted whenever a surface's creation, movement, or resizing + results in some part of it being within the scanout region of an + output.

Note that a surface may be overlapping with zero or more outputs. +

wl_surface::leave + - surface leaves an output

+

output
wl_output + - output left by the surface

+

+ This is emitted whenever a surface's creation, movement, or resizing + results in it no longer having any part of it within the scanout region + of an output. +

Enums provided by wl_surface

wl_surface::error + - wl_surface error values

+ These errors can be emitted in response to wl_surface requests. +

invalid_scale
0 + - buffer scale value is invalid
invalid_transform
1 + - buffer transform value is invalid

wl_seat + - group of input devices

+ A seat is a group of keyboards, pointer and touch devices. This + object is published as a global during start up, or when such a + device is hot plugged. A seat typically has a pointer and + maintains a keyboard focus and a pointer focus. +

Requests provided by wl_seat

wl_seat::get_pointer + - return pointer object

+

id
+ id for the new + wl_pointer + - seat pointer

+

+ The ID provided will be initialized to the wl_pointer interface + for this seat.

This request only takes effect if the seat has the pointer + capability, or has had the pointer capability in the past. + It is a protocol violation to issue this request on a seat that has + never had the pointer capability. +

wl_seat::get_keyboard + - return keyboard object

+

id
+ id for the new + wl_keyboard + - seat keyboard

+

+ The ID provided will be initialized to the wl_keyboard interface + for this seat.

This request only takes effect if the seat has the keyboard + capability, or has had the keyboard capability in the past. + It is a protocol violation to issue this request on a seat that has + never had the keyboard capability. +

wl_seat::get_touch + - return touch object

+

id
+ id for the new + wl_touch + - seat touch interface

+

+ The ID provided will be initialized to the wl_touch interface + for this seat.

This request only takes effect if the seat has the touch + capability, or has had the touch capability in the past. + It is a protocol violation to issue this request on a seat that has + never had the touch capability. +

wl_seat::release + - release the seat object

+

+

+ Using this request a client can tell the server that it is not going to + use the seat object anymore. +

Events provided by wl_seat

wl_seat::capabilities + - seat capabilities changed

+

capabilities
wl_seat::capability + (uint) + + - capabilities of the seat

+

+ This is emitted whenever a seat gains or loses the pointer, + keyboard or touch capabilities. The argument is a capability + enum containing the complete set of capabilities this seat has.

When the pointer capability is added, a client may create a + wl_pointer object using the wl_seat.get_pointer request. This object + will receive pointer events until the capability is removed in the + future.

When the pointer capability is removed, a client should destroy the + wl_pointer objects associated with the seat where the capability was + removed, using the wl_pointer.release request. No further pointer + events will be received on these objects.

In some compositors, if a seat regains the pointer capability and a + client has a previously obtained wl_pointer object of version 4 or + less, that object may start sending pointer events again. This + behavior is considered a misinterpretation of the intended behavior + and must not be relied upon by the client. wl_pointer objects of + version 5 or later must not send events if created before the most + recent event notifying the client of an added pointer capability.

The above behavior also applies to wl_keyboard and wl_touch with the + keyboard and touch capabilities, respectively. +

wl_seat::name + - unique identifier for this seat

+

name
string + - seat identifier

+

+ In a multiseat configuration this can be used by the client to help + identify which physical devices the seat represents. Based on + the seat configuration used by the compositor. +

Enums provided by wl_seat

wl_seat::capability + - bitfield + + - seat capability bitmask

+ This is a bitmask of capabilities this seat has; if a member is + set, then it is present on the seat. +

pointer
1 + - the seat has pointer devices
keyboard
2 + - the seat has one or more keyboards
touch
4 + - the seat has touch devices

wl_pointer + - pointer input device

+ The wl_pointer interface represents one or more input devices, + such as mice, which control the pointer location and pointer_focus + of a seat.

The wl_pointer interface generates motion, enter and leave + events for the surfaces that the pointer is located over, + and button and axis events for button presses, button releases + and scrolling. +

Requests provided by wl_pointer

wl_pointer::set_cursor + - set the pointer surface

+

serial
uint + - serial number of the enter event
surface
wl_surface + - pointer surface
hotspot_x
int + - surface-local x coordinate
hotspot_y
int + - surface-local y coordinate

+

+ Set the pointer surface, i.e., the surface that contains the + pointer image (cursor). This request gives the surface the role + of a cursor. If the surface already has another role, it raises + a protocol error.

The cursor actually changes only if the pointer + focus for this device is one of the requesting client's surfaces + or the surface parameter is the current pointer surface. If + there was a previous surface set with this request it is + replaced. If surface is NULL, the pointer image is hidden.

The parameters hotspot_x and hotspot_y define the position of + the pointer surface relative to the pointer location. Its + top-left corner is always at (x, y) - (hotspot_x, hotspot_y), + where (x, y) are the coordinates of the pointer location, in + surface-local coordinates.

On surface.attach requests to the pointer surface, hotspot_x + and hotspot_y are decremented by the x and y parameters + passed to the request. Attach must be confirmed by + wl_surface.commit as usual.

The hotspot can also be updated by passing the currently set + pointer surface to this request with new values for hotspot_x + and hotspot_y.

The current and pending input regions of the wl_surface are + cleared, and wl_surface.set_input_region is ignored until the + wl_surface is no longer used as the cursor. When the use as a + cursor ends, the current and pending input regions become + undefined, and the wl_surface is unmapped. +

wl_pointer::release + - release the pointer object

+

+

+ Using this request a client can tell the server that it is not going to + use the pointer object anymore.

This request destroys the pointer proxy object, so clients must not call + wl_pointer_destroy() after using this request. +

Events provided by wl_pointer

wl_pointer::enter + - enter event

+

serial
uint + - serial number of the enter event
surface
wl_surface + - surface entered by the pointer
surface_x
fixed + - surface-local x coordinate
surface_y
fixed + - surface-local y coordinate

+

+ Notification that this seat's pointer is focused on a certain + surface.

When a seat's focus enters a surface, the pointer image + is undefined and a client should respond to this event by setting + an appropriate pointer image with the set_cursor request. +

wl_pointer::leave + - leave event

+

serial
uint + - serial number of the leave event
surface
wl_surface + - surface left by the pointer

+

+ Notification that this seat's pointer is no longer focused on + a certain surface.

The leave notification is sent before the enter notification + for the new focus. +

wl_pointer::motion + - pointer motion event

+

time
uint + - timestamp with millisecond granularity
surface_x
fixed + - surface-local x coordinate
surface_y
fixed + - surface-local y coordinate

+

+ Notification of pointer location change. The arguments + surface_x and surface_y are the location relative to the + focused surface. +

wl_pointer::button + - pointer button event

+

serial
uint + - serial number of the button event
time
uint + - timestamp with millisecond granularity
button
uint + - button that produced the event
state
wl_pointer::button_state + (uint) + + - physical state of the button

+

+ Mouse button click and release notifications.

The location of the click is given by the last motion or + enter event. + The time argument is a timestamp with millisecond + granularity, with an undefined base.

The button is a button code as defined in the Linux kernel's + linux/input-event-codes.h header file, e.g. BTN_LEFT.

Any 16-bit button code value is reserved for future additions to the + kernel's event code list. All other button codes above 0xFFFF are + currently undefined but may be used in future versions of this + protocol. +

wl_pointer::axis + - axis event

+

time
uint + - timestamp with millisecond granularity
axis
wl_pointer::axis + (uint) + + - axis type
value
fixed + - length of vector in surface-local coordinate space

+

+ Scroll and other axis notifications.

For scroll events (vertical and horizontal scroll axes), the + value parameter is the length of a vector along the specified + axis in a coordinate space identical to those of motion events, + representing a relative movement along the specified axis.

For devices that support movements non-parallel to axes multiple + axis events will be emitted.

When applicable, for example for touch pads, the server can + choose to emit scroll events where the motion vector is + equivalent to a motion event vector.

When applicable, a client can transform its content relative to the + scroll distance. +

wl_pointer::frame + - end of a pointer event sequence

+

+

+ Indicates the end of a set of events that logically belong together. + A client is expected to accumulate the data in all events within the + frame before proceeding.

All wl_pointer events before a wl_pointer.frame event belong + logically together. For example, in a diagonal scroll motion the + compositor will send an optional wl_pointer.axis_source event, two + wl_pointer.axis events (horizontal and vertical) and finally a + wl_pointer.frame event. The client may use this information to + calculate a diagonal vector for scrolling.

When multiple wl_pointer.axis events occur within the same frame, + the motion vector is the combined motion of all events. + When a wl_pointer.axis and a wl_pointer.axis_stop event occur within + the same frame, this indicates that axis movement in one axis has + stopped but continues in the other axis. + When multiple wl_pointer.axis_stop events occur within the same + frame, this indicates that these axes stopped in the same instance.

A wl_pointer.frame event is sent for every logical event group, + even if the group only contains a single wl_pointer event. + Specifically, a client may get a sequence: motion, frame, button, + frame, axis, frame, axis_stop, frame.

The wl_pointer.enter and wl_pointer.leave events are logical events + generated by the compositor and not the hardware. These events are + also grouped by a wl_pointer.frame. When a pointer moves from one + surface to another, a compositor should group the + wl_pointer.leave event within the same wl_pointer.frame. + However, a client must not rely on wl_pointer.leave and + wl_pointer.enter being in the same wl_pointer.frame. + Compositor-specific policies may require the wl_pointer.leave and + wl_pointer.enter event being split across multiple wl_pointer.frame + groups. +

wl_pointer::axis_source + - axis source event

+

axis_source
wl_pointer::axis_source + (uint) + + - source of the axis event

+

+ Source information for scroll and other axes.

This event does not occur on its own. It is sent before a + wl_pointer.frame event and carries the source information for + all events within that frame.

The source specifies how this event was generated. If the source is + wl_pointer.axis_source.finger, a wl_pointer.axis_stop event will be + sent when the user lifts the finger off the device.

If the source is wl_pointer.axis_source.wheel, + wl_pointer.axis_source.wheel_tilt or + wl_pointer.axis_source.continuous, a wl_pointer.axis_stop event may + or may not be sent. Whether a compositor sends an axis_stop event + for these sources is hardware-specific and implementation-dependent; + clients must not rely on receiving an axis_stop event for these + scroll sources and should treat scroll sequences from these scroll + sources as unterminated by default.

This event is optional. If the source is unknown for a particular + axis event sequence, no event is sent. + Only one wl_pointer.axis_source event is permitted per frame.

The order of wl_pointer.axis_discrete and wl_pointer.axis_source is + not guaranteed. +

wl_pointer::axis_stop + - axis stop event

+

time
uint + - timestamp with millisecond granularity
axis
wl_pointer::axis + (uint) + + - the axis stopped with this event

+

+ Stop notification for scroll and other axes.

For some wl_pointer.axis_source types, a wl_pointer.axis_stop event + is sent to notify a client that the axis sequence has terminated. + This enables the client to implement kinetic scrolling. + See the wl_pointer.axis_source documentation for information on when + this event may be generated.

Any wl_pointer.axis events with the same axis_source after this + event should be considered as the start of a new axis motion.

The timestamp is to be interpreted identical to the timestamp in the + wl_pointer.axis event. The timestamp value may be the same as a + preceding wl_pointer.axis event. +

wl_pointer::axis_discrete + - axis click event

+

axis
wl_pointer::axis + (uint) + + - axis type
discrete
int + - number of steps

+

+ Discrete step information for scroll and other axes.

This event carries the axis value of the wl_pointer.axis event in + discrete steps (e.g. mouse wheel clicks).

This event does not occur on its own, it is coupled with a + wl_pointer.axis event that represents this axis value on a + continuous scale. The protocol guarantees that each axis_discrete + event is always followed by exactly one axis event with the same + axis number within the same wl_pointer.frame. Note that the protocol + allows for other events to occur between the axis_discrete and + its coupled axis event, including other axis_discrete or axis + events.

This event is optional; continuous scrolling devices + like two-finger scrolling on touchpads do not have discrete + steps and do not generate this event.

The discrete value carries the directional information. e.g. a value + of -2 is two steps towards the negative direction of this axis.

The axis number is identical to the axis number in the associated + axis event.

The order of wl_pointer.axis_discrete and wl_pointer.axis_source is + not guaranteed. +

Enums provided by wl_pointer

wl_pointer::error

role
0 + - given wl_surface has another role

wl_pointer::button_state + - physical button state

+ Describes the physical state of a button that produced the button + event. +

released
0 + - the button is not pressed
pressed
1 + - the button is pressed

wl_pointer::axis + - axis types

+ Describes the axis types of scroll events. +

vertical_scroll
0 + - vertical axis
horizontal_scroll
1 + - horizontal axis

wl_pointer::axis_source + - axis source types

+ Describes the source types for axis events. This indicates to the + client how an axis event was physically generated; a client may + adjust the user interface accordingly. For example, scroll events + from a "finger" source may be in a smooth coordinate space with + kinetic scrolling whereas a "wheel" source may be in discrete steps + of a number of lines.

The "continuous" axis source is a device generating events in a + continuous coordinate space, but using something other than a + finger. One example for this source is button-based scrolling where + the vertical motion of a device is converted to scroll events while + a button is held down.

The "wheel tilt" axis source indicates that the actual device is a + wheel but the scroll event is not caused by a rotation but a + (usually sideways) tilt of the wheel. +

wheel
0 + - a physical wheel rotation
finger
1 + - finger on a touch surface
continuous
2 + - continuous coordinate space
wheel_tilt
3 + - a physical wheel tilt

wl_keyboard + - keyboard input device

+ The wl_keyboard interface represents one or more keyboards + associated with a seat. +

Requests provided by wl_keyboard

wl_keyboard::release + - release the keyboard object

+

+

Events provided by wl_keyboard

wl_keyboard::keymap + - keyboard mapping

+

format
wl_keyboard::keymap_format + (uint) + + - keymap format
fd
fd + - keymap file descriptor
size
uint + - keymap size, in bytes

+

+ This event provides a file descriptor to the client which can be + memory-mapped to provide a keyboard mapping description. +

wl_keyboard::enter + - enter event

+

serial
uint + - serial number of the enter event
surface
wl_surface + - surface gaining keyboard focus
keys
array + - the currently pressed keys

+

+ Notification that this seat's keyboard focus is on a certain + surface. +

wl_keyboard::leave + - leave event

+

serial
uint + - serial number of the leave event
surface
wl_surface + - surface that lost keyboard focus

+

+ Notification that this seat's keyboard focus is no longer on + a certain surface.

The leave notification is sent before the enter notification + for the new focus. +

wl_keyboard::key + - key event

+

serial
uint + - serial number of the key event
time
uint + - timestamp with millisecond granularity
key
uint + - key that produced the event
state
wl_keyboard::key_state + (uint) + + - physical state of the key

+

+ A key was pressed or released. + The time argument is a timestamp with millisecond + granularity, with an undefined base. +

wl_keyboard::modifiers + - modifier and group state

+

serial
uint + - serial number of the modifiers event
mods_depressed
uint + - depressed modifiers
mods_latched
uint + - latched modifiers
mods_locked
uint + - locked modifiers
group
uint + - keyboard layout

+

+ Notifies clients that the modifier and/or group state has + changed, and it should update its local state. +

wl_keyboard::repeat_info + - repeat rate and delay

+

rate
int + - the rate of repeating keys in characters per second
delay
int + - delay in milliseconds since key down until repeating starts

+

+ Informs the client about the keyboard's repeat rate and delay.

This event is sent as soon as the wl_keyboard object has been created, + and is guaranteed to be received by the client before any key press + event.

Negative values for either rate or delay are illegal. A rate of zero + will disable any repeating (regardless of the value of delay).

This event can be sent later on as well with a new value if necessary, + so clients should continue listening for the event past the creation + of wl_keyboard. +

Enums provided by wl_keyboard

wl_keyboard::keymap_format + - keyboard mapping format

+ This specifies the format of the keymap provided to the + client with the wl_keyboard.keymap event. +

no_keymap
0 + - no keymap; client must understand how to interpret the raw keycode
xkb_v1
1 + - libxkbcommon compatible; to determine the xkb keycode, clients must add 8 to the key event keycode

wl_keyboard::key_state + - physical key state

+ Describes the physical state of a key that produced the key event. +

released
0 + - key is not pressed
pressed
1 + - key is pressed

wl_touch + - touchscreen input device

+ The wl_touch interface represents a touchscreen + associated with a seat.

Touch interactions can consist of one or more contacts. + For each contact, a series of events is generated, starting + with a down event, followed by zero or more motion events, + and ending with an up event. Events relating to the same + contact point can be identified by the ID of the sequence. +

Requests provided by wl_touch

wl_touch::release + - release the touch object

+

+

Events provided by wl_touch

wl_touch::down + - touch down event and beginning of a touch sequence

+

serial
uint + - serial number of the touch down event
time
uint + - timestamp with millisecond granularity
surface
wl_surface + - surface touched
id
int + - the unique ID of this touch point
x
fixed + - surface-local x coordinate
y
fixed + - surface-local y coordinate

+

+ A new touch point has appeared on the surface. This touch point is + assigned a unique ID. Future events from this touch point reference + this ID. The ID ceases to be valid after a touch up event and may be + reused in the future. +

wl_touch::up + - end of a touch event sequence

+

serial
uint + - serial number of the touch up event
time
uint + - timestamp with millisecond granularity
id
int + - the unique ID of this touch point

+

+ The touch point has disappeared. No further events will be sent for + this touch point and the touch point's ID is released and may be + reused in a future touch down event. +

wl_touch::motion + - update of touch point coordinates

+

time
uint + - timestamp with millisecond granularity
id
int + - the unique ID of this touch point
x
fixed + - surface-local x coordinate
y
fixed + - surface-local y coordinate

+

+ A touch point has changed coordinates. +

wl_touch::frame + - end of touch frame event

+

+

+ Indicates the end of a set of events that logically belong together. + A client is expected to accumulate the data in all events within the + frame before proceeding.

A wl_touch.frame terminates at least one event but otherwise no + guarantee is provided about the set of events within a frame. A client + must assume that any state not updated in a frame is unchanged from the + previously known state. +

wl_touch::cancel + - touch session cancelled

+

+

+ Sent if the compositor decides the touch stream is a global + gesture. No further events are sent to the clients from that + particular gesture. Touch cancellation applies to all touch points + currently active on this client's surface. The client is + responsible for finalizing the touch points, future touch points on + this surface may reuse the touch point ID. +

wl_touch::shape + - update shape of touch point

+

id
int + - the unique ID of this touch point
major
fixed + - length of the major axis in surface-local coordinates
minor
fixed + - length of the minor axis in surface-local coordinates

+

+ Sent when a touchpoint has changed its shape.

This event does not occur on its own. It is sent before a + wl_touch.frame event and carries the new shape information for + any previously reported, or new touch points of that frame.

Other events describing the touch point such as wl_touch.down, + wl_touch.motion or wl_touch.orientation may be sent within the + same wl_touch.frame. A client should treat these events as a single + logical touch point update. The order of wl_touch.shape, + wl_touch.orientation and wl_touch.motion is not guaranteed. + A wl_touch.down event is guaranteed to occur before the first + wl_touch.shape event for this touch ID but both events may occur within + the same wl_touch.frame.

A touchpoint shape is approximated by an ellipse through the major and + minor axis length. The major axis length describes the longer diameter + of the ellipse, while the minor axis length describes the shorter + diameter. Major and minor are orthogonal and both are specified in + surface-local coordinates. The center of the ellipse is always at the + touchpoint location as reported by wl_touch.down or wl_touch.move.

This event is only sent by the compositor if the touch device supports + shape reports. The client has to make reasonable assumptions about the + shape if it did not receive this event. +

wl_touch::orientation + - update orientation of touch point

+

id
int + - the unique ID of this touch point
orientation
fixed + - angle between major axis and positive surface y-axis in degrees

+

+ Sent when a touchpoint has changed its orientation.

This event does not occur on its own. It is sent before a + wl_touch.frame event and carries the new shape information for + any previously reported, or new touch points of that frame.

Other events describing the touch point such as wl_touch.down, + wl_touch.motion or wl_touch.shape may be sent within the + same wl_touch.frame. A client should treat these events as a single + logical touch point update. The order of wl_touch.shape, + wl_touch.orientation and wl_touch.motion is not guaranteed. + A wl_touch.down event is guaranteed to occur before the first + wl_touch.orientation event for this touch ID but both events may occur + within the same wl_touch.frame.

The orientation describes the clockwise angle of a touchpoint's major + axis to the positive surface y-axis and is normalized to the -180 to + +180 degree range. The granularity of orientation depends on the touch + device, some devices only support binary rotation values between 0 and + 90 degrees.

This event is only sent by the compositor if the touch device supports + orientation reports. +

wl_output + - compositor output region

+ An output describes part of the compositor geometry. The + compositor works in the 'compositor coordinate system' and an + output corresponds to a rectangular area in that space that is + actually visible. This typically corresponds to a monitor that + displays part of the compositor space. This object is published + as global during start up, or when a monitor is hotplugged. +

Requests provided by wl_output

wl_output::release + - release the output object

+

+

+ Using this request a client can tell the server that it is not going to + use the output object anymore. +

Events provided by wl_output

wl_output::geometry + - properties of the output

+

x
int + - x position within the global compositor space
y
int + - y position within the global compositor space
physical_width
int + - width in millimeters of the output
physical_height
int + - height in millimeters of the output
subpixel
wl_output::subpixel + (int) + + - subpixel orientation of the output
make
string + - textual description of the manufacturer
model
string + - textual description of the model
transform
wl_output::transform + (int) + + - transform that maps framebuffer to output

+

+ The geometry event describes geometric properties of the output. + The event is sent when binding to the output object and whenever + any of the properties change. +

wl_output::mode + - advertise available modes for the output

+

flags
wl_output::mode + (uint) + + - bitfield of mode flags
width
int + - width of the mode in hardware units
height
int + - height of the mode in hardware units
refresh
int + - vertical refresh rate in mHz

+

+ The mode event describes an available mode for the output.

The event is sent when binding to the output object and there + will always be one mode, the current mode. The event is sent + again if an output changes mode, for the mode that is now + current. In other words, the current mode is always the last + mode that was received with the current flag set.

The size of a mode is given in physical hardware units of + the output device. This is not necessarily the same as + the output size in the global compositor space. For instance, + the output may be scaled, as described in wl_output.scale, + or transformed, as described in wl_output.transform. +

wl_output::done + - sent all information about output

+

+

+ This event is sent after all other properties have been + sent after binding to the output object and after any + other property changes done after that. This allows + changes to the output properties to be seen as + atomic, even if they happen via multiple events. +

wl_output::scale + - output scaling properties

+

factor
int + - scaling factor of output

+

+ This event contains scaling geometry information + that is not in the geometry event. It may be sent after + binding the output object or if the output scale changes + later. If it is not sent, the client should assume a + scale of 1.

A scale larger than 1 means that the compositor will + automatically scale surface buffers by this amount + when rendering. This is used for very high resolution + displays where applications rendering at the native + resolution would be too small to be legible.

It is intended that scaling aware clients track the + current output of a surface, and if it is on a scaled + output it should use wl_surface.set_buffer_scale with + the scale of the output. That way the compositor can + avoid scaling the surface, and the client can supply + a higher detail image. +

Enums provided by wl_output

wl_output::subpixel + - subpixel geometry information

+ This enumeration describes how the physical + pixels on an output are laid out. +

unknown
0 + - unknown geometry
none
1 + - no geometry
horizontal_rgb
2 + - horizontal RGB
horizontal_bgr
3 + - horizontal BGR
vertical_rgb
4 + - vertical RGB
vertical_bgr
5 + - vertical BGR

wl_output::transform + - transform from framebuffer to output

+ This describes the transform that a compositor will apply to a + surface to compensate for the rotation or mirroring of an + output device.

The flipped values correspond to an initial flip around a + vertical axis followed by rotation.

The purpose is mainly to allow clients to render accordingly and + tell the compositor, so that for fullscreen surfaces, the + compositor will still be able to scan out directly from client + surfaces. +

normal
0 + - no transform
90
1 + - 90 degrees counter-clockwise
180
2 + - 180 degrees counter-clockwise
270
3 + - 270 degrees counter-clockwise
flipped
4 + - 180 degree flip around a vertical axis
flipped_90
5 + - flip and rotate 90 degrees counter-clockwise
flipped_180
6 + - flip and rotate 180 degrees counter-clockwise
flipped_270
7 + - flip and rotate 270 degrees counter-clockwise

wl_output::mode + - bitfield + + - mode information

+ These flags describe properties of an output mode. + They are used in the flags bitfield of the mode event. +

current
0x1 + - indicates this is the current mode
preferred
0x2 + - indicates this is the preferred mode

wl_region + - region interface

+ A region object describes an area.

Region objects are used to describe the opaque and input + regions of a surface. +

Requests provided by wl_region

wl_region::destroy + - destroy region

+

+

+ Destroy the region. This will invalidate the object ID. +

wl_region::add + - add rectangle to region

+

x
int + - region-local x coordinate
y
int + - region-local y coordinate
width
int + - rectangle width
height
int + - rectangle height

+

+ Add the specified rectangle to the region. +

wl_region::subtract + - subtract rectangle from region

+

x
int + - region-local x coordinate
y
int + - region-local y coordinate
width
int + - rectangle width
height
int + - rectangle height

+

+ Subtract the specified rectangle from the region. +

wl_subcompositor + - sub-surface compositing

+ The global interface exposing sub-surface compositing capabilities. + A wl_surface, that has sub-surfaces associated, is called the + parent surface. Sub-surfaces can be arbitrarily nested and create + a tree of sub-surfaces.

The root surface in a tree of sub-surfaces is the main + surface. The main surface cannot be a sub-surface, because + sub-surfaces must always have a parent.

A main surface with its sub-surfaces forms a (compound) window. + For window management purposes, this set of wl_surface objects is + to be considered as a single window, and it should also behave as + such.

The aim of sub-surfaces is to offload some of the compositing work + within a window from clients to the compositor. A prime example is + a video player with decorations and video in separate wl_surface + objects. This should allow the compositor to pass YUV video buffer + processing to dedicated overlay hardware when possible. +

Requests provided by wl_subcompositor

wl_subcompositor::destroy + - unbind from the subcompositor interface

+

+

+ Informs the server that the client will not be using this + protocol object anymore. This does not affect any other + objects, wl_subsurface objects included. +

wl_subcompositor::get_subsurface + - give a surface the role sub-surface

+

id
+ id for the new + wl_subsurface + - the new sub-surface object ID
surface
wl_surface + - the surface to be turned into a sub-surface
parent
wl_surface + - the parent surface

+

+ Create a sub-surface interface for the given surface, and + associate it with the given parent surface. This turns a + plain wl_surface into a sub-surface.

The to-be sub-surface must not already have another role, and it + must not have an existing wl_subsurface object. Otherwise a protocol + error is raised.

Adding sub-surfaces to a parent is a double-buffered operation on the + parent (see wl_surface.commit). The effect of adding a sub-surface + becomes visible on the next time the state of the parent surface is + applied.

This request modifies the behaviour of wl_surface.commit request on + the sub-surface, see the documentation on wl_subsurface interface. +

Enums provided by wl_subcompositor

wl_subcompositor::error

bad_surface
0 + - the to-be sub-surface is invalid

wl_subsurface + - sub-surface interface to a wl_surface

+ An additional interface to a wl_surface object, which has been + made a sub-surface. A sub-surface has one parent surface. A + sub-surface's size and position are not limited to that of the parent. + Particularly, a sub-surface is not automatically clipped to its + parent's area.

A sub-surface becomes mapped, when a non-NULL wl_buffer is applied + and the parent surface is mapped. The order of which one happens + first is irrelevant. A sub-surface is hidden if the parent becomes + hidden, or if a NULL wl_buffer is applied. These rules apply + recursively through the tree of surfaces.

The behaviour of a wl_surface.commit request on a sub-surface + depends on the sub-surface's mode. The possible modes are + synchronized and desynchronized, see methods + wl_subsurface.set_sync and wl_subsurface.set_desync. Synchronized + mode caches the wl_surface state to be applied when the parent's + state gets applied, and desynchronized mode applies the pending + wl_surface state directly. A sub-surface is initially in the + synchronized mode.

Sub-surfaces have also other kind of state, which is managed by + wl_subsurface requests, as opposed to wl_surface requests. This + state includes the sub-surface position relative to the parent + surface (wl_subsurface.set_position), and the stacking order of + the parent and its sub-surfaces (wl_subsurface.place_above and + .place_below). This state is applied when the parent surface's + wl_surface state is applied, regardless of the sub-surface's mode. + As the exception, set_sync and set_desync are effective immediately.

The main surface can be thought to be always in desynchronized mode, + since it does not have a parent in the sub-surfaces sense.

Even if a sub-surface is in desynchronized mode, it will behave as + in synchronized mode, if its parent surface behaves as in + synchronized mode. This rule is applied recursively throughout the + tree of surfaces. This means, that one can set a sub-surface into + synchronized mode, and then assume that all its child and grand-child + sub-surfaces are synchronized, too, without explicitly setting them.

If the wl_surface associated with the wl_subsurface is destroyed, the + wl_subsurface object becomes inert. Note, that destroying either object + takes effect immediately. If you need to synchronize the removal + of a sub-surface to the parent surface update, unmap the sub-surface + first by attaching a NULL wl_buffer, update parent, and then destroy + the sub-surface.

If the parent wl_surface object is destroyed, the sub-surface is + unmapped. +

Requests provided by wl_subsurface

wl_subsurface::destroy + - remove sub-surface interface

+

+

+ The sub-surface interface is removed from the wl_surface object + that was turned into a sub-surface with a + wl_subcompositor.get_subsurface request. The wl_surface's association + to the parent is deleted, and the wl_surface loses its role as + a sub-surface. The wl_surface is unmapped immediately. +

wl_subsurface::set_position + - reposition the sub-surface

+

x
int + - x coordinate in the parent surface
y
int + - y coordinate in the parent surface

+

+ This schedules a sub-surface position change. + The sub-surface will be moved so that its origin (top left + corner pixel) will be at the location x, y of the parent surface + coordinate system. The coordinates are not restricted to the parent + surface area. Negative values are allowed.

The scheduled coordinates will take effect whenever the state of the + parent surface is applied. When this happens depends on whether the + parent surface is in synchronized mode or not. See + wl_subsurface.set_sync and wl_subsurface.set_desync for details.

If more than one set_position request is invoked by the client before + the commit of the parent surface, the position of a new request always + replaces the scheduled position from any previous request.

The initial position is 0, 0. +

wl_subsurface::place_above + - restack the sub-surface

+

sibling
wl_surface + - the reference surface

+

+ This sub-surface is taken from the stack, and put back just + above the reference surface, changing the z-order of the sub-surfaces. + The reference surface must be one of the sibling surfaces, or the + parent surface. Using any other surface, including this sub-surface, + will cause a protocol error.

The z-order is double-buffered. Requests are handled in order and + applied immediately to a pending state. The final pending state is + copied to the active state the next time the state of the parent + surface is applied. When this happens depends on whether the parent + surface is in synchronized mode or not. See wl_subsurface.set_sync and + wl_subsurface.set_desync for details.

A new sub-surface is initially added as the top-most in the stack + of its siblings and parent. +

wl_subsurface::place_below + - restack the sub-surface

+

sibling
wl_surface + - the reference surface

+

+ The sub-surface is placed just below the reference surface. + See wl_subsurface.place_above. +

wl_subsurface::set_sync + - set sub-surface to synchronized mode

+

+

+ Change the commit behaviour of the sub-surface to synchronized + mode, also described as the parent dependent mode.

In synchronized mode, wl_surface.commit on a sub-surface will + accumulate the committed state in a cache, but the state will + not be applied and hence will not change the compositor output. + The cached state is applied to the sub-surface immediately after + the parent surface's state is applied. This ensures atomic + updates of the parent and all its synchronized sub-surfaces. + Applying the cached state will invalidate the cache, so further + parent surface commits do not (re-)apply old state.

See wl_subsurface for the recursive effect of this mode. +

wl_subsurface::set_desync + - set sub-surface to desynchronized mode

+

+

+ Change the commit behaviour of the sub-surface to desynchronized + mode, also described as independent or freely running mode.

In desynchronized mode, wl_surface.commit on a sub-surface will + apply the pending state directly, without caching, as happens + normally with a wl_surface. Calling wl_surface.commit on the + parent surface has no effect on the sub-surface's wl_surface + state. This mode allows a sub-surface to be updated on its own.

If cached state exists when wl_surface.commit is called in + desynchronized mode, the pending state is added to the cached + state, and applied as a whole. This invalidates the cache.

Note: even if a sub-surface is set to desynchronized, a parent + sub-surface may override it to behave as synchronized. For details, + see wl_subsurface.

If a surface's parent surface behaves as desynchronized, then + the cached state is applied on set_desync. +

Enums provided by wl_subsurface

wl_subsurface::error

bad_surface
0 + - wl_surface is not a sibling or the parent
diff --git a/docs/html/apb.html b/docs/html/apb.html new file mode 100644 index 0000000000000000000000000000000000000000..30d5ed0ca9de127b5f4f503eb00776a8c5f2d454 --- /dev/null +++ b/docs/html/apb.html @@ -0,0 +1,624 @@ +Appendix B. Client API

Appendix B. Client API

Table of Contents

Introduction
wl_argument + - +Protocol message argument data types.
wl_array + - +Dynamic array.
wl_display + - +Represents a connection to the compositor and acts as a proxy to the wl_display singleton object.
wl_event_queue + - +A queue for wl_proxy object events.
wl_interface + - +Protocol object interface.
wl_list + - +Doubly-linked list.
wl_message + - +Protocol message signature.
wl_proxy + - +Represents a protocol object on the client side.
Functions

Introduction

+ The open-source reference implementation of Wayland protocol is + split in two C libraries, libwayland-client and libwayland-server. Their main + responsibility is to handle the Inter-process communication + (IPC) with each other, therefore guaranteeing + the protocol objects marshaling and messages synchronization. +

+ A client uses libwayland-client to communicate with one or more + wayland servers. A wl_display object is + created and manages each open connection to a server. At least one + wl_event_queue + object is created for each wl_display, this holds events as they + are received from the server until they can be + processed. Multi-threading is supported by creating an additional + wl_event_queue for each additional thread, each object can have + it's events placed in a particular queue, so potentially a + different thread could be made to handle the events for each + object created. +

+ Though some convenience functions are provided, libwayland-client + is designed to allow the calling code to wait for events, so that + different polling mechanisms can be used. A file descriptor is + provided, when it becomes ready for reading the calling code can + ask libwayland-client to read the available events from it into + the wl_event_queue objects. +

+ The library only provides low-level access to the wayland objects. + Each object created by the client is represented by a wl_proxy object that this + library creates. This includes the id that is actually + communicated over the socket to the server, a void* data pointer + that is intended to point at a client's representation of the + object, and a pointer to a static wl_interface object, + which is generated from the xml and identifies the object's class + and can be used for introspection into the messages and events. +

+ Messages are sent by calling wl_proxy_marshal. This will write a + message to the socket, by using the message id and the + wl_interface to identify the types of each argument and convert + them into stream format. Most software will call type-safe + wrappers generated from the xml description of the Wayland protocols. For + instance the C header file generated from the xml defines the + following inline function to transmit the wl_surface::attach + message: +

static inline void
+wl_surface_attach(struct wl_surface *wl_surface, struct wl_buffer *buffer, int32_t x, int32_t y)
+{
+  wl_proxy_marshal((struct wl_proxy *) wl_surface, WL_SURFACE_ATTACH, buffer, x, y);
+}

+ Events (messages from the server) are handled by calling a + "dispatcher" callback the client stores in the wl_proxy for each + event. A language binding for a string-based interpreter, such as + CPython, might have a dispatcher that uses the event name from the + wl_interface to identify the function to call. The default + dispatcher uses the message id number to index an array of + functions pointers, called a wl_listener, and the wl_interface to + convert data from the stream into arguments to the function. The + C header file generated from the xml defines a per-class structure + that forces the function pointers to be of the correct type, for + instance the wl_surface::enter + event defines this pointer in the wl_surface_listener object: +

struct wl_surface_listener {
+  void (*enter)(void *data, struct wl_surface *, struct wl_output *);
+  ...
+}

+

wl_argument + - +Protocol message argument data types.

This union represents all of the argument types in the Wayland protocol wire format. The protocol implementation uses wl_argument within its marshalling machinery for dispatching messages between a client and a compositor.

+ See also: wl_message + + See also: wl_interface + + See also: Wire Format +

wl_array + - +Dynamic array.

A wl_array is a dynamic array that can only grow until released. It is intended for relatively small allocations whose size is variable or not known in advance. While construction of a wl_array does not require all elements to be of the same size, wl_array_for_each() does require all elements to have the same type and size.

size + - +Array size.
size_t wl_array::size
alloc + - +Allocated space.
size_t wl_array::alloc
data + - +Array data.
void* wl_array::data
wl_array_init + - +Initializes the array.
void wl_array_init(struct wl_array *array)
array
+Array to initialize

+

wl_array_release + - +Releases the array data.
void wl_array_release(struct wl_array *array)

Note: Leaves the array in an invalid state. +

array
+Array whose data is to be released

+

wl_array_add + - +Increases the size of the array by size bytes.
void * wl_array_add(struct wl_array *array, size_t size)
array
+Array whose size is to be increased
size
+Number of bytes to increase the size of the array by

+

Returns:
A pointer to the beginning of the newly appended space, or NULL when resizing fails.

+

wl_array_copy + - +Copies the contents of source to array.
int wl_array_copy(struct wl_array *array, struct wl_array *source)
array
+Destination array to copy to
source
+Source array to copy from

+

Returns:
0 on success, or -1 on failure

+

wl_array_for_each + - +Iterates over an array.

This macro expresses a for-each iterator for wl_array. It assigns each element in the array to pos, which can then be referenced in a trailing code block. pos must be a pointer to the array element type, and all array elements must be of the same type and size.

pos
+Cursor that each array element will be assigned to
array
+Array to iterate over

+ + See also: wl_list_for_each() +

wl_display + - +Represents a connection to the compositor and acts as a proxy to the wl_display singleton object.

A wl_display object represents a client connection to a Wayland compositor. It is created with either wl_display_connect() or wl_display_connect_to_fd(). A connection is terminated using wl_display_disconnect().

A wl_display is also used as the wl_proxy for the wl_display singleton object on the compositor side.

A wl_display object handles all the data sent from and to the compositor. When a wl_proxy marshals a request, it will write its wire representation to the display's write buffer. The data is sent to the compositor when the client calls wl_display_flush().

Incoming data is handled in two steps: queueing and dispatching. In the queue step, the data coming from the display fd is interpreted and added to a queue. On the dispatch step, the handler for the incoming event set by the client on the corresponding wl_proxy is called.

A wl_display has at least one event queue, called the default queue. Clients can create additional event queues with wl_display_create_queue() and assign wl_proxy's to it. Events occurring in a particular proxy are always queued in its assigned queue. A client can ensure that a certain assumption, such as holding a lock or running from a given thread, is true when a proxy event handler is called by assigning that proxy to an event queue and making sure that this queue is only dispatched when the assumption holds.

The default queue is dispatched by calling wl_display_dispatch(). This will dispatch any events queued on the default queue and attempt to read from the display fd if it's empty. Events read are then queued on the appropriate queues according to the proxy assignment.

A user created queue is dispatched with wl_display_dispatch_queue(). This function behaves exactly the same as wl_display_dispatch() but it dispatches given queue instead of the default queue.

A real world example of event queue usage is Mesa's implementation of eglSwapBuffers() for the Wayland platform. This function might need to block until a frame callback is received, but dispatching the default queue could cause an event handler on the client to start drawing again. This problem is solved using another event queue, so that only the events handled by the EGL code are dispatched during the block.

This creates a problem where a thread dispatches a non-default queue, reading all the data from the display fd. If the application would call poll(2) after that it would block, even though there might be events queued on the default queue. Those events should be dispatched with wl_display_dispatch_pending() or wl_display_dispatch_queue_pending() before flushing and blocking.

wl_display_create_queue + - +Create a new event queue for this display.
struct wl_event_queue * wl_display_create_queue(struct wl_display *display)
display
+The display context object

+

Returns:
A new event queue associated with this display or NULL on failure.

+

wl_display_connect_to_fd + - +Connect to Wayland display on an already open fd.
struct wl_display * wl_display_connect_to_fd(int fd)
fd
+The fd to use for the connection

+

Returns:
A wl_display object or NULL on failure

+The wl_display takes ownership of the fd and will close it when the display is destroyed. The fd will also be closed in case of failure.

wl_display_connect + - +Connect to a Wayland display.
struct wl_display * wl_display_connect(const char *name)
name
+Name of the Wayland display to connect to

+

Returns:
A wl_display object or NULL on failure

+Connect to the Wayland display named name. If name is NULL, its value will be replaced with the WAYLAND_DISPLAY environment variable if it is set, otherwise display "wayland-0" will be used.

If name is an absolute path, then that path is used as-is for the location of the socket at which the Wayland server is listening; no qualification inside XDG_RUNTIME_DIR is attempted.

If name is NULL and the WAYLAND_DISPLAY environment variable is set to an absolute pathname, then that pathname is used as-is for the socket in the same manner as if name held an absolute path. Support for absolute paths in name and WAYLAND_DISPLAY is present since Wayland version 1.15.

wl_display_disconnect + - +Close a connection to a Wayland display.
void wl_display_disconnect(struct wl_display *display)
display
+The display context object

+Close the connection to display and free all resources associated with it.

wl_display_get_fd + - +Get a display context's file descriptor.
int wl_display_get_fd(struct wl_display *display)
display
+The display context object

+

Returns:
Display object file descriptor

+Return the file descriptor associated with a display so it can be integrated into the client's main loop.

wl_display_roundtrip_queue + - +Block until all pending request are processed by the server.
int wl_display_roundtrip_queue(struct wl_display *display, struct wl_event_queue *queue)
display
+The display context object
queue
+The queue on which to run the roundtrip

+

Returns:
The number of dispatched events on success or -1 on failure

+This function blocks until the server has processed all currently issued requests by sending a request to the display server and waiting for a reply before returning.

This function uses wl_display_dispatch_queue() internally. It is not allowed to call this function while the thread is being prepared for reading events, and doing so will cause a dead lock.

Note: This function may dispatch other events being received on the given queue. + + See also: wl_display_roundtrip() +

wl_display_roundtrip + - +Block until all pending request are processed by the server.
int wl_display_roundtrip(struct wl_display *display)
display
+The display context object

+

Returns:
The number of dispatched events on success or -1 on failure

+This function blocks until the server has processed all currently issued requests by sending a request to the display server and waiting for a reply before returning.

This function uses wl_display_dispatch_queue() internally. It is not allowed to call this function while the thread is being prepared for reading events, and doing so will cause a dead lock.

Note: This function may dispatch other events being received on the default queue. +

wl_display_read_events + - +Read events from display file descriptor.
int wl_display_read_events(struct wl_display *display)
display
+The display context object

+

Returns:
0 on success or -1 on error. In case of error errno will be set accordingly

+Calling this function will result in data available on the display file descriptor being read and read events will be queued on their corresponding event queues.

Before calling this function, depending on what thread it is to be called from, wl_display_prepare_read_queue() or wl_display_prepare_read() needs to be called. See wl_display_prepare_read_queue() for more details.

When being called at a point where other threads have been prepared to read (using wl_display_prepare_read_queue() or wl_display_prepare_read()) this function will sleep until all other prepared threads have either been cancelled (using wl_display_cancel_read()) or them self entered this function. The last thread that calls this function will then read and queue events on their corresponding event queues, and finally wake up all other wl_display_read_events() calls causing them to return.

If a thread cancels a read preparation when all other threads that have prepared to read has either called wl_display_cancel_read() or wl_display_read_events(), all reader threads will return without having read any data.

To dispatch events that may have been queued, call wl_display_dispatch_pending() or wl_display_dispatch_queue_pending().

+ See also: wl_display_prepare_read(), wl_display_cancel_read(), wl_display_dispatch_pending(), wl_display_dispatch() +

wl_display_prepare_read_queue + - +Prepare to read events from the display's file descriptor to a queue.
int wl_display_prepare_read_queue(struct wl_display *display, struct wl_event_queue *queue)
display
+The display context object
queue
+The event queue to use

+

Returns:
0 on success or -1 if event queue was not empty

+This function (or wl_display_prepare_read()) must be called before reading from the file descriptor using wl_display_read_events(). Calling wl_display_prepare_read_queue() announces the calling thread's intention to read and ensures that until the thread is ready to read and calls wl_display_read_events(), no other thread will read from the file descriptor. This only succeeds if the event queue is empty, and if not -1 is returned and errno set to EAGAIN.

If a thread successfully calls wl_display_prepare_read_queue(), it must either call wl_display_read_events() when it's ready or cancel the read intention by calling wl_display_cancel_read().

Use this function before polling on the display fd or integrate the fd into a toolkit event loop in a race-free way. A correct usage would be (with most error checking left out):

+

while (wl_display_prepare_read_queue(display, queue) != 0)
+        wl_display_dispatch_queue_pending(display, queue);
+wl_display_flush(display);
+
+ret = poll(fds, nfds, -1);
+if (has_error(ret))
+        wl_display_cancel_read(display);
+else
+        wl_display_read_events(display);
+
+wl_display_dispatch_queue_pending(display, queue);
+

+

Here we call wl_display_prepare_read_queue(), which ensures that between returning from that call and eventually calling wl_display_read_events(), no other thread will read from the fd and queue events in our queue. If the call to wl_display_prepare_read_queue() fails, we dispatch the pending events and try again until we're successful.

The wl_display_prepare_read_queue() function doesn't acquire exclusive access to the display's fd. It only registers that the thread calling this function has intention to read from fd. When all registered readers call wl_display_read_events(), only one (at random) eventually reads and queues the events and the others are sleeping meanwhile. This way we avoid races and still can read from more threads.

+ See also: wl_display_cancel_read(), wl_display_read_events(), wl_display_prepare_read() +

wl_display_prepare_read + - +Prepare to read events from the display's file descriptor.
int wl_display_prepare_read(struct wl_display *display)
display
+The display context object

+

Returns:
0 on success or -1 if event queue was not empty

+This function does the same thing as wl_display_prepare_read_queue() with the default queue passed as the queue.

+ See also: wl_display_prepare_read_queue +

wl_display_cancel_read + - +Cancel read intention on display's fd.
void wl_display_cancel_read(struct wl_display *display)
display
+The display context object

+After a thread successfully called wl_display_prepare_read() it must either call wl_display_read_events() or wl_display_cancel_read(). If the threads do not follow this rule it will lead to deadlock.

+ See also: wl_display_prepare_read(), wl_display_read_events() +

wl_display_dispatch_queue + - +Dispatch events in an event queue.
int wl_display_dispatch_queue(struct wl_display *display, struct wl_event_queue *queue)
display
+The display context object
queue
+The event queue to dispatch

+

Returns:
The number of dispatched events on success or -1 on failure

+Dispatch events on the given event queue.

If the given event queue is empty, this function blocks until there are events to be read from the display fd. Events are read and queued on the appropriate event queues. Finally, events on given event queue are dispatched. On failure -1 is returned and errno set appropriately.

In a multi threaded environment, do not manually wait using poll() (or equivalent) before calling this function, as doing so might cause a dead lock. If external reliance on poll() (or equivalent) is required, see wl_display_prepare_read_queue() of how to do so.

This function is thread safe as long as it dispatches the right queue on the right thread. It is also compatible with the multi thread event reading preparation API (see wl_display_prepare_read_queue()), and uses the equivalent functionality internally. It is not allowed to call this function while the thread is being prepared for reading events, and doing so will cause a dead lock.

It can be used as a helper function to ease the procedure of reading and dispatching events.

Note: Since Wayland 1.5 the display has an extra queue for its own events (i. e. delete_id). This queue is dispatched always, no matter what queue we passed as an argument to this function. That means that this function can return non-0 value even when it haven't dispatched any event for the given queue. + + See also: wl_display_dispatch(), wl_display_dispatch_pending(), wl_display_dispatch_queue_pending(), wl_display_prepare_read_queue() +

wl_display_dispatch_queue_pending + - +Dispatch pending events in an event queue.
int wl_display_dispatch_queue_pending(struct wl_display *display, struct wl_event_queue *queue)
display
+The display context object
queue
+The event queue to dispatch

+

Returns:
The number of dispatched events on success or -1 on failure

+Dispatch all incoming events for objects assigned to the given event queue. On failure -1 is returned and errno set appropriately. If there are no events queued, this function returns immediately.

+ Since: 1.0.2 +

wl_display_dispatch + - +Process incoming events.
int wl_display_dispatch(struct wl_display *display)
display
+The display context object

+

Returns:
The number of dispatched events on success or -1 on failure

+Dispatch events on the default event queue.

If the default event queue is empty, this function blocks until there are events to be read from the display fd. Events are read and queued on the appropriate event queues. Finally, events on the default event queue are dispatched. On failure -1 is returned and errno set appropriately.

In a multi threaded environment, do not manually wait using poll() (or equivalent) before calling this function, as doing so might cause a dead lock. If external reliance on poll() (or equivalent) is required, see wl_display_prepare_read_queue() of how to do so.

This function is thread safe as long as it dispatches the right queue on the right thread. It is also compatible with the multi thread event reading preparation API (see wl_display_prepare_read_queue()), and uses the equivalent functionality internally. It is not allowed to call this function while the thread is being prepared for reading events, and doing so will cause a dead lock.

Note: It is not possible to check if there are events on the queue or not. For dispatching default queue events without blocking, see wl_display_dispatch_pending(). + + See also: wl_display_dispatch_pending(), wl_display_dispatch_queue(), wl_display_read_events() +

wl_display_dispatch_pending + - +Dispatch default queue events without reading from the display fd.
int wl_display_dispatch_pending(struct wl_display *display)
display
+The display context object

+

Returns:
The number of dispatched events or -1 on failure

+This function dispatches events on the main event queue. It does not attempt to read the display fd and simply returns zero if the main queue is empty, i.e., it doesn't block.

+ See also: wl_display_dispatch(), wl_display_dispatch_queue(), wl_display_flush() +

wl_display_get_error + - +Retrieve the last error that occurred on a display.
int wl_display_get_error(struct wl_display *display)
display
+The display context object

+

Returns:
The last error that occurred on display or 0 if no error occurred

+Return the last error that occurred on the display. This may be an error sent by the server or caused by the local client.

Note: Errors are fatal. If this function returns non-zero the display can no longer be used. +

wl_display_get_protocol_error + - +Retrieves the information about a protocol error:
uint32_t wl_display_get_protocol_error(struct wl_display *display, const struct wl_interface **interface, uint32_t *id)
display
+The Wayland display
interface
+if not NULL, stores the interface where the error occurred, or NULL, if unknown.
id
+if not NULL, stores the object id that generated the error, or 0, if the object id is unknown. There's no guarantee the object is still valid; the client must know if it deleted the object.

+

Returns:
The error code as defined in the interface specification.

+

int err = wl_display_get_error(display);
+
+if (err == EPROTO) {
+       code = wl_display_get_protocol_error(display, &interface, &id);
+       handle_error(code, interface, id);
+}
+
+...
+

wl_display_flush + - +Send all buffered requests on the display to the server.
int wl_display_flush(struct wl_display *display)
display
+The display context object

+

Returns:
The number of bytes sent on success or -1 on failure

+Send all buffered data on the client side to the server. Clients should always call this function before blocking on input from the display fd. On success, the number of bytes sent to the server is returned. On failure, this function returns -1 and errno is set appropriately.

wl_display_flush() never blocks. It will write as much data as possible, but if all data could not be written, errno will be set to EAGAIN and -1 returned. In that case, use poll on the display file descriptor to wait for it to become writable again.

wl_event_queue + - +A queue for wl_proxy object events.

Event queues allows the events on a display to be handled in a thread-safe manner. See wl_display for details.

wl_event_queue_destroy + - +Destroy an event queue.
void wl_event_queue_destroy(struct wl_event_queue *queue)
queue
+The event queue to be destroyed

+Destroy the given event queue. Any pending event on that queue is discarded.

The wl_display object used to create the queue should not be destroyed until all event queues created with it are destroyed with this function.

wl_interface + - +Protocol object interface.

A wl_interface describes the API of a protocol object defined in the Wayland protocol specification. The protocol implementation uses a wl_interface within its marshalling machinery for encoding client requests.

The name of a wl_interface is the name of the corresponding protocol interface, and version represents the version of the interface. The members method_count and event_count represent the number of methods (requests) and events in the respective wl_message members.

For example, consider a protocol interface foo, marked as version 1, with two requests and one event.

+

<interface name="foo" version="1">
+  <request name="a"></request>
+  <request name="b"></request>
+  <event name="c"></event>
+</interface>
+

+

Given two wl_message arrays foo_requests and foo_events, a wl_interface for foo might be:

+

struct wl_interface foo_interface = {
+        "foo", 1,
+        2, foo_requests,
+        1, foo_events
+};
+

+

Note: The server side of the protocol may define interface implementation types that incorporate the term interface in their name. Take care to not confuse these server-side structs with a wl_interface variable whose name also ends in interface. For example, while the server may define a type struct wl_foo_interface, the client may define a struct wl_interface wl_foo_interface. + + See also: wl_message + + See also: wl_proxy + + See also: Interfaces + + See also: Versioning +

wl_list + - +Doubly-linked list.

On its own, an instance of struct wl_list represents the sentinel head of a doubly-linked list, and must be initialized using wl_list_init(). When empty, the list head's next and prev members point to the list head itself, otherwise next references the first element in the list, and prev refers to the last element in the list.

Use the struct wl_list type to represent both the list head and the links between elements within the list. Use wl_list_empty() to determine if the list is empty in O(1).

All elements in the list must be of the same type. The element type must have a struct wl_list member, often named link by convention. Prior to insertion, there is no need to initialize an element's link - invoking wl_list_init() on an individual list element's struct wl_list member is unnecessary if the very next operation is wl_list_insert(). However, a common idiom is to initialize an element's link prior to removal - ensure safety by invoking wl_list_init() before wl_list_remove().

Consider a list reference struct wl_list foo_list, an element type as struct element, and an element's link member as struct wl_list link.

The following code initializes a list and adds three elements to it.

+

struct wl_list foo_list;
+
+struct element {
+        int foo;
+        struct wl_list link;
+};
+struct element e1, e2, e3;
+
+wl_list_init(&foo_list);
+wl_list_insert(&foo_list, &e1.link);   // e1 is the first element
+wl_list_insert(&foo_list, &e2.link);   // e2 is now the first element
+wl_list_insert(&e2.link, &e3.link); // insert e3 after e2
+

+

The list now looks like [e2, e3, e1].

The wl_list API provides some iterator macros. For example, to iterate a list in ascending order:

+

struct element *e;
+wl_list_for_each(e, foo_list, link) {
+        do_something_with_element(e);
+}
+

+

See the documentation of each iterator for details. + See also: http://git.kernel.org/cgit/linux/kernel/git/torvalds/linux.git/tree/include/linux/list.h +

prev + - +Previous list element.
struct wl_list* wl_list::prev
next + - +Next list element.
struct wl_list* wl_list::next
wl_list_init + - +Initializes the list.
void wl_list_init(struct wl_list *list)
list
+List to initialize

+

wl_list_insert + - +Inserts an element into the list, after the element represented by list.
void wl_list_insert(struct wl_list *list, struct wl_list *elm)

When list is a reference to the list itself (the head), set the containing struct of elm as the first element in the list.

Note: If elm is already part of a list, inserting it again will lead to list corruption. +

list
+List element after which the new element is inserted
elm
+Link of the containing struct to insert into the list

+

wl_list_remove + - +Removes an element from the list.
void wl_list_remove(struct wl_list *elm)

Note: This operation leaves elm in an invalid state. +

elm
+Link of the containing struct to remove from the list

+

wl_list_length + - +Determines the length of the list.
int wl_list_length(const struct wl_list *list)

Note: This is an O(n) operation. +

list
+List whose length is to be determined

+

Returns:
Number of elements in the list

+

wl_list_empty + - +Determines if the list is empty.
int wl_list_empty(const struct wl_list *list)
list
+List whose emptiness is to be determined

+

Returns:
1 if empty, or 0 if not empty

+

wl_list_insert_list + - +Inserts all of the elements of one list into another, after the element represented by list.
void wl_list_insert_list(struct wl_list *list, struct wl_list *other)

Note: This leaves other in an invalid state. +

list
+List element after which the other list elements will be inserted
other
+List of elements to insert

+

wl_list_for_each + - +Iterates over a list.

This macro expresses a for-each iterator for wl_list. Given a list and wl_list link member name (often named link by convention), this macro assigns each element in the list to pos, which can then be referenced in a trailing code block. For example, given a wl_list of struct message elements:

+

struct message {
+        char *contents;
+        wl_list link;
+};
+
+struct wl_list *message_list;
+// Assume message_list now "contains" many messages
+
+struct message *m;
+wl_list_for_each(m, message_list, link) {
+        do_something_with_message(m);
+}
+

+

pos
+Cursor that each list element will be assigned to
head
+Head of the list to iterate over
member
+Name of the link member within the element struct

+

wl_list_for_each_safe + - +Iterates over a list, safe against removal of the list element.

Note: Only removal of the current element, pos, is safe. Removing any other element during traversal may lead to a loop malfunction. + + See also: wl_list_for_each() +

pos
+Cursor that each list element will be assigned to
tmp
+Temporary pointer of the same type as pos
head
+Head of the list to iterate over
member
+Name of the link member within the element struct

+

wl_list_for_each_reverse + - +Iterates backwards over a list.

+ See also: wl_list_for_each() +

pos
+Cursor that each list element will be assigned to
head
+Head of the list to iterate over
member
+Name of the link member within the element struct

+

wl_list_for_each_reverse_safe + - +Iterates backwards over a list, safe against removal of the list element.

Note: Only removal of the current element, pos, is safe. Removing any other element during traversal may lead to a loop malfunction. + + See also: wl_list_for_each() +

pos
+Cursor that each list element will be assigned to
tmp
+Temporary pointer of the same type as pos
head
+Head of the list to iterate over
member
+Name of the link member within the element struct

+

wl_message + - +Protocol message signature.

A wl_message describes the signature of an actual protocol message, such as a request or event, that adheres to the Wayland protocol wire format. The protocol implementation uses a wl_message within its demarshal machinery for decoding messages between a compositor and its clients. In a sense, a wl_message is to a protocol message like a class is to an object.

The name of a wl_message is the name of the corresponding protocol message.

The signature is an ordered list of symbols representing the data types of message arguments and, optionally, a protocol version and indicators for nullability. A leading integer in the signature indicates the since version of the protocol message. A ? preceding a data type symbol indicates that the following argument type is nullable. While it is a protocol violation to send messages with non-nullable arguments set to NULL, event handlers in clients might still get called with non-nullable object arguments set to NULL. This can happen when the client destroyed the object being used as argument on its side and an event referencing that object was sent before the server knew about its destruction. As this race cannot be prevented, clients should - as a general rule - program their event handlers such that they can handle object arguments declared non-nullable being NULL gracefully.

When no arguments accompany a message, signature is an empty string.

Symbols:

  • i: int
  • u: uint
  • f: fixed
  • s: string
  • o: object
  • n: new_id
  • a: array
  • h: fd
  • ?: following argument is nullable

+

While demarshaling primitive arguments is straightforward, when demarshaling messages containing object or new_id arguments, the protocol implementation often must determine the type of the object. The types of a wl_message is an array of wl_interface references that correspond to o and n arguments in signature, with NULL placeholders for arguments with non-object types.

Consider the protocol event wl_display delete_id that has a single uint argument. The wl_message is:

+

{ "delete_id", "u", [NULL] }
+

+

Here, the message name is "delete_id", the signature is "u", and the argument types is [NULL], indicating that the uint argument has no corresponding wl_interface since it is a primitive argument.

In contrast, consider a wl_foo interface supporting protocol request bar that has existed since version 2, and has two arguments: a uint and an object of type wl_baz_interface that may be NULL. Such a wl_message might be:

+

{ "bar", "2u?o", [NULL, &wl_baz_interface] }
+

+

Here, the message name is "bar", and the signature is "2u?o". Notice how the 2 indicates the protocol version, the u indicates the first argument type is uint, and the ?o indicates that the second argument is an object that may be NULL. Lastly, the argument types array indicates that no wl_interface corresponds to the first argument, while the type wl_baz_interface corresponds to the second argument.

+ See also: wl_argument + + See also: wl_interface + + See also: Wire Format +

wl_proxy + - +Represents a protocol object on the client side.

A wl_proxy acts as a client side proxy to an object existing in the compositor. The proxy is responsible for converting requests made by the clients with wl_proxy_marshal() into Wayland's wire format. Events coming from the compositor are also handled by the proxy, which will in turn call the handler set with wl_proxy_add_listener().

Note: With the exception of function wl_proxy_set_queue(), functions accessing a wl_proxy are not normally used by client code. Clients should normally use the higher level interface generated by the scanner to interact with compositor objects. +

wl_proxy_create + - +Create a proxy object with a given interface.
struct wl_proxy * wl_proxy_create(struct wl_proxy *factory, const struct wl_interface *interface)
factory
+Factory proxy object
interface
+Interface the proxy object should use

+

Returns:
A newly allocated proxy object or NULL on failure

+This function creates a new proxy object with the supplied interface. The proxy object will have an id assigned from the client id space. The id should be created on the compositor side by sending an appropriate request with wl_proxy_marshal().

The proxy will inherit the display and event queue of the factory object.

Note: This should not normally be used by non-generated code. + + See also: wl_display, wl_event_queue, wl_proxy_marshal() +

wl_proxy_destroy + - +Destroy a proxy object.
void wl_proxy_destroy(struct wl_proxy *proxy)
proxy
+The proxy to be destroyed

+proxy must not be a proxy wrapper.

wl_proxy_add_listener + - +Set a proxy's listener.
int wl_proxy_add_listener(struct wl_proxy *proxy, void(**implementation)(void), void *data)
proxy
+The proxy object
implementation
+The listener to be added to proxy
data
+User data to be associated with the proxy

+

Returns:
0 on success or -1 on failure

+Set proxy's listener to implementation and its user data to data. If a listener has already been set, this function fails and nothing is changed.

implementation is a vector of function pointers. For an opcode n, implementation[n] should point to the handler of n for the given object.

proxy must not be a proxy wrapper.

wl_proxy_get_listener + - +Get a proxy's listener.
const void * wl_proxy_get_listener(struct wl_proxy *proxy)
proxy
+The proxy object

+

Returns:
The address of the proxy's listener or NULL if no listener is set

+Gets the address to the proxy's listener; which is the listener set with wl_proxy_add_listener.

This function is useful in clients with multiple listeners on the same interface to allow the identification of which code to execute.

wl_proxy_add_dispatcher + - +Set a proxy's listener (with dispatcher)
int wl_proxy_add_dispatcher(struct wl_proxy *proxy, wl_dispatcher_func_t dispatcher, const void *implementation, void *data)
proxy
+The proxy object
dispatcher
+The dispatcher to be used for this proxy
implementation
+The dispatcher-specific listener implementation
data
+User data to be associated with the proxy

+

Returns:
0 on success or -1 on failure

+Set proxy's listener to use dispatcher_func as its dispatcher and dispatcher_data as its dispatcher-specific implementation and its user data to data. If a listener has already been set, this function fails and nothing is changed.

The exact details of dispatcher_data depend on the dispatcher used. This function is intended to be used by language bindings, not user code.

proxy must not be a proxy wrapper.

wl_proxy_marshal_array_constructor + - +Prepare a request to be sent to the compositor.
struct wl_proxy * wl_proxy_marshal_array_constructor(struct wl_proxy *proxy, uint32_t opcode, union wl_argument *args, const struct wl_interface *interface)
proxy
+The proxy object
opcode
+Opcode of the request to be sent
args
+Extra arguments for the given request
interface
+The interface to use for the new proxy

+This function translates a request given an opcode, an interface and a wl_argument array to the wire format and writes it to the connection buffer.

For new-id arguments, this function will allocate a new wl_proxy and send the ID to the server. The new wl_proxy will be returned on success or NULL on error with errno set accordingly. The newly created proxy will inherit their version from their parent.

Note: This is intended to be used by language bindings and not in non-generated code. + + See also: wl_proxy_marshal() +

wl_proxy_marshal_array_constructor_versioned + - +Prepare a request to be sent to the compositor.
struct wl_proxy * wl_proxy_marshal_array_constructor_versioned(struct wl_proxy *proxy, uint32_t opcode, union wl_argument *args, const struct wl_interface *interface, uint32_t version)
proxy
+The proxy object
opcode
+Opcode of the request to be sent
args
+Extra arguments for the given request
interface
+The interface to use for the new proxy
version
+The protocol object version for the new proxy

+Translates the request given by opcode and the extra arguments into the wire format and write it to the connection buffer. This version takes an array of the union type wl_argument.

For new-id arguments, this function will allocate a new wl_proxy and send the ID to the server. The new wl_proxy will be returned on success or NULL on error with errno set accordingly. The newly created proxy will have the version specified.

Note: This is intended to be used by language bindings and not in non-generated code. + + See also: wl_proxy_marshal() +

wl_proxy_marshal + - +Prepare a request to be sent to the compositor.
void wl_proxy_marshal(struct wl_proxy *proxy, uint32_t opcode,...)
proxy
+The proxy object
opcode
+Opcode of the request to be sent
...
+Extra arguments for the given request

+This function is similar to wl_proxy_marshal_constructor(), except it doesn't create proxies for new-id arguments.

Note: This should not normally be used by non-generated code. + + See also: wl_proxy_create() +

wl_proxy_marshal_constructor + - +Prepare a request to be sent to the compositor.
struct wl_proxy * wl_proxy_marshal_constructor(struct wl_proxy *proxy, uint32_t opcode, const struct wl_interface *interface,...)
proxy
+The proxy object
opcode
+Opcode of the request to be sent
interface
+The interface to use for the new proxy
...
+Extra arguments for the given request

+

Returns:
A new wl_proxy for the new_id argument or NULL on error

+This function translates a request given an opcode, an interface and extra arguments to the wire format and writes it to the connection buffer. The types of the extra arguments must correspond to the argument types of the method associated with the opcode in the interface.

For new-id arguments, this function will allocate a new wl_proxy and send the ID to the server. The new wl_proxy will be returned on success or NULL on error with errno set accordingly. The newly created proxy will inherit their version from their parent.

Note: This should not normally be used by non-generated code. +

wl_proxy_marshal_constructor_versioned + - +Prepare a request to be sent to the compositor.
struct wl_proxy * wl_proxy_marshal_constructor_versioned(struct wl_proxy *proxy, uint32_t opcode, const struct wl_interface *interface, uint32_t version,...)
proxy
+The proxy object
opcode
+Opcode of the request to be sent
interface
+The interface to use for the new proxy
version
+The protocol object version of the new proxy
...
+Extra arguments for the given request

+

Returns:
A new wl_proxy for the new_id argument or NULL on error

+Translates the request given by opcode and the extra arguments into the wire format and write it to the connection buffer.

For new-id arguments, this function will allocate a new wl_proxy and send the ID to the server. The new wl_proxy will be returned on success or NULL on error with errno set accordingly. The newly created proxy will have the version specified.

Note: This should not normally be used by non-generated code. +

wl_proxy_marshal_array + - +Prepare a request to be sent to the compositor.
void wl_proxy_marshal_array(struct wl_proxy *proxy, uint32_t opcode, union wl_argument *args)
proxy
+The proxy object
opcode
+Opcode of the request to be sent
args
+Extra arguments for the given request

+This function is similar to wl_proxy_marshal_array_constructor(), except it doesn't create proxies for new-id arguments.

Note: This is intended to be used by language bindings and not in non-generated code. + + See also: wl_proxy_marshal() +

wl_proxy_set_user_data + - +Set the user data associated with a proxy.
void wl_proxy_set_user_data(struct wl_proxy *proxy, void *user_data)
proxy
+The proxy object
user_data
+The data to be associated with proxy

+Set the user data associated with proxy. When events for this proxy are received, user_data will be supplied to its listener.

wl_proxy_get_user_data + - +Get the user data associated with a proxy.
void * wl_proxy_get_user_data(struct wl_proxy *proxy)
proxy
+The proxy object

+

Returns:
The user data associated with proxy

+

wl_proxy_get_version + - +Get the protocol object version of a proxy object.
uint32_t wl_proxy_get_version(struct wl_proxy *proxy)
proxy
+The proxy object

+

Returns:
The protocol object version of the proxy or 0

+Gets the protocol object version of a proxy object, or 0 if the proxy was created with unversioned API.

A returned value of 0 means that no version information is available, so the caller must make safe assumptions about the object's real version.

wl_display's version will always return 0.

wl_proxy_get_id + - +Get the id of a proxy object.
uint32_t wl_proxy_get_id(struct wl_proxy *proxy)
proxy
+The proxy object

+

Returns:
The id the object associated with the proxy

+

wl_proxy_get_class + - +Get the interface name (class) of a proxy object.
const char * wl_proxy_get_class(struct wl_proxy *proxy)
proxy
+The proxy object

+

Returns:
The interface name of the object associated with the proxy

+

wl_proxy_set_queue + - +Assign a proxy to an event queue.
void wl_proxy_set_queue(struct wl_proxy *proxy, struct wl_event_queue *queue)
proxy
+The proxy object
queue
+The event queue that will handle this proxy or NULL

+Assign proxy to event queue. Events coming from proxy will be queued in queue from now. If queue is NULL, then the display's default queue is set to the proxy.

Note: By default, the queue set in proxy is the one inherited from parent. + + See also: wl_display_dispatch_queue() +

wl_proxy_create_wrapper + - +Create a proxy wrapper for making queue assignments thread-safe.
void * wl_proxy_create_wrapper(void *proxy)
proxy
+The proxy object to be wrapped

+

Returns:
A proxy wrapper for the given proxy or NULL on failure

+A proxy wrapper is type of 'struct wl_proxy' instance that can be used when sending requests instead of using the original proxy. A proxy wrapper does not have an implementation or dispatcher, and events received on the object is still emitted on the original proxy. Trying to set an implementation or dispatcher will have no effect but result in a warning being logged.

Setting the proxy queue of the proxy wrapper will make new objects created using the proxy wrapper use the set proxy queue. Even though there is no implementation nor dispatcher, the proxy queue can be changed. This will affect the default queue of new objects created by requests sent via the proxy wrapper.

A proxy wrapper can only be destroyed using wl_proxy_wrapper_destroy().

A proxy wrapper must be destroyed before the proxy it was created from.

If a user reads and dispatches events on more than one thread, it is necessary to use a proxy wrapper when sending requests on objects when the intention is that a newly created proxy is to use a proxy queue different from the proxy the request was sent on, as creating the new proxy and then setting the queue is not thread safe.

For example, a module that runs using its own proxy queue that needs to do display roundtrip must wrap the wl_display proxy object before sending the wl_display.sync request. For example:

struct wl_event_queue *queue = ...;
+struct wl_display *wrapped_display;
+struct wl_callback *callback;
+
+wrapped_display = wl_proxy_create_wrapper(display);
+wl_proxy_set_queue((struct wl_proxy *) wrapped_display, queue);
+callback = wl_display_sync(wrapped_display);
+wl_proxy_wrapper_destroy(wrapped_display);
+wl_callback_add_listener(callback, ...);
+

wl_proxy_wrapper_destroy + - +Destroy a proxy wrapper.
void wl_proxy_wrapper_destroy(void *proxy_wrapper)
proxy_wrapper
+The proxy wrapper to be destroyed

+

Functions

wl_event_queue_destroy
void wl_event_queue_destroy(struct wl_event_queue *queue)
wl_proxy_marshal
void wl_proxy_marshal(struct wl_proxy *p, uint32_t opcode,...)
wl_proxy_marshal_array
void wl_proxy_marshal_array(struct wl_proxy *p, uint32_t opcode, union wl_argument *args)
wl_proxy_create
struct wl_proxy* wl_proxy_create(struct wl_proxy *factory, const struct wl_interface *interface)
wl_proxy_create_wrapper
void* wl_proxy_create_wrapper(void *proxy)
wl_proxy_wrapper_destroy
void wl_proxy_wrapper_destroy(void *proxy_wrapper)
wl_proxy_marshal_constructor
struct wl_proxy* wl_proxy_marshal_constructor(struct wl_proxy *proxy, uint32_t opcode, const struct wl_interface *interface,...)
wl_proxy_marshal_constructor_versioned
struct wl_proxy* wl_proxy_marshal_constructor_versioned(struct wl_proxy *proxy, uint32_t opcode, const struct wl_interface *interface, uint32_t version,...)
wl_proxy_marshal_array_constructor
struct wl_proxy* wl_proxy_marshal_array_constructor(struct wl_proxy *proxy, uint32_t opcode, union wl_argument *args, const struct wl_interface *interface)
wl_proxy_marshal_array_constructor_versioned
struct wl_proxy* wl_proxy_marshal_array_constructor_versioned(struct wl_proxy *proxy, uint32_t opcode, union wl_argument *args, const struct wl_interface *interface, uint32_t version)
wl_proxy_destroy
void wl_proxy_destroy(struct wl_proxy *proxy)
wl_proxy_add_listener
int wl_proxy_add_listener(struct wl_proxy *proxy, void(**implementation)(void), void *data)
wl_proxy_get_listener
const void* wl_proxy_get_listener(struct wl_proxy *proxy)
wl_proxy_add_dispatcher
int wl_proxy_add_dispatcher(struct wl_proxy *proxy, wl_dispatcher_func_t dispatcher_func, const void *dispatcher_data, void *data)
wl_proxy_set_user_data
void wl_proxy_set_user_data(struct wl_proxy *proxy, void *user_data)
wl_proxy_get_user_data
void* wl_proxy_get_user_data(struct wl_proxy *proxy)
wl_proxy_get_version
uint32_t wl_proxy_get_version(struct wl_proxy *proxy)
wl_proxy_get_id
uint32_t wl_proxy_get_id(struct wl_proxy *proxy)
wl_proxy_get_class
const char* wl_proxy_get_class(struct wl_proxy *proxy)
wl_proxy_set_queue
void wl_proxy_set_queue(struct wl_proxy *proxy, struct wl_event_queue *queue)
wl_display_connect
struct wl_display* wl_display_connect(const char *name)
wl_display_connect_to_fd
struct wl_display* wl_display_connect_to_fd(int fd)
wl_display_disconnect
void wl_display_disconnect(struct wl_display *display)
wl_display_get_fd
int wl_display_get_fd(struct wl_display *display)
wl_display_dispatch
int wl_display_dispatch(struct wl_display *display)
wl_display_dispatch_queue
int wl_display_dispatch_queue(struct wl_display *display, struct wl_event_queue *queue)
wl_display_dispatch_queue_pending
int wl_display_dispatch_queue_pending(struct wl_display *display, struct wl_event_queue *queue)
wl_display_dispatch_pending
int wl_display_dispatch_pending(struct wl_display *display)
wl_display_get_error
int wl_display_get_error(struct wl_display *display)
wl_display_get_protocol_error
uint32_t wl_display_get_protocol_error(struct wl_display *display, const struct wl_interface **interface, uint32_t *id)
wl_display_flush
int wl_display_flush(struct wl_display *display)
wl_display_roundtrip_queue
int wl_display_roundtrip_queue(struct wl_display *display, struct wl_event_queue *queue)
wl_display_roundtrip
int wl_display_roundtrip(struct wl_display *display)
wl_display_create_queue
struct wl_event_queue* wl_display_create_queue(struct wl_display *display)
wl_display_prepare_read_queue
int wl_display_prepare_read_queue(struct wl_display *display, struct wl_event_queue *queue)
wl_display_prepare_read
int wl_display_prepare_read(struct wl_display *display)
wl_display_cancel_read
void wl_display_cancel_read(struct wl_display *display)
wl_display_read_events
int wl_display_read_events(struct wl_display *display)
wl_log_set_handler_client
void wl_log_set_handler_client(wl_log_func_t handler)
wl_log_set_handler_client
void wl_log_set_handler_client(wl_log_func_t handler)
WL_EXPORT + - +Visibility attribute.
WL_DEPRECATED + - +Deprecated attribute.
WL_PRINTF + - +Printf-style argument attribute.
x
+Ordinality of the format string argument
y
+Ordinality of the argument to check against the format string

+ + See also: https://gcc.gnu.org/onlinedocs/gcc-3.2.1/gcc/Function-Attributes.html +

wl_container_of + - +Retrieves a pointer to a containing struct, given a member name.

This macro allows "conversion" from a pointer to a member to its containing struct. This is useful if you have a contained item like a wl_list, wl_listener, or wl_signal, provided via a callback or other means, and would like to retrieve the struct that contains it.

To demonstrate, the following example retrieves a pointer to example_container given only its destroy_listener member:

+

struct example_container {
+        struct wl_listener destroy_listener;
+        // other members...
+};
+
+void example_container_destroy(struct wl_listener *listener, void *data)
+{
+        struct example_container *ctr;
+
+        ctr = wl_container_of(listener, ctr, destroy_listener);
+        // destroy ctr...
+}
+

+

Note: sample need not be a valid pointer. A null or uninitialised pointer is sufficient. +

ptr
+Valid pointer to the contained member
sample
+Pointer to a struct whose type contains ptr
member
+Named location of ptr within the sample type

+

Returns:
The container for the specified pointer

+

wl_iterator_result + - +Return value of an iterator function.

+ See also: wl_client_for_each_resource_iterator_func_t + + See also: wl_client_for_each_resource +

wl_fixed_t + - +Fixed-point number.
typedef int32_t wl_fixed_t

A wl_fixed_t is a 24.8 signed fixed-point number with a sign bit, 23 bits of integer precision and 8 bits of decimal precision. Consider wl_fixed_t as an opaque struct with methods that facilitate conversion to and from double and int types.

wl_dispatcher_func_t + - +Dispatcher function type alias.
typedef int(* wl_dispatcher_func_t) (const void *, void *, uint32_t, const struct wl_message *, union wl_argument *))(const void *, void *, uint32_t, const struct wl_message *, union wl_argument *)

A dispatcher is a function that handles the emitting of callbacks in client code. For programs directly using the C library, this is done by using libffi to call function pointers. When binding to languages other than C, dispatchers provide a way to abstract the function calling process to be friendlier to other function calling systems.

A dispatcher takes five arguments: The first is the dispatcher-specific implementation associated with the target object. The second is the object upon which the callback is being invoked (either wl_proxy or wl_resource). The third and fourth arguments are the opcode and the wl_message corresponding to the callback. The final argument is an array of arguments received from the other process via the wire protocol.

const void *
+Dispatcher-specific implementation data
void *
+Callback invocation target (wl_proxy or wl_resource)
uint32_t
+Callback opcode
const struct wl_message *
+Callback message signature
union wl_argument *
+Array of received arguments

+

Returns:
0 on success, or -1 on failure

+

wl_log_func_t + - +Log function type alias.
typedef void(* wl_log_func_t) (const char *, va_list))(const char *, va_list)

The C implementation of the Wayland protocol abstracts the details of logging. Users may customize the logging behavior, with a function conforming to the wl_log_func_t type, via wl_log_set_handler_client and wl_log_set_handler_server.

A wl_log_func_t must conform to the expectations of vprintf, and expects two arguments: a string to write and a corresponding variable argument list. While the string to write may contain format specifiers and use values in the variable argument list, the behavior of any wl_log_func_t depends on the implementation.

Note: Take care to not confuse this with wl_protocol_logger_func_t, which is a specific server-side logger for requests and events. +

const char *
+String to write to the log, containing optional format specifiers
va_list
+Variable argument list

+ + See also: wl_log_set_handler_client + + See also: wl_log_set_handler_server +

diff --git a/docs/html/apc.html b/docs/html/apc.html new file mode 100644 index 0000000000000000000000000000000000000000..243a291b29c33036c75f42be8d36120e6f3efa7b --- /dev/null +++ b/docs/html/apc.html @@ -0,0 +1,674 @@ +Appendix C. Server API

Appendix C. Server API

Table of Contents

Introduction
wl_argument + - +Protocol message argument data types.
wl_array + - +Dynamic array.
wl_buffer
wl_client
wl_display
wl_event_loop + - +An event loop context.
wl_event_source + - +An abstract event source.
wl_global
wl_interface + - +Protocol object interface.
wl_list + - +Doubly-linked list.
wl_listener + - +A single listener for Wayland signals.
wl_message + - +Protocol message signature.
wl_object
wl_protocol_logger
wl_protocol_logger_message
wl_resource
wl_resource_iterator_context
wl_shm_buffer
wl_shm_pool
wl_shm_sigbus_data
wl_signal + - +A source of a type of observable event.
wl_socket
Functions

Introduction

+ The open-source reference implementation of Wayland protocol is + split in two C libraries, libwayland-client and + libwayland-server. Their main responsibility is to handle the + Inter-process communication (IPC) with each + other, therefore guaranteeing the protocol objects marshaling and + messages synchronization. +

+ The server library is designed to work much like libwayland-client, + although it is considerably complicated due to the server needing + to support multiple versions of the protocol. It is best to learn + libwayland-client first. +

+ Each open socket to a client is represented by a wl_client. The equvalent + of the wl_proxy that + libwayland-client uses to represent an object is wl_resource for + client-created objects, and wl_global for objects + created by the server. +

+ Often a server is also a client for another Wayland server, and + thus must link with both libwayland-client and libwayland-server. + This produces some type name conflicts (such as the client wl_display and + server wl_display, + but the duplicate-but-not-the-same types are opaque, and accessed + only inside the correct library where it came from. Naturally that + means that the program writer needs to always know if a pointer to + a wl_display is for the server or client side and use the + corresponding functions. +

wl_argument + - +Protocol message argument data types.

This union represents all of the argument types in the Wayland protocol wire format. The protocol implementation uses wl_argument within its marshalling machinery for dispatching messages between a client and a compositor.

+ See also: wl_message + + See also: wl_interface + + See also: Wire Format +

wl_array + - +Dynamic array.

A wl_array is a dynamic array that can only grow until released. It is intended for relatively small allocations whose size is variable or not known in advance. While construction of a wl_array does not require all elements to be of the same size, wl_array_for_each() does require all elements to have the same type and size.

size + - +Array size.
size_t wl_array::size
alloc + - +Allocated space.
size_t wl_array::alloc
data + - +Array data.
void* wl_array::data
wl_array_init + - +Initializes the array.
void wl_array_init(struct wl_array *array)
array
+Array to initialize

+

wl_array_release + - +Releases the array data.
void wl_array_release(struct wl_array *array)

Note: Leaves the array in an invalid state. +

array
+Array whose data is to be released

+

wl_array_add + - +Increases the size of the array by size bytes.
void * wl_array_add(struct wl_array *array, size_t size)
array
+Array whose size is to be increased
size
+Number of bytes to increase the size of the array by

+

Returns:
A pointer to the beginning of the newly appended space, or NULL when resizing fails.

+

wl_array_copy + - +Copies the contents of source to array.
int wl_array_copy(struct wl_array *array, struct wl_array *source)
array
+Destination array to copy to
source
+Source array to copy from

+

Returns:
0 on success, or -1 on failure

+

wl_array_for_each + - +Iterates over an array.

This macro expresses a for-each iterator for wl_array. It assigns each element in the array to pos, which can then be referenced in a trailing code block. pos must be a pointer to the array element type, and all array elements must be of the same type and size.

pos
+Cursor that each array element will be assigned to
array
+Array to iterate over

+ + See also: wl_list_for_each() +

wl_buffer

wl_client

wl_client_flush + - +Flush pending events to the client.
void wl_client_flush(struct wl_client *client)
client
+The client object

+Events sent to clients are queued in a buffer and written to the socket later - typically when the compositor has handled all requests and goes back to block in the event loop. This function flushes all queued up events for a client immediately.

wl_client_get_display + - +Get the display object for the given client.
struct wl_display * wl_client_get_display(struct wl_client *client)
client
+The client object

+

Returns:
The display object the client is associated with.

+

wl_client_get_credentials + - +Return Unix credentials for the client.
void wl_client_get_credentials(struct wl_client *client, pid_t *pid, uid_t *uid, gid_t *gid)
client
+The display object
pid
+Returns the process ID
uid
+Returns the user ID
gid
+Returns the group ID

+This function returns the process ID, the user ID and the group ID for the given client. The credentials come from getsockopt() with SO_PEERCRED, on the client socket fd. All the pointers can be NULL, if the caller is not interested in a particular ID.

Be aware that for clients that a compositor forks and execs and then connects using socketpair(), this function will return the credentials for the compositor. The credentials for the socketpair are set at creation time in the compositor.

wl_client_get_fd + - +Get the file descriptor for the client.
int wl_client_get_fd(struct wl_client *client)
client
+The display object

+

Returns:
The file descriptor to use for the connection

+This function returns the file descriptor for the given client.

Be sure to use the file descriptor from the client for inspection only. If the caller does anything to the file descriptor that changes its state, it will likely cause problems.

See also wl_client_get_credentials(). It is recommended that you evaluate whether wl_client_get_credentials() can be applied to your use case instead of this function.

If you would like to distinguish just between the client and the compositor itself from the client's request, it can be done by getting the client credentials and by checking the PID of the client and the compositor's PID. Regarding the case in which the socketpair() is being used, you need to be careful. Please note the documentation for wl_client_get_credentials().

This function can be used for a compositor to validate a request from a client if there are additional information provided from the client's file descriptor. For instance, suppose you can get the security contexts from the client's file descriptor. The compositor can validate the client's request with the contexts and make a decision whether it permits or deny it.

wl_client_get_object + - +Look up an object in the client name space.
struct wl_resource * wl_client_get_object(struct wl_client *client, uint32_t id)
client
+The client object
id
+The object id

+

Returns:
The object or NULL if there is not object for the given ID

+This looks up an object in the client object name space by its object ID.

wl_client_get_link + - +Get the link by which a client is inserted in the client list.
struct wl_list * wl_client_get_link(struct wl_client *client)
client
+The client object

+ + See also: wl_client_for_each() + + See also: wl_display_get_client_list() + + See also: wl_client_from_link() +

wl_client_from_link + - +Get a wl_client by its link.
struct wl_client * wl_client_from_link(struct wl_list *link)
link
+The link of a wl_client

+ + See also: wl_client_for_each() + + See also: wl_display_get_client_list() + + See also: wl_client_get_link() +

wl_client_add_resource_created_listener + - +Add a listener for the client's resource creation signal.
void wl_client_add_resource_created_listener(struct wl_client *client, struct wl_listener *listener)
client
+The client object
listener
+The listener to be added

+When a new resource is created for this client the listener will be notified, carrying the new resource as the data argument.

wl_client_for_each_resource + - +Iterate over all the resources of a client.
void wl_client_for_each_resource(struct wl_client *client, wl_client_for_each_resource_iterator_func_t iterator, void *user_data)
client
+The client object
iterator
+The iterator function
user_data
+The user data pointer

+The function pointed by iterator will be called for each resource owned by the client. The user_data will be passed as the second argument of the iterator function. If the iterator function returns WL_ITERATOR_CONTINUE the iteration will continue, if it returns WL_ITERATOR_STOP it will stop.

Creating and destroying resources while iterating is safe, but new resources may or may not be picked up by the iterator.

+ See also: wl_iterator_result +

wl_display

wl_client_create + - +Create a client for the given file descriptor.
struct wl_client * wl_client_create(struct wl_display *display, int fd)
display
+The display object
fd
+The file descriptor for the socket to the client

+

Returns:
The new client object or NULL on failure.

+Given a file descriptor corresponding to one end of a socket, this function will create a wl_client struct and add the new client to the compositors client list. At that point, the client is initialized and ready to run, as if the client had connected to the servers listening socket. When the client eventually sends requests to the compositor, the wl_client argument to the request handler will be the wl_client returned from this function.

The other end of the socket can be passed to wl_display_connect_to_fd() on the client side or used with the WAYLAND_SOCKET environment variable on the client side.

Listeners added with wl_display_add_client_created_listener() will be notified by this function after the client is fully constructed.

On failure this function sets errno accordingly and returns NULL.

wl_display_create + - +Create Wayland display object.
struct wl_display * wl_display_create(void)
Returns:
The Wayland display object. Null if failed to create

+This creates the wl_display object.

wl_display_destroy + - +Destroy Wayland display object.
void wl_display_destroy(struct wl_display *display)
display
+The Wayland display object which should be destroyed.

+

Returns:
None.

+This function emits the wl_display destroy signal, releases all the sockets added to this display, free's all the globals associated with this display, free's memory of additional shared memory formats and destroy the display object.

+ See also: wl_display_add_destroy_listener +

wl_display_set_global_filter + - +Set a filter function for global objects.
void wl_display_set_global_filter(struct wl_display *display, wl_display_global_filter_func_t filter, void *data)
display
+The Wayland display object.
filter
+The global filter funtion.
data
+User data to be associated with the global filter.

+

Returns:
None.

+Set a filter for the wl_display to advertise or hide global objects to clients. The set filter will be used during wl_global advertisment to determine whether a global object should be advertised to a given client, and during wl_global binding to determine whether a given client should be allowed to bind to a global.

Clients that try to bind to a global that was filtered out will have an error raised.

Setting the filter NULL will result in all globals being advertised to all clients. The default is no filter.

wl_display_get_serial + - +Get the current serial number.
uint32_t wl_display_get_serial(struct wl_display *display)
display
+The display object

+This function returns the most recent serial number, but does not increment it.

wl_display_next_serial + - +Get the next serial number.
uint32_t wl_display_next_serial(struct wl_display *display)
display
+The display object

+This function increments the display serial number and returns the new value.

wl_display_destroy_clients + - +Destroy all clients connected to the display.
void wl_display_destroy_clients(struct wl_display *display)
display
+The display object

+This function should be called right before wl_display_destroy() to ensure all client resources are closed properly. Destroying a client from within wl_display_destroy_clients() is safe, but creating one will leak resources and raise a warning.

wl_display_add_socket_fd + - +Add a socket with an existing fd to Wayland display for the clients to connect.
int wl_display_add_socket_fd(struct wl_display *display, int sock_fd)
display
+Wayland display to which the socket should be added.
sock_fd
+The existing socket file descriptor to be used

+

Returns:
0 if success. -1 if failed.

+The existing socket fd must already be created, opened, and locked. The fd must be properly set to CLOEXEC and bound to a socket file with both bind() and listen() already called.

wl_display_add_socket + - +Add a socket to Wayland display for the clients to connect.
int wl_display_add_socket(struct wl_display *display, const char *name)
display
+Wayland display to which the socket should be added.
name
+Name of the Unix socket.

+

Returns:
0 if success. -1 if failed.

+This adds a Unix socket to Wayland display which can be used by clients to connect to Wayland display.

If NULL is passed as name, then it would look for WAYLAND_DISPLAY env variable for the socket name. If WAYLAND_DISPLAY is not set, then default wayland-0 is used.

The Unix socket will be created in the directory pointed to by environment variable XDG_RUNTIME_DIR. If XDG_RUNTIME_DIR is not set, then this function fails and returns -1.

The length of socket path, i.e., the path set in XDG_RUNTIME_DIR and the socket name, must not exceed the maximum length of a Unix socket path. The function also fails if the user do not have write permission in the XDG_RUNTIME_DIR path or if the socket name is already in use.

wl_display_add_protocol_logger + - +Adds a new protocol logger.
struct wl_protocol_logger * wl_display_add_protocol_logger(struct wl_display *display, wl_protocol_logger_func_t func, void *user_data)

When a new protocol message arrives or is sent from the server all the protocol logger functions will be called, carrying the user_data pointer, the type of the message (request or event) and the actual message. The lifetime of the messages passed to the logger function ends when they return so the messages cannot be stored and accessed later.

errno is set on error.

display
+The display object
func
+The function to call to log a new protocol message
user_data
+The user data pointer to pass to func

+

Returns:
The protol logger object on success, NULL on failure.

+ + See also: wl_protocol_logger_destroy +

wl_display_add_shm_format + - +Add support for a wl_shm pixel format.
uint32_t * wl_display_add_shm_format(struct wl_display *display, uint32_t format)
display
+The display object
format
+The wl_shm pixel format to advertise

+

Returns:
A pointer to the wl_shm format that was added to the list or NULL if adding it to the list failed.

+Add the specified wl_shm format to the list of formats the wl_shm object advertises when a client binds to it. Adding a format to the list means that clients will know that the compositor supports this format and may use it for creating wl_shm buffers. The compositor must be able to handle the pixel format when a client requests it.

The compositor by default supports WL_SHM_FORMAT_ARGB8888 and WL_SHM_FORMAT_XRGB8888.

wl_display_get_client_list + - +Get the list of currently connected clients.
struct wl_list * wl_display_get_client_list(struct wl_display *display)
display
+The display object

+This function returns a pointer to the list of clients currently connected to the display. You can iterate on the list by using the wl_client_for_each macro. The returned value is valid for the lifetime of the display. You must not modify the returned list, but only access it.

+ See also: wl_client_for_each() + + See also: wl_client_get_link() + + See also: wl_client_from_link() +

wl_event_loop + - +An event loop context.

Usually you create an event loop context, add sources to it, and call wl_event_loop_dispatch() in a loop to process events.

+ See also: wl_event_source +

wl_event_loop_create + - +Create a new event loop context.
struct wl_event_loop * wl_event_loop_create(void)
Returns:
A new event loop context object.

+This creates a new event loop context. Initially this context is empty. Event sources need to be explicitly added to it.

Normally the event loop is run by calling wl_event_loop_dispatch() in a loop until the program terminates. Alternatively, an event loop can be embedded in another event loop by its file descriptor, see wl_event_loop_get_fd().

wl_event_loop_destroy + - +Destroy an event loop context.
void wl_event_loop_destroy(struct wl_event_loop *loop)
loop
+The event loop to be destroyed.

+This emits the event loop destroy signal, closes the event loop file descriptor, and frees loop.

If the event loop has existing sources, those cannot be safely removed afterwards. Therefore one must call wl_event_source_remove() on all event sources before destroying the event loop context.

wl_event_loop_dispatch_idle + - +Dispatch the idle sources.
void wl_event_loop_dispatch_idle(struct wl_event_loop *loop)
loop
+The event loop whose idle sources are dispatched.

+ + See also: wl_event_loop_add_idle() +

wl_event_loop_dispatch + - +Wait for events and dispatch them.
int wl_event_loop_dispatch(struct wl_event_loop *loop, int timeout)
loop
+The event loop whose sources to wait for.
timeout
+The polling timeout in milliseconds.

+

Returns:
0 for success, -1 for polling error.

+All the associated event sources are polled. This function blocks until any event source delivers an event (idle sources excluded), or the timeout expires. A timeout of -1 disables the timeout, causing the function to block indefinitely. A timeout of zero causes the poll to always return immediately.

All idle sources are dispatched before blocking. An idle source is destroyed when it is dispatched. After blocking, all other ready sources are dispatched. Then, idle sources are dispatched again, in case the dispatched events created idle sources. Finally, all sources marked with wl_event_source_check() are dispatched in a loop until their dispatch functions all return zero.

wl_event_loop_get_fd + - +Get the event loop file descriptor.
int wl_event_loop_get_fd(struct wl_event_loop *loop)
loop
+The event loop context.

+

Returns:
The aggregate file descriptor.

+This function returns the aggregate file descriptor, that represents all the event sources (idle sources excluded) associated with the given event loop context. When any event source makes an event available, it will be reflected in the aggregate file descriptor.

When the aggregate file descriptor delivers an event, one can call wl_event_loop_dispatch() on the event loop context to dispatch all the available events.

wl_event_loop_add_destroy_listener + - +Register a destroy listener for an event loop context.
void wl_event_loop_add_destroy_listener(struct wl_event_loop *loop, struct wl_listener *listener)
loop
+The event loop context whose destruction to listen for.
listener
+The listener with the callback to be called.

+ + See also: wl_listener +

wl_event_loop_get_destroy_listener + - +Get the listener struct for the specified callback.
struct wl_listener * wl_event_loop_get_destroy_listener(struct wl_event_loop *loop, wl_notify_func_t notify)
loop
+The event loop context to inspect.
notify
+The destroy callback to find.

+

Returns:
The wl_listener registered to the event loop context with the given callback pointer.

+

wl_event_source + - +An abstract event source.

This is the generic type for fd, timer, signal, and idle sources. Functions that operate on specific source types must not be used with a different type, even if the function signature allows it.

wl_event_loop_fd_func_t + - +File descriptor dispatch function type.
typedef int(* wl_event_loop_fd_func_t) (int fd, uint32_t mask, void *data))(int fd, uint32_t mask, void *data)

Functions of this type are used as callbacks for file descriptor events.

fd
+The file descriptor delivering the event.
mask
+Describes the kind of the event as a bitwise-or of: WL_EVENT_READABLE, WL_EVENT_WRITABLE, WL_EVENT_HANGUP, WL_EVENT_ERROR.
data
+The user data argument of the related wl_event_loop_add_fd() call.

+

Returns:
If the event source is registered for re-check with wl_event_source_check(): 0 for all done, 1 for needing a re-check. If not registered, the return value is ignored and should be zero.

+ + See also: wl_event_loop_add_fd() +

wl_event_loop_timer_func_t + - +Timer dispatch function type.
typedef int(* wl_event_loop_timer_func_t) (void *data))(void *data)

Functions of this type are used as callbacks for timer expiry.

data
+The user data argument of the related wl_event_loop_add_timer() call.

+

Returns:
If the event source is registered for re-check with wl_event_source_check(): 0 for all done, 1 for needing a re-check. If not registered, the return value is ignored and should be zero.

+ + See also: wl_event_loop_add_timer() +

wl_event_loop_signal_func_t + - +Signal dispatch function type.
typedef int(* wl_event_loop_signal_func_t) (int signal_number, void *data))(int signal_number, void *data)

Functions of this type are used as callbacks for (POSIX) signals.

signal_number
+
data
+The user data argument of the related wl_event_loop_add_signal() call.

+

Returns:
If the event source is registered for re-check with wl_event_source_check(): 0 for all done, 1 for needing a re-check. If not registered, the return value is ignored and should be zero.

+ + See also: wl_event_loop_add_signal() +

wl_event_loop_idle_func_t + - +Idle task function type.
typedef void(* wl_event_loop_idle_func_t) (void *data))(void *data)

Functions of this type are used as callbacks before blocking in wl_event_loop_dispatch().

data
+The user data argument of the related wl_event_loop_add_idle() call.

+ + See also: wl_event_loop_add_idle() wl_event_loop_dispatch() +

wl_event_loop_add_fd + - +Create a file descriptor event source.
struct wl_event_source * wl_event_loop_add_fd(struct wl_event_loop *loop, int fd, uint32_t mask, wl_event_loop_fd_func_t func, void *data)
loop
+The event loop that will process the new source.
fd
+The file descriptor to watch.
mask
+A bitwise-or of which events to watch for: WL_EVENT_READABLE, WL_EVENT_WRITABLE.
func
+The file descriptor dispatch function.
data
+User data.

+

Returns:
A new file descriptor event source.

+The given file descriptor is initially watched for the events given in mask. This can be changed as needed with wl_event_source_fd_update().

If it is possible that program execution causes the file descriptor to be read while leaving the data in a buffer without actually processing it, it may be necessary to register the file descriptor source to be re-checked, see wl_event_source_check(). This will ensure that the dispatch function gets called even if the file descriptor is not readable or writable anymore. This is especially useful with IPC libraries that automatically buffer incoming data, possibly as a side-effect of other operations.

+ See also: wl_event_loop_fd_func_t +

wl_event_source_fd_update + - +Update a file descriptor source's event mask.
int wl_event_source_fd_update(struct wl_event_source *source, uint32_t mask)
source
+The file descriptor event source to update.
mask
+The new mask, a bitwise-or of: WL_EVENT_READABLE, WL_EVENT_WRITABLE.

+

Returns:
0 on success, -1 on failure.

+This changes which events, readable and/or writable, cause the dispatch callback to be called on.

File descriptors are usually writable to begin with, so they do not need to be polled for writable until a write actually fails. When a write fails, the event mask can be changed to poll for readable and writable, delivering a dispatch callback when it is possible to write more. Once all data has been written, the mask can be changed to poll only for readable to avoid busy-looping on dispatch.

+ See also: wl_event_loop_add_fd() +

wl_event_loop_add_timer + - +Create a timer event source.
struct wl_event_source * wl_event_loop_add_timer(struct wl_event_loop *loop, wl_event_loop_timer_func_t func, void *data)
loop
+The event loop that will process the new source.
func
+The timer dispatch function.
data
+User data.

+

Returns:
A new timer event source.

+The timer is initially disarmed. It needs to be armed with a call to wl_event_source_timer_update() before it can trigger a dispatch call.

+ See also: wl_event_loop_timer_func_t +

wl_event_source_timer_update + - +Arm or disarm a timer.
int wl_event_source_timer_update(struct wl_event_source *source, int ms_delay)
source
+The timer event source to modify.
ms_delay
+The timeout in milliseconds.

+

Returns:
0 on success, -1 on failure.

+If the timeout is zero, the timer is disarmed.

If the timeout is non-zero, the timer is set to expire after the given timeout in milliseconds. When the timer expires, the dispatch function set with wl_event_loop_add_timer() is called once from wl_event_loop_dispatch(). If another dispatch is desired after another expiry, wl_event_source_timer_update() needs to be called again.

wl_event_loop_add_signal + - +Create a POSIX signal event source.
struct wl_event_source * wl_event_loop_add_signal(struct wl_event_loop *loop, int signal_number, wl_event_loop_signal_func_t func, void *data)
loop
+The event loop that will process the new source.
signal_number
+Number of the signal to watch for.
func
+The signal dispatch function.
data
+User data.

+

Returns:
A new signal event source.

+This function blocks the normal delivery of the given signal in the calling thread, and creates a "watch" for it. Signal delivery no longer happens asynchronously, but by wl_event_loop_dispatch() calling the dispatch callback function func.

It is the caller's responsibility to ensure that all other threads have also blocked the signal.

+ See also: wl_event_loop_signal_func_t +

wl_event_loop_add_idle + - +Create an idle task.
struct wl_event_source * wl_event_loop_add_idle(struct wl_event_loop *loop, wl_event_loop_idle_func_t func, void *data)
loop
+The event loop that will process the new task.
func
+The idle task dispatch function.
data
+User data.

+

Returns:
A new idle task (an event source).

+Idle tasks are dispatched before wl_event_loop_dispatch() goes to sleep. See wl_event_loop_dispatch() for more details.

Idle tasks fire once, and are automatically destroyed right after the callback function has been called.

An idle task can be cancelled before the callback has been called by wl_event_source_remove(). Calling wl_event_source_remove() after or from within the callback results in undefined behaviour.

+ See also: wl_event_loop_idle_func_t +

wl_event_source_check + - +Mark event source to be re-checked.
void wl_event_source_check(struct wl_event_source *source)
source
+The event source to be re-checked.

+This function permanently marks the event source to be re-checked after the normal dispatch of sources in wl_event_loop_dispatch(). Re-checking will keep iterating over all such event sources until the dispatch function for them all returns zero.

Re-checking is used on sources that may become ready to dispatch as a side-effect of dispatching themselves or other event sources, including idle sources. Re-checking ensures all the incoming events have been fully drained before wl_event_loop_dispatch() returns.

wl_event_source_remove + - +Remove an event source from its event loop.
int wl_event_source_remove(struct wl_event_source *source)
source
+The event source to be removed.

+

Returns:
Zero.

+The event source is removed from the event loop it was created for, and is effectively destroyed. This invalidates source . The dispatch function of the source will no longer be called through this source.

wl_global

wl_interface + - +Protocol object interface.

A wl_interface describes the API of a protocol object defined in the Wayland protocol specification. The protocol implementation uses a wl_interface within its marshalling machinery for encoding client requests.

The name of a wl_interface is the name of the corresponding protocol interface, and version represents the version of the interface. The members method_count and event_count represent the number of methods (requests) and events in the respective wl_message members.

For example, consider a protocol interface foo, marked as version 1, with two requests and one event.

+

<interface name="foo" version="1">
+  <request name="a"></request>
+  <request name="b"></request>
+  <event name="c"></event>
+</interface>
+

+

Given two wl_message arrays foo_requests and foo_events, a wl_interface for foo might be:

+

struct wl_interface foo_interface = {
+        "foo", 1,
+        2, foo_requests,
+        1, foo_events
+};
+

+

Note: The server side of the protocol may define interface implementation types that incorporate the term interface in their name. Take care to not confuse these server-side structs with a wl_interface variable whose name also ends in interface. For example, while the server may define a type struct wl_foo_interface, the client may define a struct wl_interface wl_foo_interface. + + See also: wl_message + + See also: wl_proxy + + See also: Interfaces + + See also: Versioning +

wl_list + - +Doubly-linked list.

On its own, an instance of struct wl_list represents the sentinel head of a doubly-linked list, and must be initialized using wl_list_init(). When empty, the list head's next and prev members point to the list head itself, otherwise next references the first element in the list, and prev refers to the last element in the list.

Use the struct wl_list type to represent both the list head and the links between elements within the list. Use wl_list_empty() to determine if the list is empty in O(1).

All elements in the list must be of the same type. The element type must have a struct wl_list member, often named link by convention. Prior to insertion, there is no need to initialize an element's link - invoking wl_list_init() on an individual list element's struct wl_list member is unnecessary if the very next operation is wl_list_insert(). However, a common idiom is to initialize an element's link prior to removal - ensure safety by invoking wl_list_init() before wl_list_remove().

Consider a list reference struct wl_list foo_list, an element type as struct element, and an element's link member as struct wl_list link.

The following code initializes a list and adds three elements to it.

+

struct wl_list foo_list;
+
+struct element {
+        int foo;
+        struct wl_list link;
+};
+struct element e1, e2, e3;
+
+wl_list_init(&foo_list);
+wl_list_insert(&foo_list, &e1.link);   // e1 is the first element
+wl_list_insert(&foo_list, &e2.link);   // e2 is now the first element
+wl_list_insert(&e2.link, &e3.link); // insert e3 after e2
+

+

The list now looks like [e2, e3, e1].

The wl_list API provides some iterator macros. For example, to iterate a list in ascending order:

+

struct element *e;
+wl_list_for_each(e, foo_list, link) {
+        do_something_with_element(e);
+}
+

+

See the documentation of each iterator for details. + See also: http://git.kernel.org/cgit/linux/kernel/git/torvalds/linux.git/tree/include/linux/list.h +

prev + - +Previous list element.
struct wl_list* wl_list::prev
next + - +Next list element.
struct wl_list* wl_list::next
wl_list_init + - +Initializes the list.
void wl_list_init(struct wl_list *list)
list
+List to initialize

+

wl_list_insert + - +Inserts an element into the list, after the element represented by list.
void wl_list_insert(struct wl_list *list, struct wl_list *elm)

When list is a reference to the list itself (the head), set the containing struct of elm as the first element in the list.

Note: If elm is already part of a list, inserting it again will lead to list corruption. +

list
+List element after which the new element is inserted
elm
+Link of the containing struct to insert into the list

+

wl_list_remove + - +Removes an element from the list.
void wl_list_remove(struct wl_list *elm)

Note: This operation leaves elm in an invalid state. +

elm
+Link of the containing struct to remove from the list

+

wl_list_length + - +Determines the length of the list.
int wl_list_length(const struct wl_list *list)

Note: This is an O(n) operation. +

list
+List whose length is to be determined

+

Returns:
Number of elements in the list

+

wl_list_empty + - +Determines if the list is empty.
int wl_list_empty(const struct wl_list *list)
list
+List whose emptiness is to be determined

+

Returns:
1 if empty, or 0 if not empty

+

wl_list_insert_list + - +Inserts all of the elements of one list into another, after the element represented by list.
void wl_list_insert_list(struct wl_list *list, struct wl_list *other)

Note: This leaves other in an invalid state. +

list
+List element after which the other list elements will be inserted
other
+List of elements to insert

+

wl_list_for_each + - +Iterates over a list.

This macro expresses a for-each iterator for wl_list. Given a list and wl_list link member name (often named link by convention), this macro assigns each element in the list to pos, which can then be referenced in a trailing code block. For example, given a wl_list of struct message elements:

+

struct message {
+        char *contents;
+        wl_list link;
+};
+
+struct wl_list *message_list;
+// Assume message_list now "contains" many messages
+
+struct message *m;
+wl_list_for_each(m, message_list, link) {
+        do_something_with_message(m);
+}
+

+

pos
+Cursor that each list element will be assigned to
head
+Head of the list to iterate over
member
+Name of the link member within the element struct

+

wl_list_for_each_safe + - +Iterates over a list, safe against removal of the list element.

Note: Only removal of the current element, pos, is safe. Removing any other element during traversal may lead to a loop malfunction. + + See also: wl_list_for_each() +

pos
+Cursor that each list element will be assigned to
tmp
+Temporary pointer of the same type as pos
head
+Head of the list to iterate over
member
+Name of the link member within the element struct

+

wl_list_for_each_reverse + - +Iterates backwards over a list.

+ See also: wl_list_for_each() +

pos
+Cursor that each list element will be assigned to
head
+Head of the list to iterate over
member
+Name of the link member within the element struct

+

wl_list_for_each_reverse_safe + - +Iterates backwards over a list, safe against removal of the list element.

Note: Only removal of the current element, pos, is safe. Removing any other element during traversal may lead to a loop malfunction. + + See also: wl_list_for_each() +

pos
+Cursor that each list element will be assigned to
tmp
+Temporary pointer of the same type as pos
head
+Head of the list to iterate over
member
+Name of the link member within the element struct

+

wl_listener + - +A single listener for Wayland signals.

wl_listener provides the means to listen for wl_signal notifications. Many Wayland objects use wl_listener for notification of significant events like object destruction.

Clients should create wl_listener objects manually and can register them as listeners to signals using wl_signal_add, assuming the signal is directly accessible. For opaque structs like wl_event_loop, adding a listener should be done through provided accessor methods. A listener can only listen to one signal at a time.

+

struct wl_listener your_listener;
+
+your_listener.notify = your_callback_method;
+
+// Direct access
+wl_signal_add(&some_object->destroy_signal, &your_listener);
+
+// Accessor access
+wl_event_loop *loop = ...;
+wl_event_loop_add_destroy_listener(loop, &your_listener);
+

+

If the listener is part of a larger struct, wl_container_of can be used to retrieve a pointer to it:

+

void your_listener(struct wl_listener *listener, void *data)
+{
+        struct your_data *data;
+
+        your_data = wl_container_of(listener, data, your_member_name);
+}
+

+

If you need to remove a listener from a signal, use wl_list_remove().

+

wl_list_remove(&your_listener.link);
+

+

+ See also: wl_signal +

wl_message + - +Protocol message signature.

A wl_message describes the signature of an actual protocol message, such as a request or event, that adheres to the Wayland protocol wire format. The protocol implementation uses a wl_message within its demarshal machinery for decoding messages between a compositor and its clients. In a sense, a wl_message is to a protocol message like a class is to an object.

The name of a wl_message is the name of the corresponding protocol message.

The signature is an ordered list of symbols representing the data types of message arguments and, optionally, a protocol version and indicators for nullability. A leading integer in the signature indicates the since version of the protocol message. A ? preceding a data type symbol indicates that the following argument type is nullable. While it is a protocol violation to send messages with non-nullable arguments set to NULL, event handlers in clients might still get called with non-nullable object arguments set to NULL. This can happen when the client destroyed the object being used as argument on its side and an event referencing that object was sent before the server knew about its destruction. As this race cannot be prevented, clients should - as a general rule - program their event handlers such that they can handle object arguments declared non-nullable being NULL gracefully.

When no arguments accompany a message, signature is an empty string.

Symbols:

  • i: int
  • u: uint
  • f: fixed
  • s: string
  • o: object
  • n: new_id
  • a: array
  • h: fd
  • ?: following argument is nullable

+

While demarshaling primitive arguments is straightforward, when demarshaling messages containing object or new_id arguments, the protocol implementation often must determine the type of the object. The types of a wl_message is an array of wl_interface references that correspond to o and n arguments in signature, with NULL placeholders for arguments with non-object types.

Consider the protocol event wl_display delete_id that has a single uint argument. The wl_message is:

+

{ "delete_id", "u", [NULL] }
+

+

Here, the message name is "delete_id", the signature is "u", and the argument types is [NULL], indicating that the uint argument has no corresponding wl_interface since it is a primitive argument.

In contrast, consider a wl_foo interface supporting protocol request bar that has existed since version 2, and has two arguments: a uint and an object of type wl_baz_interface that may be NULL. Such a wl_message might be:

+

{ "bar", "2u?o", [NULL, &wl_baz_interface] }
+

+

Here, the message name is "bar", and the signature is "2u?o". Notice how the 2 indicates the protocol version, the u indicates the first argument type is uint, and the ?o indicates that the second argument is an object that may be NULL. Lastly, the argument types array indicates that no wl_interface corresponds to the first argument, while the type wl_baz_interface corresponds to the second argument.

+ See also: wl_argument + + See also: wl_interface + + See also: Wire Format +

wl_object

wl_protocol_logger

wl_protocol_logger_destroy + - +Destroys a protocol logger.
void wl_protocol_logger_destroy(struct wl_protocol_logger *logger)

This function destroys a protocol logger and removes it from the display it was added to with wl_display_add_protocol_logger. The logger object becomes invalid after calling this function.

+ See also: wl_display_add_protocol_logger +

wl_protocol_logger_message

wl_resource

wl_resource_get_class + - +Retrieve the interface name (class) of a resource object.
const char * wl_resource_get_class(struct wl_resource *resource)
resource
+The resource object

+

wl_resource_create + - +Create a new resource object.
struct wl_resource * wl_resource_create(struct wl_client *client, const struct wl_interface *interface, int version, uint32_t id)
client
+The client owner of the new resource.
interface
+The interface of the new resource.
version
+The version of the new resource.
id
+The id of the new resource. If 0, an available id will be used.

+Listeners added with wl_client_add_resource_created_listener will be notified at the end of this function.

wl_resource_iterator_context

wl_shm_buffer

wl_shm_buffer_get_data + - +Get a pointer to the memory for the SHM buffer.
void * wl_shm_buffer_get_data(struct wl_shm_buffer *buffer)
buffer
+The buffer object

+Returns a pointer which can be used to read the data contained in the given SHM buffer.

As this buffer is memory-mapped, reading from it may generate SIGBUS signals. This can happen if the client claims that the buffer is larger than it is or if something truncates the underlying file. To prevent this signal from causing the compositor to crash you should call wl_shm_buffer_begin_access and wl_shm_buffer_end_access around code that reads from the memory.

wl_shm_buffer_ref_pool + - +Get a reference to a shm_buffer's shm_pool.
struct wl_shm_pool * wl_shm_buffer_ref_pool(struct wl_shm_buffer *buffer)
buffer
+The buffer object

+Returns a pointer to a buffer's shm_pool and increases the shm_pool refcount.

The compositor must remember to call wl_shm_pool_unref when it no longer needs the reference to ensure proper destruction of the pool.

+ See also: wl_shm_pool_unref +

wl_shm_buffer_begin_access + - +Mark that the given SHM buffer is about to be accessed.
void wl_shm_buffer_begin_access(struct wl_shm_buffer *buffer)
buffer
+The SHM buffer

+An SHM buffer is a memory-mapped file given by the client. According to POSIX, reading from a memory-mapped region that extends off the end of the file will cause a SIGBUS signal to be generated. Normally this would cause the compositor to terminate. In order to make the compositor robust against clients that change the size of the underlying file or lie about its size, you should protect access to the buffer by calling this function before reading from the memory and call wl_shm_buffer_end_access afterwards. This will install a signal handler for SIGBUS which will prevent the compositor from crashing.

After calling this function the signal handler will remain installed for the lifetime of the compositor process. Note that this function will not work properly if the compositor is also installing its own handler for SIGBUS.

If a SIGBUS signal is received for an address within the range of the SHM pool of the given buffer then the client will be sent an error event when wl_shm_buffer_end_access is called. If the signal is for an address outside that range then the signal handler will reraise the signal which would will likely cause the compositor to terminate.

It is safe to nest calls to these functions as long as the nested calls are all accessing the same buffer. The number of calls to wl_shm_buffer_end_access must match the number of calls to wl_shm_buffer_begin_access. These functions are thread-safe and it is allowed to simultaneously access different buffers or the same buffer from multiple threads.

wl_shm_buffer_end_access + - +Ends the access to a buffer started by wl_shm_buffer_begin_access.
void wl_shm_buffer_end_access(struct wl_shm_buffer *buffer)
buffer
+The SHM buffer

+This should be called after wl_shm_buffer_begin_access once the buffer is no longer being accessed. If a SIGBUS signal was generated in-between these two calls then the resource for the given buffer will be sent an error.

wl_shm_pool

wl_shm_pool_unref + - +Unreference a shm_pool.
void wl_shm_pool_unref(struct wl_shm_pool *pool)
pool
+The pool object

+Drops a reference to a wl_shm_pool object.

This is only necessary if the compositor has explicitly taken a reference with wl_shm_buffer_ref_pool(), otherwise the pool will be automatically destroyed when appropriate.

+ See also: wl_shm_buffer_ref_pool +

wl_shm_sigbus_data

wl_signal + - +A source of a type of observable event.

Signals are recognized points where significant events can be observed. Compositors as well as the server can provide signals. Observers are wl_listener's that are added through wl_signal_add. Signals are emitted using wl_signal_emit, which will invoke all listeners until that listener is removed by wl_list_remove() (or whenever the signal is destroyed).

+ See also: wl_listener for more information on using wl_signal +

wl_signal_init + - +Initialize a new wl_signal for use.
static void wl_signal_init(struct wl_signal *signal)
signal
+The signal that will be initialized

+

wl_signal_add + - +Add the specified listener to this signal.
static void wl_signal_add(struct wl_signal *signal, struct wl_listener *listener)
signal
+The signal that will emit events to the listener
listener
+The listener to add

+

wl_signal_get + - +Gets the listener struct for the specified callback.
static struct wl_listener * wl_signal_get(struct wl_signal *signal, wl_notify_func_t notify)
signal
+The signal that contains the specified listener
notify
+The listener that is the target of this search

+

Returns:
the list item that corresponds to the specified listener, or NULL if none was found

+

wl_signal_emit + - +Emits this signal, notifying all registered listeners.
static void wl_signal_emit(struct wl_signal *signal, void *data)
signal
+The signal object that will emit the signal
data
+The data that will be emitted with the signal

+

wl_socket

Functions

wl_client_for_each + - +Iterate over a list of clients.
wl_display_global_filter_func_t + - +A filter function for wl_global objects.
typedef bool(* wl_display_global_filter_func_t) (const struct wl_client *client, const struct wl_global *global, void *data))(const struct wl_client *client, const struct wl_global *global, void *data)
client
+The client object
global
+The global object to show or hide
data
+The user data pointer

+A filter function enables the server to decide which globals to advertise to each client.

When a wl_global filter is set, the given callback funtion will be called during wl_global advertisment and binding.

This function should return true if the global object should be made visible to the client or false otherwise.

wl_event_loop_create
struct wl_event_loop* wl_event_loop_create(void)
wl_event_loop_destroy
void wl_event_loop_destroy(struct wl_event_loop *loop)
wl_event_loop_add_fd
struct wl_event_source* wl_event_loop_add_fd(struct wl_event_loop *loop, int fd, uint32_t mask, wl_event_loop_fd_func_t func, void *data)
wl_event_source_fd_update
int wl_event_source_fd_update(struct wl_event_source *source, uint32_t mask)
wl_event_loop_add_timer
struct wl_event_source* wl_event_loop_add_timer(struct wl_event_loop *loop, wl_event_loop_timer_func_t func, void *data)
wl_event_loop_add_signal
struct wl_event_source* wl_event_loop_add_signal(struct wl_event_loop *loop, int signal_number, wl_event_loop_signal_func_t func, void *data)
wl_event_source_timer_update
int wl_event_source_timer_update(struct wl_event_source *source, int ms_delay)
wl_event_source_remove
int wl_event_source_remove(struct wl_event_source *source)
wl_event_source_check
void wl_event_source_check(struct wl_event_source *source)
wl_event_loop_dispatch
int wl_event_loop_dispatch(struct wl_event_loop *loop, int timeout)
wl_event_loop_dispatch_idle
void wl_event_loop_dispatch_idle(struct wl_event_loop *loop)
wl_event_loop_add_idle
struct wl_event_source* wl_event_loop_add_idle(struct wl_event_loop *loop, wl_event_loop_idle_func_t func, void *data)
wl_event_loop_get_fd
int wl_event_loop_get_fd(struct wl_event_loop *loop)
wl_event_loop_add_destroy_listener
void wl_event_loop_add_destroy_listener(struct wl_event_loop *loop, struct wl_listener *listener)
wl_event_loop_get_destroy_listener
struct wl_listener* wl_event_loop_get_destroy_listener(struct wl_event_loop *loop, wl_notify_func_t notify)
wl_display_create
struct wl_display* wl_display_create(void)
wl_display_destroy
void wl_display_destroy(struct wl_display *display)
wl_display_get_event_loop
struct wl_event_loop* wl_display_get_event_loop(struct wl_display *display)
wl_display_add_socket
int wl_display_add_socket(struct wl_display *display, const char *name)
wl_display_add_socket_auto
const char* wl_display_add_socket_auto(struct wl_display *display)
wl_display_add_socket_fd
int wl_display_add_socket_fd(struct wl_display *display, int sock_fd)
wl_display_terminate
void wl_display_terminate(struct wl_display *display)
wl_display_run
void wl_display_run(struct wl_display *display)
wl_display_flush_clients
void wl_display_flush_clients(struct wl_display *display)
wl_display_destroy_clients
void wl_display_destroy_clients(struct wl_display *display)
wl_display_get_serial
uint32_t wl_display_get_serial(struct wl_display *display)
wl_display_next_serial
uint32_t wl_display_next_serial(struct wl_display *display)
wl_display_add_destroy_listener
void wl_display_add_destroy_listener(struct wl_display *display, struct wl_listener *listener)
wl_display_add_client_created_listener + - +Registers a listener for the client connection signal.
void wl_display_add_client_created_listener(struct wl_display *display, struct wl_listener *listener)

When a new client object is created, listener will be notified, carrying a pointer to the new wl_client object.

wl_client_create wl_display wl_listener

display
+The display object
listener
+Signal handler object

+

wl_display_get_destroy_listener
struct wl_listener* wl_display_get_destroy_listener(struct wl_display *display, wl_notify_func_t notify)
wl_global_create
struct wl_global* wl_global_create(struct wl_display *display, const struct wl_interface *interface, int version, void *data, wl_global_bind_func_t bind)
wl_global_destroy
void wl_global_destroy(struct wl_global *global)
wl_display_set_global_filter
void wl_display_set_global_filter(struct wl_display *display, wl_display_global_filter_func_t filter, void *data)
wl_global_get_interface
const struct wl_interface* wl_global_get_interface(const struct wl_global *global)
wl_global_get_user_data
void* wl_global_get_user_data(const struct wl_global *global)
wl_client_create
struct wl_client* wl_client_create(struct wl_display *display, int fd)
wl_display_get_client_list
struct wl_list* wl_display_get_client_list(struct wl_display *display)
wl_client_get_link
struct wl_list* wl_client_get_link(struct wl_client *client)
wl_client_from_link
struct wl_client* wl_client_from_link(struct wl_list *link)
wl_client_destroy
void wl_client_destroy(struct wl_client *client)
wl_client_flush
void wl_client_flush(struct wl_client *client)
wl_client_get_credentials
void wl_client_get_credentials(struct wl_client *client, pid_t *pid, uid_t *uid, gid_t *gid)
wl_client_get_fd
int wl_client_get_fd(struct wl_client *client)
wl_client_add_destroy_listener
void wl_client_add_destroy_listener(struct wl_client *client, struct wl_listener *listener)
wl_client_get_destroy_listener
struct wl_listener* wl_client_get_destroy_listener(struct wl_client *client, wl_notify_func_t notify)
wl_client_get_object
struct wl_resource* wl_client_get_object(struct wl_client *client, uint32_t id)
wl_client_post_no_memory
void wl_client_post_no_memory(struct wl_client *client)
wl_client_add_resource_created_listener
void wl_client_add_resource_created_listener(struct wl_client *client, struct wl_listener *listener)
wl_client_for_each_resource
void wl_client_for_each_resource(struct wl_client *client, wl_client_for_each_resource_iterator_func_t iterator, void *user_data)
wl_resource_post_event
void wl_resource_post_event(struct wl_resource *resource, uint32_t opcode,...)
wl_resource_post_event_array
void wl_resource_post_event_array(struct wl_resource *resource, uint32_t opcode, union wl_argument *args)
wl_resource_queue_event
void wl_resource_queue_event(struct wl_resource *resource, uint32_t opcode,...)
wl_resource_queue_event_array
void wl_resource_queue_event_array(struct wl_resource *resource, uint32_t opcode, union wl_argument *args)
wl_resource_post_error
void wl_resource_post_error(struct wl_resource *resource, uint32_t code, const char *msg,...)
wl_resource_post_no_memory
void wl_resource_post_no_memory(struct wl_resource *resource)
wl_client_get_display
struct wl_display* wl_client_get_display(struct wl_client *client)
wl_resource_create
struct wl_resource* wl_resource_create(struct wl_client *client, const struct wl_interface *interface, int version, uint32_t id)
wl_resource_set_implementation
void wl_resource_set_implementation(struct wl_resource *resource, const void *implementation, void *data, wl_resource_destroy_func_t destroy)
wl_resource_set_dispatcher
void wl_resource_set_dispatcher(struct wl_resource *resource, wl_dispatcher_func_t dispatcher, const void *implementation, void *data, wl_resource_destroy_func_t destroy)
wl_resource_destroy
void wl_resource_destroy(struct wl_resource *resource)
wl_resource_get_id
uint32_t wl_resource_get_id(struct wl_resource *resource)
wl_resource_get_link
struct wl_list* wl_resource_get_link(struct wl_resource *resource)
wl_resource_from_link
struct wl_resource* wl_resource_from_link(struct wl_list *resource)
wl_resource_find_for_client
struct wl_resource* wl_resource_find_for_client(struct wl_list *list, struct wl_client *client)
wl_resource_get_client
struct wl_client* wl_resource_get_client(struct wl_resource *resource)
wl_resource_set_user_data
void wl_resource_set_user_data(struct wl_resource *resource, void *data)
wl_resource_get_user_data
void* wl_resource_get_user_data(struct wl_resource *resource)
wl_resource_get_version
int wl_resource_get_version(struct wl_resource *resource)
wl_resource_set_destructor
void wl_resource_set_destructor(struct wl_resource *resource, wl_resource_destroy_func_t destroy)
wl_resource_instance_of
int wl_resource_instance_of(struct wl_resource *resource, const struct wl_interface *interface, const void *implementation)
wl_resource_get_class
const char* wl_resource_get_class(struct wl_resource *resource)
wl_resource_add_destroy_listener
void wl_resource_add_destroy_listener(struct wl_resource *resource, struct wl_listener *listener)
wl_resource_get_destroy_listener
struct wl_listener* wl_resource_get_destroy_listener(struct wl_resource *resource, wl_notify_func_t notify)
wl_shm_buffer_get
struct wl_shm_buffer* wl_shm_buffer_get(struct wl_resource *resource)
wl_shm_buffer_begin_access
void wl_shm_buffer_begin_access(struct wl_shm_buffer *buffer)
wl_shm_buffer_end_access
void wl_shm_buffer_end_access(struct wl_shm_buffer *buffer)
wl_shm_buffer_get_data
void* wl_shm_buffer_get_data(struct wl_shm_buffer *buffer)
wl_shm_buffer_get_stride
int32_t wl_shm_buffer_get_stride(struct wl_shm_buffer *buffer)
wl_shm_buffer_get_format
uint32_t wl_shm_buffer_get_format(struct wl_shm_buffer *buffer)
wl_shm_buffer_get_width
int32_t wl_shm_buffer_get_width(struct wl_shm_buffer *buffer)
wl_shm_buffer_get_height
int32_t wl_shm_buffer_get_height(struct wl_shm_buffer *buffer)
wl_shm_buffer_ref_pool
struct wl_shm_pool* wl_shm_buffer_ref_pool(struct wl_shm_buffer *buffer)
wl_shm_pool_unref
void wl_shm_pool_unref(struct wl_shm_pool *pool)
wl_display_init_shm
int wl_display_init_shm(struct wl_display *display)
wl_display_add_shm_format
uint32_t* wl_display_add_shm_format(struct wl_display *display, uint32_t format)
wl_shm_buffer_create
struct wl_shm_buffer* wl_shm_buffer_create(struct wl_client *client, uint32_t id, int32_t width, int32_t height, int32_t stride, uint32_t format) WL_DEPRECATED
wl_log_set_handler_server
void wl_log_set_handler_server(wl_log_func_t handler)
wl_display_add_protocol_logger
struct wl_protocol_logger* wl_display_add_protocol_logger(struct wl_display *display, wl_protocol_logger_func_t, void *user_data)
wl_protocol_logger_destroy
void wl_protocol_logger_destroy(struct wl_protocol_logger *logger)
wl_resource_post_event_array
void wl_resource_post_event_array(struct wl_resource *resource, uint32_t opcode, union wl_argument *args)
wl_resource_post_event
void wl_resource_post_event(struct wl_resource *resource, uint32_t opcode,...)
wl_resource_queue_event_array
void wl_resource_queue_event_array(struct wl_resource *resource, uint32_t opcode, union wl_argument *args)
wl_resource_queue_event
void wl_resource_queue_event(struct wl_resource *resource, uint32_t opcode,...)
wl_resource_post_error
void wl_resource_post_error(struct wl_resource *resource, uint32_t code, const char *msg,...)
wl_client_post_no_memory
void wl_client_post_no_memory(struct wl_client *client)
wl_resource_post_no_memory
void wl_resource_post_no_memory(struct wl_resource *resource)
wl_resource_destroy
void wl_resource_destroy(struct wl_resource *resource)
wl_resource_get_id
uint32_t wl_resource_get_id(struct wl_resource *resource)
wl_resource_get_link
struct wl_list* wl_resource_get_link(struct wl_resource *resource)
wl_resource_from_link
struct wl_resource* wl_resource_from_link(struct wl_list *link)
wl_resource_find_for_client
struct wl_resource* wl_resource_find_for_client(struct wl_list *list, struct wl_client *client)
wl_resource_get_client
struct wl_client* wl_resource_get_client(struct wl_resource *resource)
wl_resource_set_user_data
void wl_resource_set_user_data(struct wl_resource *resource, void *data)
wl_resource_get_user_data
void* wl_resource_get_user_data(struct wl_resource *resource)
wl_resource_get_version
int wl_resource_get_version(struct wl_resource *resource)
wl_resource_set_destructor
void wl_resource_set_destructor(struct wl_resource *resource, wl_resource_destroy_func_t destroy)
wl_resource_instance_of
int wl_resource_instance_of(struct wl_resource *resource, const struct wl_interface *interface, const void *implementation)
wl_resource_add_destroy_listener
void wl_resource_add_destroy_listener(struct wl_resource *resource, struct wl_listener *listener)
wl_resource_get_destroy_listener
struct wl_listener* wl_resource_get_destroy_listener(struct wl_resource *resource, wl_notify_func_t notify)
wl_client_add_destroy_listener
void wl_client_add_destroy_listener(struct wl_client *client, struct wl_listener *listener)
wl_client_get_destroy_listener
struct wl_listener* wl_client_get_destroy_listener(struct wl_client *client, wl_notify_func_t notify)
wl_client_destroy
void wl_client_destroy(struct wl_client *client)
wl_global_create
struct wl_global* wl_global_create(struct wl_display *display, const struct wl_interface *interface, int version, void *data, wl_global_bind_func_t bind)
wl_global_destroy
void wl_global_destroy(struct wl_global *global)
wl_global_get_interface
const struct wl_interface* wl_global_get_interface(const struct wl_global *global)
wl_global_get_user_data
void* wl_global_get_user_data(const struct wl_global *global)
wl_display_get_event_loop
struct wl_event_loop* wl_display_get_event_loop(struct wl_display *display)
wl_display_terminate
void wl_display_terminate(struct wl_display *display)
wl_display_run
void wl_display_run(struct wl_display *display)
wl_display_flush_clients
void wl_display_flush_clients(struct wl_display *display)
wl_display_add_socket_auto
const char* wl_display_add_socket_auto(struct wl_display *display)
wl_display_add_destroy_listener
void wl_display_add_destroy_listener(struct wl_display *display, struct wl_listener *listener)
wl_display_add_client_created_listener + - +Registers a listener for the client connection signal.
void wl_display_add_client_created_listener(struct wl_display *display, struct wl_listener *listener)

When a new client object is created, listener will be notified, carrying a pointer to the new wl_client object.

wl_client_create wl_display wl_listener

display
+The display object
listener
+Signal handler object

+

wl_display_get_destroy_listener
struct wl_listener* wl_display_get_destroy_listener(struct wl_display *display, wl_notify_func_t notify)
wl_resource_set_implementation
void wl_resource_set_implementation(struct wl_resource *resource, const void *implementation, void *data, wl_resource_destroy_func_t destroy)
wl_resource_set_dispatcher
void wl_resource_set_dispatcher(struct wl_resource *resource, wl_dispatcher_func_t dispatcher, const void *implementation, void *data, wl_resource_destroy_func_t destroy)
wl_log_set_handler_server
void wl_log_set_handler_server(wl_log_func_t handler)
wl_client_add_resource
uint32_t wl_client_add_resource(struct wl_client *client, struct wl_resource *resource) WL_DEPRECATED
wl_client_add_object
struct wl_resource* wl_client_add_object(struct wl_client *client, const struct wl_interface *interface, const void *implementation, uint32_t id, void *data) WL_DEPRECATED
wl_client_new_object
struct wl_resource* wl_client_new_object(struct wl_client *client, const struct wl_interface *interface, const void *implementation, void *data) WL_DEPRECATED
wl_display_add_global
struct wl_global* wl_display_add_global(struct wl_display *display, const struct wl_interface *interface, void *data, wl_global_bind_func_t bind) WL_DEPRECATED
wl_display_remove_global
void wl_display_remove_global(struct wl_display *display, struct wl_global *global) WL_DEPRECATED
wl_display_init_shm
int wl_display_init_shm(struct wl_display *display)
wl_shm_buffer_get
struct wl_shm_buffer* wl_shm_buffer_get(struct wl_resource *resource)
wl_shm_buffer_get_stride
int32_t wl_shm_buffer_get_stride(struct wl_shm_buffer *buffer)
wl_shm_buffer_get_format
uint32_t wl_shm_buffer_get_format(struct wl_shm_buffer *buffer)
wl_shm_buffer_get_width
int32_t wl_shm_buffer_get_width(struct wl_shm_buffer *buffer)
wl_shm_buffer_get_height
int32_t wl_shm_buffer_get_height(struct wl_shm_buffer *buffer)
WL_EXPORT + - +Visibility attribute.
WL_DEPRECATED + - +Deprecated attribute.
WL_PRINTF + - +Printf-style argument attribute.
x
+Ordinality of the format string argument
y
+Ordinality of the argument to check against the format string

+ + See also: https://gcc.gnu.org/onlinedocs/gcc-3.2.1/gcc/Function-Attributes.html +

wl_container_of + - +Retrieves a pointer to a containing struct, given a member name.

This macro allows "conversion" from a pointer to a member to its containing struct. This is useful if you have a contained item like a wl_list, wl_listener, or wl_signal, provided via a callback or other means, and would like to retrieve the struct that contains it.

To demonstrate, the following example retrieves a pointer to example_container given only its destroy_listener member:

+

struct example_container {
+        struct wl_listener destroy_listener;
+        // other members...
+};
+
+void example_container_destroy(struct wl_listener *listener, void *data)
+{
+        struct example_container *ctr;
+
+        ctr = wl_container_of(listener, ctr, destroy_listener);
+        // destroy ctr...
+}
+

+

Note: sample need not be a valid pointer. A null or uninitialised pointer is sufficient. +

ptr
+Valid pointer to the contained member
sample
+Pointer to a struct whose type contains ptr
member
+Named location of ptr within the sample type

+

Returns:
The container for the specified pointer

+

wl_iterator_result + - +Return value of an iterator function.

+ See also: wl_client_for_each_resource_iterator_func_t + + See also: wl_client_for_each_resource +

wl_fixed_t + - +Fixed-point number.
typedef int32_t wl_fixed_t

A wl_fixed_t is a 24.8 signed fixed-point number with a sign bit, 23 bits of integer precision and 8 bits of decimal precision. Consider wl_fixed_t as an opaque struct with methods that facilitate conversion to and from double and int types.

wl_dispatcher_func_t + - +Dispatcher function type alias.
typedef int(* wl_dispatcher_func_t) (const void *, void *, uint32_t, const struct wl_message *, union wl_argument *))(const void *, void *, uint32_t, const struct wl_message *, union wl_argument *)

A dispatcher is a function that handles the emitting of callbacks in client code. For programs directly using the C library, this is done by using libffi to call function pointers. When binding to languages other than C, dispatchers provide a way to abstract the function calling process to be friendlier to other function calling systems.

A dispatcher takes five arguments: The first is the dispatcher-specific implementation associated with the target object. The second is the object upon which the callback is being invoked (either wl_proxy or wl_resource). The third and fourth arguments are the opcode and the wl_message corresponding to the callback. The final argument is an array of arguments received from the other process via the wire protocol.

const void *
+Dispatcher-specific implementation data
void *
+Callback invocation target (wl_proxy or wl_resource)
uint32_t
+Callback opcode
const struct wl_message *
+Callback message signature
union wl_argument *
+Array of received arguments

+

Returns:
0 on success, or -1 on failure

+

wl_log_func_t + - +Log function type alias.
typedef void(* wl_log_func_t) (const char *, va_list))(const char *, va_list)

The C implementation of the Wayland protocol abstracts the details of logging. Users may customize the logging behavior, with a function conforming to the wl_log_func_t type, via wl_log_set_handler_client and wl_log_set_handler_server.

A wl_log_func_t must conform to the expectations of vprintf, and expects two arguments: a string to write and a corresponding variable argument list. While the string to write may contain format specifiers and use values in the variable argument list, the behavior of any wl_log_func_t depends on the implementation.

Note: Take care to not confuse this with wl_protocol_logger_func_t, which is a specific server-side logger for requests and events. +

const char *
+String to write to the log, containing optional format specifiers
va_list
+Variable argument list

+ + See also: wl_log_set_handler_client + + See also: wl_log_set_handler_server +

diff --git a/docs/html/ch01.html b/docs/html/ch01.html new file mode 100644 index 0000000000000000000000000000000000000000..ac01b2fd6c58f6d6a1c3aeda6171a75d651c1ee9 --- /dev/null +++ b/docs/html/ch01.html @@ -0,0 +1,73 @@ +Chapter 1. Introduction

Chapter 1. Introduction

Table of Contents

Motivation
The compositing manager as the display server

Motivation

+ Most Linux and Unix-based systems rely on the X Window System (or + simply X) as the low-level protocol for building + bitmap graphics interfaces. On these systems, the X stack has grown to + encompass functionality arguably belonging in client libraries, + helper libraries, or the host operating system kernel. Support for + things like PCI resource management, display configuration management, + direct rendering, and memory management has been integrated into the X + stack, imposing limitations like limited support for standalone + applications, duplication in other projects (e.g. the Linux fb layer + or the DirectFB project), and high levels of complexity for systems + combining multiple elements (for example radeon memory map handling + between the fb driver and X driver, or VT switching). +

+ Moreover, X has grown to incorporate modern features like offscreen + rendering and scene composition, but subject to the limitations of the + X architecture. For example, the X implementation of composition adds + additional context switches and makes things like input redirection + difficult. +

X architecture diagram

+ The diagram above illustrates the central role of the X server and + compositor in operations, and the steps required to get contents on to + the screen. +

+ Over time, X developers came to understand the shortcomings of this + approach and worked to split things up. Over the past several years, + a lot of functionality has moved out of the X server and into + client-side libraries or kernel drivers. One of the first components + to move out was font rendering, with freetype and fontconfig providing + an alternative to the core X fonts. Direct rendering OpenGL as a + graphics driver in a client side library went through some iterations, + ending up as DRI2, which abstracted most of the direct rendering + buffer management from client code. Then cairo came along and provided + a modern 2D rendering library independent of X, and compositing + managers took over control of the rendering of the desktop as toolkits + like GTK+ and Qt moved away from using X APIs for rendering. Recently, + memory and display management have moved to the Linux kernel, further + reducing the scope of X and its driver stack. The end result is a + highly modular graphics stack. +

The compositing manager as the display server

+ Wayland is a new display server and compositing protocol, and Weston + is the implementation of this protocol which builds on top of all the + components above. We are trying to distill out the functionality in + the X server that is still used by the modern Linux desktop. This + turns out to be not a whole lot. Applications can allocate their own + off-screen buffers and render their window contents directly, using + hardware accelerated libraries like libGL, or high quality software + implementations like those found in Cairo. In the end, what’s needed + is a way to present the resulting window surface for display, and a + way to receive and arbitrate input among multiple clients. This is + what Wayland provides, by piecing together the components already in + the eco-system in a slightly different way. +

+ X will always be relevant, in the same way Fortran compilers and VRML + browsers are, but it’s time that we think about moving it out of the + critical path and provide it as an optional component for legacy + applications. +

+ Overall, the philosophy of Wayland is to provide clients with a way to + manage windows and how their contents is displayed. Rendering is left + to clients, and system wide memory management interfaces are used to + pass buffer handles between clients and the compositing manager. +

Wayland architecture diagram

+ The figure above illustrates how Wayland clients interact with a + Wayland server. Note that window management and composition are + handled entirely in the server, significantly reducing complexity + while marginally improving performance through reduced context + switching. The resulting system is easier to build and extend than a + similar X system, because often changes need only be made in one + place. Or in the case of protocol extensions, two (rather than 3 or 4 + in the X case where window management and/or composition handling may + also need to be updated). +

diff --git a/docs/html/ch02.html b/docs/html/ch02.html new file mode 100644 index 0000000000000000000000000000000000000000..1aec41667d2f4062c600ce858152234fb8f2b2a0 --- /dev/null +++ b/docs/html/ch02.html @@ -0,0 +1,77 @@ +Chapter 2. Types of Compositors

Chapter 2. Types of Compositors

Table of Contents

System Compositor
Session Compositor
Embedding Compositor

+ Compositors come in different types, depending on which + role they play in the overall architecture of the OS. + For instance, a + system compositor + can be used for booting the system, handling multiple user switching, a + possible console terminal emulator and so forth. A different compositor, a + session compositor + would provide the actual desktop environment. There are many ways for + different types of compositors to co-exist. +

+ In this section, we introduce three types of Wayland compositors relying + on libwayland-server. +

System Compositor

+ A system compositor can run from early boot until shutdown. + It effectively replaces the kernel vt system, and can tie in + with the systems graphical boot setup and multiseat support. +

+ A system compositor can host different types of session + compositors, and let us switch between multiple sessions + (fast user switching, or secure/personal desktop switching). +

+ A linux implementation of a system compositor will typically + use libudev, egl, kms, evdev and cairo. +

+ For fullscreen clients, the system compositor can reprogram the + video scanout address to read directly from the client provided + buffer. +

Session Compositor

+ A session compositor is responsible for a single user session. + If a system compositor is present, the session compositor will + run nested under the system compositor. Nesting is feasible because + the protocol is asynchronous; roundtrips would be too expensive + when nesting is involved. If no system compositor is present, a + session compositor can run directly on the hw. +

+ X applications can continue working under a session compositor + by means of a root-less X server that is activated on demand. +

+ Possible examples for session compositors include +

  • + gnome-shell +

  • + moblin +

  • + kwin +

  • + kmscon +

  • + rdp session +

  • + Weston with X11 or Wayland backend is a session compositor nested + in another session compositor. +

  • + fullscreen X session under Wayland +

+

Embedding Compositor

+ X11 lets clients embed windows from other clients, or lets clients + copy pixmap contents rendered by another client into their window. + This is often used for applets in a panel, browser plugins and similar. + Wayland doesn't directly allow this, but clients can communicate GEM + buffer names out-of-band, for example, using D-Bus, or command line + arguments when the panel launches the applet. Another option is to + use a nested Wayland instance. For this, the Wayland server will have + to be a library that the host application links to. The host + application will then pass the Wayland server socket name to the + embedded application, and will need to implement the Wayland + compositor interface. The host application composites the client + surfaces as part of it's window, that is, in the web page or in the + panel. The benefit of nesting the Wayland server is that it provides + the requests the embedded client needs to inform the host about buffer + updates and a mechanism for forwarding input events from the host + application. +

+ An example for this kind of setup is firefox embedding the flash + player as a kind of special-purpose compositor. +

diff --git a/docs/html/ch03.html b/docs/html/ch03.html new file mode 100644 index 0000000000000000000000000000000000000000..9b6de010e18e0c103ababc916c0e7cdfc6d4c5bc --- /dev/null +++ b/docs/html/ch03.html @@ -0,0 +1,237 @@ +Chapter 3. Wayland Architecture

Chapter 3. Wayland Architecture

Table of Contents

X vs. Wayland Architecture
Wayland Rendering
Hardware Enabling for Wayland

X vs. Wayland Architecture

+ A good way to understand the Wayland architecture + and how it is different from X is to follow an event + from the input device to the point where the change + it affects appears on screen. +

+ This is where we are now with X: +

Figure 3.1. X architecture diagram

X architecture diagram

+

  1. + The kernel gets an event from an input + device and sends it to X through the evdev + input driver. The kernel does all the hard + work here by driving the device and + translating the different device specific + event protocols to the linux evdev input + event standard. +

  2. + The X server determines which window the + event affects and sends it to the clients + that have selected for the event in question + on that window. The X server doesn't + actually know how to do this right, since + the window location on screen is controlled + by the compositor and may be transformed in + a number of ways that the X server doesn't + understand (scaled down, rotated, wobbling, + etc). +

  3. + The client looks at the event and decides + what to do. Often the UI will have to change + in response to the event - perhaps a check + box was clicked or the pointer entered a + button that must be highlighted. Thus the + client sends a rendering request back to the + X server. +

  4. + When the X server receives the rendering + request, it sends it to the driver to let it + program the hardware to do the rendering. + The X server also calculates the bounding + region of the rendering, and sends that to + the compositor as a damage event. +

  5. + The damage event tells the compositor that + something changed in the window and that it + has to recomposite the part of the screen + where that window is visible. The compositor + is responsible for rendering the entire + screen contents based on its scenegraph and + the contents of the X windows. Yet, it has + to go through the X server to render this. +

  6. + The X server receives the rendering requests + from the compositor and either copies the + compositor back buffer to the front buffer + or does a pageflip. In the general case, the + X server has to do this step so it can + account for overlapping windows, which may + require clipping and determine whether or + not it can page flip. However, for a + compositor, which is always fullscreen, this + is another unnecessary context switch. +

+

+ As suggested above, there are a few problems with this + approach. The X server doesn't have the information to + decide which window should receive the event, nor can it + transform the screen coordinates to window-local + coordinates. And even though X has handed responsibility for + the final painting of the screen to the compositing manager, + X still controls the front buffer and modesetting. Most of + the complexity that the X server used to handle is now + available in the kernel or self contained libraries (KMS, + evdev, mesa, fontconfig, freetype, cairo, Qt etc). In + general, the X server is now just a middle man that + introduces an extra step between applications and the + compositor and an extra step between the compositor and the + hardware. +

+ In Wayland the compositor is the display server. We transfer + the control of KMS and evdev to the compositor. The Wayland + protocol lets the compositor send the input events directly + to the clients and lets the client send the damage event + directly to the compositor: +

Figure 3.2. Wayland architecture diagram

Wayland architecture diagram

+

  1. + The kernel gets an event and sends + it to the compositor. This + is similar to the X case, which is + great, since we get to reuse all the + input drivers in the kernel. +

  2. + The compositor looks through its + scenegraph to determine which window + should receive the event. The + scenegraph corresponds to what's on + screen and the compositor + understands the transformations that + it may have applied to the elements + in the scenegraph. Thus, the + compositor can pick the right window + and transform the screen coordinates + to window-local coordinates, by + applying the inverse + transformations. The types of + transformation that can be applied + to a window is only restricted to + what the compositor can do, as long + as it can compute the inverse + transformation for the input events. +

  3. + As in the X case, when the client + receives the event, it updates the + UI in response. But in the Wayland + case, the rendering happens in the + client, and the client just sends a + request to the compositor to + indicate the region that was + updated. +

  4. + The compositor collects damage + requests from its clients and then + recomposites the screen. The + compositor can then directly issue + an ioctl to schedule a pageflip with + KMS. +

+

Wayland Rendering

+ One of the details I left out in the above overview + is how clients actually render under Wayland. By + removing the X server from the picture we also + removed the mechanism by which X clients typically + render. But there's another mechanism that we're + already using with DRI2 under X: direct rendering. + With direct rendering, the client and the server + share a video memory buffer. The client links to a + rendering library such as OpenGL that knows how to + program the hardware and renders directly into the + buffer. The compositor in turn can take the buffer + and use it as a texture when it composites the + desktop. After the initial setup, the client only + needs to tell the compositor which buffer to use and + when and where it has rendered new content into it. +

+ This leaves an application with two ways to update its window contents: +

+

  1. + Render the new content into a new buffer and tell the compositor + to use that instead of the old buffer. The application can + allocate a new buffer every time it needs to update the window + contents or it can keep two (or more) buffers around and cycle + between them. The buffer management is entirely under + application control. +

  2. + Render the new content into the buffer that it previously + told the compositor to to use. While it's possible to just + render directly into the buffer shared with the compositor, + this might race with the compositor. What can happen is that + repainting the window contents could be interrupted by the + compositor repainting the desktop. If the application gets + interrupted just after clearing the window but before + rendering the contents, the compositor will texture from a + blank buffer. The result is that the application window will + flicker between a blank window or half-rendered content. The + traditional way to avoid this is to render the new content + into a back buffer and then copy from there into the + compositor surface. The back buffer can be allocated on the + fly and just big enough to hold the new content, or the + application can keep a buffer around. Again, this is under + application control. +

+

+ In either case, the application must tell the compositor + which area of the surface holds new contents. When the + application renders directly to the shared buffer, the + compositor needs to be noticed that there is new content. + But also when exchanging buffers, the compositor doesn't + assume anything changed, and needs a request from the + application before it will repaint the desktop. The idea + that even if an application passes a new buffer to the + compositor, only a small part of the buffer may be + different, like a blinking cursor or a spinner. +

Hardware Enabling for Wayland

+ Typically, hardware enabling includes modesetting/display + and EGL/GLES2. On top of that Wayland needs a way to share + buffers efficiently between processes. There are two sides + to that, the client side and the server side. +

+ On the client side we've defined a Wayland EGL platform. In + the EGL model, that consists of the native types + (EGLNativeDisplayType, EGLNativeWindowType and + EGLNativePixmapType) and a way to create those types. In + other words, it's the glue code that binds the EGL stack and + its buffer sharing mechanism to the generic Wayland API. The + EGL stack is expected to provide an implementation of the + Wayland EGL platform. The full API is in the wayland-egl.h + header. The open source implementation in the mesa EGL stack + is in wayland-egl.c and platform_wayland.c. +

+ Under the hood, the EGL stack is expected to define a + vendor-specific protocol extension that lets the client side + EGL stack communicate buffer details with the compositor in + order to share buffers. The point of the wayland-egl.h API + is to abstract that away and just let the client create an + EGLSurface for a Wayland surface and start rendering. The + open source stack uses the drm Wayland extension, which lets + the client discover the drm device to use and authenticate + and then share drm (GEM) buffers with the compositor. +

+ The server side of Wayland is the compositor and core UX for + the vertical, typically integrating task switcher, app + launcher, lock screen in one monolithic application. The + server runs on top of a modesetting API (kernel modesetting, + OpenWF Display or similar) and composites the final UI using + a mix of EGL/GLES2 compositor and hardware overlays if + available. Enabling modesetting, EGL/GLES2 and overlays is + something that should be part of standard hardware bringup. + The extra requirement for Wayland enabling is the + EGL_WL_bind_wayland_display extension that lets the + compositor create an EGLImage from a generic Wayland shared + buffer. It's similar to the EGL_KHR_image_pixmap extension + to create an EGLImage from an X pixmap. +

+ The extension has a setup step where you have to bind the + EGL display to a Wayland display. Then as the compositor + receives generic Wayland buffers from the clients (typically + when the client calls eglSwapBuffers), it will be able to + pass the struct wl_buffer pointer to eglCreateImageKHR as + the EGLClientBuffer argument and with EGL_WAYLAND_BUFFER_WL + as the target. This will create an EGLImage, which can then + be used by the compositor as a texture or passed to the + modesetting code to use as an overlay plane. Again, this is + implemented by the vendor specific protocol extension, which + on the server side will receive the driver specific details + about the shared buffer and turn that into an EGL image when + the user calls eglCreateImageKHR. +

diff --git a/docs/html/ch04.html b/docs/html/ch04.html new file mode 100644 index 0000000000000000000000000000000000000000..3a16f2bc4bb65a232d7a961fb858b1758ba5091b --- /dev/null +++ b/docs/html/ch04.html @@ -0,0 +1,381 @@ +Chapter 4. Wayland Protocol and Model of Operation

Chapter 4. Wayland Protocol and Model of Operation

Table of Contents

Basic Principles
Code Generation
Wire Format
Interfaces
Versioning
Connect Time
Security and Authentication
Creating Objects
Compositor
Surfaces
Input
Output
Data sharing between clients

Basic Principles

+ The Wayland protocol is an asynchronous object oriented protocol. All + requests are method invocations on some object. The requests include + an object ID that uniquely identifies an object on the server. Each + object implements an interface and the requests include an opcode that + identifies which method in the interface to invoke. +

+ The protocol is message-based. A message sent by a client to the server + is called request. A message from the server to a client is called event. + A message has a number of arguments, each of which has a certain type (see + the section called “Wire Format” for a list of argument types). +

+ Additionally, the protocol can specify enums which associate + names to specific numeric enumeration values. These are primarily just + descriptive in nature: at the wire format level enums are just integers. + But they also serve a secondary purpose to enhance type safety or + otherwise add context for use in language bindings or other such code. + This latter usage is only supported so long as code written before these + attributes were introduced still works after; in other words, adding an + enum should not break API, otherwise it puts backwards compatibility at + risk. +

+ enums can be defined as just a set of integers, or as + bitfields. This is specified via the bitfield boolean + attribute in the enum definition. If this attribute is true, + the enum is intended to be accessed primarily using bitwise operations, + for example when arbitrarily many choices of the enum can be ORed + together; if it is false, or the attribute is omitted, then the enum + arguments are a just a sequence of numerical values. +

+ The enum attribute can be used on either uint + or int arguments, however if the enum is + defined as a bitfield, it can only be used on + uint args. +

+ The server sends back events to the client, each event is emitted from + an object. Events can be error conditions. The event includes the + object ID and the event opcode, from which the client can determine + the type of event. Events are generated both in response to requests + (in which case the request and the event constitutes a round trip) or + spontaneously when the server state changes. +

+

  • + State is broadcast on connect, events are sent + out when state changes. Clients must listen for + these changes and cache the state. + There is no need (or mechanism) to query server state. +

  • + The server will broadcast the presence of a number of global objects, + which in turn will broadcast their current state. +

+

Code Generation

+ The interfaces, requests and events are defined in + protocol/wayland.xml. + This xml is used to generate the function prototypes that can be used by + clients and compositors. +

+ The protocol entry points are generated as inline functions which just + wrap the wl_proxy_* functions. The inline functions aren't + part of the library ABI and language bindings should generate their + own stubs for the protocol entry points from the xml. +

Wire Format

+ The protocol is sent over a UNIX domain stream socket, where the endpoint + usually is named wayland-0 + (although it can be changed via WAYLAND_DISPLAY + in the environment). Beginning in Wayland 1.15, implementations can + optionally support server socket endpoints located at arbitrary + locations in the filesystem by setting WAYLAND_DISPLAY + to the absolute path at which the server endpoint listens. +

+ Every message is structured as 32-bit words; values are represented in the + host's byte-order. The message header has 2 words in it: +

  • + The first word is the sender's object ID (32-bit). +

  • + The second has 2 parts of 16-bit. The upper 16-bits are the message + size in bytes, starting at the header (i.e. it has a minimum value of 8).The lower is the request/event opcode. +

+ The payload describes the request/event arguments. Every argument is always + aligned to 32-bits. Where padding is required, the value of padding bytes is + undefined. There is no prefix that describes the type, but it is + inferred implicitly from the xml specification. +

+ + The representation of argument types are as follows: +

int, uint

+ The value is the 32-bit value of the signed/unsigned + int. +

fixed

+ Signed 24.8 decimal numbers. It is a signed decimal type which + offers a sign bit, 23 bits of integer precision and 8 bits of + decimal precision. This is exposed as an opaque struct with + conversion helpers to and from double and int on the C API side. +

string

+ Starts with an unsigned 32-bit length, followed by the + string contents, including terminating null byte, then padding + to a 32-bit boundary. +

object

+ 32-bit object ID. +

new_id

+ The 32-bit object ID. On requests, the client + decides the ID. The only events with new_id are + advertisements of globals, and the server will use IDs below + 0x10000. +

array

+ Starts with 32-bit array size in bytes, followed by the array + contents verbatim, and finally padding to a 32-bit boundary. +

fd

+ The file descriptor is not stored in the message buffer, but in + the ancillary data of the UNIX domain socket message (msg_control). +

+

Interfaces

+ The protocol includes several interfaces which are used for + interacting with the server. Each interface provides requests, + events, and errors (which are really just special events) as described + above. Specific compositor implementations may have their own + interfaces provided as extensions, but there are several which are + always expected to be present. +

+ Core interfaces: +

wl_display
core global object
wl_registry
global registry object
wl_callback
callback object
wl_compositor
the compositor singleton
wl_shm_pool
a shared memory pool
wl_shm
shared memory support
wl_buffer
content for a wl_surface
wl_data_offer
offer to transfer data
wl_data_source
offer to transfer data
wl_data_device
data transfer device
wl_data_device_manager
data transfer interface
wl_shell
create desktop-style surfaces
wl_shell_surface
desktop-style metadata interface
wl_surface
an onscreen surface
wl_seat
group of input devices
wl_pointer
pointer input device
wl_keyboard
keyboard input device
wl_touch
touchscreen input device
wl_output
compositor output region
wl_region
region interface
wl_subcompositor
sub-surface compositing
wl_subsurface
sub-surface interface to a wl_surface

Versioning

+ Every interface is versioned and every protocol object implements a + particular version of its interface. For global objects, the maximum + version supported by the server is advertised with the global and the + actual version of the created protocol object is determined by the + version argument passed to wl_registry.bind(). For objects that are + not globals, their version is inferred from the object that created + them. +

+ In order to keep things sane, this has a few implications for + interface versions: +

  • + The object creation hierarchy must be a tree. Otherwise, + infering object versions from the parent object becomes a much + more difficult to properly track. +

  • + When the version of an interface increases, so does the version + of its parent (recursively until you get to a global interface) +

  • + A global interface's version number acts like a counter for all + of its child interfaces. Whenever a child interface gets + modified, the global parent's interface version number also + increases (see above). The child interface then takes on the + same version number as the new version of its parent global + interface. +

+

+ To illustrate the above, consider the wl_compositor interface. It + has two children, wl_surface and wl_region. As of wayland version + 1.2, wl_surface and wl_compositor are both at version 3. If + something is added to the wl_region interface, both wl_region and + wl_compositor will get bumpped to version 4. If, afterwards, + wl_surface is changed, both wl_compositor and wl_surface will be at + version 5. In this way the global interface version is used as a + sort of "counter" for all of its child interfaces. This makes it + very simple to know the version of the child given the version of its + parent. The child is at the highest possible interface version that + is less than or equal to its parent's version. +

+ It is worth noting a particular exception to the above versioning + scheme. The wl_display (and, by extension, wl_registry) interface + cannot change because it is the core protocol object and its version + is never advertised nor is there a mechanism to request a different + version. +

Connect Time

+ There is no fixed connection setup information, the server emits + multiple events at connect time, to indicate the presence and + properties of global objects: outputs, compositor, input devices. +

Security and Authentication

+

  • + mostly about access to underlying buffers, need new drm auth + mechanism (the grant-to ioctl idea), need to check the cmd stream? +

  • + getting the server socket depends on the compositor type, could + be a system wide name, through fd passing on the session dbus. + or the client is forked by the compositor and the fd is + already opened. +

+

Creating Objects

+ Each object has a unique ID. The IDs are allocated by the entity + creating the object (either client or server). IDs allocated by the + client are in the range [1, 0xfeffffff] while IDs allocated by the + server are in the range [0xff000000, 0xffffffff]. The 0 ID is + reserved to represent a null or non-existant object. + + For efficiency purposes, the IDs are densely packed in the sense that + the ID N will not be used until N-1 has been used. Any ID allocation + algorithm that does not maintain this property is incompatible with + the implementation in libwayland. +

Compositor

+ The compositor is a global object, advertised at connect time. +

+ See the section called “wl_compositor + - the compositor singleton” for the + protocol description. +

Surfaces

+ A surface manages a rectangular grid of pixels that clients create + for displaying their content to the screen. Clients don't know + the global position of their surfaces, and cannot access other + clients' surfaces. +

+ Once the client has finished writing pixels, it 'commits' the + buffer; this permits the compositor to access the buffer and read + the pixels. When the compositor is finished, it releases the + buffer back to the client. +

+ See the section called “wl_surface + - an onscreen surface” for the protocol + description. +

Input

+ A seat represents a group of input devices including mice, + keyboards and touchscreens. It has a keyboard and pointer + focus. Seats are global objects. Pointer events are delivered + in surface-local coordinates. +

+ The compositor maintains an implicit grab when a button is + pressed, to ensure that the corresponding button release + event gets delivered to the same surface. But there is no way + for clients to take an explicit grab. Instead, surfaces can + be mapped as 'popup', which combines transient window semantics + with a pointer grab. +

+ To avoid race conditions, input events that are likely to + trigger further requests (such as button presses, key events, + pointer motions) carry serial numbers, and requests such as + wl_surface.set_popup require that the serial number of the + triggering event is specified. The server maintains a + monotonically increasing counter for these serial numbers. +

+ Input events also carry timestamps with millisecond granularity. + Their base is undefined, so they can't be compared against + system time (as obtained with clock_gettime or gettimeofday). + They can be compared with each other though, and for instance + be used to identify sequences of button presses as double + or triple clicks. +

+ See the section called “wl_seat + - group of input devices” for the + protocol description. +

+ Talk about: + +

  • + keyboard map, change events +

  • + xkb on Wayland +

  • + multi pointer Wayland +

+

+ A surface can change the pointer image when the surface is the pointer + focus of the input device. Wayland doesn't automatically change the + pointer image when a pointer enters a surface, but expects the + application to set the cursor it wants in response to the pointer + focus and motion events. The rationale is that a client has to manage + changing pointer images for UI elements within the surface in response + to motion events anyway, so we'll make that the only mechanism for + setting or changing the pointer image. If the server receives a request + to set the pointer image after the surface loses pointer focus, the + request is ignored. To the client this will look like it successfully + set the pointer image. +

+ The compositor will revert the pointer image back to a default image + when no surface has the pointer focus for that device. Clients can + revert the pointer image back to the default image by setting a NULL + image. +

+ What if the pointer moves from one window which has set a special + pointer image to a surface that doesn't set an image in response to + the motion event? The new surface will be stuck with the special + pointer image. We can't just revert the pointer image on leaving a + surface, since if we immediately enter a surface that sets a different + image, the image will flicker. Broken app, I suppose. +

Output

+ An output is a global object, advertised at connect time or as it + comes and goes. +

+ See the section called “wl_output + - compositor output region” for the protocol + description. +

+

  • + laid out in a big (compositor) coordinate system +

  • + basically xrandr over Wayland +

  • + geometry needs position in compositor coordinate system +

  • + events to advertise available modes, requests to move and change + modes +

Data sharing between clients

+ The Wayland protocol provides clients a mechanism for sharing + data that allows the implementation of copy-paste and + drag-and-drop. The client providing the data creates a + wl_data_source object and the clients + obtaining the data will see it as wl_data_offer + object. This interface allows the clients to agree on a mutually + supported mime type and transfer the data via a file descriptor + that is passed through the protocol. +

+ The next section explains the negotiation between data source and + data offer objects. the section called “Data devices” + explains how these objects are created and passed to different + clients using the wl_data_device interface + that implements copy-paste and drag-and-drop support. +

+ See the section called “wl_data_offer + - offer to transfer data”, + the section called “wl_data_source + - offer to transfer data”, + the section called “wl_data_device + - data transfer device” and + the section called “wl_data_device_manager + - data transfer interface” for + protocol descriptions. +

+ MIME is defined in RFC's 2045-2049. A + + registry of MIME types is maintained by the Internet Assigned + Numbers Authority (IANA). +

Data negotiation

+ A client providing data to other clients will create a wl_data_source + object and advertise the mime types for the formats it supports for + that data through the wl_data_source.offer + request. On the receiving end, the data offer object will generate one + wl_data_offer.offer event for each supported mime + type. +

+ The actual data transfer happens when the receiving client sends a + wl_data_offer.receive request. This request takes + a mime type and a file descriptor as arguments. This request will generate a + wl_data_source.send event on the sending client + with the same arguments, and the latter client is expected to write its + data to the given file descriptor using the chosen mime type. +

Data devices

+ Data devices glue data sources and offers together. A data device is + associated with a wl_seat and is obtained by the clients using the + wl_data_device_manager factory object, which is also responsible for + creating data sources. +

+ Clients are informed of new data offers through the + wl_data_device.data_offer event. After this + event is generated the data offer will advertise the available mime + types. New data offers are introduced prior to their use for + copy-paste or drag-and-drop. +

Selection

+ Each data device has a selection data source. Clients create a data + source object using the device manager and may set it as the + current selection for a given data device. Whenever the current + selection changes, the client with keyboard focus receives a + wl_data_device.selection event. This event is + also generated on a client immediately before it receives keyboard + focus. +

+ The data offer is introduced with + wl_data_device.data_offer event before the + selection event. +

Drag and Drop

+ A drag-and-drop operation is started using the + wl_data_device.start_drag request. This + requests causes a pointer grab that will generate enter, motion and + leave events on the data device. A data source is supplied as + argument to start_drag, and data offers associated with it are + supplied to clients surfaces under the pointer in the + wl_data_device.enter event. The data offer + is introduced to the client prior to the enter event with the + wl_data_device.data_offer event. +

+ Clients are expected to provide feedback to the data sending client + by calling the wl_data_offer.accept request with + a mime type it accepts. If none of the advertised mime types is + supported by the receiving client, it should supply NULL to the + accept request. The accept request causes the sending client to + receive a wl_data_source.target event with the + chosen mime type. +

+ When the drag ends, the receiving client receives a + wl_data_device.drop event at which it is expected + to transfer the data using the + wl_data_offer.receive request. +

diff --git a/docs/html/ch05.html b/docs/html/ch05.html new file mode 100644 index 0000000000000000000000000000000000000000..d3df824ba03846431838d478209e40d25df6a0e7 --- /dev/null +++ b/docs/html/ch05.html @@ -0,0 +1,120 @@ +Chapter 5. X11 Application Support

Chapter 5. X11 Application Support

Table of Contents

Introduction
Two Modes for Foreign Windows
Architecture
X Window Manager (XWM)

Introduction

+ Being able to run existing X11 applications is crucial for the adoption + of Wayland, especially on desktops, as there will always be X11 + applications that have not been or cannot be converted into Wayland + applications, and throwing them all away would be prohibitive. + Therefore a Wayland compositor often needs to support running X11 + applications. +

+ X11 and Wayland are different enough that there is no "simple" way to + translate between them. Most of X11 is uninteresting to a Wayland + compositor. That, combined with the gigantic implementation effort needed + to support X11, makes it intractable to just write X11 support directly in + a Wayland compositor. The implementation would be nothing short of a + real X11 server. +

+ Therefore, Wayland compositors should use Xwayland, the X11 server that + lives in the Xorg server source code repository and shares most of the + implementation with the Xorg server. Xwayland is a complete X11 server, + just like Xorg is, but instead of driving the displays and opening input + devices, it acts as a Wayland client. The rest of this chapter talks + about how Xwayland works. +

+ For integration and architecture reasons, while Xwayland is a Wayland + client of the Wayland compositor, the Wayland compositor is an X11 client + of Xwayland. This circular dependency requires special care from the + Wayland compositor. +

Two Modes for Foreign Windows

+ In general, windows from a foreign window system can be presented in one + of two ways: rootless and rootful (not rootless). +

+ In rootful mode, the foreign window system as a whole is represented as a + window (or more) of its own. You have a native window, inside which all + the foreign windows are. The advantage of this approach in Xwayland's + case is that you can run your favourite X11 window manager to manage your + X11 applications. The disadvantage is that the foreign windows do not + integrate with the native desktop. Therefore this mode is not usually + used. +

+ In rootless mode, each foreign window is a first-class resident among the + native windows. Foreign windows are not confined inside a native window + but act as if they were native windows. The advantage is that one can + freely stack and mix native and foreign windows, which is not possible in + rootful mode. The disadvantage is that this mode is harder to implement + and fundamental differences in window systems may prevent some things + from working. With rootless Xwayland, the Wayland compositor must take + the role as the X11 window manager, and one cannot use any other X11 + window manager in its place. +

+ This chapter concentrates on the rootless mode, and ignores the rootful + mode. +

Architecture

+ A Wayland compositor usually takes care of launching Xwayland. + Xwayland works in cooperation with a Wayland compositor as follows: +

Figure 5.1. Xwayland architecture diagram

Xwayland architecture diagram

+ An X11 application connects to Xwayland just like it would connect to any + X server. Xwayland processes all the X11 requests. On the other end, + Xwayland is a Wayland client that connects to the Wayland compositor. +

+ The X11 window manager (XWM) is an integral part of the Wayland + compositor. XWM uses the usual X11 window management protocol to manage + all X11 windows in Xwayland. Most importantly, XWM acts as a bridge + between Xwayland window state and the Wayland compositor's window manager + (WWM). This way WWM can manage all windows, both native Wayland and X11 + (Xwayland) windows. This is very important for a coherent user + experience. +

+ Since Xwayland uses Wayland for input and output, it does not have any + use for the device drivers that Xorg uses. None of the xf86-video-* or + xf86-input-* modules are used. There also is no configuration file for + the Xwayland server. For optional hardware accelerated rendering, + Xwayland uses GLAMOR. +

+ A Wayland compositor usually spawns only one Xwayland instance. This is + because many X11 applications assume they can communicate with other X11 + applications through the X server, and this requires a shared X server + instance. This also means that Xwayland does not protect nor isolate X11 + clients from each other, unless the Wayland compositor specifically + chooses to break the X11 client intercommunications by spawning + application specific Xwayland instances. X11 clients are naturally + isolated from Wayland clients. +

+ Xwayland compatibility compared to a native X server will probably never + reach 100%. Desktop environment (DE) components, specifically X11 window + managers, are practically never supported. An X11 window manager would + not know about native Wayland windows, so it could manage only X11 + windows. On the other hand, there must be an XWM that reserves the + exclusive window manager role so that the Wayland compositor could show + the X11 windows appropriately. For other DE components, like pagers and + panels, adding the necessary interfaces to support them in WWM through XWM + is often considered not worthwhile. +

X Window Manager (XWM)

+ From the X11 point of view, the X window manager (XWM) living inside a + Wayland compositor is just like any other window manager. The difference + is mostly in which process it resides in, and the few extra conventions + in the X11 protocol to support Wayland window management (WWM) + specifically. +

+ There are two separate asynchronous communication channels between + Xwayland and a Wayland compositor: one uses the Wayland protocol, and the + other one, solely for XWM, uses X11 protocol. This setting demands great + care from the XWM implementation to avoid (random) deadlocks with + Xwayland. It is often nearly impossible to prove that synchronous or + blocking X11 calls from XWM cannot cause a deadlock, and therefore it is + strongly recommended to make all X11 communications asynchronous. All + Wayland communications are already asynchonous by design. +

Window identification

+ In Xwayland, an X11 window may have a corresponding wl_surface object + in Wayland. The wl_surface object is used for input and output: it is + referenced by input events and used to provide the X11 window content + to the Wayland compositor. The X11 window and the wl_surface live in + different protocol streams, and they need to be matched for XWM to do + its job. +

+ When Xwayland creates a wl_surface on Wayland, it will also send an X11 + ClientMessage of type atom "WL_SURFACE_ID" to the X11 window carrying + the wl_surface Wayland object ID as the first 32-bit data element. This + is how XWM can associate a wl_surface with an X11 window. Note that + the request to create a wl_surface and the ID message may arrive in any + order in the Wayland compositor. +

diff --git a/docs/html/css/brand.css b/docs/html/css/brand.css new file mode 100644 index 0000000000000000000000000000000000000000..d86cba937909435f5cf731e075fef4994cf0dae8 --- /dev/null +++ b/docs/html/css/brand.css @@ -0,0 +1,14 @@ +/*headings*/ +h1, h2, h3, h4, h5, h6, +div.producttitle, +div.subtitle, +div.author div.author, +div.translator div.translator, +div.othercredit div.othercredit, +div.editor div.editor, +div.contrib div.contrib, +.title, +.titlepage .edition, +.titlepage .releaseinfo { + color: #336699; +} diff --git a/docs/html/css/common.css b/docs/html/css/common.css new file mode 100644 index 0000000000000000000000000000000000000000..a05648ef59481afe827e9c1c6fbf95567dc45c35 --- /dev/null +++ b/docs/html/css/common.css @@ -0,0 +1,1769 @@ +* { + widows: 4 !important; + orphans: 4 !important; +} + +body, h1, h2, h3, h4, h5, h6, pre, li, div { + line-height: 1.29em; +} + +body { + background-color: white; + margin:0 auto; + font-family: "liberation sans", "Myriad ", "Bitstream Vera Sans", "Lucida Grande", "Luxi Sans", "Trebuchet MS", helvetica, verdana, arial, sans-serif; + font-size: 14px; + max-width: 770px; + color: black; +} + +body.toc_embeded { + /*for web hosting system only*/ + margin-left: 300px; +} + +object.toc, iframe.toc { + /*for web hosting system only*/ + border-style: none; + position: fixed; + width: 290px; + height: 99.99%; + top: 0; + left: 0; + z-index: 100; + border-style: none; + border-right:1px solid #999; +} + +/* Hide web menu */ + +body.notoc { + margin-left: 3em; +} + +iframe.notoc { + border-style:none; + border: none; + padding: 0px; + position:fixed; + width: 21px; + height: 29px; + top: 0px; + left:0; + overflow: hidden; + margin: 0px; + margin-left: -3px; +} +/* End hide web menu */ + +/* desktop styles */ +body.desktop { + margin-left: 26em; +} + +body.desktop .book > .toc { + display:block; + width:24em; + height:99.99%; + position:fixed; + overflow:auto; + top:0px; + left:0px; +/* padding-left:1em; */ + background-color:#EEEEEE; + font-size: 12px; +} + +body.pdf { + max-width: 100%; +} + +.toc { + line-height:1.35em; +} + +.toc .glossary, +.toc .chapter, .toc .appendix { + margin-top:1em; +} + +.toc .part { + margin-top:1em; + display:block; +} + +span.glossary, +span.appendix { + display:block; + margin-top:0.5em; +} + +div { + padding-top:0px; +} + +div.section { + page-break-inside: avoid; +} + +p, div.para { + padding-top: 0px; + margin-top: 1em; + padding-bottom: 0px; + margin-bottom: 1em; +} + +div.formalpara { + padding-top: 0px; + margin-top: 1em; + padding-bottom: 0px; + margin-bottom: 1em; +} + +.varlistentry div.para { + page-break-before: avoid; + +} + +/*Links*/ +a { + outline: none; +} + +a:link { + text-decoration: none; + border-bottom: 1px dotted ; + color:#3366cc; +} + +body.pdf a:link { + word-wrap: break-word; +} + +a:visited { + text-decoration:none; + border-bottom: 1px dotted ; + color:#003366; +} + +div.longdesc-link { + float:right; + color:#999; +} + +.toc a, .qandaset a { + font-weight:normal; + border:none; +} + +.toc a:hover, .qandaset a:hover +{ + border-bottom: 1px dotted; +} + +/*headings*/ +h1, h2, h3, h4, h5, h6 { + color: #336699; + margin-top: 0px; + margin-bottom: 0px; + background-color: transparent; + margin-bottom: 0px; + margin-top: 20px; + page-break-inside: avoid; + page-break-after: avoid; + word-wrap: break-word; +} + +h1 { + font-size: 22px; +} + +.titlepage h1.title { + text-align:left; +} + +.book > .titlepage h1.title { + text-align: center; +} + +.article > .titlepage h1.title, +.article > .titlepage h2.title { + text-align: center; +} + +.set .titlepage > div > div > h1.title { + text-align: center; +} + +.part > .titlepage h1.title { + text-align: center; + font-size: 24px; +} + +div.producttitle { + margin-top: 0px; + margin-bottom: 20px; + font-size: 48px; + font-weight: bold; +/* background: #003d6e url(../images/h1-bg.png) top left repeat-x; */ + color: #336699; + text-align: center; + padding-top: 12px; +} + +.titlepage .corpauthor { + margin-top: 1em; + text-align: center; +} + +.section h1.title { + font-size: 18px; + padding: 0px; + color: #336699; + text-align: left; + background: white; +} + +h2 { + font-size: 20px; + margin-top: 30px; +} + + +.book div.subtitle, .book h2.subtitle, .book h3.subtitle { + margin-top: 1em; + margin-bottom: 1em; + font-size: 18px; + text-align: center; +} + +div.subtitle { + color: #336699; + font-weight: bold; +} + +h1.legalnotice { + font-size: 24px; +} + +.preface > div > div > div > h2.title, +.preface > div > div > div > h1.title { + margin-top: 1em; + font-size: 24px; +} + +.appendix h2 { + font-size: 24px; +} + + + +h3 { + font-size: 14px; + padding-top:0px; + padding-bottom: 0px; + margin-bottom: 0px; +} +h4 { + font-size: 14px; + padding-top:0px; + padding-bottom:0px; +} + +h5 { + font-size: 14px; +} + +h6 { + font-size: 14px; + margin-bottom: 0px; +} + +.abstract h6 { + margin-top:1em; + margin-bottom:.5em; + font-size: 24px; +} + +.index > div > div > div > h2.title { + font-size: 24px; +} + +.chapter > div > div > div > h2.title { + font-size: 24px; +} + +.section > div > div > div > h2.title { + font-size: 21px; + page-break-inside: avoid; + page-break-before: avoid; + page-break-after: avoid; +} + +.section > div > div > div > h3.title { + font-size: 17px; +} + +/*element rules*/ +hr { + border-collapse: collapse; + border-style:none; + border-top: 1px dotted #ccc; + width:100%; +} + +/* web site rules */ +ul.languages, .languages li { + display:inline; + padding:0px; +} + +.languages li a { + padding:0px .5em; + text-decoration: none; +} + +.languages li p, .languages li div.para { + display:inline; +} + +.languages li a:link, .languages li a:visited { + color:#444; +} + +.languages li a:hover, .languages li a:focus, .languages li a:active { + color:black; +} + +ul.languages { + display:block; + background-color:#eee; + padding:.5em; +} + +/*supporting stylesheets*/ + +/*unique to the webpage only*/ +.books { + position:relative; +} + +.versions li { + width:100%; + clear:both; + display:block; +} + +a.version { + font-size: 20px; + text-decoration:none; + width:100%; + display:block; + padding:1em 0px .2em 0px; + clear:both; +} + +a.version:before { + content:"Version"; + font-size: smaller; +} + +a.version:visited, a.version:link { + color:#666; +} + +a.version:focus, a.version:hover { + color:black; +} + +.books { + display:block; + position:relative; + clear:both; + width:100%; +} + +.books li { + display:block; + width:200px; + float:left; + position:relative; + clear: none ; +} + +.books .html { + width:170px; + display:block; +} + +.books .pdf { + position:absolute; + left:170px; + top:0px; + font-size: smaller; +} + +.books .pdf:link, .books .pdf:visited { + color:#555; +} + +.books .pdf:hover, .books .pdf:focus { + color:#000; +} + +.books li a { + text-decoration:none; +} + +.books li a:hover { + color:black; +} + +/*products*/ +.products li { + display: block; + width:300px; + float:left; +} + +.products li a { + width:300px; + padding:.5em 0px; +} + +.products ul { + clear:both; +} + +/*revision history*/ +.revhistory { + display:block; +} + +.revhistory table { + background-color:transparent; + border-color:#fff; + padding:0px; + margin: 0; + border-collapse:collapse; + border-style:none; +} + +.revhistory td { + text-align :left; + padding:0px; + border: none; + border-top: 1px solid #fff; + font-weight: bold; +} + +.revhistory .simplelist td { + font-weight: normal; +} + +.revhistory .simplelist { + margin-bottom: 1.5em; + margin-left: 1em; +} + +.revhistory table th { + display: none; +} + + +/*credits*/ +.authorgroup div { + clear:both; + text-align: center; +} + +div.author div.author, +div.translator div.translator, +div.othercredit div.othercredit, +div.editor div.editor, +div.contrib div.contrib { + margin: 0px; + padding: 0px; + margin-top: 12px; + font-size: 14px; + font-weight: bold; + color: #336699; +} + +div.editedby { + margin-top: 15px; + margin-bottom: -0.8em; +} + +div.authorgroup .author, +div.authorgroup.editor, +div.authorgroup.translator, +div.authorgroup.othercredit, +div.authorgroup.contrib { + display: block; + font-size: 14px; + page-break-inside: avoid; +} + +.revhistory .author { + display: inline; +} + +.othercredit h3 { + padding-top: 1em; +} + + +.othercredit { + margin:0px; + padding:0px; +} + +.releaseinfo { + clear: both; +} + +.copyright { + margin-top: 1em; +} + +/* qanda sets */ +.answer { + margin-bottom:1em; + border-bottom:1px dotted #ccc; +} + +.qandaset .toc { + border-bottom:1px dotted #ccc; +} + +.question { + font-weight:bold; +} + +.answer .data, .question .data { + padding-left: 2.6em; +} + +.answer .label, .question .label { + float:left; + font-weight:bold; +} + +/* inline syntax highlighting */ +.perl_Alert { + color: #0000ff; +} + +.perl_BaseN { + color: #007f00; +} + +.perl_BString { + color: #5C3566; +} + +.perl_Char { + color: #ff00ff; +} + +.perl_Comment { + color: #888888; +} + + +.perl_DataType { + color: #0000ff; +} + + +.perl_DecVal { + color: #00007f; +} + + +.perl_Error { + color: #ff0000; +} + + +.perl_Float { + color: #00007f; +} + + +.perl_Function { + color: #007f00; +} + + +.perl_IString { + color: #5C3566; +} + + +.perl_Keyword { + color: #002F5D; +} + + +.perl_Operator { + color: #ffa500; +} + + +.perl_Others { + color: #b03060; +} + + +.perl_RegionMarker { + color: #96b9ff; +} + + +.perl_Reserved { + color: #9b30ff; +} + + +.perl_String { + color: #5C3566; +} + + +.perl_Variable { + color: #0000ff; +} + + +.perl_Warning { + color: #0000ff; +} + +/*Lists*/ +ul { + list-style-image: url("../images/dot.png"); + list-style-type: circle; + padding-left: 1.6em; +} + +ul ul { + list-style-image: url("../images/dot2.png"); + list-style-type: circle; +} + +ol.1 { + list-style-type: decimal; +} + +ol.a, +ol ol { + list-style-type: lower-alpha; +} + +ol.i { + list-style-type: lower-roman; +} +ol.A { + list-style-type: upper-alpha; +} + +ol.I { + list-style-type: upper-roman; +} + +dt { + font-weight:bold; + margin-bottom:0px; + padding-bottom:0px; +} + +dd { + margin:0px; + margin-left:2em; + padding-top:0px; +} + +li { + padding-top: 0px; + margin-top: 0px; + padding-bottom: 0px; +/* margin-bottom: 16px; */ +} + +/*images*/ +img { + display:block; + margin: 2em 0; + max-width: 100%; +} + +.inlinemediaobject, +.inlinemediaobject img, +.inlinemediaobject object { + display:inline; + margin:0px; + overflow: hidden; +} + +.figure { + margin-top: 1em; + width: 100%; +} + +.figure img, +.mediaobject img { + display:block; + margin: 0em; + page-break-inside: avoid; +} + +.figure .title { + margin-bottom:2em; + padding:0px; +} + +/*document modes*/ +.confidential { + background-color:#900; + color:White; + padding:.5em .5em; + text-transform:uppercase; + text-align:center; +} + +.longdesc-link { + display:none; +} + +.longdesc { + display:none; +} + +.prompt { + padding:0px .3em; +} + +/*user interface styles*/ +.screen .replaceable { +} + +.guibutton, .guilabel { + font-family: "liberation mono", "bitstream vera mono", "dejavu mono", monospace; + font-weight: bold; +} + +.example { + background-color: #ffffff; + border-left: 3px solid #aaaaaa; + padding-top: 1px; + padding-bottom: 0.1em; + padding-left: 1em; +} + +.equation { + border-left: 3px solid #aaaaaa; + background-color: #ffffff; + padding-top: 1px; + padding-bottom: 0.1em; + padding-left: 1em; +} + +.equation-contents { + margin-left: 4em; +} + +div.title { + margin-bottom: 1em; + font-weight: 14px; + font-weight: bold; + color: #336699; + page-break-inside: avoid; + page-break-after: avoid; + word-wrap: break-word; +} + +.example-contents { + background-color: #ffffff; +} + +.example-contents .para { +/* padding: 10px;*/ +} + +/*terminal/console text*/ +.computeroutput, +.option { + font-family:"liberation mono", "bitstream vera mono", "dejavu mono", monospace; + font-weight:bold; +} + +.replaceable { + font-style: italic; +} + +.command, .filename, .keycap, .classname, .literal { + font-family:"liberation mono", "bitstream vera mono", "dejavu mono", monospace; + font-weight:bold; +} + +/* no bold in toc */ +.toc * { + font-weight: inherit; +} + +.toc H1 { + font-weight: bold; +} + + +div.programlisting { + white-space: pre-wrap; /* css-3 */ + white-space: -moz-pre-wrap !important; /* Mozilla, since 1999 */ + white-space: -pre-wrap; /* Opera 4-6 */ + white-space: -o-pre-wrap; /* Opera 7 */ + word-wrap: break-word; /* Internet Explorer 5.5+ */ +} + +pre { + font-family:"liberation mono", "bitstream vera mono", "dejavu mono", monospace; + display:block; + background-color: #f5f5f5; + color: #000000; +/* border: 1px solid #aaaaaa; */ + margin-bottom: 1em; + padding:.5em 1em; + white-space: pre-wrap; /* css-3 */ + white-space: -moz-pre-wrap !important; /* Mozilla, since 1999 */ + white-space: -pre-wrap; /* Opera 4-6 */ + white-space: -o-pre-wrap; /* Opera 7 */ + word-wrap: break-word; /* Internet Explorer 5.5+ */ + font-size: 0.9em; + border-style:none; + box-shadow: 0 2px 5px #AAAAAA inset; + -moz-box-shadow: 0 2px 5px #AAAAAA inset; + -webkit-box-shadow: 0 2px 5px #AAAAAA inset; + -o-box-shadow: 0 2px 5px #AAAAAA inset; +} + +body.pdf pre { + border: 1px solid #AAAAAA; + box-shadow: none; + -moz-box-shadow: none; + -webkit-box-shadow: none; + -o-box-shadow: none; +} + + +pre .replaceable, +pre .keycap { +} + +code { + font-family:"liberation mono", "bitstream vera mono", "dejavu mono", monospace; + white-space: pre-wrap; + word-wrap: break-word; + font-weight:bold; +} + +.parameter code { + display: inline; + white-space: pre-wrap; /* css-3 */ + white-space: -moz-pre-wrap !important; /* Mozilla, since 1999 */ + white-space: -pre-wrap; /* Opera 4-6 */ + white-space: -o-pre-wrap; /* Opera 7 */ + word-wrap: break-word; /* Internet Explorer 5.5+ */ +} + +code.email { + font-weight: normal; + font-family: "liberation sans", "Myriad ", "Bitstream Vera Sans", "Lucida Grande", "Luxi Sans", "Trebuchet MS", helvetica, verdana, arial, sans-serif; + +} + +/*Notifications*/ +div.warning:before { + content:url(../images/warning.png); + padding-left: 5px; +} + +div.note:before { + content:url(../images/note.png); + padding-left: 5px; +} + +div.important:before { + content:url(../images/important.png); + padding-left: 5px; +} + +div.warning, div.note, div.important { + color: black; + margin: 0px; + padding: 0px; + background: none; + background-color: white; + margin-bottom: 1em; + border-bottom: 1px solid #aaaaaa; + page-break-inside: avoid; +} + +div.admonition_header p { + margin: 0px; + padding: 0px; + color: #eeeeec; + padding-top: 0px; + padding-bottom: 0px; + height: 1.4em; + line-height: 1.4em; + font-size: 17px; + display:inline; +} + +div.admonition_header { + background-origin:content-box; + clear: both; + margin: 0px; + padding: 0px; + margin-top: -40px; + padding-left: 58px; + line-height: 1.0px; + font-size: 1.0px; +} + +div.warning div.admonition_header { + background: url(../images/red.png) top left repeat-x; + background-color: #590000; + background: -webkit-linear-gradient(#a40000,#590000); + background: linear-gradient(#a40000,#590000); +} + +div.note div.admonition_header { + background: url(../images/green.png) top right repeat-x; + background-color: #597800; + background: -webkit-linear-gradient(#769f00,#597800); + background: linear-gradient(#769f00,#597800); +} + +div.important div.admonition_header { + background: url(../images/yellow.png) top right repeat-x; + background-color: #a6710f; + background: -webkit-linear-gradient(#d08e13,#a6710f); + background: linear-gradient(#d08e13,#a6710f); +} + +div.warning p:first-child, +div.warning div.para:first-child, +div.note p:first-child, +div.note div.para:first-child, +div.important p:first-child, +div.important div.para:first-child { + padding: 0px; + margin: 0px; +} + +div.admonition { + border: none; + border-left: 1px solid #aaaaaa; + border-right: 1px solid #aaaaaa; + padding:0px; + margin:0px; + padding-top: 1.5em; + padding-bottom: 1em; + padding-left: 2em; + padding-right: 1em; + background-color: #eeeeec; + -moz-border-radius: 0px; + -webkit-border-radius: 0px; + border-radius: 0px; +} + +/*Page Title*/ +#title { + display:block; + height:45px; + padding-bottom:1em; + margin:0px; +} + +#title a.left{ + display:inline; + border:none; +} + +#title a.left img{ + border:none; + float:left; + margin:0px; + margin-top:.7em; +} + +#title a.right { + padding-bottom:1em; +} + +#title a.right img { + border:none; + float:right; + margin:0px; + margin-top:.7em; +} + +/*Table*/ +div.table { +/* page-break-inside: avoid; */ +} + +table { + border: 1px solid #444; + width:100%; + border-collapse:collapse; + table-layout: fixed; + word-wrap: break-word; +} + +table.blockquote, +table.simplelist, +.calloutlist table { + border-style: none; +} + +table th { + text-align:left; + background-color:#6699cc; + padding:.3em .5em; + color:white; +} + +table td { + padding:.15em .5em; +} + +table tr.even td { + background-color:#f5f5f5; +} + +tr:nth-child(even) { + background-color: #eeeeee; + +} + + +table th p:first-child, table td p:first-child, table li p:first-child, +table th div.para:first-child, table td div.para:first-child, table li div.para:first-child { + margin-top:0px; + padding-top:0px; + display:inline; +} + +th, td { + border-style:none; + vertical-align: top; +/* border: 1px solid #000; */ +} + +.blockquote td, +.simplelist th, +.simplelist td { + border: none; +} + +table table td { + border-bottom:1px dotted #aaa; + background-color:white; + padding:.6em 0px; +} + +table table { + border:1px solid white; +} + +td.remarkval { + color:#444; +} + +td.fieldval { + font-weight:bold; +} + +.lbname, .lbtype, .lbdescr, .lbdriver, .lbhost { + color:white; + font-weight:bold; + background-color:#999; + width:120px; +} + +td.remarkval { + width:230px; +} + +td.tname { + font-weight:bold; +} + +th.dbfield { + width:120px; +} + +th.dbtype { + width:70px; +} + +th.dbdefault { + width:70px; +} + +th.dbnul { + width:70px; +} + +th.dbkey { + width:70px; +} + +span.book { + margin-top:4em; + display:block; + font-size: 11pt; +} + +span.book a{ + font-weight:bold; +} +span.chapter { + display:block; +} + +table.simplelist td, .calloutlist table td { + border-style: none; +} + + +table.lt-4-cols.lt-7-rows td { + border: none; +} +/*to simplify layout*/ + + +table.lt-4-cols.gt-14-rows tr:nth-child(odd) { + background-color: #fafafa; +} +/* to keep simple but stripe rows */ + + +.gt-8-cols td { + border-left: 1px solid #ccc; +} + +.gt-8-cols td:first-child { + border-left: 0; +} +/* to apply vertical lines to differentiate columns*/ + +/*Breadcrumbs*/ +#breadcrumbs ul li.first:before { + content:" "; +} + +#breadcrumbs { + color:#900; + padding:3px; + margin-bottom:25px; +} + +#breadcrumbs ul { + margin-left:0; + padding-left:0; + display:inline; + border:none; +} + +#breadcrumbs ul li { + margin-left:0; + padding-left:2px; + border:none; + list-style:none; + display:inline; +} + +#breadcrumbs ul li:before { + content:"\0020 \0020 \0020 \00BB \0020"; + color:#333; +} + +dl { + margin-top: 0px; + margin-left: 28px; +} + +.toc dl { + margin-left: 10px; +} + +/*index*/ +.glossary h3, +.index h3 { + font-size: 20px; + color:#aaa; + margin:0px; +} + +.indexdiv { + margin-bottom:1em; +} + +.glossary dt, +.index dt { + color:#444; + padding-top:.5em; +} + +.glossary dl dl dt, +.index dl dl dt { + color:#777; + font-weight:normal; + padding-top:0px; +} + +.index dl dl dt:before { + content:"- "; + color:#ccc; +} + +/*changes*/ +.footnote { + font-size: 10px; + margin: 0px; + color: #222; +} + +.footnotes { + margin-bottom: 60px; +} + +table .footnote { +} + +sup { + margin:0px; + padding:0px; + font-size: 10px; + padding-left:0px; +} + +.footnote { + position:relative; +} + +.footnote sup { + color: black; + left: .4em; +} + +.footnote a:link, +.footnote a:visited { + text-decoration:none; + border: none; +} + +.footnote .para sup { +/* position:absolute; */ + vertical-align:text-bottom; +} + +a.footnote { + padding-right: 0.5em; + text-decoration:none; + border: none; +} + +.footnote sup a:link, +.footnote sup a:visited { + color:#92917d; + text-decoration:none; +} + +.footnote:hover sup a { + text-decoration:none; +} + +.footnote p,.footnote div.para { + padding-left:1em; +} + +.footnote a:link, +.footnote a:visited before{ + color:#00537c; +} + +.footnote a:hover { +} + +/**/ +.pdf-break { + page-break-before: always; +} + +div.legalnotice { + page-break-before: always; +} + +div.abstract { + page-break-before: always; +/* page-break-after: always;*/ +} + +div.chapter { + page-break-before: always; +} + + +div.titlepage, div.titlepage > div, div.titlepage > div > div { + page-break-inside: avoid; + page-break-after: avoid; +} + +div.preface, div.part { + page-break-before: always; +} + +div.appendix { + page-break-before: always; +} + +div.section { + page-break-inside: auto; + page-break-before: auto; + page-break-after: auto; +} + + +dt.varlistentry { + page-break-inside: avoid; + page-break-after: avoid; +} + +dd { + page-break-before: avoid; +} + +div.note .replaceable, +div.important .replaceable, +div.warning .replaceable, +div.note .keycap, +div.important .keycap, +div.warning .keycap +{ +} + +ul li p:last-child, ul li para:last-child { + margin-bottom:0px; + padding-bottom:0px; +} + +/*document navigation*/ +.docnav a, .docnav strong { + border:none; + text-decoration:none; + font-weight:normal; +} + +.docnav { + list-style:none; + margin:0px; + padding:0px; + position:relative; + width:100%; + padding-bottom:2em; + padding-top:1em; + height:2.5em; + line-height:2.5em; +/* + border-top:1px dotted #ccc; + background-color: rgba(240, 240, 240, 0.9); +-webkitbox-shadow: 0px .15em .5em rgba(0,0,0,0.2); + -moz-box-shadow: 0px .15em .5em rgba(0,0,0,0.2); + box-shadow: 0px .15em .5em rgba(0,0,0,0.2); +*/ +} + +.docnav li { + list-style:none; + margin:0px; + padding:0px; + display:inline; + font-size: 14px; +} + +.docnav li:before { + content:" "; +} + +.docnav li.previous, .docnav li.next { + position:absolute; + top:1.5em; +} + +.docnav li.up, .docnav li.home { + margin:0px 1.5em; +} + +.docnav.top li.home { + color: #336699; + font-size: 22pt; + font-weight: bold; +} + + +.docnav li.previous { + left:0px; + text-align:left; +} + +.docnav li.next { + right:0px; + text-align:right; +} + +.docnav li.previous strong, .docnav li.next strong { + height: 17px; + display: block; +} + +.docnav { + margin:0 auto; + text-align:center; +} + +.docnav li.next a strong { + background: url(../images/stock-go-forward.png) right 120% no-repeat; + padding-top:3px; + padding-bottom:4px; + padding-right:28px; +} + +.docnav li.previous a strong { + background: url(../images/stock-go-back.png) left 120% no-repeat; + padding-top:3px; + padding-bottom:4px; + padding-left:28px; + padding-right:0.5em; +} + +.docnav li.home a strong { + background: url(../images/stock-home.png) top left no-repeat; + padding:5px; + padding-left:28px; +} + +.docnav li.up a strong { + background: url(../images/stock-go-up.png) top left no-repeat; + padding:5px; + padding-left:28px; +} + +.docnav a:link, .docnav a:visited { + color:#666; +} + +.docnav a:hover, .docnav a:focus, .docnav a:active { + color:black; +} + +.docnav a { + max-width: 10px; + overflow:hidden; +} + +.docnav a:link strong { + text-decoration:none; +} + +.docnav { + margin:0 auto; + text-align:center; +} + +ul.docnav { + margin-bottom: 1em; +} +/* Reports */ +.reports ul { + list-style:none; + margin:0px; + padding:0px; +} + +.reports li{ + margin:0px; + padding:0px; +} + +.reports li.odd { + background-color: #eeeeee; + margin:0px; + padding:0px; +} + +.reports dl { + display:inline; + margin:0px; + padding:0px; + float:right; + margin-right: 17em; + margin-top:-1.3em; +} + +.reports dt { + display:inline; + margin:0px; + padding:0px; +} + +.reports dd { + display:inline; + margin:0px; + padding:0px; + padding-right:.5em; +} + +.reports h2, .reports h3{ + display:inline; + padding-right:.5em; + font-size: 14px; + font-weight:normal; +} + +.reports div.progress { + display:inline; + float:right; + width:16em; + background:#c00 url(../images/shine.png) top left repeat-x; + margin:0px; + margin-top:-1.3em; + padding:0px; + border:none; +} + +/*uniform*/ +body.results, body.reports { + max-width:57em ; + padding:0px; +} + +/*Progress Bar*/ +div.progress { + display:block; + float:left; + width:16em; + background:#c00 url(../images/shine.png) top left repeat-x; + height:1em; +} + +div.progress span { + height:1em; + float:left; +} + +div.progress span.translated { + background:#6c3 url(../images/shine.png) top left repeat-x; +} + +div.progress span.fuzzy { + background:#ff9f00 url(../images/shine.png) top left repeat-x; +} + + +/*Results*/ + +.results ul { + list-style:none; + margin:0px; + padding:0px; +} + +.results li{ + margin:0px; + padding:0px; +} + +.results li.odd { + background-color: #eeeeee; + margin:0px; + padding:0px; +} + +.results dl { + display:inline; + margin:0px; + padding:0px; + float:right; + margin-right: 17em; + margin-top:-1.3em; +} + +.results dt { + display:inline; + margin:0px; + padding:0px; +} + +.results dd { + display:inline; + margin:0px; + padding:0px; + padding-right:.5em; +} + +.results h2, .results h3 { + display:inline; + padding-right:.5em; + font-size: 14px; + font-weight:normal; +} + +.results div.progress { + display:inline; + float:right; + width:16em; + background:#c00 url(../images/shine.png) top left repeat-x; + margin:0px; + margin-top:-1.3em; + padding:0px; + border:none; +} + +/* Dirty EVIL Mozilla hack for round corners */ +pre { + -moz-border-radius:11px; + -webkit-border-radius:11px; + border-radius: 11px; +/* page-break-inside: avoid; */ +} + +.example { + -moz-border-radius:0px; + -webkit-border-radius:0px; + border-radius: 0px; + page-break-inside: avoid; +} + +/* move these invisible fields out of the flow */ +.example > a:first-child, +.table > a:first-child { + float: left; +} + +.package, .citetitle { + font-style: italic; +} + +.titlepage .edition, +.titlepage .releaseinfo { + color: #336699; + background-color: transparent; + margin-top: 1em; + margin-bottom: 1em; + font-size: 20px; + font-weight: bold; + text-align: center; +} + +span.remark { + background-color: #ff00ff; +} + +.draft { + background-image: url(../images/watermark-draft.png); + background-repeat: repeat-y; + background-position: center; +} + +.foreignphrase { + font-style: inherit; +} + +dt { + clear:both; + page-break-inside: avoid; + page-break-after: avoid; +} + +dt img { + border-style: none; + max-width: 112px; +} + +dt object { + max-width: 112px; +} + +dt .inlinemediaobject, dt object { + display: inline; + float: left; + margin-bottom: 1em; + padding-right: 1em; + width: 112px; +} + +dl:after { + display: block; + clear: both; + content: ""; +} + +.toc dd { + padding-bottom: 0px; + margin-bottom: 1em; + padding-left: 1.3em; + margin-left: 0px; +} + +div.toc > dl > dt { + padding-bottom: 0px; + margin-bottom: 0px; + margin-top: 1em; +} + + +.strikethrough { + text-decoration: line-through; +} + +.underline { + text-decoration: underline; +} + +.calloutlist img, .callout { + padding: 0px; + margin: 0px; + width: 12pt; + display: inline; + vertical-align: middle; +} + +li.step > a:first-child { + display: block; +} + +.stepalternatives { + list-style-image: none; + list-style-type: upper-alpha; +} +.task { +/* page-break-inside: avoid; */ +} + + +.added { + background-color: #99ff99; +} + +.changed { + background-color: #ffff77; +} + +.deleted { + background-color: #ff4455; + text-decoration: line-through; +} diff --git a/docs/html/css/default.css b/docs/html/css/default.css new file mode 100644 index 0000000000000000000000000000000000000000..bf38ebb59311a770914945ae9f98979a48506a7a --- /dev/null +++ b/docs/html/css/default.css @@ -0,0 +1,3 @@ +@import url("common.css"); +@import url("overrides.css"); +@import url("lang.css"); diff --git a/docs/html/css/epub.css b/docs/html/css/epub.css new file mode 100644 index 0000000000000000000000000000000000000000..b0ffd43cb791141b05f6d51c5a92179f5f07c012 --- /dev/null +++ b/docs/html/css/epub.css @@ -0,0 +1,115 @@ +/*headings*/ +h1, h2, h3, h4, h5, h6, +div.producttitle, +div.subtitle, +div.author div.author, +div.translator div.translator, +div.othercredit div.othercredit, +div.editor div.editor, +div.contrib div.contrib, +.title, +.titlepage .edition { +} + +div.para { + margin-top: 1em; +} +/* inline syntax highlighting */ +.perl_Alert { + color: #0000ff; +} + +.perl_BaseN { + color: #007f00; +} + +.perl_BString { + color: #5C3566; +} + +.perl_Char { + color: #ff00ff; +} + +.perl_Comment { + color: #888888; +} + + +.perl_DataType { + color: #0000ff; +} + + +.perl_DecVal { + color: #00007f; +} + + +.perl_Error { + color: #ff0000; +} + + +.perl_Float { + color: #00007f; +} + + +.perl_Function { + color: #007f00; +} + + +.perl_IString { + color: #5C3566; +} + + +.perl_Keyword { + color: #002F5D; +} + + +.perl_Operator { + color: #ffa500; +} + + +.perl_Others { + color: #b03060; +} + + +.perl_RegionMarker { + color: #96b9ff; +} + + +.perl_Reserved { + color: #9b30ff; +} + + +.perl_String { + color: #5C3566; +} + + +.perl_Variable { + color: #0000ff; +} + + +.perl_Warning { + color: #0000ff; +} + +b, strong { + font-weight: bolder; +} + +code.command { + font-family: monospace; + font-weight: bolder; +} diff --git a/docs/html/css/print.css b/docs/html/css/print.css new file mode 100644 index 0000000000000000000000000000000000000000..54088f48d6d5010601dd88b34ce1e533f81cba95 --- /dev/null +++ b/docs/html/css/print.css @@ -0,0 +1,15 @@ +@import url("common.css"); +@import url("overrides.css"); +@import url("lang.css"); + +#tocframe { + display: none; +} + +body.toc_embeded { + margin-left: 30px; +} + +.producttitle { + color: #336699; +} diff --git a/docs/html/images/icon.svg b/docs/html/images/icon.svg new file mode 100644 index 0000000000000000000000000000000000000000..b2f16d0f61d039f7e50c344cdcdd544210cc418c --- /dev/null +++ b/docs/html/images/icon.svg @@ -0,0 +1,19 @@ + + + + + + + + + + + + + + + + + + + diff --git a/docs/html/images/wayland-architecture.png b/docs/html/images/wayland-architecture.png new file mode 100644 index 0000000000000000000000000000000000000000..84dcbbfe03f72e837ccc42721fb259563f391b18 Binary files /dev/null and b/docs/html/images/wayland-architecture.png differ diff --git a/docs/html/images/wayland.png b/docs/html/images/wayland.png new file mode 100644 index 0000000000000000000000000000000000000000..c9937928ce9584a660ee10f7092eed2033f6eab8 Binary files /dev/null and b/docs/html/images/wayland.png differ diff --git a/docs/html/images/x-architecture.png b/docs/html/images/x-architecture.png new file mode 100644 index 0000000000000000000000000000000000000000..b727914481933b2850608da2db5210e0d5a50df6 Binary files /dev/null and b/docs/html/images/x-architecture.png differ diff --git a/docs/html/images/xwayland-architecture.png b/docs/html/images/xwayland-architecture.png new file mode 100644 index 0000000000000000000000000000000000000000..f24dc1837f2e190c9d38719420a844aeb5997efa Binary files /dev/null and b/docs/html/images/xwayland-architecture.png differ diff --git a/docs/html/index.html b/docs/html/index.html new file mode 100644 index 0000000000000000000000000000000000000000..d037652df27b8b9c98db982ba931d89f6911633e --- /dev/null +++ b/docs/html/index.html @@ -0,0 +1,89 @@ +Wayland

Wayland

The Wayland Protocol

+ Wayland logo +

Kristian Høgsberg

Intel Corporation

+ Copyright © 2012 Kristian Høgsberg, Intel Corporation +

+ Permission is hereby granted, free of charge, to any person obtaining a + copy of this software and associated documentation files (the "Software"), + to deal in the Software without restriction, including without limitation + the rights to use, copy, modify, merge, publish, distribute, sublicense, + and/or sell copies of the Software, and to permit persons to whom the + Software is furnished to do so, subject to the following conditions: +

+ The above copyright notice and this permission notice (including the next + paragraph) shall be included in all copies or substantial portions of the + Software. +

+ THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL + THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING + FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER + DEALINGS IN THE SOFTWARE. +

Abstract

+ Wayland is a protocol for a compositor to talk to + its clients as well as a C library implementation of + that protocol. The compositor can be a standalone + display server running on Linux kernel modesetting + and evdev input devices, an X application, or a + Wayland client itself. The clients can be + traditional applications, X servers (rootless or + fullscreen) or other display servers. +


Table of Contents

Preface
Acknowledgments
1. Introduction
Motivation
The compositing manager as the display server
2. Types of Compositors
System Compositor
Session Compositor
Embedding Compositor
3. Wayland Architecture
X vs. Wayland Architecture
Wayland Rendering
Hardware Enabling for Wayland
4. Wayland Protocol and Model of Operation
Basic Principles
Code Generation
Wire Format
Interfaces
Versioning
Connect Time
Security and Authentication
Creating Objects
Compositor
Surfaces
Input
Output
Data sharing between clients
5. X11 Application Support
Introduction
Two Modes for Foreign Windows
Architecture
X Window Manager (XWM)
A. Wayland Protocol Specification
wl_display + - core global object
wl_registry + - global registry object
wl_callback + - callback object
wl_compositor + - the compositor singleton
wl_shm_pool + - a shared memory pool
wl_shm + - shared memory support
wl_buffer + - content for a wl_surface
wl_data_offer + - offer to transfer data
wl_data_source + - offer to transfer data
wl_data_device + - data transfer device
wl_data_device_manager + - data transfer interface
wl_shell + - create desktop-style surfaces
wl_shell_surface + - desktop-style metadata interface
wl_surface + - an onscreen surface
wl_seat + - group of input devices
wl_pointer + - pointer input device
wl_keyboard + - keyboard input device
wl_touch + - touchscreen input device
wl_output + - compositor output region
wl_region + - region interface
wl_subcompositor + - sub-surface compositing
wl_subsurface + - sub-surface interface to a wl_surface
B. Client API
Introduction
wl_argument + - +Protocol message argument data types.
wl_array + - +Dynamic array.
wl_display + - +Represents a connection to the compositor and acts as a proxy to the wl_display singleton object.
wl_event_queue + - +A queue for wl_proxy object events.
wl_interface + - +Protocol object interface.
wl_list + - +Doubly-linked list.
wl_message + - +Protocol message signature.
wl_proxy + - +Represents a protocol object on the client side.
Functions
C. Server API
Introduction
wl_argument + - +Protocol message argument data types.
wl_array + - +Dynamic array.
wl_buffer
wl_client
wl_display
wl_event_loop + - +An event loop context.
wl_event_source + - +An abstract event source.
wl_global
wl_interface + - +Protocol object interface.
wl_list + - +Doubly-linked list.
wl_listener + - +A single listener for Wayland signals.
wl_message + - +Protocol message signature.
wl_object
wl_protocol_logger
wl_protocol_logger_message
wl_resource
wl_resource_iterator_context
wl_shm_buffer
wl_shm_pool
wl_shm_sigbus_data
wl_signal + - +A source of a type of observable event.
wl_socket
Functions

List of Figures

3.1. X architecture diagram
3.2. Wayland architecture diagram
5.1. Xwayland architecture diagram
diff --git a/docs/html/pr01.html b/docs/html/pr01.html new file mode 100644 index 0000000000000000000000000000000000000000..9ab64a4f5c3aae5f65d6582bfb16b221d2e9ca7b --- /dev/null +++ b/docs/html/pr01.html @@ -0,0 +1,15 @@ +Preface

Preface

+ This document describes the (i) Wayland architecture, (ii) Wayland model of + operation and (iii) its library API. Also, the Wayland protocol specification is shown + in the Appendix. This document is aimed primarily at Wayland developers and + those looking to program with it; it does not cover application development. +

+ There have been many contributors to this document and since this is only the + first edition many errors are expected to be found. We appreciate + corrections. +


+Yours,
+
+        the Wayland open-source community
+        November 2012
+  

diff --git a/docs/html/pr02.html b/docs/html/pr02.html new file mode 100644 index 0000000000000000000000000000000000000000..8e42784db30b96e767a6a8b6e7e1b344be5ba62e --- /dev/null +++ b/docs/html/pr02.html @@ -0,0 +1,8 @@ +Acknowledgments

Acknowledgments

+ TODO: Kristian has to fill up this with one or two paragraphs and a small + "thank you": http://en.wikipedia.org/wiki/Preface +


+Best,
+
+        Kristian Høgsberg
+  

diff --git a/docs/pdf/Documentation-1.1-Wayland-en-US.pdf-broken b/docs/pdf/Documentation-1.1-Wayland-en-US.pdf-broken new file mode 100644 index 0000000000000000000000000000000000000000..7190c1468d4847f4e021dacbd3dca7f7f1a27290 Binary files /dev/null and b/docs/pdf/Documentation-1.1-Wayland-en-US.pdf-broken differ diff --git a/docs/pdf/Documentation-1.2-Wayland-en-US.pdf b/docs/pdf/Documentation-1.2-Wayland-en-US.pdf new file mode 100644 index 0000000000000000000000000000000000000000..d7a9507b455a4e8e0dcf8a79c6200d2f1e87967a Binary files /dev/null and b/docs/pdf/Documentation-1.2-Wayland-en-US.pdf differ diff --git a/docs/pdf/Documentation-1.3-Wayland-en-US.pdf b/docs/pdf/Documentation-1.3-Wayland-en-US.pdf new file mode 100644 index 0000000000000000000000000000000000000000..0ccdaa25e0671f84aa37c4077713a0a0fe5605ab Binary files /dev/null and b/docs/pdf/Documentation-1.3-Wayland-en-US.pdf differ diff --git a/libinput/doc/0.0/README_8txt.html b/libinput/doc/0.0/README_8txt.html new file mode 100644 index 0000000000000000000000000000000000000000..5d2c1a691bc5da8599ad444dd3f35107dc886ebb --- /dev/null +++ b/libinput/doc/0.0/README_8txt.html @@ -0,0 +1,117 @@ + + + + + + + + + + + libinput: /home/whot/code/libinput/README.txt File Reference + + + + + + + + + + + + + + + + +
+
+
+
+
+
+ + + + + + +
+
+ + +
+ +
+ +
+
+
+
/home/whot/code/libinput/README.txt File Reference
+
+
+
+ + +
+
+
+
+
+ + + diff --git a/libinput/doc/0.0/absolute-axes_8dox.html b/libinput/doc/0.0/absolute-axes_8dox.html new file mode 100644 index 0000000000000000000000000000000000000000..dcb8567c4c736eee5e29a393c0db1116e42a248f --- /dev/null +++ b/libinput/doc/0.0/absolute-axes_8dox.html @@ -0,0 +1,117 @@ + + + + + + + + + + + libinput: absolute-axes.dox File Reference + + + + + + + + + + + + + + + + +
+
+
+
+
+
+ + + + + + +
+
+ + +
+ +
+ +
+
+
+
absolute-axes.dox File Reference
+
+
+
+ + +
+
+
+
+
+ + + diff --git a/libinput/doc/0.0/absolute_axes.html b/libinput/doc/0.0/absolute_axes.html new file mode 100644 index 0000000000000000000000000000000000000000..bd0f9a560e2735ae08f2a36de024d19918929e41 --- /dev/null +++ b/libinput/doc/0.0/absolute_axes.html @@ -0,0 +1,156 @@ + + + + + + + + + + + libinput: Absolute axes + + + + + + + + + + + + + + + + +
+
+
+
+
+
+ + + + + +
+
+ + +
+ +
+ + +
+
+
+
Absolute axes
+
+
+

Devices with absolute axes are those that send positioning data for an axis in a device-specific coordinate range, defined by a minimum and a maximum value.

+

Compare this to relative devices (e.g. a mouse) that can only detect directional data, not positional data.

+

libinput supports three types of devices with absolute axes:

+ +

Touchpads are technically absolute devices but libinput converts the axis values to directional motion and posts events as relative events. Touchpads do not count as absolute devices in libinput.

+

For all absolute devices in libinput, the default unit for x/y coordinates is in mm off the top left corner on the device, or more specifically off the device's sensor. If the device is physically rotated from its natural position and this rotation was communicated to libinput (e.g. by setting the device left-handed), the coordinate origin is the top left corner of in the current rotation.

+

+Handling of absolute coordinates

+

In most use-cases, absolute input devices are mapped to a single screen. For direct input devices such as touchscreens the aspect ratio of the screen and the device match. Mapping the input device position to the output position is thus a simple mapping between two coordinates. libinput provides the API for this with

+ +

libinput's API only provides the call to map into a single coordinate range. If the coordinate range has an offset, the compositor is responsible for applying that offset after the mapping. For example, if the device is mapped to the right of two outputs, add the output offset to the transformed coordinate.

+

+Devices without x/y resolution

+

An absolute device that does not provide a valid resolution is considered buggy and must be fixed in the kernel. Some touchpad devices do not provide resolution, those devices are correctly handled within libinput (touchpads are not absolute devices, as mentioned above).

+

+Calibration of absolute devices

+

Absolute devices may require calibration to map precisely into the output range required. This is done by setting a transformation matrix, see libinput_device_config_calibration_set_matrix() which is applied to each input coordinate.

+

+\[ \begin{pmatrix} cos\theta & -sin\theta & xoff \\ sin\theta & cos\theta & yoff \\ 0 & 0 & 1 \end{pmatrix} \begin{pmatrix} x \\ y \\ 1 \end{pmatrix} \] +

+

\(\theta\) is the rotation angle. The offsets \(xoff\) and \(yoff\) are specified in device dimensions, i.e. a value of 1 equals one device width or height. Note that rotation applies to the device's origin, rotation usually requires an offset to move the coordinates back into the original range.

+

The most common matrices are:

+
    +
  • 90 degree clockwise: \( \begin{pmatrix} 0 & -1 & 1 \\ 1 & 0 & 0 \\ 0 & 0 & 1 \end{pmatrix} \)
  • +
  • 180 degree clockwise: \( \begin{pmatrix} -1 & 0 & 1 \\ 0 & -1 & 1 \\ 0 & 0 & 1 \end{pmatrix} \)
  • +
  • 270 degree clockwise: \( \begin{pmatrix} 0 & 1 & 0 \\ -1 & 0 & 1 \\ 0 & 0 & 1 \end{pmatrix} \)
  • +
  • reflection along y axis: \( \begin{pmatrix} -1 & 0 & 1 \\ 1 & 0 & 0 \\ 0 & 0 & 1 \end{pmatrix} \)
  • +
+

See Wikipedia's Transformation Matrix article for more information on the matrix maths. See libinput_device_config_calibration_get_default_matrix() for how these matrices must be supplied to libinput.

+

Once applied, any x and y axis value has the calibration applied before it is made available to the caller. libinput does not provide access to the raw coordinates before the calibration is applied.

+

+Why x/y coordinates are not normalized

+

x/y are not given in normalized coordinates ([0..1]) for one simple reason: the aspect ratio of virtually all current devices is something other than 1:1. A normalized axes thus is only useful to determine that the stylus is e.g. at 78% from the left, 34% from the top of the device. Without knowing the per-axis resolution, these numbers are meaningless. Worse, calculation based on previous coordinates is simply wrong: a movement from 0/0 to 50%/50% is not a 45% degree line.

+

This could be alleviated by providing resolution and information about the aspect ratio to the caller. Which shifts processing and likely errors into the caller for little benefit. Providing the x/y axes in mm from the outset removes these errors.

+
+ + +
+
+
+
+
+ + + diff --git a/libinput/doc/0.0/annotated.html b/libinput/doc/0.0/annotated.html new file mode 100644 index 0000000000000000000000000000000000000000..1bec646eaa0c1da88fcc3562a504fdd53341c400 --- /dev/null +++ b/libinput/doc/0.0/annotated.html @@ -0,0 +1,134 @@ + + + + + + + + + + + libinput: Data Structures + + + + + + + + + + + + + + + + +
+
+
+
+
+
+ + + + + +
+ +
+
+ + +
+ +
+ +
+
+
Data Structures
+
+
+
Here are the data structures with brief descriptions:
+ + + + + + + + + + + + + +
 ClibinputA handle for accessing libinput
 Clibinput_deviceA base handle for accessing libinput devices
 Clibinput_device_groupA base handle for accessing libinput device groups
 Clibinput_eventThe base event type
 Clibinput_event_device_notifyAn event notifying the caller of a device being added or removed
 Clibinput_event_keyboardA keyboard event representing a key press/release
 Clibinput_event_pointerA pointer event representing relative or absolute pointer movement, a button press/release or scroll axis events
 Clibinput_event_tablet_toolTablet tool event representing an axis update, button press, or tool update
 Clibinput_event_touchTouch event representing a touch down, move or up, as well as a touch cancel and touch frame events
 Clibinput_interfaceLibinput does not open file descriptors to devices directly, instead open_restricted() and close_restricted() are called for each path that must be opened
 Clibinput_seatThe base handle for accessing libinput seats
 Clibinput_tablet_toolAn object representing a tool being used by a device with the LIBINPUT_DEVICE_CAP_TABLET_TOOL capability
+
+
+ + +
+
+
+
+
+ + + diff --git a/libinput/doc/0.0/arrowdown.png b/libinput/doc/0.0/arrowdown.png new file mode 100644 index 0000000000000000000000000000000000000000..0b63f6d38c4b9ec907b820192ebe9724ed6eca22 Binary files /dev/null and b/libinput/doc/0.0/arrowdown.png differ diff --git a/libinput/doc/0.0/arrowright.png b/libinput/doc/0.0/arrowright.png new file mode 100644 index 0000000000000000000000000000000000000000..c6ee22f937a07d1dbfc27c669d11f8ed13e2f152 Binary files /dev/null and b/libinput/doc/0.0/arrowright.png differ diff --git a/libinput/doc/0.0/bc_s.png b/libinput/doc/0.0/bc_s.png new file mode 100644 index 0000000000000000000000000000000000000000..224b29aa9847d5a4b3902efd602b7ddf7d33e6c2 Binary files /dev/null and b/libinput/doc/0.0/bc_s.png differ diff --git a/libinput/doc/0.0/bdwn.png b/libinput/doc/0.0/bdwn.png new file mode 100644 index 0000000000000000000000000000000000000000..940a0b950443a0bb1b216ac03c45b8a16c955452 Binary files /dev/null and b/libinput/doc/0.0/bdwn.png differ diff --git a/libinput/doc/0.0/bootstrap.css b/libinput/doc/0.0/bootstrap.css new file mode 100644 index 0000000000000000000000000000000000000000..05dc92517272dd76ad2931a532922f621ee0ec97 --- /dev/null +++ b/libinput/doc/0.0/bootstrap.css @@ -0,0 +1,7500 @@ +@import url("https://fonts.googleapis.com/css?family=Roboto:300,400,500,700"); +/*! + * bootswatch v3.3.5 + * Homepage: http://bootswatch.com + * Copyright 2012-2015 Thomas Park + * Licensed under MIT + * Based on Bootstrap +*/ +/*! + * Bootstrap v3.3.5 (http://getbootstrap.com) + * Copyright 2011-2015 Twitter, Inc. + * Licensed under MIT (https://github.com/twbs/bootstrap/blob/master/LICENSE) + */ +/*! normalize.css v3.0.3 | MIT License | github.com/necolas/normalize.css */ +html { + font-family: sans-serif; + -ms-text-size-adjust: 100%; + -webkit-text-size-adjust: 100%; +} +body { + margin: 0; +} +article, +aside, +details, +figcaption, +figure, +footer, +header, +hgroup, +main, +menu, +nav, +section, +summary { + display: block; +} +audio, +canvas, +progress, +video { + display: inline-block; + vertical-align: baseline; +} +audio:not([controls]) { + display: none; + height: 0; +} +[hidden], +template { + display: none; +} +a { + background-color: transparent; +} +a:active, +a:hover { + outline: 0; +} +abbr[title] { + border-bottom: 1px dotted; +} +b, +strong { + font-weight: bold; +} +dfn { + font-style: italic; +} +h1 { + font-size: 2em; + margin: 0.67em 0; +} +mark { + background: #ff0; + color: #000; +} +small { + font-size: 80%; +} +sub, +sup { + font-size: 75%; + line-height: 0; + position: relative; + vertical-align: baseline; +} +sup { + top: -0.5em; +} +sub { + bottom: -0.25em; +} +img { + border: 0; +} +svg:not(:root) { + overflow: hidden; +} +figure { + margin: 1em 40px; +} +hr { + -webkit-box-sizing: content-box; + -moz-box-sizing: content-box; + box-sizing: content-box; + height: 0; +} +pre { + overflow: auto; +} +code, +kbd, +pre, +samp { + font-family: monospace, monospace; + font-size: 1em; +} +button, +input, +optgroup, +select, +textarea { + color: inherit; + font: inherit; + margin: 0; +} +button { + overflow: visible; +} +button, +select { + text-transform: none; +} +button, +html input[type="button"], +input[type="reset"], +input[type="submit"] { + -webkit-appearance: button; + cursor: pointer; +} +button[disabled], +html input[disabled] { + cursor: default; +} +button::-moz-focus-inner, +input::-moz-focus-inner { + border: 0; + padding: 0; +} +input { + line-height: normal; +} +input[type="checkbox"], +input[type="radio"] { + -webkit-box-sizing: border-box; + -moz-box-sizing: border-box; + box-sizing: border-box; + padding: 0; +} +input[type="number"]::-webkit-inner-spin-button, +input[type="number"]::-webkit-outer-spin-button { + height: auto; +} +input[type="search"] { + -webkit-appearance: textfield; + -webkit-box-sizing: content-box; + -moz-box-sizing: content-box; + box-sizing: content-box; +} +input[type="search"]::-webkit-search-cancel-button, +input[type="search"]::-webkit-search-decoration { + -webkit-appearance: none; +} +fieldset { + border: 1px solid #c0c0c0; + margin: 0 2px; + padding: 0.35em 0.625em 0.75em; +} +legend { + border: 0; + padding: 0; +} +textarea { + overflow: auto; +} +optgroup { + font-weight: bold; +} +table { + border-collapse: collapse; + border-spacing: 0; +} +td, +th { + padding: 0; +} +/*! Source: https://github.com/h5bp/html5-boilerplate/blob/master/src/css/main.css */ +@media print { + *, + *:before, + *:after { + background: transparent !important; + color: #000 !important; + -webkit-box-shadow: none !important; + box-shadow: none !important; + text-shadow: none !important; + } + a, + a:visited { + text-decoration: underline; + } + a[href]:after { + content: " (" attr(href) ")"; + } + abbr[title]:after { + content: " (" attr(title) ")"; + } + a[href^="#"]:after, + a[href^="javascript:"]:after { + content: ""; + } + pre, + blockquote { + border: 1px solid #999; + page-break-inside: avoid; + } + thead { + display: table-header-group; + } + tr, + img { + page-break-inside: avoid; + } + img { + max-width: 100% !important; + } + p, + h2, + h3 { + orphans: 3; + widows: 3; + } + h2, + h3 { + page-break-after: avoid; + } + .navbar { + display: none; + } + .btn > .caret, + .dropup > .btn > .caret { + border-top-color: #000 !important; + } + .label { + border: 1px solid #000; + } + .table { + border-collapse: collapse !important; + } + .table td, + .table th { + background-color: #fff !important; + } + .table-bordered th, + .table-bordered td { + border: 1px solid #ddd !important; + } +} +@font-face { + font-family: 'Glyphicons Halflings'; + src: url('../fonts/glyphicons-halflings-regular.eot'); + src: url('../fonts/glyphicons-halflings-regular.eot?#iefix') format('embedded-opentype'), url('../fonts/glyphicons-halflings-regular.woff2') format('woff2'), url('../fonts/glyphicons-halflings-regular.woff') format('woff'), url('../fonts/glyphicons-halflings-regular.ttf') format('truetype'), url('../fonts/glyphicons-halflings-regular.svg#glyphicons_halflingsregular') format('svg'); +} +.glyphicon { + position: relative; + top: 1px; + display: inline-block; + font-family: 'Glyphicons Halflings'; + font-style: normal; + font-weight: normal; + line-height: 1; + -webkit-font-smoothing: antialiased; + -moz-osx-font-smoothing: grayscale; +} +.glyphicon-asterisk:before { + content: "\2a"; +} +.glyphicon-plus:before { + content: "\2b"; +} +.glyphicon-euro:before, +.glyphicon-eur:before { + content: "\20ac"; +} +.glyphicon-minus:before { + content: "\2212"; +} +.glyphicon-cloud:before { + content: "\2601"; +} +.glyphicon-envelope:before { + content: "\2709"; +} +.glyphicon-pencil:before { + content: "\270f"; +} +.glyphicon-glass:before { + content: "\e001"; +} +.glyphicon-music:before { + content: "\e002"; +} +.glyphicon-search:before { + content: "\e003"; +} +.glyphicon-heart:before { + content: "\e005"; +} +.glyphicon-star:before { + content: "\e006"; +} +.glyphicon-star-empty:before { + content: "\e007"; +} +.glyphicon-user:before { + content: "\e008"; +} +.glyphicon-film:before { + content: "\e009"; +} +.glyphicon-th-large:before { + content: "\e010"; +} +.glyphicon-th:before { + content: "\e011"; +} +.glyphicon-th-list:before { + content: "\e012"; +} +.glyphicon-ok:before { + content: "\e013"; +} +.glyphicon-remove:before { + content: "\e014"; +} +.glyphicon-zoom-in:before { + content: "\e015"; +} +.glyphicon-zoom-out:before { + content: "\e016"; +} +.glyphicon-off:before { + content: "\e017"; +} +.glyphicon-signal:before { + content: "\e018"; +} +.glyphicon-cog:before { + content: "\e019"; +} +.glyphicon-trash:before { + content: "\e020"; +} +.glyphicon-home:before { + content: "\e021"; +} +.glyphicon-file:before { + content: "\e022"; +} +.glyphicon-time:before { + content: "\e023"; +} +.glyphicon-road:before { + content: "\e024"; +} +.glyphicon-download-alt:before { + content: "\e025"; +} +.glyphicon-download:before { + content: "\e026"; +} +.glyphicon-upload:before { + content: "\e027"; +} +.glyphicon-inbox:before { + content: "\e028"; +} +.glyphicon-play-circle:before { + content: "\e029"; +} +.glyphicon-repeat:before { + content: "\e030"; +} +.glyphicon-refresh:before { + content: "\e031"; +} +.glyphicon-list-alt:before { + content: "\e032"; +} +.glyphicon-lock:before { + content: "\e033"; +} +.glyphicon-flag:before { + content: "\e034"; +} +.glyphicon-headphones:before { + content: "\e035"; +} +.glyphicon-volume-off:before { + content: "\e036"; +} +.glyphicon-volume-down:before { + content: "\e037"; +} +.glyphicon-volume-up:before { + content: "\e038"; +} +.glyphicon-qrcode:before { + content: "\e039"; +} +.glyphicon-barcode:before { + content: "\e040"; +} +.glyphicon-tag:before { + content: "\e041"; +} +.glyphicon-tags:before { + content: "\e042"; +} +.glyphicon-book:before { + content: "\e043"; +} +.glyphicon-bookmark:before { + content: "\e044"; +} +.glyphicon-print:before { + content: "\e045"; +} +.glyphicon-camera:before { + content: "\e046"; +} +.glyphicon-font:before { + content: "\e047"; +} +.glyphicon-bold:before { + content: "\e048"; +} +.glyphicon-italic:before { + content: "\e049"; +} +.glyphicon-text-height:before { + content: "\e050"; +} +.glyphicon-text-width:before { + content: "\e051"; +} +.glyphicon-align-left:before { + content: "\e052"; +} +.glyphicon-align-center:before { + content: "\e053"; +} +.glyphicon-align-right:before { + content: "\e054"; +} +.glyphicon-align-justify:before { + content: "\e055"; +} +.glyphicon-list:before { + content: "\e056"; +} +.glyphicon-indent-left:before { + content: "\e057"; +} +.glyphicon-indent-right:before { + content: "\e058"; +} +.glyphicon-facetime-video:before { + content: "\e059"; +} +.glyphicon-picture:before { + content: "\e060"; +} +.glyphicon-map-marker:before { + content: "\e062"; +} +.glyphicon-adjust:before { + content: "\e063"; +} +.glyphicon-tint:before { + content: "\e064"; +} +.glyphicon-edit:before { + content: "\e065"; +} +.glyphicon-share:before { + content: "\e066"; +} +.glyphicon-check:before { + content: "\e067"; +} +.glyphicon-move:before { + content: "\e068"; +} +.glyphicon-step-backward:before { + content: "\e069"; +} +.glyphicon-fast-backward:before { + content: "\e070"; +} +.glyphicon-backward:before { + content: "\e071"; +} +.glyphicon-play:before { + content: "\e072"; +} +.glyphicon-pause:before { + content: "\e073"; +} +.glyphicon-stop:before { + content: "\e074"; +} +.glyphicon-forward:before { + content: "\e075"; +} +.glyphicon-fast-forward:before { + content: "\e076"; +} +.glyphicon-step-forward:before { + content: "\e077"; +} +.glyphicon-eject:before { + content: "\e078"; +} +.glyphicon-chevron-left:before { + content: "\e079"; +} +.glyphicon-chevron-right:before { + content: "\e080"; +} +.glyphicon-plus-sign:before { + content: "\e081"; +} +.glyphicon-minus-sign:before { + content: "\e082"; +} +.glyphicon-remove-sign:before { + content: "\e083"; +} +.glyphicon-ok-sign:before { + content: "\e084"; +} +.glyphicon-question-sign:before { + content: "\e085"; +} +.glyphicon-info-sign:before { + content: "\e086"; +} +.glyphicon-screenshot:before { + content: "\e087"; +} +.glyphicon-remove-circle:before { + content: "\e088"; +} +.glyphicon-ok-circle:before { + content: "\e089"; +} +.glyphicon-ban-circle:before { + content: "\e090"; +} +.glyphicon-arrow-left:before { + content: "\e091"; +} +.glyphicon-arrow-right:before { + content: "\e092"; +} +.glyphicon-arrow-up:before { + content: "\e093"; +} +.glyphicon-arrow-down:before { + content: "\e094"; +} +.glyphicon-share-alt:before { + content: "\e095"; +} +.glyphicon-resize-full:before { + content: "\e096"; +} +.glyphicon-resize-small:before { + content: "\e097"; +} +.glyphicon-exclamation-sign:before { + content: "\e101"; +} +.glyphicon-gift:before { + content: "\e102"; +} +.glyphicon-leaf:before { + content: "\e103"; +} +.glyphicon-fire:before { + content: "\e104"; +} +.glyphicon-eye-open:before { + content: "\e105"; +} +.glyphicon-eye-close:before { + content: "\e106"; +} +.glyphicon-warning-sign:before { + content: "\e107"; +} +.glyphicon-plane:before { + content: "\e108"; +} +.glyphicon-calendar:before { + content: "\e109"; +} +.glyphicon-random:before { + content: "\e110"; +} +.glyphicon-comment:before { + content: "\e111"; +} +.glyphicon-magnet:before { + content: "\e112"; +} +.glyphicon-chevron-up:before { + content: "\e113"; +} +.glyphicon-chevron-down:before { + content: "\e114"; +} +.glyphicon-retweet:before { + content: "\e115"; +} +.glyphicon-shopping-cart:before { + content: "\e116"; +} +.glyphicon-folder-close:before { + content: "\e117"; +} +.glyphicon-folder-open:before { + content: "\e118"; +} +.glyphicon-resize-vertical:before { + content: "\e119"; +} +.glyphicon-resize-horizontal:before { + content: "\e120"; +} +.glyphicon-hdd:before { + content: "\e121"; +} +.glyphicon-bullhorn:before { + content: "\e122"; +} +.glyphicon-bell:before { + content: "\e123"; +} +.glyphicon-certificate:before { + content: "\e124"; +} +.glyphicon-thumbs-up:before { + content: "\e125"; +} +.glyphicon-thumbs-down:before { + content: "\e126"; +} +.glyphicon-hand-right:before { + content: "\e127"; +} +.glyphicon-hand-left:before { + content: "\e128"; +} +.glyphicon-hand-up:before { + content: "\e129"; +} +.glyphicon-hand-down:before { + content: "\e130"; +} +.glyphicon-circle-arrow-right:before { + content: "\e131"; +} +.glyphicon-circle-arrow-left:before { + content: "\e132"; +} +.glyphicon-circle-arrow-up:before { + content: "\e133"; +} +.glyphicon-circle-arrow-down:before { + content: "\e134"; +} +.glyphicon-globe:before { + content: "\e135"; +} +.glyphicon-wrench:before { + content: "\e136"; +} +.glyphicon-tasks:before { + content: "\e137"; +} +.glyphicon-filter:before { + content: "\e138"; +} +.glyphicon-briefcase:before { + content: "\e139"; +} +.glyphicon-fullscreen:before { + content: "\e140"; +} +.glyphicon-dashboard:before { + content: "\e141"; +} +.glyphicon-paperclip:before { + content: "\e142"; +} +.glyphicon-heart-empty:before { + content: "\e143"; +} +.glyphicon-link:before { + content: "\e144"; +} +.glyphicon-phone:before { + content: "\e145"; +} +.glyphicon-pushpin:before { + content: "\e146"; +} +.glyphicon-usd:before { + content: "\e148"; +} +.glyphicon-gbp:before { + content: "\e149"; +} +.glyphicon-sort:before { + content: "\e150"; +} +.glyphicon-sort-by-alphabet:before { + content: "\e151"; +} +.glyphicon-sort-by-alphabet-alt:before { + content: "\e152"; +} +.glyphicon-sort-by-order:before { + content: "\e153"; +} +.glyphicon-sort-by-order-alt:before { + content: "\e154"; +} +.glyphicon-sort-by-attributes:before { + content: "\e155"; +} +.glyphicon-sort-by-attributes-alt:before { + content: "\e156"; +} +.glyphicon-unchecked:before { + content: "\e157"; +} +.glyphicon-expand:before { + content: "\e158"; +} +.glyphicon-collapse-down:before { + content: "\e159"; +} +.glyphicon-collapse-up:before { + content: "\e160"; +} +.glyphicon-log-in:before { + content: "\e161"; +} +.glyphicon-flash:before { + content: "\e162"; +} +.glyphicon-log-out:before { + content: "\e163"; +} +.glyphicon-new-window:before { + content: "\e164"; +} +.glyphicon-record:before { + content: "\e165"; +} +.glyphicon-save:before { + content: "\e166"; +} +.glyphicon-open:before { + content: "\e167"; +} +.glyphicon-saved:before { + content: "\e168"; +} +.glyphicon-import:before { + content: "\e169"; +} +.glyphicon-export:before { + content: "\e170"; +} +.glyphicon-send:before { + content: "\e171"; +} +.glyphicon-floppy-disk:before { + content: "\e172"; +} +.glyphicon-floppy-saved:before { + content: "\e173"; +} +.glyphicon-floppy-remove:before { + content: "\e174"; +} +.glyphicon-floppy-save:before { + content: "\e175"; +} +.glyphicon-floppy-open:before { + content: "\e176"; +} +.glyphicon-credit-card:before { + content: "\e177"; +} +.glyphicon-transfer:before { + content: "\e178"; +} +.glyphicon-cutlery:before { + content: "\e179"; +} +.glyphicon-header:before { + content: "\e180"; +} +.glyphicon-compressed:before { + content: "\e181"; +} +.glyphicon-earphone:before { + content: "\e182"; +} +.glyphicon-phone-alt:before { + content: "\e183"; +} +.glyphicon-tower:before { + content: "\e184"; +} +.glyphicon-stats:before { + content: "\e185"; +} +.glyphicon-sd-video:before { + content: "\e186"; +} +.glyphicon-hd-video:before { + content: "\e187"; +} +.glyphicon-subtitles:before { + content: "\e188"; +} +.glyphicon-sound-stereo:before { + content: "\e189"; +} +.glyphicon-sound-dolby:before { + content: "\e190"; +} +.glyphicon-sound-5-1:before { + content: "\e191"; +} +.glyphicon-sound-6-1:before { + content: "\e192"; +} +.glyphicon-sound-7-1:before { + content: "\e193"; +} +.glyphicon-copyright-mark:before { + content: "\e194"; +} +.glyphicon-registration-mark:before { + content: "\e195"; +} +.glyphicon-cloud-download:before { + content: "\e197"; +} +.glyphicon-cloud-upload:before { + content: "\e198"; +} +.glyphicon-tree-conifer:before { + content: "\e199"; +} +.glyphicon-tree-deciduous:before { + content: "\e200"; +} +.glyphicon-cd:before { + content: "\e201"; +} +.glyphicon-save-file:before { + content: "\e202"; +} +.glyphicon-open-file:before { + content: "\e203"; +} +.glyphicon-level-up:before { + content: "\e204"; +} +.glyphicon-copy:before { + content: "\e205"; +} +.glyphicon-paste:before { + content: "\e206"; +} +.glyphicon-alert:before { + content: "\e209"; +} +.glyphicon-equalizer:before { + content: "\e210"; +} +.glyphicon-king:before { + content: "\e211"; +} +.glyphicon-queen:before { + content: "\e212"; +} +.glyphicon-pawn:before { + content: "\e213"; +} +.glyphicon-bishop:before { + content: "\e214"; +} +.glyphicon-knight:before { + content: "\e215"; +} +.glyphicon-baby-formula:before { + content: "\e216"; +} +.glyphicon-tent:before { + content: "\26fa"; +} +.glyphicon-blackboard:before { + content: "\e218"; +} +.glyphicon-bed:before { + content: "\e219"; +} +.glyphicon-apple:before { + content: "\f8ff"; +} +.glyphicon-erase:before { + content: "\e221"; +} +.glyphicon-hourglass:before { + content: "\231b"; +} +.glyphicon-lamp:before { + content: "\e223"; +} +.glyphicon-duplicate:before { + content: "\e224"; +} +.glyphicon-piggy-bank:before { + content: "\e225"; +} +.glyphicon-scissors:before { + content: "\e226"; +} +.glyphicon-bitcoin:before { + content: "\e227"; +} +.glyphicon-btc:before { + content: "\e227"; +} +.glyphicon-xbt:before { + content: "\e227"; +} +.glyphicon-yen:before { + content: "\00a5"; +} +.glyphicon-jpy:before { + content: "\00a5"; +} +.glyphicon-ruble:before { + content: "\20bd"; +} +.glyphicon-rub:before { + content: "\20bd"; +} +.glyphicon-scale:before { + content: "\e230"; +} +.glyphicon-ice-lolly:before { + content: "\e231"; +} +.glyphicon-ice-lolly-tasted:before { + content: "\e232"; +} +.glyphicon-education:before { + content: "\e233"; +} +.glyphicon-option-horizontal:before { + content: "\e234"; +} +.glyphicon-option-vertical:before { + content: "\e235"; +} +.glyphicon-menu-hamburger:before { + content: "\e236"; +} +.glyphicon-modal-window:before { + content: "\e237"; +} +.glyphicon-oil:before { + content: "\e238"; +} +.glyphicon-grain:before { + content: "\e239"; +} +.glyphicon-sunglasses:before { + content: "\e240"; +} +.glyphicon-text-size:before { + content: "\e241"; +} +.glyphicon-text-color:before { + content: "\e242"; +} +.glyphicon-text-background:before { + content: "\e243"; +} +.glyphicon-object-align-top:before { + content: "\e244"; +} +.glyphicon-object-align-bottom:before { + content: "\e245"; +} +.glyphicon-object-align-horizontal:before { + content: "\e246"; +} +.glyphicon-object-align-left:before { + content: "\e247"; +} +.glyphicon-object-align-vertical:before { + content: "\e248"; +} +.glyphicon-object-align-right:before { + content: "\e249"; +} +.glyphicon-triangle-right:before { + content: "\e250"; +} +.glyphicon-triangle-left:before { + content: "\e251"; +} +.glyphicon-triangle-bottom:before { + content: "\e252"; +} +.glyphicon-triangle-top:before { + content: "\e253"; +} +.glyphicon-console:before { + content: "\e254"; +} +.glyphicon-superscript:before { + content: "\e255"; +} +.glyphicon-subscript:before { + content: "\e256"; +} +.glyphicon-menu-left:before { + content: "\e257"; +} +.glyphicon-menu-right:before { + content: "\e258"; +} +.glyphicon-menu-down:before { + content: "\e259"; +} +.glyphicon-menu-up:before { + content: "\e260"; +} +* { + -webkit-box-sizing: border-box; + -moz-box-sizing: border-box; + box-sizing: border-box; +} +*:before, +*:after { + -webkit-box-sizing: border-box; + -moz-box-sizing: border-box; + box-sizing: border-box; +} +html { + font-size: 10px; + -webkit-tap-highlight-color: rgba(0, 0, 0, 0); +} +body { + font-family: "Roboto", "Helvetica Neue", Helvetica, Arial, sans-serif; + font-size: 13px; + line-height: 1.846; + color: #666666; + background-color: #ffffff; +} +input, +button, +select, +textarea { + font-family: inherit; + font-size: inherit; + line-height: inherit; +} +a { + color: #2196f3; + text-decoration: none; +} +a:hover, +a:focus { + color: #0a6ebd; + text-decoration: underline; +} +a:focus { + outline: thin dotted; + outline: 5px auto -webkit-focus-ring-color; + outline-offset: -2px; +} +figure { + margin: 0; +} +img { + vertical-align: middle; +} +.img-responsive, +.thumbnail > img, +.thumbnail a > img, +.carousel-inner > .item > img, +.carousel-inner > .item > a > img { + display: block; + max-width: 100%; + height: auto; +} +.img-rounded { + border-radius: 3px; +} +.img-thumbnail { + padding: 4px; + line-height: 1.846; + background-color: #ffffff; + border: 1px solid #dddddd; + border-radius: 3px; + -webkit-transition: all 0.2s ease-in-out; + -o-transition: all 0.2s ease-in-out; + transition: all 0.2s ease-in-out; + display: inline-block; + max-width: 100%; + height: auto; +} +.img-circle { + border-radius: 50%; +} +hr { + margin-top: 23px; + margin-bottom: 23px; + border: 0; + border-top: 1px solid #eeeeee; +} +.sr-only { + position: absolute; + width: 1px; + height: 1px; + margin: -1px; + padding: 0; + overflow: hidden; + clip: rect(0, 0, 0, 0); + border: 0; +} +.sr-only-focusable:active, +.sr-only-focusable:focus { + position: static; + width: auto; + height: auto; + margin: 0; + overflow: visible; + clip: auto; +} +[role="button"] { + cursor: pointer; +} +h1, +h2, +h3, +h4, +h5, +h6, +.h1, +.h2, +.h3, +.h4, +.h5, +.h6 { + font-family: inherit; + font-weight: 400; + line-height: 1.1; + color: #444444; +} +h1 small, +h2 small, +h3 small, +h4 small, +h5 small, +h6 small, +.h1 small, +.h2 small, +.h3 small, +.h4 small, +.h5 small, +.h6 small, +h1 .small, +h2 .small, +h3 .small, +h4 .small, +h5 .small, +h6 .small, +.h1 .small, +.h2 .small, +.h3 .small, +.h4 .small, +.h5 .small, +.h6 .small { + font-weight: normal; + line-height: 1; + color: #bbbbbb; +} +h1, +.h1, +h2, +.h2, +h3, +.h3 { + margin-top: 23px; + margin-bottom: 11.5px; +} +h1 small, +.h1 small, +h2 small, +.h2 small, +h3 small, +.h3 small, +h1 .small, +.h1 .small, +h2 .small, +.h2 .small, +h3 .small, +.h3 .small { + font-size: 65%; +} +h4, +.h4, +h5, +.h5, +h6, +.h6 { + margin-top: 11.5px; + margin-bottom: 11.5px; +} +h4 small, +.h4 small, +h5 small, +.h5 small, +h6 small, +.h6 small, +h4 .small, +.h4 .small, +h5 .small, +.h5 .small, +h6 .small, +.h6 .small { + font-size: 75%; +} +h1, +.h1 { + font-size: 56px; +} +h2, +.h2 { + font-size: 45px; +} +h3, +.h3 { + font-size: 34px; +} +h4, +.h4 { + font-size: 24px; +} +h5, +.h5 { + font-size: 20px; +} +h6, +.h6 { + font-size: 14px; +} +p { + margin: 0 0 11.5px; +} +.lead { + margin-bottom: 23px; + font-size: 14px; + font-weight: 300; + line-height: 1.4; +} +@media (min-width: 768px) { + .lead { + font-size: 19.5px; + } +} +small, +.small { + font-size: 92%; +} +mark, +.mark { + background-color: #ffe0b2; + padding: .2em; +} +.text-left { + text-align: left; +} +.text-right { + text-align: right; +} +.text-center { + text-align: center; +} +.text-justify { + text-align: justify; +} +.text-nowrap { + white-space: nowrap; +} +.text-lowercase { + text-transform: lowercase; +} +.text-uppercase { + text-transform: uppercase; +} +.text-capitalize { + text-transform: capitalize; +} +.text-muted { + color: #bbbbbb; +} +.text-primary { + color: #2196f3; +} +a.text-primary:hover, +a.text-primary:focus { + color: #0c7cd5; +} +.text-success { + color: #4caf50; +} +a.text-success:hover, +a.text-success:focus { + color: #3d8b40; +} +.text-info { + color: #9c27b0; +} +a.text-info:hover, +a.text-info:focus { + color: #771e86; +} +.text-warning { + color: #ff9800; +} +a.text-warning:hover, +a.text-warning:focus { + color: #cc7a00; +} +.text-danger { + color: #e51c23; +} +a.text-danger:hover, +a.text-danger:focus { + color: #b9151b; +} +.bg-primary { + color: #fff; + background-color: #2196f3; +} +a.bg-primary:hover, +a.bg-primary:focus { + background-color: #0c7cd5; +} +.bg-success { + background-color: #dff0d8; +} +a.bg-success:hover, +a.bg-success:focus { + background-color: #c1e2b3; +} +.bg-info { + background-color: #e1bee7; +} +a.bg-info:hover, +a.bg-info:focus { + background-color: #d099d9; +} +.bg-warning { + background-color: #ffe0b2; +} +a.bg-warning:hover, +a.bg-warning:focus { + background-color: #ffcb7f; +} +.bg-danger { + background-color: #f9bdbb; +} +a.bg-danger:hover, +a.bg-danger:focus { + background-color: #f5908c; +} +.page-header { + padding-bottom: 10.5px; + margin: 46px 0 23px; + border-bottom: 1px solid #eeeeee; +} +ul, +ol { + margin-top: 0; + margin-bottom: 11.5px; +} +ul ul, +ol ul, +ul ol, +ol ol { + margin-bottom: 0; +} +.list-unstyled { + padding-left: 0; + list-style: none; +} +.list-inline { + padding-left: 0; + list-style: none; + margin-left: -5px; +} +.list-inline > li { + display: inline-block; + padding-left: 5px; + padding-right: 5px; +} +dl { + margin-top: 0; + margin-bottom: 23px; +} +dt, +dd { + line-height: 1.846; +} +dt { + font-weight: bold; +} +dd { + margin-left: 0; +} +@media (min-width: 768px) { + .dl-horizontal dt { + float: left; + width: 160px; + clear: left; + text-align: right; + overflow: hidden; + text-overflow: ellipsis; + white-space: nowrap; + } + .dl-horizontal dd { + margin-left: 180px; + } +} +abbr[title], +abbr[data-original-title] { + cursor: help; + border-bottom: 1px dotted #bbbbbb; +} +.initialism { + font-size: 90%; + text-transform: uppercase; +} +blockquote { + padding: 11.5px 23px; + margin: 0 0 23px; + font-size: 16.25px; + border-left: 5px solid #eeeeee; +} +blockquote p:last-child, +blockquote ul:last-child, +blockquote ol:last-child { + margin-bottom: 0; +} +blockquote footer, +blockquote small, +blockquote .small { + display: block; + font-size: 80%; + line-height: 1.846; + color: #bbbbbb; +} +blockquote footer:before, +blockquote small:before, +blockquote .small:before { + content: '\2014 \00A0'; +} +.blockquote-reverse, +blockquote.pull-right { + padding-right: 15px; + padding-left: 0; + border-right: 5px solid #eeeeee; + border-left: 0; + text-align: right; +} +.blockquote-reverse footer:before, +blockquote.pull-right footer:before, +.blockquote-reverse small:before, +blockquote.pull-right small:before, +.blockquote-reverse .small:before, +blockquote.pull-right .small:before { + content: ''; +} +.blockquote-reverse footer:after, +blockquote.pull-right footer:after, +.blockquote-reverse small:after, +blockquote.pull-right small:after, +.blockquote-reverse .small:after, +blockquote.pull-right .small:after { + content: '\00A0 \2014'; +} +address { + margin-bottom: 23px; + font-style: normal; + line-height: 1.846; +} +code, +kbd, +pre, +samp { + font-family: Menlo, Monaco, Consolas, "Courier New", monospace; +} +code { + padding: 2px 4px; + font-size: 90%; + color: #c7254e; + background-color: #f9f2f4; + border-radius: 3px; +} +kbd { + padding: 2px 4px; + font-size: 90%; + color: #ffffff; + background-color: #333333; + border-radius: 3px; + -webkit-box-shadow: inset 0 -1px 0 rgba(0, 0, 0, 0.25); + box-shadow: inset 0 -1px 0 rgba(0, 0, 0, 0.25); +} +kbd kbd { + padding: 0; + font-size: 100%; + font-weight: bold; + -webkit-box-shadow: none; + box-shadow: none; +} +pre { + display: block; + padding: 11px; + margin: 0 0 11.5px; + font-size: 12px; + line-height: 1.846; + word-break: break-all; + word-wrap: break-word; + color: #212121; + background-color: #f5f5f5; + border: 1px solid #cccccc; + border-radius: 3px; +} +pre code { + padding: 0; + font-size: inherit; + color: inherit; + white-space: pre-wrap; + background-color: transparent; + border-radius: 0; +} +.pre-scrollable { + max-height: 340px; + overflow-y: scroll; +} +.container { + margin-right: auto; + margin-left: auto; + padding-left: 15px; + padding-right: 15px; +} +@media (min-width: 768px) { + .container { + width: 750px; + } +} +@media (min-width: 992px) { + .container { + width: 970px; + } +} +@media (min-width: 1200px) { + .container { + width: 1170px; + } +} +.container-fluid { + margin-right: auto; + margin-left: auto; + padding-left: 15px; + padding-right: 15px; +} +.row { + margin-left: -15px; + margin-right: -15px; +} +.col-xs-1, .col-sm-1, .col-md-1, .col-lg-1, .col-xs-2, .col-sm-2, .col-md-2, .col-lg-2, .col-xs-3, .col-sm-3, .col-md-3, .col-lg-3, .col-xs-4, .col-sm-4, .col-md-4, .col-lg-4, .col-xs-5, .col-sm-5, .col-md-5, .col-lg-5, .col-xs-6, .col-sm-6, .col-md-6, .col-lg-6, .col-xs-7, .col-sm-7, .col-md-7, .col-lg-7, .col-xs-8, .col-sm-8, .col-md-8, .col-lg-8, .col-xs-9, .col-sm-9, .col-md-9, .col-lg-9, .col-xs-10, .col-sm-10, .col-md-10, .col-lg-10, .col-xs-11, .col-sm-11, .col-md-11, .col-lg-11, .col-xs-12, .col-sm-12, .col-md-12, .col-lg-12 { + position: relative; + min-height: 1px; + padding-left: 15px; + padding-right: 15px; +} +.col-xs-1, .col-xs-2, .col-xs-3, .col-xs-4, .col-xs-5, .col-xs-6, .col-xs-7, .col-xs-8, .col-xs-9, .col-xs-10, .col-xs-11, .col-xs-12 { + float: left; +} +.col-xs-12 { + width: 100%; +} +.col-xs-11 { + width: 91.66666667%; +} +.col-xs-10 { + width: 83.33333333%; +} +.col-xs-9 { + width: 75%; +} +.col-xs-8 { + width: 66.66666667%; +} +.col-xs-7 { + width: 58.33333333%; +} +.col-xs-6 { + width: 50%; +} +.col-xs-5 { + width: 41.66666667%; +} +.col-xs-4 { + width: 33.33333333%; +} +.col-xs-3 { + width: 25%; +} +.col-xs-2 { + width: 16.66666667%; +} +.col-xs-1 { + width: 8.33333333%; +} +.col-xs-pull-12 { + right: 100%; +} +.col-xs-pull-11 { + right: 91.66666667%; +} +.col-xs-pull-10 { + right: 83.33333333%; +} +.col-xs-pull-9 { + right: 75%; +} +.col-xs-pull-8 { + right: 66.66666667%; +} +.col-xs-pull-7 { + right: 58.33333333%; +} +.col-xs-pull-6 { + right: 50%; +} +.col-xs-pull-5 { + right: 41.66666667%; +} +.col-xs-pull-4 { + right: 33.33333333%; +} +.col-xs-pull-3 { + right: 25%; +} +.col-xs-pull-2 { + right: 16.66666667%; +} +.col-xs-pull-1 { + right: 8.33333333%; +} +.col-xs-pull-0 { + right: auto; +} +.col-xs-push-12 { + left: 100%; +} +.col-xs-push-11 { + left: 91.66666667%; +} +.col-xs-push-10 { + left: 83.33333333%; +} +.col-xs-push-9 { + left: 75%; +} +.col-xs-push-8 { + left: 66.66666667%; +} +.col-xs-push-7 { + left: 58.33333333%; +} +.col-xs-push-6 { + left: 50%; +} +.col-xs-push-5 { + left: 41.66666667%; +} +.col-xs-push-4 { + left: 33.33333333%; +} +.col-xs-push-3 { + left: 25%; +} +.col-xs-push-2 { + left: 16.66666667%; +} +.col-xs-push-1 { + left: 8.33333333%; +} +.col-xs-push-0 { + left: auto; +} +.col-xs-offset-12 { + margin-left: 100%; +} +.col-xs-offset-11 { + margin-left: 91.66666667%; +} +.col-xs-offset-10 { + margin-left: 83.33333333%; +} +.col-xs-offset-9 { + margin-left: 75%; +} +.col-xs-offset-8 { + margin-left: 66.66666667%; +} +.col-xs-offset-7 { + margin-left: 58.33333333%; +} +.col-xs-offset-6 { + margin-left: 50%; +} +.col-xs-offset-5 { + margin-left: 41.66666667%; +} +.col-xs-offset-4 { + margin-left: 33.33333333%; +} +.col-xs-offset-3 { + margin-left: 25%; +} +.col-xs-offset-2 { + margin-left: 16.66666667%; +} +.col-xs-offset-1 { + margin-left: 8.33333333%; +} +.col-xs-offset-0 { + margin-left: 0%; +} +@media (min-width: 768px) { + .col-sm-1, .col-sm-2, .col-sm-3, .col-sm-4, .col-sm-5, .col-sm-6, .col-sm-7, .col-sm-8, .col-sm-9, .col-sm-10, .col-sm-11, .col-sm-12 { + float: left; + } + .col-sm-12 { + width: 100%; + } + .col-sm-11 { + width: 91.66666667%; + } + .col-sm-10 { + width: 83.33333333%; + } + .col-sm-9 { + width: 75%; + } + .col-sm-8 { + width: 66.66666667%; + } + .col-sm-7 { + width: 58.33333333%; + } + .col-sm-6 { + width: 50%; + } + .col-sm-5 { + width: 41.66666667%; + } + .col-sm-4 { + width: 33.33333333%; + } + .col-sm-3 { + width: 25%; + } + .col-sm-2 { + width: 16.66666667%; + } + .col-sm-1 { + width: 8.33333333%; + } + .col-sm-pull-12 { + right: 100%; + } + .col-sm-pull-11 { + right: 91.66666667%; + } + .col-sm-pull-10 { + right: 83.33333333%; + } + .col-sm-pull-9 { + right: 75%; + } + .col-sm-pull-8 { + right: 66.66666667%; + } + .col-sm-pull-7 { + right: 58.33333333%; + } + .col-sm-pull-6 { + right: 50%; + } + .col-sm-pull-5 { + right: 41.66666667%; + } + .col-sm-pull-4 { + right: 33.33333333%; + } + .col-sm-pull-3 { + right: 25%; + } + .col-sm-pull-2 { + right: 16.66666667%; + } + .col-sm-pull-1 { + right: 8.33333333%; + } + .col-sm-pull-0 { + right: auto; + } + .col-sm-push-12 { + left: 100%; + } + .col-sm-push-11 { + left: 91.66666667%; + } + .col-sm-push-10 { + left: 83.33333333%; + } + .col-sm-push-9 { + left: 75%; + } + .col-sm-push-8 { + left: 66.66666667%; + } + .col-sm-push-7 { + left: 58.33333333%; + } + .col-sm-push-6 { + left: 50%; + } + .col-sm-push-5 { + left: 41.66666667%; + } + .col-sm-push-4 { + left: 33.33333333%; + } + .col-sm-push-3 { + left: 25%; + } + .col-sm-push-2 { + left: 16.66666667%; + } + .col-sm-push-1 { + left: 8.33333333%; + } + .col-sm-push-0 { + left: auto; + } + .col-sm-offset-12 { + margin-left: 100%; + } + .col-sm-offset-11 { + margin-left: 91.66666667%; + } + .col-sm-offset-10 { + margin-left: 83.33333333%; + } + .col-sm-offset-9 { + margin-left: 75%; + } + .col-sm-offset-8 { + margin-left: 66.66666667%; + } + .col-sm-offset-7 { + margin-left: 58.33333333%; + } + .col-sm-offset-6 { + margin-left: 50%; + } + .col-sm-offset-5 { + margin-left: 41.66666667%; + } + .col-sm-offset-4 { + margin-left: 33.33333333%; + } + .col-sm-offset-3 { + margin-left: 25%; + } + .col-sm-offset-2 { + margin-left: 16.66666667%; + } + .col-sm-offset-1 { + margin-left: 8.33333333%; + } + .col-sm-offset-0 { + margin-left: 0%; + } +} +@media (min-width: 992px) { + .col-md-1, .col-md-2, .col-md-3, .col-md-4, .col-md-5, .col-md-6, .col-md-7, .col-md-8, .col-md-9, .col-md-10, .col-md-11, .col-md-12 { + float: left; + } + .col-md-12 { + width: 100%; + } + .col-md-11 { + width: 91.66666667%; + } + .col-md-10 { + width: 83.33333333%; + } + .col-md-9 { + width: 75%; + } + .col-md-8 { + width: 66.66666667%; + } + .col-md-7 { + width: 58.33333333%; + } + .col-md-6 { + width: 50%; + } + .col-md-5 { + width: 41.66666667%; + } + .col-md-4 { + width: 33.33333333%; + } + .col-md-3 { + width: 25%; + } + .col-md-2 { + width: 16.66666667%; + } + .col-md-1 { + width: 8.33333333%; + } + .col-md-pull-12 { + right: 100%; + } + .col-md-pull-11 { + right: 91.66666667%; + } + .col-md-pull-10 { + right: 83.33333333%; + } + .col-md-pull-9 { + right: 75%; + } + .col-md-pull-8 { + right: 66.66666667%; + } + .col-md-pull-7 { + right: 58.33333333%; + } + .col-md-pull-6 { + right: 50%; + } + .col-md-pull-5 { + right: 41.66666667%; + } + .col-md-pull-4 { + right: 33.33333333%; + } + .col-md-pull-3 { + right: 25%; + } + .col-md-pull-2 { + right: 16.66666667%; + } + .col-md-pull-1 { + right: 8.33333333%; + } + .col-md-pull-0 { + right: auto; + } + .col-md-push-12 { + left: 100%; + } + .col-md-push-11 { + left: 91.66666667%; + } + .col-md-push-10 { + left: 83.33333333%; + } + .col-md-push-9 { + left: 75%; + } + .col-md-push-8 { + left: 66.66666667%; + } + .col-md-push-7 { + left: 58.33333333%; + } + .col-md-push-6 { + left: 50%; + } + .col-md-push-5 { + left: 41.66666667%; + } + .col-md-push-4 { + left: 33.33333333%; + } + .col-md-push-3 { + left: 25%; + } + .col-md-push-2 { + left: 16.66666667%; + } + .col-md-push-1 { + left: 8.33333333%; + } + .col-md-push-0 { + left: auto; + } + .col-md-offset-12 { + margin-left: 100%; + } + .col-md-offset-11 { + margin-left: 91.66666667%; + } + .col-md-offset-10 { + margin-left: 83.33333333%; + } + .col-md-offset-9 { + margin-left: 75%; + } + .col-md-offset-8 { + margin-left: 66.66666667%; + } + .col-md-offset-7 { + margin-left: 58.33333333%; + } + .col-md-offset-6 { + margin-left: 50%; + } + .col-md-offset-5 { + margin-left: 41.66666667%; + } + .col-md-offset-4 { + margin-left: 33.33333333%; + } + .col-md-offset-3 { + margin-left: 25%; + } + .col-md-offset-2 { + margin-left: 16.66666667%; + } + .col-md-offset-1 { + margin-left: 8.33333333%; + } + .col-md-offset-0 { + margin-left: 0%; + } +} +@media (min-width: 1200px) { + .col-lg-1, .col-lg-2, .col-lg-3, .col-lg-4, .col-lg-5, .col-lg-6, .col-lg-7, .col-lg-8, .col-lg-9, .col-lg-10, .col-lg-11, .col-lg-12 { + float: left; + } + .col-lg-12 { + width: 100%; + } + .col-lg-11 { + width: 91.66666667%; + } + .col-lg-10 { + width: 83.33333333%; + } + .col-lg-9 { + width: 75%; + } + .col-lg-8 { + width: 66.66666667%; + } + .col-lg-7 { + width: 58.33333333%; + } + .col-lg-6 { + width: 50%; + } + .col-lg-5 { + width: 41.66666667%; + } + .col-lg-4 { + width: 33.33333333%; + } + .col-lg-3 { + width: 25%; + } + .col-lg-2 { + width: 16.66666667%; + } + .col-lg-1 { + width: 8.33333333%; + } + .col-lg-pull-12 { + right: 100%; + } + .col-lg-pull-11 { + right: 91.66666667%; + } + .col-lg-pull-10 { + right: 83.33333333%; + } + .col-lg-pull-9 { + right: 75%; + } + .col-lg-pull-8 { + right: 66.66666667%; + } + .col-lg-pull-7 { + right: 58.33333333%; + } + .col-lg-pull-6 { + right: 50%; + } + .col-lg-pull-5 { + right: 41.66666667%; + } + .col-lg-pull-4 { + right: 33.33333333%; + } + .col-lg-pull-3 { + right: 25%; + } + .col-lg-pull-2 { + right: 16.66666667%; + } + .col-lg-pull-1 { + right: 8.33333333%; + } + .col-lg-pull-0 { + right: auto; + } + .col-lg-push-12 { + left: 100%; + } + .col-lg-push-11 { + left: 91.66666667%; + } + .col-lg-push-10 { + left: 83.33333333%; + } + .col-lg-push-9 { + left: 75%; + } + .col-lg-push-8 { + left: 66.66666667%; + } + .col-lg-push-7 { + left: 58.33333333%; + } + .col-lg-push-6 { + left: 50%; + } + .col-lg-push-5 { + left: 41.66666667%; + } + .col-lg-push-4 { + left: 33.33333333%; + } + .col-lg-push-3 { + left: 25%; + } + .col-lg-push-2 { + left: 16.66666667%; + } + .col-lg-push-1 { + left: 8.33333333%; + } + .col-lg-push-0 { + left: auto; + } + .col-lg-offset-12 { + margin-left: 100%; + } + .col-lg-offset-11 { + margin-left: 91.66666667%; + } + .col-lg-offset-10 { + margin-left: 83.33333333%; + } + .col-lg-offset-9 { + margin-left: 75%; + } + .col-lg-offset-8 { + margin-left: 66.66666667%; + } + .col-lg-offset-7 { + margin-left: 58.33333333%; + } + .col-lg-offset-6 { + margin-left: 50%; + } + .col-lg-offset-5 { + margin-left: 41.66666667%; + } + .col-lg-offset-4 { + margin-left: 33.33333333%; + } + .col-lg-offset-3 { + margin-left: 25%; + } + .col-lg-offset-2 { + margin-left: 16.66666667%; + } + .col-lg-offset-1 { + margin-left: 8.33333333%; + } + .col-lg-offset-0 { + margin-left: 0%; + } +} +table { + background-color: transparent; +} +caption { + padding-top: 8px; + padding-bottom: 8px; + color: #bbbbbb; + text-align: left; +} +th { + text-align: left; +} +.table { + width: 100%; + max-width: 100%; + margin-bottom: 23px; +} +.table > thead > tr > th, +.table > tbody > tr > th, +.table > tfoot > tr > th, +.table > thead > tr > td, +.table > tbody > tr > td, +.table > tfoot > tr > td { + padding: 8px; + line-height: 1.846; + vertical-align: top; + border-top: 1px solid #dddddd; +} +.table > thead > tr > th { + vertical-align: bottom; + border-bottom: 2px solid #dddddd; +} +.table > caption + thead > tr:first-child > th, +.table > colgroup + thead > tr:first-child > th, +.table > thead:first-child > tr:first-child > th, +.table > caption + thead > tr:first-child > td, +.table > colgroup + thead > tr:first-child > td, +.table > thead:first-child > tr:first-child > td { + border-top: 0; +} +.table > tbody + tbody { + border-top: 2px solid #dddddd; +} +.table .table { + background-color: #ffffff; +} +.table-condensed > thead > tr > th, +.table-condensed > tbody > tr > th, +.table-condensed > tfoot > tr > th, +.table-condensed > thead > tr > td, +.table-condensed > tbody > tr > td, +.table-condensed > tfoot > tr > td { + padding: 5px; +} +.table-bordered { + border: 1px solid #dddddd; +} +.table-bordered > thead > tr > th, +.table-bordered > tbody > tr > th, +.table-bordered > tfoot > tr > th, +.table-bordered > thead > tr > td, +.table-bordered > tbody > tr > td, +.table-bordered > tfoot > tr > td { + border: 1px solid #dddddd; +} +.table-bordered > thead > tr > th, +.table-bordered > thead > tr > td { + border-bottom-width: 2px; +} +.table-striped > tbody > tr:nth-of-type(odd) { + background-color: #f9f9f9; +} +.table-hover > tbody > tr:hover { + background-color: #f5f5f5; +} +table col[class*="col-"] { + position: static; + float: none; + display: table-column; +} +table td[class*="col-"], +table th[class*="col-"] { + position: static; + float: none; + display: table-cell; +} +.table > thead > tr > td.active, +.table > tbody > tr > td.active, +.table > tfoot > tr > td.active, +.table > thead > tr > th.active, +.table > tbody > tr > th.active, +.table > tfoot > tr > th.active, +.table > thead > tr.active > td, +.table > tbody > tr.active > td, +.table > tfoot > tr.active > td, +.table > thead > tr.active > th, +.table > tbody > tr.active > th, +.table > tfoot > tr.active > th { + background-color: #f5f5f5; +} +.table-hover > tbody > tr > td.active:hover, +.table-hover > tbody > tr > th.active:hover, +.table-hover > tbody > tr.active:hover > td, +.table-hover > tbody > tr:hover > .active, +.table-hover > tbody > tr.active:hover > th { + background-color: #e8e8e8; +} +.table > thead > tr > td.success, +.table > tbody > tr > td.success, +.table > tfoot > tr > td.success, +.table > thead > tr > th.success, +.table > tbody > tr > th.success, +.table > tfoot > tr > th.success, +.table > thead > tr.success > td, +.table > tbody > tr.success > td, +.table > tfoot > tr.success > td, +.table > thead > tr.success > th, +.table > tbody > tr.success > th, +.table > tfoot > tr.success > th { + background-color: #dff0d8; +} +.table-hover > tbody > tr > td.success:hover, +.table-hover > tbody > tr > th.success:hover, +.table-hover > tbody > tr.success:hover > td, +.table-hover > tbody > tr:hover > .success, +.table-hover > tbody > tr.success:hover > th { + background-color: #d0e9c6; +} +.table > thead > tr > td.info, +.table > tbody > tr > td.info, +.table > tfoot > tr > td.info, +.table > thead > tr > th.info, +.table > tbody > tr > th.info, +.table > tfoot > tr > th.info, +.table > thead > tr.info > td, +.table > tbody > tr.info > td, +.table > tfoot > tr.info > td, +.table > thead > tr.info > th, +.table > tbody > tr.info > th, +.table > tfoot > tr.info > th { + background-color: #e1bee7; +} +.table-hover > tbody > tr > td.info:hover, +.table-hover > tbody > tr > th.info:hover, +.table-hover > tbody > tr.info:hover > td, +.table-hover > tbody > tr:hover > .info, +.table-hover > tbody > tr.info:hover > th { + background-color: #d8abe0; +} +.table > thead > tr > td.warning, +.table > tbody > tr > td.warning, +.table > tfoot > tr > td.warning, +.table > thead > tr > th.warning, +.table > tbody > tr > th.warning, +.table > tfoot > tr > th.warning, +.table > thead > tr.warning > td, +.table > tbody > tr.warning > td, +.table > tfoot > tr.warning > td, +.table > thead > tr.warning > th, +.table > tbody > tr.warning > th, +.table > tfoot > tr.warning > th { + background-color: #ffe0b2; +} +.table-hover > tbody > tr > td.warning:hover, +.table-hover > tbody > tr > th.warning:hover, +.table-hover > tbody > tr.warning:hover > td, +.table-hover > tbody > tr:hover > .warning, +.table-hover > tbody > tr.warning:hover > th { + background-color: #ffd699; +} +.table > thead > tr > td.danger, +.table > tbody > tr > td.danger, +.table > tfoot > tr > td.danger, +.table > thead > tr > th.danger, +.table > tbody > tr > th.danger, +.table > tfoot > tr > th.danger, +.table > thead > tr.danger > td, +.table > tbody > tr.danger > td, +.table > tfoot > tr.danger > td, +.table > thead > tr.danger > th, +.table > tbody > tr.danger > th, +.table > tfoot > tr.danger > th { + background-color: #f9bdbb; +} +.table-hover > tbody > tr > td.danger:hover, +.table-hover > tbody > tr > th.danger:hover, +.table-hover > tbody > tr.danger:hover > td, +.table-hover > tbody > tr:hover > .danger, +.table-hover > tbody > tr.danger:hover > th { + background-color: #f7a6a4; +} +.table-responsive { + overflow-x: auto; + min-height: 0.01%; +} +@media screen and (max-width: 767px) { + .table-responsive { + width: 100%; + margin-bottom: 17.25px; + overflow-y: hidden; + -ms-overflow-style: -ms-autohiding-scrollbar; + border: 1px solid #dddddd; + } + .table-responsive > .table { + margin-bottom: 0; + } + .table-responsive > .table > thead > tr > th, + .table-responsive > .table > tbody > tr > th, + .table-responsive > .table > tfoot > tr > th, + .table-responsive > .table > thead > tr > td, + .table-responsive > .table > tbody > tr > td, + .table-responsive > .table > tfoot > tr > td { + white-space: nowrap; + } + .table-responsive > .table-bordered { + border: 0; + } + .table-responsive > .table-bordered > thead > tr > th:first-child, + .table-responsive > .table-bordered > tbody > tr > th:first-child, + .table-responsive > .table-bordered > tfoot > tr > th:first-child, + .table-responsive > .table-bordered > thead > tr > td:first-child, + .table-responsive > .table-bordered > tbody > tr > td:first-child, + .table-responsive > .table-bordered > tfoot > tr > td:first-child { + border-left: 0; + } + .table-responsive > .table-bordered > thead > tr > th:last-child, + .table-responsive > .table-bordered > tbody > tr > th:last-child, + .table-responsive > .table-bordered > tfoot > tr > th:last-child, + .table-responsive > .table-bordered > thead > tr > td:last-child, + .table-responsive > .table-bordered > tbody > tr > td:last-child, + .table-responsive > .table-bordered > tfoot > tr > td:last-child { + border-right: 0; + } + .table-responsive > .table-bordered > tbody > tr:last-child > th, + .table-responsive > .table-bordered > tfoot > tr:last-child > th, + .table-responsive > .table-bordered > tbody > tr:last-child > td, + .table-responsive > .table-bordered > tfoot > tr:last-child > td { + border-bottom: 0; + } +} +fieldset { + padding: 0; + margin: 0; + border: 0; + min-width: 0; +} +legend { + display: block; + width: 100%; + padding: 0; + margin-bottom: 23px; + font-size: 19.5px; + line-height: inherit; + color: #212121; + border: 0; + border-bottom: 1px solid #e5e5e5; +} +label { + display: inline-block; + max-width: 100%; + margin-bottom: 5px; + font-weight: bold; +} +input[type="search"] { + -webkit-box-sizing: border-box; + -moz-box-sizing: border-box; + box-sizing: border-box; +} +input[type="radio"], +input[type="checkbox"] { + margin: 4px 0 0; + margin-top: 1px \9; + line-height: normal; +} +input[type="file"] { + display: block; +} +input[type="range"] { + display: block; + width: 100%; +} +select[multiple], +select[size] { + height: auto; +} +input[type="file"]:focus, +input[type="radio"]:focus, +input[type="checkbox"]:focus { + outline: thin dotted; + outline: 5px auto -webkit-focus-ring-color; + outline-offset: -2px; +} +output { + display: block; + padding-top: 7px; + font-size: 13px; + line-height: 1.846; + color: #666666; +} +.form-control { + display: block; + width: 100%; + height: 37px; + padding: 6px 16px; + font-size: 13px; + line-height: 1.846; + color: #666666; + background-color: transparent; + background-image: none; + border: 1px solid transparent; + border-radius: 3px; + -webkit-box-shadow: inset 0 1px 1px rgba(0, 0, 0, 0.075); + box-shadow: inset 0 1px 1px rgba(0, 0, 0, 0.075); + -webkit-transition: border-color ease-in-out .15s, -webkit-box-shadow ease-in-out .15s; + -o-transition: border-color ease-in-out .15s, box-shadow ease-in-out .15s; + transition: border-color ease-in-out .15s, box-shadow ease-in-out .15s; +} +.form-control:focus { + border-color: #66afe9; + outline: 0; + -webkit-box-shadow: inset 0 1px 1px rgba(0,0,0,.075), 0 0 8px rgba(102, 175, 233, 0.6); + box-shadow: inset 0 1px 1px rgba(0,0,0,.075), 0 0 8px rgba(102, 175, 233, 0.6); +} +.form-control::-moz-placeholder { + color: #bbbbbb; + opacity: 1; +} +.form-control:-ms-input-placeholder { + color: #bbbbbb; +} +.form-control::-webkit-input-placeholder { + color: #bbbbbb; +} +.form-control[disabled], +.form-control[readonly], +fieldset[disabled] .form-control { + background-color: transparent; + opacity: 1; +} +.form-control[disabled], +fieldset[disabled] .form-control { + cursor: not-allowed; +} +textarea.form-control { + height: auto; +} +input[type="search"] { + -webkit-appearance: none; +} +@media screen and (-webkit-min-device-pixel-ratio: 0) { + input[type="date"].form-control, + input[type="time"].form-control, + input[type="datetime-local"].form-control, + input[type="month"].form-control { + line-height: 37px; + } + input[type="date"].input-sm, + input[type="time"].input-sm, + input[type="datetime-local"].input-sm, + input[type="month"].input-sm, + .input-group-sm input[type="date"], + .input-group-sm input[type="time"], + .input-group-sm input[type="datetime-local"], + .input-group-sm input[type="month"] { + line-height: 30px; + } + input[type="date"].input-lg, + input[type="time"].input-lg, + input[type="datetime-local"].input-lg, + input[type="month"].input-lg, + .input-group-lg input[type="date"], + .input-group-lg input[type="time"], + .input-group-lg input[type="datetime-local"], + .input-group-lg input[type="month"] { + line-height: 45px; + } +} +.form-group { + margin-bottom: 15px; +} +.radio, +.checkbox { + position: relative; + display: block; + margin-top: 10px; + margin-bottom: 10px; +} +.radio label, +.checkbox label { + min-height: 23px; + padding-left: 20px; + margin-bottom: 0; + font-weight: normal; + cursor: pointer; +} +.radio input[type="radio"], +.radio-inline input[type="radio"], +.checkbox input[type="checkbox"], +.checkbox-inline input[type="checkbox"] { + position: absolute; + margin-left: -20px; + margin-top: 4px \9; +} +.radio + .radio, +.checkbox + .checkbox { + margin-top: -5px; +} +.radio-inline, +.checkbox-inline { + position: relative; + display: inline-block; + padding-left: 20px; + margin-bottom: 0; + vertical-align: middle; + font-weight: normal; + cursor: pointer; +} +.radio-inline + .radio-inline, +.checkbox-inline + .checkbox-inline { + margin-top: 0; + margin-left: 10px; +} +input[type="radio"][disabled], +input[type="checkbox"][disabled], +input[type="radio"].disabled, +input[type="checkbox"].disabled, +fieldset[disabled] input[type="radio"], +fieldset[disabled] input[type="checkbox"] { + cursor: not-allowed; +} +.radio-inline.disabled, +.checkbox-inline.disabled, +fieldset[disabled] .radio-inline, +fieldset[disabled] .checkbox-inline { + cursor: not-allowed; +} +.radio.disabled label, +.checkbox.disabled label, +fieldset[disabled] .radio label, +fieldset[disabled] .checkbox label { + cursor: not-allowed; +} +.form-control-static { + padding-top: 7px; + padding-bottom: 7px; + margin-bottom: 0; + min-height: 36px; +} +.form-control-static.input-lg, +.form-control-static.input-sm { + padding-left: 0; + padding-right: 0; +} +.input-sm { + height: 30px; + padding: 5px 10px; + font-size: 12px; + line-height: 1.5; + border-radius: 3px; +} +select.input-sm { + height: 30px; + line-height: 30px; +} +textarea.input-sm, +select[multiple].input-sm { + height: auto; +} +.form-group-sm .form-control { + height: 30px; + padding: 5px 10px; + font-size: 12px; + line-height: 1.5; + border-radius: 3px; +} +.form-group-sm select.form-control { + height: 30px; + line-height: 30px; +} +.form-group-sm textarea.form-control, +.form-group-sm select[multiple].form-control { + height: auto; +} +.form-group-sm .form-control-static { + height: 30px; + min-height: 35px; + padding: 6px 10px; + font-size: 12px; + line-height: 1.5; +} +.input-lg { + height: 45px; + padding: 10px 16px; + font-size: 17px; + line-height: 1.3333333; + border-radius: 3px; +} +select.input-lg { + height: 45px; + line-height: 45px; +} +textarea.input-lg, +select[multiple].input-lg { + height: auto; +} +.form-group-lg .form-control { + height: 45px; + padding: 10px 16px; + font-size: 17px; + line-height: 1.3333333; + border-radius: 3px; +} +.form-group-lg select.form-control { + height: 45px; + line-height: 45px; +} +.form-group-lg textarea.form-control, +.form-group-lg select[multiple].form-control { + height: auto; +} +.form-group-lg .form-control-static { + height: 45px; + min-height: 40px; + padding: 11px 16px; + font-size: 17px; + line-height: 1.3333333; +} +.has-feedback { + position: relative; +} +.has-feedback .form-control { + padding-right: 46.25px; +} +.form-control-feedback { + position: absolute; + top: 0; + right: 0; + z-index: 2; + display: block; + width: 37px; + height: 37px; + line-height: 37px; + text-align: center; + pointer-events: none; +} +.input-lg + .form-control-feedback, +.input-group-lg + .form-control-feedback, +.form-group-lg .form-control + .form-control-feedback { + width: 45px; + height: 45px; + line-height: 45px; +} +.input-sm + .form-control-feedback, +.input-group-sm + .form-control-feedback, +.form-group-sm .form-control + .form-control-feedback { + width: 30px; + height: 30px; + line-height: 30px; +} +.has-success .help-block, +.has-success .control-label, +.has-success .radio, +.has-success .checkbox, +.has-success .radio-inline, +.has-success .checkbox-inline, +.has-success.radio label, +.has-success.checkbox label, +.has-success.radio-inline label, +.has-success.checkbox-inline label { + color: #4caf50; +} +.has-success .form-control { + border-color: #4caf50; + -webkit-box-shadow: inset 0 1px 1px rgba(0, 0, 0, 0.075); + box-shadow: inset 0 1px 1px rgba(0, 0, 0, 0.075); +} +.has-success .form-control:focus { + border-color: #3d8b40; + -webkit-box-shadow: inset 0 1px 1px rgba(0, 0, 0, 0.075), 0 0 6px #92cf94; + box-shadow: inset 0 1px 1px rgba(0, 0, 0, 0.075), 0 0 6px #92cf94; +} +.has-success .input-group-addon { + color: #4caf50; + border-color: #4caf50; + background-color: #dff0d8; +} +.has-success .form-control-feedback { + color: #4caf50; +} +.has-warning .help-block, +.has-warning .control-label, +.has-warning .radio, +.has-warning .checkbox, +.has-warning .radio-inline, +.has-warning .checkbox-inline, +.has-warning.radio label, +.has-warning.checkbox label, +.has-warning.radio-inline label, +.has-warning.checkbox-inline label { + color: #ff9800; +} +.has-warning .form-control { + border-color: #ff9800; + -webkit-box-shadow: inset 0 1px 1px rgba(0, 0, 0, 0.075); + box-shadow: inset 0 1px 1px rgba(0, 0, 0, 0.075); +} +.has-warning .form-control:focus { + border-color: #cc7a00; + -webkit-box-shadow: inset 0 1px 1px rgba(0, 0, 0, 0.075), 0 0 6px #ffc166; + box-shadow: inset 0 1px 1px rgba(0, 0, 0, 0.075), 0 0 6px #ffc166; +} +.has-warning .input-group-addon { + color: #ff9800; + border-color: #ff9800; + background-color: #ffe0b2; +} +.has-warning .form-control-feedback { + color: #ff9800; +} +.has-error .help-block, +.has-error .control-label, +.has-error .radio, +.has-error .checkbox, +.has-error .radio-inline, +.has-error .checkbox-inline, +.has-error.radio label, +.has-error.checkbox label, +.has-error.radio-inline label, +.has-error.checkbox-inline label { + color: #e51c23; +} +.has-error .form-control { + border-color: #e51c23; + -webkit-box-shadow: inset 0 1px 1px rgba(0, 0, 0, 0.075); + box-shadow: inset 0 1px 1px rgba(0, 0, 0, 0.075); +} +.has-error .form-control:focus { + border-color: #b9151b; + -webkit-box-shadow: inset 0 1px 1px rgba(0, 0, 0, 0.075), 0 0 6px #ef787c; + box-shadow: inset 0 1px 1px rgba(0, 0, 0, 0.075), 0 0 6px #ef787c; +} +.has-error .input-group-addon { + color: #e51c23; + border-color: #e51c23; + background-color: #f9bdbb; +} +.has-error .form-control-feedback { + color: #e51c23; +} +.has-feedback label ~ .form-control-feedback { + top: 28px; +} +.has-feedback label.sr-only ~ .form-control-feedback { + top: 0; +} +.help-block { + display: block; + margin-top: 5px; + margin-bottom: 10px; + color: #a6a6a6; +} +@media (min-width: 768px) { + .form-inline .form-group { + display: inline-block; + margin-bottom: 0; + vertical-align: middle; + } + .form-inline .form-control { + display: inline-block; + width: auto; + vertical-align: middle; + } + .form-inline .form-control-static { + display: inline-block; + } + .form-inline .input-group { + display: inline-table; + vertical-align: middle; + } + .form-inline .input-group .input-group-addon, + .form-inline .input-group .input-group-btn, + .form-inline .input-group .form-control { + width: auto; + } + .form-inline .input-group > .form-control { + width: 100%; + } + .form-inline .control-label { + margin-bottom: 0; + vertical-align: middle; + } + .form-inline .radio, + .form-inline .checkbox { + display: inline-block; + margin-top: 0; + margin-bottom: 0; + vertical-align: middle; + } + .form-inline .radio label, + .form-inline .checkbox label { + padding-left: 0; + } + .form-inline .radio input[type="radio"], + .form-inline .checkbox input[type="checkbox"] { + position: relative; + margin-left: 0; + } + .form-inline .has-feedback .form-control-feedback { + top: 0; + } +} +.form-horizontal .radio, +.form-horizontal .checkbox, +.form-horizontal .radio-inline, +.form-horizontal .checkbox-inline { + margin-top: 0; + margin-bottom: 0; + padding-top: 7px; +} +.form-horizontal .radio, +.form-horizontal .checkbox { + min-height: 30px; +} +.form-horizontal .form-group { + margin-left: -15px; + margin-right: -15px; +} +@media (min-width: 768px) { + .form-horizontal .control-label { + text-align: right; + margin-bottom: 0; + padding-top: 7px; + } +} +.form-horizontal .has-feedback .form-control-feedback { + right: 15px; +} +@media (min-width: 768px) { + .form-horizontal .form-group-lg .control-label { + padding-top: 14.333333px; + font-size: 17px; + } +} +@media (min-width: 768px) { + .form-horizontal .form-group-sm .control-label { + padding-top: 6px; + font-size: 12px; + } +} +.btn { + display: inline-block; + margin-bottom: 0; + font-weight: normal; + text-align: center; + vertical-align: middle; + -ms-touch-action: manipulation; + touch-action: manipulation; + cursor: pointer; + background-image: none; + border: 1px solid transparent; + white-space: nowrap; + padding: 6px 16px; + font-size: 13px; + line-height: 1.846; + border-radius: 3px; + -webkit-user-select: none; + -moz-user-select: none; + -ms-user-select: none; + user-select: none; +} +.btn:focus, +.btn:active:focus, +.btn.active:focus, +.btn.focus, +.btn:active.focus, +.btn.active.focus { + outline: thin dotted; + outline: 5px auto -webkit-focus-ring-color; + outline-offset: -2px; +} +.btn:hover, +.btn:focus, +.btn.focus { + color: #666666; + text-decoration: none; +} +.btn:active, +.btn.active { + outline: 0; + background-image: none; + -webkit-box-shadow: inset 0 3px 5px rgba(0, 0, 0, 0.125); + box-shadow: inset 0 3px 5px rgba(0, 0, 0, 0.125); +} +.btn.disabled, +.btn[disabled], +fieldset[disabled] .btn { + cursor: not-allowed; + opacity: 0.65; + filter: alpha(opacity=65); + -webkit-box-shadow: none; + box-shadow: none; +} +a.btn.disabled, +fieldset[disabled] a.btn { + pointer-events: none; +} +.btn-default { + color: #666666; + background-color: #ffffff; + border-color: #eeeeee; +} +.btn-default:focus, +.btn-default.focus { + color: #666666; + background-color: #e6e6e6; + border-color: #aeaeae; +} +.btn-default:hover { + color: #666666; + background-color: #e6e6e6; + border-color: #cfcfcf; +} +.btn-default:active, +.btn-default.active, +.open > .dropdown-toggle.btn-default { + color: #666666; + background-color: #e6e6e6; + border-color: #cfcfcf; +} +.btn-default:active:hover, +.btn-default.active:hover, +.open > .dropdown-toggle.btn-default:hover, +.btn-default:active:focus, +.btn-default.active:focus, +.open > .dropdown-toggle.btn-default:focus, +.btn-default:active.focus, +.btn-default.active.focus, +.open > .dropdown-toggle.btn-default.focus { + color: #666666; + background-color: #d4d4d4; + border-color: #aeaeae; +} +.btn-default:active, +.btn-default.active, +.open > .dropdown-toggle.btn-default { + background-image: none; +} +.btn-default.disabled, +.btn-default[disabled], +fieldset[disabled] .btn-default, +.btn-default.disabled:hover, +.btn-default[disabled]:hover, +fieldset[disabled] .btn-default:hover, +.btn-default.disabled:focus, +.btn-default[disabled]:focus, +fieldset[disabled] .btn-default:focus, +.btn-default.disabled.focus, +.btn-default[disabled].focus, +fieldset[disabled] .btn-default.focus, +.btn-default.disabled:active, +.btn-default[disabled]:active, +fieldset[disabled] .btn-default:active, +.btn-default.disabled.active, +.btn-default[disabled].active, +fieldset[disabled] .btn-default.active { + background-color: #ffffff; + border-color: #eeeeee; +} +.btn-default .badge { + color: #ffffff; + background-color: #666666; +} +.btn-primary { + color: #ffffff; + background-color: #2196f3; + border-color: transparent; +} +.btn-primary:focus, +.btn-primary.focus { + color: #ffffff; + background-color: #0c7cd5; + border-color: rgba(0, 0, 0, 0); +} +.btn-primary:hover { + color: #ffffff; + background-color: #0c7cd5; + border-color: rgba(0, 0, 0, 0); +} +.btn-primary:active, +.btn-primary.active, +.open > .dropdown-toggle.btn-primary { + color: #ffffff; + background-color: #0c7cd5; + border-color: rgba(0, 0, 0, 0); +} +.btn-primary:active:hover, +.btn-primary.active:hover, +.open > .dropdown-toggle.btn-primary:hover, +.btn-primary:active:focus, +.btn-primary.active:focus, +.open > .dropdown-toggle.btn-primary:focus, +.btn-primary:active.focus, +.btn-primary.active.focus, +.open > .dropdown-toggle.btn-primary.focus { + color: #ffffff; + background-color: #0a68b4; + border-color: rgba(0, 0, 0, 0); +} +.btn-primary:active, +.btn-primary.active, +.open > .dropdown-toggle.btn-primary { + background-image: none; +} +.btn-primary.disabled, +.btn-primary[disabled], +fieldset[disabled] .btn-primary, +.btn-primary.disabled:hover, +.btn-primary[disabled]:hover, +fieldset[disabled] .btn-primary:hover, +.btn-primary.disabled:focus, +.btn-primary[disabled]:focus, +fieldset[disabled] .btn-primary:focus, +.btn-primary.disabled.focus, +.btn-primary[disabled].focus, +fieldset[disabled] .btn-primary.focus, +.btn-primary.disabled:active, +.btn-primary[disabled]:active, +fieldset[disabled] .btn-primary:active, +.btn-primary.disabled.active, +.btn-primary[disabled].active, +fieldset[disabled] .btn-primary.active { + background-color: #2196f3; + border-color: transparent; +} +.btn-primary .badge { + color: #2196f3; + background-color: #ffffff; +} +.btn-success { + color: #ffffff; + background-color: #4caf50; + border-color: transparent; +} +.btn-success:focus, +.btn-success.focus { + color: #ffffff; + background-color: #3d8b40; + border-color: rgba(0, 0, 0, 0); +} +.btn-success:hover { + color: #ffffff; + background-color: #3d8b40; + border-color: rgba(0, 0, 0, 0); +} +.btn-success:active, +.btn-success.active, +.open > .dropdown-toggle.btn-success { + color: #ffffff; + background-color: #3d8b40; + border-color: rgba(0, 0, 0, 0); +} +.btn-success:active:hover, +.btn-success.active:hover, +.open > .dropdown-toggle.btn-success:hover, +.btn-success:active:focus, +.btn-success.active:focus, +.open > .dropdown-toggle.btn-success:focus, +.btn-success:active.focus, +.btn-success.active.focus, +.open > .dropdown-toggle.btn-success.focus { + color: #ffffff; + background-color: #327334; + border-color: rgba(0, 0, 0, 0); +} +.btn-success:active, +.btn-success.active, +.open > .dropdown-toggle.btn-success { + background-image: none; +} +.btn-success.disabled, +.btn-success[disabled], +fieldset[disabled] .btn-success, +.btn-success.disabled:hover, +.btn-success[disabled]:hover, +fieldset[disabled] .btn-success:hover, +.btn-success.disabled:focus, +.btn-success[disabled]:focus, +fieldset[disabled] .btn-success:focus, +.btn-success.disabled.focus, +.btn-success[disabled].focus, +fieldset[disabled] .btn-success.focus, +.btn-success.disabled:active, +.btn-success[disabled]:active, +fieldset[disabled] .btn-success:active, +.btn-success.disabled.active, +.btn-success[disabled].active, +fieldset[disabled] .btn-success.active { + background-color: #4caf50; + border-color: transparent; +} +.btn-success .badge { + color: #4caf50; + background-color: #ffffff; +} +.btn-info { + color: #ffffff; + background-color: #9c27b0; + border-color: transparent; +} +.btn-info:focus, +.btn-info.focus { + color: #ffffff; + background-color: #771e86; + border-color: rgba(0, 0, 0, 0); +} +.btn-info:hover { + color: #ffffff; + background-color: #771e86; + border-color: rgba(0, 0, 0, 0); +} +.btn-info:active, +.btn-info.active, +.open > .dropdown-toggle.btn-info { + color: #ffffff; + background-color: #771e86; + border-color: rgba(0, 0, 0, 0); +} +.btn-info:active:hover, +.btn-info.active:hover, +.open > .dropdown-toggle.btn-info:hover, +.btn-info:active:focus, +.btn-info.active:focus, +.open > .dropdown-toggle.btn-info:focus, +.btn-info:active.focus, +.btn-info.active.focus, +.open > .dropdown-toggle.btn-info.focus { + color: #ffffff; + background-color: #5d1769; + border-color: rgba(0, 0, 0, 0); +} +.btn-info:active, +.btn-info.active, +.open > .dropdown-toggle.btn-info { + background-image: none; +} +.btn-info.disabled, +.btn-info[disabled], +fieldset[disabled] .btn-info, +.btn-info.disabled:hover, +.btn-info[disabled]:hover, +fieldset[disabled] .btn-info:hover, +.btn-info.disabled:focus, +.btn-info[disabled]:focus, +fieldset[disabled] .btn-info:focus, +.btn-info.disabled.focus, +.btn-info[disabled].focus, +fieldset[disabled] .btn-info.focus, +.btn-info.disabled:active, +.btn-info[disabled]:active, +fieldset[disabled] .btn-info:active, +.btn-info.disabled.active, +.btn-info[disabled].active, +fieldset[disabled] .btn-info.active { + background-color: #9c27b0; + border-color: transparent; +} +.btn-info .badge { + color: #9c27b0; + background-color: #ffffff; +} +.btn-warning { + color: #ffffff; + background-color: #ff9800; + border-color: transparent; +} +.btn-warning:focus, +.btn-warning.focus { + color: #ffffff; + background-color: #cc7a00; + border-color: rgba(0, 0, 0, 0); +} +.btn-warning:hover { + color: #ffffff; + background-color: #cc7a00; + border-color: rgba(0, 0, 0, 0); +} +.btn-warning:active, +.btn-warning.active, +.open > .dropdown-toggle.btn-warning { + color: #ffffff; + background-color: #cc7a00; + border-color: rgba(0, 0, 0, 0); +} +.btn-warning:active:hover, +.btn-warning.active:hover, +.open > .dropdown-toggle.btn-warning:hover, +.btn-warning:active:focus, +.btn-warning.active:focus, +.open > .dropdown-toggle.btn-warning:focus, +.btn-warning:active.focus, +.btn-warning.active.focus, +.open > .dropdown-toggle.btn-warning.focus { + color: #ffffff; + background-color: #a86400; + border-color: rgba(0, 0, 0, 0); +} +.btn-warning:active, +.btn-warning.active, +.open > .dropdown-toggle.btn-warning { + background-image: none; +} +.btn-warning.disabled, +.btn-warning[disabled], +fieldset[disabled] .btn-warning, +.btn-warning.disabled:hover, +.btn-warning[disabled]:hover, +fieldset[disabled] .btn-warning:hover, +.btn-warning.disabled:focus, +.btn-warning[disabled]:focus, +fieldset[disabled] .btn-warning:focus, +.btn-warning.disabled.focus, +.btn-warning[disabled].focus, +fieldset[disabled] .btn-warning.focus, +.btn-warning.disabled:active, +.btn-warning[disabled]:active, +fieldset[disabled] .btn-warning:active, +.btn-warning.disabled.active, +.btn-warning[disabled].active, +fieldset[disabled] .btn-warning.active { + background-color: #ff9800; + border-color: transparent; +} +.btn-warning .badge { + color: #ff9800; + background-color: #ffffff; +} +.btn-danger { + color: #ffffff; + background-color: #e51c23; + border-color: transparent; +} +.btn-danger:focus, +.btn-danger.focus { + color: #ffffff; + background-color: #b9151b; + border-color: rgba(0, 0, 0, 0); +} +.btn-danger:hover { + color: #ffffff; + background-color: #b9151b; + border-color: rgba(0, 0, 0, 0); +} +.btn-danger:active, +.btn-danger.active, +.open > .dropdown-toggle.btn-danger { + color: #ffffff; + background-color: #b9151b; + border-color: rgba(0, 0, 0, 0); +} +.btn-danger:active:hover, +.btn-danger.active:hover, +.open > .dropdown-toggle.btn-danger:hover, +.btn-danger:active:focus, +.btn-danger.active:focus, +.open > .dropdown-toggle.btn-danger:focus, +.btn-danger:active.focus, +.btn-danger.active.focus, +.open > .dropdown-toggle.btn-danger.focus { + color: #ffffff; + background-color: #991216; + border-color: rgba(0, 0, 0, 0); +} +.btn-danger:active, +.btn-danger.active, +.open > .dropdown-toggle.btn-danger { + background-image: none; +} +.btn-danger.disabled, +.btn-danger[disabled], +fieldset[disabled] .btn-danger, +.btn-danger.disabled:hover, +.btn-danger[disabled]:hover, +fieldset[disabled] .btn-danger:hover, +.btn-danger.disabled:focus, +.btn-danger[disabled]:focus, +fieldset[disabled] .btn-danger:focus, +.btn-danger.disabled.focus, +.btn-danger[disabled].focus, +fieldset[disabled] .btn-danger.focus, +.btn-danger.disabled:active, +.btn-danger[disabled]:active, +fieldset[disabled] .btn-danger:active, +.btn-danger.disabled.active, +.btn-danger[disabled].active, +fieldset[disabled] .btn-danger.active { + background-color: #e51c23; + border-color: transparent; +} +.btn-danger .badge { + color: #e51c23; + background-color: #ffffff; +} +.btn-link { + color: #2196f3; + font-weight: normal; + border-radius: 0; +} +.btn-link, +.btn-link:active, +.btn-link.active, +.btn-link[disabled], +fieldset[disabled] .btn-link { + background-color: transparent; + -webkit-box-shadow: none; + box-shadow: none; +} +.btn-link, +.btn-link:hover, +.btn-link:focus, +.btn-link:active { + border-color: transparent; +} +.btn-link:hover, +.btn-link:focus { + color: #0a6ebd; + text-decoration: underline; + background-color: transparent; +} +.btn-link[disabled]:hover, +fieldset[disabled] .btn-link:hover, +.btn-link[disabled]:focus, +fieldset[disabled] .btn-link:focus { + color: #bbbbbb; + text-decoration: none; +} +.btn-lg, +.btn-group-lg > .btn { + padding: 10px 16px; + font-size: 17px; + line-height: 1.3333333; + border-radius: 3px; +} +.btn-sm, +.btn-group-sm > .btn { + padding: 5px 10px; + font-size: 12px; + line-height: 1.5; + border-radius: 3px; +} +.btn-xs, +.btn-group-xs > .btn { + padding: 1px 5px; + font-size: 12px; + line-height: 1.5; + border-radius: 3px; +} +.btn-block { + display: block; + width: 100%; +} +.btn-block + .btn-block { + margin-top: 5px; +} +input[type="submit"].btn-block, +input[type="reset"].btn-block, +input[type="button"].btn-block { + width: 100%; +} +.fade { + opacity: 0; + -webkit-transition: opacity 0.15s linear; + -o-transition: opacity 0.15s linear; + transition: opacity 0.15s linear; +} +.fade.in { + opacity: 1; +} +.collapse { + display: none; +} +.collapse.in { + display: block; +} +tr.collapse.in { + display: table-row; +} +tbody.collapse.in { + display: table-row-group; +} +.collapsing { + position: relative; + height: 0; + overflow: hidden; + -webkit-transition-property: height, visibility; + -o-transition-property: height, visibility; + transition-property: height, visibility; + -webkit-transition-duration: 0.35s; + -o-transition-duration: 0.35s; + transition-duration: 0.35s; + -webkit-transition-timing-function: ease; + -o-transition-timing-function: ease; + transition-timing-function: ease; +} +.caret { + display: inline-block; + width: 0; + height: 0; + margin-left: 2px; + vertical-align: middle; + border-top: 4px dashed; + border-top: 4px solid \9; + border-right: 4px solid transparent; + border-left: 4px solid transparent; +} +.dropup, +.dropdown { + position: relative; +} +.dropdown-toggle:focus { + outline: 0; +} +.dropdown-menu { + position: absolute; + top: 100%; + left: 0; + z-index: 1000; + display: none; + float: left; + min-width: 160px; + padding: 5px 0; + margin: 2px 0 0; + list-style: none; + font-size: 13px; + text-align: left; + background-color: #ffffff; + border: 1px solid #cccccc; + border: 1px solid rgba(0, 0, 0, 0.15); + border-radius: 3px; + -webkit-box-shadow: 0 6px 12px rgba(0, 0, 0, 0.175); + box-shadow: 0 6px 12px rgba(0, 0, 0, 0.175); + -webkit-background-clip: padding-box; + background-clip: padding-box; +} +.dropdown-menu.pull-right { + right: 0; + left: auto; +} +.dropdown-menu .divider { + height: 1px; + margin: 10.5px 0; + overflow: hidden; + background-color: #e5e5e5; +} +.dropdown-menu > li > a { + display: block; + padding: 3px 20px; + clear: both; + font-weight: normal; + line-height: 1.846; + color: #666666; + white-space: nowrap; +} +.dropdown-menu > li > a:hover, +.dropdown-menu > li > a:focus { + text-decoration: none; + color: #141414; + background-color: #eeeeee; +} +.dropdown-menu > .active > a, +.dropdown-menu > .active > a:hover, +.dropdown-menu > .active > a:focus { + color: #ffffff; + text-decoration: none; + outline: 0; + background-color: #2196f3; +} +.dropdown-menu > .disabled > a, +.dropdown-menu > .disabled > a:hover, +.dropdown-menu > .disabled > a:focus { + color: #bbbbbb; +} +.dropdown-menu > .disabled > a:hover, +.dropdown-menu > .disabled > a:focus { + text-decoration: none; + background-color: transparent; + background-image: none; + filter: progid:DXImageTransform.Microsoft.gradient(enabled = false); + cursor: not-allowed; +} +.open > .dropdown-menu { + display: block; +} +.open > a { + outline: 0; +} +.dropdown-menu-right { + left: auto; + right: 0; +} +.dropdown-menu-left { + left: 0; + right: auto; +} +.dropdown-header { + display: block; + padding: 3px 20px; + font-size: 12px; + line-height: 1.846; + color: #bbbbbb; + white-space: nowrap; +} +.dropdown-backdrop { + position: fixed; + left: 0; + right: 0; + bottom: 0; + top: 0; + z-index: 990; +} +.pull-right > .dropdown-menu { + right: 0; + left: auto; +} +.dropup .caret, +.navbar-fixed-bottom .dropdown .caret { + border-top: 0; + border-bottom: 4px dashed; + border-bottom: 4px solid \9; + content: ""; +} +.dropup .dropdown-menu, +.navbar-fixed-bottom .dropdown .dropdown-menu { + top: auto; + bottom: 100%; + margin-bottom: 2px; +} +@media (min-width: 768px) { + .navbar-right .dropdown-menu { + left: auto; + right: 0; + } + .navbar-right .dropdown-menu-left { + left: 0; + right: auto; + } +} +.btn-group, +.btn-group-vertical { + position: relative; + display: inline-block; + vertical-align: middle; +} +.btn-group > .btn, +.btn-group-vertical > .btn { + position: relative; + float: left; +} +.btn-group > .btn:hover, +.btn-group-vertical > .btn:hover, +.btn-group > .btn:focus, +.btn-group-vertical > .btn:focus, +.btn-group > .btn:active, +.btn-group-vertical > .btn:active, +.btn-group > .btn.active, +.btn-group-vertical > .btn.active { + z-index: 2; +} +.btn-group .btn + .btn, +.btn-group .btn + .btn-group, +.btn-group .btn-group + .btn, +.btn-group .btn-group + .btn-group { + margin-left: -1px; +} +.btn-toolbar { + margin-left: -5px; +} +.btn-toolbar .btn, +.btn-toolbar .btn-group, +.btn-toolbar .input-group { + float: left; +} +.btn-toolbar > .btn, +.btn-toolbar > .btn-group, +.btn-toolbar > .input-group { + margin-left: 5px; +} +.btn-group > .btn:not(:first-child):not(:last-child):not(.dropdown-toggle) { + border-radius: 0; +} +.btn-group > .btn:first-child { + margin-left: 0; +} +.btn-group > .btn:first-child:not(:last-child):not(.dropdown-toggle) { + border-bottom-right-radius: 0; + border-top-right-radius: 0; +} +.btn-group > .btn:last-child:not(:first-child), +.btn-group > .dropdown-toggle:not(:first-child) { + border-bottom-left-radius: 0; + border-top-left-radius: 0; +} +.btn-group > .btn-group { + float: left; +} +.btn-group > .btn-group:not(:first-child):not(:last-child) > .btn { + border-radius: 0; +} +.btn-group > .btn-group:first-child:not(:last-child) > .btn:last-child, +.btn-group > .btn-group:first-child:not(:last-child) > .dropdown-toggle { + border-bottom-right-radius: 0; + border-top-right-radius: 0; +} +.btn-group > .btn-group:last-child:not(:first-child) > .btn:first-child { + border-bottom-left-radius: 0; + border-top-left-radius: 0; +} +.btn-group .dropdown-toggle:active, +.btn-group.open .dropdown-toggle { + outline: 0; +} +.btn-group > .btn + .dropdown-toggle { + padding-left: 8px; + padding-right: 8px; +} +.btn-group > .btn-lg + .dropdown-toggle { + padding-left: 12px; + padding-right: 12px; +} +.btn-group.open .dropdown-toggle { + -webkit-box-shadow: inset 0 3px 5px rgba(0, 0, 0, 0.125); + box-shadow: inset 0 3px 5px rgba(0, 0, 0, 0.125); +} +.btn-group.open .dropdown-toggle.btn-link { + -webkit-box-shadow: none; + box-shadow: none; +} +.btn .caret { + margin-left: 0; +} +.btn-lg .caret { + border-width: 5px 5px 0; + border-bottom-width: 0; +} +.dropup .btn-lg .caret { + border-width: 0 5px 5px; +} +.btn-group-vertical > .btn, +.btn-group-vertical > .btn-group, +.btn-group-vertical > .btn-group > .btn { + display: block; + float: none; + width: 100%; + max-width: 100%; +} +.btn-group-vertical > .btn-group > .btn { + float: none; +} +.btn-group-vertical > .btn + .btn, +.btn-group-vertical > .btn + .btn-group, +.btn-group-vertical > .btn-group + .btn, +.btn-group-vertical > .btn-group + .btn-group { + margin-top: -1px; + margin-left: 0; +} +.btn-group-vertical > .btn:not(:first-child):not(:last-child) { + border-radius: 0; +} +.btn-group-vertical > .btn:first-child:not(:last-child) { + border-top-right-radius: 3px; + border-bottom-right-radius: 0; + border-bottom-left-radius: 0; +} +.btn-group-vertical > .btn:last-child:not(:first-child) { + border-bottom-left-radius: 3px; + border-top-right-radius: 0; + border-top-left-radius: 0; +} +.btn-group-vertical > .btn-group:not(:first-child):not(:last-child) > .btn { + border-radius: 0; +} +.btn-group-vertical > .btn-group:first-child:not(:last-child) > .btn:last-child, +.btn-group-vertical > .btn-group:first-child:not(:last-child) > .dropdown-toggle { + border-bottom-right-radius: 0; + border-bottom-left-radius: 0; +} +.btn-group-vertical > .btn-group:last-child:not(:first-child) > .btn:first-child { + border-top-right-radius: 0; + border-top-left-radius: 0; +} +.btn-group-justified { + display: table; + width: 100%; + table-layout: fixed; + border-collapse: separate; +} +.btn-group-justified > .btn, +.btn-group-justified > .btn-group { + float: none; + display: table-cell; + width: 1%; +} +.btn-group-justified > .btn-group .btn { + width: 100%; +} +.btn-group-justified > .btn-group .dropdown-menu { + left: auto; +} +[data-toggle="buttons"] > .btn input[type="radio"], +[data-toggle="buttons"] > .btn-group > .btn input[type="radio"], +[data-toggle="buttons"] > .btn input[type="checkbox"], +[data-toggle="buttons"] > .btn-group > .btn input[type="checkbox"] { + position: absolute; + clip: rect(0, 0, 0, 0); + pointer-events: none; +} +.input-group { + position: relative; + display: table; + border-collapse: separate; +} +.input-group[class*="col-"] { + float: none; + padding-left: 0; + padding-right: 0; +} +.input-group .form-control { + position: relative; + z-index: 2; + float: left; + width: 100%; + margin-bottom: 0; +} +.input-group-lg > .form-control, +.input-group-lg > .input-group-addon, +.input-group-lg > .input-group-btn > .btn { + height: 45px; + padding: 10px 16px; + font-size: 17px; + line-height: 1.3333333; + border-radius: 3px; +} +select.input-group-lg > .form-control, +select.input-group-lg > .input-group-addon, +select.input-group-lg > .input-group-btn > .btn { + height: 45px; + line-height: 45px; +} +textarea.input-group-lg > .form-control, +textarea.input-group-lg > .input-group-addon, +textarea.input-group-lg > .input-group-btn > .btn, +select[multiple].input-group-lg > .form-control, +select[multiple].input-group-lg > .input-group-addon, +select[multiple].input-group-lg > .input-group-btn > .btn { + height: auto; +} +.input-group-sm > .form-control, +.input-group-sm > .input-group-addon, +.input-group-sm > .input-group-btn > .btn { + height: 30px; + padding: 5px 10px; + font-size: 12px; + line-height: 1.5; + border-radius: 3px; +} +select.input-group-sm > .form-control, +select.input-group-sm > .input-group-addon, +select.input-group-sm > .input-group-btn > .btn { + height: 30px; + line-height: 30px; +} +textarea.input-group-sm > .form-control, +textarea.input-group-sm > .input-group-addon, +textarea.input-group-sm > .input-group-btn > .btn, +select[multiple].input-group-sm > .form-control, +select[multiple].input-group-sm > .input-group-addon, +select[multiple].input-group-sm > .input-group-btn > .btn { + height: auto; +} +.input-group-addon, +.input-group-btn, +.input-group .form-control { + display: table-cell; +} +.input-group-addon:not(:first-child):not(:last-child), +.input-group-btn:not(:first-child):not(:last-child), +.input-group .form-control:not(:first-child):not(:last-child) { + border-radius: 0; +} +.input-group-addon, +.input-group-btn { + width: 1%; + white-space: nowrap; + vertical-align: middle; +} +.input-group-addon { + padding: 6px 16px; + font-size: 13px; + font-weight: normal; + line-height: 1; + color: #666666; + text-align: center; + background-color: transparent; + border: 1px solid transparent; + border-radius: 3px; +} +.input-group-addon.input-sm { + padding: 5px 10px; + font-size: 12px; + border-radius: 3px; +} +.input-group-addon.input-lg { + padding: 10px 16px; + font-size: 17px; + border-radius: 3px; +} +.input-group-addon input[type="radio"], +.input-group-addon input[type="checkbox"] { + margin-top: 0; +} +.input-group .form-control:first-child, +.input-group-addon:first-child, +.input-group-btn:first-child > .btn, +.input-group-btn:first-child > .btn-group > .btn, +.input-group-btn:first-child > .dropdown-toggle, +.input-group-btn:last-child > .btn:not(:last-child):not(.dropdown-toggle), +.input-group-btn:last-child > .btn-group:not(:last-child) > .btn { + border-bottom-right-radius: 0; + border-top-right-radius: 0; +} +.input-group-addon:first-child { + border-right: 0; +} +.input-group .form-control:last-child, +.input-group-addon:last-child, +.input-group-btn:last-child > .btn, +.input-group-btn:last-child > .btn-group > .btn, +.input-group-btn:last-child > .dropdown-toggle, +.input-group-btn:first-child > .btn:not(:first-child), +.input-group-btn:first-child > .btn-group:not(:first-child) > .btn { + border-bottom-left-radius: 0; + border-top-left-radius: 0; +} +.input-group-addon:last-child { + border-left: 0; +} +.input-group-btn { + position: relative; + font-size: 0; + white-space: nowrap; +} +.input-group-btn > .btn { + position: relative; +} +.input-group-btn > .btn + .btn { + margin-left: -1px; +} +.input-group-btn > .btn:hover, +.input-group-btn > .btn:focus, +.input-group-btn > .btn:active { + z-index: 2; +} +.input-group-btn:first-child > .btn, +.input-group-btn:first-child > .btn-group { + margin-right: -1px; +} +.input-group-btn:last-child > .btn, +.input-group-btn:last-child > .btn-group { + z-index: 2; + margin-left: -1px; +} +.nav { + margin-bottom: 0; + padding-left: 0; + list-style: none; +} +.nav > li { + position: relative; + display: block; +} +.nav > li > a { + position: relative; + display: block; + padding: 10px 15px; +} +.nav > li > a:hover, +.nav > li > a:focus { + text-decoration: none; + background-color: #eeeeee; +} +.nav > li.disabled > a { + color: #bbbbbb; +} +.nav > li.disabled > a:hover, +.nav > li.disabled > a:focus { + color: #bbbbbb; + text-decoration: none; + background-color: transparent; + cursor: not-allowed; +} +.nav .open > a, +.nav .open > a:hover, +.nav .open > a:focus { + background-color: #eeeeee; + border-color: #2196f3; +} +.nav .nav-divider { + height: 1px; + margin: 10.5px 0; + overflow: hidden; + background-color: #e5e5e5; +} +.nav > li > a > img { + max-width: none; +} +.nav-tabs { + border-bottom: 1px solid transparent; +} +.nav-tabs > li { + float: left; + margin-bottom: -1px; +} +.nav-tabs > li > a { + margin-right: 2px; + line-height: 1.846; + border: 1px solid transparent; + border-radius: 3px 3px 0 0; +} +.nav-tabs > li > a:hover { + border-color: #eeeeee #eeeeee transparent; +} +.nav-tabs > li.active > a, +.nav-tabs > li.active > a:hover, +.nav-tabs > li.active > a:focus { + color: #666666; + background-color: transparent; + border: 1px solid transparent; + border-bottom-color: transparent; + cursor: default; +} +.nav-tabs.nav-justified { + width: 100%; + border-bottom: 0; +} +.nav-tabs.nav-justified > li { + float: none; +} +.nav-tabs.nav-justified > li > a { + text-align: center; + margin-bottom: 5px; +} +.nav-tabs.nav-justified > .dropdown .dropdown-menu { + top: auto; + left: auto; +} +@media (min-width: 768px) { + .nav-tabs.nav-justified > li { + display: table-cell; + width: 1%; + } + .nav-tabs.nav-justified > li > a { + margin-bottom: 0; + } +} +.nav-tabs.nav-justified > li > a { + margin-right: 0; + border-radius: 3px; +} +.nav-tabs.nav-justified > .active > a, +.nav-tabs.nav-justified > .active > a:hover, +.nav-tabs.nav-justified > .active > a:focus { + border: 1px solid transparent; +} +@media (min-width: 768px) { + .nav-tabs.nav-justified > li > a { + border-bottom: 1px solid transparent; + border-radius: 3px 3px 0 0; + } + .nav-tabs.nav-justified > .active > a, + .nav-tabs.nav-justified > .active > a:hover, + .nav-tabs.nav-justified > .active > a:focus { + border-bottom-color: #ffffff; + } +} +.nav-pills > li { + float: left; +} +.nav-pills > li > a { + border-radius: 3px; +} +.nav-pills > li + li { + margin-left: 2px; +} +.nav-pills > li.active > a, +.nav-pills > li.active > a:hover, +.nav-pills > li.active > a:focus { + color: #ffffff; + background-color: #2196f3; +} +.nav-stacked > li { + float: none; +} +.nav-stacked > li + li { + margin-top: 2px; + margin-left: 0; +} +.nav-justified { + width: 100%; +} +.nav-justified > li { + float: none; +} +.nav-justified > li > a { + text-align: center; + margin-bottom: 5px; +} +.nav-justified > .dropdown .dropdown-menu { + top: auto; + left: auto; +} +@media (min-width: 768px) { + .nav-justified > li { + display: table-cell; + width: 1%; + } + .nav-justified > li > a { + margin-bottom: 0; + } +} +.nav-tabs-justified { + border-bottom: 0; +} +.nav-tabs-justified > li > a { + margin-right: 0; + border-radius: 3px; +} +.nav-tabs-justified > .active > a, +.nav-tabs-justified > .active > a:hover, +.nav-tabs-justified > .active > a:focus { + border: 1px solid transparent; +} +@media (min-width: 768px) { + .nav-tabs-justified > li > a { + border-bottom: 1px solid transparent; + border-radius: 3px 3px 0 0; + } + .nav-tabs-justified > .active > a, + .nav-tabs-justified > .active > a:hover, + .nav-tabs-justified > .active > a:focus { + border-bottom-color: #ffffff; + } +} +.tab-content > .tab-pane { + display: none; +} +.tab-content > .active { + display: block; +} +.nav-tabs .dropdown-menu { + margin-top: -1px; + border-top-right-radius: 0; + border-top-left-radius: 0; +} +.navbar { + position: relative; + min-height: 64px; + margin-bottom: 23px; + border: 1px solid transparent; +} +@media (min-width: 768px) { + .navbar { + border-radius: 3px; + } +} +@media (min-width: 768px) { + .navbar-header { + float: left; + } +} +.navbar-collapse { + overflow-x: visible; + padding-right: 15px; + padding-left: 15px; + border-top: 1px solid transparent; + -webkit-box-shadow: inset 0 1px 0 rgba(255, 255, 255, 0.1); + box-shadow: inset 0 1px 0 rgba(255, 255, 255, 0.1); + -webkit-overflow-scrolling: touch; +} +.navbar-collapse.in { + overflow-y: auto; +} +@media (min-width: 768px) { + .navbar-collapse { + width: auto; + border-top: 0; + -webkit-box-shadow: none; + box-shadow: none; + } + .navbar-collapse.collapse { + display: block !important; + height: auto !important; + padding-bottom: 0; + overflow: visible !important; + } + .navbar-collapse.in { + overflow-y: visible; + } + .navbar-fixed-top .navbar-collapse, + .navbar-static-top .navbar-collapse, + .navbar-fixed-bottom .navbar-collapse { + padding-left: 0; + padding-right: 0; + } +} +.navbar-fixed-top .navbar-collapse, +.navbar-fixed-bottom .navbar-collapse { + max-height: 340px; +} +@media (max-device-width: 480px) and (orientation: landscape) { + .navbar-fixed-top .navbar-collapse, + .navbar-fixed-bottom .navbar-collapse { + max-height: 200px; + } +} +.container > .navbar-header, +.container-fluid > .navbar-header, +.container > .navbar-collapse, +.container-fluid > .navbar-collapse { + margin-right: -15px; + margin-left: -15px; +} +@media (min-width: 768px) { + .container > .navbar-header, + .container-fluid > .navbar-header, + .container > .navbar-collapse, + .container-fluid > .navbar-collapse { + margin-right: 0; + margin-left: 0; + } +} +.navbar-static-top { + z-index: 1000; + border-width: 0 0 1px; +} +@media (min-width: 768px) { + .navbar-static-top { + border-radius: 0; + } +} +.navbar-fixed-top, +.navbar-fixed-bottom { + position: fixed; + right: 0; + left: 0; + z-index: 1030; +} +@media (min-width: 768px) { + .navbar-fixed-top, + .navbar-fixed-bottom { + border-radius: 0; + } +} +.navbar-fixed-top { + top: 0; + border-width: 0 0 1px; +} +.navbar-fixed-bottom { + bottom: 0; + margin-bottom: 0; + border-width: 1px 0 0; +} +.navbar-brand { + float: left; + padding: 20.5px 15px; + font-size: 17px; + line-height: 23px; + height: 64px; +} +.navbar-brand:hover, +.navbar-brand:focus { + text-decoration: none; +} +.navbar-brand > img { + display: block; +} +@media (min-width: 768px) { + .navbar > .container .navbar-brand, + .navbar > .container-fluid .navbar-brand { + margin-left: -15px; + } +} +.navbar-toggle { + position: relative; + float: right; + margin-right: 15px; + padding: 9px 10px; + margin-top: 15px; + margin-bottom: 15px; + background-color: transparent; + background-image: none; + border: 1px solid transparent; + border-radius: 3px; +} +.navbar-toggle:focus { + outline: 0; +} +.navbar-toggle .icon-bar { + display: block; + width: 22px; + height: 2px; + border-radius: 1px; +} +.navbar-toggle .icon-bar + .icon-bar { + margin-top: 4px; +} +@media (min-width: 768px) { + .navbar-toggle { + display: none; + } +} +.navbar-nav { + margin: 10.25px -15px; +} +.navbar-nav > li > a { + padding-top: 10px; + padding-bottom: 10px; + line-height: 23px; +} +@media (max-width: 767px) { + .navbar-nav .open .dropdown-menu { + position: static; + float: none; + width: auto; + margin-top: 0; + background-color: transparent; + border: 0; + -webkit-box-shadow: none; + box-shadow: none; + } + .navbar-nav .open .dropdown-menu > li > a, + .navbar-nav .open .dropdown-menu .dropdown-header { + padding: 5px 15px 5px 25px; + } + .navbar-nav .open .dropdown-menu > li > a { + line-height: 23px; + } + .navbar-nav .open .dropdown-menu > li > a:hover, + .navbar-nav .open .dropdown-menu > li > a:focus { + background-image: none; + } +} +@media (min-width: 768px) { + .navbar-nav { + float: left; + margin: 0; + } + .navbar-nav > li { + float: left; + } + .navbar-nav > li > a { + padding-top: 20.5px; + padding-bottom: 20.5px; + } +} +.navbar-form { + margin-left: -15px; + margin-right: -15px; + padding: 10px 15px; + border-top: 1px solid transparent; + border-bottom: 1px solid transparent; + -webkit-box-shadow: inset 0 1px 0 rgba(255, 255, 255, 0.1), 0 1px 0 rgba(255, 255, 255, 0.1); + box-shadow: inset 0 1px 0 rgba(255, 255, 255, 0.1), 0 1px 0 rgba(255, 255, 255, 0.1); + margin-top: 13.5px; + margin-bottom: 13.5px; +} +@media (min-width: 768px) { + .navbar-form .form-group { + display: inline-block; + margin-bottom: 0; + vertical-align: middle; + } + .navbar-form .form-control { + display: inline-block; + width: auto; + vertical-align: middle; + } + .navbar-form .form-control-static { + display: inline-block; + } + .navbar-form .input-group { + display: inline-table; + vertical-align: middle; + } + .navbar-form .input-group .input-group-addon, + .navbar-form .input-group .input-group-btn, + .navbar-form .input-group .form-control { + width: auto; + } + .navbar-form .input-group > .form-control { + width: 100%; + } + .navbar-form .control-label { + margin-bottom: 0; + vertical-align: middle; + } + .navbar-form .radio, + .navbar-form .checkbox { + display: inline-block; + margin-top: 0; + margin-bottom: 0; + vertical-align: middle; + } + .navbar-form .radio label, + .navbar-form .checkbox label { + padding-left: 0; + } + .navbar-form .radio input[type="radio"], + .navbar-form .checkbox input[type="checkbox"] { + position: relative; + margin-left: 0; + } + .navbar-form .has-feedback .form-control-feedback { + top: 0; + } +} +@media (max-width: 767px) { + .navbar-form .form-group { + margin-bottom: 5px; + } + .navbar-form .form-group:last-child { + margin-bottom: 0; + } +} +@media (min-width: 768px) { + .navbar-form { + width: auto; + border: 0; + margin-left: 0; + margin-right: 0; + padding-top: 0; + padding-bottom: 0; + -webkit-box-shadow: none; + box-shadow: none; + } +} +.navbar-nav > li > .dropdown-menu { + margin-top: 0; + border-top-right-radius: 0; + border-top-left-radius: 0; +} +.navbar-fixed-bottom .navbar-nav > li > .dropdown-menu { + margin-bottom: 0; + border-top-right-radius: 3px; + border-top-left-radius: 3px; + border-bottom-right-radius: 0; + border-bottom-left-radius: 0; +} +.navbar-btn { + margin-top: 13.5px; + margin-bottom: 13.5px; +} +.navbar-btn.btn-sm { + margin-top: 17px; + margin-bottom: 17px; +} +.navbar-btn.btn-xs { + margin-top: 21px; + margin-bottom: 21px; +} +.navbar-text { + margin-top: 20.5px; + margin-bottom: 20.5px; +} +@media (min-width: 768px) { + .navbar-text { + float: left; + margin-left: 15px; + margin-right: 15px; + } +} +@media (min-width: 768px) { + .navbar-left { + float: left !important; + } + .navbar-right { + float: right !important; + margin-right: -15px; + } + .navbar-right ~ .navbar-right { + margin-right: 0; + } +} +.navbar-default { + background-color: #ffffff; + border-color: transparent; +} +.navbar-default .navbar-brand { + color: #666666; +} +.navbar-default .navbar-brand:hover, +.navbar-default .navbar-brand:focus { + color: #212121; + background-color: transparent; +} +.navbar-default .navbar-text { + color: #bbbbbb; +} +.navbar-default .navbar-nav > li > a { + color: #666666; +} +.navbar-default .navbar-nav > li > a:hover, +.navbar-default .navbar-nav > li > a:focus { + color: #212121; + background-color: transparent; +} +.navbar-default .navbar-nav > .active > a, +.navbar-default .navbar-nav > .active > a:hover, +.navbar-default .navbar-nav > .active > a:focus { + color: #212121; + background-color: #eeeeee; +} +.navbar-default .navbar-nav > .disabled > a, +.navbar-default .navbar-nav > .disabled > a:hover, +.navbar-default .navbar-nav > .disabled > a:focus { + color: #cccccc; + background-color: transparent; +} +.navbar-default .navbar-toggle { + border-color: transparent; +} +.navbar-default .navbar-toggle:hover, +.navbar-default .navbar-toggle:focus { + background-color: transparent; +} +.navbar-default .navbar-toggle .icon-bar { + background-color: rgba(0, 0, 0, 0.5); +} +.navbar-default .navbar-collapse, +.navbar-default .navbar-form { + border-color: transparent; +} +.navbar-default .navbar-nav > .open > a, +.navbar-default .navbar-nav > .open > a:hover, +.navbar-default .navbar-nav > .open > a:focus { + background-color: #eeeeee; + color: #212121; +} +@media (max-width: 767px) { + .navbar-default .navbar-nav .open .dropdown-menu > li > a { + color: #666666; + } + .navbar-default .navbar-nav .open .dropdown-menu > li > a:hover, + .navbar-default .navbar-nav .open .dropdown-menu > li > a:focus { + color: #212121; + background-color: transparent; + } + .navbar-default .navbar-nav .open .dropdown-menu > .active > a, + .navbar-default .navbar-nav .open .dropdown-menu > .active > a:hover, + .navbar-default .navbar-nav .open .dropdown-menu > .active > a:focus { + color: #212121; + background-color: #eeeeee; + } + .navbar-default .navbar-nav .open .dropdown-menu > .disabled > a, + .navbar-default .navbar-nav .open .dropdown-menu > .disabled > a:hover, + .navbar-default .navbar-nav .open .dropdown-menu > .disabled > a:focus { + color: #cccccc; + background-color: transparent; + } +} +.navbar-default .navbar-link { + color: #666666; +} +.navbar-default .navbar-link:hover { + color: #212121; +} +.navbar-default .btn-link { + color: #666666; +} +.navbar-default .btn-link:hover, +.navbar-default .btn-link:focus { + color: #212121; +} +.navbar-default .btn-link[disabled]:hover, +fieldset[disabled] .navbar-default .btn-link:hover, +.navbar-default .btn-link[disabled]:focus, +fieldset[disabled] .navbar-default .btn-link:focus { + color: #cccccc; +} +.navbar-inverse { + background-color: #2196f3; + border-color: transparent; +} +.navbar-inverse .navbar-brand { + color: #b2dbfb; +} +.navbar-inverse .navbar-brand:hover, +.navbar-inverse .navbar-brand:focus { + color: #ffffff; + background-color: transparent; +} +.navbar-inverse .navbar-text { + color: #bbbbbb; +} +.navbar-inverse .navbar-nav > li > a { + color: #b2dbfb; +} +.navbar-inverse .navbar-nav > li > a:hover, +.navbar-inverse .navbar-nav > li > a:focus { + color: #ffffff; + background-color: transparent; +} +.navbar-inverse .navbar-nav > .active > a, +.navbar-inverse .navbar-nav > .active > a:hover, +.navbar-inverse .navbar-nav > .active > a:focus { + color: #ffffff; + background-color: #0c7cd5; +} +.navbar-inverse .navbar-nav > .disabled > a, +.navbar-inverse .navbar-nav > .disabled > a:hover, +.navbar-inverse .navbar-nav > .disabled > a:focus { + color: #444444; + background-color: transparent; +} +.navbar-inverse .navbar-toggle { + border-color: transparent; +} +.navbar-inverse .navbar-toggle:hover, +.navbar-inverse .navbar-toggle:focus { + background-color: transparent; +} +.navbar-inverse .navbar-toggle .icon-bar { + background-color: rgba(0, 0, 0, 0.5); +} +.navbar-inverse .navbar-collapse, +.navbar-inverse .navbar-form { + border-color: #0c84e4; +} +.navbar-inverse .navbar-nav > .open > a, +.navbar-inverse .navbar-nav > .open > a:hover, +.navbar-inverse .navbar-nav > .open > a:focus { + background-color: #0c7cd5; + color: #ffffff; +} +@media (max-width: 767px) { + .navbar-inverse .navbar-nav .open .dropdown-menu > .dropdown-header { + border-color: transparent; + } + .navbar-inverse .navbar-nav .open .dropdown-menu .divider { + background-color: transparent; + } + .navbar-inverse .navbar-nav .open .dropdown-menu > li > a { + color: #b2dbfb; + } + .navbar-inverse .navbar-nav .open .dropdown-menu > li > a:hover, + .navbar-inverse .navbar-nav .open .dropdown-menu > li > a:focus { + color: #ffffff; + background-color: transparent; + } + .navbar-inverse .navbar-nav .open .dropdown-menu > .active > a, + .navbar-inverse .navbar-nav .open .dropdown-menu > .active > a:hover, + .navbar-inverse .navbar-nav .open .dropdown-menu > .active > a:focus { + color: #ffffff; + background-color: #0c7cd5; + } + .navbar-inverse .navbar-nav .open .dropdown-menu > .disabled > a, + .navbar-inverse .navbar-nav .open .dropdown-menu > .disabled > a:hover, + .navbar-inverse .navbar-nav .open .dropdown-menu > .disabled > a:focus { + color: #444444; + background-color: transparent; + } +} +.navbar-inverse .navbar-link { + color: #b2dbfb; +} +.navbar-inverse .navbar-link:hover { + color: #ffffff; +} +.navbar-inverse .btn-link { + color: #b2dbfb; +} +.navbar-inverse .btn-link:hover, +.navbar-inverse .btn-link:focus { + color: #ffffff; +} +.navbar-inverse .btn-link[disabled]:hover, +fieldset[disabled] .navbar-inverse .btn-link:hover, +.navbar-inverse .btn-link[disabled]:focus, +fieldset[disabled] .navbar-inverse .btn-link:focus { + color: #444444; +} +.breadcrumb { + padding: 8px 15px; + margin-bottom: 23px; + list-style: none; + background-color: #f5f5f5; + border-radius: 3px; +} +.breadcrumb > li { + display: inline-block; +} +.breadcrumb > li + li:before { + content: "/\00a0"; + padding: 0 5px; + color: #cccccc; +} +.breadcrumb > .active { + color: #bbbbbb; +} +.pagination { + display: inline-block; + padding-left: 0; + margin: 23px 0; + border-radius: 3px; +} +.pagination > li { + display: inline; +} +.pagination > li > a, +.pagination > li > span { + position: relative; + float: left; + padding: 6px 16px; + line-height: 1.846; + text-decoration: none; + color: #2196f3; + background-color: #ffffff; + border: 1px solid #dddddd; + margin-left: -1px; +} +.pagination > li:first-child > a, +.pagination > li:first-child > span { + margin-left: 0; + border-bottom-left-radius: 3px; + border-top-left-radius: 3px; +} +.pagination > li:last-child > a, +.pagination > li:last-child > span { + border-bottom-right-radius: 3px; + border-top-right-radius: 3px; +} +.pagination > li > a:hover, +.pagination > li > span:hover, +.pagination > li > a:focus, +.pagination > li > span:focus { + z-index: 3; + color: #0a6ebd; + background-color: #eeeeee; + border-color: #dddddd; +} +.pagination > .active > a, +.pagination > .active > span, +.pagination > .active > a:hover, +.pagination > .active > span:hover, +.pagination > .active > a:focus, +.pagination > .active > span:focus { + z-index: 2; + color: #ffffff; + background-color: #2196f3; + border-color: #2196f3; + cursor: default; +} +.pagination > .disabled > span, +.pagination > .disabled > span:hover, +.pagination > .disabled > span:focus, +.pagination > .disabled > a, +.pagination > .disabled > a:hover, +.pagination > .disabled > a:focus { + color: #bbbbbb; + background-color: #ffffff; + border-color: #dddddd; + cursor: not-allowed; +} +.pagination-lg > li > a, +.pagination-lg > li > span { + padding: 10px 16px; + font-size: 17px; + line-height: 1.3333333; +} +.pagination-lg > li:first-child > a, +.pagination-lg > li:first-child > span { + border-bottom-left-radius: 3px; + border-top-left-radius: 3px; +} +.pagination-lg > li:last-child > a, +.pagination-lg > li:last-child > span { + border-bottom-right-radius: 3px; + border-top-right-radius: 3px; +} +.pagination-sm > li > a, +.pagination-sm > li > span { + padding: 5px 10px; + font-size: 12px; + line-height: 1.5; +} +.pagination-sm > li:first-child > a, +.pagination-sm > li:first-child > span { + border-bottom-left-radius: 3px; + border-top-left-radius: 3px; +} +.pagination-sm > li:last-child > a, +.pagination-sm > li:last-child > span { + border-bottom-right-radius: 3px; + border-top-right-radius: 3px; +} +.pager { + padding-left: 0; + margin: 23px 0; + list-style: none; + text-align: center; +} +.pager li { + display: inline; +} +.pager li > a, +.pager li > span { + display: inline-block; + padding: 5px 14px; + background-color: #ffffff; + border: 1px solid #dddddd; + border-radius: 15px; +} +.pager li > a:hover, +.pager li > a:focus { + text-decoration: none; + background-color: #eeeeee; +} +.pager .next > a, +.pager .next > span { + float: right; +} +.pager .previous > a, +.pager .previous > span { + float: left; +} +.pager .disabled > a, +.pager .disabled > a:hover, +.pager .disabled > a:focus, +.pager .disabled > span { + color: #bbbbbb; + background-color: #ffffff; + cursor: not-allowed; +} +.label { + display: inline; + padding: .2em .6em .3em; + font-size: 75%; + font-weight: bold; + line-height: 1; + color: #ffffff; + text-align: center; + white-space: nowrap; + vertical-align: baseline; + border-radius: .25em; +} +a.label:hover, +a.label:focus { + color: #ffffff; + text-decoration: none; + cursor: pointer; +} +.label:empty { + display: none; +} +.btn .label { + position: relative; + top: -1px; +} +.label-default { + background-color: #bbbbbb; +} +.label-default[href]:hover, +.label-default[href]:focus { + background-color: #a2a2a2; +} +.label-primary { + background-color: #2196f3; +} +.label-primary[href]:hover, +.label-primary[href]:focus { + background-color: #0c7cd5; +} +.label-success { + background-color: #4caf50; +} +.label-success[href]:hover, +.label-success[href]:focus { + background-color: #3d8b40; +} +.label-info { + background-color: #9c27b0; +} +.label-info[href]:hover, +.label-info[href]:focus { + background-color: #771e86; +} +.label-warning { + background-color: #ff9800; +} +.label-warning[href]:hover, +.label-warning[href]:focus { + background-color: #cc7a00; +} +.label-danger { + background-color: #e51c23; +} +.label-danger[href]:hover, +.label-danger[href]:focus { + background-color: #b9151b; +} +.badge { + display: inline-block; + min-width: 10px; + padding: 3px 7px; + font-size: 12px; + font-weight: normal; + color: #ffffff; + line-height: 1; + vertical-align: middle; + white-space: nowrap; + text-align: center; + background-color: #bbbbbb; + border-radius: 10px; +} +.badge:empty { + display: none; +} +.btn .badge { + position: relative; + top: -1px; +} +.btn-xs .badge, +.btn-group-xs > .btn .badge { + top: 0; + padding: 1px 5px; +} +a.badge:hover, +a.badge:focus { + color: #ffffff; + text-decoration: none; + cursor: pointer; +} +.list-group-item.active > .badge, +.nav-pills > .active > a > .badge { + color: #2196f3; + background-color: #ffffff; +} +.list-group-item > .badge { + float: right; +} +.list-group-item > .badge + .badge { + margin-right: 5px; +} +.nav-pills > li > a > .badge { + margin-left: 3px; +} +.jumbotron { + padding-top: 30px; + padding-bottom: 30px; + margin-bottom: 30px; + color: inherit; + background-color: #f9f9f9; +} +.jumbotron h1, +.jumbotron .h1 { + color: #444444; +} +.jumbotron p { + margin-bottom: 15px; + font-size: 20px; + font-weight: 200; +} +.jumbotron > hr { + border-top-color: #e0e0e0; +} +.container .jumbotron, +.container-fluid .jumbotron { + border-radius: 3px; +} +.jumbotron .container { + max-width: 100%; +} +@media screen and (min-width: 768px) { + .jumbotron { + padding-top: 48px; + padding-bottom: 48px; + } + .container .jumbotron, + .container-fluid .jumbotron { + padding-left: 60px; + padding-right: 60px; + } + .jumbotron h1, + .jumbotron .h1 { + font-size: 59px; + } +} +.thumbnail { + display: block; + padding: 4px; + margin-bottom: 23px; + line-height: 1.846; + background-color: #ffffff; + border: 1px solid #dddddd; + border-radius: 3px; + -webkit-transition: border 0.2s ease-in-out; + -o-transition: border 0.2s ease-in-out; + transition: border 0.2s ease-in-out; +} +.thumbnail > img, +.thumbnail a > img { + margin-left: auto; + margin-right: auto; +} +a.thumbnail:hover, +a.thumbnail:focus, +a.thumbnail.active { + border-color: #2196f3; +} +.thumbnail .caption { + padding: 9px; + color: #666666; +} +.alert { + padding: 15px; + margin-bottom: 23px; + border: 1px solid transparent; + border-radius: 3px; +} +.alert h4 { + margin-top: 0; + color: inherit; +} +.alert .alert-link { + font-weight: bold; +} +.alert > p, +.alert > ul { + margin-bottom: 0; +} +.alert > p + p { + margin-top: 5px; +} +.alert-dismissable, +.alert-dismissible { + padding-right: 35px; +} +.alert-dismissable .close, +.alert-dismissible .close { + position: relative; + top: -2px; + right: -21px; + color: inherit; +} +.alert-success { + background-color: #dff0d8; + border-color: #d6e9c6; + color: #4caf50; +} +.alert-success hr { + border-top-color: #c9e2b3; +} +.alert-success .alert-link { + color: #3d8b40; +} +.alert-info { + background-color: #e1bee7; + border-color: #cba4dd; + color: #9c27b0; +} +.alert-info hr { + border-top-color: #c191d6; +} +.alert-info .alert-link { + color: #771e86; +} +.alert-warning { + background-color: #ffe0b2; + border-color: #ffc599; + color: #ff9800; +} +.alert-warning hr { + border-top-color: #ffb67f; +} +.alert-warning .alert-link { + color: #cc7a00; +} +.alert-danger { + background-color: #f9bdbb; + border-color: #f7a4af; + color: #e51c23; +} +.alert-danger hr { + border-top-color: #f58c9a; +} +.alert-danger .alert-link { + color: #b9151b; +} +@-webkit-keyframes progress-bar-stripes { + from { + background-position: 40px 0; + } + to { + background-position: 0 0; + } +} +@-o-keyframes progress-bar-stripes { + from { + background-position: 40px 0; + } + to { + background-position: 0 0; + } +} +@keyframes progress-bar-stripes { + from { + background-position: 40px 0; + } + to { + background-position: 0 0; + } +} +.progress { + overflow: hidden; + height: 23px; + margin-bottom: 23px; + background-color: #f5f5f5; + border-radius: 3px; + -webkit-box-shadow: inset 0 1px 2px rgba(0, 0, 0, 0.1); + box-shadow: inset 0 1px 2px rgba(0, 0, 0, 0.1); +} +.progress-bar { + float: left; + width: 0%; + height: 100%; + font-size: 12px; + line-height: 23px; + color: #ffffff; + text-align: center; + background-color: #2196f3; + -webkit-box-shadow: inset 0 -1px 0 rgba(0, 0, 0, 0.15); + box-shadow: inset 0 -1px 0 rgba(0, 0, 0, 0.15); + -webkit-transition: width 0.6s ease; + -o-transition: width 0.6s ease; + transition: width 0.6s ease; +} +.progress-striped .progress-bar, +.progress-bar-striped { + background-image: -webkit-linear-gradient(45deg, rgba(255, 255, 255, 0.15) 25%, transparent 25%, transparent 50%, rgba(255, 255, 255, 0.15) 50%, rgba(255, 255, 255, 0.15) 75%, transparent 75%, transparent); + background-image: -o-linear-gradient(45deg, rgba(255, 255, 255, 0.15) 25%, transparent 25%, transparent 50%, rgba(255, 255, 255, 0.15) 50%, rgba(255, 255, 255, 0.15) 75%, transparent 75%, transparent); + background-image: linear-gradient(45deg, rgba(255, 255, 255, 0.15) 25%, transparent 25%, transparent 50%, rgba(255, 255, 255, 0.15) 50%, rgba(255, 255, 255, 0.15) 75%, transparent 75%, transparent); + -webkit-background-size: 40px 40px; + background-size: 40px 40px; +} +.progress.active .progress-bar, +.progress-bar.active { + -webkit-animation: progress-bar-stripes 2s linear infinite; + -o-animation: progress-bar-stripes 2s linear infinite; + animation: progress-bar-stripes 2s linear infinite; +} +.progress-bar-success { + background-color: #4caf50; +} +.progress-striped .progress-bar-success { + background-image: -webkit-linear-gradient(45deg, rgba(255, 255, 255, 0.15) 25%, transparent 25%, transparent 50%, rgba(255, 255, 255, 0.15) 50%, rgba(255, 255, 255, 0.15) 75%, transparent 75%, transparent); + background-image: -o-linear-gradient(45deg, rgba(255, 255, 255, 0.15) 25%, transparent 25%, transparent 50%, rgba(255, 255, 255, 0.15) 50%, rgba(255, 255, 255, 0.15) 75%, transparent 75%, transparent); + background-image: linear-gradient(45deg, rgba(255, 255, 255, 0.15) 25%, transparent 25%, transparent 50%, rgba(255, 255, 255, 0.15) 50%, rgba(255, 255, 255, 0.15) 75%, transparent 75%, transparent); +} +.progress-bar-info { + background-color: #9c27b0; +} +.progress-striped .progress-bar-info { + background-image: -webkit-linear-gradient(45deg, rgba(255, 255, 255, 0.15) 25%, transparent 25%, transparent 50%, rgba(255, 255, 255, 0.15) 50%, rgba(255, 255, 255, 0.15) 75%, transparent 75%, transparent); + background-image: -o-linear-gradient(45deg, rgba(255, 255, 255, 0.15) 25%, transparent 25%, transparent 50%, rgba(255, 255, 255, 0.15) 50%, rgba(255, 255, 255, 0.15) 75%, transparent 75%, transparent); + background-image: linear-gradient(45deg, rgba(255, 255, 255, 0.15) 25%, transparent 25%, transparent 50%, rgba(255, 255, 255, 0.15) 50%, rgba(255, 255, 255, 0.15) 75%, transparent 75%, transparent); +} +.progress-bar-warning { + background-color: #ff9800; +} +.progress-striped .progress-bar-warning { + background-image: -webkit-linear-gradient(45deg, rgba(255, 255, 255, 0.15) 25%, transparent 25%, transparent 50%, rgba(255, 255, 255, 0.15) 50%, rgba(255, 255, 255, 0.15) 75%, transparent 75%, transparent); + background-image: -o-linear-gradient(45deg, rgba(255, 255, 255, 0.15) 25%, transparent 25%, transparent 50%, rgba(255, 255, 255, 0.15) 50%, rgba(255, 255, 255, 0.15) 75%, transparent 75%, transparent); + background-image: linear-gradient(45deg, rgba(255, 255, 255, 0.15) 25%, transparent 25%, transparent 50%, rgba(255, 255, 255, 0.15) 50%, rgba(255, 255, 255, 0.15) 75%, transparent 75%, transparent); +} +.progress-bar-danger { + background-color: #e51c23; +} +.progress-striped .progress-bar-danger { + background-image: -webkit-linear-gradient(45deg, rgba(255, 255, 255, 0.15) 25%, transparent 25%, transparent 50%, rgba(255, 255, 255, 0.15) 50%, rgba(255, 255, 255, 0.15) 75%, transparent 75%, transparent); + background-image: -o-linear-gradient(45deg, rgba(255, 255, 255, 0.15) 25%, transparent 25%, transparent 50%, rgba(255, 255, 255, 0.15) 50%, rgba(255, 255, 255, 0.15) 75%, transparent 75%, transparent); + background-image: linear-gradient(45deg, rgba(255, 255, 255, 0.15) 25%, transparent 25%, transparent 50%, rgba(255, 255, 255, 0.15) 50%, rgba(255, 255, 255, 0.15) 75%, transparent 75%, transparent); +} +.media { + margin-top: 15px; +} +.media:first-child { + margin-top: 0; +} +.media, +.media-body { + zoom: 1; + overflow: hidden; +} +.media-body { + width: 10000px; +} +.media-object { + display: block; +} +.media-object.img-thumbnail { + max-width: none; +} +.media-right, +.media > .pull-right { + padding-left: 10px; +} +.media-left, +.media > .pull-left { + padding-right: 10px; +} +.media-left, +.media-right, +.media-body { + display: table-cell; + vertical-align: top; +} +.media-middle { + vertical-align: middle; +} +.media-bottom { + vertical-align: bottom; +} +.media-heading { + margin-top: 0; + margin-bottom: 5px; +} +.media-list { + padding-left: 0; + list-style: none; +} +.list-group { + margin-bottom: 20px; + padding-left: 0; +} +.list-group-item { + position: relative; + display: block; + padding: 10px 15px; + margin-bottom: -1px; + background-color: #ffffff; + border: 1px solid #dddddd; +} +.list-group-item:first-child { + border-top-right-radius: 3px; + border-top-left-radius: 3px; +} +.list-group-item:last-child { + margin-bottom: 0; + border-bottom-right-radius: 3px; + border-bottom-left-radius: 3px; +} +a.list-group-item, +button.list-group-item { + color: #555555; +} +a.list-group-item .list-group-item-heading, +button.list-group-item .list-group-item-heading { + color: #333333; +} +a.list-group-item:hover, +button.list-group-item:hover, +a.list-group-item:focus, +button.list-group-item:focus { + text-decoration: none; + color: #555555; + background-color: #f5f5f5; +} +button.list-group-item { + width: 100%; + text-align: left; +} +.list-group-item.disabled, +.list-group-item.disabled:hover, +.list-group-item.disabled:focus { + background-color: #eeeeee; + color: #bbbbbb; + cursor: not-allowed; +} +.list-group-item.disabled .list-group-item-heading, +.list-group-item.disabled:hover .list-group-item-heading, +.list-group-item.disabled:focus .list-group-item-heading { + color: inherit; +} +.list-group-item.disabled .list-group-item-text, +.list-group-item.disabled:hover .list-group-item-text, +.list-group-item.disabled:focus .list-group-item-text { + color: #bbbbbb; +} +.list-group-item.active, +.list-group-item.active:hover, +.list-group-item.active:focus { + z-index: 2; + color: #ffffff; + background-color: #2196f3; + border-color: #2196f3; +} +.list-group-item.active .list-group-item-heading, +.list-group-item.active:hover .list-group-item-heading, +.list-group-item.active:focus .list-group-item-heading, +.list-group-item.active .list-group-item-heading > small, +.list-group-item.active:hover .list-group-item-heading > small, +.list-group-item.active:focus .list-group-item-heading > small, +.list-group-item.active .list-group-item-heading > .small, +.list-group-item.active:hover .list-group-item-heading > .small, +.list-group-item.active:focus .list-group-item-heading > .small { + color: inherit; +} +.list-group-item.active .list-group-item-text, +.list-group-item.active:hover .list-group-item-text, +.list-group-item.active:focus .list-group-item-text { + color: #e3f2fd; +} +.list-group-item-success { + color: #4caf50; + background-color: #dff0d8; +} +a.list-group-item-success, +button.list-group-item-success { + color: #4caf50; +} +a.list-group-item-success .list-group-item-heading, +button.list-group-item-success .list-group-item-heading { + color: inherit; +} +a.list-group-item-success:hover, +button.list-group-item-success:hover, +a.list-group-item-success:focus, +button.list-group-item-success:focus { + color: #4caf50; + background-color: #d0e9c6; +} +a.list-group-item-success.active, +button.list-group-item-success.active, +a.list-group-item-success.active:hover, +button.list-group-item-success.active:hover, +a.list-group-item-success.active:focus, +button.list-group-item-success.active:focus { + color: #fff; + background-color: #4caf50; + border-color: #4caf50; +} +.list-group-item-info { + color: #9c27b0; + background-color: #e1bee7; +} +a.list-group-item-info, +button.list-group-item-info { + color: #9c27b0; +} +a.list-group-item-info .list-group-item-heading, +button.list-group-item-info .list-group-item-heading { + color: inherit; +} +a.list-group-item-info:hover, +button.list-group-item-info:hover, +a.list-group-item-info:focus, +button.list-group-item-info:focus { + color: #9c27b0; + background-color: #d8abe0; +} +a.list-group-item-info.active, +button.list-group-item-info.active, +a.list-group-item-info.active:hover, +button.list-group-item-info.active:hover, +a.list-group-item-info.active:focus, +button.list-group-item-info.active:focus { + color: #fff; + background-color: #9c27b0; + border-color: #9c27b0; +} +.list-group-item-warning { + color: #ff9800; + background-color: #ffe0b2; +} +a.list-group-item-warning, +button.list-group-item-warning { + color: #ff9800; +} +a.list-group-item-warning .list-group-item-heading, +button.list-group-item-warning .list-group-item-heading { + color: inherit; +} +a.list-group-item-warning:hover, +button.list-group-item-warning:hover, +a.list-group-item-warning:focus, +button.list-group-item-warning:focus { + color: #ff9800; + background-color: #ffd699; +} +a.list-group-item-warning.active, +button.list-group-item-warning.active, +a.list-group-item-warning.active:hover, +button.list-group-item-warning.active:hover, +a.list-group-item-warning.active:focus, +button.list-group-item-warning.active:focus { + color: #fff; + background-color: #ff9800; + border-color: #ff9800; +} +.list-group-item-danger { + color: #e51c23; + background-color: #f9bdbb; +} +a.list-group-item-danger, +button.list-group-item-danger { + color: #e51c23; +} +a.list-group-item-danger .list-group-item-heading, +button.list-group-item-danger .list-group-item-heading { + color: inherit; +} +a.list-group-item-danger:hover, +button.list-group-item-danger:hover, +a.list-group-item-danger:focus, +button.list-group-item-danger:focus { + color: #e51c23; + background-color: #f7a6a4; +} +a.list-group-item-danger.active, +button.list-group-item-danger.active, +a.list-group-item-danger.active:hover, +button.list-group-item-danger.active:hover, +a.list-group-item-danger.active:focus, +button.list-group-item-danger.active:focus { + color: #fff; + background-color: #e51c23; + border-color: #e51c23; +} +.list-group-item-heading { + margin-top: 0; + margin-bottom: 5px; +} +.list-group-item-text { + margin-bottom: 0; + line-height: 1.3; +} +.panel { + margin-bottom: 23px; + background-color: #ffffff; + border: 1px solid transparent; + border-radius: 3px; + -webkit-box-shadow: 0 1px 1px rgba(0, 0, 0, 0.05); + box-shadow: 0 1px 1px rgba(0, 0, 0, 0.05); +} +.panel-body { + padding: 15px; +} +.panel-heading { + padding: 10px 15px; + border-bottom: 1px solid transparent; + border-top-right-radius: 2px; + border-top-left-radius: 2px; +} +.panel-heading > .dropdown .dropdown-toggle { + color: inherit; +} +.panel-title { + margin-top: 0; + margin-bottom: 0; + font-size: 15px; + color: inherit; +} +.panel-title > a, +.panel-title > small, +.panel-title > .small, +.panel-title > small > a, +.panel-title > .small > a { + color: inherit; +} +.panel-footer { + padding: 10px 15px; + background-color: #f5f5f5; + border-top: 1px solid #dddddd; + border-bottom-right-radius: 2px; + border-bottom-left-radius: 2px; +} +.panel > .list-group, +.panel > .panel-collapse > .list-group { + margin-bottom: 0; +} +.panel > .list-group .list-group-item, +.panel > .panel-collapse > .list-group .list-group-item { + border-width: 1px 0; + border-radius: 0; +} +.panel > .list-group:first-child .list-group-item:first-child, +.panel > .panel-collapse > .list-group:first-child .list-group-item:first-child { + border-top: 0; + border-top-right-radius: 2px; + border-top-left-radius: 2px; +} +.panel > .list-group:last-child .list-group-item:last-child, +.panel > .panel-collapse > .list-group:last-child .list-group-item:last-child { + border-bottom: 0; + border-bottom-right-radius: 2px; + border-bottom-left-radius: 2px; +} +.panel > .panel-heading + .panel-collapse > .list-group .list-group-item:first-child { + border-top-right-radius: 0; + border-top-left-radius: 0; +} +.panel-heading + .list-group .list-group-item:first-child { + border-top-width: 0; +} +.list-group + .panel-footer { + border-top-width: 0; +} +.panel > .table, +.panel > .table-responsive > .table, +.panel > .panel-collapse > .table { + margin-bottom: 0; +} +.panel > .table caption, +.panel > .table-responsive > .table caption, +.panel > .panel-collapse > .table caption { + padding-left: 15px; + padding-right: 15px; +} +.panel > .table:first-child, +.panel > .table-responsive:first-child > .table:first-child { + border-top-right-radius: 2px; + border-top-left-radius: 2px; +} +.panel > .table:first-child > thead:first-child > tr:first-child, +.panel > .table-responsive:first-child > .table:first-child > thead:first-child > tr:first-child, +.panel > .table:first-child > tbody:first-child > tr:first-child, +.panel > .table-responsive:first-child > .table:first-child > tbody:first-child > tr:first-child { + border-top-left-radius: 2px; + border-top-right-radius: 2px; +} +.panel > .table:first-child > thead:first-child > tr:first-child td:first-child, +.panel > .table-responsive:first-child > .table:first-child > thead:first-child > tr:first-child td:first-child, +.panel > .table:first-child > tbody:first-child > tr:first-child td:first-child, +.panel > .table-responsive:first-child > .table:first-child > tbody:first-child > tr:first-child td:first-child, +.panel > .table:first-child > thead:first-child > tr:first-child th:first-child, +.panel > .table-responsive:first-child > .table:first-child > thead:first-child > tr:first-child th:first-child, +.panel > .table:first-child > tbody:first-child > tr:first-child th:first-child, +.panel > .table-responsive:first-child > .table:first-child > tbody:first-child > tr:first-child th:first-child { + border-top-left-radius: 2px; +} +.panel > .table:first-child > thead:first-child > tr:first-child td:last-child, +.panel > .table-responsive:first-child > .table:first-child > thead:first-child > tr:first-child td:last-child, +.panel > .table:first-child > tbody:first-child > tr:first-child td:last-child, +.panel > .table-responsive:first-child > .table:first-child > tbody:first-child > tr:first-child td:last-child, +.panel > .table:first-child > thead:first-child > tr:first-child th:last-child, +.panel > .table-responsive:first-child > .table:first-child > thead:first-child > tr:first-child th:last-child, +.panel > .table:first-child > tbody:first-child > tr:first-child th:last-child, +.panel > .table-responsive:first-child > .table:first-child > tbody:first-child > tr:first-child th:last-child { + border-top-right-radius: 2px; +} +.panel > .table:last-child, +.panel > .table-responsive:last-child > .table:last-child { + border-bottom-right-radius: 2px; + border-bottom-left-radius: 2px; +} +.panel > .table:last-child > tbody:last-child > tr:last-child, +.panel > .table-responsive:last-child > .table:last-child > tbody:last-child > tr:last-child, +.panel > .table:last-child > tfoot:last-child > tr:last-child, +.panel > .table-responsive:last-child > .table:last-child > tfoot:last-child > tr:last-child { + border-bottom-left-radius: 2px; + border-bottom-right-radius: 2px; +} +.panel > .table:last-child > tbody:last-child > tr:last-child td:first-child, +.panel > .table-responsive:last-child > .table:last-child > tbody:last-child > tr:last-child td:first-child, +.panel > .table:last-child > tfoot:last-child > tr:last-child td:first-child, +.panel > .table-responsive:last-child > .table:last-child > tfoot:last-child > tr:last-child td:first-child, +.panel > .table:last-child > tbody:last-child > tr:last-child th:first-child, +.panel > .table-responsive:last-child > .table:last-child > tbody:last-child > tr:last-child th:first-child, +.panel > .table:last-child > tfoot:last-child > tr:last-child th:first-child, +.panel > .table-responsive:last-child > .table:last-child > tfoot:last-child > tr:last-child th:first-child { + border-bottom-left-radius: 2px; +} +.panel > .table:last-child > tbody:last-child > tr:last-child td:last-child, +.panel > .table-responsive:last-child > .table:last-child > tbody:last-child > tr:last-child td:last-child, +.panel > .table:last-child > tfoot:last-child > tr:last-child td:last-child, +.panel > .table-responsive:last-child > .table:last-child > tfoot:last-child > tr:last-child td:last-child, +.panel > .table:last-child > tbody:last-child > tr:last-child th:last-child, +.panel > .table-responsive:last-child > .table:last-child > tbody:last-child > tr:last-child th:last-child, +.panel > .table:last-child > tfoot:last-child > tr:last-child th:last-child, +.panel > .table-responsive:last-child > .table:last-child > tfoot:last-child > tr:last-child th:last-child { + border-bottom-right-radius: 2px; +} +.panel > .panel-body + .table, +.panel > .panel-body + .table-responsive, +.panel > .table + .panel-body, +.panel > .table-responsive + .panel-body { + border-top: 1px solid #dddddd; +} +.panel > .table > tbody:first-child > tr:first-child th, +.panel > .table > tbody:first-child > tr:first-child td { + border-top: 0; +} +.panel > .table-bordered, +.panel > .table-responsive > .table-bordered { + border: 0; +} +.panel > .table-bordered > thead > tr > th:first-child, +.panel > .table-responsive > .table-bordered > thead > tr > th:first-child, +.panel > .table-bordered > tbody > tr > th:first-child, +.panel > .table-responsive > .table-bordered > tbody > tr > th:first-child, +.panel > .table-bordered > tfoot > tr > th:first-child, +.panel > .table-responsive > .table-bordered > tfoot > tr > th:first-child, +.panel > .table-bordered > thead > tr > td:first-child, +.panel > .table-responsive > .table-bordered > thead > tr > td:first-child, +.panel > .table-bordered > tbody > tr > td:first-child, +.panel > .table-responsive > .table-bordered > tbody > tr > td:first-child, +.panel > .table-bordered > tfoot > tr > td:first-child, +.panel > .table-responsive > .table-bordered > tfoot > tr > td:first-child { + border-left: 0; +} +.panel > .table-bordered > thead > tr > th:last-child, +.panel > .table-responsive > .table-bordered > thead > tr > th:last-child, +.panel > .table-bordered > tbody > tr > th:last-child, +.panel > .table-responsive > .table-bordered > tbody > tr > th:last-child, +.panel > .table-bordered > tfoot > tr > th:last-child, +.panel > .table-responsive > .table-bordered > tfoot > tr > th:last-child, +.panel > .table-bordered > thead > tr > td:last-child, +.panel > .table-responsive > .table-bordered > thead > tr > td:last-child, +.panel > .table-bordered > tbody > tr > td:last-child, +.panel > .table-responsive > .table-bordered > tbody > tr > td:last-child, +.panel > .table-bordered > tfoot > tr > td:last-child, +.panel > .table-responsive > .table-bordered > tfoot > tr > td:last-child { + border-right: 0; +} +.panel > .table-bordered > thead > tr:first-child > td, +.panel > .table-responsive > .table-bordered > thead > tr:first-child > td, +.panel > .table-bordered > tbody > tr:first-child > td, +.panel > .table-responsive > .table-bordered > tbody > tr:first-child > td, +.panel > .table-bordered > thead > tr:first-child > th, +.panel > .table-responsive > .table-bordered > thead > tr:first-child > th, +.panel > .table-bordered > tbody > tr:first-child > th, +.panel > .table-responsive > .table-bordered > tbody > tr:first-child > th { + border-bottom: 0; +} +.panel > .table-bordered > tbody > tr:last-child > td, +.panel > .table-responsive > .table-bordered > tbody > tr:last-child > td, +.panel > .table-bordered > tfoot > tr:last-child > td, +.panel > .table-responsive > .table-bordered > tfoot > tr:last-child > td, +.panel > .table-bordered > tbody > tr:last-child > th, +.panel > .table-responsive > .table-bordered > tbody > tr:last-child > th, +.panel > .table-bordered > tfoot > tr:last-child > th, +.panel > .table-responsive > .table-bordered > tfoot > tr:last-child > th { + border-bottom: 0; +} +.panel > .table-responsive { + border: 0; + margin-bottom: 0; +} +.panel-group { + margin-bottom: 23px; +} +.panel-group .panel { + margin-bottom: 0; + border-radius: 3px; +} +.panel-group .panel + .panel { + margin-top: 5px; +} +.panel-group .panel-heading { + border-bottom: 0; +} +.panel-group .panel-heading + .panel-collapse > .panel-body, +.panel-group .panel-heading + .panel-collapse > .list-group { + border-top: 1px solid #dddddd; +} +.panel-group .panel-footer { + border-top: 0; +} +.panel-group .panel-footer + .panel-collapse .panel-body { + border-bottom: 1px solid #dddddd; +} +.panel-default { + border-color: #dddddd; +} +.panel-default > .panel-heading { + color: #212121; + background-color: #f5f5f5; + border-color: #dddddd; +} +.panel-default > .panel-heading + .panel-collapse > .panel-body { + border-top-color: #dddddd; +} +.panel-default > .panel-heading .badge { + color: #f5f5f5; + background-color: #212121; +} +.panel-default > .panel-footer + .panel-collapse > .panel-body { + border-bottom-color: #dddddd; +} +.panel-primary { + border-color: #2196f3; +} +.panel-primary > .panel-heading { + color: #ffffff; + background-color: #2196f3; + border-color: #2196f3; +} +.panel-primary > .panel-heading + .panel-collapse > .panel-body { + border-top-color: #2196f3; +} +.panel-primary > .panel-heading .badge { + color: #2196f3; + background-color: #ffffff; +} +.panel-primary > .panel-footer + .panel-collapse > .panel-body { + border-bottom-color: #2196f3; +} +.panel-success { + border-color: #d6e9c6; +} +.panel-success > .panel-heading { + color: #ffffff; + background-color: #4caf50; + border-color: #d6e9c6; +} +.panel-success > .panel-heading + .panel-collapse > .panel-body { + border-top-color: #d6e9c6; +} +.panel-success > .panel-heading .badge { + color: #4caf50; + background-color: #ffffff; +} +.panel-success > .panel-footer + .panel-collapse > .panel-body { + border-bottom-color: #d6e9c6; +} +.panel-info { + border-color: #cba4dd; +} +.panel-info > .panel-heading { + color: #ffffff; + background-color: #9c27b0; + border-color: #cba4dd; +} +.panel-info > .panel-heading + .panel-collapse > .panel-body { + border-top-color: #cba4dd; +} +.panel-info > .panel-heading .badge { + color: #9c27b0; + background-color: #ffffff; +} +.panel-info > .panel-footer + .panel-collapse > .panel-body { + border-bottom-color: #cba4dd; +} +.panel-warning { + border-color: #ffc599; +} +.panel-warning > .panel-heading { + color: #ffffff; + background-color: #ff9800; + border-color: #ffc599; +} +.panel-warning > .panel-heading + .panel-collapse > .panel-body { + border-top-color: #ffc599; +} +.panel-warning > .panel-heading .badge { + color: #ff9800; + background-color: #ffffff; +} +.panel-warning > .panel-footer + .panel-collapse > .panel-body { + border-bottom-color: #ffc599; +} +.panel-danger { + border-color: #f7a4af; +} +.panel-danger > .panel-heading { + color: #ffffff; + background-color: #e51c23; + border-color: #f7a4af; +} +.panel-danger > .panel-heading + .panel-collapse > .panel-body { + border-top-color: #f7a4af; +} +.panel-danger > .panel-heading .badge { + color: #e51c23; + background-color: #ffffff; +} +.panel-danger > .panel-footer + .panel-collapse > .panel-body { + border-bottom-color: #f7a4af; +} +.embed-responsive { + position: relative; + display: block; + height: 0; + padding: 0; + overflow: hidden; +} +.embed-responsive .embed-responsive-item, +.embed-responsive iframe, +.embed-responsive embed, +.embed-responsive object, +.embed-responsive video { + position: absolute; + top: 0; + left: 0; + bottom: 0; + height: 100%; + width: 100%; + border: 0; +} +.embed-responsive-16by9 { + padding-bottom: 56.25%; +} +.embed-responsive-4by3 { + padding-bottom: 75%; +} +.well { + min-height: 20px; + padding: 19px; + margin-bottom: 20px; + background-color: #f9f9f9; + border: 1px solid transparent; + border-radius: 3px; + -webkit-box-shadow: inset 0 1px 1px rgba(0, 0, 0, 0.05); + box-shadow: inset 0 1px 1px rgba(0, 0, 0, 0.05); +} +.well blockquote { + border-color: #ddd; + border-color: rgba(0, 0, 0, 0.15); +} +.well-lg { + padding: 24px; + border-radius: 3px; +} +.well-sm { + padding: 9px; + border-radius: 3px; +} +.close { + float: right; + font-size: 19.5px; + font-weight: normal; + line-height: 1; + color: #000000; + text-shadow: none; + opacity: 0.2; + filter: alpha(opacity=20); +} +.close:hover, +.close:focus { + color: #000000; + text-decoration: none; + cursor: pointer; + opacity: 0.5; + filter: alpha(opacity=50); +} +button.close { + padding: 0; + cursor: pointer; + background: transparent; + border: 0; + -webkit-appearance: none; +} +.modal-open { + overflow: hidden; +} +.modal { + display: none; + overflow: hidden; + position: fixed; + top: 0; + right: 0; + bottom: 0; + left: 0; + z-index: 1050; + -webkit-overflow-scrolling: touch; + outline: 0; +} +.modal.fade .modal-dialog { + -webkit-transform: translate(0, -25%); + -ms-transform: translate(0, -25%); + -o-transform: translate(0, -25%); + transform: translate(0, -25%); + -webkit-transition: -webkit-transform 0.3s ease-out; + -o-transition: -o-transform 0.3s ease-out; + transition: transform 0.3s ease-out; +} +.modal.in .modal-dialog { + -webkit-transform: translate(0, 0); + -ms-transform: translate(0, 0); + -o-transform: translate(0, 0); + transform: translate(0, 0); +} +.modal-open .modal { + overflow-x: hidden; + overflow-y: auto; +} +.modal-dialog { + position: relative; + width: auto; + margin: 10px; +} +.modal-content { + position: relative; + background-color: #ffffff; + border: 1px solid #999999; + border: 1px solid transparent; + border-radius: 3px; + -webkit-box-shadow: 0 3px 9px rgba(0, 0, 0, 0.5); + box-shadow: 0 3px 9px rgba(0, 0, 0, 0.5); + -webkit-background-clip: padding-box; + background-clip: padding-box; + outline: 0; +} +.modal-backdrop { + position: fixed; + top: 0; + right: 0; + bottom: 0; + left: 0; + z-index: 1040; + background-color: #000000; +} +.modal-backdrop.fade { + opacity: 0; + filter: alpha(opacity=0); +} +.modal-backdrop.in { + opacity: 0.5; + filter: alpha(opacity=50); +} +.modal-header { + padding: 15px; + border-bottom: 1px solid transparent; + min-height: 16.846px; +} +.modal-header .close { + margin-top: -2px; +} +.modal-title { + margin: 0; + line-height: 1.846; +} +.modal-body { + position: relative; + padding: 15px; +} +.modal-footer { + padding: 15px; + text-align: right; + border-top: 1px solid transparent; +} +.modal-footer .btn + .btn { + margin-left: 5px; + margin-bottom: 0; +} +.modal-footer .btn-group .btn + .btn { + margin-left: -1px; +} +.modal-footer .btn-block + .btn-block { + margin-left: 0; +} +.modal-scrollbar-measure { + position: absolute; + top: -9999px; + width: 50px; + height: 50px; + overflow: scroll; +} +@media (min-width: 768px) { + .modal-dialog { + width: 600px; + margin: 30px auto; + } + .modal-content { + -webkit-box-shadow: 0 5px 15px rgba(0, 0, 0, 0.5); + box-shadow: 0 5px 15px rgba(0, 0, 0, 0.5); + } + .modal-sm { + width: 300px; + } +} +@media (min-width: 992px) { + .modal-lg { + width: 900px; + } +} +.tooltip { + position: absolute; + z-index: 1070; + display: block; + font-family: "Roboto", "Helvetica Neue", Helvetica, Arial, sans-serif; + font-style: normal; + font-weight: normal; + letter-spacing: normal; + line-break: auto; + line-height: 1.846; + text-align: left; + text-align: start; + text-decoration: none; + text-shadow: none; + text-transform: none; + white-space: normal; + word-break: normal; + word-spacing: normal; + word-wrap: normal; + font-size: 12px; + opacity: 0; + filter: alpha(opacity=0); +} +.tooltip.in { + opacity: 0.9; + filter: alpha(opacity=90); +} +.tooltip.top { + margin-top: -3px; + padding: 5px 0; +} +.tooltip.right { + margin-left: 3px; + padding: 0 5px; +} +.tooltip.bottom { + margin-top: 3px; + padding: 5px 0; +} +.tooltip.left { + margin-left: -3px; + padding: 0 5px; +} +.tooltip-inner { + max-width: 200px; + padding: 3px 8px; + color: #ffffff; + text-align: center; + background-color: #727272; + border-radius: 3px; +} +.tooltip-arrow { + position: absolute; + width: 0; + height: 0; + border-color: transparent; + border-style: solid; +} +.tooltip.top .tooltip-arrow { + bottom: 0; + left: 50%; + margin-left: -5px; + border-width: 5px 5px 0; + border-top-color: #727272; +} +.tooltip.top-left .tooltip-arrow { + bottom: 0; + right: 5px; + margin-bottom: -5px; + border-width: 5px 5px 0; + border-top-color: #727272; +} +.tooltip.top-right .tooltip-arrow { + bottom: 0; + left: 5px; + margin-bottom: -5px; + border-width: 5px 5px 0; + border-top-color: #727272; +} +.tooltip.right .tooltip-arrow { + top: 50%; + left: 0; + margin-top: -5px; + border-width: 5px 5px 5px 0; + border-right-color: #727272; +} +.tooltip.left .tooltip-arrow { + top: 50%; + right: 0; + margin-top: -5px; + border-width: 5px 0 5px 5px; + border-left-color: #727272; +} +.tooltip.bottom .tooltip-arrow { + top: 0; + left: 50%; + margin-left: -5px; + border-width: 0 5px 5px; + border-bottom-color: #727272; +} +.tooltip.bottom-left .tooltip-arrow { + top: 0; + right: 5px; + margin-top: -5px; + border-width: 0 5px 5px; + border-bottom-color: #727272; +} +.tooltip.bottom-right .tooltip-arrow { + top: 0; + left: 5px; + margin-top: -5px; + border-width: 0 5px 5px; + border-bottom-color: #727272; +} +.popover { + position: absolute; + top: 0; + left: 0; + z-index: 1060; + display: none; + max-width: 276px; + padding: 1px; + font-family: "Roboto", "Helvetica Neue", Helvetica, Arial, sans-serif; + font-style: normal; + font-weight: normal; + letter-spacing: normal; + line-break: auto; + line-height: 1.846; + text-align: left; + text-align: start; + text-decoration: none; + text-shadow: none; + text-transform: none; + white-space: normal; + word-break: normal; + word-spacing: normal; + word-wrap: normal; + font-size: 13px; + background-color: #ffffff; + -webkit-background-clip: padding-box; + background-clip: padding-box; + border: 1px solid transparent; + border-radius: 3px; + -webkit-box-shadow: 0 5px 10px rgba(0, 0, 0, 0.2); + box-shadow: 0 5px 10px rgba(0, 0, 0, 0.2); +} +.popover.top { + margin-top: -10px; +} +.popover.right { + margin-left: 10px; +} +.popover.bottom { + margin-top: 10px; +} +.popover.left { + margin-left: -10px; +} +.popover-title { + margin: 0; + padding: 8px 14px; + font-size: 13px; + background-color: #f7f7f7; + border-bottom: 1px solid #ebebeb; + border-radius: 2px 2px 0 0; +} +.popover-content { + padding: 9px 14px; +} +.popover > .arrow, +.popover > .arrow:after { + position: absolute; + display: block; + width: 0; + height: 0; + border-color: transparent; + border-style: solid; +} +.popover > .arrow { + border-width: 11px; +} +.popover > .arrow:after { + border-width: 10px; + content: ""; +} +.popover.top > .arrow { + left: 50%; + margin-left: -11px; + border-bottom-width: 0; + border-top-color: rgba(0, 0, 0, 0); + border-top-color: rgba(0, 0, 0, 0.075); + bottom: -11px; +} +.popover.top > .arrow:after { + content: " "; + bottom: 1px; + margin-left: -10px; + border-bottom-width: 0; + border-top-color: #ffffff; +} +.popover.right > .arrow { + top: 50%; + left: -11px; + margin-top: -11px; + border-left-width: 0; + border-right-color: rgba(0, 0, 0, 0); + border-right-color: rgba(0, 0, 0, 0.075); +} +.popover.right > .arrow:after { + content: " "; + left: 1px; + bottom: -10px; + border-left-width: 0; + border-right-color: #ffffff; +} +.popover.bottom > .arrow { + left: 50%; + margin-left: -11px; + border-top-width: 0; + border-bottom-color: rgba(0, 0, 0, 0); + border-bottom-color: rgba(0, 0, 0, 0.075); + top: -11px; +} +.popover.bottom > .arrow:after { + content: " "; + top: 1px; + margin-left: -10px; + border-top-width: 0; + border-bottom-color: #ffffff; +} +.popover.left > .arrow { + top: 50%; + right: -11px; + margin-top: -11px; + border-right-width: 0; + border-left-color: rgba(0, 0, 0, 0); + border-left-color: rgba(0, 0, 0, 0.075); +} +.popover.left > .arrow:after { + content: " "; + right: 1px; + border-right-width: 0; + border-left-color: #ffffff; + bottom: -10px; +} +.carousel { + position: relative; +} +.carousel-inner { + position: relative; + overflow: hidden; + width: 100%; +} +.carousel-inner > .item { + display: none; + position: relative; + -webkit-transition: 0.6s ease-in-out left; + -o-transition: 0.6s ease-in-out left; + transition: 0.6s ease-in-out left; +} +.carousel-inner > .item > img, +.carousel-inner > .item > a > img { + line-height: 1; +} +@media all and (transform-3d), (-webkit-transform-3d) { + .carousel-inner > .item { + -webkit-transition: -webkit-transform 0.6s ease-in-out; + -o-transition: -o-transform 0.6s ease-in-out; + transition: transform 0.6s ease-in-out; + -webkit-backface-visibility: hidden; + backface-visibility: hidden; + -webkit-perspective: 1000px; + perspective: 1000px; + } + .carousel-inner > .item.next, + .carousel-inner > .item.active.right { + -webkit-transform: translate3d(100%, 0, 0); + transform: translate3d(100%, 0, 0); + left: 0; + } + .carousel-inner > .item.prev, + .carousel-inner > .item.active.left { + -webkit-transform: translate3d(-100%, 0, 0); + transform: translate3d(-100%, 0, 0); + left: 0; + } + .carousel-inner > .item.next.left, + .carousel-inner > .item.prev.right, + .carousel-inner > .item.active { + -webkit-transform: translate3d(0, 0, 0); + transform: translate3d(0, 0, 0); + left: 0; + } +} +.carousel-inner > .active, +.carousel-inner > .next, +.carousel-inner > .prev { + display: block; +} +.carousel-inner > .active { + left: 0; +} +.carousel-inner > .next, +.carousel-inner > .prev { + position: absolute; + top: 0; + width: 100%; +} +.carousel-inner > .next { + left: 100%; +} +.carousel-inner > .prev { + left: -100%; +} +.carousel-inner > .next.left, +.carousel-inner > .prev.right { + left: 0; +} +.carousel-inner > .active.left { + left: -100%; +} +.carousel-inner > .active.right { + left: 100%; +} +.carousel-control { + position: absolute; + top: 0; + left: 0; + bottom: 0; + width: 15%; + opacity: 0.5; + filter: alpha(opacity=50); + font-size: 20px; + color: #ffffff; + text-align: center; + text-shadow: 0 1px 2px rgba(0, 0, 0, 0.6); +} +.carousel-control.left { + background-image: -webkit-linear-gradient(left, rgba(0, 0, 0, 0.5) 0%, rgba(0, 0, 0, 0.0001) 100%); + background-image: -o-linear-gradient(left, rgba(0, 0, 0, 0.5) 0%, rgba(0, 0, 0, 0.0001) 100%); + background-image: -webkit-gradient(linear, left top, right top, from(rgba(0, 0, 0, 0.5)), to(rgba(0, 0, 0, 0.0001))); + background-image: linear-gradient(to right, rgba(0, 0, 0, 0.5) 0%, rgba(0, 0, 0, 0.0001) 100%); + background-repeat: repeat-x; + filter: progid:DXImageTransform.Microsoft.gradient(startColorstr='#80000000', endColorstr='#00000000', GradientType=1); +} +.carousel-control.right { + left: auto; + right: 0; + background-image: -webkit-linear-gradient(left, rgba(0, 0, 0, 0.0001) 0%, rgba(0, 0, 0, 0.5) 100%); + background-image: -o-linear-gradient(left, rgba(0, 0, 0, 0.0001) 0%, rgba(0, 0, 0, 0.5) 100%); + background-image: -webkit-gradient(linear, left top, right top, from(rgba(0, 0, 0, 0.0001)), to(rgba(0, 0, 0, 0.5))); + background-image: linear-gradient(to right, rgba(0, 0, 0, 0.0001) 0%, rgba(0, 0, 0, 0.5) 100%); + background-repeat: repeat-x; + filter: progid:DXImageTransform.Microsoft.gradient(startColorstr='#00000000', endColorstr='#80000000', GradientType=1); +} +.carousel-control:hover, +.carousel-control:focus { + outline: 0; + color: #ffffff; + text-decoration: none; + opacity: 0.9; + filter: alpha(opacity=90); +} +.carousel-control .icon-prev, +.carousel-control .icon-next, +.carousel-control .glyphicon-chevron-left, +.carousel-control .glyphicon-chevron-right { + position: absolute; + top: 50%; + margin-top: -10px; + z-index: 5; + display: inline-block; +} +.carousel-control .icon-prev, +.carousel-control .glyphicon-chevron-left { + left: 50%; + margin-left: -10px; +} +.carousel-control .icon-next, +.carousel-control .glyphicon-chevron-right { + right: 50%; + margin-right: -10px; +} +.carousel-control .icon-prev, +.carousel-control .icon-next { + width: 20px; + height: 20px; + line-height: 1; + font-family: serif; +} +.carousel-control .icon-prev:before { + content: '\2039'; +} +.carousel-control .icon-next:before { + content: '\203a'; +} +.carousel-indicators { + position: absolute; + bottom: 10px; + left: 50%; + z-index: 15; + width: 60%; + margin-left: -30%; + padding-left: 0; + list-style: none; + text-align: center; +} +.carousel-indicators li { + display: inline-block; + width: 10px; + height: 10px; + margin: 1px; + text-indent: -999px; + border: 1px solid #ffffff; + border-radius: 10px; + cursor: pointer; + background-color: #000 \9; + background-color: rgba(0, 0, 0, 0); +} +.carousel-indicators .active { + margin: 0; + width: 12px; + height: 12px; + background-color: #ffffff; +} +.carousel-caption { + position: absolute; + left: 15%; + right: 15%; + bottom: 20px; + z-index: 10; + padding-top: 20px; + padding-bottom: 20px; + color: #ffffff; + text-align: center; + text-shadow: 0 1px 2px rgba(0, 0, 0, 0.6); +} +.carousel-caption .btn { + text-shadow: none; +} +@media screen and (min-width: 768px) { + .carousel-control .glyphicon-chevron-left, + .carousel-control .glyphicon-chevron-right, + .carousel-control .icon-prev, + .carousel-control .icon-next { + width: 30px; + height: 30px; + margin-top: -15px; + font-size: 30px; + } + .carousel-control .glyphicon-chevron-left, + .carousel-control .icon-prev { + margin-left: -15px; + } + .carousel-control .glyphicon-chevron-right, + .carousel-control .icon-next { + margin-right: -15px; + } + .carousel-caption { + left: 20%; + right: 20%; + padding-bottom: 30px; + } + .carousel-indicators { + bottom: 20px; + } +} +.clearfix:before, +.clearfix:after, +.dl-horizontal dd:before, +.dl-horizontal dd:after, +.container:before, +.container:after, +.container-fluid:before, +.container-fluid:after, +.row:before, +.row:after, +.form-horizontal .form-group:before, +.form-horizontal .form-group:after, +.btn-toolbar:before, +.btn-toolbar:after, +.btn-group-vertical > .btn-group:before, +.btn-group-vertical > .btn-group:after, +.nav:before, +.nav:after, +.navbar:before, +.navbar:after, +.navbar-header:before, +.navbar-header:after, +.navbar-collapse:before, +.navbar-collapse:after, +.pager:before, +.pager:after, +.panel-body:before, +.panel-body:after, +.modal-footer:before, +.modal-footer:after { + content: " "; + display: table; +} +.clearfix:after, +.dl-horizontal dd:after, +.container:after, +.container-fluid:after, +.row:after, +.form-horizontal .form-group:after, +.btn-toolbar:after, +.btn-group-vertical > .btn-group:after, +.nav:after, +.navbar:after, +.navbar-header:after, +.navbar-collapse:after, +.pager:after, +.panel-body:after, +.modal-footer:after { + clear: both; +} +.center-block { + display: block; + margin-left: auto; + margin-right: auto; +} +.pull-right { + float: right !important; +} +.pull-left { + float: left !important; +} +.hide { + display: none !important; +} +.show { + display: block !important; +} +.invisible { + visibility: hidden; +} +.text-hide { + font: 0/0 a; + color: transparent; + text-shadow: none; + background-color: transparent; + border: 0; +} +.hidden { + display: none !important; +} +.affix { + position: fixed; +} +@-ms-viewport { + width: device-width; +} +.visible-xs, +.visible-sm, +.visible-md, +.visible-lg { + display: none !important; +} +.visible-xs-block, +.visible-xs-inline, +.visible-xs-inline-block, +.visible-sm-block, +.visible-sm-inline, +.visible-sm-inline-block, +.visible-md-block, +.visible-md-inline, +.visible-md-inline-block, +.visible-lg-block, +.visible-lg-inline, +.visible-lg-inline-block { + display: none !important; +} +@media (max-width: 767px) { + .visible-xs { + display: block !important; + } + table.visible-xs { + display: table !important; + } + tr.visible-xs { + display: table-row !important; + } + th.visible-xs, + td.visible-xs { + display: table-cell !important; + } +} +@media (max-width: 767px) { + .visible-xs-block { + display: block !important; + } +} +@media (max-width: 767px) { + .visible-xs-inline { + display: inline !important; + } +} +@media (max-width: 767px) { + .visible-xs-inline-block { + display: inline-block !important; + } +} +@media (min-width: 768px) and (max-width: 991px) { + .visible-sm { + display: block !important; + } + table.visible-sm { + display: table !important; + } + tr.visible-sm { + display: table-row !important; + } + th.visible-sm, + td.visible-sm { + display: table-cell !important; + } +} +@media (min-width: 768px) and (max-width: 991px) { + .visible-sm-block { + display: block !important; + } +} +@media (min-width: 768px) and (max-width: 991px) { + .visible-sm-inline { + display: inline !important; + } +} +@media (min-width: 768px) and (max-width: 991px) { + .visible-sm-inline-block { + display: inline-block !important; + } +} +@media (min-width: 992px) and (max-width: 1199px) { + .visible-md { + display: block !important; + } + table.visible-md { + display: table !important; + } + tr.visible-md { + display: table-row !important; + } + th.visible-md, + td.visible-md { + display: table-cell !important; + } +} +@media (min-width: 992px) and (max-width: 1199px) { + .visible-md-block { + display: block !important; + } +} +@media (min-width: 992px) and (max-width: 1199px) { + .visible-md-inline { + display: inline !important; + } +} +@media (min-width: 992px) and (max-width: 1199px) { + .visible-md-inline-block { + display: inline-block !important; + } +} +@media (min-width: 1200px) { + .visible-lg { + display: block !important; + } + table.visible-lg { + display: table !important; + } + tr.visible-lg { + display: table-row !important; + } + th.visible-lg, + td.visible-lg { + display: table-cell !important; + } +} +@media (min-width: 1200px) { + .visible-lg-block { + display: block !important; + } +} +@media (min-width: 1200px) { + .visible-lg-inline { + display: inline !important; + } +} +@media (min-width: 1200px) { + .visible-lg-inline-block { + display: inline-block !important; + } +} +@media (max-width: 767px) { + .hidden-xs { + display: none !important; + } +} +@media (min-width: 768px) and (max-width: 991px) { + .hidden-sm { + display: none !important; + } +} +@media (min-width: 992px) and (max-width: 1199px) { + .hidden-md { + display: none !important; + } +} +@media (min-width: 1200px) { + .hidden-lg { + display: none !important; + } +} +.visible-print { + display: none !important; +} +@media print { + .visible-print { + display: block !important; + } + table.visible-print { + display: table !important; + } + tr.visible-print { + display: table-row !important; + } + th.visible-print, + td.visible-print { + display: table-cell !important; + } +} +.visible-print-block { + display: none !important; +} +@media print { + .visible-print-block { + display: block !important; + } +} +.visible-print-inline { + display: none !important; +} +@media print { + .visible-print-inline { + display: inline !important; + } +} +.visible-print-inline-block { + display: none !important; +} +@media print { + .visible-print-inline-block { + display: inline-block !important; + } +} +@media print { + .hidden-print { + display: none !important; + } +} +.navbar { + border: none; + -webkit-box-shadow: 0 1px 2px rgba(0, 0, 0, 0.3); + box-shadow: 0 1px 2px rgba(0, 0, 0, 0.3); +} +.navbar-brand { + font-size: 24px; +} +.navbar-inverse .form-control { + color: #fff; +} +.navbar-inverse .form-control::-moz-placeholder { + color: #b2dbfb; + opacity: 1; +} +.navbar-inverse .form-control:-ms-input-placeholder { + color: #b2dbfb; +} +.navbar-inverse .form-control::-webkit-input-placeholder { + color: #b2dbfb; +} +.navbar-inverse .form-control[type=text], +.navbar-inverse .form-control[type=password] { + -webkit-box-shadow: inset 0 -1px 0 #b2dbfb; + box-shadow: inset 0 -1px 0 #b2dbfb; +} +.navbar-inverse .form-control[type=text]:focus, +.navbar-inverse .form-control[type=password]:focus { + -webkit-box-shadow: inset 0 -2px 0 #ffffff; + box-shadow: inset 0 -2px 0 #ffffff; +} +.btn-default { + -webkit-background-size: 200% 200%; + background-size: 200%; + background-position: 50%; +} +.btn-default:hover, +.btn-default:active:hover, +.btn-default:focus { + background-color: #f0f0f0; +} +.btn-default:active { + background-color: #f0f0f0; + background-image: -webkit-radial-gradient(circle, #f0f0f0 10%, #ffffff 11%); + background-image: -o-radial-gradient(circle, #f0f0f0 10%, #ffffff 11%); + background-image: radial-gradient(circle, #f0f0f0 10%, #ffffff 11%); + background-repeat: no-repeat; + -webkit-background-size: 1000% 1000%; + background-size: 1000%; + -webkit-box-shadow: 2px 2px 2px rgba(0, 0, 0, 0.3); + box-shadow: 2px 2px 2px rgba(0, 0, 0, 0.3); +} +.btn-primary { + -webkit-background-size: 200% 200%; + background-size: 200%; + background-position: 50%; +} +.btn-primary:hover, +.btn-primary:active:hover, +.btn-primary:focus { + background-color: #0d87e9; +} +.btn-primary:active { + background-color: #0d87e9; + background-image: -webkit-radial-gradient(circle, #0d87e9 10%, #2196f3 11%); + background-image: -o-radial-gradient(circle, #0d87e9 10%, #2196f3 11%); + background-image: radial-gradient(circle, #0d87e9 10%, #2196f3 11%); + background-repeat: no-repeat; + -webkit-background-size: 1000% 1000%; + background-size: 1000%; + -webkit-box-shadow: 2px 2px 2px rgba(0, 0, 0, 0.3); + box-shadow: 2px 2px 2px rgba(0, 0, 0, 0.3); +} +.btn-success { + -webkit-background-size: 200% 200%; + background-size: 200%; + background-position: 50%; +} +.btn-success:hover, +.btn-success:active:hover, +.btn-success:focus { + background-color: #439a46; +} +.btn-success:active { + background-color: #439a46; + background-image: -webkit-radial-gradient(circle, #439a46 10%, #4caf50 11%); + background-image: -o-radial-gradient(circle, #439a46 10%, #4caf50 11%); + background-image: radial-gradient(circle, #439a46 10%, #4caf50 11%); + background-repeat: no-repeat; + -webkit-background-size: 1000% 1000%; + background-size: 1000%; + -webkit-box-shadow: 2px 2px 2px rgba(0, 0, 0, 0.3); + box-shadow: 2px 2px 2px rgba(0, 0, 0, 0.3); +} +.btn-info { + -webkit-background-size: 200% 200%; + background-size: 200%; + background-position: 50%; +} +.btn-info:hover, +.btn-info:active:hover, +.btn-info:focus { + background-color: #862197; +} +.btn-info:active { + background-color: #862197; + background-image: -webkit-radial-gradient(circle, #862197 10%, #9c27b0 11%); + background-image: -o-radial-gradient(circle, #862197 10%, #9c27b0 11%); + background-image: radial-gradient(circle, #862197 10%, #9c27b0 11%); + background-repeat: no-repeat; + -webkit-background-size: 1000% 1000%; + background-size: 1000%; + -webkit-box-shadow: 2px 2px 2px rgba(0, 0, 0, 0.3); + box-shadow: 2px 2px 2px rgba(0, 0, 0, 0.3); +} +.btn-warning { + -webkit-background-size: 200% 200%; + background-size: 200%; + background-position: 50%; +} +.btn-warning:hover, +.btn-warning:active:hover, +.btn-warning:focus { + background-color: #e08600; +} +.btn-warning:active { + background-color: #e08600; + background-image: -webkit-radial-gradient(circle, #e08600 10%, #ff9800 11%); + background-image: -o-radial-gradient(circle, #e08600 10%, #ff9800 11%); + background-image: radial-gradient(circle, #e08600 10%, #ff9800 11%); + background-repeat: no-repeat; + -webkit-background-size: 1000% 1000%; + background-size: 1000%; + -webkit-box-shadow: 2px 2px 2px rgba(0, 0, 0, 0.3); + box-shadow: 2px 2px 2px rgba(0, 0, 0, 0.3); +} +.btn-danger { + -webkit-background-size: 200% 200%; + background-size: 200%; + background-position: 50%; +} +.btn-danger:hover, +.btn-danger:active:hover, +.btn-danger:focus { + background-color: #cb171e; +} +.btn-danger:active { + background-color: #cb171e; + background-image: -webkit-radial-gradient(circle, #cb171e 10%, #e51c23 11%); + background-image: -o-radial-gradient(circle, #cb171e 10%, #e51c23 11%); + background-image: radial-gradient(circle, #cb171e 10%, #e51c23 11%); + background-repeat: no-repeat; + -webkit-background-size: 1000% 1000%; + background-size: 1000%; + -webkit-box-shadow: 2px 2px 2px rgba(0, 0, 0, 0.3); + box-shadow: 2px 2px 2px rgba(0, 0, 0, 0.3); +} +.btn { + text-transform: uppercase; + border-right: none; + border-bottom: none; + -webkit-box-shadow: 1px 1px 2px rgba(0, 0, 0, 0.3); + box-shadow: 1px 1px 2px rgba(0, 0, 0, 0.3); + -webkit-transition: all 0.2s; + -o-transition: all 0.2s; + transition: all 0.2s; +} +.btn-link { + -webkit-box-shadow: none; + box-shadow: none; +} +.btn-link:hover, +.btn-link:focus { + color: #2196f3; + text-decoration: none; +} +.btn-default.disabled { + border: 1px solid #eeeeee; +} +.btn-group .btn + .btn, +.btn-group .btn + .btn-group, +.btn-group .btn-group + .btn, +.btn-group .btn-group + .btn-group { + margin-left: 0; +} +.btn-group-vertical > .btn + .btn, +.btn-group-vertical > .btn + .btn-group, +.btn-group-vertical > .btn-group + .btn, +.btn-group-vertical > .btn-group + .btn-group { + margin-top: 0; +} +body { + -webkit-font-smoothing: antialiased; + letter-spacing: .1px; +} +p { + margin: 0 0 1em; +} +input, +button { + -webkit-font-smoothing: antialiased; + letter-spacing: .1px; +} +a { + -webkit-transition: all 0.2s; + -o-transition: all 0.2s; + transition: all 0.2s; +} +.table-hover > tbody > tr, +.table-hover > tbody > tr > th, +.table-hover > tbody > tr > td { + -webkit-transition: all 0.2s; + -o-transition: all 0.2s; + transition: all 0.2s; +} +label { + font-weight: normal; +} +textarea, +textarea.form-control, +input.form-control, +input[type=text], +input[type=password], +input[type=email], +input[type=number], +[type=text].form-control, +[type=password].form-control, +[type=email].form-control, +[type=tel].form-control, +[contenteditable].form-control { + padding: 0; + border: none; + border-radius: 0; + -webkit-appearance: none; + -webkit-box-shadow: inset 0 -1px 0 #dddddd; + box-shadow: inset 0 -1px 0 #dddddd; + font-size: 16px; +} +textarea:focus, +textarea.form-control:focus, +input.form-control:focus, +input[type=text]:focus, +input[type=password]:focus, +input[type=email]:focus, +input[type=number]:focus, +[type=text].form-control:focus, +[type=password].form-control:focus, +[type=email].form-control:focus, +[type=tel].form-control:focus, +[contenteditable].form-control:focus { + -webkit-box-shadow: inset 0 -2px 0 #2196f3; + box-shadow: inset 0 -2px 0 #2196f3; +} +textarea[disabled], +textarea.form-control[disabled], +input.form-control[disabled], +input[type=text][disabled], +input[type=password][disabled], +input[type=email][disabled], +input[type=number][disabled], +[type=text].form-control[disabled], +[type=password].form-control[disabled], +[type=email].form-control[disabled], +[type=tel].form-control[disabled], +[contenteditable].form-control[disabled], +textarea[readonly], +textarea.form-control[readonly], +input.form-control[readonly], +input[type=text][readonly], +input[type=password][readonly], +input[type=email][readonly], +input[type=number][readonly], +[type=text].form-control[readonly], +[type=password].form-control[readonly], +[type=email].form-control[readonly], +[type=tel].form-control[readonly], +[contenteditable].form-control[readonly] { + -webkit-box-shadow: none; + box-shadow: none; + border-bottom: 1px dotted #ddd; +} +textarea.input-sm, +textarea.form-control.input-sm, +input.form-control.input-sm, +input[type=text].input-sm, +input[type=password].input-sm, +input[type=email].input-sm, +input[type=number].input-sm, +[type=text].form-control.input-sm, +[type=password].form-control.input-sm, +[type=email].form-control.input-sm, +[type=tel].form-control.input-sm, +[contenteditable].form-control.input-sm { + font-size: 12px; +} +textarea.input-lg, +textarea.form-control.input-lg, +input.form-control.input-lg, +input[type=text].input-lg, +input[type=password].input-lg, +input[type=email].input-lg, +input[type=number].input-lg, +[type=text].form-control.input-lg, +[type=password].form-control.input-lg, +[type=email].form-control.input-lg, +[type=tel].form-control.input-lg, +[contenteditable].form-control.input-lg { + font-size: 17px; +} +select, +select.form-control { + border: 0; + border-radius: 0; + -webkit-appearance: none; + -moz-appearance: none; + appearance: none; + padding-left: 0; + padding-right: 0\9; + background-image: url(data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABoAAAAaCAMAAACelLz8AAAAJ1BMVEVmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmaP/QSjAAAADHRSTlMAAgMJC0uWpKa6wMxMdjkoAAAANUlEQVR4AeXJyQEAERAAsNl7Hf3X6xt0QL6JpZWq30pdvdadme+0PMdzvHm8YThHcT1H7K0BtOMDniZhWOgAAAAASUVORK5CYII=); + -webkit-background-size: 13px 13px; + background-size: 13px; + background-repeat: no-repeat; + background-position: right center; + -webkit-box-shadow: inset 0 -1px 0 #dddddd; + box-shadow: inset 0 -1px 0 #dddddd; + font-size: 16px; + line-height: 1.5; +} +select::-ms-expand, +select.form-control::-ms-expand { + display: none; +} +select.input-sm, +select.form-control.input-sm { + font-size: 12px; +} +select.input-lg, +select.form-control.input-lg { + font-size: 17px; +} +select:focus, +select.form-control:focus { + -webkit-box-shadow: inset 0 -2px 0 #2196f3; + box-shadow: inset 0 -2px 0 #2196f3; + background-image: url(data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABoAAAAaCAMAAACelLz8AAAAJ1BMVEUhISEhISEhISEhISEhISEhISEhISEhISEhISEhISEhISEhISEhISF8S9ewAAAADHRSTlMAAgMJC0uWpKa6wMxMdjkoAAAANUlEQVR4AeXJyQEAERAAsNl7Hf3X6xt0QL6JpZWq30pdvdadme+0PMdzvHm8YThHcT1H7K0BtOMDniZhWOgAAAAASUVORK5CYII=); +} +select[multiple], +select.form-control[multiple] { + background: none; +} +.radio label, +.radio-inline label, +.checkbox label, +.checkbox-inline label { + padding-left: 25px; +} +.radio input[type="radio"], +.radio-inline input[type="radio"], +.checkbox input[type="radio"], +.checkbox-inline input[type="radio"], +.radio input[type="checkbox"], +.radio-inline input[type="checkbox"], +.checkbox input[type="checkbox"], +.checkbox-inline input[type="checkbox"] { + margin-left: -25px; +} +input[type="radio"], +.radio input[type="radio"], +.radio-inline input[type="radio"] { + position: relative; + margin-top: 5px; + margin-right: 4px; + vertical-align: -4px; + border: none; + background-color: transparent; + -webkit-appearance: none; + appearance: none; + cursor: pointer; +} +input[type="radio"]:focus, +.radio input[type="radio"]:focus, +.radio-inline input[type="radio"]:focus { + outline: none; +} +input[type="radio"]:before, +.radio input[type="radio"]:before, +.radio-inline input[type="radio"]:before, +input[type="radio"]:after, +.radio input[type="radio"]:after, +.radio-inline input[type="radio"]:after { + content: ""; + display: block; + width: 18px; + height: 18px; + margin-top: -3px; + border-radius: 50%; + -webkit-transition: 240ms; + -o-transition: 240ms; + transition: 240ms; +} +input[type="radio"]:before, +.radio input[type="radio"]:before, +.radio-inline input[type="radio"]:before { + position: absolute; + left: 0; + top: 0; + background-color: #2196f3; + -webkit-transform: scale(0); + -ms-transform: scale(0); + -o-transform: scale(0); + transform: scale(0); +} +input[type="radio"]:after, +.radio input[type="radio"]:after, +.radio-inline input[type="radio"]:after { + border: 2px solid #666666; +} +input[type="radio"]:checked:before, +.radio input[type="radio"]:checked:before, +.radio-inline input[type="radio"]:checked:before { + -webkit-transform: scale(0.5); + -ms-transform: scale(0.5); + -o-transform: scale(0.5); + transform: scale(0.5); +} +input[type="radio"]:disabled:checked:before, +.radio input[type="radio"]:disabled:checked:before, +.radio-inline input[type="radio"]:disabled:checked:before { + background-color: #bbbbbb; +} +input[type="radio"]:checked:after, +.radio input[type="radio"]:checked:after, +.radio-inline input[type="radio"]:checked:after { + border-color: #2196f3; +} +input[type="radio"]:disabled:after, +.radio input[type="radio"]:disabled:after, +.radio-inline input[type="radio"]:disabled:after, +input[type="radio"]:disabled:checked:after, +.radio input[type="radio"]:disabled:checked:after, +.radio-inline input[type="radio"]:disabled:checked:after { + border-color: #bbbbbb; +} +input[type="checkbox"], +.checkbox input[type="checkbox"], +.checkbox-inline input[type="checkbox"] { + position: relative; + vertical-align: -4px; + border: none; + -webkit-appearance: none; + appearance: none; + cursor: pointer; +} +input[type="checkbox"]:focus, +.checkbox input[type="checkbox"]:focus, +.checkbox-inline input[type="checkbox"]:focus { + outline: none; +} +input[type="checkbox"]:after, +.checkbox input[type="checkbox"]:after, +.checkbox-inline input[type="checkbox"]:after { + content: ""; + display: block; + width: 18px; + height: 18px; + margin-top: -2px; + margin-right: 5px; + border: 2px solid #666666; + border-radius: 2px; + -webkit-transition: 240ms; + -o-transition: 240ms; + transition: 240ms; +} +input[type="checkbox"]:checked:before, +.checkbox input[type="checkbox"]:checked:before, +.checkbox-inline input[type="checkbox"]:checked:before { + content: ""; + position: absolute; + top: 0; + left: 6px; + display: table; + width: 6px; + height: 12px; + border: 2px solid #fff; + border-top-width: 0; + border-left-width: 0; + -webkit-transform: rotate(45deg); + -ms-transform: rotate(45deg); + -o-transform: rotate(45deg); + transform: rotate(45deg); +} +input[type="checkbox"]:checked:after, +.checkbox input[type="checkbox"]:checked:after, +.checkbox-inline input[type="checkbox"]:checked:after { + background-color: #2196f3; + border-color: #2196f3; +} +input[type="checkbox"]:disabled:after, +.checkbox input[type="checkbox"]:disabled:after, +.checkbox-inline input[type="checkbox"]:disabled:after { + border-color: #bbbbbb; +} +input[type="checkbox"]:disabled:checked:after, +.checkbox input[type="checkbox"]:disabled:checked:after, +.checkbox-inline input[type="checkbox"]:disabled:checked:after { + background-color: #bbbbbb; + border-color: transparent; +} +.has-warning input:not([type=checkbox]), +.has-warning .form-control, +.has-warning input:not([type=checkbox]):focus, +.has-warning .form-control:focus { + -webkit-box-shadow: inset 0 -2px 0 #ff9800; + box-shadow: inset 0 -2px 0 #ff9800; +} +.has-error input:not([type=checkbox]), +.has-error .form-control, +.has-error input:not([type=checkbox]):focus, +.has-error .form-control:focus { + -webkit-box-shadow: inset 0 -2px 0 #e51c23; + box-shadow: inset 0 -2px 0 #e51c23; +} +.has-success input:not([type=checkbox]), +.has-success .form-control, +.has-success input:not([type=checkbox]):focus, +.has-success .form-control:focus { + -webkit-box-shadow: inset 0 -2px 0 #4caf50; + box-shadow: inset 0 -2px 0 #4caf50; +} +.has-warning .input-group-addon, +.has-error .input-group-addon, +.has-success .input-group-addon { + color: #666666; + border-color: transparent; + background-color: transparent; +} +.nav-tabs > li > a, +.nav-tabs > li > a:focus { + margin-right: 0; + background-color: transparent; + border: none; + color: #666666; + -webkit-box-shadow: inset 0 -1px 0 #dddddd; + box-shadow: inset 0 -1px 0 #dddddd; + -webkit-transition: all 0.2s; + -o-transition: all 0.2s; + transition: all 0.2s; +} +.nav-tabs > li > a:hover, +.nav-tabs > li > a:focus:hover { + background-color: transparent; + -webkit-box-shadow: inset 0 -2px 0 #2196f3; + box-shadow: inset 0 -2px 0 #2196f3; + color: #2196f3; +} +.nav-tabs > li.active > a, +.nav-tabs > li.active > a:focus { + border: none; + -webkit-box-shadow: inset 0 -2px 0 #2196f3; + box-shadow: inset 0 -2px 0 #2196f3; + color: #2196f3; +} +.nav-tabs > li.active > a:hover, +.nav-tabs > li.active > a:focus:hover { + border: none; + color: #2196f3; +} +.nav-tabs > li.disabled > a { + -webkit-box-shadow: inset 0 -1px 0 #dddddd; + box-shadow: inset 0 -1px 0 #dddddd; +} +.nav-tabs.nav-justified > li > a, +.nav-tabs.nav-justified > li > a:hover, +.nav-tabs.nav-justified > li > a:focus, +.nav-tabs.nav-justified > .active > a, +.nav-tabs.nav-justified > .active > a:hover, +.nav-tabs.nav-justified > .active > a:focus { + border: none; +} +.nav-tabs .dropdown-menu { + margin-top: 0; +} +.dropdown-menu { + margin-top: 0; + border: none; + -webkit-box-shadow: 0 1px 4px rgba(0, 0, 0, 0.3); + box-shadow: 0 1px 4px rgba(0, 0, 0, 0.3); +} +.alert { + border: none; + color: #fff; +} +.alert-success { + background-color: #4caf50; +} +.alert-info { + background-color: #9c27b0; +} +.alert-warning { + background-color: #ff9800; +} +.alert-danger { + background-color: #e51c23; +} +.alert a:not(.close), +.alert .alert-link { + color: #fff; + font-weight: bold; +} +.alert .close { + color: #fff; +} +.badge { + padding: 3px 6px 5px; +} +.progress { + position: relative; + z-index: 1; + height: 6px; + border-radius: 0; + -webkit-box-shadow: none; + box-shadow: none; +} +.progress-bar { + -webkit-box-shadow: none; + box-shadow: none; +} +.progress-bar:last-child { + border-radius: 0 3px 3px 0; +} +.progress-bar:last-child:before { + display: block; + content: ""; + position: absolute; + width: 100%; + height: 100%; + left: 0; + right: 0; + z-index: -1; + background-color: #cae6fc; +} +.progress-bar-success:last-child.progress-bar:before { + background-color: #c7e7c8; +} +.progress-bar-info:last-child.progress-bar:before { + background-color: #edc9f3; +} +.progress-bar-warning:last-child.progress-bar:before { + background-color: #ffe0b3; +} +.progress-bar-danger:last-child.progress-bar:before { + background-color: #f28e92; +} +.close { + font-size: 34px; + font-weight: 300; + line-height: 24px; + opacity: 0.6; + -webkit-transition: all 0.2s; + -o-transition: all 0.2s; + transition: all 0.2s; +} +.close:hover { + opacity: 1; +} +.list-group-item { + padding: 15px; +} +.list-group-item-text { + color: #bbbbbb; +} +.well { + border-radius: 0; + -webkit-box-shadow: none; + box-shadow: none; +} +.panel { + border: none; + border-radius: 2px; + -webkit-box-shadow: 0 1px 4px rgba(0, 0, 0, 0.3); + box-shadow: 0 1px 4px rgba(0, 0, 0, 0.3); +} +.panel-heading { + border-bottom: none; +} +.panel-footer { + border-top: none; +} +.popover { + border: none; + -webkit-box-shadow: 0 1px 4px rgba(0, 0, 0, 0.3); + box-shadow: 0 1px 4px rgba(0, 0, 0, 0.3); +} +.carousel-caption h1, +.carousel-caption h2, +.carousel-caption h3, +.carousel-caption h4, +.carousel-caption h5, +.carousel-caption h6 { + color: inherit; +} diff --git a/libinput/doc/0.0/bug.html b/libinput/doc/0.0/bug.html new file mode 100644 index 0000000000000000000000000000000000000000..c5a05b0397be6ea30e68279043ce389ea8f87f29 --- /dev/null +++ b/libinput/doc/0.0/bug.html @@ -0,0 +1,126 @@ + + + + + + + + + + + libinput: Bug List + + + + + + + + + + + + + + + + +
+
+
+
+
+
+ + + + + +
+
+ + +
+ +
+ +
+
+
+
Bug List
+
+
+
+
globalScope> Global libinput_unref (struct libinput *libinput)
+
When the refcount reaches zero, libinput_unref() releases resources even if a caller still holds refcounted references to related resources (e.g. a libinput_device). When libinput_unref() returns NULL, the caller must consider any resources related to that context invalid. See https://bugs.freedesktop.org/show_bug.cgi?id=91872. Example code:
1 li = libinput_path_create_context(&interface, NULL);
+
2 device = libinput_path_add_device(li, "/dev/input/event0");
+
3 // get extra reference to device
+
4 libinput_device_ref(device);
+
5 
+
6 // refcount reaches 0, so *all* resources are cleaned up,
+
7 // including device
+
8 libinput_unref(li);
+
9 
+
10 // INCORRECT: device has been cleaned up and must not be used
+
11 // li = libinput_device_get_context(device);
+
+
+
+ + +
+
+
+
+
+ + + diff --git a/libinput/doc/0.0/button-scrolling.svg b/libinput/doc/0.0/button-scrolling.svg new file mode 100644 index 0000000000000000000000000000000000000000..476c9c7d2e21d28d8c5f3e8903d43b65de321de5 --- /dev/null +++ b/libinput/doc/0.0/button-scrolling.svg @@ -0,0 +1,292 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + C + V + B + N + M + J + H + G + F + + + + + + + + + + + + + + + + + + + + diff --git a/libinput/doc/0.0/classes.html b/libinput/doc/0.0/classes.html new file mode 100644 index 0000000000000000000000000000000000000000..14359e96b54df2a74479b9221eaa8a9727b640d4 --- /dev/null +++ b/libinput/doc/0.0/classes.html @@ -0,0 +1,127 @@ + + + + + + + + + + + libinput: Data Structure Index + + + + + + + + + + + + + + + + +
+
+
+
+
+
+ + + + + +
+ +
+
+ + +
+ +
+ +
+
+
Data Structure Index
+
+ + + +
+
+
+
+
+ + + diff --git a/libinput/doc/0.0/clickfinger-distance.svg b/libinput/doc/0.0/clickfinger-distance.svg new file mode 100644 index 0000000000000000000000000000000000000000..ac659cfed8bae49c2f65ed07ca77607be1675a15 --- /dev/null +++ b/libinput/doc/0.0/clickfinger-distance.svg @@ -0,0 +1,106 @@ + + + + + + + + + + image/svg+xml + + + + + + + + + + + + + + + + + diff --git a/libinput/doc/0.0/clickfinger.svg b/libinput/doc/0.0/clickfinger.svg new file mode 100644 index 0000000000000000000000000000000000000000..b92dcb441cfa7370c22644014e166340f5d288f2 --- /dev/null +++ b/libinput/doc/0.0/clickfinger.svg @@ -0,0 +1,207 @@ + + + + + + + + image/svg+xml + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/libinput/doc/0.0/clickpad-softbuttons_8dox.html b/libinput/doc/0.0/clickpad-softbuttons_8dox.html new file mode 100644 index 0000000000000000000000000000000000000000..ab7a0f40d1c9a5819a4106c6a1c36f25f102541d --- /dev/null +++ b/libinput/doc/0.0/clickpad-softbuttons_8dox.html @@ -0,0 +1,117 @@ + + + + + + + + + + + libinput: clickpad-softbuttons.dox File Reference + + + + + + + + + + + + + + + + +
+
+
+
+
+
+ + + + + + +
+
+ + +
+ +
+ +
+
+
+
clickpad-softbuttons.dox File Reference
+
+
+
+ + +
+
+
+
+
+ + + diff --git a/libinput/doc/0.0/clickpad_softbuttons.html b/libinput/doc/0.0/clickpad_softbuttons.html new file mode 100644 index 0000000000000000000000000000000000000000..9fe43909acc28c816fc72b04c4c49625a5d89c6f --- /dev/null +++ b/libinput/doc/0.0/clickpad_softbuttons.html @@ -0,0 +1,157 @@ + + + + + + + + + + + libinput: Clickpad software button behavior + + + + + + + + + + + + + + + + +
+
+
+
+
+
+ + + + + +
+
+ + +
+ +
+ + +
+
+
+
Clickpad software button behavior
+
+
+

Clickpad is the name given to touchpads without physical buttons below the touchpad.

+

Instead, the whole touchpad acts as a button and left or right button clicks are distinguished by the location and/or number of fingers on the touchpad. "ClickPad" is a trademark by Synaptics Inc. but for simplicity we refer to any touchpad with the above feature as Clickpad, regardless of the manufacturer.

+

A clickpad is always marked with the INPUT_PROP_BUTTONPAD property. To perform a right-click on a Clickpad, libinput provides Software button areas and Clickfinger behavior.

+

In the page below, the term "click" shall refer to a physical button press and/or release of the touchpad, the term "button event" refers to the events generated by libinput and passed to the caller in response to a click.

+

+Software button areas

+

On most clickpads, this is the default behavior. The bottom of the touchpad is split in the middle to generate left or right button events on click. The height of the button area depends on the hardware but is usually around 10mm.

+

Left, right and middle button events can be triggered as follows:

    +
  • if a finger is in the main area or the left button area, a click generates left button events.
  • +
  • if a finger is in the right area, a click generates right button events.
  • +
  • if there is a finger in both the left and right button area, a click generates middle button events.
  • +
+
+software-buttons.svg +
+Left, right and middle-button click with software button areas
+

If fingers are down in the main area in addition to fingers in the left or right button area, those fingers are are ignored. A release event always releases the buttons logically down, regardless of the current finger position

+

The movement of a finger can alter the button area behavior:

    +
  • if a finger starts in the main area and moves into the software button area, the software buttons do not apply to that finger
  • +
  • a finger in the software button area does not move the pointer
  • +
  • if a finger moves out out of the button area it will control the pointer if it's the first finger in the main area
  • +
  • once a finger has moved out of the button area, it cannot move back in and trigger a right or middle button event
  • +
+

On some touchpads, notably the 2015 Lenovo X1 Carbon 3rd series, the very bottom end of the touchpad is outside of the sensor range but it is possible to trigger a physical click there. To libinput, the click merely shows up as a left button click without any positional finger data and it is impossible to determine whether it is a left or a right click. libinput ignores such button clicks, this behavior is intentional.

+

+Clickfinger behavior

+

This is the default behavior on Apple touchpads. Here, a left, right, middle button event is generated when one, two, or three fingers are held down on the touchpad when a physical click is generated. The location of the fingers does not matter and there are no software-defined button areas.

+
+clickfinger.svg +
+One, two and three-finger click with Clickfinger behavior
+

On some touchpads, libinput imposes a limit on how the fingers may be placed on the touchpad. In the most common use-case this allows for a user to trigger a click with the thumb while leaving the pointer-moving finger on the touchpad.

+
+clickfinger-distance.svg +
+Illustration of the distance detection algorithm
+

In the illustration above the red area marks the proximity area around the first finger. Since the thumb is outside of that area libinput considers the click a single-finger click rather than a two-finger click.

+

Clickfinger configuration can be enabled through the libinput_device_config_click_set_method() call. If clickfingers are enabled on a touchpad with top software buttons, the top area will keep acting as softbuttons for use with the trackpoint. Clickfingers will be used everywhere else on the touchpad.

+

+Special Clickpads

+

The Lenovo *40 series laptops have a clickpad that provides two software button sections, one at the top and one at the bottom. See Lenovo *40 series touchpad support for details on the top software button.

+

Some Clickpads, notably some Cypress ones, perform right button detection in firmware and appear to userspace as if the touchpad had physical buttons. While physically clickpads, these are not handled by the software and treated like traditional touchpads.

+
+ + +
+
+
+
+
+ + + diff --git a/libinput/doc/0.0/closed.png b/libinput/doc/0.0/closed.png new file mode 100644 index 0000000000000000000000000000000000000000..98cc2c909da37a6df914fbf67780eebd99c597f5 Binary files /dev/null and b/libinput/doc/0.0/closed.png differ diff --git a/libinput/doc/0.0/customdoxygen.css b/libinput/doc/0.0/customdoxygen.css new file mode 100644 index 0000000000000000000000000000000000000000..7bf2f5ec194f55a1dfb5a0146330e9bb355db57c --- /dev/null +++ b/libinput/doc/0.0/customdoxygen.css @@ -0,0 +1,255 @@ +h1, .h1, h2, .h2, h3, .h3{ + font-weight: 200 !important; +} + +#navrow1, #navrow2, #navrow3, #navrow4, #navrow5{ + border-bottom: 1px solid #EEEEEE; +} + +.adjust-right { +margin-left: 30px !important; +font-size: 1.15em !important; +} +.navbar{ + border: 0px solid #222 !important; +} + + +/* Sticky footer styles +-------------------------------------------------- */ +html, +body { + height: 100%; + /* The html and body elements cannot have any padding or margin. */ +} + +/* Wrapper for page content to push down footer */ +#wrap { + min-height: 100%; + height: auto; + /* Negative indent footer by its height */ + margin: 0 auto -60px; + /* Pad bottom by footer height */ + padding: 0 0 60px; +} + +/* Set the fixed height of the footer here */ +#footer { + font-size: 0.9em; + padding: 8px 0px; + background-color: #f5f5f5; +} + +.footer-row { + line-height: 44px; +} + +#footer > .container { + padding-left: 15px; + padding-right: 15px; +} + +.footer-follow-icon { + margin-left: 3px; + text-decoration: none !important; +} + +.footer-follow-icon img { + width: 20px; +} + +.footer-link { + padding-top: 5px; + display: inline-block; + color: #999999; + text-decoration: none; +} + +.footer-copyright { + text-align: center; +} + + +@media (min-width: 992px) { + .footer-row { + text-align: left; + } + + .footer-icons { + text-align: right; + } +} +@media (max-width: 991px) { + .footer-row { + text-align: center; + } + + .footer-icons { + text-align: center; + } +} + +/* DOXYGEN Code Styles +----------------------------------- */ + + +a.qindex { + font-weight: bold; +} + +a.qindexHL { + font-weight: bold; + background-color: #9CAFD4; + color: #ffffff; + border: 1px double #869DCA; +} + +.contents a.qindexHL:visited { + color: #ffffff; +} + +a.code, a.code:visited, a.line, a.line:visited { + color: #4665A2; +} + +a.codeRef, a.codeRef:visited, a.lineRef, a.lineRef:visited { + color: #4665A2; +} + +/* @end */ + +dl.el { + margin-left: -1cm; +} + +pre.fragment { + border: 1px solid #C4CFE5; + background-color: #FBFCFD; + padding: 4px 6px; + margin: 4px 8px 4px 2px; + overflow: auto; + word-wrap: break-word; + font-size: 9pt; + line-height: 125%; + font-family: monospace, fixed; + font-size: 105%; +} + +div.fragment { + padding: 4px 6px; + margin: 4px 8px 4px 2px; + border: 1px solid #C4CFE5; +} + +div.line { + font-family: monospace, fixed; + font-size: 13px; + min-height: 13px; + line-height: 1.0; + text-wrap: unrestricted; + white-space: -moz-pre-wrap; /* Moz */ + white-space: -pre-wrap; /* Opera 4-6 */ + white-space: -o-pre-wrap; /* Opera 7 */ + white-space: pre-wrap; /* CSS3 */ + word-wrap: break-word; /* IE 5.5+ */ + text-indent: -53px; + padding-left: 53px; + padding-bottom: 0px; + margin: 0px; + -webkit-transition-property: background-color, box-shadow; + -webkit-transition-duration: 0.5s; + -moz-transition-property: background-color, box-shadow; + -moz-transition-duration: 0.5s; + -ms-transition-property: background-color, box-shadow; + -ms-transition-duration: 0.5s; + -o-transition-property: background-color, box-shadow; + -o-transition-duration: 0.5s; + transition-property: background-color, box-shadow; + transition-duration: 0.5s; +} + +div.line.glow { + background-color: cyan; + box-shadow: 0 0 10px cyan; +} + + +span.lineno { + padding-right: 4px; + text-align: right; + border-right: 2px solid #0F0; + background-color: #E8E8E8; + white-space: pre; +} +span.lineno a { + background-color: #D8D8D8; +} + +span.lineno a:hover { + background-color: #C8C8C8; +} + +div.groupHeader { + margin-left: 16px; + margin-top: 12px; + font-weight: bold; +} + +div.groupText { + margin-left: 16px; + font-style: italic; +} + +/* @group Code Colorization */ + +span.keyword { + color: #008000 +} + +span.keywordtype { + color: #604020 +} + +span.keywordflow { + color: #e08000 +} + +span.comment { + color: #800000 +} + +span.preprocessor { + color: #806020 +} + +span.stringliteral { + color: #002080 +} + +span.charliteral { + color: #008080 +} + +span.vhdldigit { + color: #ff00ff +} + +span.vhdlchar { + color: #000000 +} + +span.vhdlkeyword { + color: #700070 +} + +span.vhdllogic { + color: #ff0000 +} + +blockquote { + background-color: #F7F8FB; + border-left: 2px solid #9CAFD4; + margin: 0 24px 0 4px; + padding: 0 12px 0 16px; +} + diff --git a/libinput/doc/0.0/developers.html b/libinput/doc/0.0/developers.html new file mode 100644 index 0000000000000000000000000000000000000000..9a1ba700de6912f4c51bda3d1cdf7f830f17866f --- /dev/null +++ b/libinput/doc/0.0/developers.html @@ -0,0 +1,116 @@ + + + + + + + + + + + libinput: Developers + + + + + + + + + + + + + + + + +
+
+
+
+
+
+ + + + + +
+
+ + +
+ +
+ +
+
+
+
Developers
+
+ + + +
+
+
+
+
+ + + diff --git a/libinput/doc/0.0/device-configuration-via-udev_8dox.html b/libinput/doc/0.0/device-configuration-via-udev_8dox.html new file mode 100644 index 0000000000000000000000000000000000000000..01c822ab50c3efb93f12eb771bd8d9acdbcaede4 --- /dev/null +++ b/libinput/doc/0.0/device-configuration-via-udev_8dox.html @@ -0,0 +1,117 @@ + + + + + + + + + + + libinput: device-configuration-via-udev.dox File Reference + + + + + + + + + + + + + + + + +
+
+
+
+
+
+ + + + + + +
+
+ + +
+ +
+ +
+
+
+
device-configuration-via-udev.dox File Reference
+
+
+
+ + +
+
+
+
+
+ + + diff --git a/libinput/doc/0.0/dir_68267d1309a1af8e8297ef4c3efbcdba.html b/libinput/doc/0.0/dir_68267d1309a1af8e8297ef4c3efbcdba.html new file mode 100644 index 0000000000000000000000000000000000000000..2d97ce863efc5440b72d7fe46278da32690af76c --- /dev/null +++ b/libinput/doc/0.0/dir_68267d1309a1af8e8297ef4c3efbcdba.html @@ -0,0 +1,121 @@ + + + + + + + + + + + libinput: /home/whot/code/libinput/src Directory Reference + + + + + + + + + + + + + + + + +
+
+
+
+
+
+ + + + + +
+
+ + +
+ +
+ + +
+
+
+
src Directory Reference
+
+
+ + + + +

+Files

file  libinput.h [code]
 
+
+ + +
+
+
+
+
+ + + diff --git a/libinput/doc/0.0/doc.png b/libinput/doc/0.0/doc.png new file mode 100644 index 0000000000000000000000000000000000000000..17edabff95f7b8da13c9516a04efe05493c29501 Binary files /dev/null and b/libinput/doc/0.0/doc.png differ diff --git a/libinput/doc/0.0/dot_evemu.png b/libinput/doc/0.0/dot_evemu.png new file mode 100644 index 0000000000000000000000000000000000000000..831799257ff60b70c1924f2ec24f82f44b3fa113 Binary files /dev/null and b/libinput/doc/0.0/dot_evemu.png differ diff --git a/libinput/doc/0.0/dot_inline_dotgraph_1.png b/libinput/doc/0.0/dot_inline_dotgraph_1.png new file mode 100644 index 0000000000000000000000000000000000000000..04fdae9e70ab37a19d3c9e73bc70e1dd55084ab2 Binary files /dev/null and b/libinput/doc/0.0/dot_inline_dotgraph_1.png differ diff --git a/libinput/doc/0.0/dot_inline_dotgraph_2.png b/libinput/doc/0.0/dot_inline_dotgraph_2.png new file mode 100644 index 0000000000000000000000000000000000000000..0c06d002e70d4cde1920bb4be8a972159ba79d53 Binary files /dev/null and b/libinput/doc/0.0/dot_inline_dotgraph_2.png differ diff --git a/libinput/doc/0.0/dot_libinput-stack-gnome.png b/libinput/doc/0.0/dot_libinput-stack-gnome.png new file mode 100644 index 0000000000000000000000000000000000000000..60644543abfa23ba28312901f4a1267840a1e96b Binary files /dev/null and b/libinput/doc/0.0/dot_libinput-stack-gnome.png differ diff --git a/libinput/doc/0.0/dot_libinput-stack-wayland.png b/libinput/doc/0.0/dot_libinput-stack-wayland.png new file mode 100644 index 0000000000000000000000000000000000000000..5c19222d4789bd622e69670284b9f15b96f6ae4b Binary files /dev/null and b/libinput/doc/0.0/dot_libinput-stack-wayland.png differ diff --git a/libinput/doc/0.0/dot_libinput-stack-xorg.png b/libinput/doc/0.0/dot_libinput-stack-xorg.png new file mode 100644 index 0000000000000000000000000000000000000000..e1e41456b4ce7066a77d588e3304c28c23655244 Binary files /dev/null and b/libinput/doc/0.0/dot_libinput-stack-xorg.png differ diff --git a/libinput/doc/0.0/dot_seats-sketch-libinput.png b/libinput/doc/0.0/dot_seats-sketch-libinput.png new file mode 100644 index 0000000000000000000000000000000000000000..ab82c0c1a6a313022ed9d8f9c5e793ac774673ea Binary files /dev/null and b/libinput/doc/0.0/dot_seats-sketch-libinput.png differ diff --git a/libinput/doc/0.0/dot_seats-sketch.png b/libinput/doc/0.0/dot_seats-sketch.png new file mode 100644 index 0000000000000000000000000000000000000000..54b98d534120fb9023e2afbae2336b0864c1fdf2 Binary files /dev/null and b/libinput/doc/0.0/dot_seats-sketch.png differ diff --git a/libinput/doc/0.0/doxygen.css b/libinput/doc/0.0/doxygen.css new file mode 100644 index 0000000000000000000000000000000000000000..b2c94ac212bd24085366baaca1d63d5ed978724d --- /dev/null +++ b/libinput/doc/0.0/doxygen.css @@ -0,0 +1,1454 @@ +/* The standard CSS for doxygen 1.8.10 */ + +body, table, div, p, dl { + font: 400 14px/22px Roboto,sans-serif; +} + +/* @group Heading Levels */ + +h1.groupheader { + font-size: 150%; +} + +.title { + font: 400 14px/28px Roboto,sans-serif; + font-size: 150%; + font-weight: bold; + margin: 10px 2px; +} + +h2.groupheader { + border-bottom: 1px solid #879ECB; + color: #354C7B; + font-size: 150%; + font-weight: normal; + margin-top: 1.75em; + padding-top: 8px; + padding-bottom: 4px; + width: 100%; +} + +h3.groupheader { + font-size: 100%; +} + +h1, h2, h3, h4, h5, h6 { + -webkit-transition: text-shadow 0.5s linear; + -moz-transition: text-shadow 0.5s linear; + -ms-transition: text-shadow 0.5s linear; + -o-transition: text-shadow 0.5s linear; + transition: text-shadow 0.5s linear; + margin-right: 15px; +} + +h1.glow, h2.glow, h3.glow, h4.glow, h5.glow, h6.glow { + text-shadow: 0 0 15px cyan; +} + +dt { + font-weight: bold; +} + +div.multicol { + -moz-column-gap: 1em; + -webkit-column-gap: 1em; + -moz-column-count: 3; + -webkit-column-count: 3; +} + +p.startli, p.startdd { + margin-top: 2px; +} + +p.starttd { + margin-top: 0px; +} + +p.endli { + margin-bottom: 0px; +} + +p.enddd { + margin-bottom: 4px; +} + +p.endtd { + margin-bottom: 2px; +} + +/* @end */ + +caption { + font-weight: bold; +} + +span.legend { + font-size: 70%; + text-align: center; +} + +h3.version { + font-size: 90%; + text-align: center; +} + +div.qindex, div.navtab{ + background-color: #EBEFF6; + border: 1px solid #A3B4D7; + text-align: center; +} + +div.qindex, div.navpath { + width: 100%; + line-height: 140%; +} + +div.navtab { + margin-right: 15px; +} + +/* @group Link Styling */ + +a { + color: #3D578C; + font-weight: normal; + text-decoration: none; +} + +.contents a:visited { + color: #4665A2; +} + +a:hover { + text-decoration: underline; +} + +a.qindex { + font-weight: bold; +} + +a.qindexHL { + font-weight: bold; + background-color: #9CAFD4; + color: #ffffff; + border: 1px double #869DCA; +} + +.contents a.qindexHL:visited { + color: #ffffff; +} + +a.el { + font-weight: bold; +} + +a.elRef { +} + +a.code, a.code:visited, a.line, a.line:visited { + color: #4665A2; +} + +a.codeRef, a.codeRef:visited, a.lineRef, a.lineRef:visited { + color: #4665A2; +} + +/* @end */ + +dl.el { + margin-left: -1cm; +} + +pre.fragment { + border: 1px solid #C4CFE5; + background-color: #FBFCFD; + padding: 4px 6px; + margin: 4px 8px 4px 2px; + overflow: auto; + word-wrap: break-word; + font-size: 9pt; + line-height: 125%; + font-family: monospace, fixed; + font-size: 105%; +} + +div.fragment { + padding: 4px 6px; + margin: 4px 8px 4px 2px; + background-color: #FBFCFD; + border: 1px solid #C4CFE5; +} + +div.line { + font-family: monospace, fixed; + font-size: 13px; + min-height: 13px; + line-height: 1.0; + text-wrap: unrestricted; + white-space: -moz-pre-wrap; /* Moz */ + white-space: -pre-wrap; /* Opera 4-6 */ + white-space: -o-pre-wrap; /* Opera 7 */ + white-space: pre-wrap; /* CSS3 */ + word-wrap: break-word; /* IE 5.5+ */ + text-indent: -53px; + padding-left: 53px; + padding-bottom: 0px; + margin: 0px; + -webkit-transition-property: background-color, box-shadow; + -webkit-transition-duration: 0.5s; + -moz-transition-property: background-color, box-shadow; + -moz-transition-duration: 0.5s; + -ms-transition-property: background-color, box-shadow; + -ms-transition-duration: 0.5s; + -o-transition-property: background-color, box-shadow; + -o-transition-duration: 0.5s; + transition-property: background-color, box-shadow; + transition-duration: 0.5s; +} + +div.line.glow { + background-color: cyan; + box-shadow: 0 0 10px cyan; +} + + +span.lineno { + padding-right: 4px; + text-align: right; + border-right: 2px solid #0F0; + background-color: #E8E8E8; + white-space: pre; +} +span.lineno a { + background-color: #D8D8D8; +} + +span.lineno a:hover { + background-color: #C8C8C8; +} + +div.ah, span.ah { + background-color: black; + font-weight: bold; + color: #ffffff; + margin-bottom: 3px; + margin-top: 3px; + padding: 0.2em; + border: solid thin #333; + border-radius: 0.5em; + -webkit-border-radius: .5em; + -moz-border-radius: .5em; + box-shadow: 2px 2px 3px #999; + -webkit-box-shadow: 2px 2px 3px #999; + -moz-box-shadow: rgba(0, 0, 0, 0.15) 2px 2px 2px; + background-image: -webkit-gradient(linear, left top, left bottom, from(#eee), to(#000),color-stop(0.3, #444)); + background-image: -moz-linear-gradient(center top, #eee 0%, #444 40%, #000); +} + +div.classindex ul { + list-style: none; + padding-left: 0; +} + +div.classindex span.ai { + display: inline-block; +} + +div.groupHeader { + margin-left: 16px; + margin-top: 12px; + font-weight: bold; +} + +div.groupText { + margin-left: 16px; + font-style: italic; +} + +body { + background-color: white; + color: black; + margin: 0; +} + +div.contents { + margin-top: 10px; + margin-left: 12px; + margin-right: 8px; +} + +td.indexkey { + background-color: #EBEFF6; + font-weight: bold; + border: 1px solid #C4CFE5; + margin: 2px 0px 2px 0; + padding: 2px 10px; + white-space: nowrap; + vertical-align: top; +} + +td.indexvalue { + background-color: #EBEFF6; + border: 1px solid #C4CFE5; + padding: 2px 10px; + margin: 2px 0px; +} + +tr.memlist { + background-color: #EEF1F7; +} + +p.formulaDsp { + text-align: center; +} + +img.formulaDsp { + +} + +img.formulaInl { + vertical-align: middle; +} + +div.center { + text-align: center; + margin-top: 0px; + margin-bottom: 0px; + padding: 0px; +} + +div.center img { + border: 0px; +} + +address.footer { + text-align: right; + padding-right: 12px; +} + +img.footer { + border: 0px; + vertical-align: middle; +} + +/* @group Code Colorization */ + +span.keyword { + color: #008000 +} + +span.keywordtype { + color: #604020 +} + +span.keywordflow { + color: #e08000 +} + +span.comment { + color: #800000 +} + +span.preprocessor { + color: #806020 +} + +span.stringliteral { + color: #002080 +} + +span.charliteral { + color: #008080 +} + +span.vhdldigit { + color: #ff00ff +} + +span.vhdlchar { + color: #000000 +} + +span.vhdlkeyword { + color: #700070 +} + +span.vhdllogic { + color: #ff0000 +} + +blockquote { + background-color: #F7F8FB; + border-left: 2px solid #9CAFD4; + margin: 0 24px 0 4px; + padding: 0 12px 0 16px; +} + +/* @end */ + +/* +.search { + color: #003399; + font-weight: bold; +} + +form.search { + margin-bottom: 0px; + margin-top: 0px; +} + +input.search { + font-size: 75%; + color: #000080; + font-weight: normal; + background-color: #e8eef2; +} +*/ + +td.tiny { + font-size: 75%; +} + +.dirtab { + padding: 4px; + border-collapse: collapse; + border: 1px solid #A3B4D7; +} + +th.dirtab { + background: #EBEFF6; + font-weight: bold; +} + +hr { + height: 0px; + border: none; + border-top: 1px solid #4A6AAA; +} + +hr.footer { + height: 1px; +} + +/* @group Member Descriptions */ + +table.memberdecls { + border-spacing: 0px; + padding: 0px; +} + +.memberdecls td, .fieldtable tr { + -webkit-transition-property: background-color, box-shadow; + -webkit-transition-duration: 0.5s; + -moz-transition-property: background-color, box-shadow; + -moz-transition-duration: 0.5s; + -ms-transition-property: background-color, box-shadow; + -ms-transition-duration: 0.5s; + -o-transition-property: background-color, box-shadow; + -o-transition-duration: 0.5s; + transition-property: background-color, box-shadow; + transition-duration: 0.5s; +} + +.memberdecls td.glow, .fieldtable tr.glow { + background-color: cyan; + box-shadow: 0 0 15px cyan; +} + +.mdescLeft, .mdescRight, +.memItemLeft, .memItemRight, +.memTemplItemLeft, .memTemplItemRight, .memTemplParams { + background-color: #F9FAFC; + border: none; + margin: 4px; + padding: 1px 0 0 8px; +} + +.mdescLeft, .mdescRight { + padding: 0px 8px 4px 8px; + color: #555; +} + +.memSeparator { + border-bottom: 1px solid #DEE4F0; + line-height: 1px; + margin: 0px; + padding: 0px; +} + +.memItemLeft, .memTemplItemLeft { + white-space: nowrap; +} + +.memItemRight { + width: 100%; +} + +.memTemplParams { + color: #4665A2; + white-space: nowrap; + font-size: 80%; +} + +/* @end */ + +/* @group Member Details */ + +/* Styles for detailed member documentation */ + +.memtemplate { + font-size: 80%; + color: #4665A2; + font-weight: normal; + margin-left: 9px; +} + +.memnav { + background-color: #EBEFF6; + border: 1px solid #A3B4D7; + text-align: center; + margin: 2px; + margin-right: 15px; + padding: 2px; +} + +.mempage { + width: 100%; +} + +.memitem { + padding: 0; + margin-bottom: 10px; + margin-right: 5px; + -webkit-transition: box-shadow 0.5s linear; + -moz-transition: box-shadow 0.5s linear; + -ms-transition: box-shadow 0.5s linear; + -o-transition: box-shadow 0.5s linear; + transition: box-shadow 0.5s linear; + display: table !important; + width: 100%; +} + +.memitem.glow { + box-shadow: 0 0 15px cyan; +} + +.memname { + font-weight: bold; + margin-left: 6px; +} + +.memname td { + vertical-align: bottom; +} + +.memproto, dl.reflist dt { + border-top: 1px solid #A8B8D9; + border-left: 1px solid #A8B8D9; + border-right: 1px solid #A8B8D9; + padding: 6px 0px 6px 0px; + color: #253555; + font-weight: bold; + text-shadow: 0px 1px 1px rgba(255, 255, 255, 0.9); + background-image:url('nav_f.png'); + background-repeat:repeat-x; + background-color: #E2E8F2; + /* opera specific markup */ + box-shadow: 5px 5px 5px rgba(0, 0, 0, 0.15); + border-top-right-radius: 4px; + border-top-left-radius: 4px; + /* firefox specific markup */ + -moz-box-shadow: rgba(0, 0, 0, 0.15) 5px 5px 5px; + -moz-border-radius-topright: 4px; + -moz-border-radius-topleft: 4px; + /* webkit specific markup */ + -webkit-box-shadow: 5px 5px 5px rgba(0, 0, 0, 0.15); + -webkit-border-top-right-radius: 4px; + -webkit-border-top-left-radius: 4px; + +} + +.memdoc, dl.reflist dd { + border-bottom: 1px solid #A8B8D9; + border-left: 1px solid #A8B8D9; + border-right: 1px solid #A8B8D9; + padding: 6px 10px 2px 10px; + background-color: #FBFCFD; + border-top-width: 0; + background-image:url('nav_g.png'); + background-repeat:repeat-x; + background-color: #FFFFFF; + /* opera specific markup */ + border-bottom-left-radius: 4px; + border-bottom-right-radius: 4px; + box-shadow: 5px 5px 5px rgba(0, 0, 0, 0.15); + /* firefox specific markup */ + -moz-border-radius-bottomleft: 4px; + -moz-border-radius-bottomright: 4px; + -moz-box-shadow: rgba(0, 0, 0, 0.15) 5px 5px 5px; + /* webkit specific markup */ + -webkit-border-bottom-left-radius: 4px; + -webkit-border-bottom-right-radius: 4px; + -webkit-box-shadow: 5px 5px 5px rgba(0, 0, 0, 0.15); +} + +dl.reflist dt { + padding: 5px; +} + +dl.reflist dd { + margin: 0px 0px 10px 0px; + padding: 5px; +} + +.paramkey { + text-align: right; +} + +.paramtype { + white-space: nowrap; +} + +.paramname { + color: #602020; + white-space: nowrap; +} +.paramname em { + font-style: normal; +} +.paramname code { + line-height: 14px; +} + +.params, .retval, .exception, .tparams { + margin-left: 0px; + padding-left: 0px; +} + +.params .paramname, .retval .paramname { + font-weight: bold; + vertical-align: top; +} + +.params .paramtype { + font-style: italic; + vertical-align: top; +} + +.params .paramdir { + font-family: "courier new",courier,monospace; + vertical-align: top; +} + +table.mlabels { + border-spacing: 0px; +} + +td.mlabels-left { + width: 100%; + padding: 0px; +} + +td.mlabels-right { + vertical-align: bottom; + padding: 0px; + white-space: nowrap; +} + +span.mlabels { + margin-left: 8px; +} + +span.mlabel { + background-color: #728DC1; + border-top:1px solid #5373B4; + border-left:1px solid #5373B4; + border-right:1px solid #C4CFE5; + border-bottom:1px solid #C4CFE5; + text-shadow: none; + color: white; + margin-right: 4px; + padding: 2px 3px; + border-radius: 3px; + font-size: 7pt; + white-space: nowrap; + vertical-align: middle; +} + + + +/* @end */ + +/* these are for tree view inside a (index) page */ + +div.directory { + margin: 10px 0px; + border-top: 1px solid #9CAFD4; + border-bottom: 1px solid #9CAFD4; + width: 100%; +} + +.directory table { + border-collapse:collapse; +} + +.directory td { + margin: 0px; + padding: 0px; + vertical-align: top; +} + +.directory td.entry { + white-space: nowrap; + padding-right: 6px; + padding-top: 3px; +} + +.directory td.entry a { + outline:none; +} + +.directory td.entry a img { + border: none; +} + +.directory td.desc { + width: 100%; + padding-left: 6px; + padding-right: 6px; + padding-top: 3px; + border-left: 1px solid rgba(0,0,0,0.05); +} + +.directory tr.even { + padding-left: 6px; + background-color: #F7F8FB; +} + +.directory img { + vertical-align: -30%; +} + +.directory .levels { + white-space: nowrap; + width: 100%; + text-align: right; + font-size: 9pt; +} + +.directory .levels span { + cursor: pointer; + padding-left: 2px; + padding-right: 2px; + color: #3D578C; +} + +.arrow { + color: #9CAFD4; + -webkit-user-select: none; + -khtml-user-select: none; + -moz-user-select: none; + -ms-user-select: none; + user-select: none; + cursor: pointer; + font-size: 80%; + display: inline-block; + width: 16px; + height: 22px; +} + +.icon { + font-family: Arial, Helvetica; + font-weight: bold; + font-size: 12px; + height: 14px; + width: 16px; + display: inline-block; + background-color: #728DC1; + color: white; + text-align: center; + border-radius: 4px; + margin-left: 2px; + margin-right: 2px; +} + +.icona { + width: 24px; + height: 22px; + display: inline-block; +} + +.iconfopen { + width: 24px; + height: 18px; + margin-bottom: 4px; + background-image:url('folderopen.png'); + background-position: 0px -4px; + background-repeat: repeat-y; + vertical-align:top; + display: inline-block; +} + +.iconfclosed { + width: 24px; + height: 18px; + margin-bottom: 4px; + background-image:url('folderclosed.png'); + background-position: 0px -4px; + background-repeat: repeat-y; + vertical-align:top; + display: inline-block; +} + +.icondoc { + width: 24px; + height: 18px; + margin-bottom: 4px; + background-image:url('doc.png'); + background-position: 0px -4px; + background-repeat: repeat-y; + vertical-align:top; + display: inline-block; +} + +table.directory { + font: 400 14px Roboto,sans-serif; +} + +/* @end */ + +div.dynheader { + margin-top: 8px; + -webkit-touch-callout: none; + -webkit-user-select: none; + -khtml-user-select: none; + -moz-user-select: none; + -ms-user-select: none; + user-select: none; +} + +address { + font-style: normal; + color: #2A3D61; +} + +table.doxtable { + border-collapse:collapse; + margin-top: 4px; + margin-bottom: 4px; +} + +table.doxtable td, table.doxtable th { + border: 1px solid #2D4068; + padding: 3px 7px 2px; +} + +table.doxtable th { + background-color: #374F7F; + color: #FFFFFF; + font-size: 110%; + padding-bottom: 4px; + padding-top: 5px; +} + +table.fieldtable { + /*width: 100%;*/ + margin-bottom: 10px; + border: 1px solid #A8B8D9; + border-spacing: 0px; + -moz-border-radius: 4px; + -webkit-border-radius: 4px; + border-radius: 4px; + -moz-box-shadow: rgba(0, 0, 0, 0.15) 2px 2px 2px; + -webkit-box-shadow: 2px 2px 2px rgba(0, 0, 0, 0.15); + box-shadow: 2px 2px 2px rgba(0, 0, 0, 0.15); +} + +.fieldtable td, .fieldtable th { + padding: 3px 7px 2px; +} + +.fieldtable td.fieldtype, .fieldtable td.fieldname { + white-space: nowrap; + border-right: 1px solid #A8B8D9; + border-bottom: 1px solid #A8B8D9; + vertical-align: top; +} + +.fieldtable td.fieldname { + padding-top: 3px; +} + +.fieldtable td.fielddoc { + border-bottom: 1px solid #A8B8D9; + /*width: 100%;*/ +} + +.fieldtable td.fielddoc p:first-child { + margin-top: 0px; +} + +.fieldtable td.fielddoc p:last-child { + margin-bottom: 2px; +} + +.fieldtable tr:last-child td { + border-bottom: none; +} + +.fieldtable th { + background-image:url('nav_f.png'); + background-repeat:repeat-x; + background-color: #E2E8F2; + font-size: 90%; + color: #253555; + padding-bottom: 4px; + padding-top: 5px; + text-align:left; + -moz-border-radius-topleft: 4px; + -moz-border-radius-topright: 4px; + -webkit-border-top-left-radius: 4px; + -webkit-border-top-right-radius: 4px; + border-top-left-radius: 4px; + border-top-right-radius: 4px; + border-bottom: 1px solid #A8B8D9; +} + + +.tabsearch { + top: 0px; + left: 10px; + height: 36px; + background-image: url('tab_b.png'); + z-index: 101; + overflow: hidden; + font-size: 13px; +} + +.navpath ul +{ + font-size: 11px; + background-image:url('tab_b.png'); + background-repeat:repeat-x; + background-position: 0 -5px; + height:30px; + line-height:30px; + color:#8AA0CC; + border:solid 1px #C2CDE4; + overflow:hidden; + margin:0px; + padding:0px; +} + +.navpath li +{ + list-style-type:none; + float:left; + padding-left:10px; + padding-right:15px; + background-image:url('bc_s.png'); + background-repeat:no-repeat; + background-position:right; + color:#364D7C; +} + +.navpath li.navelem a +{ + height:32px; + display:block; + text-decoration: none; + outline: none; + color: #283A5D; + font-family: 'Lucida Grande',Geneva,Helvetica,Arial,sans-serif; + text-shadow: 0px 1px 1px rgba(255, 255, 255, 0.9); + text-decoration: none; +} + +.navpath li.navelem a:hover +{ + color:#6884BD; +} + +.navpath li.footer +{ + list-style-type:none; + float:right; + padding-left:10px; + padding-right:15px; + background-image:none; + background-repeat:no-repeat; + background-position:right; + color:#364D7C; + font-size: 8pt; +} + + +div.summary +{ + float: right; + font-size: 8pt; + padding-right: 5px; + width: 50%; + text-align: right; +} + +div.summary a +{ + white-space: nowrap; +} + +div.ingroups +{ + font-size: 8pt; + width: 50%; + text-align: left; +} + +div.ingroups a +{ + white-space: nowrap; +} + +div.header +{ + background-image:url('nav_h.png'); + background-repeat:repeat-x; + background-color: #F9FAFC; + margin: 0px; + border-bottom: 1px solid #C4CFE5; +} + +div.headertitle +{ + padding: 5px 5px 5px 10px; +} + +dl +{ + padding: 0 0 0 10px; +} + +/* dl.note, dl.warning, dl.attention, dl.pre, dl.post, dl.invariant, dl.deprecated, dl.todo, dl.test, dl.bug */ +dl.section +{ + margin-left: 0px; + padding-left: 0px; +} + +dl.note +{ + margin-left:-7px; + padding-left: 3px; + border-left:4px solid; + border-color: #D0C000; +} + +dl.warning, dl.attention +{ + margin-left:-7px; + padding-left: 3px; + border-left:4px solid; + border-color: #FF0000; +} + +dl.pre, dl.post, dl.invariant +{ + margin-left:-7px; + padding-left: 3px; + border-left:4px solid; + border-color: #00D000; +} + +dl.deprecated +{ + margin-left:-7px; + padding-left: 3px; + border-left:4px solid; + border-color: #505050; +} + +dl.todo +{ + margin-left:-7px; + padding-left: 3px; + border-left:4px solid; + border-color: #00C0E0; +} + +dl.test +{ + margin-left:-7px; + padding-left: 3px; + border-left:4px solid; + border-color: #3030E0; +} + +dl.bug +{ + margin-left:-7px; + padding-left: 3px; + border-left:4px solid; + border-color: #C08050; +} + +dl.section dd { + margin-bottom: 6px; +} + + +#projectlogo +{ + text-align: center; + vertical-align: bottom; + border-collapse: separate; +} + +#projectlogo img +{ + border: 0px none; +} + +#projectalign +{ + vertical-align: middle; +} + +#projectname +{ + font: 300% Tahoma, Arial,sans-serif; + margin: 0px; + padding: 2px 0px; +} + +#projectbrief +{ + font: 120% Tahoma, Arial,sans-serif; + margin: 0px; + padding: 0px; +} + +#projectnumber +{ + font: 50% Tahoma, Arial,sans-serif; + margin: 0px; + padding: 0px; +} + +#titlearea +{ + padding: 0px; + margin: 0px; + width: 100%; + border-bottom: 1px solid #5373B4; +} + +.image +{ + text-align: center; +} + +.dotgraph +{ + text-align: center; +} + +.mscgraph +{ + text-align: center; +} + +.diagraph +{ + text-align: center; +} + +.caption +{ + font-weight: bold; +} + +div.zoom +{ + border: 1px solid #90A5CE; +} + +dl.citelist { + margin-bottom:50px; +} + +dl.citelist dt { + color:#334975; + float:left; + font-weight:bold; + margin-right:10px; + padding:5px; +} + +dl.citelist dd { + margin:2px 0; + padding:5px 0; +} + +div.toc { + padding: 14px 25px; + background-color: #F4F6FA; + border: 1px solid #D8DFEE; + border-radius: 7px 7px 7px 7px; + float: right; + height: auto; + margin: 0 20px 10px 10px; + width: 200px; +} + +div.toc li { + background: url("bdwn.png") no-repeat scroll 0 5px transparent; + font: 10px/1.2 Verdana,DejaVu Sans,Geneva,sans-serif; + margin-top: 5px; + padding-left: 10px; + padding-top: 2px; +} + +div.toc h3 { + font: bold 12px/1.2 Arial,FreeSans,sans-serif; + color: #4665A2; + border-bottom: 0 none; + margin: 0; +} + +div.toc ul { + list-style: none outside none; + border: medium none; + padding: 0px; +} + +div.toc li.level1 { + margin-left: 0px; +} + +div.toc li.level2 { + margin-left: 15px; +} + +div.toc li.level3 { + margin-left: 30px; +} + +div.toc li.level4 { + margin-left: 45px; +} + +.inherit_header { + font-weight: bold; + color: gray; + cursor: pointer; + -webkit-touch-callout: none; + -webkit-user-select: none; + -khtml-user-select: none; + -moz-user-select: none; + -ms-user-select: none; + user-select: none; +} + +.inherit_header td { + padding: 6px 0px 2px 5px; +} + +.inherit { + display: none; +} + +tr.heading h2 { + margin-top: 12px; + margin-bottom: 4px; +} + +/* tooltip related style info */ + +.ttc { + position: absolute; + display: none; +} + +#powerTip { + cursor: default; + white-space: nowrap; + background-color: white; + border: 1px solid gray; + border-radius: 4px 4px 4px 4px; + box-shadow: 1px 1px 7px gray; + display: none; + font-size: smaller; + max-width: 80%; + opacity: 0.9; + padding: 1ex 1em 1em; + position: absolute; + z-index: 2147483647; +} + +#powerTip div.ttdoc { + color: grey; + font-style: italic; +} + +#powerTip div.ttname a { + font-weight: bold; +} + +#powerTip div.ttname { + font-weight: bold; +} + +#powerTip div.ttdeci { + color: #006318; +} + +#powerTip div { + margin: 0px; + padding: 0px; + font: 12px/16px Roboto,sans-serif; +} + +#powerTip:before, #powerTip:after { + content: ""; + position: absolute; + margin: 0px; +} + +#powerTip.n:after, #powerTip.n:before, +#powerTip.s:after, #powerTip.s:before, +#powerTip.w:after, #powerTip.w:before, +#powerTip.e:after, #powerTip.e:before, +#powerTip.ne:after, #powerTip.ne:before, +#powerTip.se:after, #powerTip.se:before, +#powerTip.nw:after, #powerTip.nw:before, +#powerTip.sw:after, #powerTip.sw:before { + border: solid transparent; + content: " "; + height: 0; + width: 0; + position: absolute; +} + +#powerTip.n:after, #powerTip.s:after, +#powerTip.w:after, #powerTip.e:after, +#powerTip.nw:after, #powerTip.ne:after, +#powerTip.sw:after, #powerTip.se:after { + border-color: rgba(255, 255, 255, 0); +} + +#powerTip.n:before, #powerTip.s:before, +#powerTip.w:before, #powerTip.e:before, +#powerTip.nw:before, #powerTip.ne:before, +#powerTip.sw:before, #powerTip.se:before { + border-color: rgba(128, 128, 128, 0); +} + +#powerTip.n:after, #powerTip.n:before, +#powerTip.ne:after, #powerTip.ne:before, +#powerTip.nw:after, #powerTip.nw:before { + top: 100%; +} + +#powerTip.n:after, #powerTip.ne:after, #powerTip.nw:after { + border-top-color: #ffffff; + border-width: 10px; + margin: 0px -10px; +} +#powerTip.n:before { + border-top-color: #808080; + border-width: 11px; + margin: 0px -11px; +} +#powerTip.n:after, #powerTip.n:before { + left: 50%; +} + +#powerTip.nw:after, #powerTip.nw:before { + right: 14px; +} + +#powerTip.ne:after, #powerTip.ne:before { + left: 14px; +} + +#powerTip.s:after, #powerTip.s:before, +#powerTip.se:after, #powerTip.se:before, +#powerTip.sw:after, #powerTip.sw:before { + bottom: 100%; +} + +#powerTip.s:after, #powerTip.se:after, #powerTip.sw:after { + border-bottom-color: #ffffff; + border-width: 10px; + margin: 0px -10px; +} + +#powerTip.s:before, #powerTip.se:before, #powerTip.sw:before { + border-bottom-color: #808080; + border-width: 11px; + margin: 0px -11px; +} + +#powerTip.s:after, #powerTip.s:before { + left: 50%; +} + +#powerTip.sw:after, #powerTip.sw:before { + right: 14px; +} + +#powerTip.se:after, #powerTip.se:before { + left: 14px; +} + +#powerTip.e:after, #powerTip.e:before { + left: 100%; +} +#powerTip.e:after { + border-left-color: #ffffff; + border-width: 10px; + top: 50%; + margin-top: -10px; +} +#powerTip.e:before { + border-left-color: #808080; + border-width: 11px; + top: 50%; + margin-top: -11px; +} + +#powerTip.w:after, #powerTip.w:before { + right: 100%; +} +#powerTip.w:after { + border-right-color: #ffffff; + border-width: 10px; + top: 50%; + margin-top: -10px; +} +#powerTip.w:before { + border-right-color: #808080; + border-width: 11px; + top: 50%; + margin-top: -11px; +} + +@media print +{ + #top { display: none; } + #side-nav { display: none; } + #nav-path { display: none; } + body { overflow:visible; } + h1, h2, h3, h4, h5, h6 { page-break-after: avoid; } + .summary { display: none; } + .memitem { page-break-inside: avoid; } + #doc-content + { + margin-left:0 !important; + height:auto !important; + width:auto !important; + overflow:inherit; + display:inline; + } +} + diff --git a/libinput/doc/0.0/doxygen.png b/libinput/doc/0.0/doxygen.png new file mode 100644 index 0000000000000000000000000000000000000000..3ff17d807fd8aa003bed8bb2a69e8f0909592fd1 Binary files /dev/null and b/libinput/doc/0.0/doxygen.png differ diff --git a/libinput/doc/0.0/dynsections.js b/libinput/doc/0.0/dynsections.js new file mode 100644 index 0000000000000000000000000000000000000000..85e183690954af49931335b87a063b2c078d4546 --- /dev/null +++ b/libinput/doc/0.0/dynsections.js @@ -0,0 +1,97 @@ +function toggleVisibility(linkObj) +{ + var base = $(linkObj).attr('id'); + var summary = $('#'+base+'-summary'); + var content = $('#'+base+'-content'); + var trigger = $('#'+base+'-trigger'); + var src=$(trigger).attr('src'); + if (content.is(':visible')===true) { + content.hide(); + summary.show(); + $(linkObj).addClass('closed').removeClass('opened'); + $(trigger).attr('src',src.substring(0,src.length-8)+'closed.png'); + } else { + content.show(); + summary.hide(); + $(linkObj).removeClass('closed').addClass('opened'); + $(trigger).attr('src',src.substring(0,src.length-10)+'open.png'); + } + return false; +} + +function updateStripes() +{ + $('table.directory tr'). + removeClass('even').filter(':visible:even').addClass('even'); +} + +function toggleLevel(level) +{ + $('table.directory tr').each(function() { + var l = this.id.split('_').length-1; + var i = $('#img'+this.id.substring(3)); + var a = $('#arr'+this.id.substring(3)); + if (l + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/libinput/doc/0.0/faq.html b/libinput/doc/0.0/faq.html new file mode 100644 index 0000000000000000000000000000000000000000..15ea21d7da8536c633abf6f30dee6b222e270d67 --- /dev/null +++ b/libinput/doc/0.0/faq.html @@ -0,0 +1,136 @@ + + + + + + + + + + + libinput: FAQs - Frequently Asked Questions + + + + + + + + + + + + + + + + +
+
+
+
+
+
+ + + + + +
+
+ + +
+ +
+ + +
+
+
+
FAQs - Frequently Asked Questions
+
+
+

Frequently asked questions about libinput.

+

+My mouse moves too fast, even at the slowest setting

+

This is a symptom of high-dpi mice (greater than 1000dpi). These devices need a udev hwdb entry to normalize their motion. See Normalization of relative motion for a detailed explanation.

+

+Kinetic scrolling does not work

+

The X.Org synaptics driver implemented kinetic scrolling in the driver. It measures the scroll speed and once the finger leaves the touchpad the driver keeps sending scroll events for a predetermined time. This effectively provides for kinetic scrolling without client support but triggers an unfixable bug: the client cannot know that the events are from a kinetic scroll source. Scroll events in X are always sent to the current cursor position, a movement of the cursor after lifting the finger will send the kinetic scroll events to the new client, something the user does not usually expect. A key event during the kinetic scroll procedure causes side-effects such as triggering zoom.

+

libinput does not implement kinetic scrolling for touchpads. Instead it provides the libinput_event_pointer_get_axis_source() function that enables callers to implement kinetic scrolling on a per-widget basis, see Scroll sources.

+

+Is libinput GPL-licensed?

+

No, libinput is MIT licensed. The Linux kernel header file linux/input.h in libinput's tree is provided to ensure the same behavior regardless of which kernel version libinput is built on. It does not make libinput GPL-licensed.

+

+Where is the configuration stored?

+

libinput does not store configuration options, it is up to the caller to manage these and decide which configuration option to apply to each device. This must be done at startup, after a resume and whenever a new device is detected.

+

In a GNOME X.Org stack a user would usually toggle an option in the gnome-control-center which adjusts a gsettings entry. That change is picked up by gnome-settings-daemon and applied to the device by adjusting input device properties that the xf86-input-libinput driver provides. The input device property changes map to the respective libinput configuration options.

+

+dot_libinput-stack-gnome.png + +
+

+

This has an effect on the availability of configuration options: if an option is not exposed by the intermediary, it cannot be configured by the client. Also some configuration options that are provided by the intermediary may not be libinput-specific configuration options.

+
+ + +
+
+
+
+
+ + + diff --git a/libinput/doc/0.0/faqs_8dox.html b/libinput/doc/0.0/faqs_8dox.html new file mode 100644 index 0000000000000000000000000000000000000000..a2da7f3fbec6414b66907ea01c0138076cdcfbeb --- /dev/null +++ b/libinput/doc/0.0/faqs_8dox.html @@ -0,0 +1,117 @@ + + + + + + + + + + + libinput: faqs.dox File Reference + + + + + + + + + + + + + + + + +
+
+
+
+
+
+ + + + + + +
+
+ + +
+ +
+ +
+
+
+
faqs.dox File Reference
+
+
+
+ + +
+
+
+
+
+ + + diff --git a/libinput/doc/0.0/files.html b/libinput/doc/0.0/files.html new file mode 100644 index 0000000000000000000000000000000000000000..428804510e1671b7ab111ac6bacb8af321291a56 --- /dev/null +++ b/libinput/doc/0.0/files.html @@ -0,0 +1,123 @@ + + + + + + + + + + + libinput: File List + + + + + + + + + + + + + + + + +
+
+
+
+
+
+ + + + + +
+ +
+
+ + +
+ +
+ +
+
+
File List
+
+
+
Here is a list of all files with brief descriptions:
+
[detail level 12]
+ + +
  src
 libinput.h
+
+
+ + +
+
+
+
+
+ + + diff --git a/libinput/doc/0.0/folderclosed.png b/libinput/doc/0.0/folderclosed.png new file mode 100644 index 0000000000000000000000000000000000000000..bb8ab35edce8e97554e360005ee9fc5bffb36e66 Binary files /dev/null and b/libinput/doc/0.0/folderclosed.png differ diff --git a/libinput/doc/0.0/folderopen.png b/libinput/doc/0.0/folderopen.png new file mode 100644 index 0000000000000000000000000000000000000000..d6c7f676a3b3ef8c2c307d319dff3c6a604eb227 Binary files /dev/null and b/libinput/doc/0.0/folderopen.png differ diff --git a/libinput/doc/0.0/functions.html b/libinput/doc/0.0/functions.html new file mode 100644 index 0000000000000000000000000000000000000000..0d288220d0b5055148c6df1da2fe2d40549d2cbd --- /dev/null +++ b/libinput/doc/0.0/functions.html @@ -0,0 +1,128 @@ + + + + + + + + + + + libinput: Data Fields + + + + + + + + + + + + + + + + +
+
+
+
+
+
+ + + + + + +
+ +
+
+ + +
+ +
+ +
+
Here is a list of all struct and union fields with links to the structures/unions they belong to:
+
+ + +
+
+
+
+
+ + + diff --git a/libinput/doc/0.0/functions_vars.html b/libinput/doc/0.0/functions_vars.html new file mode 100644 index 0000000000000000000000000000000000000000..18bbd45ea84cef96695fe321912ef7555aaa5416 --- /dev/null +++ b/libinput/doc/0.0/functions_vars.html @@ -0,0 +1,128 @@ + + + + + + + + + + + libinput: Data Fields - Variables + + + + + + + + + + + + + + + + +
+
+
+
+
+
+ + + + + + +
+ +
+
+ + +
+ +
+ +
+
+ + +
+
+
+
+
+ + + diff --git a/libinput/doc/0.0/general.html b/libinput/doc/0.0/general.html new file mode 100644 index 0000000000000000000000000000000000000000..7b36782f290a6978c886ef207f2e7f22bfd80ff5 --- /dev/null +++ b/libinput/doc/0.0/general.html @@ -0,0 +1,115 @@ + + + + + + + + + + + libinput: General setup + + + + + + + + + + + + + + + + +
+
+
+
+
+
+ + + + + +
+
+ + +
+ +
+ +
+
+
+
General setup
+
+ + + +
+
+
+
+
+ + + diff --git a/libinput/doc/0.0/gesture-2fg-ambiguity.svg b/libinput/doc/0.0/gesture-2fg-ambiguity.svg new file mode 100644 index 0000000000000000000000000000000000000000..e4996ca98d3ae04f08c4eddef3c9326502bafee1 --- /dev/null +++ b/libinput/doc/0.0/gesture-2fg-ambiguity.svg @@ -0,0 +1,496 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + image/svg+xml + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + Touch 1 + + + Touch 2 + + diff --git a/libinput/doc/0.0/gestures.html b/libinput/doc/0.0/gestures.html new file mode 100644 index 0000000000000000000000000000000000000000..8ed3d6b468c06b854e45b32b87afc1b73afecde7 --- /dev/null +++ b/libinput/doc/0.0/gestures.html @@ -0,0 +1,176 @@ + + + + + + + + + + + libinput: Gestures + + + + + + + + + + + + + + + + +
+
+
+
+
+
+ + + + + +
+
+ + +
+ +
+ + +
+
+
+
Gestures
+
+
+

libinput supports basic gestures on touchpads and other indirect input devices.

+

Two types of gestures are supported: Pinch gestures and Swipe gestures. Support for gestures depends on the hardware device, most touchpads support both gestures and any device that may send gesture events has the LIBINPUT_DEVICE_CAP_GESTURE capability set.

+

Note that libinput does not support gestures on touchscreens, see Touchscreen gestures.

+

+Lifetime of a gesture

+

A gesture's lifetime has three distinct stages: begin, update and end, each with their own event types. Begin is sent when the fingers are first set down or libinput decides that the gesture begins. For Pinch gestures this sets the initial scale. Any events changing properties of the gesture are sent as update events. On termination of the gesture, an end event is sent.

+

A gesture includes the finger count (see libinput_event_gesture_get_finger_count()) and that finger count remains the same for the lifetime of a gesture. Thus, if a user puts down a fourth finger during a three-finger swipe gesture, libinput will end the three-finger gesture and, if applicable, start a four-finger swipe gesture. A caller may decide that those gestures are semantically identical and continue the two gestures as one single gesture.

+
See also
LIBINPUT_EVENT_GESTURE_PINCH_BEGIN
+
+LIBINPUT_EVENT_GESTURE_PINCH_UPDATE
+
+LIBINPUT_EVENT_GESTURE_PINCH_END
+
+LIBINPUT_EVENT_GESTURE_PINCH_BEGIN
+
+LIBINPUT_EVENT_GESTURE_SWIPE_UPDATE
+
+LIBINPUT_EVENT_GESTURE_SWIPE_END
+

+Pinch gestures

+

Pinch gestures are executed when two or more fingers are located on the touchpad and are either changing the relative distance to each other (pinching) or are changing the relative angle (rotate). Pinch gestures may change both rotation and distance at the same time. For such gestures, libinput calculates a logical center for the gestures and provides the caller with the delta x/y coordinates of that center, the relative angle of the fingers compared to the previous event, and the absolute scale compared to the initial finger position.

+
+pinch-gestures.svg +
+The pinch and rotate gestures
+

The illustration above shows a basic pinch in the left image and a rotate in the right angle. Not shown is a movement of the logical center if the fingers move unevenly. Such a movement is supported by libinput, it is merely left out of the illustration.

+

Note that while position and angle is relative to the previous event, the scale is always absolute and a multiplier of the initial finger position's scale.

+

+Swipe gestures

+

Swipe gestures are executed when three or more fingers are moved synchronously in the same direction. libinput provides x and y coordinates in the gesture and thus allows swipe gestures in any direction, including the tracing of complex paths. It is up to the caller to interpret the gesture into an action or limit a gesture to specific directions only.

+
+swipe-gestures.svg +
+The swipe gestures
+

The illustration above shows a vertical three-finger swipe. The coordinates provided during the gesture are the movements of the logical center.

+

+Touchscreen gestures

+

Touchscreen gestures are not interpreted by libinput. Rather, any touch point is passed to the caller and any interpretation of gestures is up to the caller or, eventually, the X or Wayland client.

+

Interpreting gestures on a touchscreen requires context that libinput does not have, such as the location of windows and other virtual objects on the screen as well as the context of those virtual objects:

+
+touchscreen-gestures.svg +
+Context-sensitivity of touchscreen gestures
+

In this example, the finger movements are identical but in the left case both fingers are located within the same window, thus suggesting an attempt to zoom. In the right case both fingers are located on a window border, thus suggesting a window movement. libinput only has knowledge of the finger coordinates (and even then only in device coordinates, not in screen coordinates) and thus cannot differentiate the two.

+

+Gestures with enabled software buttons

+

If the touchpad device is a Clickpad, it is recommended that a caller switches to Clickfinger behavior. Usually fingers placed in a software button area is not considered for gestures, resulting in some gestures to be interpreted as pointer motion or two-finger scroll events.

+
+pinch-gestures-softbuttons.svg +
+Interference of software buttons and pinch gestures
+

In the example above, the software button area is highlighted in red. The user executes a three-finger pinch gesture, with the thumb remaining in the software button area. libinput ignores fingers within the software button areas, the movement of the remaining fingers is thus interpreted as a two-finger scroll motion.

+

+Gestures on two-finger touchpads

+

As of kernel 4.2, many Partial multi-touch touchpads provide only two slots. This affects how gestures can be interpreted. Touchpads with only two slots can identify two touches by position but can usually tell that there is a third (or fourth) finger down on the touchpad - without providing positional information for that finger.

+

Touchpoints are assigned in sequential order and only the first two touch points are trackable. For libinput this produces an ambiguity where it is impossible to detect whether a gesture is a pinch gesture or a swipe gesture whenever a user puts the index and middle finger down first. Since the third finger does not have positional information, it's location cannot be determined.

+
+gesture-2fg-ambiguity.svg +
+Ambiguity of three-finger gestures on two-finger touchpads
+

The image above illustrates this ambiguity. The index and middle finger are set down first, the data stream from both finger positions looks identical. In this case, libinput assumes the fingers are in a horizontal arrangement (the right image above) and use a swipe gesture.

+
+ + +
+
+
+
+
+ + + diff --git a/libinput/doc/0.0/gestures_8dox.html b/libinput/doc/0.0/gestures_8dox.html new file mode 100644 index 0000000000000000000000000000000000000000..04a1c6038e782f0768cc9a793f60174b6f168f96 --- /dev/null +++ b/libinput/doc/0.0/gestures_8dox.html @@ -0,0 +1,117 @@ + + + + + + + + + + + libinput: gestures.dox File Reference + + + + + + + + + + + + + + + + +
+
+
+
+
+
+ + + + + + +
+
+ + +
+ +
+ +
+
+
+
gestures.dox File Reference
+
+
+
+ + +
+
+
+
+
+ + + diff --git a/libinput/doc/0.0/globals.html b/libinput/doc/0.0/globals.html new file mode 100644 index 0000000000000000000000000000000000000000..109182a2eb0c58de1400d748dec2eac7f79b6118 --- /dev/null +++ b/libinput/doc/0.0/globals.html @@ -0,0 +1,1056 @@ + + + + + + + + + + + libinput: Globals + + + + + + + + + + + + + + + + +
+
+
+
+
+
+ + + + + + + +
+ +
+
+ + +
+ +
+ +
+
Here is a list of all functions, variables, defines, enums, and typedefs with links to the files they belong to:
+ +

- l -

    +
  • LIBINPUT_ATTRIBUTE_DEPRECATED +: libinput.h +
  • +
  • LIBINPUT_ATTRIBUTE_PRINTF +: libinput.h +
  • +
  • libinput_button_state +: libinput.h +
  • +
  • LIBINPUT_BUTTON_STATE_PRESSED +: libinput.h +
  • +
  • LIBINPUT_BUTTON_STATE_RELEASED +: libinput.h +
  • +
  • libinput_config_accel_profile +: libinput.h +
  • +
  • LIBINPUT_CONFIG_ACCEL_PROFILE_ADAPTIVE +: libinput.h +
  • +
  • LIBINPUT_CONFIG_ACCEL_PROFILE_FLAT +: libinput.h +
  • +
  • LIBINPUT_CONFIG_ACCEL_PROFILE_NONE +: libinput.h +
  • +
  • libinput_config_click_method +: libinput.h +
  • +
  • LIBINPUT_CONFIG_CLICK_METHOD_BUTTON_AREAS +: libinput.h +
  • +
  • LIBINPUT_CONFIG_CLICK_METHOD_CLICKFINGER +: libinput.h +
  • +
  • LIBINPUT_CONFIG_CLICK_METHOD_NONE +: libinput.h +
  • +
  • LIBINPUT_CONFIG_DRAG_DISABLED +: libinput.h +
  • +
  • LIBINPUT_CONFIG_DRAG_ENABLED +: libinput.h +
  • +
  • LIBINPUT_CONFIG_DRAG_LOCK_DISABLED +: libinput.h +
  • +
  • LIBINPUT_CONFIG_DRAG_LOCK_ENABLED +: libinput.h +
  • +
  • libinput_config_drag_lock_state +: libinput.h +
  • +
  • libinput_config_drag_state +: libinput.h +
  • +
  • LIBINPUT_CONFIG_DWT_DISABLED +: libinput.h +
  • +
  • LIBINPUT_CONFIG_DWT_ENABLED +: libinput.h +
  • +
  • libinput_config_dwt_state +: libinput.h +
  • +
  • LIBINPUT_CONFIG_MIDDLE_EMULATION_DISABLED +: libinput.h +
  • +
  • LIBINPUT_CONFIG_MIDDLE_EMULATION_ENABLED +: libinput.h +
  • +
  • libinput_config_middle_emulation_state +: libinput.h +
  • +
  • LIBINPUT_CONFIG_SCROLL_2FG +: libinput.h +
  • +
  • LIBINPUT_CONFIG_SCROLL_EDGE +: libinput.h +
  • +
  • libinput_config_scroll_method +: libinput.h +
  • +
  • LIBINPUT_CONFIG_SCROLL_NO_SCROLL +: libinput.h +
  • +
  • LIBINPUT_CONFIG_SCROLL_ON_BUTTON_DOWN +: libinput.h +
  • +
  • LIBINPUT_CONFIG_SEND_EVENTS_DISABLED +: libinput.h +
  • +
  • LIBINPUT_CONFIG_SEND_EVENTS_DISABLED_ON_EXTERNAL_MOUSE +: libinput.h +
  • +
  • LIBINPUT_CONFIG_SEND_EVENTS_ENABLED +: libinput.h +
  • +
  • libinput_config_send_events_mode +: libinput.h +
  • +
  • libinput_config_status +: libinput.h +
  • +
  • LIBINPUT_CONFIG_STATUS_INVALID +: libinput.h +
  • +
  • LIBINPUT_CONFIG_STATUS_SUCCESS +: libinput.h +
  • +
  • libinput_config_status_to_str() +: libinput.h +
  • +
  • LIBINPUT_CONFIG_STATUS_UNSUPPORTED +: libinput.h +
  • +
  • LIBINPUT_CONFIG_TAP_DISABLED +: libinput.h +
  • +
  • LIBINPUT_CONFIG_TAP_ENABLED +: libinput.h +
  • +
  • libinput_config_tap_state +: libinput.h +
  • +
  • LIBINPUT_DEVICE_CAP_GESTURE +: libinput.h +
  • +
  • LIBINPUT_DEVICE_CAP_KEYBOARD +: libinput.h +
  • +
  • LIBINPUT_DEVICE_CAP_POINTER +: libinput.h +
  • +
  • LIBINPUT_DEVICE_CAP_TABLET_TOOL +: libinput.h +
  • +
  • LIBINPUT_DEVICE_CAP_TOUCH +: libinput.h +
  • +
  • libinput_device_capability +: libinput.h +
  • +
  • libinput_device_config_accel_get_default_profile() +: libinput.h +
  • +
  • libinput_device_config_accel_get_default_speed() +: libinput.h +
  • +
  • libinput_device_config_accel_get_profile() +: libinput.h +
  • +
  • libinput_device_config_accel_get_profiles() +: libinput.h +
  • +
  • libinput_device_config_accel_get_speed() +: libinput.h +
  • +
  • libinput_device_config_accel_is_available() +: libinput.h +
  • +
  • libinput_device_config_accel_set_profile() +: libinput.h +
  • +
  • libinput_device_config_accel_set_speed() +: libinput.h +
  • +
  • libinput_device_config_calibration_get_default_matrix() +: libinput.h +
  • +
  • libinput_device_config_calibration_get_matrix() +: libinput.h +
  • +
  • libinput_device_config_calibration_has_matrix() +: libinput.h +
  • +
  • libinput_device_config_calibration_set_matrix() +: libinput.h +
  • +
  • libinput_device_config_click_get_default_method() +: libinput.h +
  • +
  • libinput_device_config_click_get_method() +: libinput.h +
  • +
  • libinput_device_config_click_get_methods() +: libinput.h +
  • +
  • libinput_device_config_click_set_method() +: libinput.h +
  • +
  • libinput_device_config_dwt_get_default_enabled() +: libinput.h +
  • +
  • libinput_device_config_dwt_get_enabled() +: libinput.h +
  • +
  • libinput_device_config_dwt_is_available() +: libinput.h +
  • +
  • libinput_device_config_dwt_set_enabled() +: libinput.h +
  • +
  • libinput_device_config_left_handed_get() +: libinput.h +
  • +
  • libinput_device_config_left_handed_get_default() +: libinput.h +
  • +
  • libinput_device_config_left_handed_is_available() +: libinput.h +
  • +
  • libinput_device_config_left_handed_set() +: libinput.h +
  • +
  • libinput_device_config_middle_emulation_get_default_enabled() +: libinput.h +
  • +
  • libinput_device_config_middle_emulation_get_enabled() +: libinput.h +
  • +
  • libinput_device_config_middle_emulation_is_available() +: libinput.h +
  • +
  • libinput_device_config_middle_emulation_set_enabled() +: libinput.h +
  • +
  • libinput_device_config_scroll_get_button() +: libinput.h +
  • +
  • libinput_device_config_scroll_get_default_button() +: libinput.h +
  • +
  • libinput_device_config_scroll_get_default_method() +: libinput.h +
  • +
  • libinput_device_config_scroll_get_default_natural_scroll_enabled() +: libinput.h +
  • +
  • libinput_device_config_scroll_get_method() +: libinput.h +
  • +
  • libinput_device_config_scroll_get_methods() +: libinput.h +
  • +
  • libinput_device_config_scroll_get_natural_scroll_enabled() +: libinput.h +
  • +
  • libinput_device_config_scroll_has_natural_scroll() +: libinput.h +
  • +
  • libinput_device_config_scroll_set_button() +: libinput.h +
  • +
  • libinput_device_config_scroll_set_method() +: libinput.h +
  • +
  • libinput_device_config_scroll_set_natural_scroll_enabled() +: libinput.h +
  • +
  • libinput_device_config_send_events_get_default_mode() +: libinput.h +
  • +
  • libinput_device_config_send_events_get_mode() +: libinput.h +
  • +
  • libinput_device_config_send_events_get_modes() +: libinput.h +
  • +
  • libinput_device_config_send_events_set_mode() +: libinput.h +
  • +
  • libinput_device_config_tap_get_default_drag_enabled() +: libinput.h +
  • +
  • libinput_device_config_tap_get_default_drag_lock_enabled() +: libinput.h +
  • +
  • libinput_device_config_tap_get_default_enabled() +: libinput.h +
  • +
  • libinput_device_config_tap_get_drag_enabled() +: libinput.h +
  • +
  • libinput_device_config_tap_get_drag_lock_enabled() +: libinput.h +
  • +
  • libinput_device_config_tap_get_enabled() +: libinput.h +
  • +
  • libinput_device_config_tap_get_finger_count() +: libinput.h +
  • +
  • libinput_device_config_tap_set_drag_enabled() +: libinput.h +
  • +
  • libinput_device_config_tap_set_drag_lock_enabled() +: libinput.h +
  • +
  • libinput_device_config_tap_set_enabled() +: libinput.h +
  • +
  • libinput_device_get_context() +: libinput.h +
  • +
  • libinput_device_get_device_group() +: libinput.h +
  • +
  • libinput_device_get_id_product() +: libinput.h +
  • +
  • libinput_device_get_id_vendor() +: libinput.h +
  • +
  • libinput_device_get_name() +: libinput.h +
  • +
  • libinput_device_get_output_name() +: libinput.h +
  • +
  • libinput_device_get_seat() +: libinput.h +
  • +
  • libinput_device_get_size() +: libinput.h +
  • +
  • libinput_device_get_sysname() +: libinput.h +
  • +
  • libinput_device_get_udev_device() +: libinput.h +
  • +
  • libinput_device_get_user_data() +: libinput.h +
  • +
  • libinput_device_group_get_user_data() +: libinput.h +
  • +
  • libinput_device_group_ref() +: libinput.h +
  • +
  • libinput_device_group_set_user_data() +: libinput.h +
  • +
  • libinput_device_group_unref() +: libinput.h +
  • +
  • libinput_device_has_capability() +: libinput.h +
  • +
  • libinput_device_keyboard_has_key() +: libinput.h +
  • +
  • libinput_device_led_update() +: libinput.h +
  • +
  • libinput_device_pointer_has_button() +: libinput.h +
  • +
  • libinput_device_ref() +: libinput.h +
  • +
  • libinput_device_set_seat_logical_name() +: libinput.h +
  • +
  • libinput_device_set_user_data() +: libinput.h +
  • +
  • libinput_device_unref() +: libinput.h +
  • +
  • libinput_dispatch() +: libinput.h +
  • +
  • libinput_event_destroy() +: libinput.h +
  • +
  • LIBINPUT_EVENT_DEVICE_ADDED +: libinput.h +
  • +
  • libinput_event_device_notify_get_base_event() +: libinput.h +
  • +
  • LIBINPUT_EVENT_DEVICE_REMOVED +: libinput.h +
  • +
  • libinput_event_gesture_get_angle_delta() +: libinput.h +
  • +
  • libinput_event_gesture_get_base_event() +: libinput.h +
  • +
  • libinput_event_gesture_get_cancelled() +: libinput.h +
  • +
  • libinput_event_gesture_get_dx() +: libinput.h +
  • +
  • libinput_event_gesture_get_dx_unaccelerated() +: libinput.h +
  • +
  • libinput_event_gesture_get_dy() +: libinput.h +
  • +
  • libinput_event_gesture_get_dy_unaccelerated() +: libinput.h +
  • +
  • libinput_event_gesture_get_finger_count() +: libinput.h +
  • +
  • libinput_event_gesture_get_scale() +: libinput.h +
  • +
  • libinput_event_gesture_get_time() +: libinput.h +
  • +
  • libinput_event_gesture_get_time_usec() +: libinput.h +
  • +
  • LIBINPUT_EVENT_GESTURE_PINCH_BEGIN +: libinput.h +
  • +
  • LIBINPUT_EVENT_GESTURE_PINCH_END +: libinput.h +
  • +
  • LIBINPUT_EVENT_GESTURE_PINCH_UPDATE +: libinput.h +
  • +
  • LIBINPUT_EVENT_GESTURE_SWIPE_BEGIN +: libinput.h +
  • +
  • LIBINPUT_EVENT_GESTURE_SWIPE_END +: libinput.h +
  • +
  • LIBINPUT_EVENT_GESTURE_SWIPE_UPDATE +: libinput.h +
  • +
  • libinput_event_get_context() +: libinput.h +
  • +
  • libinput_event_get_device() +: libinput.h +
  • +
  • libinput_event_get_device_notify_event() +: libinput.h +
  • +
  • libinput_event_get_gesture_event() +: libinput.h +
  • +
  • libinput_event_get_keyboard_event() +: libinput.h +
  • +
  • libinput_event_get_pointer_event() +: libinput.h +
  • +
  • libinput_event_get_tablet_tool_event() +: libinput.h +
  • +
  • libinput_event_get_touch_event() +: libinput.h +
  • +
  • libinput_event_get_type() +: libinput.h +
  • +
  • libinput_event_keyboard_get_base_event() +: libinput.h +
  • +
  • libinput_event_keyboard_get_key() +: libinput.h +
  • +
  • libinput_event_keyboard_get_key_state() +: libinput.h +
  • +
  • libinput_event_keyboard_get_seat_key_count() +: libinput.h +
  • +
  • libinput_event_keyboard_get_time() +: libinput.h +
  • +
  • libinput_event_keyboard_get_time_usec() +: libinput.h +
  • +
  • LIBINPUT_EVENT_KEYBOARD_KEY +: libinput.h +
  • +
  • LIBINPUT_EVENT_NONE +: libinput.h +
  • +
  • LIBINPUT_EVENT_POINTER_AXIS +: libinput.h +
  • +
  • LIBINPUT_EVENT_POINTER_BUTTON +: libinput.h +
  • +
  • libinput_event_pointer_get_absolute_x() +: libinput.h +
  • +
  • libinput_event_pointer_get_absolute_x_transformed() +: libinput.h +
  • +
  • libinput_event_pointer_get_absolute_y() +: libinput.h +
  • +
  • libinput_event_pointer_get_absolute_y_transformed() +: libinput.h +
  • +
  • libinput_event_pointer_get_axis_source() +: libinput.h +
  • +
  • libinput_event_pointer_get_axis_value() +: libinput.h +
  • +
  • libinput_event_pointer_get_axis_value_discrete() +: libinput.h +
  • +
  • libinput_event_pointer_get_base_event() +: libinput.h +
  • +
  • libinput_event_pointer_get_button() +: libinput.h +
  • +
  • libinput_event_pointer_get_button_state() +: libinput.h +
  • +
  • libinput_event_pointer_get_dx() +: libinput.h +
  • +
  • libinput_event_pointer_get_dx_unaccelerated() +: libinput.h +
  • +
  • libinput_event_pointer_get_dy() +: libinput.h +
  • +
  • libinput_event_pointer_get_dy_unaccelerated() +: libinput.h +
  • +
  • libinput_event_pointer_get_seat_button_count() +: libinput.h +
  • +
  • libinput_event_pointer_get_time() +: libinput.h +
  • +
  • libinput_event_pointer_get_time_usec() +: libinput.h +
  • +
  • libinput_event_pointer_has_axis() +: libinput.h +
  • +
  • LIBINPUT_EVENT_POINTER_MOTION +: libinput.h +
  • +
  • LIBINPUT_EVENT_POINTER_MOTION_ABSOLUTE +: libinput.h +
  • +
  • LIBINPUT_EVENT_TABLET_TOOL_AXIS +: libinput.h +
  • +
  • LIBINPUT_EVENT_TABLET_TOOL_BUTTON +: libinput.h +
  • +
  • libinput_event_tablet_tool_distance_has_changed() +: libinput.h +
  • +
  • libinput_event_tablet_tool_get_base_event() +: libinput.h +
  • +
  • libinput_event_tablet_tool_get_button() +: libinput.h +
  • +
  • libinput_event_tablet_tool_get_button_state() +: libinput.h +
  • +
  • libinput_event_tablet_tool_get_distance() +: libinput.h +
  • +
  • libinput_event_tablet_tool_get_dx() +: libinput.h +
  • +
  • libinput_event_tablet_tool_get_dy() +: libinput.h +
  • +
  • libinput_event_tablet_tool_get_pressure() +: libinput.h +
  • +
  • libinput_event_tablet_tool_get_proximity_state() +: libinput.h +
  • +
  • libinput_event_tablet_tool_get_rotation() +: libinput.h +
  • +
  • libinput_event_tablet_tool_get_seat_button_count() +: libinput.h +
  • +
  • libinput_event_tablet_tool_get_slider_position() +: libinput.h +
  • +
  • libinput_event_tablet_tool_get_tilt_x() +: libinput.h +
  • +
  • libinput_event_tablet_tool_get_tilt_y() +: libinput.h +
  • +
  • libinput_event_tablet_tool_get_time() +: libinput.h +
  • +
  • libinput_event_tablet_tool_get_time_usec() +: libinput.h +
  • +
  • libinput_event_tablet_tool_get_tip_state() +: libinput.h +
  • +
  • libinput_event_tablet_tool_get_tool() +: libinput.h +
  • +
  • libinput_event_tablet_tool_get_wheel_delta() +: libinput.h +
  • +
  • libinput_event_tablet_tool_get_wheel_delta_discrete() +: libinput.h +
  • +
  • libinput_event_tablet_tool_get_x() +: libinput.h +
  • +
  • libinput_event_tablet_tool_get_x_transformed() +: libinput.h +
  • +
  • libinput_event_tablet_tool_get_y() +: libinput.h +
  • +
  • libinput_event_tablet_tool_get_y_transformed() +: libinput.h +
  • +
  • libinput_event_tablet_tool_pressure_has_changed() +: libinput.h +
  • +
  • LIBINPUT_EVENT_TABLET_TOOL_PROXIMITY +: libinput.h +
  • +
  • libinput_event_tablet_tool_rotation_has_changed() +: libinput.h +
  • +
  • libinput_event_tablet_tool_slider_has_changed() +: libinput.h +
  • +
  • libinput_event_tablet_tool_tilt_x_has_changed() +: libinput.h +
  • +
  • libinput_event_tablet_tool_tilt_y_has_changed() +: libinput.h +
  • +
  • LIBINPUT_EVENT_TABLET_TOOL_TIP +: libinput.h +
  • +
  • libinput_event_tablet_tool_wheel_has_changed() +: libinput.h +
  • +
  • libinput_event_tablet_tool_x_has_changed() +: libinput.h +
  • +
  • libinput_event_tablet_tool_y_has_changed() +: libinput.h +
  • +
  • LIBINPUT_EVENT_TOUCH_CANCEL +: libinput.h +
  • +
  • LIBINPUT_EVENT_TOUCH_DOWN +: libinput.h +
  • +
  • LIBINPUT_EVENT_TOUCH_FRAME +: libinput.h +
  • +
  • libinput_event_touch_get_base_event() +: libinput.h +
  • +
  • libinput_event_touch_get_seat_slot() +: libinput.h +
  • +
  • libinput_event_touch_get_slot() +: libinput.h +
  • +
  • libinput_event_touch_get_time() +: libinput.h +
  • +
  • libinput_event_touch_get_time_usec() +: libinput.h +
  • +
  • libinput_event_touch_get_x() +: libinput.h +
  • +
  • libinput_event_touch_get_x_transformed() +: libinput.h +
  • +
  • libinput_event_touch_get_y() +: libinput.h +
  • +
  • libinput_event_touch_get_y_transformed() +: libinput.h +
  • +
  • LIBINPUT_EVENT_TOUCH_MOTION +: libinput.h +
  • +
  • LIBINPUT_EVENT_TOUCH_UP +: libinput.h +
  • +
  • libinput_event_type +: libinput.h +
  • +
  • libinput_get_event() +: libinput.h +
  • +
  • libinput_get_fd() +: libinput.h +
  • +
  • libinput_get_user_data() +: libinput.h +
  • +
  • libinput_key_state +: libinput.h +
  • +
  • LIBINPUT_KEY_STATE_PRESSED +: libinput.h +
  • +
  • LIBINPUT_KEY_STATE_RELEASED +: libinput.h +
  • +
  • libinput_led +: libinput.h +
  • +
  • LIBINPUT_LED_CAPS_LOCK +: libinput.h +
  • +
  • LIBINPUT_LED_NUM_LOCK +: libinput.h +
  • +
  • LIBINPUT_LED_SCROLL_LOCK +: libinput.h +
  • +
  • libinput_log_get_priority() +: libinput.h +
  • +
  • libinput_log_handler +: libinput.h +
  • +
  • libinput_log_priority +: libinput.h +
  • +
  • LIBINPUT_LOG_PRIORITY_DEBUG +: libinput.h +
  • +
  • LIBINPUT_LOG_PRIORITY_ERROR +: libinput.h +
  • +
  • LIBINPUT_LOG_PRIORITY_INFO +: libinput.h +
  • +
  • libinput_log_set_handler +: libinput.h +
  • +
  • libinput_log_set_priority() +: libinput.h +
  • +
  • libinput_next_event_type() +: libinput.h +
  • +
  • libinput_path_add_device() +: libinput.h +
  • +
  • libinput_path_create_context() +: libinput.h +
  • +
  • libinput_path_remove_device() +: libinput.h +
  • +
  • libinput_pointer_axis +: libinput.h +
  • +
  • LIBINPUT_POINTER_AXIS_SCROLL_HORIZONTAL +: libinput.h +
  • +
  • LIBINPUT_POINTER_AXIS_SCROLL_VERTICAL +: libinput.h +
  • +
  • libinput_pointer_axis_source +: libinput.h +
  • +
  • LIBINPUT_POINTER_AXIS_SOURCE_CONTINUOUS +: libinput.h +
  • +
  • LIBINPUT_POINTER_AXIS_SOURCE_FINGER +: libinput.h +
  • +
  • LIBINPUT_POINTER_AXIS_SOURCE_WHEEL +: libinput.h +
  • +
  • libinput_ref() +: libinput.h +
  • +
  • libinput_resume() +: libinput.h +
  • +
  • libinput_seat_get_context() +: libinput.h +
  • +
  • libinput_seat_get_logical_name() +: libinput.h +
  • +
  • libinput_seat_get_physical_name() +: libinput.h +
  • +
  • libinput_seat_get_user_data() +: libinput.h +
  • +
  • libinput_seat_ref() +: libinput.h +
  • +
  • libinput_seat_set_user_data() +: libinput.h +
  • +
  • libinput_seat_unref() +: libinput.h +
  • +
  • libinput_set_user_data() +: libinput.h +
  • +
  • libinput_suspend() +: libinput.h +
  • +
  • libinput_tablet_tool_get_serial() +: libinput.h +
  • +
  • libinput_tablet_tool_get_tool_id() +: libinput.h +
  • +
  • libinput_tablet_tool_get_type() +: libinput.h +
  • +
  • libinput_tablet_tool_get_user_data() +: libinput.h +
  • +
  • libinput_tablet_tool_has_button() +: libinput.h +
  • +
  • libinput_tablet_tool_has_distance() +: libinput.h +
  • +
  • libinput_tablet_tool_has_pressure() +: libinput.h +
  • +
  • libinput_tablet_tool_has_rotation() +: libinput.h +
  • +
  • libinput_tablet_tool_has_slider() +: libinput.h +
  • +
  • libinput_tablet_tool_has_tilt() +: libinput.h +
  • +
  • libinput_tablet_tool_has_wheel() +: libinput.h +
  • +
  • libinput_tablet_tool_is_unique() +: libinput.h +
  • +
  • libinput_tablet_tool_proximity_state +: