dymokomi/luce-clipboard
Source of release 0.7.0
0.7.0 / src / clipboard / linux / service.lucb
#==============================================================================================
#
# service - The X11 clipboard: a connection and a thread of its own
#
# DESCRIPTION:
# On X11 the clipboard is a conversation: a program that copies becomes the owner of
# the CLIPBOARD selection and must answer every request for it for as long as it owns
# it, and a program that pastes asks the owner and waits for its answer. So the
# clipboard keeps its own Xlib connection and hidden window, served by one thread that
# alone touches them: the UI thread hands it a request (read or write) under a lock,
# wakes it through a pipe, and waits for the answer (at most a few seconds). The thread
# meanwhile answers other programs' requests for what this one copied, in one piece or,
# past `incr_chunk` bytes, in INCR steps.
#
#==============================================================================================
## Bytes a property carries at once; more goes in INCR steps.
let incr_chunk: usize = 262144
## How long an owner has to answer a paste before it counts as gone, in nanoseconds.
let answer_ns: u64 = 1500000000
## How long the UI thread waits for the service, in milliseconds.
let request_ms: u64 = 5000
## An INCR transfer of what this program copied, to one requestor.
struct ClipTransfer:
var requestor: u64
var property: u64
var kind: u64
var data: u8[]
var offset: usize
var active: bool
## What the UI thread asked for, and the answer.
let request_none: i32 = 0
let request_read: i32 = 1
let request_write: i32 = 2
struct ClipService:
var xlib: ClipXlib
var display: void*
var window: u64
var wake_read: i32
var wake_write: i32
var clipboard: u64
var targets: u64
var utf8_string: u64
var string: u64
var text: u64
var plain_utf8: u64
var png: u64
var incr: u64
var atom: u64
var landing: u64
# Behind `mutex`: the request and its answer.
var mutex: sync.Mutex
var request: i32
var request_png: bool
var request_data: u8[]
var request_taken: bool
var request_done: bool
var answer: u8[]
var answer_present: bool
var answer_failure: str
# The service thread's own: a paste in progress, what this program owns, transfers.
var reading: bool
var read_png: bool
var read_target: u64
var read_incr: bool
var read_buffer: u8[]
var read_length: usize
var read_deadline: u64
var own_text: u8[]
var own_png: u8[]
var transfers: ClipTransfer[]
var clip_service: ClipService*? = none
## The service, started on first use; the "unavailable" error without X.
func clip_service_get() -> ClipService*!:
if let running = clip_service:
return running
let xlib = try clip_load_xlib()
let display = xlib.open_display(none) else error(window.unsupported, "the desktop clipboard is unavailable: no X display")
let root = xlib.default_root_window(display)
let hidden = xlib.create_simple_window(display, root, 0, 0, 1, 1, 0, 0, 0)
_ = xlib.select_input(display, hidden, x_property_change_mask)
var fds: i32[2] = [0, 0]
if pipe(&fds[0]) != 0:
error(failed, "the clipboard could not make its wake pipe")
let transfers = try new ClipTransfer[4] --- in memory.heap
var none_bytes: u8[]
for index in 0..<transfers.length:
transfers[index] = ClipTransfer(requestor = 0, property = 0, kind = 0, data = none_bytes, offset = 0, active = false)
var mutex: sync.Mutex
let service = try new ClipService(
xlib = xlib, display = display, window = hidden, wake_read = fds[0], wake_write = fds[1],
clipboard = xlib.intern_atom(display, "CLIPBOARD", 0), targets = xlib.intern_atom(display, "TARGETS", 0),
utf8_string = xlib.intern_atom(display, "UTF8_STRING", 0), string = xlib.intern_atom(display, "STRING", 0),
text = xlib.intern_atom(display, "TEXT", 0), plain_utf8 = xlib.intern_atom(display, "text/plain;charset=utf-8", 0),
png = xlib.intern_atom(display, "image/png", 0), incr = xlib.intern_atom(display, "INCR", 0),
atom = xlib.intern_atom(display, "ATOM", 0), landing = xlib.intern_atom(display, "LUCE_CLIPBOARD", 0),
mutex = mutex, request = request_none, request_png = false, request_data = none_bytes, request_taken = false, request_done = false,
answer = none_bytes, answer_present = false, answer_failure = "",
reading = false, read_png = false, read_target = 0, read_incr = false, read_buffer = none_bytes, read_length = 0, read_deadline = 0,
own_text = none_bytes, own_png = none_bytes, transfers = transfers) in memory.heap
_ = xlib.flush(display)
var serving = try thread.spawn(clip_serve, (void*)service, name = "clipboard")
serving.detach()
clip_service = service
return service
## Hand the service a request and wait for its answer: the bytes, or none when
## the clipboard holds nothing of that kind. `data` (a write's) is copied.
func clip_ask(kind: i32, png: bool, data: const u8[]) -> u8[]?!:
let service = try clip_service_get()
var copied: u8[]
if data.length > 0:
copied = try new u8[data.length] --- in memory.heap
memory.copy(copied, data, data.length)
service.mutex.lock()
service.request = kind
service.request_png = png
service.request_data = copied
service.request_taken = false
service.request_done = false
service.answer_present = false
service.answer_failure = ""
service.mutex.unlock()
var byte: u8 = 1
_ = write(service.wake_write, (void*)&byte, 1)
var waited: u64 = 0
while waited < request_ms:
service.mutex.lock()
if service.request_done:
service.request = request_none
let failure = service.answer_failure
let present = service.answer_present
let answer = service.answer
var empty: u8[]
service.answer = empty
service.mutex.unlock()
if failure.length > 0:
if answer.length > 0:
free(answer) in memory.heap
error(failed, failure)
if not present:
return none
return answer
service.mutex.unlock()
thread.sleep(1)
waited += 1
error(failed, "the X11 clipboard did not answer")
# mark: The service thread =====================================================================
func clip_serve(context: void*?):
let service = (ClipService*)(context else return)
let x_fd = service.xlib.connection_number(service.display)
while true:
var fds: ClipPollFd[2] = [ClipPollFd(fd = x_fd, events = 1, revents = 0), ClipPollFd(fd = service.wake_read, events = 1, revents = 0)]
# A paste in progress is timed; otherwise the thread sleeps until something happens.
_ = poll(&fds[0], 2, 20 if service.reading else -1)
if fds[1].revents != 0:
var drained: u8[64]
_ = read(service.wake_read, (void*)&drained[0], 64)
clip_take_request(service)
while service.xlib.pending(service.display) > 0:
var event: ClipEvent = ---
_ = service.xlib.next_event(service.display, (void*)&event)
clip_handle(service, &event)
if service.reading and time.now() > service.read_deadline:
clip_finish_read(service, false, "the program that copied did not answer")
_ = service.xlib.flush(service.display)
## Start the UI thread's request, if one waits.
func clip_take_request(service: ClipService*):
service.mutex.lock()
let kind = service.request
let fresh = kind != request_none and not service.request_taken
if fresh:
service.request_taken = true
let png = service.request_png
let data = service.request_data
var empty: u8[]
service.request_data = empty
service.mutex.unlock()
if not fresh:
return
if kind == request_write:
clip_own(service, png, data)
else:
clip_start_read(service, png)
## Answer the UI thread's request.
func clip_answer(service: ClipService*, present: bool, bytes: u8[], failure: str):
service.mutex.lock()
service.answer = bytes
service.answer_present = present
service.answer_failure = failure
service.request_done = true
service.mutex.unlock()
# mark: Copying: owning the selection ===========================================================
## Take the CLIPBOARD selection with `data` as this program's text or image.
func clip_own(service: ClipService*, png: bool, data: u8[]):
var empty: u8[]
if service.own_text.length > 0:
free(service.own_text) in memory.heap
if service.own_png.length > 0:
free(service.own_png) in memory.heap
service.own_text = empty if png else data
service.own_png = data if png else empty
_ = service.xlib.set_selection_owner(service.display, service.clipboard, service.window, 0)
if service.xlib.get_selection_owner(service.display, service.clipboard) != service.window:
clip_answer(service, false, empty, "the X11 clipboard could not be taken")
return
clip_answer(service, true, empty, "")
## What this program answers for `target`, and the type it goes as; none when
## it does not offer that target.
func clip_offer(service: ClipService*, target: u64, kind: u64*) -> u8[]?:
if service.own_png.length > 0:
if target == service.png:
*kind = service.png
return service.own_png
return none
if service.own_text.length == 0:
return none
if target == service.utf8_string or target == service.plain_utf8 or target == service.text:
*kind = service.utf8_string
return service.own_text
if target == service.string:
*kind = service.string
return service.own_text
return none
## Another program asks for what this one copied.
func clip_request_from(service: ClipService*, request: const ClipSelectionRequest*):
var property = request.property if request.property != 0 else request.target
let xlib = service.xlib
if request.selection != service.clipboard or request.owner != service.window:
property = 0
elif request.target == service.targets:
# The targets offered, as ATOMs (Xlib takes format 32 as longs).
var offered: u64[5] = [service.targets, 0, 0, 0, 0]
var count: i32 = 1
if service.own_png.length > 0:
offered[1] = service.png
count = 2
elif service.own_text.length > 0:
offered[1] = service.utf8_string
offered[2] = service.plain_utf8
offered[3] = service.string
offered[4] = service.text
count = 5
_ = xlib.change_property(service.display, request.requestor, property, service.atom, 32, x_prop_mode_replace, (const u8*)&offered[0], count)
else:
var kind: u64 = 0
if let offered = clip_offer(service, request.target, &kind):
if kind == service.string:
clip_send_latin1(service, request.requestor, property, offered)
elif offered.length > incr_chunk:
clip_begin_incr(service, request.requestor, property, kind, offered)
else:
_ = xlib.change_property(service.display, request.requestor, property, kind, 8, x_prop_mode_replace, offered.data, (i32)offered.length)
else:
property = 0
var notify = ClipSelectionNotify(kind = x_selection_notify, serial = 0, send_event = 1, display = service.display, requestor = request.requestor,
selection = request.selection, target = request.target, property = property, time = request.time)
_ = xlib.send_event(service.display, request.requestor, 0, 0, (void*)¬ify)
## STRING is Latin-1: the text, with what Latin-1 lacks as `?`.
func clip_send_latin1(service: ClipService*, requestor: u64, property: u64, text: const u8[]):
let latin = new u8[text.length] --- in memory.heap catch failure:
_ = failure
return
defer free(latin) in memory.heap
let length = utf8_to_latin1(text, latin)
_ = service.xlib.change_property(service.display, requestor, property, service.string, 8, x_prop_mode_replace, latin.data, (i32)length)
## Offer `data` in INCR steps: its size now, a piece each time the requestor
## deletes the property, then an empty piece.
func clip_begin_incr(service: ClipService*, requestor: u64, property: u64, kind: u64, data: const u8[]):
for index in 0..<service.transfers.length:
if service.transfers[index].active:
continue
let copied = new u8[data.length] --- in memory.heap catch failure:
_ = failure
return
memory.copy(copied, data, data.length)
service.transfers[index] = ClipTransfer(requestor = requestor, property = property, kind = kind, data = copied, offset = 0, active = true)
_ = service.xlib.select_input(service.display, requestor, x_property_change_mask)
var size: i64 = (i64)data.length
_ = service.xlib.change_property(service.display, requestor, property, service.incr, 32, x_prop_mode_replace, (const u8*)&size, 1)
return
## The requestor took a piece: send the next, or the empty one that ends it.
func clip_continue_incr(service: ClipService*, property: const ClipPropertyEvent*):
for index in 0..<service.transfers.length:
let transfer = &service.transfers[index]
if not transfer.active or transfer.requestor != property.window or transfer.property != property.atom:
continue
let left = transfer.data.length - transfer.offset
let piece = left if left < incr_chunk else incr_chunk
_ = service.xlib.change_property(service.display, transfer.requestor, transfer.property, transfer.kind, 8, x_prop_mode_replace,
transfer.data.data + transfer.offset, (i32)piece)
transfer.offset += piece
if piece == 0:
_ = service.xlib.select_input(service.display, transfer.requestor, 0)
free(transfer.data) in memory.heap
var empty: u8[]
transfer.data = empty
transfer.active = false
return
# mark: Pasting: asking the owner ===============================================================
## Ask the owner for the clipboard as text or PNG. What this program owns
## itself comes straight back.
func clip_start_read(service: ClipService*, png: bool):
var empty: u8[]
let owner = service.xlib.get_selection_owner(service.display, service.clipboard)
if owner == 0:
clip_answer(service, false, empty, "")
return
if owner == service.window:
let own = service.own_png if png else service.own_text
if own.length == 0:
clip_answer(service, false, empty, "")
return
let copied = new u8[own.length] --- in memory.heap catch failure:
clip_answer(service, false, empty, "clipboard memory ran out")
return
memory.copy(copied, own, own.length)
clip_answer(service, true, copied, "")
return
service.reading = true
service.read_png = png
service.read_incr = false
service.read_length = 0
service.read_target = service.png if png else service.utf8_string
service.read_deadline = time.now() + answer_ns
_ = service.xlib.delete_property(service.display, service.window, service.landing)
_ = service.xlib.convert_selection(service.display, service.clipboard, service.read_target, service.landing, service.window, 0)
## The owner answered (or refused) the target asked for.
func clip_selection_notified(service: ClipService*, notify: const ClipSelectionNotify*):
if not service.reading or notify.requestor != service.window or notify.selection != service.clipboard:
return
if notify.property == 0:
# Refused: text falls back from UTF8_STRING to STRING; nothing else is left to ask.
if not service.read_png and service.read_target == service.utf8_string:
service.read_target = service.string
service.read_deadline = time.now() + answer_ns
_ = service.xlib.convert_selection(service.display, service.clipboard, service.string, service.landing, service.window, 0)
return
clip_finish_read(service, false, "")
return
var kind: u64 = 0
if not clip_take_property(service, &kind):
return
if kind == service.incr:
# The owner sends it in pieces, each announced by a new value of the property.
service.read_incr = true
service.read_length = 0
service.read_deadline = time.now() + answer_ns
return
clip_finish_read(service, true, "")
## A piece of an INCR paste arrived; an empty one ends it.
func clip_property_changed(service: ClipService*, property: const ClipPropertyEvent*):
if property.window == service.window:
if service.reading and service.read_incr and property.atom == service.landing and property.state == x_property_new_value:
let before = service.read_length
var kind: u64 = 0
if not clip_take_property(service, &kind):
return
service.read_deadline = time.now() + answer_ns
if service.read_length == before:
clip_finish_read(service, true, "")
return
if property.state == x_property_delete:
clip_continue_incr(service, property)
## Append the landing property's bytes to the paste, deleting it (which asks an
## INCR owner for the next piece); false when the paste ended in failure.
func clip_take_property(service: ClipService*, kind: u64*) -> bool:
var actual_format: i32 = 0
var items: u64 = 0
var after: u64 = 0
var data: u8*? = none
if service.xlib.get_window_property(service.display, service.window, service.landing, 0, 536870911, 1, 0, kind, &actual_format, &items, &after, &data) != 0:
clip_finish_read(service, false, "the clipboard could not be read")
return false
let bytes = data else return true
defer _ = service.xlib.release((void*)bytes)
if *kind == service.incr:
return true
let sample = (usize)actual_format // 8 if actual_format == 8 or actual_format == 16 else ((usize)8 if actual_format == 32 else 1)
let length = (usize)items * sample
let limit = image_limit if service.read_png else text_limit * 4
if service.read_length + length > limit:
clip_finish_read(service, false, "the clipboard holds more than can be pasted")
return false
if service.read_length + length > service.read_buffer.length:
var capacity = service.read_buffer.length * 2 + 65536
while capacity < service.read_length + length:
capacity *= 2
let grown = new u8[capacity] --- in memory.heap catch failure:
clip_finish_read(service, false, "clipboard memory ran out")
return false
if service.read_length > 0:
memory.copy(grown, service.read_buffer, service.read_length)
if service.read_buffer.length > 0:
free(service.read_buffer) in memory.heap
service.read_buffer = grown
memory.copy(service.read_buffer[service.read_length..<service.read_length + length], u8[](bytes, length), length)
service.read_length += length
return true
## End the paste: the bytes read (as UTF-8 for text), or none, or a failure.
func clip_finish_read(service: ClipService*, present: bool, failure: str):
service.reading = false
var empty: u8[]
if not present or failure.length > 0 or service.read_length == 0:
clip_answer(service, false, empty, failure)
return
let latin = not service.read_png and service.read_target == service.string
let taken = service.read_buffer[..<service.read_length]
let answer = new u8[utf8_length_of_latin1(taken) if latin else taken.length] --- in memory.heap catch problem:
_ = problem
clip_answer(service, false, empty, "clipboard memory ran out")
return
if latin:
_ = latin1_to_utf8(taken, answer)
else:
memory.copy(answer, taken, taken.length)
clip_answer(service, true, answer, "")
## Route an event the connection delivered.
func clip_handle(service: ClipService*, event: ClipEvent*):
let any = (ClipAnyEvent*)event
if any.kind == x_selection_request:
clip_request_from(service, (ClipSelectionRequest*)event)
elif any.kind == x_selection_notify:
clip_selection_notified(service, (ClipSelectionNotify*)event)
elif any.kind == x_property_notify:
clip_property_changed(service, (ClipPropertyEvent*)event)
elif any.kind == x_selection_clear:
let clear = (ClipSelectionClear*)event
if clear.selection == service.clipboard:
# Another program copied: what this one held is no longer offered.
var empty: u8[]
if service.own_text.length > 0:
free(service.own_text) in memory.heap
if service.own_png.length > 0:
free(service.own_png) in memory.heap
service.own_text = empty
service.own_png = empty