xmenu.c

经典生物信息学多序列比对工具clustalw

  
  if (par_file != NULL)
    ckfree(par_file);
  par_file=(char *)ckalloc(FILENAMELEN*sizeof(char));

  if (!GetInputFileName (par_file,FILENAMELEN,"par","")) return; 
  
  
  /* GetTitle(readfiletext, filename, FILENAMELEN); */
  /*  stripspace(filename); */
 
  if (explicit_par_file != NULL)
    ckfree(explicit_par_file);
  explicit_par_file=(char *)ckalloc(FILENAMELEN*sizeof(char));
  /*  if (par_file != NULL)
    ckfree(par_file);
    par_file=(char *)ckalloc(FILENAMELEN*sizeof(char)); 
    strcpy(explicit_par_file,filename); */

  strcpy(explicit_par_file,par_file);
  /*strcpy(par_file,filename); */
  info("Loading color file: %s\n",par_file);
  init_color_parameters(par_file);
  if (Visible(readfilew))
    {
      Remove(readfilew);
      readfilew=NULL;
    }
  if (aln_mode == MULTIPLEM)
    color_seqs();
  else
    {
      color_prf1();
      color_prf2();
    }
  usebw=FALSE;
  usedefcolors=FALSE;
  useusercolors=TRUE;
  SetStatus(bw_item,usebw);
  SetStatus(defcol_item,usedefcolors);
  SetStatus(usercol_item,useusercolors);
  info("Done.");
}

static void RemoveGapPos(IteM item)
{
	int i,j,sl;
	Boolean sel=FALSE;

	if (nseqs==0)
	{
		Message(MSG_OK,"No file loaded.");
		return;
	}
	/*  no need for a confirmation!  Ramu
	if (Message(MSG_YN,"Remove positions that contain gaps in all sequences ?")==ANS_NO)
		return;
	*/
	if(aln_mode==MULTIPLEM)
	{
		remove_gap_pos(1,nseqs,0);
		load_aln(seq_panel,0,nseqs-1,FALSE);
	}
	else
	{
		remove_gap_pos(1,profile1_nseqs,1);
		load_aln(prf_panel[0],0,profile1_nseqs-1,FALSE);
		remove_gap_pos(profile1_nseqs+1,nseqs,2);
		load_aln(prf_panel[1],profile1_nseqs,nseqs-1,FALSE);
	}
	/*	info("Gap positions removed.");*/
	info("All the columns that contains only the gaps, are removed!");
}


static void RemoveGaps(IteM item)
{
	int i,j,sl;
	panel_data data;
	Boolean sel=FALSE;

	if (nseqs==0)
	{
		Message(MSG_OK,"No file loaded.");
		return;
	}
	GetPanelExtra(active_panel.names,&data);
	for (i=0;i<data.nseqs;i++)
		if(data.selected[i]==TRUE)
		{
			sel=TRUE;
			break;
		}
	if(sel==FALSE)
	{
		Message(MSG_OK,"Select sequences by clicking on the names.");
		return;
	}

	if (Message(MSG_YN,"Remove gaps from selected sequences ?")==ANS_NO)
		return;

	for (i=data.firstseq+1;i<=data.firstseq+data.nseqs;i++)
		if(data.selected[i-data.firstseq-1]==TRUE)
		{
                	sl=0;
                	for(j=1;j<=seqlen_array[i];++j) {
                        	if((seq_array[i][j] == gap_pos1) ||
                        	   (seq_array[i][j] == gap_pos2)) continue;
                        	++sl;
                        	seq_array[i][sl]=seq_array[i][j];
                	}
                        seq_array[i][sl+1]=-3;
                	seqlen_array[i]=sl;
		}
	load_aln(active_panel,data.firstseq,data.firstseq+data.nseqs-1,FALSE);
	active_panel.modified=TRUE;
	info("Gaps in selected sequences removed.");
}

static void CutSequences(IteM item)
{
	int i,pos;
	Boolean sel=FALSE;
	panel_data data;

	if (nseqs==0)
	{
		Message(MSG_OK,"No file loaded.");
		return;
	}

	GetPanelExtra(active_panel.names,&data);
	for (i=0;i<data.nseqs;i++)
		if(data.selected[i]==TRUE)
		{
			sel=TRUE;
			pos=i;
			break;
		}
	if(sel==FALSE)
	{
		Message(MSG_OK,"Select sequences to be cut by clicking on the names.");
		return;
	}

	/*	if(ncutseqs>0)
	{
		if (Message(MSG_YN,"The previously cut sequences will be lost.\nDo you want to continue?")==ANS_NO) return;
	}
	*/
	if (saveseqlen_array!=NULL) ckfree(saveseqlen_array);
	if (saveseq_array!=NULL)
	{
		for(i=0;i<ncutseqs;i++)
		{
			if (saveseq_array[i]!=NULL) ckfree(saveseq_array[i]);
		}
		ckfree(saveseq_array);
	}
	if (savetitles!=NULL)
	{
		for(i=0;i<ncutseqs;i++)
		{
			if (savetitles[i]!=NULL) ckfree(savetitles[i]);
		}
		ckfree(savetitles);
	}
	if (savenames!=NULL)
	{
		for(i=0;i<ncutseqs;i++)
		{
			if (savenames[i]!=NULL) ckfree(savenames[i]);
		}
		ckfree(savenames);
	}
	ncutseqs=0;

	savenames=(char **)ckalloc((data.nseqs+1) * sizeof(char *));
	savetitles=(char **)ckalloc((data.nseqs+1) * sizeof(char *));
	saveseq_array=(char **)ckalloc((data.nseqs+1) * sizeof(char *));
	saveseqlen_array=(sint *)ckalloc((data.nseqs+1) * sizeof(sint));
	for(i=0;i<data.nseqs;i++)
	{
		savenames[i]=NULL;
		savetitles[i]=NULL;
		saveseq_array[i]=NULL;
	}
	if (data.prf_no == 0)
		cut_multiplem();
	else if (data.prf_no == 1)
		cut_profile1();
	else if (data.prf_no == 2)
		cut_profile2();

	GetPanelExtra(active_panel.names,&data);
	if(pos>=data.nseqs) pos=data.nseqs-1;
	if(data.nseqs>0)
		data.selected[pos]=TRUE;
	SetPanelExtra(active_panel.names,&data);
	DrawPanel(active_panel.names);

	active_panel.modified=TRUE;
	info("Cut %d sequences.",ncutseqs);
}

static void cut_multiplem(void)
{
	int i,j;
	panel_data data;

        GetPanelExtra(active_panel.names,&data);
	for (i=data.nseqs;i>0;i--)
	{
		if(data.selected[i-1]==TRUE)
		{
			ssave(i);
			for(j=i;j<data.nseqs;j++)
				sscpy(j,j+1);
		}
	}
        nseqs-=ncutseqs;
        if (nseqs<=0) empty=TRUE;
	if (ncutseqs>0)
		if(nseqs<=data.vseqs)
			load_aln(active_panel,0,nseqs-1,TRUE);
		else
			load_aln(active_panel,0,nseqs-1,FALSE);
}

static void cut_profile1(void)
{
	int i,j;
	panel_data data;

        GetPanelExtra(active_panel.names,&data);
	for (i=data.nseqs;i>0;i--)
	{
		if(data.selected[i-1]==TRUE)
		{
			ssave(i);
			for(j=i;j<nseqs;j++)
				sscpy(j,j+1);
		}
	}
        profile1_nseqs-=ncutseqs;
	nseqs-=ncutseqs;
        if (profile1_nseqs<=0) profile1_empty=TRUE;
        if (nseqs<=0) empty=TRUE;
	if (ncutseqs>0)
	{
		if(profile1_nseqs<=data.vseqs)
			load_aln(active_panel,0,profile1_nseqs-1,TRUE);
		else
			load_aln(active_panel,0,profile1_nseqs-1,FALSE);
		if (!profile2_empty)
			load_aln(prf_panel[1],profile1_nseqs,nseqs-1,FALSE);
	}
}

static void cut_profile2(void)
{
	int i,j;
	panel_data data;

        GetPanelExtra(active_panel.names,&data);
	for (i=data.nseqs;i>0;i--)
	{
		if(data.selected[i-1]==TRUE)
		{
			ssave(i+profile1_nseqs);
			for(j=i+profile1_nseqs;j<nseqs;j++)
				sscpy(j,j+1);
		}
	}
        nseqs-=ncutseqs;
        if (nseqs-profile1_nseqs<=0) profile2_empty=TRUE;
        if (nseqs<=0) empty=TRUE;
	if (ncutseqs>0)
		if(nseqs-profile1_nseqs<=data.vseqs)
			load_aln(active_panel,profile1_nseqs,nseqs-1,FALSE);
		else
			load_aln(active_panel,profile1_nseqs,nseqs-1,TRUE);
}

static void PasteSequences(IteM item)
{
	int insert;
	int i,n;
	panel_data data;

	if (ncutseqs<=0)
	{
		Message(MSG_OK,"No sequences available for pasting.\n"
                  " Cut selected sequences first.");
		 return;
	}

	GetPanelExtra(active_panel.names,&data);
	n=ncutseqs;
	insert=-1;
        if (data.nseqs>0)
        {
                for(i=data.nseqs-1;i>=0;i--)
                        if(data.selected[i]==TRUE)
                        {
                                insert=i;
                                break;
                        }
                if (insert==-1)
                {
                        Message(MSG_OK,"Select a sequence by clicking on the name.\n"
                        " Cut sequences will be pasted after this one.");
			return;
                }
        }

	if (data.prf_no == 2)
	{
		insert += profile1_nseqs;
		for(i=profile1_nseqs+data.nseqs;i>insert+1;i--)
			sscpy(i+ncutseqs,i);
		for(i=1;ncutseqs>0;i++)
			sload(insert+i+1);
	}


       	else
	{
		for(i=nseqs;i>insert+1;i--)
			sscpy(i+ncutseqs,i);
		for(i=1;ncutseqs>0;i++)
			sload(insert+i+1);
	}

        if(data.prf_no==0)
        {
                nseqs=data.nseqs+n;
                if (nseqs>0) empty=FALSE;
		load_aln(seq_panel,0,nseqs-1,FALSE);
        }
        else if(data.prf_no==1)
        {
                profile1_nseqs=data.nseqs+n;
                nseqs+=n;
                if (profile1_nseqs>0) profile1_empty=FALSE;
		load_aln(active_panel,0,profile1_nseqs-1,FALSE);
		if (!profile2_empty)
			load_aln(prf_panel[1],profile1_nseqs,nseqs-1,FALSE);
        }
        else if(data.prf_no==2)
        {
                nseqs=profile1_nseqs+data.nseqs+n;
                if (profile1_nseqs<nseqs)
		{
			profile2_empty=FALSE;
			empty=FALSE;
		}
/*
		load_aln(prf_panel[0],0,profile1_nseqs-1,FALSE);
*/
		load_aln(prf_panel[1],profile1_nseqs,nseqs-1,FALSE);
        }

	active_panel.modified=TRUE;
	info("Pasted %d sequences.",n);
}

/* copies a sequence from clustal arrays position j to temp arrays */
static void ssave(int j)
{
	int k;

	if (saveseq_array[ncutseqs] != NULL) ckfree(saveseq_array[ncutseqs]);
	if (savenames[ncutseqs] != NULL) ckfree(savenames[ncutseqs]);
	if (savetitles[ncutseqs] != NULL) ckfree(savetitles[ncutseqs]);
	savenames[ncutseqs]=(char *)ckalloc((MAXNAMES+2)*sizeof(char));
	savetitles[ncutseqs]=(char *)ckalloc((MAXTITLES+2)*sizeof(char));

	strcpy(savenames[ncutseqs],names[j]);
	strcpy(savetitles[ncutseqs],titles[j]);
	saveseqlen_array[ncutseqs]=seqlen_array[j];
	saveseq_array[ncutseqs]=(char *)ckalloc((seqlen_array[j]+2)*sizeof(char));
	for(k=1;k<=seqlen_array[j];k++)
		saveseq_array[ncutseqs][k]=seq_array[j][k];
	saveseq_array[ncutseqs][k]= -3;
	ncutseqs++;
}

/* copies a sequence from clustal arrays position i to position j */
static void sscpy(int i,int j)
{
	int k;


	strcpy(names[i],names[j]);
	strcpy(titles[i],titles[j]);
	seqlen_array[i]=seqlen_array[j];
	realloc_seq(i,seqlen_array[i]);

	for(k=1;k<=seqlen_array[j];k++)
		seq_array[i][k]=seq_array[j][k];
	seq_array[i][k]= -3;
}

/* copies last sequence in temp arrays to clustal arrays after entry i */
static void sload(int i)
{
	int k;

	if (ncutseqs<1) return;

	ncutseqs--;
	strcpy(names[i],savenames[ncutseqs]);
	strcpy(titles[i],savetitles[ncutseqs]);
	seqlen_array[i]=saveseqlen_array[ncutseqs];
	realloc_seq(i,seqlen_array[i]);
	for(k=1;k<=seqlen_array[i];k++)
		seq_array[i][k]=saveseq_array[ncutseqs][k];
	seq_array[i][k]= -3;
}

static void SelectSeqs(IteM item)
{
	select_seqs(seq_panel,TRUE);
}

static void SelectPrf1(IteM item)
{
	select_seqs(prf_panel[0],TRUE);
}

static void SelectPrf2(IteM item)
{
	select_seqs(prf_panel[1],TRUE);
}

static void MergeProfiles(IteM item)
{
        if (profile2_empty)
        {
                error("Profile 2 not loaded");
                return;
        }
	profile_no=1;
	profile1_nseqs=nseqs;
	profile2_empty=TRUE;
	load_aln(prf_panel[0],0,profile1_nseqs-1,FALSE);
	load_aln(prf_panel[1],profile1_nseqs,nseqs-1,FALSE);
	active_panel=prf_panel[0];

	info("Added Profile 2 to Profile 1.");
}


static void ClearSeqRange(IteM item)
{
	if(aln_mode==MULTIPLEM)
		clear_seqrange(seq_panel);
	else
	{
		clear_seqrange(prf_panel[1]);
		clear_seqrange(prf_panel[0]);
	}
}

static void ClearSeqs(IteM item)
{
	if(aln_mode==MULTIPLEM)
		select_seqs(seq_panel,FALSE);
	else
	{
		select_seqs(prf_panel[1],FALSE);
		select_seqs(prf_panel[0],FALSE);
	}
}

static void clear_seqrange(spanel p)
{
	int f,l;
	panel_data data;

	GetPanelExtra(p.seqs,&data);
	f=data.firstsel;
	l=data.lastsel;
	data.firstsel=data.lastsel=-1;
	SetPanelExtra(p.seqs,&data);
	highlight_seqrange(p.seqs,f,l,NORMAL);
}

static void select_seqs(spanel p,Boolean flag)
{
	int i;
	panel_data data;

	GetPanelExtra(p.names,&data);
	if (data.nseqs == 0) return;

	for (i=0;i<data.nseqs;i++)
		data.selected[i]=flag;

	SetPanelExtra(p.names,&data);
	draw_names(p.names);
	if(flag==TRUE) active_panel=p;
}

static void CAlignWin (IteM item)
{
        if (empty)
        {
                error("No sequences loaded");
                return;
        }
        if (nseqs <= 1)
	{
                error("Alignment has only %d sequences",nseqs);
                return;
        }
	do_align_window(&calignw,&ctreetext,NEW,"Complete Alignment",CompleteAlign);
}

void CompleteAlign(ButtoN but)
{
	char phylip_name[FILENAMELEN];

    float et