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;
|
|
|
|
}
|
|
|
|
.xP {
|
|
|
|
height: 100vh;
|
|
|
|
display: flex;
|
|
|
|
flex-direction: column;
|
|
|
|
overflow: hidden;
|
|
|
|
}
|
|
|
|
|
|
|
|
.title, .status {
|
|
|
|
padding: .05rem .3rem;
|
2022-09-07 17:25:31 +02:00
|
|
|
background: #eee;
|
|
|
|
|
|
|
|
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-06 23:37:06 +02:00
|
|
|
.title {
|
|
|
|
display: flex;
|
|
|
|
justify-content: space-between;
|
2022-09-07 17:25:31 +02:00
|
|
|
align-items: baseline;
|
2022-09-06 23:37:06 +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
|
|
|
|
|
|
|
.middle {
|
|
|
|
flex: auto;
|
|
|
|
display: flex;
|
|
|
|
flex-direction: row;
|
|
|
|
overflow: hidden;
|
|
|
|
}
|
|
|
|
|
|
|
|
.list {
|
|
|
|
overflow-y: auto;
|
|
|
|
border-right: 1px solid #ccc;
|
|
|
|
min-width: 10rem;
|
|
|
|
}
|
|
|
|
.item {
|
|
|
|
padding: .05rem .3rem;
|
|
|
|
cursor: default;
|
|
|
|
}
|
|
|
|
.item.active {
|
2022-09-07 17:25:31 +02:00
|
|
|
font-style: italic;
|
|
|
|
background: #f8f8f8;
|
|
|
|
border-top: 1px solid #eee;
|
|
|
|
border-bottom: 1px solid #eee;
|
|
|
|
margin-top: -1px;
|
|
|
|
margin-bottom: -1px;
|
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;
|
|
|
|
}
|
|
|
|
.filler {
|
|
|
|
flex: auto;
|
|
|
|
}
|
|
|
|
.buffer {
|
|
|
|
display: grid;
|
|
|
|
grid-template-columns: max-content auto;
|
|
|
|
overflow-y: auto;
|
|
|
|
}
|
2022-09-06 23:37:06 +02:00
|
|
|
.log {
|
|
|
|
padding: .1rem .3rem;
|
|
|
|
font-family: monospace;
|
|
|
|
white-space: pre-wrap;
|
|
|
|
overflow-y: auto;
|
|
|
|
}
|
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 {
|
|
|
|
padding: .3rem;
|
|
|
|
grid-column: span 2;
|
|
|
|
font-weight: bold;
|
|
|
|
}
|
|
|
|
.time {
|
|
|
|
padding: .1rem .3rem;
|
|
|
|
background: #f8f8f8;
|
|
|
|
color: #bbb;
|
|
|
|
border-right: 1px solid #ccc;
|
|
|
|
}
|
|
|
|
.mark {
|
|
|
|
padding-right: .3rem;
|
|
|
|
text-align: center;
|
|
|
|
display: inline-block;
|
|
|
|
min-width: 2rem;
|
|
|
|
}
|
|
|
|
.mark.error {
|
|
|
|
color: red;
|
|
|
|
}
|
|
|
|
.mark.join {
|
|
|
|
color: green;
|
|
|
|
}
|
|
|
|
.mark.part {
|
|
|
|
color: red;
|
|
|
|
}
|
2022-09-05 22:53:34 +02:00
|
|
|
.mark.action {
|
|
|
|
color: darkred;
|
|
|
|
}
|
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
|
|
|
.content {
|
|
|
|
padding: .1rem .3rem;
|
|
|
|
white-space: pre-wrap;
|
|
|
|
}
|
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;
|
|
|
|
}
|
|
|
|
|
|
|
|
textarea {
|
2022-09-07 17:25:31 +02:00
|
|
|
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
|
|
|
padding: .05rem .3rem;
|
2022-09-07 17:25:31 +02:00
|
|
|
margin: 0;
|
|
|
|
border: 2px inset #eee;
|
|
|
|
flex-shrink: 0;
|
|
|
|
}
|
|
|
|
textarea:focus {
|
|
|
|
outline: none;
|
|
|
|
border-color: #ff5f00;
|
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
|
|
|
}
|