>>>>> crankypuss <noe...@noemail.invalid> writes:
>>>>> On 02/24/2013 04:10 AM, Ivan Shmakov wrote:
>> [Cross-posting to news:comp.windows.x, for this discussion is hardly
>> specific to its GNU/Linux implementations.]
> I'm unfamiliar with the purview of comp.windows.x but I am assuming
> that it is for discussion of X Windows,
It's "X window." No trailing "s".
> rather than MS-Windows.
LIST NEWSGROUPS reads:
comp.windows.misc Various issues about windowing systems.
...
comp.windows.x Discussion about the X Window System.
> After reading your later response, and giving the matter some
> additional thought because of the issues you brought up, I think that
> it may very well be a linux-specific topic rather than anything
> really relevant to X Windows.
Reading your message, I don't think the issue is all that
relevant to GNU/Linux, either. Perhaps news:comp.terminals
would be a better fit.
[...]
> What I am suggesting is basically the interposition of a thin-client
> layer between the hardware and the X Server, which would support a
> character-mode interface to the pixel-capable screen for application
> use, and, within that screen, allocate windows which could be used by
> X.
> This thin-client layer could also provide access to the server
> operating within the same physical housing, such things as killing
> runaway processes or even configuration functions.
I do not understand this point. Why not to use separate
utilities for these tasks? (As it's currently done.)
> And it could do it *without* the need to translate application output
> into arcane character sequences defined by "terminal" hardware
> obsoleted decades ago and then deciphering it in order to perform
> simple display functions.
Whenever one has a subsystem and an application which needs to
interface it, there /is/ a choice. The two may communicate via
series of "function calls" (which may require that the subsystem
is really just a library, running in the very same address space
as the application itself.) Or, the two may communicate by
passing around "messages" (which are, for the most part, memory
buffers annotated with length.) Or, there may be a stream,
which is either composed of "octets", or "ASCII codes." (Which
is a kind of "subset" of an octet stream. Then, either stream
may carry serialized "messages", too, but it isn't necessary.)
As it is, AIUI, X uses an octet stream (and "messages" on top of
that), while the text terminal interface uses an "ASCII code"
stream.
The crux of the things, however, is that there /must/ be an
encoding. (And once the goal is set to provide a way to run the
application over a network connection, this encoding should be
"compatible" with octet streams.)
Above, you show your dissatisfaction of having to "translate
application output into arcane character sequences ..." But the
truth is that, one way or another, the machine only understands
numbers (and octet streams are only capable of delivering
octets.) So, irrespective of the goals, the application would
/have/ to describe its intent in numbers.
For instance, there's /no way/ for application to command "set
the cursor at 3, 7": not until there's defined a some
combination of numbers for this command (like: 13 3 7.) So, the
only real issue you're having is that you dislike the particular
set of numbers set for that action (as in: 27 91 51 59 55 72.)
Which doesn't seem all that reasonable.
It's entirely the same for the keyboard (and pointer) input:
there's a particular encoding to choose. To my mind, ASCII is
quite a sensible choice. I understand that the "classic" PC
keyboards offer three (NB!) more "scan-code" encodings to choose
from (I don't know if the USB keyboards allow for either, or
all, of them, or provide yet another one), but would this really
be a sensible choice to use a particular piece of hardware as a
"reference" for such a protocol? Wouldn't we then need to use
an emulation once we move to some different hardware?
Also, you say "... defined by 'terminal' hardware obsoleted
decades ago." Yet again, the truth is, whatever hardware one'd
choose to model the interface after is going to be "obsoleted
decades ago" a few, well, decades from now. Wouldn't that mean
that every single application created for that particular
interface would have to be abandoned, and the whole decades-long
effort to be started from scratch?