all: add linux support

Author: changkun

.github/workflows/clipboard.yml

@@ -0,0 +1,33 @@
+name: clipboard
+
+on:
+  push:
+    branches: [ main ]
+  pull_request:
+    branches: [ main ]
+
+jobs:
+  platform_test:
+
+    runs-on: ${{ matrix.os }}
+    strategy:
+      fail-fast: false
+      matrix:
+        os: [ubuntu-latest, windows-latest, macos-latest]
+
+    steps:
+    - name: install libx11-dev
+      run: |
+        sudo apt install -y libx11-dev
+      if: ${{ runner.os == 'Linux' }}
+    - uses: actions/checkout@v2
+    - uses: actions/setup-go@v2
+      with:
+        stable: 'false'
+        go-version: '1.16.0-rc1'
+
+    - name: test
+      run: |
+        go test -v -covermode=atomic ./...
+      # FIXME: on Linux, the action environment failed to use XOpenDisplay successfully.
+      if: ${{ runner.os != 'Linux' }}

Makefile

@@ -0,0 +1,8 @@
+# Copyright 2021 The golang.design Initiative authors.
+# All rights reserved. Use of this source code is governed
+# by a GNU GPL-3 license that can be found in the LICENSE file.
+#
+# Written by Changkun Ou <changkun.de>
+
+all:
+	go test -v -count=1 -covermode=atomic ./...

README.md

@@ -1,2 +1,32 @@
-# clipboard
+# clipboard [![PkgGoDev](https://pkg.go.dev/badge/golang.design/x/clipboard)](https://pkg.go.dev/golang.design/x/clipboard) ![](https://changkun.de/urlstat?mode=github&repo=golang-design/clipboard) ![clipboard](https://github.com/golang-design/clipboard/workflows/clipboard/badge.svg?branch=main)
+
 clipboard access with Go
+
+```go
+import "golang.design/x/clipboard"
+```
+
+## Dependency
+
+- Linux users: `apt install -y libx11-dev`
+- macOS users: no dependency
+
+## Usage
+
+```go
+// write texts to the clipboard
+clipboard.Write(clipboard.MIMEText, []byte("text data"))
+
+// read texts from the clipboard
+clipboard.Read(clipboard.MIMEText)
+
+// write image to the clipboard, assume image bytes are png encoded.
+clipboard.Write(clipboard.MIMEImage, []byte("image data"))
+
+// read image from the clipboard
+clipboard.Read(clipboard.MIMEImage)
+```
+
+## License
+
+GNU GPL-3 Copyright © 2021 The golang.design Initiative Authors, written by [Changkun Ou](https://changkun.de).

clipboard.go

@@ -0,0 +1,46 @@
+// Copyright 2021 The golang.design Initiative authors.
+// All rights reserved. Use of this source code is governed
+// by a GNU GPL-3 license that can be found in the LICENSE file.
+//
+// Written by Changkun Ou <changkun.de>
+
+package clipboard // import "golang.design/x/clipboard"
+
+import (
+	"sync"
+)
+
+// MIMEType represents the MIME type of clipboard data.
+type MIMEType int
+
+// All sorts of supported clipboard data
+const (
+	// MIMEText indicates plain text MIME format
+	MIMEText MIMEType = iota
+	// MIMEImage indicates image/png MIME format
+	MIMEImage
+)
+
+// Due to the limitation on operating systems (such as darwin),
+// concurrent read can even cause panic, use a global lock to
+// guarantee one read at a time.
+var lock = sync.Mutex{}
+
+// Read reads and returns the clipboard data.
+func Read(t MIMEType) []byte {
+	lock.Lock()
+	defer lock.Unlock()
+
+	return read(t)
+}
+
+// Write writes the given buffer to the clipboard.
+//
+// If the MIME type indicates an image, then the given buf assumes
+// the image data is PNG encoded.
+func Write(t MIMEType, buf []byte) {
+	lock.Lock()
+	defer lock.Unlock()
+
+	write(t, buf)
+}

clipboard_darwin.go

@@ -0,0 +1,17 @@
+// Copyright 2021 The golang.design Initiative authors.
+// All rights reserved. Use of this source code is governed
+// by a GNU GPL-3 license that can be found in the LICENSE file.
+//
+// Written by Changkun Ou <changkun.de>
+
+// +build !linux,darwin
+
+package clipboard
+
+func readAll() (buf []byte) {
+	panic("unsupported")
+}
+
+func writeAll(buf []byte) {
+	panic("unsupported")
+}

clipboard_linux.c

@@ -0,0 +1,169 @@
+// Copyright 2021 The golang.design Initiative authors.
+// All rights reserved. Use of this source code is governed
+// by a GNU GPL-3 license that can be found in the LICENSE file.
+//
+// Written by Changkun Ou <changkun.de>
+
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+#include <X11/Xlib.h>
+#include <X11/Xatom.h>
+
+int clipboard_test() {
+    Display *d = XOpenDisplay(0);
+    if (d == NULL) {
+        return -1;
+    }
+    XCloseDisplay(d);
+    return 0;
+}
+
+// clipboard_write writes the given buf of size n as type typ.
+// if start is provided, the value of start will be changed to 1 to indicate
+// if the write is availiable for reading.
+int clipboard_write(char *typ, unsigned char *buf, size_t n, int *start) {
+    Display* d = XOpenDisplay(0);
+    if (d == NULL) {
+        if (start != NULL && *start == 0) *start = -1;
+        return -1;
+    }
+
+    Window w = XCreateSimpleWindow(d, DefaultRootWindow(d), 0, 0, 1, 1, 0, 0, 0);
+    Atom sel         = XInternAtom(d, "CLIPBOARD", True);
+    Atom atomString  = XInternAtom(d, "UTF8_STRING", True);
+    Atom atomImage   = XInternAtom(d, "image/png", True);
+    Atom targetsAtom = XInternAtom(d, "TARGETS", True);
+
+    Atom target = XInternAtom(d, typ, True);
+    if (target == None) {
+        XCloseDisplay(d);
+        if (start != NULL && *start == 0) *start = -2;
+        return -2;
+    }
+
+    XSetSelectionOwner(d, sel, w, CurrentTime);
+    if (XGetSelectionOwner(d, sel) != w) {
+        XCloseDisplay(d);
+        if (start != NULL && *start == 0) *start = -3;
+        return -3;
+    }
+
+    XEvent event;
+    XSelectionRequestEvent* xsr;
+    for (;;) {
+        // FIXME: this should race with the code on the Go side, start
+        // should use an atomic version, and use atomic_store.
+        if (start != NULL && *start == 0) 
+            *start = 1; // notify Go side
+
+        XNextEvent(d, &event);
+        switch (event.type) {
+        case SelectionClear:
+            // For debugging:
+            // printf("x11write: lost ownership of clipboard selection.\n");
+            // fflush(stdout);
+            XCloseDisplay(d);
+            return 0;
+        case SelectionNotify:
+            // For debugging:
+            // printf("x11write: notify.\n");
+            // fflush(stdout);
+            break;
+        case SelectionRequest:
+            if (event.xselectionrequest.selection != sel) {
+                break;
+            }
+
+            XSelectionRequestEvent * xsr = &event.xselectionrequest;
+            XSelectionEvent ev = {0};
+            int R = 0;
+
+            ev.type      = SelectionNotify;
+            ev.display   = xsr->display;
+            ev.requestor = xsr->requestor;
+            ev.selection = xsr->selection;
+            ev.time      = xsr->time;
+            ev.target    = xsr->target;
+            ev.property  = xsr->property;
+
+            if (ev.target == atomString && ev.target == target) {
+                R = XChangeProperty(ev.display, ev.requestor, ev.property, 
+                    atomString, 8, PropModeReplace, buf, n);
+            } else if (ev.target == atomImage && ev.target == target) {
+                R = XChangeProperty(ev.display, ev.requestor, ev.property,
+                    atomImage, 8, PropModeReplace, buf, n);
+            } else if (ev.target == targetsAtom) {
+                // Reply atoms for supported targets, other clients should
+                // request the clipboard again and obtain the data if their
+                // implementation is correct.
+                Atom targets[] = { atomString, atomImage };
+                R = XChangeProperty(ev.display, ev.requestor, ev.property,
+                    XA_ATOM, 32, PropModeReplace,
+                    (unsigned char *)&targets, sizeof(targets)/sizeof(Atom));
+            } else {
+                ev.property = None;
+            }
+
+            if ((R & 2) == 0) XSendEvent(d, ev.requestor, 0, 0, (XEvent *)&ev);
+            break;
+        }
+    }
+}
+
+// read_data reads the property of a selection if the target atom matches
+// the actual atom.
+unsigned long read_data(XSelectionEvent *sev, Atom sel, Atom prop, Atom target, char **buf) {
+    unsigned char *data;
+    Atom actual;
+    int format;
+    unsigned long n    = 0;
+    unsigned long size = 0;
+    if (sev->property == None || sev->selection != sel || sev->property != prop) {
+        return 0;
+    }
+
+    int ret = XGetWindowProperty(sev->display, sev->requestor, sev->property,
+        0L, (~0L), 0, AnyPropertyType, &actual, &format, &size, &n, &data);
+    if (ret != Success) {
+        return 0;
+    }
+
+    if (actual == target && buf != NULL) {
+        *buf = (char *)malloc(size * sizeof(char));
+        memcpy(*buf, data, size*sizeof(char));
+    }
+    XFree(data);
+    XDeleteProperty(sev->display, sev->requestor, sev->property);
+    return size * sizeof(char);
+}
+
+// clipboard_read reads the clipboard selection in given mime type typ.
+// the readed bytes is written into buf and returns the size of the buffer.
+//
+// The caller of this function should responsible for the free of the buf.
+unsigned long clipboard_read(char* typ, char **buf) {
+    Display *d = XOpenDisplay(0);
+    if (d == NULL) {
+        return -1;
+    }
+
+    Window w = XCreateSimpleWindow(d, DefaultRootWindow(d), 0, 0, 1, 1, 0, 0, 0);
+	Atom sele  = XInternAtom(d, "CLIPBOARD", True);
+	Atom prop = XInternAtom(d, "GOLANG_DESIGN_DATA", False);
+    Atom target = XInternAtom(d, typ, True);
+    if (target == None) {
+        XCloseDisplay(d);
+        return -1;
+    }
+    XConvertSelection(d, sele, target, prop, w, CurrentTime);
+    XEvent event;
+    for (;;) {
+        XNextEvent(d, &event);
+        if (event.type != SelectionNotify) continue;
+        break;
+    }
+    unsigned long n = read_data((XSelectionEvent *)&event.xselection, sele, prop, target, buf);
+    XCloseDisplay(d);
+    return n;
+}