--- /dev/null
+/* Copyright (c) 1999, 2000, 2002, 2004, 2005 by Arkkra Enterprises */
+/* All rights reserved */
+
+/* Functions related to walking through strings, to get each character
+ * in turn, along with any font/size changes and horizontal/vertical
+ * motions that should be done before printing that character.
+ */
+
+#include "defines.h"
+#include "structs.h"
+#include "globals.h"
+
+
+/* when entering pile, adjust size by PILE_A / PILE_B and when
+ * exiting pile, adjust by the recipocal of that. */
+#define PILE_A 65
+#define PILE_B 100
+
+
+/* This structure contains information about one line in a set of lines
+ * that are piled on top of one another. This might be used for figured
+ * bass or superscript/subscript or things like that. */
+struct PILED_LINE {
+ char *text; /* points to start of piled line */
+ short align_offset; /* where the alignment is, relative to text */
+ short length; /* bytes in this line */
+ short last_char_offset; /* where the last character is */
+ short last_digit_offset;/* where the last digit is */
+ float width_left_of_align; /* width for this line */
+ float width_right_of_align;
+ struct PILED_LINE *next;/* the next line in the pile */
+};
+
+/* This keep track of an entire piled section of a string */
+struct PILED {
+ float curr_x, curr_y; /* where we are now, relative to pile start */
+ struct PILED_LINE *lines_p; /* list of lines in pile */
+ struct PILED_LINE *curr_line_p; /* which piled line we're processing */
+ short curr_offset; /* offset into curr_line_p->text */
+ float width_left_of_align; /* width of the entire pile */
+ float width_right_of_align;
+ short orig_font; /* font coming into the pile */
+ short orig_size; /* size coming into the pile */
+ short new_size; /* size at beginning of pile */
+ char *pile_end; /* last character of pile */
+};
+
+/* One of these structs is passed to get_piled() with the current
+ * font and size filled in. If we are in piled mode, it will return 1 and
+ * will have filled in all the field. Otherwise it will return 0.
+ */
+
+struct PILE_INFO {
+ char font;
+ char size;
+ char ch; /* the next character in the pile, or \0 if
+ * this only indicates motion */
+ double hor; /* how much to adjust before printing ch */
+ double vert; /* how much to adjust before printing ch */
+};
+
+/* When a backspace is returned, this keeps track of its width, to
+ * potentially be returned via backsp_width() */
+static int Backspace_dist;
+
+/* This is all the info about the piled section we are currently processing.
+ * We only deal with one pile at a time, so a single static structure
+ * meets our needs. */
+static struct PILED Pile_info;
+
+static void begin_pile P((struct PILE_INFO *pile_info_p));
+static char *prep_pile P((char *string, struct PILE_INFO *pile_info_p));
+static int get_piled P((struct PILE_INFO *pile_info_p));
+static double vert_distance P((int vert_arg, int font, int size));
+\f
+
+/* When a STR_PILE is encountered, this should be called to gather all
+ * the information we might need about how to align everything in the pile.
+ * Then other functions like get_piled() can be called to retrieve info.
+ * The passed-in pile_info_p contains the font and size at the beginning
+ * of the pile, and on return will contain the new size and the vertical
+ * and horizontal offsets before the first character of the pile.
+ * Return value points to the last character that was processed from string.
+ */
+
+static char *
+prep_pile(string, pile_info_p)
+
+char *string; /* place in string where piling begins */
+struct PILE_INFO *pile_info_p; /* passed in font and size, returns size and vert */
+
+{
+ struct PILED_LINE **piled_line_p_p; /* where to link on next line */
+ struct PILED_LINE *line_p; /* the current line of pile */
+ char *s; /* to walk through string */
+ int alignments = 0; /* how many align points found */
+ int lines = 0; /* how many lines in pile */
+ float width_contribution; /* width of current char */
+ int i; /* index though a line */
+ int orig_i; /* value of i when current
+ * character began (some
+ * things take up multiple
+ * bytes and we need to know
+ * where it began. */
+ int font, size;
+
+ /* initialize */
+ Pile_info.width_left_of_align = Pile_info.width_right_of_align = 0.0;
+ Pile_info.lines_p = (struct PILED_LINE *) 0;
+ Pile_info.curr_line_p = (struct PILED_LINE *) 0;
+ Pile_info.curr_offset = 0;
+ piled_line_p_p = &(Pile_info.lines_p);
+ line_p = *piled_line_p_p;
+
+ Pile_info.orig_font = font = pile_info_p->font;
+
+ /* Adjust size for entering the pile */
+ size = Pile_info.new_size = pile_size(pile_info_p->size, NO);
+
+ /* Walk through the piled things, skipping past the initial STR_PILE,
+ * this time just to find the line boundaries and alignment offsets. */
+ for (s = string + 1; *s != '\0'; s++) {
+
+ /* if end piling, jump out */
+ int curr_char;
+ curr_char = *s & 0xff;
+ if ( curr_char == STR_PILE || curr_char == STR_BOX_END
+ || curr_char == STR_CIR_END) {
+ if (line_p != (struct PILED_LINE *) 0) {
+ line_p->length = s - line_p->text;
+ }
+ line_p = (struct PILED_LINE *) 0;
+ s++;
+ break;
+ }
+
+ /* If we don't have a current PILED_LINE struct,
+ * get one, and initialize it. */
+ if (line_p == (struct PILED_LINE *) 0) {
+ MALLOC(PILED_LINE, *piled_line_p_p, 1);
+ line_p = *piled_line_p_p;
+ line_p->text = s;
+ line_p->align_offset = -1;
+ line_p->last_digit_offset = -1;
+ line_p->last_char_offset = -1;
+ line_p->length = -1;
+ line_p->width_left_of_align = 0.0;
+ line_p->width_right_of_align = 0.0;
+ line_p->next = (struct PILED_LINE *) 0;
+ lines++;
+ }
+
+ switch (*s & 0xff) {
+
+ case STR_C_ALIGN:
+ case STR_L_ALIGN:
+ /* Point the offset at the following character,
+ * because for C_ALIGN that character will straddle
+ * the alignment point, and we can easily make
+ * L_ALIGN work with that convention too. */
+ line_p->align_offset = s - line_p->text + 1;
+ alignments++;
+ break;
+
+ case '\n':
+ /* if newline, finish this line by saving its length,
+ * then prepare for next line by moving the place at
+ * which to add a line to the current line's 'next' */
+ line_p->length = s - line_p->text;
+ piled_line_p_p = &(line_p->next);
+ line_p = (struct PILED_LINE *) 0;
+ break;
+
+ case STR_FONT:
+ case STR_SIZE:
+ case STR_BACKSPACE:
+ case STR_VERTICAL:
+ /* need to skip past its argument byte */
+ s++;
+ break;
+
+ case STR_MUS_CHAR:
+ case STR_MUS_CHAR2:
+ /* Mark as last character so far, in case we need
+ * to use that as default alignment */
+ line_p->last_char_offset = s - line_p->text;
+ /* need to skip past its 2 argument bytes */
+ s += 2;
+ break;
+
+ case STR_PAGENUM:
+ case STR_NUMPAGES:
+ /* We actually don't allow this, but can get to this
+ * code in error cases. Skip past argument. */
+ s++;
+ break;
+
+ default:
+ /* Mark as last character so far, in case we need
+ * to use that as default alignment */
+ line_p->last_char_offset = s - line_p->text;
+
+ /* remember location of last digit, in case we
+ * need to use as default aligment */
+ if ( isdigit(*s) ) {
+ line_p->last_digit_offset = s - line_p->text;
+ }
+ break;
+ }
+ }
+
+ if (*s == '\0' && line_p != (struct PILED_LINE *) 0) {
+ line_p->length = s - line_p->text;
+ }
+
+ /* if there are lines with unspecified alignment points, find them */
+ if (alignments < lines) {
+ for (line_p = Pile_info.lines_p;
+ line_p != (struct PILED_LINE *) 0;
+ line_p = line_p->next) {
+ /* If no user-specified alignment point in this line,
+ * use last digit if any, else last char. If there was
+ * no last char (empty line, maybe to get subscript
+ * without superscript, for example) this will end
+ * up with an offset of -1. */
+ if (line_p->align_offset < 0) {
+ line_p->align_offset =
+ ((line_p->last_digit_offset >= 0)
+ ? line_p->last_digit_offset
+ : line_p->last_char_offset);
+ }
+ }
+ }
+
+ /* Find left and right of alignment for each line and the
+ * widest overall for the pile. */
+ for (line_p = Pile_info.lines_p;
+ line_p != (struct PILED_LINE *) 0;
+ line_p = line_p->next) {
+
+ /* Some items take more than one byte. In that case,
+ * the index 'i' in this 'for' loop will get more added to it
+ * than just the increment at the end of each loop.
+ * When this happens, orig_i keeps track of where the
+ * multi-byte item began. */
+ for (i = 0; i < line_p->length; i++) {
+
+ orig_i = i;
+ width_contribution = 0.0;
+
+ switch (line_p->text[i] & 0xff) {
+
+ case STR_MUS_CHAR:
+ case STR_MUS_CHAR2:
+ /* get its width and skip past its args */
+ width_contribution += width(
+ str2mfont(line_p->text[i] & 0xff),
+ line_p->text[i+1],
+ line_p->text[i+2]);
+ i += 2;
+ break;
+
+ case STR_FONT:
+ /* Remember the font, may need for getting
+ * widths of future characters */
+ font = line_p->text[++i];
+ break;
+
+ case STR_SIZE:
+ /* remember the size, may need for getting
+ * widths of future characters */
+ size = line_p->text[++i];
+ break;
+
+ case STR_C_ALIGN:
+ case STR_L_ALIGN:
+ case STR_SLASH:
+ /* irrelevant for width, no args */
+ break;
+
+ case STR_VERTICAL:
+ /* irrelevant for width, 1 byte arg to skip */
+ i++;
+ break;
+
+ case STR_BACKSPACE:
+ width_contribution -= ((line_p->text[++i] *
+ size) / DFLT_SIZE) / BACKSP_FACTOR;
+ break;
+
+ case STR_BOX:
+ case STR_BOX_END:
+ case STR_CIR:
+ case STR_CIR_END:
+ /* not relevant here */
+ break;
+
+ case STR_PAGENUM:
+ case STR_NUMPAGES:
+ /* we don't really know how wide this will
+ * end up being, so just use the width of
+ * the following byte (% or #).
+ */
+ width_contribution = width(font, size,
+ line_p->text[++i]);
+ break;
+ default:
+ if ( IS_STR_COMMAND(line_p->text[i]) & 0xff) {
+ pfatal("unexpected STR_ value 0x%x in prep_pile()",
+ line_p->text[i] & 0xff);
+ }
+
+ /* ordinary character, look up its width */
+ width_contribution = width(font, size,
+ line_p->text[i]);
+ break;
+ }
+
+ /* Figure out which side of alignment.
+ * Anything before align_offset goes on left,
+ * while anything after goes on the right.
+ * If we're right at the alignment offset,
+ * and the alignment type is STR_C_ALIGN,
+ * split the width. Otherwise goes on right. */
+ if (orig_i < line_p->align_offset) {
+ line_p->width_left_of_align
+ += width_contribution;
+ }
+ else if (orig_i == line_p->align_offset &&
+ (line_p->text[orig_i - 1] & 0xff)
+ != STR_L_ALIGN) {
+ /* put half on each side */
+ width_contribution /= 2.0;
+ line_p->width_left_of_align
+ += width_contribution;
+ line_p->width_right_of_align
+ += width_contribution;
+ }
+ else {
+ line_p->width_right_of_align
+ += width_contribution;
+ }
+ }
+
+ /* find widest line */
+ if (line_p->width_left_of_align
+ > Pile_info.width_left_of_align) {
+ Pile_info.width_left_of_align
+ = line_p->width_left_of_align;
+ }
+ if (line_p->width_right_of_align
+ > Pile_info.width_right_of_align) {
+ Pile_info.width_right_of_align
+ = line_p->width_right_of_align;
+ }
+ }
+
+ /* start at first character of first line of pile */
+ begin_pile(pile_info_p);
+
+ Pile_info.pile_end = s;
+ return(s);
+}
+\f
+
+/* fill in the fields of pile_info_p for starting at the beginning of
+ * the current pile. */
+
+static void
+begin_pile(pile_info_p)
+
+struct PILE_INFO *pile_info_p;
+
+{
+ /* begin at first line of pile */
+ Pile_info.curr_line_p = Pile_info.lines_p;
+ Pile_info.curr_offset = -1;
+
+ /* if user ended a string with a pile indicator (which is a bit
+ * silly, but could happen...) get out now,
+ * to avoid dereferencing a line that doesn't exist. */
+ if (Pile_info.curr_line_p == (struct PILED_LINE *) 0) {
+ return;
+ }
+
+ /* fill in rest of returned data */
+ pile_info_p->hor = Pile_info.curr_x = Pile_info.width_left_of_align
+ - Pile_info.lines_p->width_left_of_align;
+ /* Adjust vertical by half the unpiled line height, but less a little
+ * (there is some white space padding, usually piles are numbers
+ * without descenders, and they are smaller anyway, so looks better
+ * to jam things together a bit more than normal). */
+ pile_info_p->vert = Pile_info.curr_y
+ = fontheight(Pile_info.orig_font, Pile_info.orig_size) / 2.0
+ - POINT * Pile_info.new_size / DFLT_SIZE;
+ pile_info_p->size = Pile_info.new_size;
+
+ pile_info_p->ch = '\0';
+}
+\f
+
+/* Get the next character in piled segment, along with any horizontal
+ * and/or vertical motion that should be done before printing that
+ * character. Info is placed into the struct passed in. If the returned
+ * ->ch is '\0', that means this call only returned motion information.
+ * Returns NO at end of pile, otherwise YES.
+ */
+
+static int
+get_piled(pile_info_p)
+
+struct PILE_INFO *pile_info_p;
+
+{
+ char *text = 0; /* Piled text to process. The initialization
+ * is just to avoid bogus "used before set"
+ * warning. It will always get set to a real
+ * string before actually being used. */
+ float backdist; /* width of backspace */
+ int mfont; /* FONT_MUSIC* */
+
+
+ /* Move on to next character. */
+ ++(Pile_info.curr_offset);
+
+ if (Pile_info.curr_line_p != (struct PILED_LINE *) 0) {
+
+ /* Check if we've gotten to end of pile. We are if we're
+ * past the last character of the last line of the pile */
+ if (Pile_info.curr_line_p->next == (struct PILED_LINE *) 0 &&
+ Pile_info.curr_offset
+ >= Pile_info.curr_line_p->length) {
+ /* yes, at end of pile */
+ Pile_info.curr_line_p = (struct PILED_LINE *) 0;
+ }
+ else {
+ text = Pile_info.curr_line_p->text;
+ }
+ }
+
+ /* check for end of pile */
+ if (Pile_info.curr_line_p == (struct PILED_LINE *) 0) {
+
+ /* Adjust vertical and horizontal to past pile.
+ * Horizontal adjust is the total width of the
+ * pile minus where we are currently. */
+ pile_info_p->hor = (Pile_info.width_left_of_align
+ + Pile_info.width_right_of_align)
+ - Pile_info.curr_x;
+ /* Vertical adjust is the negative of the current
+ * y, since that gets us back to zero relative to
+ * where we started. */
+ pile_info_p->vert = - (Pile_info.curr_y);
+
+ /* Restore size for leaving the pile. */
+ pile_info_p->size = pile_size(pile_info_p->size, YES);
+
+ /* mark as not being an actual character, just motion */
+ pile_info_p->ch = '\0';
+
+ return(NO);
+ }
+
+ /* handle newline -- go to next line of pile */
+ if (text[Pile_info.curr_offset] == '\n') {
+ /* prepare for next line, if any */
+ Pile_info.curr_line_p = Pile_info.curr_line_p->next;
+ Pile_info.curr_offset = -1;
+
+ /* Adjust vertical and horizontal to start next line of pile.
+ * For horizontal, go back to beginning of pile,
+ * then add the difference between this line's
+ * left of align and the pile's. */
+ if (Pile_info.curr_line_p != (struct PILED_LINE *) 0) {
+ pile_info_p->hor = - Pile_info.curr_x;
+ Pile_info.curr_x = Pile_info.width_left_of_align
+ - Pile_info.curr_line_p->width_left_of_align;
+ pile_info_p->hor += Pile_info.curr_x;
+
+ /* vertical is adjusted by height of font, less
+ * a little to jam together to look better. */
+ pile_info_p->vert = - fontheight(pile_info_p->font,
+ pile_info_p->size)
+ + POINT * pile_info_p->size / DFLT_SIZE;
+ Pile_info.curr_y += pile_info_p->vert;
+ }
+ else {
+ pile_info_p->vert = pile_info_p->hor = 0.0;
+ }
+
+ /* only motion */
+ pile_info_p->ch = '\0';
+
+ }
+
+ else {
+ pile_info_p->hor = pile_info_p->vert = 0.0;
+
+ switch (text[Pile_info.curr_offset] & 0xff) {
+
+ case STR_MUS_CHAR:
+ case STR_MUS_CHAR2:
+ mfont = str2mfont( text[Pile_info.curr_offset] & 0xff);
+ pile_info_p->font = mfont;
+ pile_info_p->size = text[Pile_info.curr_offset+1];
+ pile_info_p->ch = text[Pile_info.curr_offset+2];
+ Pile_info.curr_x += width(mfont,
+ pile_info_p->size, pile_info_p->ch);
+ Pile_info.curr_offset += 2;
+ break;
+
+ case STR_FONT:
+ (Pile_info.curr_offset)++;
+ pile_info_p->font = text[Pile_info.curr_offset];
+ pile_info_p->ch = '\0';
+ break;
+
+ case STR_SIZE:
+ (Pile_info.curr_offset)++;
+ pile_info_p->size = text[Pile_info.curr_offset];
+ pile_info_p->ch = '\0';
+ break;
+
+ case STR_SLASH:
+ pile_info_p->ch = (char) STR_SLASH;
+ break;
+
+ case STR_C_ALIGN:
+ case STR_L_ALIGN:
+ pile_info_p->ch = '\0';
+ break;
+
+ case STR_VERTICAL:
+ (Pile_info.curr_offset)++;
+ pile_info_p->vert = vert_distance(
+ DECODE_VERT(text[Pile_info.curr_offset]),
+ pile_info_p->font, pile_info_p->size);
+ pile_info_p->ch = '\0';
+ break;
+
+ case STR_BACKSPACE:
+ (Pile_info.curr_offset)++;
+ Backspace_dist = text[Pile_info.curr_offset];
+ backdist = backsp_width(pile_info_p->size);
+ pile_info_p->hor -= backdist;
+ Pile_info.curr_x -= backdist;
+ pile_info_p->ch = '\0';
+ break;
+
+ case STR_PAGENUM:
+ case STR_NUMPAGES:
+ /* These aren't really allowed in piles,
+ * but we can hit this code under some error cases,
+ * so we recognize them and do something reasonable.
+ */
+ (Pile_info.curr_offset)++;
+ pile_info_p->ch = text[Pile_info.curr_offset];
+ break;
+
+ default:
+ if ( IS_STR_COMMAND(text[Pile_info.curr_offset]) & 0xff) {
+ pfatal("unexpected STR_ value 0x%x in get_piled()",
+ text[Pile_info.curr_offset] & 0xff);
+ }
+
+ /* ordinary character */
+ Pile_info.curr_x += width(pile_info_p->font,
+ pile_info_p->size,
+ text[Pile_info.curr_offset]);
+ pile_info_p->ch = text[Pile_info.curr_offset];
+ break;
+ }
+ }
+
+ return(YES);
+}
+\f
+
+/* given a pointer into a string, return the code for the next
+ * character in the string. This will be either the ASCII code
+ * or the music symbol code. This function will also update the
+ * pointer into the string and the font and size if appropriate.
+ * If there happens to be a music character in the middle of a string,
+ * the font (and maybe size) will temporarily be changed for the music
+ * font. This function keeps track of that.
+ *
+ * Restrictions: This function must be used by calling it on the beginning
+ * of a string, then to walk through that string. You don't have to go all the
+ * way to the end of a given string, but once you switch to a new string
+ * (from which you must begin at its beginning) you cannot go back to the
+ * middle of some other string that you had been working on before.
+ *
+ * This function calls the more general function which can also update
+ * vertical motion and alignment information. It is retained for backward
+ * compatibility for the places that don't care about those things.
+ */
+
+int
+next_str_char(str_p_p, font_p, size_p)
+
+char **str_p_p; /* address of pointer into string. Will be incremented
+ * to beyond current character on return (this might
+ * be several bytes into the string if current char
+ * is a special string command */
+int *font_p; /* pointer to font. Will be updated to new font if
+ * appropriate */
+int *size_p; /* pointer to size. Will be updated to new size if
+ * appropriate */
+
+{
+ /* place to hold things we don't care about from general function */
+ double dummy_vertical, dummy_horizontal;
+ int dummy_in_pile;
+ int dummy_textfont;
+
+ return(nxt_str_char(str_p_p, font_p, size_p, &dummy_textfont,
+ &dummy_vertical, &dummy_horizontal, &dummy_in_pile, NO));
+}
+\f
+
+/* returns the next character in string, along with any font/size changes
+ * and horizontal/vertical motions that should happen before that character.
+ */
+
+int
+nxt_str_char(str_p_p, font_p, size_p, textfont_p, vertical_p, horizontal_p, in_pile_p, slash)
+
+char **str_p_p;
+int *font_p;
+int *size_p;
+int *textfont_p; /* font disregarding music characters */
+double *vertical_p; /* if non-zero, do vertical motion */
+double *horizontal_p; /* if non-zero, do horizontal motion */
+int *in_pile_p; /* will be set to YES if inside a pile */
+int slash; /* if YES, return any STR_SLASH's found,
+ * else ignore them */
+
+{
+ static char *prev_str_p; /* most recent value of *str_p_p */
+ static int textfont; /* current font, ignoring music chars */
+ static int textsize; /* current size, ignoring music chars */
+ static int pile_mode; /* if inside a pile */
+ int code;
+ struct PILE_INFO pile_info;
+
+ /* initialize to assume no vertical motion or alignment at this char */
+ *horizontal_p = *vertical_p = 0.0;
+
+ if (*str_p_p == (char *) 0) {
+ return(0);
+ }
+
+ for ( ; ; ) {
+
+ if (prev_str_p != *str_p_p) {
+ /* must be starting on a different string. Our
+ * remembered text font/size are no longer valid */
+ textfont = *font_p;
+ *textfont_p = textfont;
+ textsize = *size_p;
+ pile_mode = NO;
+ }
+
+ if (pile_mode == YES) {
+ /* call the special function for piled to get next */
+ pile_info.font = textfont;
+ pile_info.size = textsize;
+ pile_mode = get_piled(&pile_info);
+
+ /* save what it returned */
+ *font_p = pile_info.font;
+ *size_p = pile_info.size;
+ if (pile_info.font != FONT_MUSIC) {
+ textfont = pile_info.font;
+ *textfont_p = textfont;
+ textsize = pile_info.size;
+ }
+
+ /* Add motion to any accumulated so far */
+ *vertical_p += pile_info.vert;
+ *horizontal_p += pile_info.hor;
+
+ if (pile_info.ch == '\0') {
+ /* only motion this time, keep going */
+ continue;
+ }
+ else if ( (pile_info.ch & 0xff) == STR_SLASH &&
+ slash == NO) {
+ /* caller doesn't care about slashes */
+ continue;
+ }
+ else {
+ *in_pile_p = pile_mode;
+ return (pile_info.ch);
+ }
+ }
+ *in_pile_p = NO;
+
+ if (**str_p_p == '\0') {
+ /* end of string */
+ *font_p = textfont;
+ *size_p = textsize;
+ return(0);
+ }
+
+ if ( ! IS_STR_COMMAND(**str_p_p)) {
+ /* just an ordinary character. Return it after updating
+ * pointer to point past it */
+ code = **str_p_p & 0xff;
+ ++(*str_p_p);
+ prev_str_p = *str_p_p;
+
+ /* if last chacter was music character, put back real * font and size */
+ if (IS_MUSIC_FONT(*font_p)) {
+ *font_p = textfont;
+ *size_p = textsize;
+ }
+ return(code);
+ }
+
+ /* special command. see which one */
+ switch ( (unsigned) (**str_p_p & 0xff) ) {
+
+ case STR_FONT:
+ /* change font to specified font and point past it */
+ *font_p = *++(*str_p_p);
+ ++(*str_p_p);
+ textfont = *font_p;
+ *textfont_p = textfont;
+ break;
+
+ case STR_SIZE:
+ /* change size to specified size and point past it */
+ *size_p = *++(*str_p_p);
+ ++(*str_p_p);
+ textsize = *size_p;
+ break;
+
+ case STR_PAGENUM:
+ /* Page number and number of pages are strange cases.
+ * We don't necessarily know at this point
+ * how many digits long they will be. So we punt:
+ * just return % or #. For height, ascent, and descent,
+ * the % or # will be the same as any number
+ * of digits (or at least close enough, we hope).
+ * That means the only problem is when we are getting
+ * the width of a string or actually printing
+ * it, so we'll deal with those as special cases */
+ *str_p_p += 2;
+ prev_str_p = *str_p_p;
+ return('%');
+ case STR_NUMPAGES:
+ *str_p_p += 2;
+ prev_str_p = *str_p_p;
+ return('#');
+
+
+ case STR_MUS_CHAR:
+ case STR_MUS_CHAR2:
+ /* music character */
+ *font_p = str2mfont( (unsigned) (**str_p_p & 0xff) );
+ *size_p = *++(*str_p_p);
+ code = (*++(*str_p_p)) & 0xff;
+ ++(*str_p_p);
+ prev_str_p = *str_p_p;
+ return(code);
+
+ case STR_BACKSPACE:
+ Backspace_dist = (*++(*str_p_p)) & 0xff;
+ ++(*str_p_p);
+ prev_str_p = *str_p_p;
+ *font_p = textfont;
+ *size_p = textsize;
+ return('\b');
+
+ case STR_PRE:
+ case STR_U_PRE:
+ case STR_PRE_END:
+ case STR_PST:
+ case STR_U_PST:
+ case STR_PST_END:
+ case STR_BOX:
+ case STR_BOX_END:
+ case STR_CIR:
+ case STR_CIR_END:
+ ++(*str_p_p);
+ break;
+
+ case STR_VERTICAL:
+ *vertical_p += vert_distance(
+ DECODE_VERT( *++(*str_p_p) ),
+ textfont, textsize);
+ ++(*str_p_p);
+ break;
+
+ case STR_C_ALIGN:
+ case STR_L_ALIGN:
+ ++(*str_p_p);
+ break;
+
+ case STR_PILE:
+ pile_info.font = textfont;
+ pile_info.size = textsize;
+ *str_p_p = prep_pile(*str_p_p, &pile_info);
+ *vertical_p += pile_info.vert;
+ *horizontal_p += pile_info.hor;
+ *size_p = pile_info.size;
+ textsize = *size_p;
+ pile_mode = YES;
+ break;
+
+ case STR_SLASH:
+ ++(*str_p_p);
+ prev_str_p = *str_p_p;
+ if (slash == YES) {
+ return(STR_SLASH);
+ }
+ break;
+
+ default:
+ pfatal("bad internal format for string (%x)",
+ **str_p_p & 0xff);
+ /*NOTREACHED*/
+ break;
+ }
+ prev_str_p = *str_p_p;
+ }
+}
+\f
+
+/* Given an argument to STR_VERTICAL and a font and size,
+ * return the distance in inches to move vertically. */
+
+static double
+vert_distance(vert_arg, font, size)
+
+int vert_arg;
+int font;
+int size;
+
+{
+ double ratio;
+
+ /* first convert to ratio relative to font height */
+ if (vert_arg >= 0) {
+ ratio = (double) vert_arg / (double) MAXVERTICAL;
+ }
+ else {
+ ratio = (double) vert_arg / (double) (-MINVERTICAL);
+ }
+ return(ratio * fontheight(font, size));
+}
+\f
+
+/* return width of most recent backspace returned by next_str_char() */
+
+double
+backsp_width(size)
+
+int size; /* adjust to this point size */
+
+{
+ return ( (double) Backspace_dist * ((double) size / (double) DFLT_SIZE)
+ / BACKSP_FACTOR);
+}
+
+
+/* Return width of current pile */
+
+double
+pile_width()
+
+{
+ return(Pile_info.width_left_of_align + Pile_info.width_right_of_align);
+}
+\f
+
+/* adjust size when entering/leaving a pile. Called with current size and
+ * whether we are entering or leaving. It returns the new size. */
+
+int
+pile_size(size, in_pile)
+
+int size; /* current size */
+int in_pile; /* if YES, we are currently in a pile and are about to leave
+ * it; if NO, we are about to enter the pile */
+
+{
+ int new_size;
+
+ if (in_pile == NO) {
+ /* entering pile. Save current size, and return new size */
+ Pile_info.orig_size = size;
+ /* constrain new size to be at least MINSIZE */
+ if ((Pile_info.new_size = PILE_A * size / PILE_B) < MINSIZE) {
+ Pile_info.new_size = MINSIZE;
+ }
+ return(Pile_info.new_size);
+ }
+ else {
+ /* leaving pile */
+ /* Restore size. If we're still at the size at the beginning
+ * of the pile, use the orginal value before the pile to avoid
+ * any possible roundoff errors going back and forth,
+ * otherwise adjust by inverse of the factor used when
+ * entering the pile. */
+ if (size == Pile_info.new_size) {
+ return(Pile_info.orig_size);
+ }
+ else {
+ if ((new_size = (size * PILE_B) / PILE_A) > MAXSIZE) {
+ /* constrain to no larger than MAXSIZE */
+ new_size = MAXSIZE;
+ }
+ return(new_size);
+ }
+ }
+}
+\f
+
+/* given where a pile begins and the font/size at that point, return the
+ * width from the beginning to the pile to the alignment point of the pile. */
+
+double
+align_distance(string, font, size)
+
+char *string; /* pile starts here */
+int font;
+int size;
+
+{
+ struct PILE_INFO pile_info;
+
+ pile_info.font = font;
+ pile_info.size = size;
+ (void) prep_pile(string, &pile_info);
+ return(Pile_info.width_left_of_align);
+}
~mdw / mup / blobdiff