Conference bulova::decw_jan-89_to_nov-90

I don't really know what you're customer means by "vectored fonts." 
Might it be "vector fonts," meaning fonts which are defined by
outlines, rather than bitmaps?

In any case, it's certainly possible to write an application which will
resize it's fonts when it's window is resized.  This is particularly
trivial with Display PostScript, but it's possible also with regular
DECwindows fonts by choosing an appropriate bitmap font and/or scaling
the bitmaps to the desired size.  DECwrite does this.

    
    There are (in general) two types of video text: Stroke (and Outline)
    and Raster.
    
    Raster text is by far the most common type of text for raster graphic
    applications.  It's easy to use, fast and presents the "best" look on
    low-resolution devices (like this 100-dpi monitor I'm on) because each
    pixel in each glyph can be hand-tweaked by a font designer.  The text
    *can* be scaled, sheared and rotated, but the result is not always very
    pleasing - since there is no (or little) organization in a matrix of
    dots which can be used to make the test pleasing.  X11 does NOT provide
    scaling, shearing or rotation - but many other windowing/graphic systems
    do.  Such an ability CAN be layered on X11 (DECwrite, UISX, GObE are
    all examples of layered implementations).
    
    Stroke fonts can be generalized into two major types:  Stroke and
    Outline.  Stroke fonts are a list of vectors (which may be what you
    are looking for) which when drawn form characters.  GKS has a mode
    which specifies this type of text.  The "classic" stroke fonts are
    the Hershey fonts which were done by the US Navy and are in the public
    domain.  Some devices, like plotters can only use stroke fonts.
    
    Outline fonts are a form of stroke font where rather than simple lines,
    the lines form polygons which can then be filled.  The definition of
    the characters is therefor a "outline" of the edges of the polygons.
    This type of font has become popular through Postscript (which also
    does special things with splines to allow scalability).
    
    Both Stroke and Outline fonts are inherently scaleable - they're just
    drawing primitives.  However, they are generally poor on low resolution
    devices (<300dpi) and are MUCH slower than raster graphics at low-res.
    To use EITHER requires special logic - Display Postscript will allow
    the use of Outline fonts.  GKS or some other library will allow stroke
    fonts.  Or you can roll your own.  I have a library that does Hershey
    font text output (and scaling, rotation, etc.) for UIS (though there is
    really only a single graphic command:  PLOT).
    
    The Consortium has put it's money on Display Postscript.  This
    extension to X11 is now available for Unix and is testing on VMS.
    It's large and slow (at last report).
    
    

Re/ .2:

Fred, I think you should stop badmouthing Display PostScript unless you
have some actual performance data that's not satisfactory.  I've been
using it for months with more than adequate performance.

Also, PostScript doesn't do anything special to make it's outline fonts
scalable.  Bezier curves are inherently scalable, and rotatable, etc. 

    re: .3
    
    Ah, but *you* needed to move to a RISC machine to get reasonable
    performance and indicated that the VAXstation just didn't cut it... I
    have problems when a 2.8 VUP machine with better graphics performance
    than your typical PC isn't enough to output some text.  I also have
    problems when 1/2 of my colors need to be consumed by a extension.
    
    As to the Bezier curves - their use is *specificly* what Postscript
    uses special to enhance their scalablility.  As simply a list of points
    would break down when scaled too large into something course.  By
    specifying control points and having the software draw a curve though
    them - you reduce problems when scaled.  Perhaps I misled by saying it
    did something special *with* splines.
    
    

Re/ .4:
>
> Ah, but *you* needed to move to a RISC machine to get reasonable performance
> and indicated that the VAXstation just didn't cut it ...
>
Huh?  I never said that!  I moved to a RISC machine because I'm using
some other code that only runs on RISC.  It had nothing to do with
Display PostScript.  I've never even seen DPS running on a 2.8 VUP
VAXstation.  I've tried running on a 1 VUP workstation, with a RISC
machine as the host, and that was admittedly slow, but I can't say that
it was a DPS problem.  The server was also rather loaded.  Finally,
this had nothing to do with outputting text.  I was drawing very large
numbers (ie, hundreds) of Bezier curves.  DPS does some optimization of
text output, using bitmap fonts where possible.

Finally, I think the next version of DPS will use a smaller color map,
by default.  Personally, I have no problem with DPS using half my
colormap.  What else am I using it for?

Obviously the choice depends on the application, but for me, the
advantages of Display PostScript definitely outweight the
disadvantages.  Plain old X is so brain damaged when it comes to
graphics that the application has to concern itself with every detail
of the device resolution, color capability, memory availability, etc. 
With DPS, you just treat all devices as a "perfect" PostScript device,
and DPS does the best rendition it can on the available hardware.