xdisplay.c

是有关基因比对的经典算法的实现。这对于初学计算生物学的人是非常重要的算法。

#include <stdio.h>
#include <stdarg.h>
#include <string.h>

#include <vibrant.h>
#include <document.h>

#include "clustalw.h"
#include "xmenu.h"

static void VscrollMulti(BaR bar, GraphiC p, Nlm_Int2 newval, Nlm_Int2 oldval);
static void HscrollMultiN(BaR bar, GraphiC p, Nlm_Int2 newval, Nlm_Int2 oldval);
static void HscrollMultiS(BaR bar, GraphiC p, Nlm_Int2 newval, Nlm_Int2 oldval);
static void VscrollPrf1(BaR bar, GraphiC p, Nlm_Int2 newval, Nlm_Int2 oldval);
static void HscrollPrf1N(BaR bar, GraphiC p, Nlm_Int2 newval, Nlm_Int2 oldval);
static void HscrollPrf1S(BaR bar, GraphiC p, Nlm_Int2 newval, Nlm_Int2 oldval);
static void VscrollPrf2(BaR bar, GraphiC p, Nlm_Int2 newval, Nlm_Int2 oldval);
static void HscrollPrf2N(BaR bar, GraphiC p, Nlm_Int2 newval, Nlm_Int2 oldval);
static void HscrollPrf2S(BaR bar, GraphiC p, Nlm_Int2 newval, Nlm_Int2 oldval);

static void NameClick(PaneL panel, PoinT pt);
static void NameDrag(PaneL panel, PoinT pt);
static void NameRelease(PaneL panel, PoinT pt);
static void SeqClick(PaneL panel, PoinT pt);
static void SeqDrag(PaneL panel, PoinT pt);
static void SeqRelease(PaneL panel, PoinT pt);

static void fit_seq_display(RecT wr,Boolean mv_message);
static void fit_prf_displays(RecT wr,int numseqs1,int numseqs2,Boolean mv_message);

static void vscrollnames(BaR bar, int newval, int oldval);
static void hscrollnames(BaR bar, int newval, int oldval);
static void vscrollseqs(BaR bar, int newval, int oldval);
static void hscrollseqs(BaR bar, int newval, int oldval);

static void correct_scrollbar(BaR b,int visible,int total,int value,Boolean reset);

static PaneL make_panel(int type,GrouP g,int width,int height,int firstline,int tlines);
static panel_data free_panel_data(panel_data data);
static panel_data alloc_name_data(panel_data data);
static panel_data alloc_seq_data(panel_data data);

extern sint max_names;

extern int    mheader; /* maximum header lines */
extern int    mfooter; /* maximum footer lines */
extern int max_plines;     /*   profile align display length */
extern int min_plines1;     /*   profile align display length */
extern int min_plines2;     /*   profile align display length */
extern int loffset,boffset,toffset;
extern int roffset;
extern int poffset;

extern Boolean aln_mode;
extern Boolean fixed_prf_scroll;
extern Boolean window_displayed;

extern PrompT   message;           /* used in temporary message window */

extern spanel  seq_panel;        /* data for multiple alignment area */
extern spanel  prf_panel[];       /* data for profile alignment areas */
extern spanel  active_panel;       /* 'in-use' panel -scrolling,clicking etc. */
extern FonT datafont;
extern WindoW mainw;
extern GrouP  seq_display,prf1_display,prf2_display;

extern int ncolors;
extern int    inverted;

extern Boolean  dnaflag;
extern sint     nseqs;
extern sint    profile1_nseqs;
extern sint     output_order;
extern sint     *output_index;
extern sint     *seqlen_array;
extern char     **seq_array;
extern char     **names, **titles;
extern char     *amino_acid_codes;
extern sint     gap_pos1, gap_pos2;
extern char *gap_penalty_mask1,*gap_penalty_mask2;
extern char *sec_struct_mask1,*sec_struct_mask2;
extern sint struct_penalties1,struct_penalties2;
extern sint output_struct_penalties;
extern Boolean use_ss1, use_ss2;

extern char *explicit_par_file;
extern char *par_file;
extern char def_protpar_file[];
extern char def_dnapar_file[];
extern sint     ncutseqs;
extern Boolean residue_exceptions;
extern Boolean segment_exceptions;
extern color color_lut[];
extern char *res_cat1[];
extern char *res_cat2[];

static range selected_seqs;           /* sequences selected by clicking on names */
static range selected_res;           /* residues selected by clicking on seqs */

 
static int fromvscroll,fromhscroll; /* set by scrolling functions,
                            used by DrawPanel, draw_names, draw_seqs */


void resize_multi_window(void)
{
	RecT r;

	ObjectRect(mainw,&r);
	fit_seq_display(r,FALSE);
}

void resize_prf_window(int numseqs1,int numseqs2)
{
	RecT r;

	SelectFont(datafont);
	stdCharWidth=CharWidth('A');
        stdLineHeight=LineHeight();

	if(numseqs1>max_plines)
		numseqs1=max_plines;
	else if(numseqs1<min_plines1)
		numseqs1=min_plines1;
	if(numseqs2>max_plines)
		numseqs2=max_plines;
	else if(numseqs2<min_plines2)
		numseqs2=min_plines2;
	ObjectRect(mainw,&r);

	fit_prf_displays(r,numseqs1,numseqs2,FALSE);
}

static void fit_seq_display(RecT wr,Boolean mv_message)
{
	int width,height,moffset;
	RecT nr,sr,mr;
	panel_data data;

	ObjectRect(seq_panel.names,&nr);
	ObjectRect(message,&mr);
	moffset=mr.top-nr.bottom;
	width=nr.right-nr.left;
	height=wr.bottom-wr.top-boffset-toffset;
	nr.top=toffset;
	nr.left=loffset;
	nr.bottom=nr.top+height;
	nr.right=nr.left+width;
	SetPosition(seq_panel.names,&nr);

	GetPanelExtra(seq_panel.names,&data);
	data.vlines=(height-SCOREHEIGHT)/data.lineheight - MARGIN;
	data.vseqs=data.vlines-data.nhead-data.nfoot;
	SetPanelExtra(seq_panel.names,&data);


	sr.top=nr.top;
	sr.left=nr.right;
	sr.bottom=sr.top+height;
	sr.right=wr.right-wr.left-roffset;
	width=sr.right-sr.left;
	SetPosition(seq_panel.seqs,&sr);

	GetPanelExtra(seq_panel.seqs,&data);
	data.vcols=width/data.charwidth - MARGIN*2;
	data.vlines=(height-SCOREHEIGHT)/data.lineheight - MARGIN;
	data.vseqs=data.vlines-data.nhead-data.nfoot;
	SetPanelExtra(seq_panel.seqs,&data);

	if(mv_message) {
		height=mr.bottom-mr.top;
		mr.top=nr.bottom+moffset;
		mr.bottom=mr.top+height;
		SetPosition(message,&mr);
	}


	position_scrollbars(seq_panel);
	correct_name_bars(TRUE);
	correct_seq_bars(TRUE);

}

static void fit_prf_displays(RecT wr,int numseqs1,int numseqs2,Boolean mv_message)
{
	int width,height,moffset;
	RecT mr,nr,sr;
	panel_data data;

	ObjectRect(prf_panel[1].names,&nr);
	ObjectRect(message,&mr);
	moffset=mr.top-nr.bottom;

	ObjectRect(prf_panel[0].names,&nr);
	width=nr.right-nr.left;

	nr.top=toffset;
	nr.left=loffset;
	height=(wr.bottom-wr.top-boffset-toffset-poffset)*numseqs1/(numseqs1+numseqs2);
	nr.bottom=nr.top+height;
	nr.right=nr.left+width;
	SetPosition(prf_panel[0].names,&nr);
	GetPanelExtra(prf_panel[0].names,&data);
	data.vlines=(height-SCOREHEIGHT)/data.lineheight - MARGIN;
	data.vseqs=data.vlines-data.nhead-data.nfoot;
	SetPanelExtra(prf_panel[0].names,&data);
	sr.top=nr.top;
	sr.left=nr.right;
	sr.bottom=sr.top+height;
	sr.right=wr.right-wr.left-roffset;
	width=sr.right-sr.left;
	SetPosition(prf_panel[0].seqs,&sr);
	GetPanelExtra(prf_panel[0].seqs,&data);
	data.vcols=width/data.charwidth - MARGIN*2;
	data.vlines=(height-SCOREHEIGHT)/data.lineheight - MARGIN;
	data.vseqs=data.vlines-data.nhead-data.nfoot;
	SetPanelExtra(prf_panel[0].seqs,&data);
	position_scrollbars(prf_panel[0]);



	nr.top=nr.bottom+poffset;
	height=(wr.bottom-wr.top-boffset-toffset-poffset)*numseqs2/(numseqs1+numseqs2);
	nr.bottom=nr.top+height;
	SetPosition(prf_panel[1].names,&nr);
	GetPanelExtra(prf_panel[1].names,&data);
	data.vlines=(height-SCOREHEIGHT)/data.lineheight - MARGIN;
	data.vseqs=data.vlines-data.nhead-data.nfoot;
	SetPanelExtra(prf_panel[1].names,&data);
	sr.top=nr.top;
	sr.bottom=sr.top+height;
	SetPosition(prf_panel[1].seqs,&sr);
	GetPanelExtra(prf_panel[1].seqs,&data);
	data.vcols=width/data.charwidth - MARGIN*2;
	data.vlines=(height-SCOREHEIGHT)/data.lineheight - MARGIN;
	data.vseqs=data.vlines-data.nhead-data.nfoot;
	SetPanelExtra(prf_panel[1].seqs,&data);
	position_scrollbars(prf_panel[1]);

	if(mv_message) {
		height=mr.bottom-mr.top;
		mr.top=nr.bottom+moffset;
		mr.bottom=mr.top+height;
		SetPosition(message,&mr);
	}

	correct_name_bars(TRUE);
	correct_seq_bars(TRUE);
}

void ResizeWindowProc(WindoW w)
{
	int numseqs1,numseqs2;
	RecT wr;
	panel_data data;

	if(window_displayed==FALSE) return;

	ObjectRect(w,&wr);
	if (aln_mode==MULTIPLEM)
	{
/* if the window is too small, hide everything */
		if(wr.bottom-wr.top < toffset+boffset)
		{
			Hide(seq_display);
			Hide(message);
			return;
		}
		fit_seq_display(wr,TRUE);
		Show(seq_display);
		Show(message);
	}
	else
	{
/* if the window is too small, hide everything */
		if(wr.bottom-wr.top < toffset+boffset+2*poffset)
		{
			Hide(prf1_display);
			Hide(prf2_display);
			Hide(message);
			return;
		}
		GetPanelExtra(prf_panel[0].names,&data);
		numseqs1=data.nseqs;
		if(numseqs1<min_plines1)numseqs1=min_plines1;
		else if(numseqs1>max_plines)numseqs1=max_plines;
		GetPanelExtra(prf_panel[1].names,&data);
		numseqs2=data.nseqs;
		if(numseqs2<min_plines2)numseqs2=min_plines2;
		else if(numseqs2>max_plines)numseqs2=max_plines;

		fit_prf_displays(wr,numseqs1,numseqs2,TRUE);
		Show(prf1_display);
		Show(prf2_display);
		Show(message);
	}

}

void position_scrollbars(spanel p)
{
	int height;
	RecT hr,vr,nr,sr;
	panel_data data;

	ObjectRect(p.names,&nr);
	GetPanelExtra(p.names,&data);
	ObjectRect(data.hscrollbar,&hr);
	height=hr.bottom-hr.top;
	LoadRect(&hr,nr.left,nr.bottom,nr.right,nr.bottom+height);
	SetPosition(data.hscrollbar,&hr);
#ifdef WIN_MAC
	AdjustPrnt(data.hscrollbar,&hr,FALSE);
#endif
	ObjectRect(p.seqs,&sr);
	GetPanelExtra(p.seqs,&data);
	ObjectRect(data.hscrollbar,&hr);
	height=hr.bottom-hr.top;
	LoadRect(&hr,sr.left,sr.bottom,sr.right,sr.bottom+height);
	SetPosition(data.hscrollbar,&hr);
#ifdef WIN_MAC
	AdjustPrnt(data.hscrollbar,&hr,FALSE);
#endif
	ObjectRect(data.vscrollbar,&vr);
	LoadRect(&vr,vr.left,sr.top,vr.right,sr.bottom);
	SetPosition(data.vscrollbar,&vr);
#ifdef WIN_MAC
	AdjustPrnt(data.vscrollbar,&vr,FALSE);
#endif
}





void load_aln_data(spanel p,int fs,int ls,Boolean reset)
{
	int i,j,slength=0;
	int nhead;
	sint val;
	panel_data name_data,seq_data;

	WatchCursor();

	GetPanelExtra(p.names,&name_data);
	GetPanelExtra(p.seqs,&seq_data);
	name_data=free_panel_data(name_data);
	seq_data=free_panel_data(seq_data);
	SetPanelExtra(p.names,&name_data);
	SetPanelExtra(p.seqs,&seq_data);

	name_data.nseqs=ls-fs+1;
	seq_data.nseqs=name_data.nseqs;
	name_data.firstseq=fs;
	seq_data.firstseq=fs;

/* find the maximum length of sequence */
	for(i=fs;i<=ls;i++)
           	if (slength < seqlen_array[i+1]) slength = seqlen_array[i+1];
	name_data.ncols=max_names;
	seq_data.ncols=slength;

	if (name_data.nseqs>0)
	{
		name_data=alloc_name_data(name_data);
		seq_data=alloc_seq_data(seq_data);

	
		for(i=fs;i<=ls;i++)
        	{
                	strncpy(name_data.lines[i-fs],names[i+1],MAXNAMES);
                	name_data.lines[i-fs][MAXNAMES]='\0';
                	for(j=0;j<seqlen_array[i+1];j++)
                	{
                        	val = seq_array[i+1][j+1];
                        	if((val == -3) || (val == 253))
                                	break;
                        	else if((val == gap_pos1) || (val == gap_pos2))
                                	seq_data.lines[i-fs][j] = '-';
                        	else {
                                	seq_data.lines[i-fs][j] = amino_acid_codes[val];
                        	}
                	}
                	for(j=seqlen_array[i+1];j<slength;j++)
                        	seq_data.lines[i-fs][j] = ' ';
			seq_data.lines[i-fs][j]='\0';

			name_data.selected[i-fs]=FALSE;

        	}


		make_consensus(seq_data,name_data.header[0],seq_data.header[0]);
		nhead=make_struct_data(seq_data.prf_no,slength,name_data.header[1],seq_data.header[1]);
		if (nhead==0)
			nhead=make_gp_data(seq_data.prf_no,slength,name_data.header[1],seq_data.header[1]);
		seq_data.nhead=name_data.nhead=nhead+1;

		seq_data.nfoot=name_data.nfoot=1;
		seq_data.consensus=NULL;
		make_ruler(slength,name_data.footer[0],seq_data.footer[0]);
		make_colscores(seq_data);
	}
	else
	{
		seq_data.ncols=name_data.ncols=0;
	}

	if(reset==TRUE)
	{
		name_data.firstvline=0;
		name_data.firstvcol=0;
		seq_data.firstvline=0;
		seq_data.firstvcol=0;
	}
        name_data.vseqs=name_data.vlines-name_data.nhead-name_data.nfoot;
        seq_data.vseqs=seq_data.vlines-seq_data.nhead-seq_data.nfoot;

	if(seq_data.nseqs>0)
	{
/* try to find the user's color parameter file */
		if (explicit_par_file == NULL)
		{
			if (par_file != NULL)
				ckfree(par_file);
			if(dnaflag)
				par_file=find_file(def_dnapar_file);
			else
				par_file=find_file(def_protpar_file);
		}
        	init_color_parameters(par_file);
        	make_colormask(seq_data);
	}

	SetPanelExtra(p.names,&name_data);
	SetPanelExtra(p.seqs,&seq_data);

	ArrowCursor();
}

void load_aln(spanel p,int fs,int ls,Boolean reset)
{

	load_aln_data(p,fs,ls,reset);

	DrawPanel(p.names);
	DrawPanel(p.seqs);
	correct_name_bars(reset);
	correct_seq_bars(reset);

}

static panel_data alloc_name_data(panel_data data)
{
	int i;

	data.lines=(char **)ckalloc((data.nseqs+1)*sizeof(char *));
	data.colormask=NULL;
	data.selected=(int *)ckalloc((data.nseqs+1)*sizeof(int));

	for(i=0;i<data.nseqs;i++)
        {
		data.lines[i]=(char *)ckalloc((MAXNAMES+1)*sizeof(char));
		strncpy(data.lines[i],names[i+1],MAXNAMES);
		data.lines[i][MAXNAMES]='\0';
	}

	data.header=(char **)ckalloc((mheader+1)*sizeof(char *));
	for(i=0;i<mheader;i++)
		data.header[i]=(char *)ckalloc((MAXNAMES+1)*sizeof(char));
	data.footer=(char **)ckalloc((mfooter+1)*sizeof(char *));
	for(i=0;i<mfooter;i++)
		data.footer[i]=(char *)ckalloc((MAXNAMES+1)*sizeof(char));
	return(data);
}

static panel_data alloc_seq_data(panel_data data)
{
	int i;

	data.lines=(char **)ckalloc((data.nseqs+1)*sizeof(char *));
	data.colormask=(char **)ckalloc((data.nseqs+1)*sizeof(char *));
	data.firstsel=data.lastsel=-1;

	for(i=0;i<data.nseqs;i++)
        {
		data.lines[i]=(char *)ckalloc((data.ncols+1)*sizeof(char));
		data.colormask[i]=(char *)ckalloc((data.ncols+1)*sizeof(char));
	}

	data.selected=(int *)ckalloc((data.ncols+1)*sizeof(int));
	for(i=0;i<data.ncols;i++)
		data.selected[i]=FALSE;

	data.header=(char **)ckalloc((mheader+1)*sizeof(char *));
	for(i=0;i<mheader;i++)
		data.header[i]=(char *)ckalloc((data.ncols+1)*sizeof(char));

	data.colscore=(sint *)ckalloc((data.ncols+1)*sizeof(sint));
	data.residue_exception=(Boolean **)ckalloc((data.nseqs+1)*sizeof(Boolean *));
	for(i=0;i<data.nseqs;i++)
		data.residue_exception[i]=(Boolean *)ckalloc((data.ncols+1)*sizeof(Boolean));
	data.segment_exception=(short **)ckalloc((data.nseqs+1)*sizeof(short *));
	for(i=0;i<data.nseqs;i++)
		data.segment_exception[i]=(short *)ckalloc((data.ncols+1)*sizeof(short));

	data.footer=(char **)ckalloc((mfooter+1)*sizeof(char *));
	for(i=0;i<mfooter;i++)
		data.footer[i]=(char *)ckalloc((data.ncols+1)*sizeof(char));
	return(data);
}

void correct_name_bars(Boolean reset)
{
	panel_data data,data1;

	if(aln_mode==PROFILEM)
	{
		GetPanelExtra(prf_panel[0].names,&data);
		GetPanelExtra(prf_panel[1].names,&data1);
		if(reset==TRUE)
		{
			data.firstvcol=0;
			data1.firstvcol=0;
		}
		correct_scrollbar(data.hscrollbar,data.vcols,data.ncols,data.firstvcol,reset);
		correct_scrollbar(data1.hscrollbar,data1.vcols,data1.ncols,data.firstvcol,reset);
		if(reset==TRUE)
		{
			data.firstvline=0;
			data1.firstvline=0;
		}
		correct_scrollbar(data.vscrollbar,data.vseqs,data.nseqs,data.firstvline,reset);
		correct_scrollbar(data1.vscrollbar,data1.vseqs,data1.nseqs,data1.firstvline,reset);
		SetPanelExtra(prf_panel[0].names,&data);
		SetPanelExtra(prf_panel[1].names,&data1);
	}
	else
	{
		GetPanelExtra(seq_panel.names,&data);
		if(reset==TRUE)
		{
			data.firstvcol=0;
			data.firstvline=0;
		}
		correct_scrollbar(data.vscrollbar,data.vseqs,data.nseqs,data.firstvline,reset);
		correct_scrollbar(data.hscrollbar,data.vcols,data.ncols,data.firstvcol,reset);