Ole's original implementation used 'middle', which I switched away from.
After a great deal of testing it turns out that 'middle' does in fact
provide the most consistent results, so we're switching back to it.
The values don't change, so there's no reason to repeat those
calculations on every redraw. The resulting code is not just faster,
but also smaller and simpler, and we no longer need to store halign in
the text info object.
The core implementation used parseInt, which was originally to catch
text values, but really only stayed due to its side-effect of flooring
the values. The canvas implementation has never rounded coordinates.
This led to various one-pixel rendering glitches between the two
implementations. I've fixed the problem by consistently rounding
coordinates to the nearest whole number.
This resolves#991, replacing the earlier temporary patch. It takes
advantage of the fact that line-height can take the form of a unit-less
integer, in which case it mirrors the font-size, even when it is
something abstract, like 'smaller'. We can then read the dummy
element's height to learn the effective font-size.
Plugins are re-initialized with each re-plot (which may not be the right
thing to do, but that's how it works for now). The previous approach of
saving references to the original Canvas functions therefore broke,
since the second time around we'd get a reference to our new function.
Instead we hold those references as globals within the plugin, and only
set them once.
This whole idea of replacing prototype functions is, now that I step
back and look at it, really awful. This needs to be changed ASAP to
something less ridiculous.
Previously the cache was divided only by layer, with entries keyed on a
string built from the text and style. Now the style has its own tier in
the cache, i.e. layers > styles > text > info.
This introduces some complexity, since the nested for loops are ugly,
but at the same time we avoid having to create the cache-key strings.
More importantly it solves the problem of uniqueness that exists when we
try to join strings that may contain arbitrary text. It also allows a
further optimization in the canvas plugin, which can now set text style
and color just once per distinct style, instead of with every string.
This lets users 'namespace' text more naturally, i.e. placing x-axis
labels in a different container from y-axis labels, providing more
flexibility when it comes to styling and interactivity.
Internally the text cache now has a second tier: layers > text > info.
The getTextInfo method previously added new text to the top-level
container when measuring it. Now it adds the text to the text layer,
just as it will be when rendered, so that parent-child CSS rules can
resolve correctly.
This also avoids having to safe a reference to the top-level container,
since it wasn't used anywhere else.
Every cache element now contains the actual text element instead of just
its HTML, plus a flag indicating whether it is visible. The addText and
removeText methods control the state of this flag, and the render method
uses it to manage elements within the text container. So where we
previously used drawText to actually render text, now we add each string
once, then let the render method take care of drawing them as necessary.
This dramatically improves performance by eliminating the need to clear
and re-populate HTML text on every drawing cycle. Since the elements
are now static between add/remove calls, this also allows users to add
interactivity, as they could in 0.7. Finally, it eliminates the need
for a separate 'hot' cache.
I also removed the unnecessary 'dimensions' object; it's easier and
faster to store the width and height at the top level of the info
object.
The base implementation uses the new drawText and getTextInfo methods to
draw text in HTML. Canvas rendering has been moved to overrides of
these methods within the canvas-render plugin.
David Schnur
martinqt