xdisplay.c

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

	for(i=data.firstvline;i<data.firstvline+data.vseqs && i<data.nseqs;i++)
	{	
		ix=output_index[i+1]-1;
		if(segment_exceptions && data.segment_exception[ix][col] > 0)
		{
			r2.top=y-data.lineheight+data.descent+1;
			r2.bottom=r.top+data.lineheight;
			DkGray();
			PaintRect(&r2);
			White();
		}
		else if(residue_exceptions && data.residue_exception[ix][col] == TRUE)
		{
			r2.top=y-data.lineheight+data.descent+1;
			r2.bottom=r.top+data.lineheight;
		/*	LtGray(); */
			SelectColor(150,150,150);
			PaintRect(&r2);
			White();
		}
		else
		{
                        if(inverted)
                        {
                                r2.top=y-data.lineheight+data.descent+1;
                                r2.bottom=r2.top+data.lineheight;
                                if(format==HIGHLIGHT)
				{
                                        LtGray();
				}
                                else
                                SetColor(color_lut[(int)data.colormask[ix][col]].val);
                                PaintRect(&r2);
                                Black();
                        }
                        else
                                SetColor(color_lut[(int)data.colormask[ix][col]].val);

		}
		LoadPt(&pt,x,y);
		SetPen(pt);
		PaintChar(data.lines[ix][col]);
		y+=data.lineheight;
	}
	Black();
} 

void highlight_seqrange(PaneL p,int fcol,int lcol, int format)
{ 
	RecT  block,r;
	int i,t,x,y;
	int fseq,lseq,s;
	panel_data data;
	PoinT pt;

	Select(p);
	SelectFont(datafont);
	GetPanelExtra(p, &data);
	if(data.nseqs == 0) return;
	if(data.ncols == 0) return;

        if (fcol > lcol)
        {
                t=fcol;
                fcol=lcol;
                lcol=t;
        }

	if ((fcol>=data.firstvcol && fcol<data.firstvcol+data.vcols)||
	   (lcol>=data.firstvcol && lcol<data.firstvcol+data.vcols))
	{
		if (fcol<data.firstvcol) fcol=data.firstvcol;
		if (fcol>=data.firstvcol+data.vcols) fcol=data.firstvcol+data.vcols-1;
		if (lcol<data.firstvcol) lcol=data.firstvcol;
		if (lcol>=data.firstvcol+data.vcols) lcol=data.firstvcol+data.vcols-1;
	}
 
	fseq=data.firstvline;
	lseq=data.firstvline+data.vseqs-1;
	if(lseq>=data.nseqs) lseq=data.nseqs-1;
        s=fseq-data.firstvline;
        ObjectRect (p, &r);
        InsetRect(&r,1,1);
	if(format==HIGHLIGHT)
		text_colors();
	else
		data_colors();
       	block.top=r.top+((s+data.nhead)*data.lineheight)+data.descent+1;
       	block.bottom=block.top+(lseq-fseq+1)*data.lineheight;
       	block.left=r.left+(fcol-data.firstvcol+1)*data.charwidth;
       	block.right=r.left+(lcol-data.firstvcol+2)*data.charwidth;
        EraseRect(&block);

       	x=r.left+(fcol-data.firstvcol+1)*data.charwidth;
	 
       	for(i=fseq;i<=lseq;i++)
       	{
               	y=block.top+(i-fseq+1)*data.lineheight-data.descent-1;
		LoadPt(&pt,x,y);
               	draw_seqline(data,i,pt,fcol,lcol,format);
       	}
	black_on_white();
} 

GrouP make_scroll_area(GrouP w,int prf_no,int nwidth,int swidth,int height,int firstseq,int nseqs,spanel *p)
{
	panel_data ndata,sdata;
        GrouP display;
	RecT rect;
        PoinT pt;
	PaneL names,seqs;
	BaR vscrollbar,hnscrollbar,hsscrollbar;
	BarScrlProc hscrollnameproc, hscrollseqproc, vscrollproc;

	if(prf_no==0)
	{
		hscrollnameproc=HscrollMultiN;
		hscrollseqproc=HscrollMultiS;
		vscrollproc=VscrollMulti;
	}
	else if (prf_no==1)
	{
		hscrollnameproc=HscrollPrf1N;
		hscrollseqproc=HscrollPrf1S;
		vscrollproc=VscrollPrf1;
	}
	else
	{
		hscrollnameproc=HscrollPrf2N;
		hscrollseqproc=HscrollPrf2S;
		vscrollproc=VscrollPrf2;
	}

        display=HiddenGroup(w, 0, 0, NULL);
        SetGroupSpacing(display, 0, 0);
	Hide(display);

        vscrollbar=ScrollBar(display, -1, 1, vscrollproc);

        ObjectRect(vscrollbar, &rect);
        pt.x=rect.right;
        pt.y=rect.top;
        SetNextPosition(display, pt);
        names=make_panel(NAMES,display, nwidth, height, firstseq,nseqs);

        ObjectRect(names, &rect);
        pt.x=rect.right;
        pt.y=rect.top;
        SetNextPosition(display, pt);
        seqs=make_panel(SEQS,display, swidth, height, firstseq,nseqs);

/* horizontal scroll bars */
        ObjectRect(names, &rect);
        pt.x=rect.left;
        pt.y=rect.bottom;
        SetNextPosition(display, pt);
        hnscrollbar=ScrollBar(display, 1, -1, hscrollnameproc);
        ObjectRect(seqs, &rect);
        pt.x=rect.left;
        pt.y=rect.bottom;
        SetNextPosition(display, pt);
        hsscrollbar=ScrollBar(display, 1, -1, hscrollseqproc);
        
	SetRange(hsscrollbar,1,1,0);
	SetRange(hnscrollbar,1,1,0);
	SetRange(vscrollbar,1,1,0);

	GetPanelExtra(names,&ndata);
	ndata.hscrollbar=hnscrollbar;
	ndata.index=seqs;
        ndata.prf_no=prf_no;

	GetPanelExtra(seqs,&sdata);
	sdata.vscrollbar=vscrollbar;
	sdata.hscrollbar=hsscrollbar;
	sdata.index=names;
        sdata.prf_no=prf_no;

	SetPanelClick(names,NameClick, NameDrag, NULL, NameRelease);
	SetPanelClick(seqs,SeqClick, SeqDrag, NULL, SeqRelease);

	p->names = names;
	p->seqs = seqs;

	ndata=alloc_name_data(ndata);
	sdata=alloc_seq_data(sdata);
	SetPanelExtra(names,&ndata);
	SetPanelExtra(seqs,&sdata);

	Show(display);
	return(display);
}


void white_on_black(void)
{
	Black(); InvertColors(); White();
}
void black_on_white(void)
{
	White(); InvertColors(); Black();
}
void text_colors(void)
{
	SelectColor(220,220,220);
	InvertColors();
	Black();
}
void data_colors(void)
{
	White();
	InvertColors();
	Black();
}




void make_ruler(int length, char *name,char *seq)
{

	int i,j;
	char marker[5];
	int marker_len;

	strcpy(name,"ruler");
	seq[0] = '1';
	for (i=1;i<length;i++)
	{
		if ((i+1)%10 > 0)
			seq[i] = '.';
		else
		{
			sprintf(marker,"%d",((i+1)/10)*10);
			marker_len = strlen(marker);
			for (j=0;j<marker_len && i+1+j-marker_len < length;j++)
				seq[i+1+j-marker_len] = marker[j];
		}
	}
	seq[length]='\0';
}

panel_data free_panel_data(panel_data data)
{
	int i;

	if (data.header!=NULL)
	{
		for (i=0;i<mheader;i++)
		{
			if(data.header[i] != NULL) ckfree(data.header[i]);
			data.header[i]=NULL;
		}
		ckfree(data.header);
		data.header=NULL;
	}
	if (data.footer!=NULL)
	{
		for (i=0;i<mfooter;i++)
		{
			if(data.footer[i] != NULL) ckfree(data.footer[i]);
			data.footer[i]=NULL;
		}
		ckfree(data.footer);
		data.footer=NULL;
	}
	if (data.consensus!=NULL)
	{
		ckfree(data.consensus);
		data.consensus=NULL;
	}
	if (data.lines!=NULL)
	{
		for (i=0;i<data.nseqs;i++)
		{
			if(data.lines[i] != NULL) ckfree(data.lines[i]);
			data.lines[i]=NULL;
		}
		ckfree(data.lines);
		data.lines=NULL;
	}
	if (data.colormask!=NULL)
	{
		for (i=0;i<data.nseqs;i++)
		{
			if(data.colormask[i] != NULL) ckfree(data.colormask[i]);
			data.colormask[i]=NULL;
		}
		ckfree(data.colormask);
		data.colormask=NULL;
	}
	if (data.selected!=NULL) ckfree(data.selected);
	data.selected=NULL;

	if (data.seqweight!=NULL) ckfree(data.seqweight);
	data.seqweight=NULL;
	if (data.subgroup!=NULL) ckfree(data.subgroup);
	data.subgroup=NULL;
	if (data.colscore!=NULL) ckfree(data.colscore);
	data.colscore=NULL;
	if (data.residue_exception!=NULL)
	{
		for (i=0;i<data.nseqs;i++)
		{
			if(data.residue_exception[i] != NULL) ckfree(data.residue_exception[i]);
			data.residue_exception[i]=NULL;
		}
		ckfree(data.residue_exception);
		data.residue_exception=NULL;
	}
	if (data.segment_exception!=NULL)
	{
		for (i=0;i<data.nseqs;i++)
		{
			if(data.segment_exception[i] != NULL) ckfree(data.segment_exception[i]);
			data.segment_exception[i]=NULL;
		}
		ckfree(data.segment_exception);
		data.segment_exception=NULL;
	}

	return(data);
}


void make_consensus(panel_data data,char *name,char *seq1)
{
 	char c;
	sint catident1[NUMRES],catident2[NUMRES],ident;
	sint i,j,k,l;


	strcpy(name,"");    
    	for(i=0; i<data.ncols; i++) {
			seq1[i]=' ';
			ident=0;
			for(j=0;res_cat1[j]!=NULL;j++) catident1[j] = 0;
			for(j=0;res_cat2[j]!=NULL;j++) catident2[j] = 0;
			for(j=0;j<data.nseqs;++j) {
				if(isalpha(data.lines[0][i])) {
					if(data.lines[0][i] == data.lines[j][i])
					++ident;
					for(k=0;res_cat1[k]!=NULL;k++) {
					        for(l=0;(c=res_cat1[k][l]);l++) {
					        if (c=='\0') break;
							if (data.lines[j][i]==c)
							{
								catident1[k]++;
								break;
							}
						}
					}
					for(k=0;res_cat2[k]!=NULL;k++) {
					        for(l=0;(c=res_cat2[k][l]);l++) {
					        if (c=='\0') break;
							if (data.lines[j][i]==c)
							{
								catident2[k]++;
								break;
							}
						}
					}
				}
			}
			if(ident==data.nseqs)
				seq1[i]='*';
			else if (!dnaflag) {
				for(k=0;res_cat1[k]!=NULL;k++) {
					if (catident1[k]==data.nseqs) {
						seq1[i]=':';
						break;
					}
				}
				if(seq1[i]==' ')
				for(k=0;res_cat2[k]!=NULL;k++) {
					if (catident2[k]==data.nseqs) {
						seq1[i]='.';
						break;
					}
				}
			}
		}
}

int make_struct_data(int prf_no,int len, char *name,char *seq)
{
	int i,n=0;
	char val;
        char *ss_mask;
 
	seq[0]='\0';
	name[0]='\0';
if (prf_no == 1)
{
        if (struct_penalties1 == SECST && use_ss1 == TRUE) {
		n=1;
		strcpy(name,"Structures");
                ss_mask = (char *)ckalloc((seqlen_array[1]+10) * sizeof(char));
                for (i=0;i<seqlen_array[1];i++)
                        ss_mask[i] = sec_struct_mask1[i];
                print_sec_struct_mask(seqlen_array[1],sec_struct_mask1,ss_mask)
;
                for(i=0; i<len; i++) {
                        val=ss_mask[i];
                        if (val == gap_pos1)
                                seq[i]='-';
                        else
                                seq[i]=val;
                }
                seq[i]=EOS;
        	ckfree(ss_mask);
        }
 
}
else if (prf_no == 2)
{
        if (struct_penalties2 == SECST && use_ss2 == TRUE) {
		n=1;
		strcpy(name,"Structures");
                ss_mask = (char *)ckalloc((seqlen_array[profile1_nseqs+1]+10) *
sizeof(char));
                for (i=0;i<seqlen_array[profile1_nseqs+1];i++)
                        ss_mask[i] = sec_struct_mask2[i];
                print_sec_struct_mask(seqlen_array[profile1_nseqs+1],sec_struct_mask2,ss_mask);
       
                for(i=0; i<len; i++) {
                        val=ss_mask[i];
                        if (val == gap_pos1)
                                seq[i]='-';
                        else
                                seq[i]=val;
                }
                seq[i]=EOS;
       		ckfree(ss_mask);
       }
}
	return(n);
}

int make_gp_data(int prf_no,int len, char *name,char *seq)
{
	int i,n=0;
	char val;

	seq[0]='\0';
	name[0]='\0';
if (prf_no == 1)
{
        if (struct_penalties1 == GMASK && use_ss1 == TRUE) {
		n=1;
		strcpy(name,"Gap Penalties");
                for(i=0; i<len; i++) {
                        val=gap_penalty_mask1[i];
                        if (val == gap_pos1)
                                seq[i]='-';
                        else
                                seq[i]=val;
                }
                seq[i]=EOS;
        }
}
else if (prf_no == 2)
{
        if (struct_penalties2 == GMASK && use_ss2 == TRUE) {
		n=1;
		strcpy(name,"Gap Penalties");
                for(i=0; i<len; i++) {
                        val=gap_penalty_mask2[i];
                        if (val == gap_pos1)
                                seq[i]='-';
                        else
                                seq[i]=val;
                }
                seq[i]=EOS;
        }
}
	return(n);
}

static void VscrollMulti(BaR bar, GraphiC p, Nlm_Int2 newval, Nlm_Int2 oldval)
{
	active_panel=seq_panel;
	vscrollnames(bar, newval, oldval);
	vscrollseqs(bar, newval, oldval);
}

static void HscrollMultiN(BaR bar, GraphiC p, Nlm_Int2 newval, Nlm_Int2 oldval)
{
	active_panel=seq_panel;
	hscrollnames(bar, newval, oldval);
}

static void HscrollMultiS(BaR bar, GraphiC p, Nlm_Int2 newval, Nlm_Int2 oldval)
{
	active_panel=seq_panel;
	hscrollseqs(bar, newval, oldval);
}

static void VscrollPrf1(BaR bar, GraphiC p, Nlm_Int2 newval, Nlm_Int2 oldval)
{
	active_panel=prf_panel[0];
	vscrollnames(bar, newval, oldval);
	vscrollseqs(bar, newval, oldval);
}

static void HscrollPrf1N(BaR bar, GraphiC p, Nlm_Int2 newval, Nlm_Int2 oldval)
{
	active_panel=prf_panel[0];
	hscrollnames(bar, newval, oldval);
}

static void HscrollPrf1S(BaR bar, GraphiC p, Nlm_Int2 newval, Nlm_Int2 oldval)
{
	active_panel=prf_panel[0];
	hscrollseqs(bar, newval, oldval);
	if(fixed_prf_scroll==TRUE)
	{
		active_panel=prf_panel[1];
		hscrollseqs(bar, newval, oldval);
	}
}

static void VscrollPrf2(BaR bar, GraphiC p, Nlm_Int2 newval, Nlm_Int2 oldval)
{
	active_panel=prf_panel[1];
	vscrollnames(bar, newval, oldval);
	vscrollseqs(bar, newval, oldval);
}

static void HscrollPrf2N(BaR bar, GraphiC p, Nlm_Int2 newval, Nlm_Int2 oldval)
{
	active_panel=prf_panel[1];
	hscrollnames(bar, newval, oldval);
}

static void HscrollPrf2S(BaR bar, GraphiC p, Nlm_Int2 newval, Nlm_Int2 oldval)
{
	if(fixed_prf_scroll==TRUE)
	{
		active_panel=prf_panel[0];
		hscrollseqs(bar, newval, oldval);
	}
	active_panel=prf_panel[1];
	hscrollseqs(bar, newval, oldval);
}