wayland/TODO

Core wayland protocol

 - surface.set_grab_mode(GRAB_OWNER_EVENTS vs GRAB_SURFACE_EVENTS), to
   make menus work right: click and drag in a menubar grabs the
   pointer to the menubar (which we need for detecting motion into
   another menu item), but we need events for the popup menu surface
   as well.

 - The message format has to include information about number of fds
   in the message so we can skip a message correctly.  Or we should
   just give up on trying to recover from unknown messages.  We need
   to make sure you never get a message from an interface you don't
   know about (using per-client id space and subscribe) or include
   information on number of fds, so marshalling logic can skip.

 - generate pointer_focus (and drag focus) on raise/lower, move
   windows, all kinds of changes in surface stacking.

 - glyph cache

      buffer = drm.create_buffer(); /* buffer with stuff in it */

      cache.upload(buffer, x, y, width, height, int hash)

      drm.buffer: id, name, stride etc /* event to announce cache buffer */

      cache.image: hash, buffer, x, y, stride /* event to announce
					      * location in cache */

      cache.reject: hash   /* no upload for you! */

      cache.retire: buffer /* cache has stopped using buffer, please
			    * reupload whatever you had in that buffer */


 - DnD issues:

   Root window must send NULL type (to decline drop) or
   x-wayland/root-something type if the source offers that.  But the
   target deletes the drag_offer object when drag.pointer_focus leaves
   the surface...

   How do we animate the drag icon back to the drag origin in case of
   a failed drag?

   How to handle surfaces from clients that don't know about dnd or
   don't care?  Maybe the dnd object should have a
   dnd.register_surface() method so clients can opt-in the surfaces
   that will participate in dnd.  Or just assume client is not
   participating until we receive an accept request.

 - Selection/copy+paste

    - Similar to dnd, create a selection object for a device to offer
      selection data:

	 selection = shell.create(input_device)

	Requests:
	 - selection.offer(type)
	 - selection.activate(time)
	 - selection.destroy()

	Events:
	 - selection.finish(type, fd)
	 - selection.discard() /* somebody else took the selection */

    - Notes: no window owner, which seems to be mostly there as a way
      to identify the client and to allow None (instead of a release
      request).  Possibly also to make the selection go away
      automatically when the window with the contents go away, or
      possibly as a way for the source to distinguish between multiple
      selections.  Toolkits generally just create a dummy-toplevel for
      selections though.

    - Per-device selection.  The selection is per device.  Different
      keyboards copy and paste to different selections.

    - Selection offer object.  Introduced just before a surface
      receives keyboard_focus event or when somebody claims the
      selection and on keyboard_focus?  That way only keyboard_focus
      owner will know the types... limits pasting to the
      keyboard_focus surface.

	Requests:
	 - selection_offer.receive(type, fd)

	Events:
	 - selection_offer.offer(type)
	 - selection_offer.keyboard_focus()

 - Pointer image issue:

    - A touch input device doesn't have a pointer; indicate that
      somehow.

    - Cursor themes, tie in with glyph/image cache.

 - copy-n-paste, store data in server (only one mime-type available)
   or do X style (content mime-type negotiation, but data goes away
   when client quits).

 - Discard buffer, as in "wayland discarded your buffer, it's no
   longer visible, you can stop updating it now.", reattach, as in "oh
   hey, I'm about to show your buffer that I threw away, what was it
   again?".  for wayland system compositor vt switcing, for example,
   to be able to throw away the surfaces in the session we're
   switching away from.  for minimized windows that we don't want live
   thumb nails for. etc.

 - Initial placement of surfaces.  Guess we can do, 1)
   surface-relative (menus), 2) pointer-relative (tooltips and
   right-click menus) or 3) server-decides (all other top-levels).

 - Per client id space.  Each client has an entire 32 bit id namespace
   to itself.  On the server side, each struct wl_client has an object
   hash table.  Object announcements use a server id space and clients
   must respond with subscribe request with a client id for the
   object.  Part of wl_proxy_create_for_id():

      wl_display_subscribe(display, id, new_id, my_version);

   or maybe

      wl_display_bind(display, id, new_id, my_version);

   Fixes a few things:

    - Maps the global object into the client id space, lets client
      allocate the id.  All ids are allocated by the client this way,
      which fixes the range protocol problem.

    - Tells the server that the client is interested in events from
      the object.  Lets the server know that a client participates in a
      certain protocol (like drag and drop), so the server can account
      for whether or not the client is expected to reply

    - Server emits initial object state event(s) in reponse to
      receiving the subscribe request.  Introduces an extra round trip
      at initialization time, but the server will still announces all
      objects in one burst and the client can subscribe in a burst as
      well.

    - Separates client resources, since each client will have it's own
      hash table.  It's not longer possible to guess the id of another
      surface and access it.

    - Server must track the client id for each client an object is
      exposed to.  In some cases we know this (a surface is always
      only owned by one client), in other cases it provides a way to
      track who's interested in the object events.  For input device
      events, we can look up the client name when it receives pointer
      focus or keyboard focus and cache it in the device.

    - Server must know which id to send when passing object references
      in events.  We could say that any object we're passing to a
      client must have a server id, and each client has a server id ->
      client id hash.

 - When a surface is the size of the screen and on top, we can set the
   scanout buffer to that surface directly.  Like compiz unredirect
   top-level window feature.  Except it won't have any protocol state
   side-effects and the client that owns the surface won't know.  We
   lose control of updates.  Should work well for X server root window
   under wayland.  Should be possible for yuv overlays as well.

    - what about cursors then?  maybe use hw cursors if the cursor
      satisfies hw limitations (64x64, only one cursor), switch to
      composited cursors if not.

    - clients needs to allocate the surface to be suitable for
      scanout, which they can do whenever they go fullscreen.

 - multihead, screen geometry and crtc layout protocol, hotplug, lcd
   subpixel info

 - a wayland settings protocol to tell clients about themes (icons,
   cursors, widget themes), fonts details (family, hinting
   preferences) etc.  Just send all settings at connect time, send
   updates when a setting change.  Getting a little close to gconf
   here, but could be pretty simple:

     interface "settings":
       event int_value(string name, int value)
       event string_value(string name, string value)

   but maybe it's better to just require that clients get that from
   somewhere else (gconf/dbus).

 - input device discovery, hotplug

    - Advertise axes as part of the discovery, use something like
      "org.wayland.input.x" to identify the axes.

    - keyboard state, layout events at connect time and when it
      changes, keyboard leds

    - relative events

    - multi touch?

    - synaptics, 3-button emulation, scim

 - drm bo access control, authentication, flink_to

 - Range protocol may not be sufficient... if a server cycles through
   2^32 object IDs we don't have a way to handle wrapping.  And since
   we hand out a range of 256 IDs to each new clients, we're just
   talking about 2^24 clients.  That's 31 years with a new client
   every minute...  Maybe just use bigger ranges, then it's feasible
   to track and garbage collect them when a client dies.

 - Add protocol to let applications specify the effective/logical
   surface rectangle, that is, the edge of the window, ignoring drop
   shadows and other padding.  The compositor needs this for snapping
   and constraining window motion.  Also, maybe communicate the opaque
   region of the window (or just a conservative, simple estimate), to
   let the compositor reduce overdraw.

 - multi gpu, needs queue and seqno to wait on in requests

Clients and ports

 - port gtk+

    - draw window decorations in gtkwindow.c

    - Details about pointer grabs. wayland doesn't have active grabs,
      menus will behave subtly different.  Under X, clicking a menu
      open grabs the pointer and clicking outside the window pops down
      the menu and swallows the click.  without active grabs we can't
      swallow the click.  I'm sure there much more...

 - Port Qt?  There's already talk about this on the list.

 - X on Wayland

    - move most of the code from xf86-video-intel into a Xorg wayland
      module.

    - don't ask KMS for available output and modes, use the info from
      the wayland server.  then stop mooching off of drmmode.c.

    - map multiple wayland input devices to MPX in Xorg.

    - rootless; avoid allocating and setting the front buffer, draw
      window decorations in the X server (!), how to map input?

 - gnome-shell as a wayland session compositor

    - runs as a client of the wayland session compositor, uses
      clutter+egl on wayland

    - talks to an Xorg server as the compositing and window manager
      for that server and renders the output to a wayland surface.
      the Xorg server should be modified to take input from the system
      compositor through gnome-shell, but not allocate a front buffer.

    - make gnome-shell itself a nested wayland server and allow native
      wayland clients to connect and can native wayland windows with
      the windows from the X server.

 - qemu as a wayland client; session surface as X case

    - qemu has too simple acceleration, so a Wayland backend like the
      SDL/VNC ones it has now is trivial.

    - paravirt: forward wayland screen info as mmio, expose gem ioctls as mmio

    - mapping vmem is tricky, should try to only use ioctl (pwrite+pread)

    - not useful for Windows without a windows paravirt driver.

    - two approaches: 1) do a toplevel qemu window, or 2) expose a
      wayland server in the guest that forwards to the host wayland
      server, ie a "remote" compositor, but with the gem buffers
      shared.  could do a wl_connection directly on mmio memory, with
      head and tail pointers.  use an alloc_head register to indicate
      desired data to write, if it overwrites tail, block guest.  just
      a socket would be easier.

 - moblin as a wayland compositor

    - clutter as a wayland compositors

    - argh, mutter