TODO

   1 Core wayland protocol
   2
   3  - glyph cache
   4
   5  - dnd, figure out large object transfer: through wayland protocol or
   6    pass an fd through the compositor to the other client and let them
   7    sort it out?
   8
   9  - copy-n-paste, store data in server (only one mime-type available)
  10    or do X style (content mime-type negotiation, but data goes away
  11    when client quits).
  12
  13  - protocol for setting the cursor image
  14
  15     - should we have a mechanism to attach surface to cursor for
  16       guaranteed non-laggy drag?
  17
  18     - drawing cursors, moving them, cursor themes, attaching surfaces
  19       to cursors.  How do you change cursors when you mouse over a
  20       text field if you don't have subwindows?  This is what we do: a
  21       client can set a cursor for a surface and wayland will set that
  22       on enter and revert to default on leave
  23
  24  - Discard buffer, as in "wayland discarded your buffer, it's no
  25    longer visible, you can stop updating it now.", reattach, as in "oh
  26    hey, I'm about to show your buffer that I threw away, what was it
  27    again?".  for wayland system compositor vt switcing, for example,
  28    to be able to throw away the surfaces in the session we're
  29    switching away from.  for minimized windows that we don't want live
  30    thumb nails for. etc.
  31
  32  - Consolidate drm buffer upload with a create_buffer request, returns
  33    buffer object we can use in surface.attach, cache.upload and
  34    input.attach?  Will increase object id usage significantly, each
  35    buffer swap allocates and throws away a new id.  Does consolidate
  36    the details of a buffer very nicely though.
  37
  38      compositor.create_buffer(new_id, visual, name, stride, width, height)
  39
  40      surface.attach(buffer)
  41
  42      cache.upload(buffer, x, y, width, height)
  43
  44      input.set_cursor(buffer, hotspot_x, hotspot_y)
  45
  46    Doesn't increase id usage too much, can keep buffers around.
  47
  48  - Move/resize protocol in the style of the dnd protocol: a surface
  49    who has a grabbed device can send a request to initiate a
  50    resize(top/bottom+rigth/left) or a move.  The compositor will then
  51    resize or move the window and take into account windows, panels and
  52    screen edges and constrain and snap the motion accordingly.  As the
  53    cursor moves, the compositor sends resize or move (maybe not move
  54    events?) events to the app, which responds by attaching a new
  55    surface at the new size (optionally, reducing the allocated space
  56    to satisfy aspect ratio or resize increments).
  57
  58  - Initial placement of surfaces.  Guess we can do, 1)
  59    surface-relative (menus), 2) pointer-relative (tooltips and
  60    right-click menus) or 3) server-decides (all other top-levels).
  61
  62  - When a surface is the size of the screen and on top, we can set the
  63    scanout buffer to that surface directly.  Like compiz unredirect
  64    top-level window feature.  Except it won't have any protocol state
  65    side-effects and the client that owns the surface won't know.  We
  66    lose control of updates.  Should work well for X server root window
  67    under wayland.  Should be possible for yuv overlays as well.
  68
  69     - what about cursors then?  maybe use hw cursors if the cursor
  70       satisfies hw limitations (64x64, only one cursor), switch to
  71       composited cursors if not.
  72
  73     - clients needs to allocate the surface to be suitable for
  74       scanout, which they can do whenever they go fullscreen.
  75
  76  - multihead, screen geometry and crtc layout protocol, hotplug
  77
  78  - input device discovery, hotplug
  79
  80     - Advertise axes as part of the discovery, use something like
  81       "org.wayland.input.x" to identify the axes.
  82
  83     - keyboard state, layout events at connect time and when it
  84       changes, keyboard leds
  85
  86     - relative events
  87
  88     - multi touch?
  89
  90     - synaptics, 3-button emulation, scim
  91
  92  - sparse/gcc plugin based idl compiler
  93
  94     - crack?
  95
  96     - xml based description instead?
  97
  98  - actually make batch/commit batch up commands
  99
 100  - auth; We need to generate a random socket name and advertise that
 101    on dbus along with a connection cookie.  Something like a method
 102    that returns the socket name and a connection cookie.  The
 103    connection cookie is just another random string that the client
 104    must pass to the wayland server to become authenticated.  The
 105    Wayland server generates the cookie on demand when the dbus method
 106    is called and expires it after 5s or so.
 107
 108     - or just pass the fd over dbus
 109
 110  - drm bo access control, authentication, flink_to
 111
 112  - Range protocol may not be sufficient... if a server cycles through
 113    2^32 object IDs we don't have a way to handle wrapping.  And since
 114    we hand out a range of 256 IDs to each new clients, we're just
 115    talking about 2^24 clients.  That's 31 years with a new client
 116    every minute...  Maybe just use bigger ranges, then it's feasible
 117    to track and garbage collect them when a client dies.
 118
 119  - Add protocol to let applications specify the effective/logical
 120    surface rectangle, that is, the edge of the window, ignoring drop
 121    shadows and other padding.  The compositor needs this for snapping
 122    and constraining window motion.  Also, maybe communicate the opaque
 123    region of the window (or just a conservative, simple estimate), to
 124    let the compositor reduce overdraw.
 125
 126  - multi gpu, needs queue and seqno to wait on in requests
 127
 128 Clients and ports
 129
 130  - port gtk+
 131
 132     - eek, so much X legacy stuff there...
 133
 134     - draw window decorations in gtkwindow.c
 135
 136     - start from alexl's client-side-windows branch
 137
 138     - Details about pointer grabs. wayland doesn't have active grabs,
 139       menus will behave subtly different.  Under X, clicking a menu
 140       open grabs the pointer and clicking outside the window pops down
 141       the menu and swallows the click.  without active grabs we can't
 142       swallow the click.  I'm sure there much more...
 143
 144  - Port Qt?  There's already talk about this on the list.
 145
 146  - X on Wayland
 147
 148     - move most of the code from xf86-video-intel into a Xorg wayland
 149       module.
 150
 151     - don't ask KMS for available output and modes, use the info from
 152       the wayland server.  then stop mooching off of drmmode.c.
 153
 154     - map multiple wayland input devices to MPX in Xorg.
 155
 156     - rootless; avoid allocating and setting the front buffer, draw
 157       window decorations in the X server (!), how to map input?
 158
 159  - gnome-shell as a wayland session compositor
 160
 161     - runs as a client of the wayland session compositor, uses
 162       clutter+egl on wayland
 163
 164     - talks to an Xorg server as the compositing and window manager
 165       for that server and renders the output to a wayland surface.
 166       the Xorg server should be modified to take input from the system
 167       compositor through gnome-shell, but not allocate a front buffer.
 168
 169     - make gnome-shell itself a nested wayland server and allow native
 170       wayland clients to connect and can native wayland windows with
 171       the windows from the X server.
 172
 173  - qemu as a wayland client; session surface as X case
 174
 175     - qemu has too simple acceleration, so a Wayland backend like the
 176       SDL/VNC ones it has now is trivial.
 177
 178     - paravirt: forward wayland screen info as mmio, expose gem ioctls as mmio
 179
 180     - mapping vmem is tricky, should try to only use ioctl (pwrite+pread)
 181
 182     - not useful for Windows without a windows paravirt driver.
 183
 184     - two approaches: 1) do a toplevel qemu window, or 2) expose a
 185       wayland server in the guest that forwards to the host wayland
 186       server, ie a "remote" compositor, but with the gem buffers
 187       shared.  could do a wl_connection directly on mmio memory, with
 188       head and tail pointers.  use an alloc_head register to indicate
 189       desired data to write, if it overwrites tail, block guest.  just
 190       a socket would be easier.
 191
 192  - moblin as a wayland compositor
 193
 194     - clutter as a wayland compositors
 195
 196     - argh, mutter