X-Git-Url: http://git.chise.org/gitweb/?a=blobdiff_plain;f=example%2Fotfview.c;h=14604edb5df2e674121c12f1232760633402102d;hb=c54eac96a418fcdbb410a2a7dd39d22536a62660;hp=ae5f2d8e7117b66d002ac0defa8300e759574eec;hpb=6b56362f68dd52b0a85b675a5737ddb86c3421a7;p=m17n%2Flibotf.git diff --git a/example/otfview.c b/example/otfview.c index ae5f2d8..14604ed 100644 --- a/example/otfview.c +++ b/example/otfview.c @@ -1,6 +1,6 @@ /* otfview.c -- View glyphs of OpenType fonts. -Copyright (C) 2003, 2004 +Copyright (C) 2003, 2004, 2005, 2006, 2008, 2009 National Institute of Advanced Industrial Science and Technology (AIST) Registration Number H15PRO167 @@ -28,6 +28,11 @@ write to the Free Software Foundation, Inc., 59 Temple Place, Suite #include #include +#include "config.h" + +#ifdef HAVE_X11_XAW_COMMAND_H + +#include #include #include #include @@ -42,7 +47,22 @@ write to the Free Software Foundation, Inc., 59 Temple Place, Suite #include +#define CAST_FROM_XTPOINTER(TYPE, DATA, VAR) \ + do { \ + long TYPE temp = (long TYPE) (DATA); \ + (VAR) = temp; \ + } while (0) + +#define XtAddCallbackWithCast(TYPE, W, PROC, VAR) \ + do { \ + long TYPE temp = (long TYPE) (VAR); \ + XtAddCallback (W, XtNcallback, PROC, (XtPointer) temp); \ + } while (0) + + #define DEFAULT_PIXEL_SIZE 30 +int pixel_size; + #define DEFAULT_FONT_NAME "6x13" XFontStruct *font; #define FONT_HEIGHT (font->ascent + font->descent) @@ -57,33 +77,62 @@ XtAppContext context; | | quit dump charmap ... | | | +--------------------------------------+ | | +---- navi_area (box) -----------------+ | - | | FIRST PREV prev label next NEXT LAST | | + | | FIRST PREV prev range next NEXT LAST | | | +--------------------------------------+ | | +--- glyph_area (form) ----------------+ | - | | glyph[0] ... glyph[15] | | + | | idxh[0] glyph[0] ... glyph[15] | | | | ... ... | | - | | glyph[112] ... glyph[127]| | + | | idxh[7] glyph[112] ... glyph[127]| | + | | idxl[0] ... idxl[15] | | + | +--------------------------------------+ | + | +---- uvs_area (box) (optional) -------+ | + | | uvs[?].w ... | | | +--------------------------------------+ | | +--- render_area (form) ---------------+ | - | | clear | | + | | clear del bidi alt_subst | | | | +--- raw (box) --------------------+ | | | | | raw_label raw_image | | | + | | +----------------------------------+ | | + | | GSUB all none features... | | + | | GPOS all none features... | | | | +--- seq (box) --------------------+ | | | | | seq_label seq_image | | | - | | +--- gsub (box) -------------------+ | | - | | | gsub_label gsub_image | | | - | | +--- gpos (box) -------------------+ | | - | | | gpos_label gpos_image | | | + | | +----------------------------------+ | | + | | +--- code (box) -------------------+ | | + | | | code_label code_list ... | | | | | +----------------------------------+ | | | +--------------------------------------+ | +------------------------------------------+ */ Widget shell, frame; Widget command_area, quit, dump, *charmap; -Widget navi_area, FIRST, PREV, prev, label, next, NEXT, LAST; -Widget glyph_area, glyph[128]; -Widget render_area, clear, raw, seq, gsub, gpos; -Widget raw_label, raw_image, seq_label, seq_image; -Widget gsub_label, gsub_image, gpos_label, gpos_image; +Widget navi_area, FIRST, PREV, prev, range, next, NEXT, LAST; +Widget glyph_area, glyph[128], index_label[8]; +Widget uvs_area, uvs_label; +Widget render_area, clear, del, bidi, alt_subst, raw, seq, code; +Widget raw_label, raw_image, seq_label, seq_image, code_label, code_list; +unsigned long foreground, background; + +typedef struct +{ + OTF_Tag tag; + int on; + Widget w; +} FeatureElement; + +typedef struct +{ + char *label; + OTF_GSUB_GPOS *gsub_gpos; + OTF_LangSys *langsys; + int num_features; + FeatureElement *features; + Widget parent; +} FeatureRec; + +FeatureRec gsub, gpos; + +/* Currently selected script and langsys. */ +OTF_Tag script_tag, langsys_tag; int glyph_char[128]; @@ -97,7 +146,7 @@ typedef struct { int advance; } BitmapRec; -BitmapRec bitmap[0x10000]; +BitmapRec bitmap[0x110000]; int render_width, render_height; Pixmap raw_pixmap, seq_pixmap, gsub_pixmap, gpos_pixmap; @@ -113,6 +162,8 @@ struct { int charmap_index; +int reversed; +int do_alternate_subst; unsigned glyph_width, glyph_height; int glyph_x, glyph_y; int glyph_index; @@ -123,21 +174,27 @@ struct { int codes[64]; } glyph_rec; +OTF_EncodingSubtable14 *sub14 = NULL; + +struct { + Widget w; + int c; +} uvs[256]; + OTF *otf; char *filename; +int fontindex; void -create_pixmap (int pixel_size, int index) +create_pixmap (int index) { int err = FT_Load_Glyph (face, index, FT_LOAD_RENDER | FT_LOAD_MONOCHROME); XImage ximage; Pixmap pixmap; - int height = glyph_height + 1 + FONT_HEIGHT; - char index_buf[5]; if (err) { - bitmap[index].pixmap = (Pixmap) 0; + bitmap[index].pixmap = none_pixmap; return; } ximage.height = face->glyph->bitmap.rows; @@ -154,18 +211,12 @@ create_pixmap (int pixel_size, int index) ximage.bytes_per_line = face->glyph->bitmap.pitch; XInitImage (&ximage); pixmap = XCreatePixmap (display, DefaultRootWindow (display), - glyph_width, height, 1); - XFillRectangle (display, pixmap, gc, 0, 0, glyph_width, height); + glyph_width, glyph_height, 1); + XFillRectangle (display, pixmap, gc, 0, 0, glyph_width, glyph_height); XPutImage (display, pixmap, gc, &ximage, 0, 0, glyph_x + face->glyph->bitmap_left, glyph_y - face->glyph->bitmap_top, ximage.width, ximage.height); - sprintf (index_buf, "%04X", index); - XDrawLine (display, pixmap, gc_inv, - 0, glyph_height + 1, glyph_width, glyph_height + 1); - XDrawString (display, pixmap, gc_inv, - (glyph_width - XTextWidth (font, index_buf, 4)) / 2, - height - FONT_DESCENT, index_buf, 4); bitmap[index].pixmap = pixmap; bitmap[index].width = ximage.width; bitmap[index].height = ximage.height; @@ -180,6 +231,7 @@ update_glyph_area () int i; Arg arg[2]; char buf[16]; + int msb; for (i = 0; i < 128; i++) { @@ -187,19 +239,316 @@ update_glyph_area () if (charmap_index >= 0) index = FT_Get_Char_Index (face, (FT_ULong) index); - if (bitmap[index].pixmap) - XtSetArg (arg[0], XtNbitmap, bitmap[index].pixmap); - else + if (charmap_index >= 0 && ! index) XtSetArg (arg[0], XtNbitmap, none_pixmap); + else + { + if (! bitmap[index].pixmap) + create_pixmap (index); + XtSetArg (arg[0], XtNbitmap, bitmap[index].pixmap); + } XtSetValues (glyph[i], arg, 1); } - sprintf (buf, " %04X-%04X ", glyph_index, glyph_index + 0x7F); + msb = (glyph_index >> 7) % 2 ? 8 : 0; + for (i = 0; i < 8; i++) + { + char str[3]; + + sprintf (str, "%XX", i | msb ); + XtSetArg (arg[0], XtNheight, glyph_height + 5); + XtSetArg (arg[1], XtNlabel, str); + XtSetValues (index_label[i], arg, 2); + } + + if (glyph_index < 0x10000) + sprintf (buf, " %04X-%04X ", glyph_index, glyph_index + 0x7F); + else + sprintf (buf, "%06X-%06X", glyph_index, glyph_index + 0x7F); XtSetArg (arg[0], XtNlabel, buf); - XtSetValues (label, arg, 1); + XtSetValues (range, arg, 1); +} + +void +update_uvs_area (int c) +{ + OTF_GlyphID code[256]; + Arg arg[1]; + int i; + + OTF_get_variation_glyphs (otf, c, code); + + for (i = 0; i < 256; i++) + if (uvs[i].w) + { + if (code[i]) + XtSetArg (arg[0], XtNsensitive, True); + else + XtSetArg (arg[0], XtNsensitive, False); + XtSetValues (uvs[i].w, arg, 1); + } +} + + +char * +get_features (OTF_FeatureList *list, FeatureRec *rec) +{ + int i, n; + char *str, *p; + + if (! rec->langsys || ! rec->features || ! rec->features[0].on) + return NULL; + for (i = n = 0; i < rec->langsys->FeatureCount; i++) + { + if (rec->features[i].on) + n++; + else + break; + } + str = malloc (n * 5); + for (i = 0, p = str; i < n; i++, p += 5) + { + OTF_tag_name (rec->features[i].tag, p); + p[4] = ','; + } + p[-1] = '\0'; + return str; +} + + +#define DEVICE_DELTA(table, size) \ + (((table).DeltaValue \ + && ((size) >= (table).StartSize && (size) <= (table).EndSize)) \ + ? (table).DeltaValue[(size) >= (table).StartSize] \ + : 0) + +void +adjust_anchor (OTF_Anchor *anchor, FT_Face ft_face, + OTF_Glyph *g, int *x, int *y) +{ + if (anchor->AnchorFormat == 2) + { + FT_Outline *outline; + int ap = anchor->f.f1.AnchorPoint; + + FT_Load_Glyph (ft_face, (FT_UInt) g->glyph_id, FT_LOAD_MONOCHROME); + outline = &ft_face->glyph->outline; + if (ap < outline->n_points) + { + *x = outline->points[ap].x; + *y = outline->points[ap].y; + } + } + else if (anchor->AnchorFormat == 3) + { + *x += DEVICE_DELTA (anchor->f.f2.XDeviceTable, pixel_size); + *y += DEVICE_DELTA (anchor->f.f2.YDeviceTable, pixel_size); + } } void +update_seq_area () +{ + int i, x; + OTF_GlyphString gstring; + OTF_Glyph *g, *prev, *base, *mark; + int base_width; + int len = glyph_rec.n_glyphs; + Arg arg[1]; + int unitsPerEm = face->units_per_EM; + + gstring.size = gstring.used = len; + gstring.glyphs = malloc (sizeof (OTF_Glyph) * len); + memset (gstring.glyphs, 0, sizeof (OTF_Glyph) * len); + for (i = 0; i < len; i++) + { + gstring.glyphs[i].c = glyph_rec.codes[i]; + if (charmap_index < 0) + gstring.glyphs[i].glyph_id = glyph_rec.glyphs[i]; + } + + XFillRectangle (display, seq_pixmap, gc, 0, 0, render_width, render_height); + XDrawLine (display, seq_pixmap, gc_set, 0, glyph_y, render_width, glyph_y); + if (otf) + { + char *script_name = NULL, *langsys_name = NULL, buf[10]; + char *str; + + if (script_tag) + { + script_name = buf; + OTF_tag_name (script_tag, script_name); + } + if (langsys_tag) + { + langsys_name = buf + 5; + OTF_tag_name (langsys_tag, langsys_name); + } + + OTF_drive_cmap (otf, &gstring); + OTF_drive_gdef (otf, &gstring); + if (otf->gsub) + { + str = get_features (&otf->gsub->FeatureList, &gsub); + if (str) + { + if (do_alternate_subst) + OTF_drive_gsub_alternate (otf, &gstring, + script_name, langsys_name, str); + else + OTF_drive_gsub (otf, &gstring, script_name, langsys_name, str); + free (str); + } + } + if (otf->gpos) + { + str = get_features (&otf->gpos->FeatureList, &gpos); + if (str) + { + OTF_drive_gpos2 (otf, &gstring, script_name, langsys_name, str); + free (str); + } + } + } + + prev = NULL; + if (reversed) + { + OTF_Glyph temp; + + for (prev = gstring.glyphs, g = gstring.glyphs + gstring.used - 1; + prev < g; prev++, g--) + temp = *prev, *prev = *g, *g = temp; + for (g = gstring.glyphs; g < gstring.glyphs + gstring.used; g++) + if (g->GlyphClass == 3) + { + OTF_Glyph *g0; + prev = g++; + while (g < gstring.glyphs + gstring.used && g->GlyphClass == 3) + g++; + for (g0 = g; prev < g0; prev++, g0--) + temp = *prev, *prev = *g, *g = temp; + } + } + + + mark = base = NULL; + for (i = 0, x = glyph_x, prev = NULL, g = gstring.glyphs; + i < gstring.used; i++, prev = g++) + { + BitmapRec *bmp = bitmap + gstring.glyphs[i].glyph_id; + int xoff = 0, yoff = 0; + int prev_width; + int advance = bmp->advance; + + if (gstring.glyphs[i].glyph_id && ! bmp->pixmap) + { + create_pixmap (gstring.glyphs[i].glyph_id); + if (! bmp->pixmap) + continue; + advance = bmp->advance; + } + if (g->positioning_type) + { + while (1) + { + switch (g->positioning_type) + { + case 1: case 2: + { + int format = g->f.f1.format; + + if (format & OTF_XPlacement) + xoff += g->f.f1.value->XPlacement * pixel_size / unitsPerEm; + if (format & OTF_XPlaDevice) + xoff += DEVICE_DELTA (g->f.f1.value->XPlaDevice, pixel_size); + if (format & OTF_YPlacement) + yoff += g->f.f1.value->YPlacement * pixel_size / unitsPerEm; + if (format & OTF_YPlaDevice) + yoff += DEVICE_DELTA (g->f.f1.value->YPlaDevice, pixel_size); + if (format & OTF_XAdvance) + advance += g->f.f1.value->XAdvance * pixel_size / unitsPerEm; + if (format & OTF_XAdvDevice) + advance += DEVICE_DELTA (g->f.f1.value->XAdvDevice, + pixel_size); + } + break; + + case 3: + /* Not yet supported. */ + break; + case 4: case 5: + if (! base) + break; + prev = base; + prev_width = base_width; + goto label_adjust_anchor; + default: /* i.e. case 6 */ + if (! mark) + break; + prev = mark; + prev_width = 0; + label_adjust_anchor: + { + int base_x, base_y, mark_x, mark_y; + + base_x = g->f.f4.base_anchor->XCoordinate * pixel_size / unitsPerEm; + base_y = g->f.f4.base_anchor->YCoordinate * pixel_size / unitsPerEm; + mark_x = g->f.f4.mark_anchor->XCoordinate * pixel_size / unitsPerEm; + mark_y = g->f.f4.mark_anchor->YCoordinate * pixel_size / unitsPerEm; + + if (g->f.f4.base_anchor->AnchorFormat != 1) + adjust_anchor (g->f.f4.base_anchor, face, prev, &base_x, &base_y); + if (g->f.f4.mark_anchor->AnchorFormat != 1) + adjust_anchor (g->f.f4.mark_anchor, face, g, &mark_x, &mark_y); + xoff = (base_x - prev_width) - mark_x; + yoff = base_y - mark_y; + } + } + if (i + 1 == gstring.used + || gstring.glyphs[i + 1].glyph_id + || ! gstring.glyphs[i + 1].positioning_type) + break; + i++, g++; + } + } + + XCopyArea (display, bmp->pixmap, seq_pixmap, gc_or, + glyph_x + bmp->x, glyph_y + bmp->y, bmp->width, bmp->height, + x + bmp->x + xoff, glyph_y + bmp->y - yoff); + x += advance; + + if (g->GlyphClass == OTF_GlyphClass0) + base = mark = g, base_width = advance; + else if (g->GlyphClass == OTF_GlyphClassMark) + mark = g; + else + base = g, base_width = advance; + } + + XtSetArg (arg[0], XtNbitmap, seq_pixmap); + XtSetValues (seq_image, arg, 1); + + if (gstring.used > 0) + { + int size = render_width / FONT_WIDTH; + char *buf = alloca (size + 1); + + sprintf (buf, "%04X", gstring.glyphs[0].glyph_id); + for (i = 1, x = 4; i < gstring.used; i++, x += 5) + sprintf (buf + x, " %04X", gstring.glyphs[i].glyph_id); + while (x < size) + buf[x] = ' '; + buf[x] = '\0'; + XtSetArg (arg[0], XtNlabel, buf); + XtSetValues (code_list, arg, 1); + } + + free (gstring.glyphs); +} + + +void update_render_area () { int i; @@ -207,48 +556,56 @@ update_render_area () Arg arg[1]; XFillRectangle (display, raw_pixmap, gc, 0, 0, render_width, render_height); - XFillRectangle (display, seq_pixmap, gc, 0, 0, render_width, render_height); for (i = 0, x = glyph_x; i < glyph_rec.n_glyphs; i++) { - BitmapRec *bmp = bitmap + glyph_rec.glyphs[i]; - char buf[5]; - - XCopyArea (display, bmp->pixmap, raw_pixmap, gc, - 0, 0, glyph_width, glyph_height, - (glyph_width + 1) * i + 1, 1); - XDrawRectangle (display, raw_pixmap, gc_set, - (glyph_width + 1) * i, 0, - glyph_width + 1, glyph_height + 1); - XDrawLine (display, raw_pixmap, gc_set, - (glyph_width + 1) * i + 1 + glyph_x, 1, - (glyph_width + 1) * i + 1 + glyph_x, glyph_height + 1); - XDrawLine (display, raw_pixmap, gc_set, - (glyph_width + 1) * i + 1 + glyph_x + bmp->advance, 1, - (glyph_width + 1) * i + 1 + glyph_x + bmp->advance, - glyph_height + 1); - - sprintf (buf, "%04X", glyph_rec.codes[i]); - XDrawString (display, raw_pixmap, gc_inv, - (glyph_width + 1) * i + 1 - + (glyph_width - XTextWidth (font, buf, 4)) / 2, - glyph_height + 2 + FONT_HEIGHT, buf, 4); - XCopyArea (display, bmp->pixmap, seq_pixmap, gc_or, - glyph_x + bmp->x, glyph_y + bmp->y, bmp->width, bmp->height, - x + bmp->x, glyph_y + bmp->y); - x += bmp->advance; + if (glyph_rec.glyphs[i] >= 0) + { + BitmapRec *bmp = bitmap + glyph_rec.glyphs[i]; + char buf[5]; + + XCopyArea (display, bmp->pixmap, raw_pixmap, gc, + 0, 0, glyph_width, glyph_height, + (glyph_width + 4) * i + 1, 1); + XDrawRectangle (display, raw_pixmap, gc_set, + (glyph_width + 4) * i, 0, + glyph_width + 1, glyph_height + 1); + XDrawLine (display, raw_pixmap, gc_set, + (glyph_width + 4) * i + 1 + glyph_x, 1, + (glyph_width + 4) * i + 1 + glyph_x, glyph_height + 1); + XDrawLine (display, raw_pixmap, gc_set, + (glyph_width + 4) * i + 1 + glyph_x + bmp->advance, 1, + (glyph_width + 4) * i + 1 + glyph_x + bmp->advance, + glyph_height + 1); + + sprintf (buf, "%04X", glyph_rec.codes[i]); + XDrawString (display, raw_pixmap, gc_inv, + (glyph_width + 4) * i + 1 + + (glyph_width - XTextWidth (font, buf, 4)) / 2, + glyph_height + 2 + FONT_HEIGHT, buf, 4); + } + else + { + /* Variation Selector */ + int idx = - glyph_rec.glyphs[i]; + char buf[4]; + + sprintf (buf, "%03d", idx); + XDrawRectangle (display, raw_pixmap, gc_set, + (glyph_width + 4) * i, 0, + glyph_width + 1, glyph_height + 1); + XDrawString (display, raw_pixmap, gc_set, + (glyph_width + 4) * i + 1 + + (glyph_width - XTextWidth (font, "VS", 2)) / 2, + 1 + glyph_height / 2, "VS", 2); + XDrawString (display, raw_pixmap, gc_set, + (glyph_width + 4) * i + 1 + + (glyph_width - XTextWidth (font, buf, 3)) / 2, + 1 + glyph_height / 2 + FONT_ASCENT, buf, 3); + } } XtSetArg (arg[0], XtNbitmap, raw_pixmap); XtSetValues (raw_image, arg, 1); - XtSetArg (arg[0], XtNbitmap, seq_pixmap); - XtSetValues (seq_image, arg, 1); - if (! otf) - return; - XFillRectangle (display, gsub_pixmap, gc, 0, 0, render_width, render_height); - XFillRectangle (display, gpos_pixmap, gc, 0, 0, render_width, render_height); - XtSetArg (arg[0], XtNbitmap, gsub_pixmap); - XtSetValues (gsub_image, arg, 1); - XtSetArg (arg[0], XtNbitmap, gpos_pixmap); - XtSetValues (gpos_image, arg, 1); + update_seq_area (); } void @@ -258,124 +615,136 @@ QuitProc (Widget w, XtPointer client_data, XtPointer call_data) } void -DumpProc (Widget w, XtPointer client_data, XtPointer pixel_size) +DumpProc (Widget w, XtPointer client_data, XtPointer call_data) { - int g_width, g_height, g_x, g_y, pix_width, pix_height; - int margin = 20 * 300 / 25.4; - int a4_width = 210 * 300 / 25.4 - margin * 2; - int a4_height = 297 * 300 / 25.4 - margin * 2; - int size = 100; - Pixmap pixmap; - XImage ximage, *image; - int i, x, y; - char *data; - int bytes_per_line; + int g_width, g_height; + float g_x, g_y; + /* unit in points (1/72 inch); to fit in both US-letter and A4 */ + static int xoff = 30, yoff = 30; + static int unit = 30; + static int margin = 2; + static int title_height = 20, label_height = 10; + int total_width = (unit + margin * 2) * 16; + int total_height = (unit + margin * 2 + label_height) * 16 + title_height; + /* pixel size (dots) */ + int size = 128; + int i, j, k, l; + char *name = alloca (strlen (filename) + 10); + FILE *fp; + int index = (glyph_index / 0x100) * 0x100; + float scale; + + g_width = face->bbox.xMax - face->bbox.xMin; + g_height = face->bbox.yMax - face->bbox.yMin; + if (g_width > g_height) + { + scale = g_width * size; + g_x = face->bbox.xMin * unit / g_width; + g_y = face->bbox.yMin * unit / g_width; + } + else + { + scale = g_height * size; + g_x = face->bbox.xMin * unit / g_height; + g_y = face->bbox.yMin * unit / g_height; + } + scale /= face->units_per_EM; FT_Set_Pixel_Sizes (face, 0, size); - g_width = ((face->bbox.xMax - face->bbox.xMin) * size / face->units_per_EM); - g_height = ((face->bbox.yMax - face->bbox.yMin) * size / face->units_per_EM); - pix_width = (g_width + 1) * 16 + margin + 1; - pix_height = (g_height + 1 + FONT_HEIGHT) * 16 + margin + 1; - while (pix_width > a4_width || pix_height > a4_height) - { - size--; - FT_Set_Pixel_Sizes (face, 0, size); - g_width = ((face->bbox.xMax - face->bbox.xMin) - * size / face->units_per_EM); - g_height = ((face->bbox.yMax - face->bbox.yMin) - * size / face->units_per_EM); - pix_width = (g_width + 1) * 16 + margin + 1; - pix_height = (g_height + 1 + FONT_HEIGHT) * 16 + margin + 1; - } - - g_x = - (face->bbox.xMin * size / face->units_per_EM); - g_y = face->bbox.yMax * size / face->units_per_EM; - for (i = 0; i < 0x10000; i++) - if (FT_Load_Glyph (face, i, FT_LOAD_RENDER | FT_LOAD_MONOCHROME) == 0) + + sprintf (name, "%s-%04X.ps", face->family_name, index); + printf ("Writing %s ... ", name); + fflush (stdout); + fp = fopen (name, "w"); + + fprintf (fp, "%s\n", "%!PS-Adobe-2.0 EPSF-2.0"); + fprintf (fp, "%s\n", "%%Creater: otfview"); + fprintf (fp, "%s %s(%s)-%04X\n", "%%Title:", + face->family_name, face->style_name, index); + fprintf (fp, "%s\n", "%%Pages: 1"); + fprintf (fp, "%s %d %d %d %d\n", "%%BoundingBox:", + xoff, yoff, xoff + total_width, yoff + total_height); + fprintf (fp, "%s\n", "%%EndComments"); + fprintf (fp, "%s\n", "%%BeginProlog"); + fprintf (fp, "/W %d def\n", unit + margin * 2); + fprintf (fp, "/H %d def\n", unit + margin * 2 + label_height); + fprintf (fp, "/STR 10 string def\n"); + fprintf (fp, "/DrawIndex {\n"); + fprintf (fp, " I 16 lt { (000) show } { I 256 lt { (00) show } { I 4096 lt { (0) show} if } ifelse } ifelse I 16 STR cvrs show\n"); + fprintf (fp, "} def\n"); + fprintf (fp, "/DrawTitle {\n"); + fprintf (fp, " /Courier findfont 20 scalefont setfont\n"); + fprintf (fp, " %d %d 4 add moveto\n", xoff + total_width / 2, + yoff + total_height - title_height + 2); + fprintf (fp, " (%s(%s)-%04X) dup stringwidth pop 2 div neg 0 rmoveto show\n", + face->family_name, face->style_name, index); + fprintf (fp, "} def\n"); + fprintf (fp, "/DrawFrame { gsave %d %d translate 0 setlinewidth\n", + xoff, yoff); + fprintf (fp, " /Courier findfont 10 scalefont setfont\n"); + fprintf (fp, " /I %d def\n", index); + fprintf (fp, " 0 1 16 { W mul 0 moveto 0 H 16 mul rlineto stroke } for\n"); + fprintf (fp, " 0 1 16 { H mul 0 exch moveto W 16 mul 0 rlineto stroke } for\n"); + fprintf (fp, " 0 1 15 { H mul %d add 0 exch moveto W 16 mul 0 rlineto stroke } for\n", label_height); + fprintf (fp, " 15 -1 0 { gsave H mul 0 exch translate 0 0 moveto\n"); + fprintf (fp, " 0 1 15 { gsave W mul 0 moveto\n"); + fprintf (fp, " 4 2 rmoveto DrawIndex /I I 1 add def grestore} for\n"); + fprintf (fp, " grestore } for grestore } def\n"); + fprintf (fp, "%s\n", "%%EndProlog"); + fprintf (fp, "DrawTitle DrawFrame\n"); + + for (i = 0; i < 16; i++) + for (j = 0; j < 16; j++, index++) { - if (g_x < - face->glyph->bitmap_left) - g_x = - face->glyph->bitmap_left; - if (g_y < face->glyph->bitmap_top) - g_y = face->glyph->bitmap_top; - if (g_width - < g_x + face->glyph->bitmap_left + face->glyph->bitmap.width) - g_width - = g_x + face->glyph->bitmap_left + face->glyph->bitmap.width; - if (g_height - < g_y - face->glyph->bitmap_top + face->glyph->bitmap.rows) - g_height - = g_y - face->glyph->bitmap_top + face->glyph->bitmap.rows; + int idx; + + if (charmap_index >= 0) + idx = FT_Get_Char_Index (face, (FT_ULong) index); + else + idx = index; + if (idx > 0 + && FT_Load_Glyph (face, idx, FT_LOAD_RENDER | FT_LOAD_MONOCHROME) == 0 + && face->glyph->bitmap.rows > 0 + && face->glyph->bitmap.width > 0) + { + unsigned char *p = face->glyph->bitmap.buffer; + int width = (face->glyph->bitmap.width - 1) / 8 + 1; + + fprintf (fp, "gsave %f %f translate %d %d scale 0 0 moveto\n", + xoff + (unit + margin * 2) * j + margin - g_x, + yoff + (unit + label_height + margin * 2) * (15 - i) + label_height + margin - g_y, + unit, unit); + fprintf (fp, "%d %d true [%f 0 0 %f %d %d]\n", + width * 8, face->glyph->bitmap.rows, + scale, -scale, -face->glyph->bitmap_left, + face->glyph->bitmap_top); + fprintf (fp, "{< "); + for (k = 0; k < face->glyph->bitmap.rows; + k++, p += face->glyph->bitmap.pitch) + { + for (l = 0; l < width; l++) + fprintf (fp, "%02X", p[l]); + fprintf (fp, "\n"); + } + fprintf (fp, ">} imagemask grestore\n"); + } + else + { + int boxsize = unit + margin * 2; + + fprintf (fp, "gsave 0 setlinewidth %d %d translate\n", + xoff + boxsize * j, + yoff + (boxsize + label_height) * (15 - i) + label_height); + fprintf (fp, "0 0 moveto %d %d lineto stroke\n", + boxsize, boxsize); + fprintf (fp, "0 %d moveto %d 0 lineto stroke grestore\n", + boxsize, boxsize); + } } - pix_width = (g_width + 1) * 16 + margin + 1; - pix_height = (g_height + FONT_HEIGHT + 1) * 16 + margin + 1; - pixmap = XCreatePixmap (display, - RootWindow (display, DefaultScreen (display)), - pix_width, pix_height, 1); - XFillRectangle (display, pixmap, gc, 0, 0, pix_width, pix_height); - - for (i = 0, x = margin; i <= 16; i++, x += g_width + 1) - XDrawLine (display, pixmap, gc_set, x, margin, - x, margin + (g_height + FONT_HEIGHT + 1) * 16); - for (i = 0, y = margin; i <= 16; i++, y += g_height + FONT_HEIGHT + 1) - XDrawLine (display, pixmap, gc_set, margin, y, - margin + (g_width + 1) * 16, y); - for (i = 0; i < 256; i++) - { - char str[5]; - int idx; + fprintf (fp, "showpage\n"); + fclose (fp); + printf ("done\n"); - if (charmap_index >= 0) - idx = FT_Get_Char_Index (face, (FT_ULong) i); - else - idx = i; - x = margin + (g_width + 1) * (i % 16); - y = margin + (g_height + FONT_HEIGHT + 1) * (i / 16); - if (FT_Load_Glyph (face, idx, FT_LOAD_RENDER | FT_LOAD_MONOCHROME) == 0) - { - ximage.height = face->glyph->bitmap.rows; - ximage.width = face->glyph->bitmap.width; - ximage.depth = 1; - ximage.bits_per_pixel = 1; - ximage.xoffset = 0; - ximage.format = XYPixmap; - ximage.data = (char *) face->glyph->bitmap.buffer; - ximage.byte_order = MSBFirst; - ximage.bitmap_unit = 8; - ximage.bitmap_bit_order = MSBFirst; - ximage.bitmap_pad = 8; - ximage.bytes_per_line = face->glyph->bitmap.pitch; - XInitImage (&ximage); - XPutImage (display, pixmap, gc, &ximage, 0, 0, - x + g_x + face->glyph->bitmap_left, - y + g_y - face->glyph->bitmap_top, - ximage.width, ximage.height); - } - sprintf (str, "0x%02X", i); - XDrawString (display, pixmap, gc_inv, - x + (g_width - XTextWidth (font, str, 4))/ 2, - y + g_height + FONT_ASCENT, str, 4); - } - - image = XGetImage (display, pixmap, 0, 0, pix_width, pix_height, - AllPlanes, XYPixmap); - XInitImage (image); - { - char *name = alloca (strlen (filename) + 5); - FILE *fp; - - sprintf (name, "%s.pbm", filename); -#if 1 - fp = fopen (name, "w"); - fprintf (fp, "P4\n%d %d\n", image->width, image->height); - bytes_per_line = (image->width + 7) / 8; - data = image->data; - for (y = 0; y < image->height; y++, data += image->bytes_per_line) - fwrite (data, 1, bytes_per_line, fp); - fclose (fp); -#else - XWriteBitmapFile (display, name, pixmap, pix_width, pix_height, 0, 0); -#endif - } FT_Set_Pixel_Sizes (face, 0, (int) pixel_size); } @@ -384,19 +753,22 @@ void GlyphProc (Widget w, XtPointer client_data, XtPointer call_data) { int old_glyph_index = glyph_index; + int data; - if ((int) client_data == -3 && glyph_index > 0) + CAST_FROM_XTPOINTER (int, client_data, data); + + if (data == -3 && glyph_index > 0) glyph_index = 0; - else if ((int) client_data == -2 && glyph_index > 0) - glyph_index = (glyph_index - 1) & 0xF000; - else if ((int) client_data == -1 && glyph_index > 0) + else if (data == -2 && glyph_index > 0) + glyph_index = (glyph_index - 1) & 0x1FF000; + else if (data == -1 && glyph_index > 0) glyph_index -= 0x80; - else if ((int) client_data == 1 && glyph_index < 0xFF80) + else if (data == 1 && glyph_index < 0x10FF80) glyph_index += 0x80; - else if ((int) client_data == 2 && glyph_index < 0xF000) - glyph_index = (glyph_index + 0x1000) & 0xF000; - else if ((int) client_data == 3 && glyph_index < 0xF000) - glyph_index = 0xFF80; + else if (data == 2 && glyph_index < 0x10F000) + glyph_index = (glyph_index + 0x1000) & 0x1FF000; + else if (data == 3 && glyph_index < 0x10F000) + glyph_index = 0x10FF80; if (glyph_index != old_glyph_index) update_glyph_area (); } @@ -404,52 +776,502 @@ GlyphProc (Widget w, XtPointer client_data, XtPointer call_data) void CharmapProc (Widget w, XtPointer client_data, XtPointer call_data) { - if (charmap_index == (int) client_data) + int data; + + CAST_FROM_XTPOINTER (int, client_data, data); + + if (charmap_index == data) return; - charmap_index = (int) client_data; + charmap_index = data; if (charmap_index >= 0) FT_Set_Charmap (face, face->charmaps[charmap_index]); update_glyph_area (); } void -RenderProc (Widget w, XtPointer client_data, XtPointer call_data) +UVSProc (Widget w, XtPointer client_data, XtPointer call_data) { - if ((int) client_data < 0) + unsigned idx; + int selector; + OTF_VariationSelectorRecord *record; + int i; + + CAST_FROM_XTPOINTER (unsigned, client_data, idx); + selector = uvs[idx].c; + + if (glyph_rec.n_glyphs >= 64) + return; + for (i = 0; i < sub14->nRecords; i++) { - glyph_rec.n_glyphs = 0; + record = sub14->Records + i; + if (record->varSelector == selector) + break; + } + if (i < sub14->nRecords) + { + if (glyph_rec.n_glyphs > 0 + && glyph_rec.glyphs[glyph_rec.n_glyphs - 1] < 0) + glyph_rec.n_glyphs--; + glyph_rec.codes[glyph_rec.n_glyphs] = selector; + glyph_rec.glyphs[glyph_rec.n_glyphs++] = - idx - 1; update_render_area (); } +} + +void +RenderProc (Widget w, XtPointer client_data, XtPointer call_data) +{ + int data; + + CAST_FROM_XTPOINTER (int, client_data, data); + + if (data < 0) + { + if (glyph_rec.n_glyphs > 0) + { + if (data == -2) + glyph_rec.n_glyphs--; + else + glyph_rec.n_glyphs = 0; + update_render_area (); + } + } else if (glyph_rec.n_glyphs < 64) { - int index = glyph_index + (int) client_data; + int index = glyph_index + data; if (charmap_index >= 0) index = FT_Get_Char_Index (face, (FT_ULong) index); if (bitmap[index].pixmap) { - glyph_rec.codes[glyph_rec.n_glyphs] = glyph_index + (int) client_data; + glyph_rec.codes[glyph_rec.n_glyphs] = glyph_index + data; glyph_rec.glyphs[glyph_rec.n_glyphs++] = index; + if (otf) + update_uvs_area (glyph_index + data); update_render_area (); } } } void -create_widgets (int pixel_size) +BidiProc (Widget w, XtPointer client_data, XtPointer call_data) +{ + Arg arg[1]; + + reversed = ! reversed; + if (reversed) + XtSetArg (arg[0], XtNlabel, "L<-R"); + else + XtSetArg (arg[0], XtNlabel, "L->R"); + XtSetValues (w, arg, 1); + update_seq_area (); +} + +void +AltSubstProc (Widget w, XtPointer client_data, XtPointer call_data) +{ + do_alternate_subst = ! do_alternate_subst; + update_seq_area (); +} + +void +FeatureProc (Widget w, XtPointer client_data, XtPointer call_data) +{ + FeatureRec *rec = (FeatureRec *) client_data; + int idx, i, j; + Arg arg[4]; + char *label; + + if (! rec->langsys) + return; + XtSetArg (arg[0], XtNlabel, &label); + XtGetValues (w, arg, 1); + if (! strcmp (label, "all")) + idx = -2; + else if (! strcmp (label, "none")) + idx = -1; + else + { + for (idx = 0; idx < rec->langsys->FeatureCount; idx++) + if (rec->features[idx].w == w) + break; + if (idx == rec->langsys->FeatureCount) + idx = -1; + } + if (idx < 0) + { + int on = idx == -2; + + for (i = j = 0; j < rec->langsys->FeatureCount; j++) + { + int index = rec->langsys->FeatureIndex[j]; + + rec->features[j].tag + = rec->gsub_gpos->FeatureList.Feature[index].FeatureTag; + rec->features[j].on = on; + } + } + else + { + OTF_Tag tag = rec->features[idx].tag; + + i = idx; + if (rec->features[i].on) + { + for (j = i + 1; + j < rec->langsys->FeatureCount && rec->features[j].on; j++) + rec->features[j - 1].tag = rec->features[j].tag; + rec->features[j - 1].tag = tag; + rec->features[j - 1].on = 0; + } + else + { + for (j = i + 1; i > 0 && ! rec->features[i - 1].on; i--) + rec->features[i].tag = rec->features[i - 1].tag; + rec->features[i].tag = tag; + rec->features[i].on = 1; + } + } + + for (; i < j; i++) + { + char str[5]; + + if (rec->features[i].on) + { + XtSetArg (arg[0], XtNborderWidth, 3); + XtSetArg (arg[1], XtNinternalHeight, 2); + XtSetArg (arg[2], XtNinternalWidth, 2); + } + else + { + XtSetArg (arg[0], XtNborderWidth, 1); + XtSetArg (arg[1], XtNinternalHeight, 4); + XtSetArg (arg[2], XtNinternalWidth, 4); + } + OTF_tag_name (rec->features[i].tag, str); + XtSetArg (arg[3], XtNlabel, str); + XtSetValues (rec->features[i].w, arg, 4); + } + update_seq_area (); +} + +void +setup_feature_rec (FeatureRec *rec) +{ + int i, j; + Arg arg[10]; + + rec->langsys = NULL; + if (! rec->gsub_gpos) + return; + for (i = 0; i < rec->gsub_gpos->ScriptList.ScriptCount; i++) + if (rec->gsub_gpos->ScriptList.Script[i].ScriptTag == script_tag) + { + OTF_Script *script = rec->gsub_gpos->ScriptList.Script + i; + + if (langsys_tag) + { + for (j = 0; j < script->LangSysCount; j++) + if (script->LangSysRecord[j].LangSysTag == langsys_tag) + { + rec->langsys = script->LangSys + j; + break; + } + } + if (! rec->langsys) + rec->langsys = &rec->gsub_gpos->ScriptList.Script[i].DefaultLangSys; + break; + } + + if (! rec->langsys) + i = 0; + else + { + XtSetArg (arg[0], XtNborderWidth, 1); + XtSetArg (arg[1], XtNinternalHeight, 4); + XtSetArg (arg[2], XtNinternalWidth, 4); + XtSetArg (arg[3], XtNborderColor, foreground); + XtSetArg (arg[4], XtNsensitive, True); + for (i = 0; i < rec->langsys->FeatureCount; i++) + { + OTF_Feature *feature = rec->gsub_gpos->FeatureList.Feature; + int index = rec->langsys->FeatureIndex[i]; + char label[5]; + + if (! rec->features[i].w) + { + Widget w = XtCreateManagedWidget ("", commandWidgetClass, + rec->parent, arg, 0); + XtAddCallback (w, XtNcallback, FeatureProc, (XtPointer) rec); + rec->features[i].w = w; + } + + rec->features[i].tag = feature[index].FeatureTag; + rec->features[i].on = 0; + OTF_tag_name (rec->features[i].tag, label); + XtSetArg (arg[5], XtNlabel, label); + XtSetValues (rec->features[i].w, arg, 6); + } + } + XtSetArg (arg[0], XtNborderColor, background); + XtSetArg (arg[1], XtNsensitive, False); + XtSetArg (arg[2], XtNlabel, " "); + for (; i < rec->num_features; i++) + { + if (! rec->features[i].w) + { + Widget w = XtCreateManagedWidget ("", commandWidgetClass, + rec->parent, arg, 0); + XtAddCallback (w, XtNcallback, FeatureProc, (XtPointer) rec); + rec->features[i].w = w; + } + XtSetValues (rec->features[i].w, arg, 3); + } +} + +void +compose_script_langsys (OTF_Tag script, OTF_Tag langsys, char *name) +{ + OTF_tag_name (script, name); + if (langsys) + { + name[4] = '('; + OTF_tag_name (langsys, name + 5); + name[9] = ')'; + name[10] = '\0'; + } +} + +void +decompose_script_langsys (OTF_Tag *script, OTF_Tag *langsys, char *name) +{ + *script = OTF_tag (name); + if (name[4]) + *langsys = OTF_tag (name + 5); + else + *langsys = 0; +} + +void +ScriptProc (Widget w, XtPointer client_data, XtPointer call_data) +{ + char *name; + OTF_Tag script, langsys; + Arg arg[1]; + + XtSetArg (arg[0], XtNlabel, &name); + XtGetValues (w, arg, 1); + decompose_script_langsys (&script, &langsys, name); + if (script_tag == script && langsys_tag == langsys) + return; + script_tag = script; + langsys_tag = langsys; + setup_feature_rec (&gsub); + setup_feature_rec (&gpos); + update_seq_area (); +} + +Widget +create_otf_script_widgets (Widget prev) +{ + Widget w; + Arg arg[10]; + int n, prev_n, i, j; + struct { + OTF_Tag script; + OTF_Tag langsys; + } *script_langsys; + char name[11]; + int nfeatures; + + XtSetArg (arg[0], XtNborderWidth, 0); + XtSetArg (arg[1], XtNleft, XawChainLeft); + XtSetArg (arg[2], XtNright, XawChainLeft); + XtSetArg (arg[3], XtNtop, XawChainTop); + XtSetArg (arg[4], XtNbottom, XawChainTop); + XtSetArg (arg[5], XtNfromVert, prev); + XtSetArg (arg[6], XtNorientation, XtorientHorizontal); + prev = XtCreateManagedWidget ("Script", boxWidgetClass, render_area, arg, 7); + XtCreateManagedWidget ("script(langsys)", labelWidgetClass, prev, arg, 1); + + n = 0; + if (otf->gsub) + for (i = 0; i < otf->gsub->ScriptList.ScriptCount; i++) + n += otf->gsub->ScriptList.Script[i].LangSysCount + 1; + if (otf->gpos) + for (i = 0; i < otf->gpos->ScriptList.ScriptCount; i++) + n += otf->gpos->ScriptList.Script[i].LangSysCount + 1; + script_langsys = alloca ((sizeof script_langsys[0]) * n); + n = 0; + nfeatures = 0; + if (otf->gsub) + for (i = 0; i < otf->gsub->ScriptList.ScriptCount; i++) + { + OTF_Tag tag = otf->gsub->ScriptList.Script[i].ScriptTag; + + script_langsys[n].script = tag; + script_langsys[n++].langsys = 0; + if (nfeatures + < otf->gsub->ScriptList.Script[i].DefaultLangSys.FeatureCount) + nfeatures + = otf->gsub->ScriptList.Script[i].DefaultLangSys.FeatureCount; + for (j = 0; j < otf->gsub->ScriptList.Script[i].LangSysCount; j++) + { + script_langsys[n].script = tag; + script_langsys[n++].langsys + = otf->gsub->ScriptList.Script[i].LangSysRecord[j].LangSysTag; + if (nfeatures + < otf->gsub->ScriptList.Script[i].LangSys[j].FeatureCount) + nfeatures + = otf->gsub->ScriptList.Script[i].LangSys[j].FeatureCount; + } + } + gsub.num_features = nfeatures; + if (nfeatures > 0) + { + gsub.num_features = nfeatures; + gsub.features = malloc ((sizeof (FeatureElement)) * nfeatures); + memset (gsub.features, 0, (sizeof (FeatureElement)) * nfeatures); + } + prev_n = n; + nfeatures = 0; + if (otf->gpos) + for (i = 0; i < otf->gpos->ScriptList.ScriptCount; i++) + { + OTF_Tag tag = otf->gpos->ScriptList.Script[i].ScriptTag; + int k; + + if (nfeatures + < otf->gpos->ScriptList.Script[i].DefaultLangSys.FeatureCount) + nfeatures + = otf->gpos->ScriptList.Script[i].DefaultLangSys.FeatureCount; + for (k = 0; k < prev_n; k++) + if (tag == script_langsys[k].script) + break; + if (k == prev_n) + { + script_langsys[n].script = tag; + script_langsys[n++].langsys = 0; + } + for (j = 0; j < otf->gpos->ScriptList.Script[i].LangSysCount; j++) + { + int l; + + if (k < prev_n) + { + OTF_Script *script = otf->gpos->ScriptList.Script + i; + + for (l = k; l < prev_n && tag == script_langsys[l].script; l++) + if (script->LangSysRecord[j].LangSysTag + == script_langsys[l].langsys) + break; + } + else + l = prev_n; + if (l == prev_n) + { + script_langsys[n].script = tag; + script_langsys[n++].langsys = 0; + } + if (nfeatures + < otf->gpos->ScriptList.Script[i].LangSys[j].FeatureCount) + nfeatures + = otf->gpos->ScriptList.Script[i].LangSys[j].FeatureCount; + } + } + + if (nfeatures > 0) + { + gpos.num_features = nfeatures; + gpos.features = malloc ((sizeof (FeatureElement)) * nfeatures); + memset (gpos.features, 0, (sizeof (FeatureElement)) * nfeatures); + } + + if (n == 0) + return prev; + + script_tag = script_langsys[0].script; + langsys_tag = script_langsys[0].langsys; + compose_script_langsys (script_tag, langsys_tag, name); + + if (n == 1) + { + XtSetArg (arg[0], XtNforeground, background); + XtSetArg (arg[1], XtNbackground, foreground); + XtCreateManagedWidget (name, labelWidgetClass, prev, arg, 2); + } + else + { + XtSetArg (arg[0], XtNstate, True); + w = XtCreateManagedWidget (name, toggleWidgetClass, prev, arg, 1); + XtAddCallback (w, XtNcallback, ScriptProc, NULL); + XtSetArg (arg[0], XtNradioGroup, w); + for (i = 1; i < n; i++) + { + compose_script_langsys (script_langsys[i].script, + script_langsys[i].langsys, name); + w = XtCreateManagedWidget (name, toggleWidgetClass, prev, arg, 1); + XtAddCallback (w, XtNcallback, ScriptProc, NULL); + } + } + return prev; +} + + +Widget +create_otf_widgets (Widget prev, FeatureRec *rec) +{ + Arg arg[10]; + Widget w; + + XtSetArg (arg[0], XtNborderWidth, 0); + XtSetArg (arg[1], XtNleft, XawChainLeft); + XtSetArg (arg[2], XtNright, XawChainLeft); + XtSetArg (arg[3], XtNtop, XawChainTop); + XtSetArg (arg[4], XtNbottom, XawChainTop); + XtSetArg (arg[5], XtNfromVert, prev); + XtSetArg (arg[6], XtNorientation, XtorientHorizontal); + prev = XtCreateManagedWidget (rec->label, boxWidgetClass, render_area, + arg, 7); + XtCreateManagedWidget (rec->label, labelWidgetClass, prev, arg, 1); + XtSetArg (arg[0], XtNborderWidth, 1); + XtSetArg (arg[1], XtNinternalHeight, 4); + XtSetArg (arg[2], XtNinternalWidth, 4); + w = XtCreateManagedWidget ("all", commandWidgetClass, prev, arg, 3); + XtAddCallback (w, XtNcallback, FeatureProc, (XtPointer) rec); + w = XtCreateManagedWidget ("none", commandWidgetClass, prev, arg, 3); + XtAddCallback (w, XtNcallback, FeatureProc, (XtPointer) rec); + + rec->parent = prev; + setup_feature_rec (rec); + return prev; +} + +void +create_widgets () { String quit_action = "q: set() notify() unset()"; - String FIRST_action = "~Shiftf: set() notify() unset()"; - String PREV_action = "Shiftp: set() notify() unset()"; - String prev_action = "~Shiftp: set() notify() unset()"; - String next_action = "~Shiftn: set() notify() unset()"; - String NEXT_action = "Shiftn: set() notify() unset()"; - String LAST_action = "~Shiftl: set() notify() unset()"; + String FIRST_action = "f: set() notify() unset()\n\ + Home: set() notify() unset()"; + String PREV_action = "Shiftp: set() notify() unset()\n\ + Up: set() notify() unset()"; + String prev_action = "~Shiftp: set() notify() unset()\n\ + Left: set() notify() unset()"; + String next_action = "~Shiftn: set() notify() unset()\n\ + Right: set() notify() unset()"; + String NEXT_action = "Shiftn: set() notify() unset()\n\ + Down: set() notify() unset()"; + String LAST_action = "l: set() notify() unset()\n\ + End: set() notify() unset()"; Arg arg[10]; int i, j; - int glyph_widget_height; + Widget prev, w; + String trans = ": Expose()"; + + XtSetArg (arg[0], XtNtranslations, XtParseTranslationTable (trans)); + frame = XtCreateManagedWidget ("frame", formWidgetClass, shell, arg, 1); - frame = XtCreateManagedWidget ("frame", formWidgetClass, shell, NULL, 0); XtSetArg (arg[0], XtNleft, XawChainLeft); XtSetArg (arg[1], XtNright, XawChainLeft); XtSetArg (arg[2], XtNtop, XawChainTop); @@ -461,13 +1283,46 @@ create_widgets (int pixel_size) XtSetArg (arg[6], XtNfromVert, command_area); navi_area = XtCreateManagedWidget ("navi-area", boxWidgetClass, frame, arg, 7); - XtSetArg (arg[4], XtNborderWidth, 1); + XtSetArg (arg[4], XtNborderWidth, 0); XtSetArg (arg[5], XtNfromVert, navi_area); XtSetArg (arg[6], XtNdefaultDistance, 0); glyph_area = XtCreateManagedWidget ("glyph-area", formWidgetClass, frame, arg, 7); - XtSetArg (arg[4], XtNborderWidth, 0); + XtSetArg (arg[5], XtNfromVert, glyph_area); + if (sub14) + { + Arg arg2[3]; + + XtSetArg (arg[6], XtNorientation, XtorientHorizontal); + uvs_area = XtCreateManagedWidget ("uvs-area", boxWidgetClass, + frame, arg, 7); + XtSetArg (arg2[0], XtNborderWidth, 0); + XtSetArg (arg2[1], XtNlabel, "Variation Selector: "); + uvs_label = XtCreateManagedWidget ("uvs-label", labelWidgetClass, + uvs_area, arg2, 2); + XtSetArg (arg2[0], XtNborderWidth, 1); + for (i = 0; i < sub14->nRecords; i++) + { + OTF_VariationSelectorRecord *record = sub14->Records + i; + unsigned selector = record->varSelector; + unsigned idx; + char lbl[4]; + + idx = (selector <= 0xFE0F ? selector - 0xFE00 + : selector - 0xE0100 + 16); + if (uvs[idx].c) + continue; + uvs[idx].c = selector; + sprintf (lbl, "%03d", idx + 1); + XtSetArg (arg2[1], XtNlabel, lbl); + XtSetArg (arg2[2], XtNsensitive, False); + uvs[idx].w = XtCreateManagedWidget ("lbl", commandWidgetClass, + uvs_area, arg2, 3); + XtAddCallbackWithCast (unsigned, uvs[idx].w, UVSProc, idx); + } + XtSetArg (arg[5], XtNfromVert, uvs_area); + } render_area = XtCreateManagedWidget ("render-area", formWidgetClass, frame, arg, 6); @@ -476,9 +1331,13 @@ create_widgets (int pixel_size) command_area, arg, 1); XtAddCallback (quit, XtNcallback, QuitProc, NULL); - dump = XtCreateManagedWidget ("Dump Image", commandWidgetClass, + dump = XtCreateManagedWidget ("DumpImage", commandWidgetClass, command_area, arg, 1); - XtAddCallback (dump, XtNcallback, DumpProc, (XtPointer) pixel_size); + XtAddCallback (dump, XtNcallback, DumpProc, NULL); + + XtSetArg (arg[0], XtNborderWidth, 0); + XtSetArg (arg[1], XtNwidth, 10); + XtCreateManagedWidget ("spacer", boxWidgetClass, command_area, arg, 2); charmap = alloca (sizeof (Widget) * (face->num_charmaps + 1)); XtSetArg (arg[0], XtNstate, True); @@ -491,7 +1350,7 @@ create_widgets (int pixel_size) charmap[i + 1] = XtCreateManagedWidget (charmap_rec[i + 1].name, toggleWidgetClass, command_area, arg, 1); - XtAddCallback (charmap[i + 1], XtNcallback, CharmapProc, (XtPointer) i); + XtAddCallbackWithCast (int, charmap[i + 1], CharmapProc, i); } XtSetArg (arg[0], XtNlabel, " |< (f)"); @@ -510,8 +1369,12 @@ create_widgets (int pixel_size) navi_area, arg, 2); XtAddCallback (prev, XtNcallback, GlyphProc, (XtPointer) -1); XtSetArg (arg[0], XtNlabel, " 0000 "); - label = XtCreateManagedWidget ("label", labelWidgetClass, + range = XtCreateManagedWidget ("range", labelWidgetClass, navi_area, arg, 1); + XtSetArg (arg[0], XtNforeground, &foreground); + XtSetArg (arg[1], XtNbackground, &background); + XtGetValues (range, arg, 2); + XtSetArg (arg[0], XtNlabel, "> (n)"); XtSetArg (arg[1], XtNaccelerators, XtParseAcceleratorTable (next_action)); next = XtCreateManagedWidget ("next", commandWidgetClass, @@ -528,41 +1391,80 @@ create_widgets (int pixel_size) navi_area, arg, 2); XtAddCallback (LAST, XtNcallback, GlyphProc, (XtPointer) 3); - glyph_widget_height = glyph_height + 1 + FONT_HEIGHT; XtSetArg (arg[0], XtNleft, XawChainLeft); XtSetArg (arg[1], XtNright, XawChainLeft); XtSetArg (arg[2], XtNtop, XawChainTop); XtSetArg (arg[3], XtNbottom, XawChainTop); + for (i = 0; i < 8; i++) - for (j = 0; j < 16; j++) - { - int k = i * 16 + j; - int num_args = 4; - - XtSetArg (arg[num_args], XtNwidth, glyph_width), num_args++; - XtSetArg (arg[num_args], XtNheight, glyph_widget_height), num_args++; - if (j > 0) - XtSetArg (arg[num_args], XtNfromHoriz, glyph[k - 1]), num_args++; - if (i > 0) - XtSetArg (arg[num_args], XtNfromVert, glyph[k - 16]), num_args++; - XtSetArg (arg[num_args], XtNinternalWidth, 0), num_args++; - glyph[k] = XtCreateManagedWidget ("glyph", commandWidgetClass, - glyph_area, arg, num_args); - XtAddCallback (glyph[k], XtNcallback, RenderProc, (XtPointer) k); - } + { + char str[3]; + int n = 4; + Widget head; + + sprintf (str, "%XX", i); + XtSetArg (arg[n], XtNheight, glyph_height + 5), n++; + XtSetArg (arg[n], XtNlabel, str), n++; + XtSetArg (arg[n], XtNborderWidth, 0), n++; + if (i > 0) + XtSetArg (arg[n], XtNfromVert, w), n++; + head = XtCreateManagedWidget (str, labelWidgetClass, glyph_area, arg, n); + index_label[i] = head; + for (j = 0; j < 16; j++) + { + int k = i * 16 + j; + + n = 4; + if (i > 0) + XtSetArg (arg[n], XtNfromVert, w), n++; + if (j == 0) + XtSetArg (arg[n], XtNfromHoriz, head), n++; + else + XtSetArg (arg[n], XtNfromHoriz, glyph[k - 1]), n++; + XtSetArg (arg[n], XtNbitmap, none_pixmap), n++; + glyph[k] = XtCreateManagedWidget ("glyph", commandWidgetClass, + glyph_area, arg, n); + XtAddCallbackWithCast (int, glyph[k], RenderProc, k); + } + w = head; + } + /* 10 = (1 (border_width) + 4 (inner_width)) * 2 */ + XtSetArg(arg[4], XtNwidth, glyph_width + 10); + XtSetArg (arg[5], XtNfromVert, glyph[112]); + XtSetArg (arg[6], XtNfromHoriz, w); + XtSetArg (arg[7], XtNborderWidth, 0); + + for (j = 0; j < 16; j++) + { + char str[3]; + + sprintf (str, "X%X", j); + XtSetArg (arg[8], XtNlabel, str); + w = XtCreateManagedWidget ("idx", labelWidgetClass, glyph_area, arg, 9); + XtSetArg (arg[6], XtNfromHoriz, w); + } XtSetArg (arg[0], XtNleft, XawChainLeft); XtSetArg (arg[1], XtNright, XawChainLeft); XtSetArg (arg[2], XtNtop, XawChainTop); XtSetArg (arg[3], XtNbottom, XawChainTop); - clear = XtCreateManagedWidget ("clear", commandWidgetClass, - render_area, arg, 4); + XtSetArg (arg[4], XtNorientation, XtorientHorizontal); + XtSetArg (arg[5], XtNborderWidth, 0); + w = XtCreateManagedWidget ("clear-box", boxWidgetClass, render_area, arg, 6); + clear = XtCreateManagedWidget ("clear", commandWidgetClass, w, arg, 0); XtAddCallback (clear, XtNcallback, RenderProc, (XtPointer) -1); + del = XtCreateManagedWidget ("delete", commandWidgetClass, w, arg, 0); + XtAddCallback (del, XtNcallback, RenderProc, (XtPointer) -2); + bidi = XtCreateManagedWidget ("L->R", toggleWidgetClass, w, arg, 0); + XtAddCallback (bidi, XtNcallback, BidiProc, NULL); + alt_subst = XtCreateManagedWidget ("AltSubst", toggleWidgetClass, w, arg, 0); + XtAddCallback (alt_subst, XtNcallback, AltSubstProc, NULL); + XtSetArg (arg[4], XtNorientation, XtorientHorizontal); XtSetArg (arg[5], XtNborderWidth, 0); - XtSetArg (arg[6], XtNfromVert, clear); - raw = XtCreateManagedWidget ("raw", boxWidgetClass, - render_area, arg, 7); + XtSetArg (arg[6], XtNfromVert, w); + raw = XtCreateManagedWidget ("raw", boxWidgetClass, render_area, arg, 7); + XtSetArg (arg[0], XtNborderWidth, 0); XtSetArg (arg[1], XtNlabel, "raw: "); raw_label = XtCreateManagedWidget ("raw-label", labelWidgetClass, @@ -570,41 +1472,63 @@ create_widgets (int pixel_size) XtSetArg (arg[1], XtNbitmap, raw_pixmap); raw_image = XtCreateManagedWidget ("raw-image", labelWidgetClass, raw, arg, 2); - XtSetArg (arg[6], XtNfromVert, raw); - seq = XtCreateManagedWidget ("seq", boxWidgetClass, - render_area, arg, 7); + w = raw; + if (otf) + { + OTF_get_table (otf, "GSUB"); + OTF_get_table (otf, "GPOS"); + w = create_otf_script_widgets (w); + if (otf->gsub) + { + gsub.label = "GSUB"; + gsub.gsub_gpos = otf->gsub; + w = create_otf_widgets (w, &gsub); + } + if (otf->gpos) + { + gpos.label = "GPOS"; + gpos.gsub_gpos = otf->gpos; + w = create_otf_widgets (w, &gpos); + } + } + + XtSetArg (arg[6], XtNfromVert, w); + seq = XtCreateManagedWidget ("seq", boxWidgetClass, render_area, arg, 7); XtSetArg (arg[0], XtNborderWidth, 0); XtSetArg (arg[1], XtNlabel, "seq: "); seq_label = XtCreateManagedWidget ("seq-label", labelWidgetClass, - seq, arg, 2); + seq, arg, 2); XtSetArg (arg[1], XtNbitmap, seq_pixmap); seq_image = XtCreateManagedWidget ("seq-image", labelWidgetClass, - seq, arg, 2); - if (otf) - { - XtSetArg (arg[6], XtNfromVert, seq); - gsub = XtCreateManagedWidget ("gsub", boxWidgetClass, - render_area, arg, 7); - XtSetArg (arg[0], XtNborderWidth, 0); - XtSetArg (arg[1], XtNlabel, "gsub: "); - gsub_label = XtCreateManagedWidget ("gsub-label", labelWidgetClass, - gsub, arg, 2); - gsub_image = XtCreateManagedWidget ("gsub-image", labelWidgetClass, - gsub, arg, 1); - XtSetArg (arg[6], XtNfromVert, gsub); - gpos = XtCreateManagedWidget ("gpos", boxWidgetClass, - render_area, arg, 7); - XtSetArg (arg[0], XtNborderWidth, 0); - XtSetArg (arg[1], XtNlabel, "gpos: "); - gpos_label = XtCreateManagedWidget ("gpos-label", labelWidgetClass, - gpos, arg, 2); - gpos_image = XtCreateManagedWidget ("gpos-image", labelWidgetClass, - gpos, arg, 1); - } - + seq, arg, 2); + XtSetArg (arg[6], XtNfromVert, seq); + code = XtCreateManagedWidget ("code", boxWidgetClass, render_area, arg, 7); + XtSetArg (arg[0], XtNborderWidth, 0); + XtSetArg (arg[1], XtNlabel, "code:"); + code_label = XtCreateManagedWidget ("code-label", labelWidgetClass, + code, arg, 2); + XtSetArg (arg[1], XtNlabel, ""); + XtSetArg (arg[2], XtNwidth, render_width); + code_list = XtCreateManagedWidget ("code-list", labelWidgetClass, + code, arg, 3); XtInstallAllAccelerators (shell, shell); } +static void +ExposeProc (Widget w, XEvent *event, String *str, Cardinal *num) +{ + XTextProperty text_prop; + char *pname = "otfview"; + char *fname = basename (filename); + char *name = alloca (strlen (fname) + 3 + strlen (pname) + 1); + + sprintf (name, "%s - %s", pname, fname); + text_prop.value = (unsigned char *) name; + text_prop.encoding = XA_STRING; + text_prop.format = 8; + text_prop.nitems = strlen (name); + XSetWMName (display, XtWindow (shell), &text_prop); +} /* Format MSG by FMT and print the result to the stderr, and exit. */ @@ -614,20 +1538,42 @@ create_widgets (int pixel_size) exit (1); \ } while (0) +static int +x_error_handler (Display *display, XErrorEvent *error) +{ + return 0; +} + +void +help (char **argv, int err) +{ + FILE *fp = err ? stderr : stdout; + + fprintf (fp, "Usage: %s [ X-OPTION ... ] OTF-FILE [INDEX]\n", + basename (argv[0])); + fprintf (fp, " Environment variable PIXEL_SIZE specifies the pixel size.\n"); + fprintf (fp, " The default pixel size is %d, but is reduced\n", + DEFAULT_PIXEL_SIZE); + fprintf (fp, " if your screen is not that wide.\n"); + exit (err); +} + int main (int argc, char **argv) { - FT_Library library; + XtActionsRec actions[] = { {"Expose", ExposeProc} }; + Arg arg[10]; + FT_Library library; OTF_GlyphString gstring; OTF_Glyph *g; int err; int i; - int pixel_size = DEFAULT_PIXEL_SIZE; int fixed_pixel_size = 0; int display_width; + pixel_size = DEFAULT_PIXEL_SIZE; { char *str = getenv ("PIXEL_SIZE"); @@ -643,42 +1589,64 @@ main (int argc, char **argv) gstring.glyphs = g; shell = XtOpenApplication (&context, "OTFView", NULL, 0, &argc, argv, NULL, - shellWidgetClass, NULL, 0); + shellWidgetClass, arg, 0); display = XtDisplay (shell); + /*XSynchronize (display, True);*/ + XSetErrorHandler (x_error_handler); display_width = DisplayWidth (display, XScreenNumberOfScreen (XtScreen (shell))); font = XLoadQueryFont (display, DEFAULT_FONT_NAME); if (! font) font = XLoadQueryFont (display, "fixed"); - if (argc != 2) - FATAL_ERROR ("%s\n", "Usage: otfview [ X-OPTION ... ] OTF-FILE"); + if (argc < 2) + help (argv, 1); + if (!strcmp (argv[1], "-h") || !strcmp (argv[1], "--help")) + help (argv, 0); filename = argv[1]; - - if (strstr (filename, ".ttf") - || strstr (filename, ".TTF") - || strstr (filename, ".otf") - || strstr (filename, ".OTF")) + if (argc > 2) { - otf = OTF_open (filename); - if (! otf - || OTF_get_table (otf, "head") < 0 - || OTF_get_table (otf, "cmap") < 0 - || (OTF_get_table (otf, "gsub") < 0 - && OTF_get_table (otf, "gpos") < 0)) - otf = NULL; + fontindex = atoi (argv[2]); + if (fontindex < 0) + FATAL_ERROR ("Invalid font index: %d\n", fontindex); } if ((err = FT_Init_FreeType (&library))) FATAL_ERROR ("%s\n", "FT_Init_FreeType: error"); - err = FT_New_Face (library, filename, 0, &face); + err = FT_New_Face (library, filename, fontindex, &face); if (err == FT_Err_Unknown_File_Format) FATAL_ERROR ("%s\n", "FT_New_Face: unknown file format"); else if (err) - FATAL_ERROR ("%s\n", "FT_New_Face: unknown error"); + FATAL_ERROR ("%s\n", "FT_New_Face: unknown error (invalid face index?)"); if ((err = FT_Set_Pixel_Sizes (face, 0, pixel_size))) FATAL_ERROR ("%s\n", "FT_Set_Pixel_Sizes: error"); + if (strstr (filename, ".ttf") + || strstr (filename, ".TTF") + || strstr (filename, ".otf") + || strstr (filename, ".OTF")) + { + otf = OTF_open_ft_face (face); + if (otf) + { + if (OTF_get_table (otf, "head") < 0 + || OTF_get_table (otf, "cmap") < 0 + || (OTF_check_table (otf, "GSUB") < 0 + && OTF_check_table (otf, "GPOS") < 0)) + { + OTF_close (otf); + otf = NULL; + } + } + if (otf) + for (i = 0; i < otf->cmap->numTables; i++) + if (otf->cmap->EncodingRecord[i].subtable.format == 14) + { + sub14 = otf->cmap->EncodingRecord[i].subtable.f.f14; + break; + } + } + { char title[256]; Arg arg[1]; @@ -707,35 +1675,19 @@ main (int argc, char **argv) glyph_x = - (face->bbox.xMin * pixel_size / face->units_per_EM); glyph_y = face->bbox.yMax * pixel_size / face->units_per_EM; - - for (i = 0; i < 0x10000; i++) - if (FT_Load_Glyph (face, i, FT_LOAD_RENDER | FT_LOAD_MONOCHROME) == 0) - { - if (glyph_x < - face->glyph->bitmap_left) - glyph_x = - face->glyph->bitmap_left; - if (glyph_y < face->glyph->bitmap_top) - glyph_y = face->glyph->bitmap_top; - if (glyph_width - < glyph_x + face->glyph->bitmap_left + face->glyph->bitmap.width) - glyph_width - = glyph_x + face->glyph->bitmap_left + face->glyph->bitmap.width; - if (glyph_height - < glyph_y - face->glyph->bitmap_top + face->glyph->bitmap.rows) - glyph_height - = glyph_y - face->glyph->bitmap_top + face->glyph->bitmap.rows; - } - none_pixmap = XCreatePixmap (display, DefaultRootWindow (display), - glyph_width, glyph_height + 1 + FONT_HEIGHT, 1); + glyph_width, glyph_height, 1); { unsigned long valuemask = GCFunction | GCLineWidth; XGCValues values; gc = XCreateGC (display, none_pixmap, (unsigned long) 0, NULL); + XSetFont (display, gc, font->fid); values.function = GXset; values.line_width = 1; gc_set = XCreateGC (display, none_pixmap, valuemask, &values); + XSetFont (display, gc_set, font->fid); values.function = GXor; gc_or = XCreateGC (display, none_pixmap, valuemask, &values); values.function = GXcopyInverted; @@ -743,13 +1695,13 @@ main (int argc, char **argv) } XFillRectangle (display, none_pixmap, gc, 0, 0, - glyph_width, glyph_height + 1 + FONT_HEIGHT); + glyph_width, glyph_height); XDrawString (display, none_pixmap, gc_inv, (glyph_width - XTextWidth (font, "none", 4)) / 2, glyph_height / 2, "none", 4); - render_width = (glyph_width + 1) * 15 + 1; - render_height = glyph_height + FONT_HEIGHT + 2; + render_width = (glyph_width + 4) * 15 + 1; + render_height = glyph_height + 2; charmap_rec[0].platform_id = -1; charmap_rec[0].encoding_id = -1; @@ -774,21 +1726,29 @@ main (int argc, char **argv) render_width, render_height, 1); seq_pixmap = XCreatePixmap (display, DefaultRootWindow (display), render_width, render_height, 1); - gsub_pixmap = XCreatePixmap (display, DefaultRootWindow (display), - render_width, render_height, 1); - gpos_pixmap = XCreatePixmap (display, DefaultRootWindow (display), - render_width, render_height, 1); - - for (i = 0; i < 0x10000; i++) - create_pixmap (pixel_size, i); - create_widgets (pixel_size); + + memset (bitmap, 0, sizeof (bitmap)); + create_widgets (); glyph_index = 0; charmap_index = -1; update_glyph_area (); update_render_area (); + XtAppAddActions (context, actions, XtNumber (actions)); XtRealizeWidget (shell); XtAppMainLoop (context); exit (0); } + +#else /* not HAVE_X11_XAW_COMMAND_H */ + +int +main (int argc, char **argv) +{ + fprintf (stderr, + "Building of this program failed (lack of some header files)\n"); + exit (1); +} + +#endif