--- /dev/null
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include "array.h"
+#include "gjutil.h"
+#include "version.h"
+
+/****************************************************************************
+
+ ALPS - Main routines for ALSCRIPT alignment formatting tool
+
+ Copyright: Geoffrey J. Barton (1992,1993,1997)
+
+ email: geoff@ebi.ac.uk
+
+All use of this program must cite: Barton, G. J. (1993), ALSCRIPT: A Tool to
+Format Multiple Sequence Alignments, Protein Engineering, Volume 6, No. 1,
+pp. 37-40.
+
+ Please see README file for details of limitations of use.
+
+ $Id: alps.c,v 1.3 1998/09/17 17:34:26 geoff Exp $
+ $Log: alps.c,v $
+ Revision 1.3 1998/09/17 17:34:26 geoff
+ Add the new README file and the LICENSE and RELEASE_NOTES
+
+ Revision 1.2 1998/09/17 16:54:58 geoff
+ Check consistency with archive
+
+
+****************************************************************************
+
+ Main routine for ALSCRIPT - formally called ALPS
+
+ alps: 11th June 1992.
+ Author: G. J. Barton
+
+ This file contains a set of subroutines that provide for flexible
+formatting of multiple sequence alignments in PostScript at
+publication quality.
+
+11-18th June 1992:
+
+1. Modified getbloc.c to Agetbloc.c. Agetbloc reads all characters
+(ie not just legal amino acid codes) from an AMPS blocfile format
+multiple alignment file.
+
+2. Wrote basic page scaling features to allow arbitrary page
+dimensions to be defined and to allow all x,y locations to be defined
+in terms of characters of the chosen pointsize. The number of
+residues per line and hence number of pages is determined by the
+pointsize. The page is divided into four areas. (a) The main region
+for plotting out the amino acid sequences. (b) A region to the left of
+a for plotting sequence identifier codes - the width of this region is
+set by variable Cidwidth. (c) A region above region a, and (d) a
+region below a. Regions c and d are initially set to zero size.
+Routine ALReserveSpace() allows a selected number of lines to be
+reserved above or below for plotting.
+
+3. Routines ALOutID and ALOutSeq written and multi-page plotting of
+the sequences sorted out. Still limited to one page in the vertical
+direction - toyed with the idea of writing single page PostScript and
+using PostScript to modify clipping boundaries like in the Poster demo
+program in the CookBook.
+
+4. Experiment with simple boxing facility - ALDrawSimpleBox(). This
+routine is incompatible with multi-page output since page breaks are
+unpredictable.
+
+5. Develop sophisticated (!) boxing facility - defines boxes in terms
+of TOP BOTTOM LEFT and RIGHT lines that may be defined around each
+character routine ALLineRes() implements this feature. The details of
+TOP etc for each character are stored in the unsigned char array
+"lines". This uses the rightmost four bits to encode LEFT RIGHT etc.
+Thus a line to the LEFT line is coded by decimal 1 (0001 binary), a
+full box by decimal 15 (1111 binary). ALBoxRes and ALBoxRegion
+written to allow boxing of arbitrary regions.
+
+6. The y coordinate sent to the low level ALLineRes routine
+refers directly to the index to the lines array. If you want to work in
+residue coordinate space, you need to flip the y coordinate before
+writing to the lines array (also the fill array). Routines ALSurroundChars
+and ALFillChars do this directly. Routines ALBoxRegion and ALFilRegion
+make use of the Yindx array which does the flip in a much cleaner and more
+elegant way. If I'd thought of it at the
+time, I would have used this in ALSurroundChars and ALFillChars as well!
+
+7. Now add capability to split alignments vertically as well as horizontally.
+There is now no limit on pointsize or number/length of sequences
+(in principle!). Next move on the page layout front will be to allow
+multiple blocks on a single page - this would permit alignments of a
+few sequences, or small fonts to make better use of paper!
+
+8. We now have most of the subroutines working OK. So time to tidy up the
+input. Add simple command parser to main programme - this is in two steps,
+step 1 reads the basic page layout commands, step 2 reads the boxing/shading
+font changing commands - Oh yes, added the font changing option as well.
+
+Current commands as follows:
+Commands are delimited by space, comma, or tab. Newline signals the end of a
+command. Unless otherwise stated, units are in characters of the default pointsize.
+For a full list see the file "alscript.doc".
+
+step 1 commands:
+
+BLOCK_FILE <input filename> %The name of the alignment file to format
+OUTPUT_FILE <file> %must have this near the beginning
+LANDSCAPE %Longest side horizontal
+PORTRAIT % vertical
+POINTSIZE <float> %Pointsize for page calculations and character spacing/default size.
+IDENT_WIDTH <integer> %Width allocated to identifiers.
+NUMBER_SEQS 1 || 0 %1=number identifiers, 0= no numbers (default).
+DEFINE_FONT <font number integer> <font name> <pointsize> %define a font to be referred to as font number.
+e.g.
+ DEFINE_FONT 0 Helvetica 10 %font 0 is Helvetica at 10 point
+ DEFINE_FONT 4 Times-Roman DEFAULT %font 4 is Times-Roman at the default pointsize.
+SETUP %signals end of step 1 commands.
+
+step 2 commands:
+
+RESERVE_SPACE_TOP <integer> %make space at the top of the alignment
+RESERVE_SPACE_BOTTOM <integer> % bottom DOES NOT WORK.
+SURROUND_CHARS <chars> <start_res> <start_seq> <end_res> <end_seq>
+ %surround (box) the characters chars within the ranges specified
+e.g.
+ SURROUND_CHARS PG 1 7 20 12 %surround P and G characters from residues 1 to 20 of sequences 7 to 12.
+ SURROUND_CHARS DEKHR ALL %surround D and E and K and R characters for the whole alignment.
+
+SHADE_CHARS <chars> <start_res> <start_seq> <end_res> <end_seq> <grey>
+ %similar syntax to SURROUND_CHARS with the addition of a grey value
+ % 0 = black, 1 = white. Note that shading is done before outputing the
+ % alignment.
+e.g.
+ SHADE_CHARS PG 1 7 20 12 0.5 % shade P and G in the range shown with a grey value of 0.5
+ SHADE_CHARS ILV ALL 0 % shade all I and L and V in black.
+
+FONT_CHARS <chars> <start_res> <start_seq> <end_res> <end_seq> <fontnumber>
+ %same syntax as SHADE_CHARS, only give the font number in place of grey.
+ %font numbers must first be defined with the DEFINE_FONT command above.
+FONT_RESIDUE sx sy font %allows setting of font for one residue (use with TEXT command)
+
+BOX_REGION <start_res> <start_seq> <end_res> <end_seq>
+ %draw a rectangular box around the characters within the defined range.
+SHADE_REGION <start_res> <start_seq> <end_res> <end_seq> <grey>
+ %shade the region by the chosed grey value.
+
+9. Add option to place arbitrary text string at a character location.
+e.g
+ TEXT 1 7 "SIGNAL PEPTIDE" %puts this text at sequence position 1 7.
+ %to change fonts use the FONT_RESIDUE or FONT_REGION commands.
+10. Add option to change fonts of identifiers.
+ID_FONT <sequence> <font>
+e.g.
+ ID_FONT 3 1 %sets font to 1 for sequence identifier 3
+ ID_FONT ALL 7 %uses font 7 for all identifiers
+
+19th June 1992:
+Still fiddling - must get back to some real work soon.
+Split alps away from the scanps program. Now have a separate main() for the routine.
+
+Add options to redefine all defaults: e.g. MAXslen (maximum sequence
+length etc.) Add arbitrary line drawing options: eg. LINE TOP 20 15 50
+draws a line along the top of the characters from residue 20 to 50 or
+sequence 15. Think about adding the option to change line thickness at
+different parts of the plot. Decide not to implement that option right
+now. Add option to include dummy sequences (ADD_SEQ)
+
+Check the programme compiles on the 386 PC. It does!
+Write documentation and brief report of the programme.
+
+22nd June 1992: Get back to some real work!
+
+19th October: Add SILENT_MODE Command and carriage returns to all .PS print statements.
+21st October: Add VERTICAL_SPACING command and ability to output multiple blocks per page.
+15th November: Add pipe options to alscript.c Tidy up file handling.
+
+6th December: Add Colour options.
+18th Jan 1993: Tidy up citations: modify Inverse chars to allow reversion.
+1 March 1993: Fix bug in colour option. Pass use_colour to ALDrawLines routine to
+ specify black for line colour. Previously, this was drawn in white
+ if coloured shading had been specified on the same characters.
+2 March 1993: Fix bug in colour option to output identifiers in black, not white!
+9 March 1993: Add NO_NUMBERS option to avoid printing residue numbers.
+24 March 1993: Add mask features.
+
+11 March 1994: At PERI - Add special text features - preliminary version only.
+ This permits strands and helices to be plotted as cylinders and arrows.
+ Special text features also permit triangles and circles etc etc. through
+ use of text command.
+
+23 May 1995: Numerous changes and additions over the last year - these
+include the option to colour backgrounds differently, ommission of
+idents on second and subsequent lines, helix, strand and other special
+characters, relative numbering, error checking of ranges on input,
+bounding box, screening, conservation colouring...
+
+
+*/
+
+#define TOKENS "\" ,\n\t" /* standard command token delimiters */
+#define POINT 72 /* Work in points throughout */
+#define C_ID_WIDTH 10 /* Default width for writing id's (in characters) */
+#define DEF_POINTSIZE 10.0
+#define X_OFFSET 40 /* offset for bottom lh corner of page (points) */
+#define Y_OFFSET 30
+#define DEF_YPOS 0 /* default first printinf position (character units) */
+#define LINE_WIDTH_FACTOR 0.05 /* Multiply pointsize by this to get linewidth */
+#define MAX_ADD_SEQ 10 /* Maximum number of ADD_SEQ commands allowed */
+
+/*#define MAX_S 10.5 max and min page side in inches */
+/*#define MIN_S 6.5 */
+/*#define MAXSIDE (MAX_S * POINT) Default Max and min dimensions of paper */
+/*#define MINSIDE (MIN_S * POINT) */
+
+#define SCREENSIZE 120 /* define default size for screen */
+
+
+int width = 0; /* max width and height of drawing area */
+int height = 0;
+char *tokens = TOKENS;
+
+float MAXside = 10.5 * POINT; /* values to hold Max and min page side in points */
+float MINside = 6.5 * POINT;
+
+int xoff = X_OFFSET;
+int yoff = Y_OFFSET;
+
+int Cidwidth = C_ID_WIDTH; /* width of id region in characters (left of sequence block)*/
+int Cseqwidth; /* width of sequence region in characters */
+int Cwidth; /* width/height of page in characters */
+int Cheight;
+int Xspace; /* spacing between characters in X */
+int Yspace; /* spacing between characters in Y */
+float XspaceFactor = 0.2; /* extra bit to add to horizontal character spacing */
+float YspaceFactor = 0.0; /* extra bit to add to vertical character spacing */
+float XshiftFactor = 0.12; /* *pointsize gives the shift for vertical lines */
+float YshiftFactor = 0.12; /* horizontal lines */
+
+int CseqTop = 0;
+int CseqVoffset = 0; /* vertical offset for sequence block (characters)*/
+int CtopSpace =0; /* extra space above sequence block (characters) */
+int CbottomSpace = 0; /* " " below " " " */
+int Csheet = 1; /* number of vertical splits in sequence block */
+
+int TVspace = 0; /* total vertical space reserved (characters)*/
+
+float Xshift = 0; /* offsets for drawing box lines */
+float Yshift = 0;
+float LineWidthFactor = LINE_WIDTH_FACTOR;
+
+float pointsize = DEF_POINTSIZE;
+int npage;
+
+int Vspacing = 0; /* vertical spacing in characters between blocks on a page */
+
+
+enum Orientations{
+ LANDSCAPE,
+ PORTRAIT
+};
+
+enum Spaces{
+ TOP,
+ BOTTOM
+};
+
+struct addseq {
+ int pos;
+ int num;
+};
+
+/* bit masks for the lines array */
+unsigned char LINE_LEFT = 1; /* mask for line at left of char */
+unsigned char LINE_RIGHT= 2; /* right */
+unsigned char LINE_TOP = 4; /* top */
+unsigned char LINE_BOTTOM=8; /* bottom */
+
+void ALOutId(struct seqdat *,int,unsigned char *colour,
+ unsigned char *,int,int,int,int, FILE *);
+void ALOutSeq(struct seqdat *,unsigned char **,
+ char ***,
+ unsigned char **,int ,unsigned char **,
+ unsigned char **text_colour,
+ unsigned char background_colour,
+ int ,int ,int ,int ,FILE *);
+void PSPutText(int,int,char *,FILE *);
+void PSPutChar(int,int,char,FILE *);
+void PSShowPage(FILE *);
+void ALSetFont(char *,int,FILE *);
+void ALCheckSinglePage(int ,int ,int );
+void ALSetPageLimits(void);
+void PSSetOrientation(int, FILE *);
+void PSPreamble(FILE *,int, int*, int screensize);
+void PSLandscape(FILE *);
+void PSPortrait(FILE *);
+void PSSetupPage(int,int,FILE *);
+void ALReserveSpace(int, int);
+void ALReportInfo(int, FILE *);
+char **ALCreateNumbers(int,int,int,int);
+char *ALCreateTicks(int,int,int);
+void ALOutTicks(char *,int,int,int,int,FILE *);
+void ALOutNumbers(char **,int,int,int,int,FILE *);
+void PSDrawBox(float,float,float,float,float,FILE *);
+void ALSimpleBox(int,int,int,int,float,FILE *);
+void PSline(float,float,float,float,FILE *);
+void ALLineChar(unsigned char **,int,int,unsigned char);
+void ALLineRes(unsigned char **,int,int,unsigned char);
+void ALDrawLines(unsigned char **,int,
+ unsigned char **left_line_colour,
+ unsigned char **right_line_colour,
+ unsigned char **top_line_colour,
+ unsigned char **bottom_line_colour,
+ int,int,int,int,int,int,FILE *);
+void ALBoxRes(unsigned char **,int,int);
+void ALDrawFills(signed char **,int ,unsigned char **,
+ int,int ,int,int ,int ,int, FILE *);
+void ALFilRes(signed char **,int,int,float);
+void ALBoxRegion(unsigned char **,int,int,int,int,int *);
+void ALFilRegion(signed char **,int ,int,int,int , int *,float);
+void ALSurroundChars(struct seqdat *,unsigned char **,int,int,int,int,int,char *);
+void ALShadeChars(struct seqdat *,signed char **,
+ int ,int,int,int,int,char *,float);
+void ALDefineFont(int,char *,float,FILE *);
+void echo(char *);
+void ALGetFourInt(int *,int *,int *,int *);
+void ALGetThreeInt(int *,int *,int *);
+void ALGetTwoInt(int *,int *);
+void ALFontChars(struct seqdat *,unsigned char **,
+ int,int,int,int,char *,unsigned char);
+void ALFontRegion(unsigned char **,int,int,int,int,unsigned char);
+void PSSetFont(unsigned char,FILE *);
+void ALDoLine(unsigned char **,int,int,int,int,int *);
+void ALSubChars(struct seqdat *,int,int,int,int,char,char);
+char ALChekSpace(const char *);
+void PSSetGrey(float,FILE *);
+void ALInverseChars(struct seqdat *,unsigned char **,int,int,int,int,char *);
+int Agetbloc(FILE *,struct seqdat *,int *);
+void ALDefineColour(int,char *coltype, float,float,float,FILE *);
+void ALSColChars(struct seqdat *,unsigned char **,
+ int,int,int,int,int,char *,unsigned char);
+void ALColourChars(struct seqdat *,unsigned char **,
+ int ,int,int,int,char *,unsigned char);
+void ALColRes(unsigned char **,int ,int , int );
+void PSSetColour(unsigned char,FILE *);
+void ALColRegion(unsigned char **,int,int,int,int,int *,unsigned char);
+void ALColRRegion(unsigned char **,int,int,int,int,unsigned char);
+void ckdd(struct seqdat *, int);
+int Ifound(struct seqdat *,int,int,char *,int);
+void ALSColMask(unsigned char **,unsigned char **,
+ int, int, int, int,int, unsigned char);
+void ALInverseMask(unsigned char **,unsigned char **,int, int, int, int);
+void ALFontMask(unsigned char **,unsigned char **,int, int, int, int,unsigned char);
+void ALShadeMask(unsigned char **,signed char **,int,int,int,int,int *, float);
+void ALGetAllRange(int *, int *, int *, int *,int ,int );
+void ALid_mask(unsigned char **,struct seqdat *,int, int, int, int, int, char *, char *);
+void ALfre_mask(unsigned char **mask,struct seqdat *,int, int, int, int, char *, char *);
+int Ifound(struct seqdat *,int,int,char *,int);
+void ALagree_mask(unsigned char **,struct seqdat *,int,int,int,int,int);
+void ALnot_mask(unsigned char **,int, int, int, int);
+void ALsub_mask(unsigned char **,struct seqdat *,int, int, int, int, char);
+void ALMask(unsigned char **,int, int, int, int);
+void ALConsMask(unsigned char **mask,
+int sx,int sy,int ex,int ey,int *consval,int conscut);
+void ALColourMask(unsigned char **,unsigned char **,int,int,int,int,unsigned char);
+void ALSurroundMask(unsigned char **,struct seqdat *,unsigned char **,int,int,int,int,int);
+int save_pir(struct seqdat *,int,FILE *);
+void ALDrawHorizLine(
+ float Xpos, /* bottom left hand corner of character posn */
+ float Ypos, /* */
+ float Xspace, /* horizontal width of character position */
+ float Yspace, /* vertical height of character position */
+ float width_fac,FILE *outf); /* proportion of vertical height that the line will fill */
+void ALDrawRightArrow(float Xpos,float Ypos, float Xspace,
+ float Yspace, float width_fac,FILE *outf);
+void ALDrawLeftArrow(float Xpos,float Ypos, float Xspace,
+ float Yspace, float width_fac,FILE *outf);
+void ALDrawUpArrow(float Xpos,float Ypos, float Xspace,
+ float Yspace, float width_fac,FILE *outf);
+void ALDrawDownArrow(float Xpos,float Ypos, float Xspace,
+ float Yspace, float width_fac,FILE *outf);
+void ALDrawCircle(float Xpos,float Ypos, float Xspace,
+ float Yspace, float width_fac,FILE *outf);
+void ALDrawPseudoEllipse(float Xpos,float Ypos, float Xspace,
+ float Yspace, float width_fac,
+ FILE *outf);
+void ALDrawLeftSemiEnd(float Xpos,float Ypos, float Xspace,
+ float Yspace, float width_fac,FILE *outf);
+void ALDrawRightSemiEnd(float Xpos,float Ypos, float Xspace,
+ float Yspace, float width_fac,FILE *outf);
+void ALDrawRightHalfHorizLine(float Xpos,float Ypos,float Xspace,
+ float Yspace,float width_fac,FILE *outf);
+void ALDrawLeftHalfHorizLine(float Xpos,float Ypos,float Xspace,float
+ Yspace,float width_fac,FILE *outf);
+void PSmoveto(float x,float y,FILE *outf);
+void PSlineto(float x,float y,FILE *outf);
+void PSPutSpecialText(float Xpos,float Ypos,float Xspace,
+ float Yspace,char *text,unsigned char current_col,
+ unsigned char background_colour,
+ float YspaceFactor,FILE *outf);
+void PSstroke(FILE *outf);
+void PSnewpath(FILE *outf);
+void ALColourBackground(FILE *outf,int colour,int *background_region);
+void ALCheckLegalRange(int sx,int sy, int ex, int ey, int xmin, int ymin, int xmax, int ymax);
+void ALMakeCoilText(int sx, int sy, int ex, char ***texts);
+void ALMakeStrandText(int sx, int sy, int ex, char ***texts);
+void ALMakeHelixText(int sx, int sy, int ex, char ***texts);
+int ALrel(char *pos,int *relnum);
+int GJindex(char *str,char c);
+float mzcons(unsigned char *pos,int n);
+int *ALCalCons(struct seqdat *bloc,
+ int sx,int sy,int ex,int ey,int *ret_val,int len);
+int save_msf(struct seqdat *bloc,int nseq,FILE *msff);
+
+int alps(char *command_file,int silent, int pipe, int singlepage)
+{
+ FILE *cf,*inf,*outf,*pirf,*msff;
+ char *buff;
+ char *token;
+ char *charstring;
+ struct seqdat *bloc;
+ struct seqdat *temp;
+ int orientation;
+ extern int MAXtlen,MAXnbloc;
+ extern int MAXilen,precis,MAXslen;
+ int nseq;
+ int start_aa;
+ int start_seq;
+ int i,j,k;
+ int totalpage;
+ char **numbers;
+ char *ticks;
+ unsigned char **lines;
+#ifdef VAX
+ char **fills;
+#else
+ signed char **fills;
+#endif
+ unsigned char **fonts;
+ unsigned char *idfonts;
+ unsigned char **inverse;
+ char ***texts;
+ int *Yindx;
+ int number_seqs = 0;
+
+ int Xtemp,Ytemp;
+ int sx,sy,ex,ey;
+
+ int fnum;
+ char *fname;
+ float fpoint;
+ int rowsiz;
+
+ char oldchar,newchar;
+
+ struct seqdat *addbloc;
+ struct addseq *adds;
+ int nadds;
+ int natot;
+ int l;
+ int do_ticks = 0;
+ int number_int = 10;
+ int pirsave = 0;
+ int msfsave = 0;
+
+ int nbp,nspage; /*counter and total for number of blocks per page */
+ int lastY;
+ int nbpage;
+
+ /* bounding_box - allows explicit fiddling with the bounding_box */
+ int *bounding_box;
+
+ /* colours */
+ float red,green,blue;
+ unsigned char **s_colour; /*colour number for shading */
+ unsigned char **c_colour; /*colour number for characters */
+ /* new 4th Oct 1994 */
+ unsigned char *id_colour; /*colour for identifiers */
+ unsigned char **left_line_colour; /*colours for lines */
+ unsigned char **right_line_colour;
+ unsigned char **top_line_colour;
+ unsigned char **bottom_line_colour;
+ unsigned char **text_colour; /*colour for text */
+ char *colname;
+
+ int background_colour = 99; /*set background to white */
+ int *background_region; /* use this to set the region for background colouring */
+
+ int number_colour = 100; /* colour for numbers along top of plot */
+ /* end new */
+ char *tstring;
+
+ int use_colour; /* flag set if the define_colour command is seen */
+ int res_numbers;
+
+ int msl;
+
+ /* min and max ranges in the sequence alignment */
+ int xmin, ymin, xmax, ymax;
+
+ /* masking variables */
+ unsigned char **mask;
+ char *illegal;
+ char *legal;
+ int id_cut;
+
+ /* screen size variable - for printer screen */
+ int screensize = SCREENSIZE;
+
+ /* set up relative numbering - allows commands to follow
+ a specific sequence numbering
+ firstres defines the number of the first residue */
+ int relative_seq = 0;
+ int firstres = 0;
+ int i1;
+ int *relnum;
+ /* temp relnum */
+ int *trelnum;
+
+ /* flag for idents */
+ int id_only_on_first = 0;
+ int tempCseqwidth;
+ int tempCidwidth;
+
+ /* conservation values */
+ int *consval; /* array */
+ int conscut; /* cutoff */
+
+ /* counter for add_seq errors */
+ int adderr;
+
+ /* file streams */
+ extern FILE *std_in, *std_out, *std_err;
+
+ /* By default read and write to stdin and stdout */
+ outf = std_out;
+ inf = std_in;
+
+
+ /* default is no colour */
+ use_colour = 0;
+
+ /* if set, residue numbers are output */
+ res_numbers = 1;
+
+
+
+ /* set the bounding box to default values for portrait A4*/
+ bounding_box = (int *) GJmalloc(sizeof(int) * 4);
+ bounding_box[0] = 0;
+ bounding_box[1] = 0;
+ bounding_box[2] = 590;
+ bounding_box[3] = 826;
+
+ /* set the background colour region equal to the default bounding box */
+ background_region = (int *) GJmalloc(sizeof(int) * 4);
+ background_region[0] = 0;
+ background_region[1] = 0;
+ background_region[2] = 590;
+ background_region[3] = 826;
+
+ /* initialise the mask */
+ mask = NULL;
+ illegal = NULL;
+ legal = NULL;
+
+ adds = (struct addseq *) malloc(sizeof(struct addseq) * (MAX_ADD_SEQ+1));
+ nadds = 0;
+
+
+ fname = (char *) malloc(sizeof(char)*MAXtlen);
+
+ buff = (char *) malloc(MAXtlen * sizeof(char));
+ if(buff == NULL)error("No Space for buff",1);
+
+ if((cf = fopen(command_file,"r")) == NULL){
+ error("Cannot open ALSCRIPT command file",0);
+ return 0;
+ }
+
+ /*
+ This is a little inelegant at the moment - when I get the generalized
+ parser finished this could be cleaned up substantially
+ */
+
+ /* main loop to read commands */
+ if(pipe){
+ /* Alscript is being used as a pipe so write preamble to std_out */
+ outf = std_out;
+ PSPreamble(outf,singlepage,bounding_box,screensize);
+ }
+
+ if(!silent)fprintf(std_err,"Starting ALSCRIPT\n");
+
+ while(buff = fgets(buff,MAXtlen,cf)){
+ if(!silent)echo(buff);
+ if(buff == NULL) continue;
+ token = strtok(buff,TOKENS);
+ if(token == NULL) continue;
+ token = GJstoup(token);
+ if(*token == '#'){
+ if(!silent)echo("Comment\n");
+ }else if(strcmp(token,"SILENT_MODE")==0){
+ if(!silent){
+ silent=1;
+ }else{
+ silent=0;
+ }
+ }else if(strcmp(token,"MAX_INPUT_LEN")==0){
+ if(!silent) fprintf(std_err,"Max input len was:\t%d\n",MAXtlen);
+ token = strtok(NULL,TOKENS);
+ MAXtlen = atoi(token);
+ if(!silent)fprintf(std_err,"Max input len now:\t%d\n",MAXtlen);
+ }else if(strcmp(token,"MAX_NSEQ")==0){
+ if(!silent)fprintf(std_err,"Max No. of sequences was:\t%d\n",MAXnbloc);
+ token = strtok(NULL,TOKENS);
+ MAXnbloc = atoi(token);
+ MAXtlen = MAXnbloc;
+ fprintf(std_err,"Max No. of sequences now:\t%d\n",MAXnbloc);
+ }else if(strcmp(token,"MAX_ILEN")==0){
+ if(!silent)fprintf(std_err,"Max Identifier length was:\t%d\n",MAXilen);
+ token = strtok(NULL,TOKENS);
+ MAXilen = atoi(token);
+ if(!silent)fprintf(std_err,"Max Identifier length now:\t%d\n",MAXilen);
+ }else if(strcmp(token,"PRECISION")==0){
+ token = strtok(NULL,TOKENS);
+ precis = atoi(token);
+ }else if(strcmp(token,"MAX_SEQ_LEN")==0){
+ if(!silent)fprintf(std_err,"Max Sequence Length was:\t%d\n",MAXslen);
+ token = strtok(NULL,TOKENS);
+ MAXslen = atoi(token);
+ if(!silent)fprintf(std_err,"Max Sequence Length now:\t%d\n",MAXslen);
+ }else if(strcmp(token,"X_OFFSET")==0){
+ if(!silent)fprintf(std_err,"X offset was:\t%d\n",xoff);
+ token = strtok(NULL,TOKENS);
+ xoff = atoi(token);
+ if(!silent)fprintf(std_err,"X offset now:\t%d\n",xoff);
+ }else if(strcmp(token,"Y_OFFSET")==0){
+ if(!silent)fprintf(std_err,"Y offset was:\t%d\n",yoff);
+ token = strtok(NULL,TOKENS);
+ yoff = atoi(token);
+ if(!silent)fprintf(std_err,"Y offset now:\t%d\n",yoff);
+ }else if(strcmp(token,"MAX_SIDE")==0){
+ if(!silent)fprintf(std_err,"Longest page side was:\t%.2f inches\n",MAXside/POINT);
+ token = strtok(NULL,TOKENS);
+ MAXside = POINT * atof(token);
+ if(!silent)fprintf(std_err,"Longest page side now:\t%.2f inches\n",MAXside/POINT);
+ }else if(strcmp(token,"MIN_SIDE")==0){
+ if(!silent)fprintf(std_err,"Shortest page side was:\t%.2f inches\n",MINside/POINT);
+ token = strtok(NULL,TOKENS);
+ MINside = POINT * atof(token);
+ if(!silent)fprintf(std_err,"Shortest page side now:\t%.2f inches\n",MINside/POINT);
+ }else if(strcmp(token,"LINE_WIDTH_FACTOR")==0){
+ if(!silent)fprintf(std_err,"Line width multiplication factor was:\t%f\n",LineWidthFactor);
+ token = strtok(NULL,TOKENS);
+ LineWidthFactor = atof(token);
+ if(!silent)fprintf(std_err,"Line width multiplication factor now:\t%f\n",LineWidthFactor);
+ }else if(strcmp(token,"SCREENSIZE")==0){
+ if(!silent)fprintf(std_err,"Screensize was:\t%d\n",screensize);
+ token = strtok(NULL,TOKENS);
+ screensize = atoi(token);
+ if(!silent)fprintf(std_err,"Screensize now:\t%d\n",screensize);
+ }else if(strcmp(token,"BLOCK_FILE") == 0){
+ token = strtok(NULL,TOKENS);
+ if(!pipe){
+ inf = fopen(token,"r");
+ if(inf == NULL)error("Cannot open BLOCK_FILE\n",1);
+ }
+ }else if(strcmp(token,"OUTPUT_FILE")==0){
+ token = strtok(NULL,TOKENS);
+ if(!pipe){
+ outf = fopen(token,"w");
+ if(outf == NULL)error("Cannot open OUTPUT_FILE\n",1);
+ PSPreamble(outf,singlepage,bounding_box,screensize);
+ }
+ }else if(strcmp(token,"PIR_SAVE")==0){
+ token = strtok(NULL,TOKENS);
+ pirf = fopen(token,"w");
+ if(pirf == NULL)error("Cannot open PIR_SAVE file\n",1);
+ pirsave = 1;
+ }else if(strcmp(token,"MSF_SAVE")==0){
+ token = strtok(NULL,TOKENS);
+ msff = fopen(token,"w");
+ if(msff == NULL)error("Cannot open MSF_SAVE file\n",1);
+ msfsave = 1;
+ }else if(strcmp(token,"LANDSCAPE")==0){
+ orientation = LANDSCAPE;
+ }else if(strcmp(token,"PORTRAIT")==0){
+ orientation = PORTRAIT;
+
+ }else if(strcmp(token,"POINTSIZE")==0){
+ token = strtok(NULL,TOKENS);
+ pointsize = atof(token);
+ }else if(strcmp(token,"IDENT_WIDTH")==0){
+ token = strtok(NULL,TOKENS);
+ Cidwidth = atoi(token);
+ if(Cidwidth > MAXilen)error("INCREASE MAX_ID_LEN value",1);
+ }else if(strcmp(token,"NUMBER_SEQS")==0){
+ number_seqs=1;
+ }else if(strcmp(token,"X_SPACE_FACTOR")==0){
+ if(!silent)fprintf(std_err,"Was:\t%.2f\n",XspaceFactor);
+ token = strtok(NULL,TOKENS);
+ XspaceFactor = atof(token);
+ if(!silent)fprintf(std_err,"Now Is:\t%.2f\n",XspaceFactor);
+ }else if(strcmp(token,"Y_SPACE_FACTOR")==0){
+ if(!silent)fprintf(std_err,"Was:\t%.2f\n",YspaceFactor);
+ token = strtok(NULL,TOKENS);
+ YspaceFactor = atof(token);
+ }else if(strcmp(token,"X_SHIFT_FACTOR")==0){
+ if(!silent)fprintf(std_err,"Was:\t%.2f\n",XshiftFactor);
+ token = strtok(NULL,TOKENS);
+ XshiftFactor = atof(token);
+ if(!silent)fprintf(std_err,"Now Is:\t%.2f\n",XshiftFactor);
+ }else if(strcmp(token,"Y_SHIFT_FACTOR")==0){
+ if(!silent)fprintf(std_err,"Was:\t%.2f\n",YshiftFactor);
+ token = strtok(NULL,TOKENS);
+ YshiftFactor = atof(token);
+ if(!silent)fprintf(std_err,"Now Is:\t%.2f\n",YshiftFactor);
+ }else if(strcmp(token,"VERTICAL_SPACING")==0){
+ if(!silent)fprintf(std_err,"Was:\t%d\n",Vspacing);
+ token = strtok(NULL,TOKENS);
+ Vspacing = (int) atol(token);
+ if(!silent)fprintf(std_err,"Now Is:\t%d\n",Vspacing);
+ }else if(strcmp(token,"DEFINE_FONT")==0){
+ token = strtok(NULL,TOKENS);
+ fnum = atoi(token); /* font number */
+ token = strtok(NULL,TOKENS); /* font name */
+ fname = strcpy(fname,token);
+ token = strtok(NULL,TOKENS);
+ if(strcmp(token,"DEFAULT")==0){
+ fpoint = pointsize;
+ }else if(strcmp(token,"REL")==0){
+ token = strtok(NULL,TOKENS);
+ fpoint = pointsize * atof(token);
+ }else{
+ fpoint = atof(token);
+ }
+ ALDefineFont(fnum,fname,fpoint,outf);
+ }else if(strcmp(token,"DEFINE_COLOUR")==0 || strcmp(token,"DEFINE_COLOR")==0){
+ /* new style
+ define_colour <colour_number | colour type> colour_name r g b <colour_number> */
+ /* e.g. define_colour 1 1.0 1.0 1.0
+ (same as before)
+ define_colour rgb red 1.0 0.0 0.0 7
+ (define an rgb colour (red,green,blue),colour_number)
+ define_colour hsb red 1.0 0.0 0.0 9
+ (define an hsb colour (hue,sat,bright),colour_number)
+ currently can use either hsb OR rgb, but not mix them
+ */
+ use_colour = 1;
+ token = strtok(NULL,TOKENS);
+ tstring = GJstoupper(token);
+ if(strcmp(tstring,"RGB")==0 || strcmp(tstring,"HSB")==0){
+ token = strtok(NULL,TOKENS);
+ colname = GJstrdup(token);
+ token = strtok(NULL,TOKENS);
+ red = atof(token);
+ token = strtok(NULL,TOKENS);
+ green = atof(token);
+ token = strtok(NULL,TOKENS);
+ blue = atof(token);
+ token = strtok(NULL,TOKENS);
+ fnum = atoi(token);
+ }else{
+ fnum = atoi(token); /* colour number */
+ token = strtok(NULL,TOKENS);
+ red = atof(token);
+ token = strtok(NULL,TOKENS);
+ green = atof(token);
+ token = strtok(NULL,TOKENS);
+ blue = atof(token);
+
+ }
+ /* for now just ignore the colour name - we'll allow use of this later */
+ ALDefineColour(fnum,tstring,red,green,blue,outf);
+ GJfree(tstring);
+ }else if(strcmp(token,"ADD_SEQ")==0){
+ token = strtok(NULL,TOKENS);
+ adds[nadds].pos = atoi(token);
+ token = strtok(NULL,TOKENS);
+ adds[nadds].num = atoi(token);
+ ++nadds;
+ }else if(strcmp(token,"DO_TICKS")==0){
+ do_ticks=1;
+ }else if(strcmp(token,"NUMBER_INT")==0){
+ token = strtok(NULL,TOKENS);
+ number_int = atoi(token);
+ if(!silent)fprintf(std_err,"Sequence Numbering interval now:\t%d\n",number_int);
+ }else if(strcmp(token,"NO_NUMBERS")==0){
+ res_numbers = 0;
+ }else if(strcmp(token,"NUMBER_COLOUR")==0){
+ token = strtok(NULL,TOKENS);
+ number_colour = atoi(token);
+ }else if(strcmp(token,"SINGLE_PAGE")==0){
+ /* if this is set, then alscript assumes a single page -
+ just adds a bounding box for now*/
+ if(!silent)fprintf(std_err,"Single page was: %d\n",singlepage);
+ singlepage = 1;
+ if(!silent)fprintf(std_err,"Single page now: %d\n",singlepage);
+ }else if(strcmp(token,"BOUNDING_BOX")==0){
+ ALGetFourInt(&bounding_box[0],&bounding_box[1],
+ &bounding_box[2],&bounding_box[3]);
+ if(!silent){
+ fprintf(std_err,"Bounding box set to: %d %d %d %d\n",
+ bounding_box[0],bounding_box[1],
+ bounding_box[2],bounding_box[3]);
+ }
+ }else if(strcmp(token,"BACKGROUND_REGION") == 0){
+ /* set the region of the background to colour */
+ ALGetFourInt(&background_region[0],&background_region[1],
+ &background_region[2],&background_region[3]);
+ if(!silent){
+ fprintf(std_err,"Background region set to: %d %d %d %d\n",
+ background_region[0],background_region[1],
+ background_region[2],background_region[3]);
+ }
+ }else if(strcmp(token,"ID_ONLY_ON_FIRST_LINE")==0){
+ /* flag to indicate identifiers only on first line!*/
+ id_only_on_first = 1;
+ }else if(strcmp(token,"BACKGROUND_COLOUR") ==0){
+ /* set the colour for background defined by background_region */
+ token = strtok(NULL,TOKENS);
+ background_colour = atoi(token);
+ }else if(strcmp(token,"SETUP")==0){
+ if(!silent)fprintf(std_err,"Initial Commands read - Establishing basic settings\n");
+ break;
+ }else{
+ fprintf(std_err,"%s",buff);
+ error("Unrecognised Step 1 command",1);
+
+ }
+ }
+
+ if(outf == std_out){
+ if(!silent)fprintf(std_err,"Output file undefined - will write to stdout\n");
+ }
+
+
+ if(inf == std_in){
+ if(!silent)fprintf(std_err,"Block file undefined - will read from stdin\n");
+ }
+
+ bloc = (struct seqdat *) malloc(sizeof(struct seqdat) * MAXnbloc);
+ mcheck((char *) bloc,"Cannot get space for bloc");
+ if(!Agetbloc(inf,bloc,&nseq))error("Cannot read bloc file",1);
+
+ ckdd(bloc,nseq);
+
+ if(pirsave){
+ if(!save_pir(bloc,nseq,pirf))error("Cannot write to pirf file",1);
+ exit(0);
+ }
+
+ if(msfsave){
+ if(!save_msf(bloc,nseq,msff))error("Cannot write to msf file",1);
+ exit(0);
+ }
+
+ /* Initialise relnum to 1..n*/
+ /* relnum = (int *) GJmalloc(sizeof(int) * MAXslen); */
+ /* for(i=1;i<MAXslen;++i){ */
+ /* relnum[i]=i; */
+ /* } */
+
+ /* Initialise relnum to 1..n*/
+ /* 29 July 1998 - allocate relnum to MAXslen *2. with pointer in the middle */
+
+ trelnum = (int *) GJmalloc(sizeof(int) * MAXslen * 2);
+ for(i=1;i<(MAXslen +1);++i){
+ trelnum[i]=0;
+ }
+ relnum = &trelnum[MAXslen];
+ for(i=1;i<MAXslen;++i){
+ relnum[i] = i;
+ }
+
+ /* do a check of the adds array to make sure there are no out of bounds
+ requests
+ */
+ adderr = 0;
+ for(i=0;i<nadds;++i){
+ if(adds[i].pos > nseq){
+ ++adderr;
+ fprintf(std_err,"Error in ADD_SEQ request: %d %d\n",adds[i].pos,adds[i].num);
+ fprintf(std_err,"%d is greater than the number of sequences in the block file(%d)\n",adds[i].pos,nseq);
+ fprintf(std_err,"Please see the manual for help on using ADD_SEQ\n");
+ }
+ }
+ if(adderr > 0){
+ fprintf(std_err,"%d ADD_SEQ errors - exiting\n",adderr);
+ exit(-1);
+ }
+
+
+ if(nadds > 0){
+ if(!silent)fprintf(std_err,"Making extra space for %d additions\n",nadds);
+ natot = 0;
+ for(i=0;i<nadds;++i){
+ natot += adds[i].num;
+ }
+ if(!silent)fprintf(std_err,"Total of %d extra sequences\n",natot);
+ addbloc = (struct seqdat *) malloc(sizeof(struct seqdat) *(nseq+natot+1));
+ i = 0;
+ j = 0;
+ k = 0;
+ while(i < nseq+1){
+ if(k < nadds && i==adds[k].pos){
+ /* reserve space for the new sequences and set to blank*/
+ for(l=0;l<adds[k].num;++l){
+ ++j;
+ addbloc[j].id = (char *) malloc(sizeof(char) * MAXilen);
+ addbloc[j].id = GJstrblank(addbloc[j].id,MAXilen);
+ addbloc[j].seq = (char *) malloc(sizeof(char) * (bloc[1].slen+1));
+ addbloc[j].seq = GJstrblank(addbloc[j].seq,bloc[1].slen+1);
+ }
+ ++k;
+ }else{
+ /* just copy the pointers to the bloc sequences */
+ ++i;
+ ++j;
+ if(i<nseq+1){
+ addbloc[j].id = bloc[i].id;
+ addbloc[j].title = bloc[i].title;
+ addbloc[j].seq = bloc[i].seq;
+ }
+ }
+ }
+ addbloc[1].slen = bloc[1].slen;
+ temp = bloc;
+ bloc = addbloc;
+ addbloc = temp;
+ nseq += natot;
+ if(!silent)fprintf(std_err,"Total number of sequences now: %d\n",nseq);
+ }
+ msl = bloc[1].slen-2; /* maximum sequence length defined */
+
+ xmin = 1; ymin = 1; xmax = msl+1; ymax = nseq;
+
+ PSSetupPage(orientation,1,outf);
+ ALSetPageLimits();
+
+ CtopSpace = 2; /* set top 2 lines for numbers */
+
+ /* now set up the bounding box and background
+ based on current values of xoff, yoff, width and height
+ these can be overridden by step 2 commands
+
+ bounding_box[0] = 0;
+ bounding_box[1] = 0;
+ bounding_box[2] = width;
+ bounding_box[3] = height;
+ */
+
+ /* set the background colour region equal to the default bounding box
+ background_region[0] = bounding_box[0];
+ background_region[1] = bounding_box[1];
+ background_region[2] = bounding_box[2];
+ background_region[3] = bounding_box[3];
+ */
+
+ if(background_colour != 99)ALColourBackground(outf,background_colour,background_region);
+
+
+
+/* TVspace = nseq;*/
+/* ALReserveSpace(TOP,2);*/
+
+
+ /* allocate to +1 size to allow indexing from 1...max */
+ /* lines array - stored info on where to draw lines */
+ lines = uchararr(bloc[1].slen+1,nseq+1);
+ if(lines == NULL)error("No space for lines array\n",1);
+ GJUCinit(lines,bloc[1].slen+1,nseq+1,0);
+
+ /* array holds grey value for each character fill*/
+ fills = chararr(bloc[1].slen+1,nseq+1);
+ if(fills == NULL)error("No space for fills array\n",1);
+ GJCinit(fills,bloc[1].slen+1,nseq+1,-1);
+
+ /* allocate to +1 size to allow indexing from 1...max */
+ /* fonts array - stores a number representing the font to use for each residue */
+ /* default font is font 0 */
+ fonts = uchararr(bloc[1].slen+1,nseq+1);
+ if(fonts == NULL)error("No space for fonts array\n",1);
+ GJUCinit(fonts,bloc[1].slen+1,nseq+1,0);
+
+ /* inverse indicates whether the the text at i j should be printed in white */
+ inverse = uchararr(bloc[1].slen+1,nseq+1);
+ if(inverse == NULL)error("No space for inverse array\n",1);
+ GJUCinit(inverse,bloc[1].slen+1,nseq+1,0);
+
+ /* colour arrays - define the colour to use for shading and lettering */
+ /* default colour numbers are 99 for white and 100 for black */
+ s_colour = uchararr(bloc[1].slen+1,nseq+1); /* shading colour */
+ if(s_colour == NULL)error("No space for s_colour array\n",1);
+ GJUCinit(s_colour,bloc[1].slen+1,nseq+1,background_colour);
+ c_colour = uchararr(bloc[1].slen+1,nseq+1); /* character colour */
+ if(c_colour == NULL)error("No space for c_colour array\n",1);
+ GJUCinit(c_colour,bloc[1].slen+1,nseq+1,100);
+ left_line_colour = uchararr(bloc[1].slen+1,nseq+1); /* left line colour */
+ if(left_line_colour == NULL)error("No space for left_line_colour array\n",1);
+ GJUCinit(left_line_colour,bloc[1].slen+1,nseq+1,100);
+ right_line_colour = uchararr(bloc[1].slen+1,nseq+1); /* right line colour */
+ if(right_line_colour == NULL)error("No space for right_line_colour array\n",1);
+ GJUCinit(right_line_colour,bloc[1].slen+1,nseq+1,100);
+ top_line_colour = uchararr(bloc[1].slen+1,nseq+1); /* top line colour */
+ if(top_line_colour == NULL)error("No space for top_line_colour array\n",1);
+ GJUCinit(top_line_colour,bloc[1].slen+1,nseq+1,100);
+ bottom_line_colour = uchararr(bloc[1].slen+1,nseq+1); /* bottom line colour */
+ if(bottom_line_colour == NULL)error("No space for bottom_line_colour array\n",1);
+ GJUCinit(bottom_line_colour,bloc[1].slen+1,nseq+1,100);
+ text_colour = uchararr(bloc[1].slen+1,nseq+1); /* text colour */
+ if(text_colour == NULL)error("No space for text_colour array\n",1);
+ GJUCinit(text_colour,bloc[1].slen+1,nseq+1,100);
+
+ /* holds font information for each identifier */
+ idfonts = (unsigned char *) malloc(sizeof(unsigned char) * nseq+1);
+ for(i=0;i<nseq+1;++i){
+ idfonts[i]= (unsigned char) 0;
+ }
+ /* holds colour information for each identifier */
+ id_colour = (unsigned char *) GJmalloc(sizeof(unsigned char) * nseq+1);
+ for(i=0;i<nseq+1;++i){
+ id_colour[i]= (unsigned char) 100;
+ }
+ /* holds conservation values */
+ consval = (int *) GJmalloc(sizeof(int) * bloc[1].slen);
+ GJIinit(consval,bloc[1].slen,0);
+
+
+ /* array holds pointers to text strings at each [i][j] point*/
+ texts = (char ***) malloc(sizeof(char **) * (bloc[1].slen+1));
+ rowsiz = sizeof(char *) * (nseq + 1);
+ for(k=0;k<bloc[1].slen+1;++k){
+ texts[k] = (char **) malloc(rowsiz);
+ for(i=0;i<(nseq+1);++i){
+ texts[k][i]=NULL;
+ }
+ }
+
+ Yindx = (int *) malloc(sizeof(int)*(nseq+1));
+ for(i=1,j=nseq;i<nseq+1;++i,--j){
+ Yindx[i] = j;
+ }
+
+ numbers = ALCreateNumbers(0,number_int,bloc[1].slen,4);
+ ticks = ALCreateTicks(0,number_int,bloc[1].slen);
+ CseqTop = nseq;
+
+ while(buff = fgets(buff,MAXtlen,cf)){
+ if(buff == NULL) break;
+ if(!silent)echo(buff);
+ token = strtok(buff,TOKENS);
+ if(token == NULL) break;
+ token = GJstoup(token);
+ if(*token == '#'){
+ if(!silent)echo("Comment\n");
+ }else if(strcmp(token,"SILENT_MODE")==0){
+ if(!silent){
+ silent=1;
+ }else{
+ silent=0;
+ }
+/* This block has moved to the MODE 1 section
+ }else if(strcmp(token,"BOUNDING_BOX")==0){
+ ALGetFourInt(&bounding_box[0],&bounding_box[1],
+ &bounding_box[2],&bounding_box[3]);
+
+ }else if(strcmp(token,"BACKGROUND_REGION") == 0){
+ set the region of the background to colour
+ ALGetFourInt(&background_region[0],&background_region[1],
+ &background_region[2],&background_region[3]);
+*/
+ }else if(strcmp(token,"RESERVE_SPACE_TOP")==0){
+ token = strtok(NULL,TOKENS);
+ ALReserveSpace(TOP,atoi(token));
+ }else if(strcmp(token,"RESERVE_SPACE_BOTTOM")==0){
+ token = strtok(NULL,TOKENS);
+ ALReserveSpace(BOTTOM,atoi(token));
+ CseqTop = nseq + CbottomSpace;
+ }else if(strcmp(token,"SURROUND_CHARS")==0){
+ token = strtok(NULL,TOKENS);
+ charstring = token;
+ ALGetAllRange(&sx,&sy,&ex,&ey,xmax,nseq);
+ ALCheckLegalRange(relnum[sx],sy,relnum[ex],ey,xmin,ymin,xmax,ymax);
+ ALSurroundChars(bloc,lines,relnum[sx],sy,relnum[ex],ey,nseq,charstring);
+ }else if(strcmp(token,"SHADE_CHARS")==0){
+ token = strtok(NULL,TOKENS);
+ charstring = token;
+ ALGetAllRange(&sx,&sy,&ex,&ey,xmax,nseq);
+ ALCheckLegalRange(relnum[sx],sy,relnum[ex],ey,xmin,ymin,xmax,ymax);
+ token = strtok(NULL,TOKENS);
+ ALShadeChars(bloc,fills,relnum[sx],sy,relnum[ex],ey,nseq,charstring,(float)atof(token));
+ }else if(strcmp(token,"FONT_CHARS")==0){
+ token = strtok(NULL,TOKENS);
+ charstring = token;
+ ALGetAllRange(&sx,&sy,&ex,&ey,xmax,nseq);
+ ALCheckLegalRange(relnum[sx],sy,relnum[ex],ey,xmin,ymin,xmax,ymax);
+ token = strtok(NULL,TOKENS);
+ ALFontChars(bloc,fonts,relnum[sx],sy,relnum[ex],ey,charstring,atoi(token));
+ }else if(strcmp(token,"CCOL_CHARS")==0){ /* colour characters */
+ if(!use_colour)error("You must use the DEFINE_COLOUR command first",1);
+ token = strtok(NULL,TOKENS);
+ charstring = token;
+ ALGetAllRange(&sx,&sy,&ex,&ey,xmax,nseq);
+ ALCheckLegalRange(relnum[sx],sy,relnum[ex],ey,xmin,ymin,xmax,ymax);
+ token = strtok(NULL,TOKENS);
+ ALColourChars(bloc,c_colour,relnum[sx],sy,relnum[ex],ey,charstring,atoi(token));
+ }else if(strcmp(token,"SCOL_CHARS")==0){ /* colour character backgrounds */
+ if(!use_colour)error("You must use the DEFINE_COLOUR command first",1);
+ token = strtok(NULL,TOKENS);
+ charstring = token;
+ ALGetAllRange(&sx,&sy,&ex,&ey,xmax,nseq);
+ ALCheckLegalRange(relnum[sx],sy,relnum[ex],ey,xmin,ymin,xmax,ymax);
+ token = strtok(NULL,TOKENS);
+ ALSColChars(bloc,s_colour,relnum[sx],sy,relnum[ex],ey,nseq,charstring,(unsigned char) atoi(token));
+ }else if(strcmp(token,"INVERSE_CHARS")==0){
+ token = strtok(NULL,TOKENS);
+ charstring = token;
+ ALGetAllRange(&sx,&sy,&ex,&ey,xmax,nseq);
+ ALCheckLegalRange(relnum[sx],sy,relnum[ex],ey,xmin,ymin,xmax,ymax);
+ ALInverseChars(bloc,inverse,relnum[sx],sy,relnum[ex],ey,charstring);
+ }else if(strcmp(token,"SUB_CHARS")==0){
+ token = strtok(NULL,TOKENS);
+ if(strcmp(token,"ALL")==0){
+ token = strtok(NULL,TOKENS);
+ oldchar = ALChekSpace(token);
+ token = strtok(NULL,TOKENS);
+ newchar = ALChekSpace(token);
+ ALSubChars(bloc,1,1,bloc[1].slen-1,nseq,oldchar,newchar);
+ }else{
+ sx = atoi(token);
+ ALGetThreeInt(&sy,&ex,&ey);
+ token = strtok(NULL,TOKENS);
+ oldchar = ALChekSpace(token);
+ token = strtok(NULL,TOKENS);
+ newchar = ALChekSpace(token);
+ ALCheckLegalRange(relnum[sx],sy,relnum[ex],ey,xmin,ymin,xmax,ymax);
+ ALSubChars(bloc,relnum[sx],sy,relnum[ex],ey,oldchar,newchar);
+ }
+ }else if(strcmp(token,"SUB_ID")==0){
+ token = strtok(NULL,"\"");
+ sx = atoi(token);
+ token = strtok(NULL,"\"");
+ ALCheckLegalRange(xmin,1,xmax,sx,xmin,ymin,xmax,ymax);
+ bloc[sx].id = (char *) realloc(bloc[sx].id,sizeof(char)*(strlen(token)+1));
+ bloc[sx].id = strcpy(bloc[sx].id,token);
+ }else if(strcmp(token,"FONT_REGION")==0){
+ ALGetAllRange(&sx,&sy,&ex,&ey,xmax,nseq);
+ token = strtok(NULL,TOKENS);
+ ALCheckLegalRange(relnum[sx],sy,relnum[ex],ey,xmin,ymin,xmax,ymax);
+ ALFontRegion(fonts,relnum[sx],sy,relnum[ex],ey,atoi(token));
+ }else if(strcmp(token,"FONT_RESIDUE")==0){
+ token = strtok(NULL,TOKENS);
+ sx = atoi(token);
+ token=strtok(NULL,TOKENS);
+ sy = atoi(token);
+ token=strtok(NULL,TOKENS);
+ ALCheckLegalRange(relnum[sx],sy,relnum[sx],sy,xmin,ymin,xmax,ymax);
+ ALFontRegion(fonts,relnum[sx],sy,relnum[sx],sy,atoi(token));
+ }else if(strcmp(token,"LINE")==0){
+ token = strtok(NULL,TOKENS);
+ if(strcmp(token,"TOP")==0){
+ ALGetThreeInt(&sx,&sy,&ex);
+ if(ex > bloc[1].slen-1) ex = bloc[1].slen-1;
+ ALCheckLegalRange(relnum[sx],sy,relnum[ex],sy,xmin,ymin,xmax,ymax);
+ ALDoLine(lines,relnum[sx],sy,relnum[ex],LINE_TOP,Yindx);
+ }else if(strcmp(token,"BOTTOM")==0){
+ ALGetThreeInt(&sx,&sy,&ex);
+ ALCheckLegalRange(relnum[sx],sy,relnum[ex],sy,xmin,ymin,xmax,ymax);
+ if(ex > bloc[1].slen-1) ex = bloc[1].slen-1;
+ ALDoLine(lines,relnum[sx],sy,relnum[ex],LINE_BOTTOM,Yindx);
+ }else if(strcmp(token,"LEFT")==0){
+ ALGetThreeInt(&sx,&sy,&ey);
+ ALCheckLegalRange(relnum[sx],sy,relnum[sx],ey,xmin,ymin,xmax,ymax);
+ if(ey > nseq) ey = nseq;
+ ALDoLine(lines,relnum[sx],sy,ey,LINE_LEFT,Yindx);
+ }else if(strcmp(token,"RIGHT")==0){
+ ALGetThreeInt(&sx,&sy,&ey);
+ ALCheckLegalRange(relnum[sx],sy,relnum[sx],ey,xmin,ymin,xmax,ymax);
+ if(ey > nseq) ey = nseq;
+ ALDoLine(lines,relnum[sx],sy,ey,LINE_RIGHT,Yindx);
+ }else{
+ error("Illegal LINE command\n",1);
+ }
+ }else if(strcmp(token,"BOX_REGION")==0){
+ ALGetAllRange(&sx,&sy,&ex,&ey,xmax,nseq);
+ ALCheckLegalRange(relnum[sx],sy,relnum[ex],ey,xmin,ymin,xmax,ymax);
+ ALBoxRegion(lines,relnum[sx],sy,relnum[ex],ey,Yindx);
+ }else if(strcmp(token,"SHADE_REGION")==0){
+ ALGetAllRange(&sx,&sy,&ex,&ey,xmax,nseq);
+ ALCheckLegalRange(relnum[sx],sy,relnum[ex],ey,xmin,ymin,xmax,ymax);
+ token = strtok(NULL,TOKENS);
+ ALFilRegion(fills,relnum[sx],sy,relnum[ex],ey,Yindx,(float)atof(token));
+ }else if(strcmp(token,"SHADE_RES")==0){
+ ALGetTwoInt(&sx,&sy);
+ ALCheckLegalRange(relnum[sx],sy,relnum[sx],sy,xmin,ymin,xmax,ymax);
+ token = strtok(NULL,TOKENS);
+ ALFilRegion(fills,relnum[sx],sy,relnum[sx],sy,Yindx,(float)atof(token));
+ }else if(strcmp(token,"COLOUR_REGION")==0 || strcmp(token,"COLOR_REGION")==0){
+ if(!use_colour)error("You must use the DEFINE_COLOUR command first",1);
+ ALGetAllRange(&sx,&sy,&ex,&ey,xmax,nseq);
+ ALCheckLegalRange(relnum[sx],sy,relnum[ex],ey,xmin,ymin,xmax,ymax);
+ token = strtok(NULL,TOKENS);
+ ALColRegion(s_colour,relnum[sx],sy,relnum[ex],ey,Yindx,(unsigned char) atoi(token));
+ }else if(strcmp(token,"COLOUR_TEXT_REGION")==0 || strcmp(token,"COLOR_TEXT_REGION")==0){
+ if(!use_colour)error("You must use the DEFINE_COLOUR command first",1);
+ ALGetAllRange(&sx,&sy,&ex,&ey,xmax,nseq);
+ ALCheckLegalRange(relnum[sx],sy,relnum[ex],ey,xmin,ymin,xmax,ymax);
+ token = strtok(NULL,TOKENS);
+ ALColRRegion(text_colour,relnum[sx],sy,relnum[ex],ey,(unsigned char) atoi(token));
+ }else if(strcmp(token,"COLOUR_RES")==0 || strcmp(token,"COLOR_RES")==0){
+ if(!use_colour)error("You must use the DEFINE_COLOUR command first",1);
+ ALGetTwoInt(&sx,&sy);
+ ALCheckLegalRange(relnum[sx],sy,relnum[sx],sy,xmin,ymin,xmax,ymax);
+ token = strtok(NULL,TOKENS);
+ ALColRRegion(s_colour,relnum[sx],sy,relnum[sx],sy,(unsigned char) atoi(token));
+ }else if(strcmp(token,"CCOLOUR_REGION")==0 || strcmp(token,"CCOLOR_REGION")==0){
+ if(!use_colour)error("You must use the DEFINE_COLOUR command first",1);
+ ALGetAllRange(&sx,&sy,&ex,&ey,xmax,nseq);
+ ALCheckLegalRange(relnum[sx],sy,relnum[ex],ey,xmin,ymin,xmax,ymax);
+ token = strtok(NULL,TOKENS);
+ ALColRRegion(c_colour,relnum[sx],sy,relnum[ex],ey,(unsigned char) atoi(token));
+ }else if(strcmp(token,"COLOUR_LINE_REGION")==0 || strcmp(token,"COLOR_LINE_REGION")==0){
+ if(!use_colour)error("You must use the DEFINE_COLOUR command first",1);
+ ALGetAllRange(&sx,&sy,&ex,&ey,xmax,nseq);
+ ALCheckLegalRange(relnum[sx],sy,relnum[ex],ey,xmin,ymin,xmax,ymax);
+ token = strtok(NULL,TOKENS);
+ ALColRegion(left_line_colour,relnum[sx],sy,relnum[ex],ey,Yindx,(unsigned char) atoi(token));
+ ALColRegion(right_line_colour,relnum[sx],sy,relnum[ex],ey,Yindx,(unsigned char) atoi(token));
+ ALColRegion(top_line_colour,relnum[sx],sy,relnum[ex],ey,Yindx,(unsigned char) atoi(token));
+ ALColRegion(bottom_line_colour,relnum[sx],sy,relnum[ex],ey,Yindx,(unsigned char) atoi(token));
+ }else if(strcmp(token,"CCOLOUR_RES")==0 || strcmp(token,"CCOLOR_RES")==0){
+ if(!use_colour)error("You must use the DEFINE_COLOUR command first",1);
+ ALGetTwoInt(&sx,&sy);
+ token = strtok(NULL,TOKENS);
+ ALCheckLegalRange(relnum[sx],sy,relnum[sx],sy,xmin,ymin,xmax,ymax);
+ ALColRRegion(c_colour,relnum[sx],sy,relnum[sx],sy,(unsigned char) atoi(token));
+ }else if(strcmp(token,"MASK")==0){
+ /* mask commands */
+ token = strtok(NULL,TOKENS);
+ if(strcmp(token,"SETUP")==0){
+ if(mask == NULL){
+ mask = uchararr(bloc[1].slen+1,nseq+1);
+ GJUCinit(mask,bloc[1].slen+1,nseq+1,0);
+ }else{
+ GJUCinit(mask,bloc[1].slen+1,nseq+1,0);
+ }
+ }else if(strcmp(token,"RESET")==0){
+ GJUCinit(mask,bloc[1].slen+1,nseq+1,0);
+ }else if(strcmp(token,"LEGAL")==0){
+ /* get the legal character list */
+ token = strtok(NULL,TOKENS);
+ if(legal != NULL) GJfree(legal);
+ legal = GJstrdup(token);
+ if(!silent)fprintf(stderr,"legal:%s\n",legal);
+ }else if(strcmp(token,"ILLEGAL")==0){
+ /* get the illegal character list */
+ token = strtok(NULL,TOKENS);
+ if(illegal != NULL) GJfree(illegal);
+ illegal = GJstrdup(token);
+ if(!silent)fprintf(stderr,"illegal:%s:\n",illegal);
+ }else if(strcmp(token,"ID")==0){
+ ALGetAllRange(&sx,&sy,&ex,&ey,xmax,nseq);
+ ALCheckLegalRange(relnum[sx],sy,relnum[ex],ey,xmin,ymin,xmax,ymax);
+ token = strtok(NULL,TOKENS);
+ id_cut = atoi(token);
+ if(id_cut < (int) ( ( ((float) (ey-sy+1) / 2.0) + 0.6))){
+ error("ID cutoff must be > half the number of sequences",1);
+ }
+ ALid_mask(mask,bloc,relnum[sx],sy,relnum[ex],ey,id_cut,legal,illegal);
+ }else if(strcmp(token,"AGREE")==0){
+ ALGetAllRange(&sx,&sy,&ex,&ey,xmax,nseq);
+ ALCheckLegalRange(relnum[sx],sy,relnum[ex],ey,xmin,ymin,xmax,ymax);
+ token= strtok(NULL,TOKENS);
+ ALagree_mask(mask,bloc,relnum[sx],sy,relnum[ex],ey,atoi(token));
+ }else if(strcmp(token,"FRE")==0){
+ ALGetAllRange(&sx,&sy,&ex,&ey,xmax,nseq);
+ ALCheckLegalRange(relnum[sx],sy,relnum[ex],ey,xmin,ymin,xmax,ymax);
+ ALfre_mask(mask,bloc,relnum[sx],sy,relnum[ex],ey,legal,illegal);
+ }else if(strcmp(token,"NOT")==0){
+ ALGetAllRange(&sx,&sy,&ex,&ey,xmax,nseq);
+ ALCheckLegalRange(relnum[sx],sy,relnum[ex],ey,xmin,ymin,xmax,ymax);
+ ALnot_mask(mask,relnum[sx],sy,relnum[ex],ey);
+ }else if(strcmp(token,"SUB")==0){
+ ALGetAllRange(&sx,&sy,&ex,&ey,xmax,nseq);
+ ALCheckLegalRange(relnum[sx],sy,relnum[ex],ey,xmin,ymin,xmax,ymax);
+ token=strtok(NULL,TOKENS);
+ ALsub_mask(mask,bloc,relnum[sx],sy,relnum[ex],ey,token[0]);
+ }else if(strcmp(token,"REGION")==0){
+ ALGetAllRange(&sx,&sy,&ex,&ey,xmax,nseq);
+ ALCheckLegalRange(relnum[sx],sy,relnum[ex],ey,xmin,ymin,xmax,ymax);
+ ALMask(mask,relnum[sx],sy,relnum[ex],ey);
+ }else if(strcmp(token,"CONSERVATION")==0){
+ ALGetAllRange(&sx,&sy,&ex,&ey,xmax,nseq);
+ ALCheckLegalRange(relnum[sx],sy,relnum[ex],ey,xmin,ymin,xmax,ymax);
+ token=strtok(NULL,TOKENS);
+ conscut = atoi(token);
+ if(!silent)fprintf(std_err,"Conservation Cutoff:%d\n",conscut);
+ ALConsMask(mask,relnum[sx],sy,relnum[ex],ey,consval,conscut);
+ }else if(strcmp(token,"BOX")==0){
+ /* box the masked residues - ie surround them*/
+ ALGetAllRange(&sx,&sy,&ex,&ey,xmax,nseq);
+ ALCheckLegalRange(relnum[sx],sy,relnum[ex],ey,xmin,ymin,xmax,ymax);
+ ALSurroundMask(mask,bloc,lines,relnum[sx],sy,relnum[ex],ey,nseq);
+ }else if(strcmp(token,"SHADE")==0){
+ /* shade the masked residues - */
+ ALGetAllRange(&sx,&sy,&ex,&ey,xmax,nseq);
+ ALCheckLegalRange(relnum[sx],sy,relnum[ex],ey,xmin,ymin,xmax,ymax);
+ token = strtok(NULL,TOKENS);
+ ALShadeMask(mask,fills,relnum[sx],sy,relnum[ex],ey,Yindx,(float)atof(token));
+ }else if(strcmp(token,"FONT")==0){
+ /* set the font of the masked residues - */
+ ALGetAllRange(&sx,&sy,&ex,&ey,xmax,nseq);
+ ALCheckLegalRange(relnum[sx],sy,relnum[ex],ey,xmin,ymin,xmax,ymax);
+ token = strtok(NULL,TOKENS);
+ ALFontMask(mask,fonts,relnum[sx],sy,relnum[ex],ey,(unsigned char) atoi(token));
+ }else if(strcmp(token,"INVERSE")==0){
+ /* invert the masked residues - */
+ ALGetAllRange(&sx,&sy,&ex,&ey,xmax,nseq);
+ ALCheckLegalRange(relnum[sx],sy,relnum[ex],ey,xmin,ymin,xmax,ymax);
+ token = strtok(NULL,TOKENS);
+ ALInverseMask(mask,inverse,relnum[sx],sy,relnum[ex],ey);
+ }else if(strcmp(token,"SCOL")==0){
+ if(!use_colour)error("You must use the DEFINE_COLOUR command first",1);
+ ALGetAllRange(&sx,&sy,&ex,&ey,xmax,nseq);
+ ALCheckLegalRange(relnum[sx],sy,relnum[ex],ey,xmin,ymin,xmax,ymax);
+ token = strtok(NULL,TOKENS);
+ ALSColMask(mask,s_colour,relnum[sx],sy,relnum[ex],ey,nseq,(unsigned char) atoi(token));
+ }else if(strcmp(token,"CCOL")==0){
+ if(!use_colour)error("You must use the DEFINE_COLOUR command first",1);
+ ALGetAllRange(&sx,&sy,&ex,&ey,xmax,nseq);
+ ALCheckLegalRange(relnum[sx],sy,relnum[ex],ey,xmin,ymin,xmax,ymax);
+ token = strtok(NULL,TOKENS);
+ ALColourMask(mask,c_colour,relnum[sx],sy,relnum[ex],ey,(unsigned char) atoi(token));
+ }else{
+ error("Unrecognised MASK qualifier\n",1);
+ }
+ }else if(strcmp(token,"TEXT")==0){
+ token=strtok(NULL,TOKENS);
+ sx = atoi(token);
+ token=strtok(NULL,"\"");
+ sy = atoi(token);
+ token=strtok(NULL,"\"");
+ ALCheckLegalRange(relnum[sx],sy,relnum[sx],sy,xmin,ymin,xmax,ymax);
+ texts[relnum[sx]][sy] = (char *) malloc(sizeof(char)*(strlen(token)+1));
+ texts[relnum[sx]][sy] = (char *) strcpy(texts[relnum[sx]][sy],token);
+ }else if(strcmp(token,"NUMBERS")==0){
+ error("Numbers not implemented",1);
+ }else if(strcmp(token,"ID_FONT")==0){
+ token = strtok(NULL,TOKENS);
+ if(strcmp(token,"ALL")==0){
+ token = strtok(NULL,TOKENS);
+ for(i=1;i<nseq+1;++i)idfonts[i]= (unsigned char) atoi(token);
+ }else{
+ sx = atoi(token);
+ token = strtok(NULL,TOKENS);
+ ALCheckLegalRange(xmin,ymin,xmax,sx,xmin,ymin,xmax,ymax);
+ idfonts[sx] = atoi(token);
+ }
+ }else if(strcmp(token,"ID_COLOUR")==0){
+ token = strtok(NULL,TOKENS);
+ if(strcmp(token,"ALL")==0){
+ token = strtok(NULL,TOKENS);
+ for(i=1;i<nseq+1;++i)id_colour[i]= (unsigned char) atoi(token);
+ }else{
+ sx = atoi(token);
+ ALCheckLegalRange(xmin,ymin,xmax,sx,xmin,ymin,xmax,ymax);
+ token = strtok(NULL,TOKENS);
+ id_colour[sx] = atoi(token);
+ }
+ }else if(strcmp(token,"HELIX")==0){
+ ALGetThreeInt(&sx,&sy,&ex);
+ ALCheckLegalRange(relnum[sx],sy,relnum[ex],sy,xmin,ymin,xmax,ymax);
+ ALMakeHelixText(relnum[sx],sy,relnum[ex],texts);
+ }else if(strcmp(token,"STRAND")==0){
+ ALGetThreeInt(&sx,&sy,&ex);
+ ALCheckLegalRange(relnum[sx],sy,relnum[ex],sy,xmin,ymin,xmax,ymax);
+ ALMakeStrandText(relnum[sx],sy,relnum[ex],texts);
+ }else if(strcmp(token,"COIL")==0){
+ ALGetThreeInt(&sx,&sy,&ex);
+ ALCheckLegalRange(relnum[sx],sy,relnum[ex],sy,xmin,ymin,xmax,ymax);
+ ALMakeCoilText(relnum[sx],sy,relnum[ex],texts);
+ }else if(strcmp(token,"CALCONS")==0){
+ /* calculate conservation for the range */
+ ALGetFourInt(&sx,&sy,&ex,&ey);
+ ALCheckLegalRange(relnum[sx],relnum[sy],relnum[ex],relnum[ey],xmin,ymin,xmax,ymax);
+ consval = ALCalCons(bloc,relnum[sx],relnum[sy],relnum[ex],relnum[ey],
+ consval,bloc[1].slen);
+/* fprintf(std_err,"Conservation Values\n"); */
+/* for(k=1;k<bloc[1].slen-1;++k){*/
+/* fprintf(std_err,"%d:%d\n",k,consval[k]);*/
+/* }*/
+ }else if(strcmp(token,"RELATIVE_TO")==0){
+ token = strtok(NULL,TOKENS);
+ relative_seq = atoi(token);
+ fprintf(stderr,"RELATIVE SEQ %d\n",relative_seq);
+ fprintf(stderr,"bloc[relative_seq].slen+1] %d\n",
+ bloc[relative_seq].slen+1);
+ token = strtok(NULL,TOKENS);
+ if(token != NULL){
+ /* there is a first residue definition */
+ firstres = atoi(token);
+ fprintf(stderr,"First position is number: %d\n",firstres);
+ }else{
+ firstres = 1;
+ }
+ if(relative_seq != 0){
+ k= firstres - 1;
+ for(i=1;i<bloc[1].slen+1;++i){
+ /* for now assume all gaps are blanks */
+ if(bloc[relative_seq].seq[i] != ' '){
+ ++k;
+ relnum[k] = i;
+ }
+ }
+ /* increase the max allowed X value to the max of xmax and k */
+ /* leave the minimum value at 1 since otherwise we will not be able to mix
+ absolute and relative numbers without the Check routine skwawking */
+ if(k > xmax ) xmax = k;
+ }else{
+ for(i=1;i<bloc[1].slen+1;++i){
+ relnum[i] = i;
+ }
+ }
+ }else{
+ fprintf(std_err,"%s",buff);
+ error("Unrecognised Step 2 command\n",1);
+ }
+ }
+ if(!silent){
+ ALReportInfo(nseq,std_err);
+ }
+ ALCheckSinglePage(nseq,bloc[1].slen,silent);
+
+ start_aa = 1;
+ totalpage = npage * Csheet;
+
+ /* get how many blocks of sequence we can fit per page */
+ nspage = Cheight/(nseq+CtopSpace+Vspacing);
+ if(nspage < 1){
+ nspage = 1;
+ }
+ nbp = 0;
+
+ if(!silent)fprintf(std_err,"Will write a maximum of %d blocks of sequence per page\n",nspage);
+ if(!silent)fprintf(std_err,"Background region: %d %d %d %d\n",
+ background_region[0],
+ background_region[1],
+ background_region[2],
+ background_region[3]);
+ if(!silent && singlepage)fprintf(std_err,"Bounding box: %d %d %d %d\n",
+ bounding_box[0],
+ bounding_box[1],
+ bounding_box[2],
+ bounding_box[3]);
+
+ /* MARKER */
+
+ if((Cwidth - Cidwidth > 0)){
+ if(!silent)fprintf(std_err,"Saving (%d) Pages to file\n",totalpage/nspage);
+ }else{
+ fprintf(std_err,"This pointsize is too large to print even a single character on the page\n");
+ fprintf(std_err,"Try a smaller pointsize - or\n");
+ fprintf(std_err,"Try reducing the Identifier width\n");
+ fprintf(std_err,"Increase the paper size\n");
+ fprintf(std_err,"You could do some PostScrip-ery to print partial characters\n");
+ fprintf(std_err,"After creating an alignment on a single page - see the CookBook\n");
+ exit(1);
+ }
+ lastY = 0;
+ nbpage = 0;
+ k = 0;
+ start_seq = 1;
+ while(k < totalpage){
+ start_aa = 1;
+ Ytemp = start_seq+Cheight-CtopSpace - 1;
+ if(Ytemp > nseq) Ytemp = nseq;
+ for(i=0;i<npage;++i){
+
+ if(nspage > 1){ /* more than one block per page */
+/* fprintf(stderr,"nbp nspage %d %d\n",nbp,nspage);*/
+ if(k>0 && nbp == 0){ /* if not the first page, then setup page*/
+ PSSetupPage(orientation,nbpage+1,outf);
+ if(background_colour != 99){
+ ALColourBackground(outf,background_colour,background_region);
+ }
+ }
+ if(nbp>0){
+ /* if this is not the first block on the page, then */
+ /* translate the block of alignment back to origin */
+ fprintf(outf,"%d %d translate\n",0,-lastY);
+ }
+ /* get new position for drawing and translate to this posn*/
+ lastY = Yspace*( Cheight-(nseq+CtopSpace)*(nbp+1) - (nbp*Vspacing) );
+ fprintf(outf,"%d %d translate\n",0,lastY);
+ }else{
+ if(k>0)PSSetupPage(orientation,k+1,outf);
+ if(background_colour != 99){
+ ALColourBackground(outf,background_colour,background_region);
+ }
+ }
+ if(id_only_on_first == 1 && nbp > 0 ){
+ /* save the Cseqwidth, then reset it to Cwidth - also set Cidwidth to 0*/
+ tempCseqwidth = Cseqwidth;
+ tempCidwidth = Cidwidth;
+ Cseqwidth = Cwidth;
+ Cidwidth = 0;
+ }
+
+ Xtemp = start_aa+Cseqwidth-1;
+ if(Xtemp > bloc[1].slen) Xtemp = bloc[1].slen;
+
+ fprintf(outf,"2 setlinecap\n");
+ fprintf(outf," %.2f setlinewidth\n",LineWidthFactor*pointsize);
+
+ ALDrawFills(fills,use_colour,s_colour,start_aa,nseq-Ytemp+1,Xtemp,nseq-start_seq+1,Cidwidth,CseqVoffset,outf);
+ ALDrawLines(lines,use_colour,
+ left_line_colour,
+ right_line_colour,
+ top_line_colour,
+ bottom_line_colour,
+ start_aa,nseq-Ytemp+1,Xtemp,nseq-start_seq+1,Cidwidth,CseqVoffset,outf);
+ if(!(id_only_on_first == 1 && (nbp > 0 || k > 0))){
+ /* don't output ID string if this is not the first block on the first page*/
+ ALOutId(bloc,use_colour,
+ id_colour,idfonts,start_seq,Ytemp,CseqVoffset,number_seqs,outf);
+ }
+ ALOutSeq(bloc,fonts,texts,inverse,use_colour,c_colour,
+ text_colour,background_colour,start_seq,Ytemp,start_aa,CseqVoffset,outf);
+
+ if(res_numbers){
+ if(use_colour)PSSetColour(number_colour,outf);
+ if(do_ticks){
+ ALOutTicks(ticks,start_aa,Cidwidth,Ytemp-start_seq+1,bloc[1].slen,outf);
+ ALOutNumbers(numbers,start_aa,Cidwidth,Ytemp-start_seq+2,bloc[1].slen,outf);
+ }else{
+ ALOutNumbers(numbers,start_aa,Cidwidth,Ytemp-start_seq+1,bloc[1].slen,outf);
+ }
+ }
+ start_aa += Cseqwidth;
+
+ if(nspage > 1){
+ ++nbp;
+ if(nbp == nspage || k == totalpage-1){ /* put showpage command for page or last page */
+ PSShowPage(outf);
+ nbp = 0;
+ ++nbpage;
+ }
+ }else{
+ PSShowPage(outf);
+ }
+ ++k;
+ }
+ start_seq = Ytemp + 1;
+ if(id_only_on_first == 1 && nbp > 0){
+ /* reset the values - not strictly necessary */
+ Cseqwidth = tempCseqwidth;
+ Cidwidth = tempCidwidth;
+ }
+ }
+ return 1;
+}
+
+void ALShadeChars(struct seqdat *bloc,
+signed char **fill,
+int start_x,int start_y,int end_x,int end_y,
+int maxY,
+char *charlist,
+float grey)
+
+/* shade residues in charlist by grey value */
+
+{
+ int i,j,jpos;
+ for(i=start_x;i<end_x+1;++i){
+ for(j=start_y,jpos=(maxY-start_y+1);j<end_y+1;++j,--jpos){
+ if(strchr(charlist,bloc[j].seq[i])!=NULL){
+ ALFilRes(fill,i,jpos,grey);
+ }
+ }
+ }
+}
+void ALSColChars(struct seqdat *bloc,unsigned char **colour,int start_x,
+int start_y,int end_x,int end_y,int maxY,char *charlist,unsigned char colnum)
+
+/* colour residue backgrounds in charlist by colnum value */
+
+{
+ int i,j,jpos;
+ for(i=start_x;i<end_x+1;++i){
+ for(j=start_y,jpos=(maxY-start_y+1);j<end_y+1;++j,--jpos){
+ if(strchr(charlist,bloc[j].seq[i])!=NULL){
+ ALColRes(colour,i,jpos,colnum);
+ }
+ }
+ }
+}
+
+void ALSColMask(unsigned char **mask,unsigned char **colour,
+ int start_x,int start_y,int end_x,int end_y,int maxY,
+ unsigned char colnum)
+
+/* colour residue backgrounds in mask by colnum value */
+
+{
+ int i,j,jpos;
+ for(i=start_x;i<end_x+1;++i){
+ for(j=start_y,jpos=(maxY-start_y+1);j<end_y+1;++j,--jpos){
+ if(mask[i][j]==1){
+ ALColRes(colour,i,jpos,colnum);
+ }
+ }
+ }
+}
+void ALInverseChars(struct seqdat *bloc,unsigned char **inverse,
+ int start_x,int start_y,int end_x,int end_y,char *charlist)
+
+/* Invert the characters within the range */
+/* 18/Jan/93: Allow inverted chars to be reverted */
+
+{
+ int i,j;
+ for(i=start_x;i<end_x+1;++i){
+ for(j=start_y;j<end_y+1;++j){
+ if(strchr(charlist,bloc[j].seq[i])!=NULL){
+ if(inverse[i][j] == 1){
+ inverse[i][j] = (unsigned char) 0;
+ }else{
+ inverse[i][j] = (unsigned char ) 1;
+ }
+ }
+ }
+ }
+}
+void ALInverseMask(unsigned char **mask,unsigned char **inverse,
+ int start_x,int start_y,int end_x,int end_y)
+/* Invert the characters within the range of the mask*/
+/* 18/Jan/93: Allow inverted chars to be reverted */
+
+{
+ int i,j;
+ for(i=start_x;i<end_x+1;++i){
+ for(j=start_y;j<end_y+1;++j){
+ if(mask[i][j]){
+ if(inverse[i][j] == 1){
+ inverse[i][j] = (unsigned char) 0;
+ }else{
+ inverse[i][j] = (unsigned char ) 1;
+ }
+ }
+ }
+ }
+}
+
+void ALFontChars(struct seqdat *bloc,unsigned char **fonts,
+ int start_x,int start_y,int end_x,int end_y,char *charlist,unsigned char fontnum)
+
+/* set the characters within the range to the fontnum */
+
+{
+ int i,j;
+ for(i=start_x;i<end_x+1;++i){
+ for(j=start_y;j<end_y+1;++j){
+ if(strchr(charlist,bloc[j].seq[i])!=NULL){
+ fonts[i][j] = fontnum;
+ }
+ }
+ }
+}
+void ALFontRegion(unsigned char **fonts,
+ int start_x,int start_y,int end_x,int end_y,
+ unsigned char fontnum)
+/* set the characters within the range to the fontnum */
+
+{
+ int i,j;
+ for(i=start_x;i<end_x+1;++i){
+ for(j=start_y;j<end_y+1;++j){
+ fonts[i][j] = fontnum;
+ }
+ }
+}
+void ALFontMask(unsigned char **mask,unsigned char **fonts,
+ int start_x,int start_y,int end_x,int end_y,
+ unsigned char fontnum)
+
+/* set the characters within the range to the fontnum */
+
+{
+ int i,j;
+ for(i=start_x;i<end_x+1;++i){
+ for(j=start_y;j<end_y+1;++j){
+ if(mask[i][j]==1){
+ fonts[i][j] = fontnum;
+ }
+ }
+ }
+}
+
+void ALColourChars(struct seqdat *bloc,unsigned char **colour,
+ int start_x,int start_y,int end_x,int end_y,
+ char *charlist,unsigned char colournum)
+
+/* set the characters within the range to the colour defined by colournum */
+
+{
+ int i,j;
+ for(i=start_x;i<end_x+1;++i){
+ for(j=start_y;j<end_y+1;++j){
+ if(strchr(charlist,bloc[j].seq[i])!=NULL){
+ colour[i][j] = colournum;
+ }
+ }
+ }
+}
+void ALColourRegion(unsigned char **colour,
+ int start_x,int start_y,int end_x,int end_y,
+ unsigned char colournum)
+
+/* set the characters within the range to the colournum */
+
+{
+ int i,j;
+ for(i=start_x;i<end_x+1;++i){
+ for(j=start_y;j<end_y+1;++j){
+ colour[i][j] = colournum;
+ }
+ }
+}
+
+void ALColourMask(unsigned char **mask,unsigned char **colour,
+ int start_x,int start_y,int end_x,int end_y,
+ unsigned char colournum)
+
+/* set the characters within the range to the colournum */
+
+{
+ int i,j;
+ for(i=start_x;i<end_x+1;++i){
+ for(j=start_y;j<end_y+1;++j){
+ if(mask[i][j] == 1){
+ colour[i][j] = colournum;
+ }
+ }
+ }
+}
+
+
+void ALSubChars(struct seqdat *bloc,
+ int start_x,int start_y,int end_x,int end_y,
+ char oldchar,char newchar)
+
+/* substitute oldchar for newchar at each position in bloc */
+
+{
+ int i,j;
+ for(i=start_x;i<end_x+1;++i){
+ for(j=start_y;j<end_y+1;++j){
+ if(bloc[j].seq[i] == oldchar) bloc[j].seq[i] = newchar;
+ }
+ }
+}
+
+
+void ALSurroundChars(struct seqdat *bloc,unsigned char **lines,
+ int start_x,int start_y,int end_x,int end_y,
+ int maxY,char *charlist)
+
+/*
+within the range of start_x etc. Draw lines such that every character that
+is present within charlist is surrounded by a box.
+*/
+{
+ int i,j,jpos;
+ char above,below,left,right;
+
+ for(i=start_x;i<end_x+1;++i){
+ for(j=start_y,jpos=(maxY-start_y+1);j<end_y+1;++j,--jpos){
+ if(strchr(charlist,bloc[j].seq[i]) != NULL){
+/* fprintf(std_err,"%d %d %c %c\n",i,j,bloc[j].seq[i]*/
+ if(j == end_y){
+ below = '!';
+ }else{
+ below = bloc[j+1].seq[i];
+ }
+ if(j == start_y){
+ above = '!';
+ }else{
+ above = bloc[j-1].seq[i];
+ }
+ if(i == start_x){
+ left = '!';
+ }else{
+ left = bloc[j].seq[i-1];
+ }
+ if(i == end_x){
+ right = '!';
+ }else{
+ right = bloc[j].seq[i+1];
+ }
+
+ if(strchr(charlist,above)== NULL){
+ ALLineRes(lines,i,jpos,LINE_TOP);
+ }
+ if(strchr(charlist,below)== NULL){
+ ALLineRes(lines,i,jpos,LINE_BOTTOM);
+ }
+ if(strchr(charlist,left)==NULL){
+ ALLineRes(lines,i,jpos,LINE_LEFT);
+ }
+ if(strchr(charlist,right)==NULL){
+ ALLineRes(lines,i,jpos,LINE_RIGHT);
+ }
+ }
+ }
+ }
+}
+void ALSurroundMask(unsigned char **mask,struct seqdat *bloc,unsigned char **lines,
+ int start_x,int start_y,int end_x,int end_y,
+ int maxY)
+/*
+within the range of start_x etc. Draw lines such that every
+masked position is isolated from every non-masked position
+*/
+{
+ int i,j,jpos;
+ char above,below,left,right;
+
+/* fprintf(stdout,"ALSurroundMask: %d %d %d %d\n",start_x,start_y,end_x,end_y);*/
+
+ for(i=start_x;i<end_x+1;++i){
+ for(j=start_y,jpos=(maxY-start_y+1);j<end_y+1;++j,--jpos){
+ if(mask[i][j] == 1){
+/* fprintf(std_err,"%d %d %c %c\n",i,j,bloc[j].seq[i]*/
+ if(j == end_y){
+ below = 0;
+ }else{
+ below = mask[i][j+1];
+ }
+ if(j == start_y){
+ above = 0;
+ }else{
+ above = mask[i][j-1];
+ }
+ if(i == start_x){
+ left = 0;
+ }else{
+ left = mask[i-1][j];
+ }
+ if(i == end_x){
+ right = 0;
+ }else{
+ right = mask[i+1][j];
+ }
+ /*
+ fprintf(stdout,"IN ALSurroundMask\n");
+ fprintf(stdout,"%d %d (%d %d %d %d)\n",i,j,above,below,left,right);
+ */
+
+ if(mask[i][j] != above){
+ ALLineRes(lines,i,jpos,LINE_TOP);
+ }
+ if(mask[i][j] != below){
+ ALLineRes(lines,i,jpos,LINE_BOTTOM);
+ }
+ if(mask[i][j] != left){
+ ALLineRes(lines,i,jpos,LINE_LEFT);
+ }
+ if(mask[i][j] != right){
+ ALLineRes(lines,i,jpos,LINE_RIGHT);
+ }
+ }
+ }
+ }
+}
+
+void ALFilRegion(signed char **fill,
+ int start_x,int start_y,int end_x,int end_y,
+ int *Yindx,float grey)
+{
+ int i,j;
+ for(i=start_x;i<end_x+1;++i){
+ for(j=start_y;j<end_y+1;++j){
+ ALFilRes(fill,i,Yindx[j],grey);
+ }
+ }
+}
+
+void ALShadeMask(unsigned char **mask,signed char **fill,
+ int start_x,int start_y,int end_x,int end_y,int *Yindx,
+ float grey)
+
+{
+ int i,j;
+ for(i=start_x;i<end_x+1;++i){
+ for(j=start_y;j<end_y+1;++j){
+ if(mask[i][j]==1){
+ ALFilRes(fill,i,Yindx[j],grey);
+ }
+ }
+ }
+}
+
+
+void ALColRegion(unsigned char **colour,
+ int start_x,int start_y,int end_x,int end_y,
+ int *Yindx,unsigned char colnum)
+{
+ int i,j;
+ for(i=start_x;i<end_x+1;++i){
+ for(j=start_y;j<end_y+1;++j){
+ ALColRes(colour,i,Yindx[j],colnum);
+ }
+ }
+}
+
+void ALColRRegion(unsigned char **colour,
+ int start_x,int start_y,int end_x,int end_y,
+ unsigned char colnum)
+/* version of ALColRegion that is indexed by characters rather than position */
+/* 18/1/1995 */
+
+{
+ int i,j;
+ for(i=start_x;i<end_x+1;++i){
+ for(j=start_y;j<end_y+1;++j){
+ colour[i][j] = colnum;
+ }
+ }
+}
+
+void ALBoxRegion(unsigned char **lines,
+ int start_x,int start_y,int end_x,int end_y,
+ int *Yindx)
+{
+ int i;
+ for(i=start_x;i<end_x+1;++i){
+ ALLineRes(lines,i,Yindx[end_y],LINE_BOTTOM);
+ ALLineRes(lines,i,Yindx[start_y],LINE_TOP);
+ }
+ for(i=start_y;i<end_y+1;++i){
+ ALLineRes(lines,start_x,Yindx[i],LINE_LEFT);
+ ALLineRes(lines,end_x,Yindx[i],LINE_RIGHT);
+ }
+}
+void ALDoLine(unsigned char **lines,
+ int start_x,int start_y,int end,
+ int type,int *Yindx)
+{
+ int i;
+ if(type == LINE_TOP || type == LINE_BOTTOM){
+ for(i=start_x;i<end+1;++i){
+ ALLineRes(lines,i,Yindx[start_y],type);
+ }
+ }else{
+ for(i=start_y;i<end+1;++i){
+ ALLineRes(lines,start_x,Yindx[i],type);
+
+
+ }
+ }
+}
+
+void ALDrawFills(signed char **fill,int use_colour,unsigned char **colour,
+ int start_x,int start_y,int end_x,int end_y,int XOffset,int YOffset,FILE *outf)
+
+/* for values of fill >= 0 draw box and fill in with grey value */
+/* 6/12/92: add colour option */
+{
+ int i,j;
+ extern int precis;
+
+ XOffset *= Xspace;
+ YOffset *= Yspace;
+
+ for(i=end_x;i>(start_x-1);--i){
+ for(j=end_y;j>(start_y-1);--j){
+ if((int) fill[i][j] >= 0 || use_colour){
+
+/*
+Revise to use ML function 27th Oct 1992
+ fprintf(outf," newpath\n");
+ fprintf(outf,"%.2f %.2f moveto \n",(float)(i-start_x)*Xspace-Xshift+XOffset,
+ (float)(j-start_y+1)*Yspace-Yshift+YOffset);
+ fprintf(outf,"%.2f %.2f lineto \n",(float)(i-start_x)*Xspace-Xshift+XOffset,
+ (float)(j-start_y+0)*Yspace-Yshift+YOffset);
+ fprintf(outf,"%.2f %.2f lineto \n",(float)(i-start_x+1)*Xspace-Xshift+XOffset,
+ (float)(j-start_y+0)*Yspace-Yshift+YOffset);
+ fprintf(outf,"%.2f %.2f lineto \n",(float)(i-start_x+1)*Xspace-Xshift+XOffset,
+ (float)(j-start_y+1)*Yspace-Yshift+YOffset);
+ fprintf(outf,"%.2f %.2f lineto \n",(float)(i-start_x)*Xspace-Xshift+XOffset,
+ (float)(j-start_y+1)*Yspace-Yshift+YOffset);
+ fprintf(outf,"closepath %.2f setgray fill 0 setgray \n",(float)fill[i][j]/(float)precis);
+*/
+ fprintf(outf," newpath\n");
+ fprintf(outf,"%.2f %.2f %.2f %.2f %.2f %.2f %.2f %.2f %.2f %.2f ML\n",
+ (float)(i-start_x)*Xspace-Xshift+XOffset,
+ (float)(j-start_y+1)*Yspace-Yshift+YOffset,
+ (float)(i-start_x)*Xspace-Xshift+XOffset,
+ (float)(j-start_y+0)*Yspace-Yshift+YOffset,
+ (float)(i-start_x+1)*Xspace-Xshift+XOffset,
+ (float)(j-start_y+0)*Yspace-Yshift+YOffset,
+ (float)(i-start_x+1)*Xspace-Xshift+XOffset,
+ (float)(j-start_y+1)*Yspace-Yshift+YOffset,
+ (float)(i-start_x)*Xspace-Xshift+XOffset,
+ (float)(j-start_y+1)*Yspace-Yshift+YOffset);
+ if(use_colour && fill[i][j] < 0){
+ /* 6/1/1995 - only set colour if grey is not set */
+ /* set to colour number */
+ fprintf(outf,"closepath C%-d fill \n",colour[i][j]);
+ }else{
+ fprintf(outf,"closepath %.2f setgray fill 0 setgray \n",(float)fill[i][j]/(float)precis);
+ }
+ }
+ }
+ }
+}
+
+void ALFilRes(signed char **fill,int i,int j,float grey)
+
+{
+ extern int precis;
+/* ALBoxRes(lines,i,j);
+ fill[i+Cidwidth][j+CseqVoffset] = grey * precis;
+*/
+ fill[i][j] = grey * precis;
+}
+
+void ALColRes(unsigned char **colour,int i,int j,int colnum)
+
+{
+ colour[i][j] = colnum;
+}
+
+
+void ALBoxRes(unsigned char **lines,int i,int j)
+
+{
+ ALLineRes(lines,i,j,LINE_TOP);
+ ALLineRes(lines,i,j,LINE_BOTTOM);
+ ALLineRes(lines,i,j,LINE_LEFT);
+ ALLineRes(lines,i,j,LINE_RIGHT);
+}
+
+
+void ALLineRes(
+unsigned char **lines,
+int i,int j,
+unsigned char value)
+{
+/*
+ i = i + Cidwidth;
+ j = j + CseqVoffset;
+*/
+ ALLineChar(lines,i,j,value);
+}
+
+void ALLineChar(unsigned char **lines,int i,int j,unsigned char value)
+
+{
+ lines[i][j] = lines[i][j] | value;
+}
+
+void ALDrawLines(unsigned char **lines,int use_colour,
+ unsigned char **left_line_colour,
+ unsigned char **right_line_colour,
+ unsigned char **top_line_colour,
+ unsigned char **bottom_line_colour,
+ int start_x,int start_y,int end_x,int end_y,
+ int XOffset,int YOffset,FILE *outf)
+
+/* draw the lines that are indicated by the lines array in the range of the
+array indicated by start_x etc
+*/
+{
+ int i,j;
+ XOffset *= Xspace;
+ YOffset *= Yspace;
+
+/*
+ if(use_colour){
+ fprintf(outf,"C100\n");
+ }
+*/
+
+ for(i=end_x;i>(start_x-1);--i){
+ for(j=end_y;j>(start_y-1);--j){
+ if(lines[i][j] != 0){
+ if((LINE_LEFT & lines[i][j]) == LINE_LEFT){
+ PSSetColour(left_line_colour[i][j],outf);
+ PSline((float)(i-start_x)*Xspace-Xshift+XOffset,
+ (float)(j-start_y+1)*Yspace-Yshift+YOffset,
+ (float)(i-start_x)*Xspace-Xshift+XOffset,
+ (float)(j-start_y+0)*Yspace-Yshift+YOffset,outf);
+ }
+ if((LINE_RIGHT & lines[i][j]) == LINE_RIGHT){
+ PSSetColour(right_line_colour[i][j],outf);
+ PSline((float)(i-start_x+1)*Xspace-Xshift+XOffset,
+ (float)(j-start_y+1)*Yspace-Yshift+YOffset,
+ (float)(i-start_x+1)*Xspace-Xshift+XOffset,
+ (float)(j-start_y+0)*Yspace-Yshift+YOffset,outf);
+ }
+ if((LINE_TOP & lines[i][j]) == LINE_TOP){
+ PSSetColour(top_line_colour[i][j],outf);
+ PSline((float)(i-start_x)*Xspace-Xshift+XOffset,
+ (float)(j-start_y+1)*Yspace-Yshift+YOffset,
+ (float)(i-start_x+1)*Xspace-Xshift+XOffset,
+ (float)(j-start_y+1)*Yspace-Yshift+YOffset,outf);
+ }
+ if((LINE_BOTTOM & lines[i][j]) == LINE_BOTTOM){
+ PSSetColour(bottom_line_colour[i][j],outf);
+ PSline((float)(i-start_x)*Xspace-Xshift+XOffset,
+ (float)(j-start_y+0)*Yspace-Yshift+YOffset,
+ (float)(i-start_x+1)*Xspace-Xshift+XOffset,
+ (float)(j-start_y+0)*Yspace-Yshift+YOffset,outf);
+ }
+ }
+ }
+ }
+ /*
+ if(use_colour){
+ fprintf(outf,"C99\n");
+ }
+ */
+}
+
+void PSline(float x1,float y1,float x2,float y2,FILE *outf)
+
+{
+ fprintf(outf,"%.2f %.2f %.2f %.2f L\n ",x1,y1,x2,y2);
+}
+
+
+
+void ALSimpleBox(int x1,int y1,int x2,int y2,float pfactor, /* multiply pointsize by this to get linewidth */
+ FILE *outf)
+
+/* draw a box to include character coordinates x1,y1 to x2,y2 */
+/* x1 < x2 y1< y2 */
+{
+ float lshift = Xspace/6;
+ float rshift = Xspace - lshift;
+
+ x1 *= Xspace;
+ y1 *= Yspace;
+ x2 *= Xspace;
+ y2 *= Yspace;
+
+ x1 -= lshift;
+ x2 += rshift;
+ y1 -= lshift;
+
+ PSDrawBox((float)x1,(float)y1,(float)x2,(float)y2,pfactor,outf);
+}
+
+void PSDrawBox(float x1,float y1,float x2,float y2,float pfactor,FILE *out)
+
+{
+ fprintf(out,"%f setlinewidth\n ",pointsize*pfactor);
+ fprintf(out,"%f %f moveto %f %f lineto %f %f lineto %f %f lineto %f %f lineto closepath stroke\n",
+ x1,y1,x2,y1,x2,y2,x1,y2,x1,y1);
+}
+
+void ALOutTicks(char *array,int start_aa,int xpos,int ypos,int len,FILE *out)
+
+{
+ int right;
+ int j;
+
+ xpos *= Xspace;
+ ypos *= Yspace;
+
+ right = start_aa + Cseqwidth;
+ if(right > len)right = len;
+ for(j=start_aa;j<right;j++){
+ if(array[j] != '\0'){
+ PSPutChar(xpos,ypos,array[j],out);
+ }
+ xpos += Xspace;
+ }
+}
+
+void ALOutNumbers(char **array,int start_aa,int xpos,int ypos,int len,FILE *out)
+
+{
+ int right;
+ int j;
+
+ xpos *= Xspace;
+ ypos *= Yspace;
+
+ right = start_aa + Cseqwidth;
+ if(right > len)right = len;
+ for(j=start_aa;j<right;j++){
+ if(array[j][0] != '\0'){
+ PSPutText(xpos,ypos,array[j],out);
+ }
+ xpos += Xspace;
+ }
+}
+
+char *ALCreateTicks(int start, int interval, int len)
+
+/* create ticks at the desired interval starting with residue start */
+{
+ int i;
+ char *temp;
+ temp = (char *) malloc(sizeof(char) * len);
+ /* first set all ticks to '\0' */
+ for(i=0;i<len;++i){
+ temp[i]='\0';
+ }
+ for(i=0;i<len;i+=interval){
+ temp[i] = '|';
+ }
+ temp[0]='\0';
+ temp[1]='|';
+ return temp;
+}
+
+
+
+char **ALCreateNumbers(int start,int interval,int nres,int nwidth)
+
+/* create character array of numbers from start to nres at interval*/
+{
+ int i;
+ char **temp;
+ temp = (char **) malloc(nres*sizeof(char *));
+ for(i=0;i<nres;++i){
+ temp[i] = (char *) malloc(sizeof(char) *nwidth);
+ temp[i][0]='\0';
+ }
+ for(i=start;i<nres;i+=interval){
+ if(i==0){
+ sprintf(temp[i+1],"%-d",i+1);
+ }else{
+ sprintf(temp[i],"%-d",i);
+ }
+ }
+
+ return temp;
+}
+
+char **ALCreateNum2(
+int nstart, /* starting number */
+int ninterval, /* interval for numbers */
+int nend, /* end of number range */
+int nres, /* total length of sequence */
+int xstart, /* starting location for writing numbers */
+int nwidth) /* width of the number string */
+
+/* create character array of numbers from start to nres at interval*/
+{
+ int i,xp;
+ char **temp;
+ temp = (char **) malloc(nres*sizeof(char *));
+ for(i=0;i<nres;++i){
+ temp[i] = (char *) malloc(sizeof(char) *nwidth);
+ temp[i][0]='\0';
+ }
+ xp = xstart;
+ for(i=nstart;i<nend;i+=ninterval){
+ if(i==0){
+ sprintf(temp[xp+1],"%-d",i+1);
+ }else{
+ sprintf(temp[xp],"%-d",i);
+ }
+ xp += ninterval;
+ }
+
+ return temp;
+}
+
+void ALReportInfo(int nseq,FILE *out)
+
+{
+ fprintf(out,"Number of Sequences: %d\n",nseq);
+ fprintf(out,"Total Vertical Space per page: %d\n",Cheight);
+}
+
+void ALReserveSpace(int location,int nspace)
+
+{
+ extern int TVspace,CseqVoffset;
+
+ switch(location){
+ case TOP:
+ TVspace += nspace;
+ CtopSpace +=nspace;
+ break;
+ case BOTTOM:
+ TVspace += nspace;
+ CseqVoffset += nspace;
+ CbottomSpace += nspace;
+ break;
+ }
+}
+
+void PSSetupPage(int orientation,int npage,FILE *outf)
+
+{
+ fprintf(outf,"%%%%Page: ? %d\n",npage);
+ PSSetOrientation(orientation,outf);
+ PSSetFont(0,outf); /* set default font for document */
+}
+
+void ALOutSeq(struct seqdat *bloc,unsigned char **fonts,char ***texts,unsigned char **inverse,
+ int use_colour,
+ unsigned char **colour,
+ unsigned char **text_colour,
+ unsigned char background_colour,
+ int start_seq,int end_seq,int start_aa,int ypos,FILE *outf)
+
+{
+ extern int Xspace,Yspace;
+ extern int Cidwidth;
+
+ int i,j;
+ int xpos;
+ unsigned char current_col;
+
+ int right;
+
+ ypos *= Yspace;
+
+ current_col = background_colour;
+
+ right = start_aa + Cseqwidth;
+ if(right > bloc[1].slen-1)right = bloc[1].slen;
+
+ for(i=end_seq;i>(start_seq-1);--i){
+ xpos = Cidwidth * Xspace;
+ for(j=start_aa;j<right;++j){
+ if(texts[j][i] != NULL || bloc[i].seq[j] != ' '){
+ if(fonts[j][i]!=0)PSSetFont(fonts[j][i],outf);
+ if(inverse[j][i] != 0)PSSetGrey(1,outf);
+ if(use_colour && colour[j][i] != current_col){
+ PSSetColour(colour[j][i],outf);
+ current_col = colour[j][i];
+ }
+ if(bloc[i].seq[j] != ' '){
+ PSPutChar(xpos,ypos,bloc[i].seq[j],outf);
+ }
+ if(texts[j][i] != NULL){
+ if(text_colour[j][i] != current_col){
+ PSSetColour(text_colour[j][i],outf);
+ current_col = text_colour[j][i];
+ }
+ if(texts[j][i][0] == '@'){
+ PSPutSpecialText(xpos,ypos,Xspace,Yspace,texts[j][i],
+ text_colour[j][i],background_colour,0.9,outf);
+ }else{
+ PSPutText(xpos,ypos,texts[j][i],outf);
+ }
+ }
+ if(inverse[j][i] != 0)PSSetGrey(0,outf);
+ if(fonts[j][i]!=0)PSSetFont(0,outf);
+ }
+ xpos += Xspace;
+ }
+ ypos += Yspace;
+ }
+/*
+ if(use_colour){
+ PSSetColour(100,outf);
+ }
+*/
+}
+
+
+void ALOutId(struct seqdat *bloc,int use_colour,
+ unsigned char *colour,
+ unsigned char *fonts,
+ int start_seq,int end_seq,int ypos,int numbers,
+ FILE *outf)
+
+{
+ extern int MAXilen;
+ extern int Xspace,Yspace;
+ int i;
+ int xpos;
+ char *temp;
+
+ xpos = 0;
+ ypos *= Yspace;
+ temp = (char *) malloc(sizeof(char) * (MAXilen + 5));
+
+
+ for(i=end_seq;i>(start_seq-1);--i){
+ if(use_colour)PSSetColour(colour[i],outf);
+ if(fonts[i] != 0)PSSetFont(fonts[i],outf);
+ if(numbers){
+ sprintf(temp,"%4d:%s",i,bloc[i].id);
+ }else{
+ sprintf(temp,"%s",bloc[i].id);
+ }
+ PSPutText(xpos,ypos,temp,outf);
+ ypos += Yspace;
+ if(fonts[i] != 0)PSSetFont(0,outf);
+ }
+ free((char *) temp);
+
+}
+
+void PSPutText(int x,int y,char *text,FILE *outf)
+
+{
+ fprintf(outf," %d %d moveto (%s) show \n",x,y,text);
+}
+
+void PSPutChar(int x,int y,char c,FILE *outf)
+
+{
+ /* fprintf(outf," %d %d moveto (%c) show \n",x,y,c);*/
+ fprintf(outf,"(%c) %d %d P\n",c,x,y);
+}
+
+void PSShowPage(FILE *outf)
+
+{
+ fprintf(outf,"showpage\n");
+}
+
+void ALSetFont(char *font,int point,FILE *outf)
+
+{
+ fprintf(outf,"/%s findfont %d scalefont setfont\n",font,point);
+}
+
+void PSSetFont(unsigned char number,FILE *outf)
+
+{
+ fprintf(outf,"F%-d\n ",number);
+}
+
+void PSSetColour(unsigned char number,FILE *outf)
+
+{
+ fprintf(outf,"C%-d\n ",number);
+}
+
+void ALDefineFont(int number,char *font,float point,FILE *outf)
+
+/* define a PostScript function called /Fnumber which selects the
+font at point pointsize */
+{
+ fprintf(outf,"/F%-d {/%s findfont %.2f scalefont setfont } def\n",
+ number,font,point);
+}
+
+void ALDefineColour(int number,char *type,float red,float green,float blue,FILE *outf)
+
+/* define a PostScript function called /Cnumber which selects the
+colour defined by red,green, blue intensities
+
+new addition - if type is equal to "HSB" then define an hsb colour using red, green blue as
+the hue saturation and brightness.
+*/
+{
+ if(strcmp(type,"HSB")==0){
+ /* set an HSB colour */
+ fprintf(outf,"/C%-d {%f %f %f sethsbcolor } def\n", number,red,green,blue);
+ }else{
+ /* set an RGB colour */
+ fprintf(outf,"/C%-d {%f %f %f setrgbcolor } def\n", number,red,green,blue);
+ }
+}
+
+void ALCheckSinglePage(int nseq,int len,int silent)
+
+{
+ extern FILE *std_err;
+ Csheet = 1;
+
+
+ if(Cheight-CtopSpace < nseq){
+ if(!silent)fprintf(std_err,"Not enough height to print all sequences on a single page at this pointsize\n");
+ if(!silent)fprintf(std_err,"Pointsize: %.2f\n",pointsize);
+ if(!silent)fprintf(std_err,"Need a pointsize of < : %.2f\n",(float) height/(nseq+ CtopSpace));
+ Csheet = nseq/(Cheight-CtopSpace) + 1;
+ if(!silent)fprintf(std_err,"Will split alignment into %d segments\n",Csheet);
+ }
+
+ npage = len/(Cwidth - Cidwidth) + 1;
+}
+
+
+void ALSetPageLimits(void)
+/* Use the current width height and pointsize values to calculate:
+ Cwidth
+ Cheight
+ Xspace
+ Yspace
+*/
+{
+
+ Xspace = pointsize + pointsize * XspaceFactor;
+ Yspace = pointsize + pointsize * YspaceFactor;
+
+ Cwidth = width/Xspace;
+ Cheight = height/Yspace;
+
+ Cseqwidth = Cwidth - Cidwidth;
+
+ Xshift = Xspace * XshiftFactor;
+ Yshift = Yspace * YshiftFactor;
+}
+
+void PSSetOrientation(int orientation,FILE *outf)
+
+{
+ switch(orientation){
+ case LANDSCAPE:
+ PSLandscape(outf);
+ break;
+ case PORTRAIT:
+ PSPortrait(outf);
+ break;
+ default:
+ PSPortrait(outf);
+ }
+}
+
+void PSPreamble(FILE *out,int singlepage,int *b_box,int screensize)
+{
+ char *Alscript_Version = ALSCRIPT_VERSION;
+ fprintf(out,"%%!PS-Adobe-2.0\n");
+ fprintf(out,"%%%%Creator: %s\n",Alscript_Version);
+ fprintf(out,"%%%%Title: Alscript Output\n");
+ fprintf(out,"%% Barto,n G. J. (1993)\n");
+ fprintf(out,"%% ALSCRIPT - A Tool to format multiple sequence alignments\n");
+ fprintf(out,"%% Protein Engineering, 6, 37-40\n");
+ fprintf(out,"%%\n");
+ if(singlepage == 1){
+ fprintf(out,"%%%%BoundingBox: %d %d %d %d\n",
+ b_box[0],b_box[1],b_box[2],b_box[3]);
+ }
+ fprintf(out,"/P {moveto show} def\n");
+ fprintf(out,"/L {moveto lineto stroke} def\n");
+ fprintf(out,
+ "/ML {moveto lineto lineto lineto lineto} def\n");
+ fprintf(out,"2 setlinecap\n"); /* projecting line caps */
+ ALDefineColour(99,"RGB",1.0,1.0,1.0,out); /* white */
+ ALDefineColour(100,"RGB",0.0,0.0,0.0,out); /* black */
+ /* modify the screening - suggested by Michael D. Baron */
+ fprintf(out,"%d currentscreen 3 -1 roll pop setscreen\n",screensize);
+
+}
+
+void PSLandscape(FILE *out)
+
+{
+ width = MAXside;
+ height = MINside;
+
+ fprintf(out,"%d %d translate\n",xoff+height,yoff);
+ fprintf(out,"90 rotate\n");
+
+}
+
+void PSPortrait(FILE *out)
+
+{
+ width = MINside;
+ height = MAXside;
+ fprintf(out,"%d %d translate\n",xoff,yoff);
+}
+
+
+void echo(char *s)
+
+{
+ extern FILE *std_err;
+ fprintf(std_err,"%s",s);
+}
+
+void ALGetFourInt(int *sx,int *sy,int *ex,int *ey)
+
+{
+char *token;
+
+ token = strtok(NULL,TOKENS);
+ *sx = atoi(token);
+ token = strtok(NULL,TOKENS);
+ *sy = atoi(token);
+ token = strtok(NULL,TOKENS);
+ *ex = atoi(token);
+ token = strtok(NULL,TOKENS);
+ *ey = atoi(token);
+}
+void ALGetThreeInt(int *sy,int *ex,int *ey)
+
+{
+char *token;
+
+ token = strtok(NULL,TOKENS);
+ *sy = atoi(token);
+ token = strtok(NULL,TOKENS);
+ *ex = atoi(token);
+ token = strtok(NULL,TOKENS);
+ *ey = atoi(token);
+}
+void ALGetTwoInt(int *sy,int *ex)
+
+{
+char *token;
+
+ token = strtok(NULL,TOKENS);
+ *sy = atoi(token);
+ token = strtok(NULL,TOKENS);
+ *ex = atoi(token);
+}
+
+char ALChekSpace(const char *token)
+{
+ if(strcmp(token,"SPACE") == 0){
+ return ' ';
+ }else{
+ return token[0];
+ }
+}
+
+void PSSetGrey(float grey,FILE *outf)
+{
+ fprintf(outf," %.2f setgray\n",grey);
+}
+
+int save_pir(struct seqdat *bloc,int nseq,FILE *pirf)
+
+{
+ int i,j;
+ int count;
+
+
+ for(i=1;i<(nseq+1);++i){
+ fprintf(pirf,">P1;%s\n",bloc[i].id);
+ fprintf(pirf,"%s\n",bloc[i].title);
+ count=0;
+ for(j=1;j<bloc[i].slen;++j){
+ ++count;
+ /* convert spaces to dashes */
+ if(bloc[i].seq[j] == ' ')bloc[i].seq[j] = '.';
+ fputc(bloc[i].seq[j],pirf);
+ if(count==50){
+ count=0;
+ fprintf(pirf,"\n");
+ }
+ }
+ fprintf(pirf,"*\n");
+ }
+ return 1;
+}
+
+int save_msf(struct seqdat *bloc,int nseq,FILE *msff)
+
+{
+ int i,j,s,e;
+ int count;
+
+ fprintf(msff,"\njunk.msf MSF: %d Type: P January 01, 1776 12:00 Check: 7110 ..\n\n",bloc[1].slen-1);
+
+ for(i=1;i<(nseq+1);++i){
+ fprintf(msff,"Name: %20s Len: %7d Check: 0 Weight: 1.00\n",
+ bloc[i].id,bloc[1].slen-1);
+ }
+ fprintf(msff,"\n//\n\n\n");
+
+
+ s = 1;
+
+ while(s < bloc[1].slen){
+ e = s + 50;
+ if(e > bloc[1].slen) e = bloc[1].slen;
+
+ for(i=1;i<(nseq+1);++i){
+ fprintf(msff,"%10s ",bloc[i].id);
+ for(j=s;j<e;++j){
+ if(bloc[i].seq[j] == ' ')bloc[i].seq[j]='.';
+ fputc(bloc[i].seq[j],msff);
+ }
+ fprintf(msff,"\n");
+ }
+ s += 50;
+ fprintf(msff,"\n\n");
+ }
+ return 1;
+}
+
+
+void ALGetAllRange(int *sx, int *sy, int *ex, int *ey,int dex,int dey)
+/* checks the next token if it is ALL then return box around whole alignment
+ else return box according to the integers found
+*/
+{
+ char *token;
+
+ token = strtok(NULL,TOKENS);
+
+ if(strcmp(token,"ALL")==0){
+ *sx = 1;
+ *sy = 1;
+ *ex = dex;
+ *ey = dey;
+ }else{
+ *sx = atoi(token);
+ ALGetThreeInt(sy,ex,ey);
+ }
+ if(*ex > dex) *ex = dex;
+ if(*ey > dey) *ey = dey;
+}
+
+void ALid_mask(
+unsigned char **mask,
+struct seqdat *bloc,
+int sx,int sy,int ex,int ey,
+int id_cut,
+char *legal,
+char *illegal)
+
+{
+ int i,j,k,iseen;
+ char fchar;
+ char *seen; /* array of characters that are seen at this position */
+ int *freq; /* array of frequencies of the characters */
+ int nc; /* number of different character types at this position */
+ int ns;
+ int mc; /* maximum character present */
+ int imc; /* location of max character */
+
+ ns = ey - sy + 1;
+ nc = 0;
+
+ seen = (char *) GJmalloc(sizeof(char) *ns);
+ freq = (int *) GJmalloc(sizeof(int) *ns);
+
+ for(i=0;i<ns;++i){
+ freq[i] = 0;
+ seen[i] = '\0';
+ }
+
+/* fprintf(stdout,"In ALidmask\n");*/
+
+ for(i=sx;i<(ex+1);++i){
+ /* for each position get the list of characters seen and their frequencies */
+ for(j=sy;j<(ey+1);++j){
+ iseen = Ifound(bloc,i,j,seen,nc);
+ if(iseen >= 0){
+ ++freq[iseen];
+ }else{
+ seen[nc] = bloc[j].seq[i];
+ ++freq[nc];
+ ++nc;
+ }
+ }
+ /*
+ for(k=0;k<nc;++k)fprintf(stdout,"%c ",seen[k]);
+ for(k=0;k<nc;++k)fprintf(stdout,"%d ",freq[k]);
+ fprintf(stdout,"\n");
+ */
+ /* find the most frequent character that is legal and not illegal*/
+ mc = 0;
+ for(k=0;k<nc;++k){
+ if(legal != NULL && illegal != NULL){
+ if( strchr(legal,seen[k]) != NULL
+ && strchr(illegal,seen[k]) == NULL
+ && freq[k] > mc){
+ mc = freq[k];
+ imc = k;
+ }
+ }else if(legal != NULL){
+ if( strchr(legal,seen[k]) != NULL
+ && freq[k] > mc){
+ mc = freq[k];
+ imc = k;
+ }
+ }else if(illegal != NULL){
+ if( strchr(illegal,seen[k]) == NULL
+ && freq[k] > mc){
+ mc = freq[k];
+ imc = k;
+ }
+ }else{
+ if(freq[k] > mc){
+ mc = freq[k];
+ imc = k;
+ }
+ }
+ }
+ if(mc >= id_cut){
+ /* only select the character if it is >= id_cut */
+ fchar = seen[imc];
+/* fprintf(stdout,"At %d %c\n",i,fchar);*/
+ for(j=sy;j<(ey+1);++j){
+ if(bloc[j].seq[i] == fchar){
+ mask[i][j] = 1;
+/* fprintf(stdout,"%d %d \n",i,j);*/
+ }
+ }
+ }
+ for(j=0;j<ns;++j){
+ freq[j] = 0;
+ seen[j] = '\0';
+ }
+ nc = 0;
+ }
+ GJfree(seen);
+ GJfree(freq);
+}
+
+void ALfre_mask(
+unsigned char **mask,
+struct seqdat *bloc,
+int sx,int sy,int ex,int ey,
+char *legal,
+char *illegal)
+
+{
+ int i,j,k,iseen;
+ char fchar;
+ char *seen; /* array of characters that are seen at this position */
+ int *freq; /* array of frequencies of the characters */
+ int nc; /* number of different character types at this position */
+ int ns;
+ int mc; /* maximum character present */
+ int imc; /* location of max character */
+
+ ns = ey - sy + 1;
+ nc = 0;
+
+ seen = (char *) GJmalloc(sizeof(char) *ns);
+ freq = (int *) GJmalloc(sizeof(int) *ns);
+
+ for(i=0;i<ns;++i){
+ freq[i] = 0;
+ seen[i] = '\0';
+ }
+
+/* fprintf(stdout,"In ALidmask\n");*/
+
+ for(i=sx;i<(ex+1);++i){
+ /* for each position get the list of characters seen and their frequencies */
+ for(j=sy;j<(ey+1);++j){
+ iseen = Ifound(bloc,i,j,seen,nc);
+ if(iseen >= 0){
+ ++freq[iseen];
+ }else{
+ seen[nc] = bloc[j].seq[i];
+ ++freq[nc];
+ ++nc;
+ }
+ }
+/* for(k=0;k<nc;++k)fprintf(stdout,"%c ",seen[k]);
+ for(k=0;k<nc;++k)fprintf(stdout,"%d ",freq[k]);
+ fprintf(stdout,"\n");
+*/
+ /* find the most frequent character that is legal and not illegal*/
+ mc = 0;
+ for(k=0;k<nc;++k){
+ if(legal != NULL && illegal != NULL){
+ if( strchr(legal,seen[k]) != NULL
+ && strchr(illegal,seen[k]) == NULL
+ && freq[k] > mc){
+ mc = freq[k];
+ imc = k;
+ }
+ }else if(legal != NULL){
+ if( strchr(legal,seen[k]) != NULL
+ && freq[k] > mc){
+ mc = freq[k];
+ imc = k;
+ }
+ }else if(illegal != NULL){
+ if( strchr(illegal,seen[k]) == NULL
+ && freq[k] > mc){
+ mc = freq[k];
+ imc = k;
+ }
+ }else{
+ if(freq[k] > mc){
+ mc = freq[k];
+ imc = k;
+ }
+ }
+ }
+ fchar = seen[imc];
+/* fprintf(stdout,"At %d %c\n",i,fchar);*/
+ for(j=sy;j<(ey+1);++j){
+ if(bloc[j].seq[i] == fchar){
+ mask[i][j] = 1;
+/* fprintf(stdout,"%d %d \n",i,j);*/
+ }
+ }
+
+ for(j=0;j<ns;++j){
+ freq[j] = 0;
+ seen[j] = '\0';
+ }
+ nc = 0;
+ }
+ GJfree(seen);
+ GJfree(freq);
+}
+int Ifound(struct seqdat *bloc,
+int i,int j,
+char *seen,
+int nc)
+{
+ int k;
+
+ if(nc > 0){
+ for(k=0;k<nc;++k){
+ if(bloc[j].seq[i] == seen[k]){
+ return k;
+ }
+ }
+ }
+ return -1;
+}
+void ALagree_mask(
+unsigned char **mask,
+struct seqdat *bloc,
+int sx,int sy,int ex,int ey,
+int ns)
+
+{
+ int i,j;
+
+ for(i=sx;i<(ex+1);++i){
+ /* for each position mask the characters that are identical to sequence ns */
+ for(j=sy;j<(ey+1);++j){
+ if(bloc[j].seq[i] == bloc[ns].seq[i]){
+ mask[i][j] = 1;
+ }
+ }
+ }
+}
+
+void ALnot_mask(
+unsigned char **mask,
+int sx,int sy,int ex,int ey)
+
+{
+ int i,j;
+
+ for(i=sx;i<(ex+1);++i){
+ /* NOT on each mask element ie 1 goes to 0, 0 to 1 */
+ for(j=sy;j<(ey+1);++j){
+ if(mask[i][j]==1){
+ mask[i][j]=0;
+ }else if(mask[i][j]==0){
+ mask[i][j]=1;
+ }
+ }
+ }
+}
+
+
+void ALsub_mask(unsigned char **mask,struct seqdat *bloc,
+ int sx,int sy,int ex,int ey,char cchar)
+
+{
+ int i,j;
+
+ for(i=sx;i<(ex+1);++i){
+ /* substitute all characters in the mask for cchar */
+ for(j=sy;j<(ey+1);++j){
+ if(mask[i][j]==1){
+ bloc[j].seq[i] = cchar;
+ }
+ }
+ }
+}
+
+void ALMask(unsigned char **mask,
+int sx,int sy,int ex,int ey)
+
+{
+ int i,j;
+
+ for(i=sx;i<(ex+1);++i){
+ /* substitute all characters in the mask for cchar */
+ for(j=sy;j<(ey+1);++j){
+ mask[i][j] = 1;
+ }
+ }
+}
+
+void ALConsMask(unsigned char **mask,
+int sx,int sy,int ex,int ey,int *consval,int conscut)
+
+{
+ int i,j;
+
+ for(i=sx;i<(ex+1);++i){
+ /* set mask at all positions that are >= conscut in the consval array */
+ for(j=sy;j<(ey+1);++j){
+ if(consval[i] >= conscut){
+ mask[i][j] = 1;
+ }
+ }
+ }
+}
+
+
+void ALDrawHorizLine(
+ float Xpos, /* bottom left hand corner of character posn */
+ float Ypos, /* */
+ float Xspace, /* horizontal width of character position */
+ float Yspace, /* vertical height of character position */
+ float width_fac,FILE *outf) /* proportion of vertical height that the line will fill */
+
+
+{
+ float xright,ytop;
+ float ymid;
+ float hline_w;
+
+ xright = Xpos + Xspace; /* right hand edge of character (lhe of next character) */
+ ytop = Ypos + Yspace; /* top edge of character */
+ ymid = (ytop + Ypos) * 0.5; /* vertical mid point */
+
+ /* width_fac defines the width of the line in terms of the height of the characters */
+
+ hline_w = 0.5 * (width_fac * (ytop - Ypos));
+
+ fprintf(outf,"%.2f %.2f %.2f %.2f %.2f %.2f %.2f %.2f %.2f %.2f ML\n",
+ Xpos,ymid-hline_w,
+ xright,ymid-hline_w,
+ xright,ymid+hline_w,
+ Xpos,ymid+hline_w,
+ Xpos,ymid-hline_w,outf);
+}
+
+void ALDrawRightArrow(float Xpos,float Ypos, float Xspace, float Yspace, float width_fac,FILE *outf)
+
+{
+ float xright,ytop;
+ float ymid;
+ float hline_w;
+
+ xright = Xpos + Xspace; /* right hand edge of character (lhe of next character) */
+ ytop = Ypos + Yspace; /* top edge of character */
+ ymid = (ytop + Ypos) * 0.5; /* vertical mid point */
+
+ /* width_fac defines the width of the Arrow in terms of the height of the characters */
+
+ hline_w = 0.5 * (width_fac * (ytop - Ypos));
+
+ PSmoveto(Xpos,Ypos,outf);
+ PSlineto(xright,ymid,outf);
+ PSlineto(Xpos,ytop,outf);
+ PSlineto(Xpos,Ypos,outf);
+
+}
+
+void ALDrawLeftArrow(float Xpos,float Ypos, float Xspace, float Yspace, float width_fac,FILE *outf)
+
+{
+ float xright,ytop;
+ float ymid;
+ float hline_w;
+
+ xright = Xpos + Xspace; /* right hand edge of character (lhe of next character) */
+ ytop = Ypos + Yspace; /* top edge of character */
+ ymid = (ytop + Ypos) * 0.5; /* vertical mid point */
+
+ /* width_fac defines the width of the Arrow in terms of the height of the characters */
+
+ hline_w = 0.5 * (width_fac * (ytop - Ypos));
+
+ PSmoveto(xright,Ypos,outf);
+ PSlineto(xright,ytop,outf);
+ PSlineto(Xpos,ymid,outf);
+ PSlineto(xright,Ypos,outf);
+}
+
+
+void ALDrawUpArrow(float Xpos,float Ypos, float Xspace, float Yspace, float width_fac,FILE *outf)
+
+{
+ float xright,ytop;
+ float ymid;
+ float hline_w;
+ float xmid;
+
+ xright = Xpos + Xspace; /* right hand edge of character (lhe of next character) */
+ ytop = Ypos + Yspace; /* top edge of character */
+ ymid = (ytop + Ypos) * 0.5; /* vertical mid point */
+ xmid = (xright + Xpos) * 0.5; /* horizontal mid point */
+
+ hline_w = 0.5 * (width_fac * (ytop - Ypos));
+
+ PSmoveto(Xpos,Ypos,outf);
+ PSlineto(xright,Ypos,outf);
+ PSlineto(xmid,ytop,outf);
+ PSlineto(Xpos,Ypos,outf);
+}
+
+void ALDrawDownArrow(float Xpos,float Ypos, float Xspace, float Yspace, float width_fac,FILE *outf)
+
+{
+ float xright,ytop;
+ float ymid;
+ float hline_w;
+ float xmid;
+
+ xright = Xpos + Xspace; /* right hand edge of character (lhe of next character) */
+ ytop = Ypos + Yspace; /* top edge of character */
+ ymid = (ytop + Ypos) * 0.5; /* vertical mid point */
+ xmid = (xright + Xpos) * 0.5; /* horizontal mid point */
+
+ hline_w = 0.5 * (width_fac * (ytop - Ypos));
+
+ PSmoveto(Xpos,ytop,outf);
+ PSlineto(xright,ytop,outf);
+ PSlineto(xmid,Ypos,outf);
+ PSlineto(Xpos,ytop,outf);
+}
+
+/* Draw a small up arrow. mok 980917 */
+void ALDrawSmallUpArrow(float Xpos,float Ypos, float Xspace, float Yspace, float width_fac,FILE *outf)
+
+{
+ float xright,ytop;
+ float ymid;
+ float xmid;
+ float x,y;
+
+ xright = Xpos + Xspace; /* right hand edge of character (lhe of next character) */
+ ytop = Ypos + Yspace; /* top edge of character */
+ ymid = (ytop + Ypos) * 0.5; /* vertical mid point */
+ xmid = (xright + Xpos) * 0.5; /* horizontal mid point */
+
+ PSmoveto(xmid, ytop, outf);
+ x = Xpos + (xright-Xpos)/5.0; y = Ypos + 2.0*(ytop-Ypos)/3.0;
+ PSlineto(x,y,outf);
+ x = Xpos + 2.0*(xright-Xpos)/5.0;
+ PSlineto(x, y, outf);
+ PSlineto (x, Ypos, outf);
+ x = Xpos + 3.0*(xright-Xpos)/5.0;
+ PSlineto (x, Ypos, outf);
+ PSlineto(x, y, outf);
+ x = Xpos + 4.0*(xright-Xpos)/5.0;
+ PSlineto(x, y, outf);
+ PSlineto(xmid, ytop, outf);
+}
+
+/* Draw a small down arrow. mok 980917 */
+void ALDrawSmallDownArrow(float Xpos,float Ypos, float Xspace, float Yspace, float width_fac,FILE *outf)
+
+{
+ float xright,ytop;
+ float ymid;
+ float xmid;
+ float x,y;
+
+ xright = Xpos + Xspace; /* right hand edge of character (lhe of next character) */
+ ytop = Ypos + Yspace; /* top edge of character */
+ ymid = (ytop + Ypos) * 0.5; /* vertical mid point */
+ xmid = (xright + Xpos) * 0.5; /* horizontal mid point */
+
+ PSmoveto(xmid, Ypos, outf);
+ x = Xpos + 4.0*(xright-Xpos)/5.0; y = Ypos + (ytop-Ypos)/3.0;
+ PSlineto(x,y,outf);
+ x = Xpos + 3.0*(xright-Xpos)/5.0;
+ PSlineto(x, y, outf);
+ PSlineto (x, ytop, outf);
+ x = Xpos + 2.0*(xright-Xpos)/5.0;
+ PSlineto (x, ytop, outf);
+ PSlineto(x, y, outf);
+ x = Xpos + (xright-Xpos)/5.0;
+ PSlineto(x, y, outf);
+ PSlineto(xmid, Ypos, outf);
+}
+
+void ALDrawCircle(float Xpos,float Ypos, float Xspace, float Yspace, float width_fac,FILE *outf)
+
+{
+ float xright,ytop;
+ float ymid;
+ float hline_w;
+ float xmid;
+
+ xright = Xpos + Xspace; /* right hand edge of character (lhe of next character) */
+ ytop = Ypos + Yspace; /* top edge of character */
+ ymid = (ytop + Ypos) * 0.5; /* vertical mid point */
+ xmid = (xright + Xpos) * 0.5; /* horizontal mid point */
+
+ hline_w = 0.5 * (width_fac * (ytop - Ypos));
+
+ PSnewpath(outf);
+
+ fprintf(outf,"%.2f %.2f %.2f %d %d arc\n",xmid,ymid,(ytop - Ypos)*0.5,0,360);
+
+}
+
+/* Draw a diamond. mok 980917 */
+void ALDrawDiamond(float Xpos,float Ypos, float Xspace, float Yspace, float width_fac,FILE *outf)
+
+{
+ float xright,ytop;
+ float ymid;
+ float hline_w;
+ float xmid;
+
+ xright = Xpos + Xspace; /* right hand edge of character (lhe of next character) */
+ ytop = Ypos + Yspace; /* top edge of character */
+ ymid = (ytop + Ypos) * 0.5; /* vertical mid point */
+ xmid = (xright + Xpos) * 0.5; /* horizontal mid point */
+
+ PSmoveto(Xpos, ymid, outf);
+ PSlineto(xmid, ytop, outf);
+ PSlineto(xright, ymid, outf);
+ PSlineto(xmid, Ypos, outf);
+ PSlineto(Xpos, ymid, outf);
+}
+
+/* Draw a bar. mok 980917 */
+void ALDrawBar(float Xpos,float Ypos, float Xspace, float Yspace, float width_fac,FILE *outf)
+
+{
+ float xright;
+ float y1, y2;
+
+ xright = Xpos + Xspace; /* right hand edge of character (lhe of next character) */
+
+ y1 = Ypos + 2.0*(Ypos+Yspace)/5.0;
+ y2 = Ypos + 3.0*(Ypos+Yspace)/5.0;
+
+ PSmoveto(Xpos, y1, outf);
+ PSlineto(xright, y1, outf);
+ PSlineto(xright, y2, outf);
+ PSlineto(Xpos, y2, outf);
+ PSlineto(Xpos, y1, outf);
+}
+
+void ALDrawPseudoEllipse(float Xpos,float Ypos, float Xspace, float Yspace, float width_fac,
+ FILE *outf)
+
+{
+ /* draws a pseudo ellipse in the box bounded by Xpos,Ypos, Xpos+Xspace, Ypos+Yspace */
+ float xright,ytop;
+ float ymid;
+ float hline_w;
+ float xmid;
+ float xefact = 0.2; /* this shifts the guide points by 0.2 towards the axis */
+ /* should not really be hard wired */
+ float yefact = 0.0;
+
+ float xbit,ybit;
+
+ xright = Xpos + Xspace; /* right hand edge of character (lhe of next character) */
+ ytop = Ypos + Yspace; /* top edge of character */
+ ymid = (ytop + Ypos) * 0.5; /* vertical mid point */
+ xmid = (xright + Xpos) * 0.5; /* horizontal mid point */
+ xbit = Xspace * xefact;
+ ybit = Yspace * yefact;
+
+ hline_w = 0.5 * (width_fac * (ytop - Ypos));
+
+ PSnewpath(outf);
+
+ PSmoveto(xmid,Ypos,outf);
+
+ fprintf(outf,"%.2f %.2f %.2f %.2f %.2f %.2f curveto\n",
+ Xpos+xbit,Ypos+ybit,Xpos+xbit,ytop-ybit,xmid,ytop);
+ fprintf(outf,"%.2f %.2f %.2f %.2f %.2f %.2f curveto\n",
+ xright-xbit,ytop-ybit,xright-xbit,Ypos+ybit,xmid,Ypos);
+}
+
+void ALDrawLeftSemiEnd(float Xpos,float Ypos, float Xspace, float Yspace, float width_fac,FILE *outf)
+
+{
+ float xright,ytop;
+ float ymid;
+ float hline_w;
+ float xmid;
+
+ xright = Xpos + Xspace; /* right hand edge of character (lhe of next character) */
+ ytop = Ypos + Yspace; /* top edge of character */
+ ymid = (ytop + Ypos) * 0.5; /* vertical mid point */
+ xmid = (xright + Xpos) * 0.5; /* horizontal mid point */
+
+ hline_w = 0.5 * (width_fac * (ytop - Ypos));
+
+ PSnewpath(outf);
+
+ fprintf(outf,"%.2f %.2f %.2f %d %d arc\n",xmid,ymid,(ytop - Ypos) *0.5,270,90);
+
+ PSlineto(xright,ytop,outf);
+ PSlineto(xright,Ypos,outf);
+ PSlineto(xmid,Ypos,outf);
+
+}
+void ALDrawRightSemiEnd(float Xpos,float Ypos, float Xspace, float Yspace, float width_fac,FILE *outf)
+
+{
+ float xright,ytop;
+ float ymid;
+ float hline_w;
+ float xmid;
+
+ xright = Xpos + Xspace; /* right hand edge of character (lhe of next character) */
+ ytop = Ypos + Yspace; /* top edge of character */
+ ymid = (ytop + Ypos) * 0.5; /* vertical mid point */
+ xmid = (xright + Xpos) * 0.5; /* horizontal mid point */
+
+ hline_w = 0.5 * (width_fac * (ytop - Ypos));
+
+ PSnewpath(outf);
+ fprintf(outf,"%f %f %f %d %d arc\n",xmid,ymid,(ytop - Ypos) *0.5,90,270);
+
+ PSlineto(Xpos,Ypos,outf);
+ PSlineto(Xpos,ytop,outf);
+ PSlineto(xmid,ytop,outf);
+}
+void ALDrawRightHalfHorizLine(
+ float Xpos, /* bottom left hand corner of character posn */
+ float Ypos, /* */
+ float Xspace, /* horizontal width of character position */
+ float Yspace, /* vertical height of character position */
+ float width_fac, FILE *outf) /* proportion of vertical height that the line will fill */
+
+/* draw line from midpoint to right of position */
+
+
+{
+ float xright,ytop;
+ float ymid;
+ float hline_w;
+ float xmid;
+
+ xright = Xpos + Xspace; /* right hand edge of character (lhe of next character) */
+ ytop = Ypos + Yspace; /* top edge of character */
+ ymid = (ytop + Ypos) * 0.5; /* vertical mid point */
+ xmid = (xright + Xpos) * 0.5; /* horizontal mid point */
+
+ /* width_fac defines the width of the line in terms of the height of the characters */
+
+ hline_w = 0.5 * (width_fac * (ytop - Ypos));
+
+ PSmoveto(xmid,ymid-hline_w,outf);
+ PSlineto(xmid,ymid+hline_w,outf);
+ PSlineto(xright,ymid+hline_w,outf);
+ PSlineto(xright,ymid-hline_w,outf);
+ PSlineto(xmid,ymid-hline_w,outf);
+}
+
+void ALDrawLeftHalfHorizLine(
+ float Xpos, /* bottom left hand corner of character posn */
+ float Ypos, /* */
+ float Xspace, /* horizontal width of character position */
+ float Yspace, /* vertical height of character position */
+ float width_fac, FILE *outf) /* proportion of vertical height that the line will fill */
+
+/* draw line from midpoint to left of position */
+
+{
+ float xright,ytop;
+ float ymid;
+ float hline_w;
+ float xmid;
+
+ xright = Xpos + Xspace; /* right hand edge of character (lhe of next character) */
+ ytop = Ypos + Yspace; /* top edge of character */
+ ymid = (ytop + Ypos) * 0.5; /* vertical mid point */
+ xmid = (xright + Xpos) * 0.5; /* horizontal mid point */
+
+ /* width_fac defines the width of the line in terms of the height of the characters */
+
+ hline_w = 0.5 * (width_fac * (ytop - Ypos));
+
+ PSmoveto(xmid,ymid-hline_w,outf);
+ PSlineto(xmid,ymid+hline_w,outf);
+ PSlineto(Xpos,ymid+hline_w,outf);
+ PSlineto(Xpos,ymid-hline_w,outf);
+ PSlineto(xmid,ymid-hline_w,outf);
+}
+
+void PSmoveto(float x,float y,FILE *outf)
+{
+ fprintf(outf,"%.2f %.2f moveto\n",x,y);
+}
+void PSlineto(float x,float y,FILE *outf)
+{
+ fprintf(outf,"%.2f %.2f lineto\n",x,y);
+}
+void PSPutSpecialText(float Xpos,float Ypos,float Xspace,float Yspace,char *text,
+ unsigned char current_col,
+ unsigned char background_colour,float YspaceFactor,FILE *outf)
+/* Handle the special text characters */
+{
+
+ Yspace *= YspaceFactor; /* shrink the Y axis a little to avoid clashes.*/
+
+
+ if(strcmp(text,"@horizline") == 0){
+ ALDrawHorizLine(Xpos,Ypos,Xspace,Yspace,0.5,outf);
+ PSstroke(outf);
+ }else if(strcmp(text,"@fhorizline") == 0){
+ ALDrawHorizLine(Xpos,Ypos,Xspace,Yspace,0.5,outf);
+ PSstroke(outf);
+ ALDrawHorizLine(Xpos,Ypos,Xspace,Yspace,0.5,outf);
+ fprintf(outf,"closepath \n C%-d \n fill \n",current_col);
+
+ }else if(strcmp(text,"@thickhorizline") == 0){
+ ALDrawHorizLine(Xpos,Ypos,Xspace,Yspace,1.0,outf);
+ PSstroke(outf);
+ }else if(strcmp(text,"@fthickhorizline") == 0){
+ ALDrawHorizLine(Xpos,Ypos,Xspace,Yspace,1.0,outf);
+ PSstroke(outf);
+ ALDrawHorizLine(Xpos,Ypos,Xspace,Yspace,1.0,outf);
+ fprintf(outf,"closepath \n C%-d \n fill \n",current_col);
+
+ }else if(strcmp(text,"@thinhorizline") == 0){
+ ALDrawHorizLine(Xpos,Ypos,Xspace,Yspace,0.1,outf);
+ PSstroke(outf);
+ }else if(strcmp(text,"@fthinhorizline") == 0){
+ ALDrawHorizLine(Xpos,Ypos,Xspace,Yspace,0.1,outf);
+ PSstroke(outf);
+ ALDrawHorizLine(Xpos,Ypos,Xspace,Yspace,0.1,outf);
+ fprintf(outf,"closepath \n C%-d \n fill \n",current_col);
+
+ }else if(strcmp(text,"@rightarrow") == 0){
+ ALDrawRightArrow(Xpos,Ypos,Xspace,Yspace,0.5,outf);
+ PSstroke(outf);
+ }else if(strcmp(text,"@frightarrow") == 0){
+/* ALDrawRightArrow(Xpos,Ypos,Xspace,Yspace,0.5,outf);*/
+/* temporary change to the right arrow width 20/1/1995*/
+ ALDrawRightArrow(Xpos,Ypos,(Xspace*0.7),Yspace,0.5,outf);
+ PSstroke(outf);
+ ALDrawRightArrow(Xpos,Ypos,(Xspace*0.7),Yspace,0.5,outf);
+ fprintf(outf,"closepath \n C%-d \n fill \n",current_col);
+
+ }else if(strcmp(text,"@leftarrow") == 0){
+ ALDrawLeftArrow(Xpos,Ypos,Xspace,Yspace,0.5,outf);
+ PSstroke(outf);
+ }else if(strcmp(text,"@fleftarrow") == 0){
+ ALDrawLeftArrow(Xpos,Ypos,Xspace,Yspace,0.5,outf);
+ PSstroke(outf);
+ ALDrawLeftArrow(Xpos,Ypos,Xspace,Yspace,0.5,outf);
+ fprintf(outf,"closepath \n C%-d \n fill \n",current_col);
+
+ }else if(strcmp(text,"@uparrow") == 0){
+ ALDrawUpArrow(Xpos,Ypos,Xspace,Yspace,0.5,outf);
+ PSstroke(outf);
+ }else if(strcmp(text,"@fuparrow") == 0){
+ ALDrawUpArrow(Xpos,Ypos,Xspace,Yspace,0.5,outf);
+ PSstroke(outf);
+ ALDrawUpArrow(Xpos,Ypos,Xspace,Yspace,0.5,outf);
+ fprintf(outf,"closepath \n C%-d \n fill \n",current_col);
+
+ }else if(strcmp(text,"@suparrow") == 0){
+ ALDrawSmallUpArrow(Xpos,Ypos,Xspace,Yspace,0.5,outf);
+ PSstroke(outf);
+ }else if(strcmp(text,"@fsuparrow") == 0){
+ ALDrawSmallUpArrow(Xpos,Ypos,Xspace,Yspace,0.5,outf);
+ PSstroke(outf);
+ ALDrawSmallUpArrow(Xpos,Ypos,Xspace,Yspace,0.5,outf);
+ fprintf(outf,"closepath \n C%-d \n fill \n",current_col);
+
+ }else if(strcmp(text,"@downarrow") == 0){
+ ALDrawDownArrow(Xpos,Ypos,Xspace,Yspace,0.5,outf);
+ PSstroke(outf);
+ }else if(strcmp(text,"@fdownarrow") == 0){
+ ALDrawDownArrow(Xpos,Ypos,Xspace,Yspace,0.5,outf);
+ PSstroke(outf);
+ ALDrawDownArrow(Xpos,Ypos,Xspace,Yspace,0.5,outf);
+ fprintf(outf,"closepath \n C%-d \n fill \n",current_col);
+
+ }else if(strcmp(text,"@sdownarrow") == 0){
+ ALDrawSmallDownArrow(Xpos,Ypos,Xspace,Yspace,0.5,outf);
+ PSstroke(outf);
+ }else if(strcmp(text,"@fsdownarrow") == 0){
+ ALDrawSmallDownArrow(Xpos,Ypos,Xspace,Yspace,0.5,outf);
+ PSstroke(outf);
+ ALDrawSmallDownArrow(Xpos,Ypos,Xspace,Yspace,0.5,outf);
+ fprintf(outf,"closepath \n C%-d \n fill \n",current_col);
+
+ }else if(strcmp(text,"@circle") == 0){
+ ALDrawCircle(Xpos,Ypos,Xspace,Yspace,0.5,outf);
+ PSstroke(outf);
+ }else if(strcmp(text,"@fcircle") == 0){
+ ALDrawCircle(Xpos,Ypos,Xspace,Yspace,0.5,outf);
+ PSstroke(outf);
+ ALDrawCircle(Xpos,Ypos,Xspace,Yspace,0.5,outf);
+ fprintf(outf,"closepath \n C%-d \n fill \n",current_col);
+
+ }else if(strcmp(text,"@diamond") == 0){
+ ALDrawDiamond(Xpos,Ypos,Xspace,Yspace,0.5,outf);
+ PSstroke(outf);
+ }else if(strcmp(text,"@fdiamond") == 0){
+ ALDrawDiamond(Xpos,Ypos,Xspace,Yspace,0.5,outf);
+ PSstroke(outf);
+ ALDrawDiamond(Xpos,Ypos,Xspace,Yspace,0.5,outf);
+ fprintf(outf,"closepath \n C%-d \n fill \n",current_col);
+
+ }else if(strcmp(text,"@bar") == 0){
+ ALDrawBar(Xpos,Ypos,Xspace,Yspace,0.5,outf);
+ PSstroke(outf);
+ }else if(strcmp(text,"@fbar") == 0){
+ ALDrawBar(Xpos,Ypos,Xspace,Yspace,0.5,outf);
+ PSstroke(outf);
+ ALDrawBar(Xpos,Ypos,Xspace,Yspace,0.5,outf);
+ fprintf(outf,"closepath \n C%-d \n fill \n",current_col);
+
+ }else if(strcmp(text,"@leftsemiend") == 0){
+ ALDrawLeftSemiEnd(Xpos,Ypos,Xspace,Yspace,0.5,outf);
+ PSstroke(outf);
+ }else if(strcmp(text,"@fleftsemiend") == 0){
+ ALDrawLeftSemiEnd(Xpos,Ypos,Xspace,Yspace,0.5,outf);
+ PSstroke(outf);
+ ALDrawLeftSemiEnd(Xpos,Ypos,Xspace,Yspace,0.5,outf);
+ fprintf(outf,"closepath \n C%-d \n fill \n",current_col);
+
+ }else if(strcmp(text,"@rightsemiend") == 0){
+ ALDrawRightSemiEnd(Xpos,Ypos,Xspace,Yspace,0.5,outf);
+ PSstroke(outf);
+ }else if(strcmp(text,"@frightsemiend") == 0){
+ ALDrawRightSemiEnd(Xpos,Ypos,Xspace,Yspace,0.5,outf);
+ PSstroke(outf);
+ ALDrawRightSemiEnd(Xpos,Ypos,Xspace,Yspace,0.5,outf);
+ fprintf(outf,"closepath \n C%-d \n fill \n",current_col);
+
+ }else if(strcmp(text,"@lefthelixend") == 0){
+
+ ALDrawRightHalfHorizLine(Xpos,Ypos,Xspace,Yspace,1.0,outf);
+ PSstroke(outf);
+ ALDrawRightHalfHorizLine(Xpos,Ypos,Xspace,Yspace,1.0,outf);
+ fprintf(outf,"closepath \n C%-d \n fill \n",current_col);
+
+ ALDrawPseudoEllipse(Xpos,Ypos,Xspace,Yspace,0.5,outf);
+ fprintf(outf,"closepath \n C%-d \n fill \n",background_colour);
+
+ ALDrawLeftHalfHorizLine(Xpos,Ypos,Xspace,Yspace,0.1,outf);
+ PSstroke(outf);
+ ALDrawLeftHalfHorizLine(Xpos,Ypos,Xspace,Yspace,0.1,outf);
+ fprintf(outf,"closepath \n C%-d \n fill \n",current_col);
+
+ ALDrawPseudoEllipse(Xpos,Ypos,Xspace,Yspace,0.5,outf);
+ PSstroke(outf);
+
+ }else if(strcmp(text,"@righthelixend") == 0){
+
+ ALDrawLeftHalfHorizLine(Xpos,Ypos,Xspace,Yspace,1.0,outf);
+ PSstroke(outf);
+ ALDrawLeftHalfHorizLine(Xpos,Ypos,Xspace,Yspace,1.0,outf);
+ fprintf(outf,"closepath \n C%-d \n fill \n",current_col);
+
+ ALDrawPseudoEllipse(Xpos,Ypos,Xspace,Yspace,1.0,outf);
+ PSstroke(outf);
+ ALDrawPseudoEllipse(Xpos,Ypos,Xspace,Yspace,1.0,outf);
+ fprintf(outf,"closepath \n C%-d \n fill \n",current_col);
+
+ ALDrawRightHalfHorizLine(Xpos,Ypos,Xspace,Yspace,0.1,outf);
+ PSstroke(outf);
+ ALDrawRightHalfHorizLine(Xpos,Ypos,Xspace,Yspace,0.1,outf);
+ fprintf(outf,"closepath \n C%-d \n fill \n",current_col);
+
+
+ }else{
+ fprintf(stderr,"Error: Unrecognised special character: %s\n",text);
+ error(" ",1);
+ }
+}
+
+void PSstroke(FILE *outf)
+{
+ fprintf(outf,"stroke\n");
+}
+
+void PSnewpath(FILE *outf)
+{
+ fprintf(outf,"newpath\n");
+}
+
+void ALColourBackground(FILE *outf,int colour, int *b_region)
+{
+ int x1,y1,x2,y2;
+ x1 = b_region[0];
+ x2 = b_region[2];
+ y1 = b_region[1];
+ y2 = b_region[3];
+
+ fprintf(outf,"%d %d moveto %d %d lineto %d %d lineto %d %d lineto %d %d lineto closepath\n",
+ x1,y1,x2,y1,x2,y2,x1,y2,x1,y1);
+ fprintf(outf," C%-d \n fill \n",colour);
+ /* reset the colour to white */
+ /* fprintf(outf," C99\n");*/
+}
+
+void ALCheckLegalRange(int sx,int sy, int ex, int ey, int xmin, int ymin, int xmax, int ymax)
+/* check if sx, sy, ex, ey are within the limits given by xmin, ymin, xmax, ymax */
+{
+ extern FILE *std_err;
+ if( sx >= xmin && sx <= xmax
+ && sy >= ymin && sy <= ymax
+ && ex <= xmax && ex >= xmin
+ && ey <= ymax && ey >= ymin){
+ return;
+ }else{
+ fprintf(std_err,"\n\nALSCRIPT COMMAND FILE ERROR:\n");
+ fprintf(std_err,"Maximum legal range:\n");
+ fprintf(std_err,"From position %d of sequence %d to position %d of sequence %d\n",
+ xmin,ymin,xmax,ymax);
+
+ fprintf(std_err,"Your range:\n");
+ fprintf(std_err,"From position %d of sequence %d to position %d of sequence %d\n",
+ sx,sy,ex,ey);
+
+ GJerror("Range too big for alignment - try again!");
+ exit(0);
+ }
+}
+
+void ALMakeHelixText(int sx, int sy, int ex, char ***texts)
+{
+ int i;
+ texts[sx][sy] = GJstrdup("@lefthelixend");
+ texts[ex][sy] = GJstrdup("@righthelixend");
+ for(i=sx+1;i<ex;++i){
+ texts[i][sy] = GJstrdup("@fthickhorizline");
+ }
+}
+
+void ALMakeStrandText(int sx, int sy, int ex, char ***texts)
+{
+ int i;
+ texts[ex][sy] = GJstrdup("@frightarrow");
+ for(i=sx;i<ex;++i){
+ texts[i][sy] = GJstrdup("@fhorizline");
+ }
+}
+
+void ALMakeCoilText(int sx, int sy, int ex, char ***texts)
+{
+ int i;
+ for(i=sx;i<ex+1;++i){
+ texts[i][sy] = GJstrdup("@fthinhorizline");
+ }
+}
+
+int ALrel(char *pos,int *relnum)
+/* ALrel: parses a string that defines a position in a sequence. This can
+have the form
+
+to indicate position 10 10
+to indicate three before 10 10-3
+to indicate five after 10 10+5
+
+The routine looks up the relative number in *relnum before adding or
+subtracting numbers, the end result is therefore relative to the current
+alignment position.
+
+It should be easy to extend this routine for the relative movement to
+apply to positions in another sequence rather than alignment
+coordinates. (e.g. 10+5:73 might mean 5 after the current position in sequence 73).
+*/
+
+{
+ int i;
+ int len;
+ char *token;
+ int ipos,ioff; /* position and offset */
+ extern FILE *std_in,*std_out,*std_err;
+
+ len = strlen(pos);
+ ioff = 0;
+ ipos = 0;
+
+
+ if(strchr(pos,'+') != NULL){
+ token = strtok(pos,"+");
+ if(strlen(token)== 0){
+ error("Error decoding position",1);
+ fprintf(std_err,"Offending string is: %s\n",pos);
+ }else{
+ ipos = atoi(token);
+ }
+ token = strtok(NULL,"\0");
+ if(strlen(token)== 0){
+ error("Error decoding position",1);
+ fprintf(std_err,"Offending string is: %s\n",pos);
+ }else{
+ ioff = atoi(token);
+ }
+ return (relnum[ipos] + ioff);
+ }else if(strchr(pos,'-') != NULL){
+ token = strtok(pos,"-");
+ if(strlen(token)== 0){
+ error("Error decoding position",1);
+ fprintf(std_err,"Offending string is: %s\n",pos);
+ }else{
+ ipos = atoi(token);
+ }
+ token = strtok(NULL,"\0");
+ if(strlen(token)== 0){
+ error("Error decoding position",1);
+ fprintf(std_err,"Offending string is: %s\n",pos);
+ }else{
+ ioff = atoi(token);
+ }
+ return (relnum[ipos] - ioff);
+ }else{
+ ipos = atoi(pos);
+ return relnum[ipos];
+ }
+}
+
+int *ALCalCons(struct seqdat *bloc,
+ int sx,int sy,int ex,int ey,int *ret_val,int len)
+
+/* Calculate conservation for an alignment - this can be just a segment of an alignment */
+/* bloc = the alignment bloc */
+/* sx,sy,ex,ey = the positions over which to calculate the conservation */
+/* conscut = conservation number cutoff ( an integer 0 - 10) */
+/* ret_val = a pointer to an integer array to store the results of the calculation */
+/* len = the length of the array ret_val - this must be the same as the alignment length */
+
+{
+ int i,j,tlen,k;
+ char *temp;
+ char *temp2;
+ float tval;
+ int gcount;
+
+ tlen = ey -sy + 1;
+ temp = GJstrcreate(tlen+1,NULL);
+ if(ret_val == NULL){
+ ret_val = (int *) GJmalloc(sizeof(int) * len);
+ }
+
+ for(i=sx;i<(ex+1);++i){
+ /* calculate conservation at each position */
+ k = 0;
+ for(j=sy;j<(ey+1);++j){
+ temp[k] = bloc[j].seq[i];
+ ++k;
+ }
+ temp2 = GJstoupper(temp);
+ /* check for all gap columns */
+ gcount = 0;
+ for(j=0;j<tlen;++j){
+ if(temp2[j] == ' ') ++gcount;
+ }
+ if(gcount == tlen){
+ tval = 0.0;
+ }else{
+ tval = mzcons((unsigned char *)temp2,tlen);
+ }
+/* fprintf(stderr,"In calcons: i:%d tlen:%d temp:%s tval:%f\n",i,tlen,temp,tval);*/
+ ret_val[i] = 10 * tval;
+ GJfree(temp2);
+ }
+ GJfree(temp);
+ return ret_val;
+}
+
+float mzcons(unsigned char *pos,int n)
+/* calculate conservation value according to Zvelebil et al for a set
+ of amino acids and gaps stored in string pos of length n
+ translated from the fortran mzcons.f 6/3/1995
+*/
+
+{
+ /* -- conmat contains a table like that shown in the JMB paper
+ order of amino acids is GAP,ARNDCQEGHILKMFPSTWYVBZX
+ */
+ static char *acids = " ARNDCQEGHILKMFPSTWYVBZX";
+ static int conmat[24][10] = {
+ {1,1,1,1,1,1,1,1,1,1}, /* */
+ {1,0,0,0,0,1,1,0,0,0}, /*A */
+ {0,1,0,1,1,0,0,0,0,0}, /*R */
+ {0,0,0,1,0,1,0,0,0,0}, /*N */
+ {0,0,1,1,1,1,0,0,0,0}, /*D */
+ {1,0,0,0,0,1,0,0,0,0}, /*C */
+ {0,0,0,1,0,0,0,0,0,0}, /*Q */
+ {0,0,1,1,1,0,0,0,0,0}, /*E */
+ {1,0,0,0,0,1,1,0,0,0}, /*G */
+ {1,1,0,1,1,0,0,0,1,0}, /*H */
+ {1,0,0,0,0,0,0,1,0,0}, /*I */
+ {1,0,0,0,0,0,0,1,0,0}, /*L */
+ {1,1,0,1,1,0,0,0,0,0}, /*K */
+ {1,0,0,0,0,0,0,0,0,0}, /*M */
+ {1,0,0,0,0,0,0,0,1,0}, /*F */
+ {0,0,0,0,0,1,0,0,0,1}, /*P */
+ {0,0,0,1,0,1,1,0,0,0}, /*S */
+ {1,0,0,1,0,1,0,0,0,0}, /*T */
+ {1,0,0,1,0,0,0,0,1,0}, /*W */
+ {1,0,0,1,0,0,0,0,1,0}, /*Y */
+ {1,0,0,0,0,1,0,1,0,0}, /*V */
+ {0,0,0,1,0,0,0,0,0,0}, /*B */
+ {0,0,0,1,0,0,0,0,0,0}, /*Z */
+ {1,1,1,1,1,1,1,1,1,1} /*X */
+ };
+
+ int concnt,it,i,j,k,l,tcnt,ibseq;
+ int nide;
+ float con;
+ unsigned char facid;
+
+ concnt = 0;
+ for(j=0;j<10;++j){
+ /*found: outer loop over properties
+ set IT to the value of the first amino acid*/
+ it = conmat[GJindex(acids,pos[0])][j];
+ /*loop over remaining acids, if a difference occurs then
+ set tcnt to 1*/
+ tcnt = 0;
+ for(k=1;k<n;++k){
+ if(it != conmat[GJindex(acids,pos[k])][j]){
+ tcnt = 1;
+ }
+ }
+ /*add tcnt to concnt*/
+ concnt += tcnt;
+ }
+ /* check for total identity at this position*/
+ facid = pos[0];
+ nide = 0;
+ for(k=1;k<n;++k){
+ if(facid == pos[k]){
+ ++nide;
+ }
+ }
+
+ /*calculate the conservation*/
+ if(concnt == 10){
+ con = 0.0;
+ }else if(concnt == 0){
+ if(nide == (n-1)){
+ /*total identity*/
+ con = 1.0;
+ }else{
+ /*not identity, but same properties*/
+ con = 0.9;
+ }
+ }else{
+ con = 0.9 - 0.1 * concnt;
+ }
+ return con;
+}
+
+
+int GJindex(char *str,char c)
+{
+ char *t;
+ t = strchr(str,c);
+ if(t == NULL) return -1;
+ return (int) (t - str);
+}
+
git://source.jalview.org / jpred.git / blobdiff