X-Git-Url: http://git.chise.org/gitweb/?a=blobdiff_plain;f=example%2Fotfview.c;h=d867f30c7641745dbaa07b289653045e8ba267aa;hb=a9d3ac385ae58093662959ab24d4c97a5a0f0cfe;hp=2ec484eb304290ead257f775e3873a9945fdeed7;hpb=656e5bc94fffe9297717c137fb182d4b7505c8f8;p=m17n%2Flibotf.git diff --git a/example/otfview.c b/example/otfview.c index 2ec484e..d867f30 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) @@ -65,8 +85,11 @@ XtAppContext context; | | idxh[7] glyph[112] ... glyph[127]| | | | idxl[0] ... idxl[15] | | | +--------------------------------------+ | + | +---- uvs_area (box) (optional) -------+ | + | | uvs[?].w ... | | + | +--------------------------------------+ | | +--- render_area (form) ---------------+ | - | | clear del | | + | | clear del bidi alt_subst | | | | +--- raw (box) --------------------+ | | | | | raw_label raw_image | | | | | +----------------------------------+ | | @@ -81,18 +104,32 @@ Widget shell, frame; Widget command_area, quit, dump, *charmap; Widget navi_area, FIRST, PREV, prev, range, next, NEXT, LAST; Widget glyph_area, glyph[128], index_label[8]; -Widget render_area, clear, del, raw, seq; +Widget uvs_area, uvs_label; +Widget render_area, clear, del, bidi, alt_subst, raw, seq; Widget raw_label, raw_image, seq_label, seq_image; unsigned long foreground, background; typedef struct { - int idx; + 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[64], gpos[64]; +FeatureRec gsub, gpos; + +/* Currently selected script and langsys. */ +OTF_Tag script_tag, langsys_tag; int glyph_char[128]; @@ -106,7 +143,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; @@ -122,6 +159,8 @@ struct { int charmap_index; +int reversed; +int do_alternate_subst; unsigned glyph_width, glyph_height; int glyph_x, glyph_y; int glyph_index; @@ -132,11 +171,19 @@ 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; @@ -144,7 +191,7 @@ create_pixmap (int pixel_size, int index) if (err) { - bitmap[index].pixmap = (Pixmap) 0; + bitmap[index].pixmap = none_pixmap; return; } ximage.height = face->glyph->bitmap.rows; @@ -189,10 +236,14 @@ 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); } @@ -207,93 +258,272 @@ update_glyph_area () XtSetValues (index_label[i], arg, 2); } - sprintf (buf, " %04X-%04X ", glyph_index, glyph_index + 0x7F); + 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 (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 *features) +get_features (OTF_FeatureList *list, FeatureRec *rec) { - int len = list->FeatureCount; int i, n; char *str, *p; - if (! features[0].on) + if (! rec->langsys || ! rec->features || ! rec->features[0].on) return NULL; - for (i = n = 0; i < len; i++) + for (i = n = 0; i < rec->langsys->FeatureCount; i++) { - if (features[i].on) + if (rec->features[i].on) n++; else break; } - if (i == len) + str = malloc (n * 5); + for (i = 0, p = str; i < n; i++, p += 5) { - str = malloc (2); - strcpy (str, "*"); - return str; + OTF_tag_name (rec->features[i].tag, p); + p[4] = ','; } - str = malloc (n * 5); - for (i = 0, p = str; i < len ; i++, p += 5) - if (features[i].on) - { - OTF_tag_name (list->Feature[features[i].idx].FeatureTag, 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 = alloca (sizeof (OTF_Glyph) * 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 = gstring.glyphs[i].glyph_id = glyph_rec.glyphs[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); + str = get_features (&otf->gsub->FeatureList, &gsub); if (str) { - OTF_drive_gsub (otf, &gstring, NULL, NULL, 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); + str = get_features (&otf->gpos->FeatureList, &gpos); if (str) { - OTF_drive_gpos (otf, &gstring, NULL, NULL, str); + OTF_drive_gpos2 (otf, &gstring, script_name, langsys_name, str); free (str); } } } - for (i = 0, x = glyph_x; i < gstring.used; i++) + 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, glyph_y + bmp->y); - x += bmp->advance; + 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; } + free (gstring.glyphs); + XtSetArg (arg[0], XtNbitmap, seq_pixmap); XtSetValues (seq_image, arg, 1); } @@ -309,28 +539,50 @@ update_render_area () XFillRectangle (display, raw_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 + 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 + 1) * i + 1 - + (glyph_width - XTextWidth (font, buf, 4)) / 2, - glyph_height + 2 + FONT_HEIGHT, buf, 4); + 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); @@ -344,130 +596,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; - - 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) + 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) { - 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; + scale = g_width * size; + g_x = face->bbox.xMin * unit / g_width; + g_y = face->bbox.yMin * unit / g_width; } - - g_x = - (face->bbox.xMin * size / face->units_per_EM); - g_y = face->bbox.yMax * size / face->units_per_EM; - for (i = 0; i < 0xFF; i++) + else { - int idx; - - if (charmap_index >= 0) - idx = FT_Get_Char_Index (face, (FT_ULong) i); - else - idx = i; - if (FT_Load_Glyph (face, idx, FT_LOAD_RENDER | FT_LOAD_MONOCHROME) == 0) - { - 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; - } + scale = g_height * size; + g_x = face->bbox.xMin * unit / g_height; + g_y = face->bbox.yMin * unit / g_height; } - 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; + scale /= face->units_per_EM; - 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); - } + FT_Set_Pixel_Sizes (face, 0, size); + + 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++) + { + 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); + } + } + fprintf (fp, "showpage\n"); + fclose (fp); + printf ("done\n"); - 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); - printf ("Writing %s ...", name); - 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); - printf ("done\n"); - } FT_Set_Pixel_Sizes (face, 0, (int) pixel_size); } @@ -476,19 +734,22 @@ void GlyphProc (Widget w, XtPointer client_data, XtPointer call_data) { int old_glyph_index = glyph_index; + int data; + + CAST_FROM_XTPOINTER (int, client_data, data); - if ((int) client_data == -3 && glyph_index > 0) + 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 (); } @@ -496,22 +757,60 @@ 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 +UVSProc (Widget w, XtPointer client_data, XtPointer call_data) +{ + 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++) + { + 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) { - if ((int) client_data < 0) + int data; + + CAST_FROM_XTPOINTER (int, client_data, data); + + if (data < 0) { if (glyph_rec.n_glyphs > 0) { - if ((int) client_data == -2) + if (data == -2) glyph_rec.n_glyphs--; else glyph_rec.n_glyphs = 0; @@ -520,123 +819,392 @@ RenderProc (Widget w, XtPointer client_data, XtPointer call_data) } 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 -FeatureProc (OTF_FeatureList *list, FeatureRec *features, int idx) +BidiProc (Widget w, XtPointer client_data, XtPointer call_data) { - int i, j; - Arg arg[3]; + 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 (idx = 0; idx < list->FeatureCount; idx++) + for (i = j = 0; j < rec->langsys->FeatureCount; j++) { - features[idx].idx = idx; - features[idx].on = on; + int index = rec->langsys->FeatureIndex[j]; + + rec->features[j].tag + = rec->gsub_gpos->FeatureList.Feature[index].FeatureTag; + rec->features[j].on = on; } - i = 0, j = list->FeatureCount - 1; } else { - int index = features[idx].idx; - i = idx; + OTF_Tag tag = rec->features[idx].tag; - if (features[i].on) + i = idx; + if (rec->features[i].on) { - for (j = i; j + 1 < list->FeatureCount && features[j + 1].on; j++) - features[j].idx = features[j + 1].idx; - features[j].idx = index; - features[j].on = 0; + 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; i > 0 && ! features[i - 1].on; i--) - features[i].idx = features[i - 1].idx; - features[i].idx = index; - features[i].on = 1; + 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++) + for (; i < j; i++) { char str[5]; - unsigned fore = foreground, back = background; - if (i == idx) - fore = background, back = foreground; - if (features[i].on) + if (rec->features[i].on) { - XtSetArg (arg[0], XtNforeground, back); - XtSetArg (arg[1], XtNbackground, fore); + XtSetArg (arg[0], XtNborderWidth, 3); + XtSetArg (arg[1], XtNinternalHeight, 2); + XtSetArg (arg[2], XtNinternalWidth, 2); } else { - XtSetArg (arg[0], XtNforeground, fore); - XtSetArg (arg[1], XtNbackground, back); + XtSetArg (arg[0], XtNborderWidth, 1); + XtSetArg (arg[1], XtNinternalHeight, 4); + XtSetArg (arg[2], XtNinternalWidth, 4); } - OTF_tag_name (list->Feature[features[i].idx].FeatureTag, str); - XtSetArg (arg[2], XtNlabel, str); - XtSetValues (features[i].w, arg, 3); + OTF_tag_name (rec->features[i].tag, str); + XtSetArg (arg[3], XtNlabel, str); + XtSetValues (rec->features[i].w, arg, 4); } update_seq_area (); } void -GsubProc (Widget w, XtPointer client_data, XtPointer call_data) +setup_feature_rec (FeatureRec *rec) { - FeatureProc (&otf->gsub->FeatureList, gsub, (int) client_data); -} + 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 -GposProc (Widget w, XtPointer client_data, XtPointer call_data) +compose_script_langsys (OTF_Tag script, OTF_Tag langsys, char *name) { - FeatureProc (&otf->gpos->FeatureList, gpos, (int) client_data); + 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_widgets (int flag, Widget prev) +create_otf_script_widgets (Widget prev) { - char *label; - OTF_FeatureList *list; - XtCallbackProc proc; - FeatureRec *features; - Arg arg[10]; Widget w; - char *box_label, feature_label[5]; - int i; + 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; - if (flag) + script_tag = script_langsys[0].script; + langsys_tag = script_langsys[0].langsys; + compose_script_langsys (script_tag, langsys_tag, name); + + if (n == 1) { - label = "GSUB"; - list = &otf->gsub->FeatureList; - proc = GsubProc; - features = gsub; + XtSetArg (arg[0], XtNforeground, background); + XtSetArg (arg[1], XtNbackground, foreground); + XtCreateManagedWidget (name, labelWidgetClass, prev, arg, 2); } else { - label = "GPOS"; - list = &otf->gpos->FeatureList; - proc = GposProc; - features = gpos; + 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); + } } - box_label = alloca (strlen (label) + 4); + return prev; +} + - strcpy (box_label, label); - strcat (box_label, "box"); +Widget +create_otf_widgets (Widget prev, FeatureRec *rec) +{ + Arg arg[10]; + Widget w; XtSetArg (arg[0], XtNborderWidth, 0); XtSetArg (arg[1], XtNleft, XawChainLeft); @@ -645,40 +1213,46 @@ create_otf_widgets (int flag, Widget prev) XtSetArg (arg[4], XtNbottom, XawChainTop); XtSetArg (arg[5], XtNfromVert, prev); XtSetArg (arg[6], XtNorientation, XtorientHorizontal); - prev = XtCreateManagedWidget (box_label, boxWidgetClass, render_area, arg, 7); - XtCreateManagedWidget (label, labelWidgetClass, prev, arg, 1); - w = XtCreateManagedWidget ("all", commandWidgetClass, prev, NULL, 0); - XtAddCallback (w, XtNcallback, proc, (XtPointer) -2); - w = XtCreateManagedWidget ("none", commandWidgetClass, prev, NULL, 0); - XtAddCallback (w, XtNcallback, proc, (XtPointer) -1); - for (i = 0; i < list->FeatureCount; i++) - { - OTF_tag_name (list->Feature[i].FeatureTag, feature_label); - features[i].idx = i; - w = XtCreateManagedWidget (feature_label, commandWidgetClass, prev, - NULL, 0); - XtAddCallback (w, XtNcallback, proc, (XtPointer) i); - features[i].w = w; - } - + 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 (int pixel_size) +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; 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); @@ -695,7 +1269,41 @@ create_widgets (int pixel_size) XtSetArg (arg[6], XtNdefaultDistance, 0); glyph_area = XtCreateManagedWidget ("glyph-area", formWidgetClass, frame, arg, 7); + 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); @@ -704,9 +1312,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); @@ -719,7 +1331,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)"); @@ -784,22 +1396,21 @@ create_widgets (int pixel_size) int k = i * 16 + j; n = 4; - XtSetArg (arg[n], XtNheight, glyph_height), n++; - XtSetArg (arg[n], XtNwidth, glyph_width), n++; 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], XtNinternalWidth, 0), n++; + XtSetArg (arg[n], XtNbitmap, none_pixmap), n++; glyph[k] = XtCreateManagedWidget ("glyph", commandWidgetClass, glyph_area, arg, n); - XtAddCallback (glyph[k], XtNcallback, RenderProc, (XtPointer) k); + XtAddCallbackWithCast (int, glyph[k], RenderProc, k); } w = head; } - XtSetArg(arg[4], XtNwidth, glyph_width + 2); + /* 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); @@ -825,6 +1436,10 @@ create_widgets (int pixel_size) 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); @@ -841,10 +1456,21 @@ create_widgets (int pixel_size) w = raw; if (otf) { - if (OTF_get_table (otf, "GSUB") >= 0) - w = create_otf_widgets (1, w); - if (OTF_get_table (otf, "GPOS") >= 0) - w = create_otf_widgets (0, w); + 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); @@ -852,13 +1478,28 @@ create_widgets (int pixel_size) 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); + seq, arg, 2); 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. */ @@ -874,21 +1515,36 @@ 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"); @@ -904,7 +1560,7 @@ 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); @@ -914,42 +1570,54 @@ main (int argc, char **argv) if (! font) font = XLoadQueryFont (display, "fixed"); - if (argc != 2 || !strcmp (argv[1], "-h") || !strcmp (argv[1], "--help")) - { - fprintf (stderr, "Usage: %s [ X-OPTION ... ] OTF-FILE\n", - basename (argv[0])); - exit (argc != 2); - } + 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_check_table (otf, "GSUB") < 0 - && OTF_check_table (otf, "GPOS") < 0)) - otf = NULL; + fontindex = atoi (argv[2]); + if (fontindex < 0) + FATAL_ERROR ("Invalid font index: %d\n", fontindex); } - if (otf) - { - memset (gsub, 0, sizeof gsub); - memset (gpos, 0, sizeof gpos); - } 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]; @@ -978,35 +1646,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; @@ -1014,7 +1666,7 @@ 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); @@ -1046,16 +1698,28 @@ main (int argc, char **argv) seq_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