Start X11 and web frontends for xC
For this, we needed a wire protocol. After surveying available options,
it was decided to implement an XDR-like protocol code generator
in portable AWK. It now has two backends, per each of:
- xF, the X11 frontend, is in C, and is meant to be the primary
user interface in the future.
- xP, the web frontend, relies on a protocol proxy written in Go,
and is meant for use on-the-go (no pun intended).
They are very much work-in-progress proofs of concept right now,
and the relay protocol is certain to change.
2022-08-08 04:39:20 +02:00
|
|
|
body {
|
|
|
|
margin: 0;
|
|
|
|
padding: 0;
|
|
|
|
font-family: sans-serif;
|
2022-09-08 15:53:29 +02:00
|
|
|
font-size: clamp(0.5rem, 2vw, 1rem);
|
Start X11 and web frontends for xC
For this, we needed a wire protocol. After surveying available options,
it was decided to implement an XDR-like protocol code generator
in portable AWK. It now has two backends, per each of:
- xF, the X11 frontend, is in C, and is meant to be the primary
user interface in the future.
- xP, the web frontend, relies on a protocol proxy written in Go,
and is meant for use on-the-go (no pun intended).
They are very much work-in-progress proofs of concept right now,
and the relay protocol is certain to change.
2022-08-08 04:39:20 +02:00
|
|
|
}
|
|
|
|
.xP {
|
|
|
|
display: flex;
|
|
|
|
flex-direction: column;
|
|
|
|
overflow: hidden;
|
2022-09-08 15:53:29 +02:00
|
|
|
height: 100vh;
|
|
|
|
/* https://caniuse.com/viewport-unit-variants */
|
|
|
|
height: 100dvh;
|
Start X11 and web frontends for xC
For this, we needed a wire protocol. After surveying available options,
it was decided to implement an XDR-like protocol code generator
in portable AWK. It now has two backends, per each of:
- xF, the X11 frontend, is in C, and is meant to be the primary
user interface in the future.
- xP, the web frontend, relies on a protocol proxy written in Go,
and is meant for use on-the-go (no pun intended).
They are very much work-in-progress proofs of concept right now,
and the relay protocol is certain to change.
2022-08-08 04:39:20 +02:00
|
|
|
}
|
|
|
|
|
2022-09-16 03:18:53 +02:00
|
|
|
.overlay {
|
|
|
|
padding: .6em .9em;
|
|
|
|
background: #eee;
|
|
|
|
border: 1px outset #eee;
|
|
|
|
position: absolute;
|
|
|
|
left: 50%;
|
|
|
|
top: 50%;
|
|
|
|
transform: translate(-50%, -50%);
|
|
|
|
text-align: center;
|
|
|
|
}
|
Start X11 and web frontends for xC
For this, we needed a wire protocol. After surveying available options,
it was decided to implement an XDR-like protocol code generator
in portable AWK. It now has two backends, per each of:
- xF, the X11 frontend, is in C, and is meant to be the primary
user interface in the future.
- xP, the web frontend, relies on a protocol proxy written in Go,
and is meant for use on-the-go (no pun intended).
They are very much work-in-progress proofs of concept right now,
and the relay protocol is certain to change.
2022-08-08 04:39:20 +02:00
|
|
|
.title, .status {
|
2022-09-08 15:53:29 +02:00
|
|
|
padding: .05em .3em;
|
2022-09-07 17:25:31 +02:00
|
|
|
background: #eee;
|
|
|
|
|
2022-09-11 20:46:35 +02:00
|
|
|
display: flex;
|
|
|
|
justify-content: space-between;
|
|
|
|
align-items: baseline;
|
|
|
|
|
2022-09-07 17:25:31 +02:00
|
|
|
position: relative;
|
|
|
|
border-top: 3px solid #ccc;
|
|
|
|
border-bottom: 2px solid #888;
|
|
|
|
}
|
|
|
|
.title:before, .status:before {
|
|
|
|
content: " ";
|
|
|
|
position: absolute;
|
|
|
|
left: 0;
|
|
|
|
right: 0;
|
|
|
|
height: 2px;
|
|
|
|
top: -2px;
|
|
|
|
background: #fff;
|
|
|
|
}
|
|
|
|
.title:after, .status:after {
|
|
|
|
content: " ";
|
|
|
|
position: absolute;
|
|
|
|
left: 0;
|
|
|
|
right: 0;
|
|
|
|
height: 1px;
|
|
|
|
bottom: -1px;
|
|
|
|
background: #ccc;
|
Start X11 and web frontends for xC
For this, we needed a wire protocol. After surveying available options,
it was decided to implement an XDR-like protocol code generator
in portable AWK. It now has two backends, per each of:
- xF, the X11 frontend, is in C, and is meant to be the primary
user interface in the future.
- xP, the web frontend, relies on a protocol proxy written in Go,
and is meant for use on-the-go (no pun intended).
They are very much work-in-progress proofs of concept right now,
and the relay protocol is certain to change.
2022-08-08 04:39:20 +02:00
|
|
|
}
|
2022-09-11 21:30:51 +02:00
|
|
|
button {
|
|
|
|
font: inherit;
|
|
|
|
}
|
Start X11 and web frontends for xC
For this, we needed a wire protocol. After surveying available options,
it was decided to implement an XDR-like protocol code generator
in portable AWK. It now has two backends, per each of:
- xF, the X11 frontend, is in C, and is meant to be the primary
user interface in the future.
- xP, the web frontend, relies on a protocol proxy written in Go,
and is meant for use on-the-go (no pun intended).
They are very much work-in-progress proofs of concept right now,
and the relay protocol is certain to change.
2022-08-08 04:39:20 +02:00
|
|
|
|
|
|
|
.middle {
|
|
|
|
flex: auto;
|
|
|
|
display: flex;
|
|
|
|
flex-direction: row;
|
|
|
|
overflow: hidden;
|
|
|
|
}
|
|
|
|
|
|
|
|
.list {
|
|
|
|
overflow-y: auto;
|
2022-09-13 03:18:12 +02:00
|
|
|
border-right: 2px solid #ccc;
|
2022-09-08 15:53:29 +02:00
|
|
|
min-width: 10em;
|
|
|
|
flex-shrink: 0;
|
Start X11 and web frontends for xC
For this, we needed a wire protocol. After surveying available options,
it was decided to implement an XDR-like protocol code generator
in portable AWK. It now has two backends, per each of:
- xF, the X11 frontend, is in C, and is meant to be the primary
user interface in the future.
- xP, the web frontend, relies on a protocol proxy written in Go,
and is meant for use on-the-go (no pun intended).
They are very much work-in-progress proofs of concept right now,
and the relay protocol is certain to change.
2022-08-08 04:39:20 +02:00
|
|
|
}
|
|
|
|
.item {
|
2022-09-08 15:53:29 +02:00
|
|
|
padding: .05em .3em;
|
Start X11 and web frontends for xC
For this, we needed a wire protocol. After surveying available options,
it was decided to implement an XDR-like protocol code generator
in portable AWK. It now has two backends, per each of:
- xF, the X11 frontend, is in C, and is meant to be the primary
user interface in the future.
- xP, the web frontend, relies on a protocol proxy written in Go,
and is meant for use on-the-go (no pun intended).
They are very much work-in-progress proofs of concept right now,
and the relay protocol is certain to change.
2022-08-08 04:39:20 +02:00
|
|
|
cursor: default;
|
|
|
|
}
|
2022-09-07 19:42:18 +02:00
|
|
|
.item.highlighted {
|
|
|
|
color: #ff5f00;
|
|
|
|
}
|
|
|
|
.item.activity {
|
|
|
|
font-weight: bold;
|
|
|
|
}
|
|
|
|
.item.current {
|
2022-09-07 17:25:31 +02:00
|
|
|
font-style: italic;
|
2022-09-13 03:18:12 +02:00
|
|
|
background: #eee;
|
Start X11 and web frontends for xC
For this, we needed a wire protocol. After surveying available options,
it was decided to implement an XDR-like protocol code generator
in portable AWK. It now has two backends, per each of:
- xF, the X11 frontend, is in C, and is meant to be the primary
user interface in the future.
- xP, the web frontend, relies on a protocol proxy written in Go,
and is meant for use on-the-go (no pun intended).
They are very much work-in-progress proofs of concept right now,
and the relay protocol is certain to change.
2022-08-08 04:39:20 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
/* Only Firefox currently supports align-content: safe end, thus this. */
|
|
|
|
.buffer-container {
|
|
|
|
flex: auto;
|
|
|
|
display: flex;
|
|
|
|
flex-direction: column;
|
|
|
|
overflow: hidden;
|
2022-09-18 05:53:44 +02:00
|
|
|
position: relative;
|
Start X11 and web frontends for xC
For this, we needed a wire protocol. After surveying available options,
it was decided to implement an XDR-like protocol code generator
in portable AWK. It now has two backends, per each of:
- xF, the X11 frontend, is in C, and is meant to be the primary
user interface in the future.
- xP, the web frontend, relies on a protocol proxy written in Go,
and is meant for use on-the-go (no pun intended).
They are very much work-in-progress proofs of concept right now,
and the relay protocol is certain to change.
2022-08-08 04:39:20 +02:00
|
|
|
}
|
|
|
|
.filler {
|
|
|
|
flex: auto;
|
|
|
|
}
|
|
|
|
.buffer {
|
|
|
|
display: grid;
|
2022-09-10 15:39:20 +02:00
|
|
|
grid-template-columns: max-content minmax(0, 1fr);
|
Start X11 and web frontends for xC
For this, we needed a wire protocol. After surveying available options,
it was decided to implement an XDR-like protocol code generator
in portable AWK. It now has two backends, per each of:
- xF, the X11 frontend, is in C, and is meant to be the primary
user interface in the future.
- xP, the web frontend, relies on a protocol proxy written in Go,
and is meant for use on-the-go (no pun intended).
They are very much work-in-progress proofs of concept right now,
and the relay protocol is certain to change.
2022-08-08 04:39:20 +02:00
|
|
|
overflow-y: auto;
|
|
|
|
}
|
2022-09-06 23:37:06 +02:00
|
|
|
.log {
|
|
|
|
font-family: monospace;
|
|
|
|
overflow-y: auto;
|
|
|
|
}
|
2022-09-10 15:39:20 +02:00
|
|
|
.log, .content {
|
|
|
|
padding: .1em .3em;
|
|
|
|
/* Note: https://bugs.chromium.org/p/chromium/issues/detail?id=1261435 */
|
|
|
|
white-space: break-spaces;
|
|
|
|
overflow-wrap: break-word;
|
|
|
|
}
|
Start X11 and web frontends for xC
For this, we needed a wire protocol. After surveying available options,
it was decided to implement an XDR-like protocol code generator
in portable AWK. It now has two backends, per each of:
- xF, the X11 frontend, is in C, and is meant to be the primary
user interface in the future.
- xP, the web frontend, relies on a protocol proxy written in Go,
and is meant for use on-the-go (no pun intended).
They are very much work-in-progress proofs of concept right now,
and the relay protocol is certain to change.
2022-08-08 04:39:20 +02:00
|
|
|
|
2022-09-07 15:33:38 +02:00
|
|
|
.leaked {
|
|
|
|
opacity: 50%;
|
|
|
|
}
|
Start X11 and web frontends for xC
For this, we needed a wire protocol. After surveying available options,
it was decided to implement an XDR-like protocol code generator
in portable AWK. It now has two backends, per each of:
- xF, the X11 frontend, is in C, and is meant to be the primary
user interface in the future.
- xP, the web frontend, relies on a protocol proxy written in Go,
and is meant for use on-the-go (no pun intended).
They are very much work-in-progress proofs of concept right now,
and the relay protocol is certain to change.
2022-08-08 04:39:20 +02:00
|
|
|
.date {
|
2022-09-08 15:53:29 +02:00
|
|
|
padding: .3em;
|
Start X11 and web frontends for xC
For this, we needed a wire protocol. After surveying available options,
it was decided to implement an XDR-like protocol code generator
in portable AWK. It now has two backends, per each of:
- xF, the X11 frontend, is in C, and is meant to be the primary
user interface in the future.
- xP, the web frontend, relies on a protocol proxy written in Go,
and is meant for use on-the-go (no pun intended).
They are very much work-in-progress proofs of concept right now,
and the relay protocol is certain to change.
2022-08-08 04:39:20 +02:00
|
|
|
grid-column: span 2;
|
|
|
|
font-weight: bold;
|
|
|
|
}
|
2022-09-07 19:42:18 +02:00
|
|
|
.unread {
|
|
|
|
grid-column: span 2;
|
2022-09-11 21:30:51 +02:00
|
|
|
border-top: 1px solid #ff5f00;
|
2022-09-07 19:42:18 +02:00
|
|
|
}
|
Start X11 and web frontends for xC
For this, we needed a wire protocol. After surveying available options,
it was decided to implement an XDR-like protocol code generator
in portable AWK. It now has two backends, per each of:
- xF, the X11 frontend, is in C, and is meant to be the primary
user interface in the future.
- xP, the web frontend, relies on a protocol proxy written in Go,
and is meant for use on-the-go (no pun intended).
They are very much work-in-progress proofs of concept right now,
and the relay protocol is certain to change.
2022-08-08 04:39:20 +02:00
|
|
|
.time {
|
2022-09-08 15:53:29 +02:00
|
|
|
padding: .1em .3em;
|
Start X11 and web frontends for xC
For this, we needed a wire protocol. After surveying available options,
it was decided to implement an XDR-like protocol code generator
in portable AWK. It now has two backends, per each of:
- xF, the X11 frontend, is in C, and is meant to be the primary
user interface in the future.
- xP, the web frontend, relies on a protocol proxy written in Go,
and is meant for use on-the-go (no pun intended).
They are very much work-in-progress proofs of concept right now,
and the relay protocol is certain to change.
2022-08-08 04:39:20 +02:00
|
|
|
background: #f8f8f8;
|
|
|
|
color: #bbb;
|
|
|
|
border-right: 1px solid #ccc;
|
|
|
|
}
|
2022-09-11 21:30:51 +02:00
|
|
|
.time.hidden:after {
|
|
|
|
border-top: .2em dotted #ccc;
|
|
|
|
display: block;
|
|
|
|
width: 50%;
|
|
|
|
margin: 0 auto;
|
|
|
|
content: "";
|
|
|
|
}
|
Start X11 and web frontends for xC
For this, we needed a wire protocol. After surveying available options,
it was decided to implement an XDR-like protocol code generator
in portable AWK. It now has two backends, per each of:
- xF, the X11 frontend, is in C, and is meant to be the primary
user interface in the future.
- xP, the web frontend, relies on a protocol proxy written in Go,
and is meant for use on-the-go (no pun intended).
They are very much work-in-progress proofs of concept right now,
and the relay protocol is certain to change.
2022-08-08 04:39:20 +02:00
|
|
|
.mark {
|
2022-09-08 15:53:29 +02:00
|
|
|
padding-right: .3em;
|
Start X11 and web frontends for xC
For this, we needed a wire protocol. After surveying available options,
it was decided to implement an XDR-like protocol code generator
in portable AWK. It now has two backends, per each of:
- xF, the X11 frontend, is in C, and is meant to be the primary
user interface in the future.
- xP, the web frontend, relies on a protocol proxy written in Go,
and is meant for use on-the-go (no pun intended).
They are very much work-in-progress proofs of concept right now,
and the relay protocol is certain to change.
2022-08-08 04:39:20 +02:00
|
|
|
text-align: center;
|
|
|
|
display: inline-block;
|
2022-09-08 15:53:29 +02:00
|
|
|
min-width: 2em;
|
Start X11 and web frontends for xC
For this, we needed a wire protocol. After surveying available options,
it was decided to implement an XDR-like protocol code generator
in portable AWK. It now has two backends, per each of:
- xF, the X11 frontend, is in C, and is meant to be the primary
user interface in the future.
- xP, the web frontend, relies on a protocol proxy written in Go,
and is meant for use on-the-go (no pun intended).
They are very much work-in-progress proofs of concept right now,
and the relay protocol is certain to change.
2022-08-08 04:39:20 +02:00
|
|
|
}
|
|
|
|
.mark.error {
|
|
|
|
color: red;
|
|
|
|
}
|
|
|
|
.mark.join {
|
|
|
|
color: green;
|
|
|
|
}
|
|
|
|
.mark.part {
|
|
|
|
color: red;
|
|
|
|
}
|
2022-09-05 22:53:34 +02:00
|
|
|
.mark.action {
|
|
|
|
color: darkred;
|
|
|
|
}
|
2022-09-06 14:35:42 +02:00
|
|
|
.content .b {
|
Start X11 and web frontends for xC
For this, we needed a wire protocol. After surveying available options,
it was decided to implement an XDR-like protocol code generator
in portable AWK. It now has two backends, per each of:
- xF, the X11 frontend, is in C, and is meant to be the primary
user interface in the future.
- xP, the web frontend, relies on a protocol proxy written in Go,
and is meant for use on-the-go (no pun intended).
They are very much work-in-progress proofs of concept right now,
and the relay protocol is certain to change.
2022-08-08 04:39:20 +02:00
|
|
|
font-weight: bold;
|
|
|
|
}
|
2022-09-06 14:35:42 +02:00
|
|
|
.content .i {
|
Start X11 and web frontends for xC
For this, we needed a wire protocol. After surveying available options,
it was decided to implement an XDR-like protocol code generator
in portable AWK. It now has two backends, per each of:
- xF, the X11 frontend, is in C, and is meant to be the primary
user interface in the future.
- xP, the web frontend, relies on a protocol proxy written in Go,
and is meant for use on-the-go (no pun intended).
They are very much work-in-progress proofs of concept right now,
and the relay protocol is certain to change.
2022-08-08 04:39:20 +02:00
|
|
|
font-style: italic;
|
|
|
|
}
|
2022-09-06 14:35:42 +02:00
|
|
|
.content .u {
|
Start X11 and web frontends for xC
For this, we needed a wire protocol. After surveying available options,
it was decided to implement an XDR-like protocol code generator
in portable AWK. It now has two backends, per each of:
- xF, the X11 frontend, is in C, and is meant to be the primary
user interface in the future.
- xP, the web frontend, relies on a protocol proxy written in Go,
and is meant for use on-the-go (no pun intended).
They are very much work-in-progress proofs of concept right now,
and the relay protocol is certain to change.
2022-08-08 04:39:20 +02:00
|
|
|
text-decoration: underline;
|
|
|
|
}
|
2022-09-06 14:35:42 +02:00
|
|
|
.content .s {
|
Start X11 and web frontends for xC
For this, we needed a wire protocol. After surveying available options,
it was decided to implement an XDR-like protocol code generator
in portable AWK. It now has two backends, per each of:
- xF, the X11 frontend, is in C, and is meant to be the primary
user interface in the future.
- xP, the web frontend, relies on a protocol proxy written in Go,
and is meant for use on-the-go (no pun intended).
They are very much work-in-progress proofs of concept right now,
and the relay protocol is certain to change.
2022-08-08 04:39:20 +02:00
|
|
|
text-decoration: line-through;
|
|
|
|
}
|
2022-09-06 14:35:42 +02:00
|
|
|
.content .m {
|
Start X11 and web frontends for xC
For this, we needed a wire protocol. After surveying available options,
it was decided to implement an XDR-like protocol code generator
in portable AWK. It now has two backends, per each of:
- xF, the X11 frontend, is in C, and is meant to be the primary
user interface in the future.
- xP, the web frontend, relies on a protocol proxy written in Go,
and is meant for use on-the-go (no pun intended).
They are very much work-in-progress proofs of concept right now,
and the relay protocol is certain to change.
2022-08-08 04:39:20 +02:00
|
|
|
font-family: monospace;
|
|
|
|
}
|
|
|
|
|
2022-09-18 05:53:44 +02:00
|
|
|
.completions {
|
|
|
|
position: absolute;
|
|
|
|
left: 0;
|
|
|
|
right: 0;
|
|
|
|
bottom: 0;
|
|
|
|
background: #fff;
|
|
|
|
padding: .05em .3em;
|
|
|
|
border-top: 1px solid #888;
|
|
|
|
|
|
|
|
max-height: 50%;
|
|
|
|
display: flex;
|
|
|
|
flex-flow: column wrap;
|
|
|
|
column-gap: .6em;
|
|
|
|
overflow-x: auto;
|
|
|
|
}
|
2022-09-19 03:16:34 +02:00
|
|
|
.input {
|
|
|
|
flex-shrink: 0;
|
|
|
|
border: 2px inset #eee;
|
|
|
|
overflow: hidden;
|
|
|
|
resize: vertical;
|
|
|
|
display: flex;
|
|
|
|
}
|
|
|
|
.input:focus-within {
|
|
|
|
border-color: #ff5f00;
|
|
|
|
}
|
|
|
|
.prompt {
|
|
|
|
padding: .05em .3em;
|
|
|
|
border-right: 1px solid #ccc;
|
|
|
|
background: #f8f8f8;
|
|
|
|
font-weight: bold;
|
|
|
|
}
|
Start X11 and web frontends for xC
For this, we needed a wire protocol. After surveying available options,
it was decided to implement an XDR-like protocol code generator
in portable AWK. It now has two backends, per each of:
- xF, the X11 frontend, is in C, and is meant to be the primary
user interface in the future.
- xP, the web frontend, relies on a protocol proxy written in Go,
and is meant for use on-the-go (no pun intended).
They are very much work-in-progress proofs of concept right now,
and the relay protocol is certain to change.
2022-08-08 04:39:20 +02:00
|
|
|
textarea {
|
2022-09-07 17:25:31 +02:00
|
|
|
font: inherit;
|
2022-09-08 15:53:29 +02:00
|
|
|
padding: .05em .3em;
|
2022-09-07 17:25:31 +02:00
|
|
|
margin: 0;
|
2022-09-19 03:16:34 +02:00
|
|
|
border: 0;
|
|
|
|
flex-grow: 1;
|
|
|
|
resize: none;
|
2022-09-07 17:25:31 +02:00
|
|
|
}
|
|
|
|
textarea:focus {
|
|
|
|
outline: none;
|
Start X11 and web frontends for xC
For this, we needed a wire protocol. After surveying available options,
it was decided to implement an XDR-like protocol code generator
in portable AWK. It now has two backends, per each of:
- xF, the X11 frontend, is in C, and is meant to be the primary
user interface in the future.
- xP, the web frontend, relies on a protocol proxy written in Go,
and is meant for use on-the-go (no pun intended).
They are very much work-in-progress proofs of concept right now,
and the relay protocol is certain to change.
2022-08-08 04:39:20 +02:00
|
|
|
}
|