summaryrefslogtreecommitdiff
path: root/dviware/dvi2bitmap/PkFont.h
diff options
context:
space:
mode:
Diffstat (limited to 'dviware/dvi2bitmap/PkFont.h')
-rw-r--r--dviware/dvi2bitmap/PkFont.h388
1 files changed, 388 insertions, 0 deletions
diff --git a/dviware/dvi2bitmap/PkFont.h b/dviware/dvi2bitmap/PkFont.h
new file mode 100644
index 0000000000..cac4e0c18a
--- /dev/null
+++ b/dviware/dvi2bitmap/PkFont.h
@@ -0,0 +1,388 @@
+/* This file is part of dvi2bitmap; see README for copyrights and licence */
+
+#ifndef PK_FONT_HEADER_READ
+#define PK_FONT_HEADER_READ 1
+
+#include <config.h>
+
+#include <string>
+// We only need to include <ostream> here, but <iostream> is on more machines
+#include <iostream>
+#include <FileByteStream.h>
+#include <Byte.h>
+#include <DviError.h>
+#include <verbosity.h>
+
+/** A PK font */
+class PkFont;
+
+class PkError : public DviError {
+ public:
+ PkError(string s) : DviError(s) { }
+};
+
+class PkRasterdata {
+ public:
+ PkRasterdata(Byte opcode,
+ const Byte *rasterdata, unsigned int len,
+ unsigned int w, unsigned int h);
+ /**
+ * Returns the bitmap corresponding to the input rasterdata
+ *
+ * @return the bitmap, as an array of size <code>[0..w-1][0..h-1]</code>
+ */
+ const Byte *bitmap()
+ { if (bitmap_ == 0) construct_bitmap(); return bitmap_; }
+ /**
+ * Sets the verbosity of this module.
+ * @param level the required verbosity
+ * @return the previous verbosity level
+ */
+ static verbosities verbosity (const verbosities level) {
+ enum verbosities oldv = verbosity_;
+ verbosity_ = level;
+ return oldv;
+ }
+ private:
+ Byte *rasterdata_, *eob_;
+ const unsigned int len_, w_, h_;
+ Byte dyn_f_;
+ bool start_black_;
+ Byte *bitmap_;
+ bool highnybble_;
+ unsigned int repeatcount_;
+ unsigned int unpackpk();
+ Byte nybble();
+ void construct_bitmap ();
+ static verbosities verbosity_;
+};
+
+class PkGlyph {
+ public:
+ PkGlyph(unsigned int cc,
+ unsigned int tfmwidth, unsigned int dm,
+ unsigned int w, unsigned int h,
+ int hoff, int voff,
+ PkRasterdata *rasterdata, PkFont *f);
+ PkGlyph(unsigned int cc,
+ unsigned int tfmwidth, unsigned int dx, unsigned int dy,
+ unsigned int w, unsigned int h,
+ int hoff, int voff,
+ PkRasterdata *rasterdata, PkFont *f);
+ PkGlyph(int resolution, PkFont *f);
+ /**
+ * The character code for this glyph
+ */
+ inline unsigned int characterCode() const { return cc_; }
+ /**
+ * The character which this glyph represents.
+ * @return the (ASCII) printable character which this glyph
+ * purports to represent
+ */
+ inline char characterChar() const
+ { return (cc_ >= ' ' && cc_ < 127
+ ? static_cast<char>(cc_) : '?'); }
+
+ const Byte *bitmap();
+ /**
+ * Width of this character. This is the row-length of the bitmap
+ * returned by method <code>bitmap()</code>
+ * @return width in device units (ie, pixels)
+ */
+ inline unsigned int w() const { return w_; }
+ /**
+ * Height of this character. This is the number of columns in the bitmap
+ * returned by method <code>bitmap()</code>
+ * @return height in device units (ie, pixels)
+ */
+ inline unsigned int h() const { return h_; }
+ /**
+ * Obtains the horizontal offset of the first
+ * pixel of the bitmap from the reference point for this glyph,
+ * with positive numbers indicating a rightward offset. This is
+ * the negative of the horizontal offset of the
+ * reference point from the bitmap, as discussed in {@link
+ * #PkGlyph the constructor}.
+ *
+ * @return the offset (in pixels, with right being positive)
+ */
+ inline int hoff() const { return -hoff_; }
+ /**
+ * Obtains the vertical offset of the first
+ * pixel of the bitmap from the reference point for this glyph,
+ * with positive numbers indicating a downward offset (which is
+ * rather rare, since the reference point is generally near the
+ * lower-left corner of the glyph).
+ * This is the negative of the vertical offset of the
+ * reference point from the bitmap, as discussed in {@link
+ * #PkGlyph the constructor}.
+ *
+ * @return the offset (in pixels, with down being positive)
+ */
+ inline int voff() const { return -voff_; }
+ /**
+ * The glyph's width.
+ * @return the glyph's width in points
+ */
+ double tfmWidth() const { return tfmwidth_; }
+ /**
+ * The glyph's horizontal escapement
+ * @return the escapement in pixels
+ */
+ int hEscapement() const { return dx_; }
+ /**
+ * The glyph's vertical escapement
+ * @return the escapement in pixels
+ */
+ int vEscapement() const { return dy_; }
+ /**
+ * Sets the verbosity of this module.
+ * @param level the required verbosity
+ * @return the previous verbosity level
+ */
+ static verbosities verbosity (const verbosities level) {
+ enum verbosities oldv = verbosity_;
+ verbosity_ = level;
+ return oldv;
+ }
+
+ private:
+ unsigned int cc_, dx_, dy_, w_, h_;
+ double tfmwidth_;
+ int hoff_, voff_;
+ PkFont *font_;
+ PkRasterdata *rasterdata_;
+ bool longform_;
+ const Byte *bitmap_;
+ static verbosities verbosity_;
+ static const int two20_ = 1048576; // 2^20
+ static const int two16_ = 65536; // 2^16
+};
+
+class PkFont {
+ public:
+ PkFont (double fontmag,
+ unsigned int c,
+ unsigned int s,
+ unsigned int d,
+ string name);
+ ~PkFont();
+ /**
+ * Returns the glyph at a given position in this font. If the
+ * font has not been loaded, it returns a dummy glyph.
+ * @return the numbered glyph from the font
+ */
+ PkGlyph *glyph (unsigned int i) const {
+ if (font_loaded_)
+ {
+ if (i > nglyphs_)
+ throw DviBug ("requested out-of-range glyph");
+ return glyphs_[i];
+ }
+ else
+ return glyphs_[0]; // dummy glyph
+ }
+ static verbosities verbosity (const verbosities level);
+ // setFontPath: specify path to search for fonts. If argument is
+ // null or zero length, simple enable this.
+ static void setFontSearchPath(string fp);
+ static void setFontSearchPath(char *fp);
+ static void setFontSearchPath(bool yesno);
+ // setFontSearchCommand: set the command to use to search for
+ // fonts. If argument is null or zero length, simply enable this,
+ // using the compiled-in default.
+ static void setFontSearchCommand(string cmd);
+ static void setFontSearchCommand(char* cmd);
+ static void setFontSearchCommand(bool yesno);
+ static void setFontSearchKpse(bool yesno);
+ /**
+ * Sets the base font resolution. This must be consistent with
+ * the the Metafont mode set by {@link #setMissingFontMode}, if
+ * font-generation is to work.
+ * @param res the new font resolution
+ * @see #dpiBase
+ */
+ static void setResolution(int res) { resolution_ = res; }
+ /**
+ * Sets the Metafont mode to be used when generating fonts. This
+ * must be consistent with any base font resolution set in {@link
+ * #setResolution}.
+ * @param mode a Metafont mode
+ */
+ static void setMissingFontMode(string mode) { missingFontMode_ = mode; }
+ // Ought I to rationalise setMakeFonts, so that this looks more
+ // like the interface of setFontSearchCommand()? Not really,
+ // since it's possible in principle that there could be more than
+ // just this command-based way of making fonts.
+ static void setFontgen(bool doit);
+ static void setFontgenCommand(string command_template);
+ string fontgenCommand() const;
+ /**
+ * Identifies the current font
+ * @return the font's name
+ */
+ string name() const { return name_; }
+ /**
+ * Locates the current font's bitmap file
+ * @return theh path to the PK file which defines this font
+ */
+ string fontFilename() const { return path_; }
+ double magnification(bool includeDviMag=true) const;
+ /**
+ * Obtains the base font resolution, in dots-per-inch. This is
+ * the base resolution corresponding to the Metafont mode set by
+ * {@link #setMissingFontMode}, and the two must be consistent if
+ * font-generation is to work.
+ * @return the font resolution, in dots-per-inch
+ * @see #setResolution
+ */
+ static int dpiBase() { return resolution_; }
+ /**
+ * Obtains the resolution of the current font, taking
+ * magnification into account
+ * @return the font's resolution, in dots-per-inch
+ */
+ int dpiScaled() const {
+ return static_cast<int>(resolution_
+ * magnification()
+ + 0.5);
+ }
+ /**
+ * Obtains the font's scale. This is the factor <em>s/d</em>,
+ * where <em>s</em> and <em>d</em> are the font scale and font
+ * design size as specified when the font was declared in the DVI
+ * file. Together, they specify that the font is to be used at
+ * <em>magnification/1000 . s/d</em> times its design size. This
+ * is distinct from the return value of {@link #magnification},
+ * which takes DVI file magnification into account, and which is
+ * therefore more useful in general.
+ *
+ * @return the font scale, s/d
+ */
+ double scale() const {
+ return (double)font_header_.s / (double)font_header_.d;
+ }
+ /**
+ * Has the current font been declared in the document so far, or
+ * just in the DVI file postamble.
+ * @return true if we have seen a fnt_def declaration for this
+ * font, in the DVI file body
+ */
+ bool seenInDoc(void) const { return seen_in_doc_; }
+ void setSeenInDoc(void) { seen_in_doc_ = true; }
+
+ /**
+ * Obtains the size of the <code>word_space</code> parameter for this font.
+ * This does <em>not</em> include any overall DVI magnification.
+ * @return <code>word_space</code> in DVI units
+ */
+ double wordSpace() const { return word_space_; }
+ /**
+ * Obtains the size of the <code>back_space</code> parameter for this font.
+ * This does <em>not</em> include any overall DVI magnification.
+ * @return <code>back_space</code> in DVI units
+ */
+ double backSpace() const { return back_space_; }
+ /**
+ * Obtains the size of the <code>quad</code> parameter for this font.
+ * This does <em>not</em> include any overall DVI magnification.
+ * @return <code>quad</code> in DVI units
+ */
+ double quad() const { return quad_; }
+
+ // No need to check font_loaded_ in these next three, since these
+ // are never called between the font being created and preamble_
+ // being filled in.
+ /**
+ * Obtains the design size of this font, as obtained from the PK
+ * file preamble.
+ * @return the design size in points
+ */
+ double designSize() const { return preamble_.designSize; }
+ /**
+ * Obtains the number of horizontal pixels per point for this
+ * font, as obtained from the PK file preamble.
+ * @return the hppp parameter in points
+ */
+ double hppp() const { return preamble_.hppp; }
+ /**
+ * Obtains the number of vertical pixels per point for this
+ * font, as obtained from the PK file preamble.
+ * @return the vppp parameter in points
+ */
+ double vppp() const { return preamble_.vppp; }
+ /**
+ * Obtains the font checksum, as obtained from the PK file preamble.
+ * @return checksum
+ */
+ unsigned int checksum() const { return preamble_.cs; }
+ /**
+ * Check if the font has actually been loaded. This is false
+ * if the font was declared in the DVI file, but its bitmaps were
+ * not or cound not be loaded from disk for some reason.
+ * @return true if the font was successfully read from disk
+ */
+ bool loaded() const { return font_loaded_; }
+
+ static string& substitute_font_string (const string fmt,
+ const string mode,
+ const string fontname,
+ const int dpi,
+ const int basedpi,
+ const double magnification)
+ throw (PkError);
+
+
+ private:
+ static const unsigned int nglyphs_ = 256;
+ static const unsigned int two20_ = 1048576; // 2^20
+ static const unsigned int two16_ = 65536; // 2^16
+
+ string name_;
+ string path_; /* name of (tbd) file containing font */
+ FileByteStream *pkf_;
+ bool font_loaded_; /* font loaded successfully */
+ struct {
+ unsigned int c; /* font checksum */
+ unsigned int s; /* fixed-point scale factor, in DVI units */
+ unsigned int d; /* `design size', in DVI units */
+ } font_header_; /* this is the information retrieved
+ from the font declaration */
+ double dvimag_; /* Magnification imposed by DVI file (1.0 = no mag) */
+ struct {
+ unsigned int id, cs;
+ double designSize, hppp, vppp;
+ string comment;
+ } preamble_;
+ //double fontscale_;
+ // following are in DVI units
+ double quad_, word_space_, back_space_;
+ PkGlyph *glyphs_[nglyphs_];
+ bool find_font (string&);
+ void read_font(InputByteStream&);
+
+ /* Search the given path for a font. Not static, so that it can
+ see the current font's parameters. */
+ string& search_pkpath (string path,
+ string name, double resolution);
+
+ bool seen_in_doc_; // true once the font_def command has been
+ // seen in the document, as well as the
+ // postamble
+ static verbosities verbosity_;
+ static string fontSearchPath_; // colon-separated list of directories
+ static string fontSearchCommandTemplate_; // command to find fonts
+ static string fontgenCommandTemplate_; // command to generate fonts
+ static void setFontSearchStrategy_(unsigned int, bool);
+ static unsigned int fontSearchStrategies_; // ways to find fonts: flags:
+ static const unsigned int fontSearchStrategyPath_ = 1;
+ static const unsigned int fontSearchStrategyKpse_ = 2;
+ static const unsigned int fontSearchStrategyCommand_ = 4;
+
+ static int resolution_; // base resolution for MF mode
+ static bool makeMissingFonts_; // automatically make fonts
+ static string missingFontMode_;
+};
+
+#endif // #ifndef PK_FONT_HEADER_READ
+