Add a NOTE on 19th-century pixel fonts

Explicitly set font-weight to 500 in CSS

Bedstead's standard weight is 500, reflecting the fact that it's
naturally quite heavy.  CSS defaults to 400, so we were depending on
CSS's font-matching rules to fall back from 400 to 500.  That's fine
at the moment, where there is no 400-weight version.  But Bedstead
could be made lighter, and indeed the code to do it already exists.
And I hope that somewhere in the future is a variable Bedstead that
might allow for lighter weights.  So for future-proofing I think the
CSS should specify the weight that it actually wants.  Obviously I can
update my CSS if I ever introduce a 400 weight, but other people might
reasonably use my CSS as an example and I shouldn't lead them into
trouble.

Tolerable rendering of variation sequences in glyph complement

I think I probably want a nice way to write "<= 0x10ffff" though.

Horizontal square brackets

I was looking for something completely different in the Unicode
Standard and found a note that U+23B4..U+23B6 can be used in terminal
applications with text printed vertically.  So obviously I had to add
them.

Apparently the same doesn't apply to the other horizontal brackets at
U+23DC..U+32E1, which are purely stretchy mathematical brackets and
not interesting to us.

The odd positioning in the character cell is based on the Unicode code
chart.

Emit a format-14 'cmap' subtable for variation sequences

Now I can put <U+0030, U+FE00> in an HTML file and Firefox will pick the
correct glyphs.

Beginnings of support for Unicode variation selectors

These are treated as particularly odd Unicode code points and packed
into the "unicode" field.  Currently only the encoding side is
implemented, withe the slashed zero, <U+0030, U+FE00>, as a motivating
example.

Generating a format 14 'cmap' subtable and properly formatting the
glyph complement are still to come.

Add support for 'zero' (slashed zero) feature

This re-uses the old Oslash glyph I drew that had the slash entirely
inside the O.  I've seen something similar on simulations of old
character generators, though I'm not sure I've seen any actual character
generators using this shape.

Switch to unsigned types for holding Unicode code points

We were only using negative numbers for the "no Unicode mapping"
constant, and even there it was mostly cast to unsigned before we used
it (because it needed to sort last).  So just using an unsigned type
throughout seems to be a bit cleaner.  It will also make me less dubious
about packing extra information in when I want to support variation
selectors.

Use a defined constant instead of -1 for "no Unicode mapping"

Partly on the principle that magic numbers should be avoided, but
mostly because I want to change it.

Use "unsigned long" when we need an unsigned Unicode type

On 16-bit systems, "unsigned int" won't get us beyond the Basic
Multilingual Plane.

Replace bare "unsigned" as a type name with "unsigned int"

I noticed some occasions where my attempts at 16-bit cleanliness had
failed because I hadn't noticed that "unsigned" was a species of "int"
and hence potentially only 16 bits.  So now I'm trying to be more
explicit and saying "unsigned int".

Next several of them will need to be replaced with something else.

Correct formatting of a comment

Reduce MAXPOINTS a little

whitepixel() now generates at most 16 points per pixel, not 20.

Add assertions that we don't overflow the "points" array

Remove a couple of spaces that just annoyed me

Allow space for terminating null in struct glyph.data

GCC 15 gives a warning (-Wunterminated-string-initialization) if you
initialize an unsigned char array from a string constant such that the
terminating null character isn't included.  Bedstead does this in most
rows of the glyphs array, which is quite noisy.  I've chosen to work
around this by making the array one byte larger.  That doesn't
actually affect the size of the struct on systems that align struct
fields, so the major loss is that now we might not get warnings if we
overflow by one byte.

There are several other ways this problem could be solved.  One could
disable the warning entirely, but that would remove a valuable warning
from the rest of the program.  We currently disable two other warnings
for the sake of the glyphs array, but working around them would
require ugly changes on every line of the array.

Probably the ideal approach would be to tag the "data" field with
"[[gnu::nonstring]]".  That would not only suppress the warning but
also enable warnings if the array was ever passed to a function
expecting a null-terminated string.  However, I think Bedstead is
currently written in plain ISO C99, while attributes like that were
only standardised in C23.  I'm not averse to moving to a newer
standard, but C23 is a but _too_ new right now.  I'm also a little
reluctant to rely on the implementation-defined behaviour of
particular compilers, which is why I'm not using "#pragma GCC
diagnostic".

Remove "copyright" notice that isn't

I don't think it's appropriate to use 'name' string 0 (copyright
notice) for something that isn't a copyright notice.  Perhaps I should
have something other than a URL that explains Bedstead's copyright
situation, but that field isn't it.

A few more 'name' strings

We now have a manufacturer, vendor URL, licensing URL, and sample text.
I've added an anchor to the Web page so to make the licensing URL more
useful.

Most of these are displayed by Firefox when listing the fonts used on a
page, so they seem like a good idea.

Use "rem" to set the base font size in CSS

This means that the font size will vary based on the user's selected
default font size even in the absence of zooming.

Add stylesheet to plain text files in .htaccess

It turns out that Firefox (version 140 at least) will happily use an
HTTP Link header for a CSS stylesheet on a plain text file.  It works
a bit weirdly because it applies the stylesheet to the HTML conversion
of the file, but that actually means that the existing bedstead.css
works pretty well.

This doesn't work on Chromium, but that's no worse than what we've
already got.

Add JavaScript and WASM to compressible file types in .htaccess

webstead: remove "test" from page title

webstead: use .mjs for JavaSript module

This means that emcc automatically uses the correct mode, and seems
slightly more correct to me.

webstead: slightly more robust invocation of bedstead

Now we don't assume that stdout is line-buffered and that we'll
therefore get a single call to print().  Instead, we collect up all
the output in a string and use it when the program exits.

webstead: add some instructions

webstead: click handler for output side

It's kind of ugly because there's no :active, but I can't see a nice
way to fake that.

webstead: style for #pixels input:focus-visible

The usual focus ring in Firefox and Chromium appears at the same
stacking level as the element it's attached to.  This means that it's
hidden by elements after it in the document, including pixels below it
and to its right.  Fiddling with the z-index of the focussed pixel
helps with this.

webstead: add page icon

webstead: support arrow keys for navigation

More restrictive content security policy for Web site

webstead: visual distinction for input:checked:active too

It's a bit crude, but I think it helps.

webstead: mark :active pixels

This makes it more obvious that something is happening when the mouse
button is pressed, even though the tickybox doesnt change state until
it's released.  Thus should make the UI feel less sluggish.

webstead: enable strict mode in top-level script

Now that it's not a module, we need to do this explicitly.  Also fix
various undeclared variables that this exposed.

webstead: JavaScript is not Perl

Remove some braces accordingly.

webstead: allow for editing C version of character

The new code triggers when the <input> is edited.  It updates the
pixel tickyboxes and the rendered glyph, but suppresses updating the
<input> itself.  This can be used for interactive editing, but is
mostly to allow for pasting in character bitmaps.

webstead: reset form at start of from_c()

That way we don't get fragments of the old glyph if it stops early.

webstead: add a function to read a C string

Like pasting in the Python editor.  Now I just need to tie this into
the UI in a way that's not horrible.

webstead: use an <input> to display C code

Styling for text <input> in bedstead.css

webstead: more sensible viewBox for <svg>

webstead: use a non-module <script> and import()

According to <https://github.com/fuweichin/xhtml5-esm-support>, an
internal script (a <script> element with content) can't be a module in
an XHTML page in Safari.  So following the suggestion on that page, I
make the <script> on the page into a classic script, and use import()
to load the module containing the bedstead executable.  Maybe this
will work on a reasonable selection of modern browsers.

Set a content security policy in .htaccess

My Web site disables JavaScript by default, so we need to override
that if the Web editor is going to work.

webstead: add Emscripten and musl copyright notices

Programs compiled with Emscripten end up statically linked against the
Emscripten runtime, which includes musl libc.  So we need to comply with
their licences by including a copy of the licence and the relevant
copyright notices.  I think putting them on the webstead page in small
print is probably the best approach.

This might need updating each release to match the version of Emscripten
that I build the editor with.

Makefile cleanups for webstead

Add -sINCOMING_MODULE_JS_API because in newer Emscripten -sSTRICT
empties it.  Remove -sMODULARIZE because -sEXPORT_ES6 implies it.  Add
-O2 since the compiled code will probably be run more than once.  Pass
standard compiler flags to emcc.  Build bedstead.js in all-web, and
remove it in clean.

webstead: prefer querySelector[All] over getElement*

It's a bit shorter, a bit more general, and allows me to properly
query only input elements that are children of the table of pixels.

webstead: mark script as async

Apparently Chromium can't cope with "defer" scripts (which modules are
by default) in XHTML documents.  But "async" scripts work properly,
so now we use one of those and then wait for DOMContentLoaded as
necessary.

webstead: set color:inherit on tickyboxes

Chromium's browser stylesheet overrides this.

webstead: put border on tickboxes, not table cells

That means the borders are clickable, which is what I want.

webstead: scale input and output better with window size

It turns out that setting --pix to 7vmin, while rather unprincipled,
does actually work quite adequately.

webstead: use currentColor for checked background

This means that webstead.xhtml doesn't know anything about the colours
in bedstead.css.

webstead: use <pre> for C code

webstead: generate initialisers to paste into bedstead.c

webstead: slight CSS simplification

Don't need to specify border colour if it's the current colour anyway.

webstead: better layout

webstead: almost-acceptable pixel-looking input

webstead: slightly cleverer path translation

Now paths with successive rlineto operations (to avoid overflowing the
Type 2 stack) work.

webstead: SVG transform to turn output right way up

webstead: properly ignore cntrmask

webstead: input from an array of tickyboxes

webstead: make a named function to update the rendered glyph

webstead: SVG rendering by extremely crude regexps

webstead: use standard bedstead.css

Capture output in HTML

Minimal build system and test page for Bedstead-in-WASM

Just allows for typing a command line and seeing the output.

Use text/plain for all-caps filenames in .htaccess

There are various text files in the Bedstead sources (and hence on the
Web site) that have conventional names in all caps, like NEWS.  These
should be served as text/plain.  That can be achieved in Apache using
a <FilesMatch> block and ForceType.

Add more compressible types in .htaccess

It looks like by AddOutputFilterByType directive somehow overrides the
defaults, and also there are a few more types that could usefully be
compressd.  So now it lists all the compressible file types in the
directory.

Enable "deflate" filter for XHTML and fonts in .htaccess

The configuration on chiark already compresses most HTML content
types, and OTF fonts (especially Bedstead) are very compressible.

Remove .sfd from .htaccess file

We don't serve and SFD files any more.

Add a paragraphs about the other semi-graphics Bedstead can do

They could probably do with examples as well.

Large type M and W vertex components

Remaining large type stem parts

The ones that aren't separately encoded provided a clear indication of
how the numbered stem parts are meant to relate to the named ones, so
there weren't actually many decisions to make.

Lots of diagonal bits of large type pieces

This is essentially all of them apart from the W and M pieces.  There
turn out to be obvious places to have the diagonals cross character-cell
boundaries such that they should all join up.  Whether this gives and
aesthetically tolerable outcome, I'm not so sure.

The W and M pieces are a bit confusing, because they're meant to span
two character cells vertically, but the obvious design doesn't.

Three more HP large type components

These are based on the existing arcs in obvious ways.

Initial HP large type pieces (U+1CE1A onwards)

This batch are the ones that can be implemented using the ordinary
box-drawing characters (and probably should have been unified with
them by Unicode).

Convert some 8-cell mosaic glyphs into aliases to 6-cell

Because in Bedstead the cell boundaries of 8-cell mosaic glyphs are a
superset of those for 6-cell mosaic glyphs, each of the existing
6-cell glyphs has an identical 8-cell glyph whose middle two rows of
cells are identical.  Thus, these 8-cell glyphs can be aliases for the
corresponding 6-cell glyph.  I've implemented this as a macro called
A() that can be mixed in with the existing O() macros in the section
of the glyphs table that generates U+1CD00..U+1CDE5, aliasing them to
characters in U+1FB00..U+1FB3B.  That makes the table even more
confusing, but at least it's compact.

Add remaining 8-cell mosaic characters

These are the ones scattered across Unicode and not in the main
U+1CD00..U+1CDE5 block that weren't already present.  They're aliased to
the corresponding 6-cell characters.

Notes on what the missing 8-cell mosaics are unified with

Main block of 8-cell mosaics in Symbols for Legacy Computing Supplement

These were mostly generated from UnicodeData.txt with a dodgy Perl
one-liner and an Emacs keyboard macro.  The dodgy one-liner was (wrapped
onto more lines):

grep "BLOCK OCTANT" ~/Downloads/UnicodeData.txt |
perl -pe '/OCTANT-(\d+)/; $i=""; map{vec($i,$_-1,1)=1}split(//,$1);
          $_=sprintf("%02X",ord($i))." $_";'

Now I need to find the characters elsewhere in Unicode that correspond
with the gaps in the table.

Add support for generating 8-cell mosaic graphics

This follows the pattern of the 6-cell and 4-cell versions, but without
separated mode because Unicode doesn't have that.  This required making
the bitmap data into an unsigned char array to allow for using all eight
bits.

The cell boundaries are chosen so that they line up with existing 6-cell
and 4-cell boundaries.  So we have row heights of [3,2,2,3], which is
maybe less pretty than [3,2,3,2], but is more in keeping with the
existing mosaics.  Indeed, it means that the existing 4-cell and 6-cell
contiguous characters could be expressed in 8-cell terms if I wanted to.

Enlarge radius of box drawings arcs

Before, the diagonal parts were the same as in the capital O.  But that
was already a bit square, and the shapes one would draw with the box
drawing characters will generally be bigger.  So now I've cut a bit more
off the corners.  This means that arcs that join to the right need the
recent change to add JOIN_R in order to join up properly.

With this change, if you try to draw a circle with them, you get an
octagon with side lengths 2, 2.8, 6 instead of 4, 1.4, 8, which I think
is an improvement.

Add JOIN_R and JOIN_D flags, and extend effects of JOIN_*

The new flags mark glyphs that join to the right and downwards.  The
effect of these, and a new effect of JOIN_U and JOIN_L, is to arrange
that getpix() treats pixels beyond the edge of the character cell as
repeating the last row of real pixels.

In practice, this means that a diagonal stroke touching the right or
bottom edge of the cell will now be drawn as though it turns into an
orthogonal stroke across the edge rather than as though it stops.  This
doesn't affect the outline of any existing glyph.

There is a more subtle consequence, which is that joining glyphs no
longer get edge hints on their joining edges.  I think that's an
improvement: such hints might move those edges so that they don't touch
the adjacent character, which would be rather unhelpful.

Move various small caps to dedicated Unicode code points

Specifically, this adds:

U+1D0C LATIN LETTER SMALL CAPITAL L WITH STROKE
U+1D23 LATIN LETTER SMALL CAPITAL EZH
U+1D7B LATIN SMALL CAPITAL LETTER I WITH STROKE
U+1DF04 LATIN LETTER SMALL CAPITAL L WITH BELT
U+1DF10 LATIN LETTER SMALL CAPITAL TURNED K

Three of this had private-use encodings that appeared in earlier
Bedstead releases.  These encodings have been preserved for backward
compatibility.

Add old-style numerals

I've designed new versions of 0, 1, and 2 that fit within the
x-height.  6 and 8 don't change at all (and are unmapped).  The other
digits are all moved down by two pixels so their top edges are at the
x-height and their bottom edges at the descender height.

This is very simple (and much simpler than my previous attempts), but
seems to be satisfactory.

U+01B7 LATIN CAPITAL LETTER EZH

It's just the lower-case moved up the baseline, but the small-cap is
new.

U+2C6D LATIN CAPITAL LETTER ALPHA

Used by at least one African language that we otherwise support, and
trivially derived from the lower-case.

Better UALIAS() macro

Now you _can_ pass an instance of U() as the first two arguments.

More modifier letters of quotation marks

They're aliases of the normal versions.  I think Hawaiian probably
wants one.  Also converted modifier primes into aliases.

Make all the capital Dcroat and African D into aliases of Eth

This saves a few bytes and avoids some repetition.

Add a macro, UALIAS(), for aliases with Unicode mappings

ALIAS() is now implemented in terms of UALIAS().

U+0194 LATIN CAPITAL LETTER GAMMA

Hyperglot says that completes several more African languages including
Dinka.

U+019D LATIN CAPITAL LETTER N WITH LEFT HOOK

Hyperglot says this is all we're missing from Bambara, which has 4
million speakers.

Finally solve the S-hachek problem

I had been trying to find an upper-case that was visibly distinct from
the existing lower-case, but I realised that I could do the same as we
do with accented 'o' and instead make a new lower-case version and
declare the existing glyph to be upper-case.  This seems to work
tolerably and removes the most embarrassing gaps in Bedstead's
repertoire.

U+0197 LATIN CAPITAL LETTER I WITH STROKE

With a small-cap glyph and appropriate mappings.  Hyperglot says that
adds nine more languages.

U+01B1 LATIN CAPITAL LETTER UPSILON

It's just an upside-down Omega.  Hyperglot says that gains us support
for five more languages.  The small-cap is just the already-existing
lower-case.

Added some useful African capitals

Not cities, but capital versions of some letters we already had in
lower-case for IPA.  Specifically:

U+0186 LATIN CAPITAL LETTER OPEN O
U+0189 LATIN CAPITAL LETTER AFRICAN D
U+0190 LATIN CAPITAL LETTER OPEN E
U+0196 LATIN CAPITAL LETTER IOTA
U+01B2 LATIN CAPITAL LETTER V WITH HOOK

Between them, Hyperglot thinks this gains us useful coverage of
languages with a few tens of millions of speakers, which seems like good
value to me.

The all also have small caps, and in the case of the African D all the
capital-D variants.

Proper names for Wgrave, wgrave, Wacute, wacute, Ygrave, and ygrave

Turns out that these are in AGLFN.  No compatibility aliases because
they never appeared in a release with the wrong names.

Redesign U+028B LATIN SMALL LETTER V WITH HOOK

The International Phonetic Association's preferred sans-serif font
doesn't give this character a serif at the top left, so Bedstead
shouldn't either.  Also the bottom-left corner of the letter is subtly
curved, so I've rounded off that corner a bit as well.  The result is
more like the IPA's ideal and also easier to design a capital version
of.

More-consistent 'W' glyphs

Now all of the caps and small caps have a central peak four pixels
above the baseline, and all of the lower-case have a central peak
three pixels above the baseline.  The outer arms vary as necessary to
accommodate accents and for small caps.

Add W/w with grave and acute

Hyperglot says these are needed for Welsh, and they're trivial to
draw.

There seems to be some confusion around the proper shape for small-cap
W in Bedstead; I should investigate this in more detail.

Add Y/y with grave

They're trivial and Hyperglot says they're necessary for writing Welsh.