malacology
/
staden-lg
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity
staden-lg/src/staden/searchUtils.c

1255 lines
30 KiB
C
Raw Permalink Blame History

/*
** Search functions for the contig editor
**
** This file is split into two parts, probably implying that it should be
** divided into two files. The first half consists of all the search
** engines, the second half the user interface code.
**
** Observations:
** Only one search window can be up at one time.
**
** Changes:
**
** 7-Nov-1991 SD Select the tag when searching on tag.
** 20-Feb-1992 SD Renamed "OK" button to "Quit"
** 29-Apr-1992 SD Changes relevant to general speedup in edUtils.c
** 11-May-1992 SD Search by name now dependant on cursor position
** 15-May-1992 SD now NOSTRSTR and NOSTRDUP
**
*/
#define REDISPLAY(X) setDisplayPos((X),positionInContig((X),(X)->cursorSeq,(X)->cursorPos))
/*
** The first half
*/
#include <stdio.h>
#include <stdlib.h>
#include "edUtils.h"
#include "tagUtils.h"
#include "searchUtils.h"
#include "select.h"
#include "string.h"
#include "ctype.h"
#include "misc.h"
/*
** Prototypes
*/
extern char *re_comp(char *s);
extern int re_exec(char *s);
#define in_interval(A,B,C) ( ((A)<(B))?((A)<=(C) && (C)<=(B)):((B)<=(C) && (C)<=(A)) )
/*
** We don't want to have all the textwidget translations
** Here are the list of the ones we want.
** This is taken from Xaw/TextTr.c source
*/
static char *defaultTranslations = "\
<Key>Right: forward-character() \n\
<Key>Left: backward-character() \n\
<Key>Delete: delete-previous-character() \n\
<Key>BackSpace: delete-previous-character() \n\
<Key>: insert-char() \n\
<FocusIn>: focus-in() \n\
<FocusOut>: focus-out() \n\
<Btn1Down>: select-start() \n\
<Btn1Motion>: extend-adjust() \n\
<Btn1Up>: extend-end(PRIMARY, CUT_BUFFER0) \n\
<Btn2Down>: insert-selection(PRIMARY, CUT_BUFFER0) \n\
<Btn3Down>: extend-start() \n\
<Btn3Motion>: extend-adjust() \n\
<Btn3Up>: extend-end(PRIMARY, CUT_BUFFER0) \
";
static void my_translations(Widget w)
/*
** Use my default translations
*/
{
XtTranslations parsedTranslations;
parsedTranslations = XtParseTranslationTable(defaultTranslations);
XtUninstallTranslations(w);
XtAugmentTranslations(w,parsedTranslations);
}
static int findGelByNumber (EdStruct *xx, char *s)
/*
** Position cursor on left end of gel sequence matched by string s.
** If s starts with a slash '/' assume a gel name is specified.
** Otherwise assume a gel number is specified.
*/
{
int i;
int gel;
gel = atoi(s);
for (i=1; i <= xx->DB_gelCount; i++) {
if (DBgetNumber(xx,i) == gel) {
xx->cursorSeq = i;
xx->cursorPos = 1;
REDISPLAY(xx);
return 1;
}
}
return 0;
}
static int findNextByName(EdStruct *xx, char *s)
/*
** Search forwards from the cursor position until the sequence specified
** is found. The cursor is positioned at the left end of the sequence,
** if found.
**
*/
{
int spos = positionInContig(xx,xx->cursorSeq,xx->cursorPos)+1;
int i;
int n;
if (!*s) return 0;
n = strlen(s);
if ((i = posToIndex(xx,spos))==0) return 0;
for (; i <= xx->DB_gelCount; i++) {
/* search through tag list for sequence */
if (strncmp(DBgetGelName(xx,xx->DBorder[i]),s,n)==0) {
xx->cursorSeq = xx->DBorder[i];
xx->cursorPos = 1;
REDISPLAY(xx);
return 1;
}
}
return 0;
}
static int findPrevByName(EdStruct *xx, char *s)
/*
** Search forwards from the cursor position until the sequence specified
** is found. The cursor is positioned at the left end of the sequence,
** if found.
**
*/
{
int spos = positionInContig(xx,xx->cursorSeq,xx->cursorPos)-1;
int i;
int n;
if (!*s) return 0;
n = strlen(s);
if ((i = posToIndex(xx,spos))==0) return 0;
for (i--; i >= 0 ; i--) {
/* search through tag list for sequence */
if (strncmp(DBgetGelName(xx,xx->DBorder[i]),s,n)==0) {
xx->cursorSeq = xx->DBorder[i];
xx->cursorPos = 1;
REDISPLAY(xx);
return 1;
}
}
return 0;
}
static int findNextGelByName (EdStruct *xx, char *s)
/*
** Position cursor on left end of gel sequence matched by string s.
** If s starts with a slash '/' assume a gel name is specified.
** Otherwise assume a gel number is specified.
*/
{
if (*s) {
if (*s == '/') {
s++;
return findNextByName(xx,s);
} else
return findGelByNumber(xx,s);
}
return 0;
}
static int findPrevGelByName (EdStruct *xx, char *s)
/*
** Position cursor on left end of gel sequence matched by string s.
** If s starts with a slash '/' assume a gel name is specified.
** Otherwise assume a gel number is specified.
*/
{
if (*s) {
if (*s == '/') {
s++;
return findPrevByName(xx,s);
} else
return findGelByNumber(xx,s);
}
return 0;
}
static int findNextTagByType (EdStruct *xx, char *type)
/*
** Search forwards from the cursor position until a tag of a specified
** type is encountered. The cursor is positioned at the left end of the
** tag, if found.
*/
{
int spos = positionInContig(xx,xx->cursorSeq,xx->cursorPos)+1;
int epos = DBgetLength(xx,0);
int fpos,fseq,i;
int fseqpos;
int *seqList;
tagStruct *found_tag;
seqList = sequencesInRegion(xx,spos, epos);
fseq = 0;
fseqpos = 0;
fpos = epos + 1;
for (i=0; seqList[i] && DBgetRelPos(xx,seqList[i]) < fpos ; i++) {
/* search through tag list for sequence */
int seq = seqList[i];
tagStruct *t;
t = (tagStruct *) DBgetTags(xx,seq);
while (t != NULL) {
int normpos;
int tagpos;
normpos = normalisePos(xx,seq,t->tagrec.position,t->tagrec.length);
tagpos=positionInContig(xx,seq,normpos);
if (!(t->flags & TAG_DELETED) &&
in_interval(spos,fpos,tagpos) &&
strncmp(t->tagrec.type.c,type,4)==0) {
fseq = seq;
fseqpos = normpos;
fpos = tagpos;
found_tag = t;
if (DBgetComp(xx,seq) == COMPLEMENTED)
/* Keep looking */
t = t->next;
else
/* Stop now */
t = NULL;
} else
t = t->next;
}
}
if (fseq) {
xx->cursorSeq = fseq;
xx->cursorPos = fseqpos;
_select_tag(xx,fseq,found_tag);
REDISPLAY(xx);
}
return fseq;
}
static int findPrevTagByType (EdStruct *xx, char *type)
/*
** Search backwards from the current cursor position until a tag of the
** specified type is encountered. The cursor is positioned at the left
** end of the tag, if found.
*/
{
int spos = positionInContig(xx,xx->cursorSeq,xx->cursorPos)-1;
int epos = 1;
int fpos,fseq,i;
int fseqpos;
int *seqList;
tagStruct *found_tag;
seqList = sequencesInRegion(xx,epos, spos);
fseq = 0;
fseqpos = 0;
fpos = epos - 1;
for (i=0; seqList[i]; i++) ;
for (i--; i>=0 && DBgetRelPos(xx,seqList[i])+DBgetLength(xx,seqList[i]) > fpos ; i--) {
/* search through tag list for sequence */
int seq = seqList[i];
tagStruct *t;
t = (tagStruct *) DBgetTags(xx,seq);
while (t != NULL) {
int normpos;
int tagpos;
normpos = normalisePos(xx,seq,t->tagrec.position,t->tagrec.length);
tagpos = positionInContig(xx,seq,normpos);
if (!(t->flags & TAG_DELETED) &&
in_interval(spos,fpos,tagpos) &&
strncmp(t->tagrec.type.c,type,4)==0) {
fseq = seq;
fseqpos = normpos;
fpos = tagpos;
found_tag = t;
if (DBgetComp(xx,seq) != COMPLEMENTED)
/* Keep looking */
t = t->next;
else
/* Stop now */
t = NULL;
} else
t = t->next;
}
}
if (fseq) {
xx->cursorSeq = fseq;
xx->cursorPos = fseqpos;
_select_tag(xx,fseq,found_tag);
REDISPLAY(xx);
}
return fseq;
}
static int findNextSequence(EdStruct *xx, char *s)
/*
** Search forwards from the cursor position until the sequence specified
** is found. The cursor is positioned at the left end of the sequence,
** if found.
**
** Observations:
** The search is done on a reading by reading basis, rather than from
** the consensus.
** The search is not case sensitive.
*/
{
int spos = positionInContig(xx,xx->cursorSeq,xx->cursorPos)+1;
int epos = DBgetLength(xx,0);
int fpos,fseq,i;
int fseqpos;
int *seqList;
char *reading;
int maxlen;
seqList = sequencesInRegion(xx,spos, epos);
fseq = 0;
fseqpos = 0;
fpos = epos + 1;
for (maxlen = 0, i=0; seqList[i] ; i++)
maxlen = max(maxlen, DBgetLength(xx,seqList[i]));
reading = malloc(maxlen+1);
for (i=0; seqList[i] && DBgetRelPos(xx,seqList[i]) < fpos ; i++) {
/* search through tag list for sequence */
int seq = seqList[i];
char *str;
char *ind;
str = DBgetSeq(xx,seq);
strncpy(reading,str,DBgetLength(xx,seq));
reading[DBgetLength(xx,seq)] = '\0';
if (in_interval(1,DBgetLength(xx,seq),spos - DBgetRelPos(xx,seq)+1)) {
int offset = spos - DBgetRelPos(xx,seq);
ind = strstr(reading + offset,s);
} else
ind = strstr(reading,s);
if (ind != NULL) {
int pos;
pos = positionInContig(xx,seq,(int) (ind - reading) + 1);
if (in_interval(spos,fpos,pos)) {
fseqpos = (int) (ind - reading) + 1;
fpos = pos;
fseq = seq;
}
}
}
if (fseq) {
xx->cursorSeq = fseq;
xx->cursorPos = fseqpos;
REDISPLAY(xx);
}
free(reading);
return fseq;
}
static void reverse_str(char *s, int len)
/*
** Verse the character sequence of a string
*/
{
int i;
char temp;
for (i=0; i < len/2; i++) {
temp = s[i];
s[i] = s[len-i-1];
s[len-i-1] = temp;
}
}
static int findPrevSequence(EdStruct *xx, char *inseq)
/*
** Search backwards from the cursor position until the sequence specified
** is found. The cursor is positioned at the left end of the sequence,
** if found.
**
** Observations:
** The search is done on a reading by reading basis, rather than from
** the consensus.
** The search is not case sensitive.
*/
{
int spos = positionInContig(xx,xx->cursorSeq,xx->cursorPos)+strlen(inseq)-2;
int epos = 1;
int fpos,fseq,i;
int fseqpos;
int *seqList;
char *reading;
char *s;
int maxlen;
s = strdup(inseq);
reverse_str(s,strlen(s));
seqList = sequencesInRegion(xx,epos, spos);
fseq = 0;
fseqpos = 0;
fpos = epos - 1;
for (maxlen = 0, i=0; seqList[i] ; i++)
maxlen = max(maxlen, DBgetLength(xx,seqList[i]));
reading = malloc(maxlen+1);
for (i=0; seqList[i]; i++) ;
for (i--; i>=0 && DBgetRelPos(xx,seqList[i])+DBgetLength(xx,seqList[i]) > fpos ; i--) {
/* search through tag list for sequence */
int seq = seqList[i];
char *str;
char *ind;
str = DBgetSeq(xx,seq);
strncpy(reading,str,DBgetLength(xx,seq));
reading[DBgetLength(xx,seq)] = '\0';
reverse_str(reading,DBgetLength(xx,seq));
if (in_interval(1,DBgetLength(xx,seq),spos - DBgetRelPos(xx,seq)+1)) {
int offset = DBgetLength(xx,seq) - (spos - DBgetRelPos(xx,seq)+1);
ind = strstr(reading + offset,s);
} else
ind = strstr(reading,s);
if (ind != NULL) {
int pos;
pos = positionInContig(xx,
seq,
DBgetLength(xx,seq) - (int)(ind - reading) - strlen(s) + 1);
if (in_interval(spos,fpos,pos)) {
fseqpos = pos - DBgetRelPos(xx,seq) + 1;
fpos = pos;
fseq = seq;
}
}
}
if (fseq) {
xx->cursorSeq = fseq;
xx->cursorPos = fseqpos;
REDISPLAY(xx);
}
free(reading);
return fseq;
}
static int findNextAnno(EdStruct *xx, char *anno)
/*
** Search forwards from the cursor position until a tag containing the
** specified annotation is found. The cursor is positioned at the left
** end of the tag, if found.
**
** Observations:
** A regular expression search is found, giving unpredictable results
** to people unfamiliar with such searches
*/
{
int spos = positionInContig(xx,xx->cursorSeq,xx->cursorPos)+1;
int epos = DBgetLength(xx,0);
int fpos,fseq,i;
int fseqpos;
int *seqList;
char *error;
char *find_all = "$";
tagStruct *found_tag;
if (! *anno) anno = find_all;
error = re_comp(anno);
if (error != NULL) {
fprintf(stderr,"findNextAnno: %s\n",error);
return 0;
}
seqList = sequencesInRegion(xx,spos, epos);
fseq = 0;
fseqpos = 0;
fpos = epos + 1;
for (i=0; seqList[i] && DBgetRelPos(xx,seqList[i]) < fpos ; i++) {
/* search through tag list for sequence */
int seq = seqList[i];
tagStruct *t;
t = (tagStruct *) DBgetTags(xx,seq);
while (t != NULL) {
int normpos;
int tagpos;
int match;
/* Code isn't very efficient here! */
normpos = normalisePos(xx,seq,t->tagrec.position,t->tagrec.length);
tagpos=positionInContig(xx,seq,normpos);
/*
** Get annotation
*/
force_comment(t);
match = ( re_exec(t->newcomment) == 1);
if (!(t->flags & TAG_DELETED) &&
in_interval(spos,fpos,tagpos) &&
t->tagrec.type.c[0] != '*' && /* avoid special tags */
t->tagrec.position != 0 &&
match) {
fseq = seq;
fseqpos = normpos;
fpos = tagpos;
found_tag = t;
if (DBgetComp(xx,seq) == COMPLEMENTED)
/* Keep looking */
t = t->next;
else
/* Stop now */
t = NULL;
} else
t = t->next;
}
}
if (fseq) {
xx->cursorSeq = fseq;
xx->cursorPos = fseqpos;
_select_tag(xx,fseq,found_tag);
REDISPLAY(xx);
}
return fseq;
}
static int findPrevAnno(EdStruct *xx, char *anno)
/*
** Search backwards from the cursor position until a tag containing the
** specified annotation is found. The cursor is positioned at the left
** end of the tag, if found.
**
** Observations:
** A regular expression search is found, giving unpredictable results
** to people unfamiliar with such searches
*/
{
int spos = positionInContig(xx,xx->cursorSeq,xx->cursorPos)-1;
int epos = 1;
int fpos,fseq,i;
int fseqpos;
int *seqList;
char *error;
char *find_all = "$";
tagStruct *found_tag;
if (! *anno) anno = find_all;
error = re_comp(anno);
if (error != NULL) {
fprintf(stderr,"findPrevAnno: %s\n",error);
return 0;
}
seqList = sequencesInRegion(xx,epos, spos);
fseq = 0;
fseqpos = 0;
fpos = epos - 1;
for (i=0; seqList[i]; i++) ;
for (i--; i>=0 && DBgetRelPos(xx,seqList[i])+DBgetLength(xx,seqList[i]) > fpos ; i--) {
/* search through tag list for sequence */
int seq = seqList[i];
tagStruct *t;
t = (tagStruct *) DBgetTags(xx,seq);
while (t != NULL) {
int normpos;
int tagpos;
int match;
/* Code isn't very efficient here! */
normpos = normalisePos(xx,seq,t->tagrec.position,t->tagrec.length);
tagpos=positionInContig(xx,seq,normpos);
/*
** Get annotation
*/
force_comment(t);
match = ( re_exec(t->newcomment) == 1);
if (!(t->flags & TAG_DELETED) &&
in_interval(spos,fpos,tagpos) &&
t->tagrec.type.c[0] != '*' && /* avoid special tags */
t->tagrec.position != 0 &&
match) {
fseq = seq;
fseqpos = normpos;
fpos = tagpos;
found_tag = t;
if (DBgetComp(xx,seq) != COMPLEMENTED)
/* Keep looking */
t = t->next;
else
/* Stop now */
t = NULL;
} else
t = t->next;
}
}
if (fseq) {
xx->cursorSeq = fseq;
xx->cursorPos = fseqpos;
_select_tag(xx,fseq,found_tag);
REDISPLAY(xx);
}
return fseq;
}
static int findPosition(EdStruct *xx, char *text_pos)
/*
** Position the cursor at the position specified.
** There are three modes:
** 1. By position in contig. eg 30717
** 2. By position in a gel. eg @100
** 3. By a relative offset. eg +1000 eg -1000
**
** Observations:
** The cursor is positioned in the same gel if possible.
** If it possible to specify negative or large numbers when
** specifying position in gel.
*/
{
int pos;
int cseq = xx->cursorSeq;
int cpos = xx->cursorPos;
for(; *text_pos && isspace(*text_pos) ; text_pos++) ;
switch (*text_pos) {
case '\0':
return 0;
case '+':
case '-':
pos = positionInContig(xx,cseq,cpos) + atoi(text_pos);
break;
case '@':
pos = DBgetRelPos(xx,cseq) + atoi(++text_pos) - 1;
break;
default:
pos = atoi(text_pos);
break;
}
if (pos > 0 && pos <= DBgetLength(xx,0)) {
if ( in_interval(DBgetRelPos(xx,cseq),DBgetRelPos(xx,cseq)+DBgetLength(xx,cseq)-1,pos ) ) {
xx->cursorPos = pos - DBgetRelPos(xx,cseq) + 1;
} else {
xx->cursorSeq = 0;
xx->cursorPos = pos;
}
REDISPLAY(xx);
return 1;
}
return 0;
}
int findNextProblem (EdStruct *xx)
/*
** Search forward from the cursor position until a the consensus is not
** A, C, G or T. The cursor is positioned on the problem base, if found.
*/
{
#define SEARCH_CHUNKS MAX_DISPLAY_WIDTH
int spos = positionInContig(xx,xx->cursorSeq,xx->cursorPos)+1;
int epos = DBgetLength(xx,0);
char buffer[SEARCH_CHUNKS+1];
int i,width;
for (i=spos; i<= epos; i+=SEARCH_CHUNKS) {
width = min(epos-i+1,SEARCH_CHUNKS);
DBcalcConsensus (xx,i,width, buffer,BOTH_STRANDS);
{
int check = strcspn(buffer,"-*");
if (check != width) { /* we have problem! */
xx->cursorSeq = 0;
xx->cursorPos = i+check;
REDISPLAY(xx);
return 1;
}
}
}
return 0;
}
static int findPrevProblem (EdStruct *xx)
/*
** Search forward from the cursor position until a the consensus is not
** A, C, G or T. The cursor is positioned on the problem base, if found.
*/
{
#define SEARCH_CHUNKS MAX_DISPLAY_WIDTH
int spos = positionInContig(xx,xx->cursorSeq,xx->cursorPos)-1;
int epos = 1;
char buffer[SEARCH_CHUNKS+1];
int i,width;
int j;
for (i=spos; i>= epos; i-=SEARCH_CHUNKS) {
width = min(i-epos+1,SEARCH_CHUNKS);
DBcalcConsensus (xx,i-width+1,width, buffer, BOTH_STRANDS);
for (j=width-1;j>=0;j--) {
char *check = strchr("-*",buffer[j]);
if (check != NULL) { /* we have problem! */
xx->cursorSeq = 0;
xx->cursorPos = i-width+1+j;
REDISPLAY(xx);
return 1;
}
}
}
return 0;
}
static int qual_prob(char a, char b)
/*
** Returns true if character 'a' is out of sorts with character 'b'
*/
{
switch (a) {
case ' ':
return 0;
case '*':
case '-':
return 1;
default:
switch (b) {
case ' ':
return 0;
case '*':
case '-':
return 1;
default:
return (a != b);
}
}
}
static int findNextQualProb (EdStruct *xx)
/*
** Search forwards from the cursor position until a problem relating to
** quality is found. The cursor is positioned on the problematic base, if found.
**
** Observations:
** Large stretches of sequence on one strand only could cause frustration
*/
{
#define SEARCH_CHUNKS MAX_DISPLAY_WIDTH
int spos = positionInContig(xx,xx->cursorSeq,xx->cursorPos)+1;
int epos = DBgetLength(xx,0);
char buffer1[SEARCH_CHUNKS+1];
char buffer2[SEARCH_CHUNKS+1];
int i,width;
int j;
for (i=spos; i<= epos; i+=SEARCH_CHUNKS) {
width = min(epos-i+1,SEARCH_CHUNKS);
DBcalcConsensus (xx,i,width,buffer1,COMPLEMENTED);
DBcalcConsensus (xx,i,width,buffer2,UNCOMPLEMENTED);
for (j=0;j<width;j++)
{
if (qual_prob(buffer1[j],buffer2[j])) { /* we have problem! */
xx->cursorSeq = 0;
xx->cursorPos = i+j;
REDISPLAY(xx);
return 1;
}
}
}
return 0;
}
static int findPrevQualProb (EdStruct *xx)
/*
** Search backwards from the cursor position until a problem relating to
** quality is found. The cursor is positioned on the problematic base, if found.
**
** Observations:
** Large stretches of sequence on one strand only could cause frustration
*/
{
#define SEARCH_CHUNKS MAX_DISPLAY_WIDTH
int spos = positionInContig(xx,xx->cursorSeq,xx->cursorPos)-1;
int epos = 1;
char buffer1[SEARCH_CHUNKS+1];
char buffer2[SEARCH_CHUNKS+1];
int i,width;
int j;
for (i=spos; i>= epos; i-=SEARCH_CHUNKS) {
width = min(i-epos+1,SEARCH_CHUNKS);
DBcalcConsensus (xx,i-width+1,width,buffer1,COMPLEMENTED);
DBcalcConsensus (xx,i-width+1,width,buffer2,UNCOMPLEMENTED);
for (j=width-1;j>=0;j--) {
if (qual_prob(buffer1[j],buffer2[j])) { /* we have problem! */
xx->cursorSeq = 0;
xx->cursorPos = i-width+1+j;
REDISPLAY(xx);
return 1;
}
}
}
return 0;
}
/*
** The second half
*/
/*
** Widgets and things
*/
#include <X11/StringDefs.h>
#include <X11/Intrinsic.h>
#include <X11/Shell.h>
#include <X11/Xaw/Form.h>
#include <X11/Xaw/Label.h>
#include <X11/Xaw/Box.h>
#include <X11/Xaw/Toggle.h>
#include <X11/Xaw/Text.h>
#include <X11/Xaw/AsciiText.h>
#include <X11/Xaw/MenuButton.h>
#include <X11/Xaw/Command.h>
#include <ctype.h>
#include "edMenu.h"
#include "main.h"
#define FORWARDS 1
#define BACKWARDS 2
static EdStruct *XX;
static char tag_type[4];
static int up = 0;
static Widget oldFogieWid;
static Widget searchWid = NULL;
static Widget form;
static Widget label;
static Widget dir_box, backwards, forwards;
static Widget opt_box, by_pos, by_name, by_tag_type, by_tag_val, by_seq, by_prob, by_qual;
static Widget val_box, text, type;
static Widget act_box, search,quit;
static void searchCallback(Widget w, XtPointer client_data, XtPointer call_data)
/*
** Interrogate buttons to determine search direct and mode, and call
** the appropriate routine.
*/
{
char *text_str;
Arg args[10];
Cardinal nargs;
int found;
int option, isforwards;
nargs = 0;
XtSetArg(args[nargs], XtNstring, &text_str); nargs++;
XtGetValues(text,args,nargs);
option = (int) XawToggleGetCurrent(by_pos);
isforwards = ( FORWARDS == (int) XawToggleGetCurrent(forwards) );
if (isforwards) {
switch(option){
case OptByGelName:
found = findNextGelByName(XX,text_str);
break;
case OptByAnnotation:
found = findNextAnno(XX,text_str);
break;
case OptBySequence:
found = findNextSequence(XX,text_str);
break;
case OptByTagType:
found = findNextTagByType (XX, tag_type);
break;
case OptByPosition:
found = findPosition(XX,text_str);
break;
case OptByProblem:
found = findNextProblem(XX);
break;
case OptByQuality:
found = findNextQualProb(XX);
break;
}
} else {
switch(option){
case OptByGelName:
found = findPrevGelByName(XX,text_str);
break;
case OptByAnnotation:
found = findPrevAnno(XX,text_str);
break;
case OptBySequence:
found = findPrevSequence(XX,text_str);
break;
case OptByTagType:
found = findPrevTagByType (XX, tag_type);
break;
case OptByPosition:
found = findPosition(XX,text_str);
break;
case OptByProblem:
found = findPrevProblem(XX);
break;
case OptByQuality:
found = findPrevQualProb(XX);
break;
}
}
if (!found) XBell(GetDisplay(),100);
}
static void quitCallback(Widget w, XtPointer client_data, XtPointer call_data)
/*
** Leave the search window gracefully
*/
{
up = 0;
XtPopdown(searchWid);
}
#include "tagdb.h"
static void tagMenuCallback(Widget w, XtPointer client_data, XtPointer call_data)
/*
** The changing of the tag type - don't miss it!
*/
{
tag_db_struct *t = (tag_db_struct *) client_data;
setButtonName(type,t->type);
strncpy(tag_type,t->id,4);
}
static void create_search_wid(Widget parentWid)
/*
** Create the widgets for the search window.
*/
{
/*
** Label
** Search: [Backwards] [Forwards]
** Operation:
** [Position] [Gel Name]
** [Annotation Type] [Annotation Content]
** [Sequence] [Problems]
** Value: [ ] [Type]
** [Search] [Quit]
*/
Cardinal nargs;
Arg args[10];
Position x, y; /* top-left hand corner of new widget */
Dimension height; /* height of parent widget */
/*
** Determine the position on the screen for this widget
*/
#define fromVertWid (XX->edWid)
nargs = 0;
XtSetArg(args[nargs], XtNheight, &height); nargs++;
XtGetValues(fromVertWid, args, nargs);
XtTranslateCoords(fromVertWid, (Position) 0, (Position) height, &x, &y);
/*
** Create popup shell
*/
nargs = 0;
XtSetArg(args[nargs], XtNx, x); nargs++;
XtSetArg(args[nargs], XtNy, y); nargs++;
searchWid = XtCreatePopupShell("search", transientShellWidgetClass, parentWid, args, nargs);
/*
** Create main form
*/
nargs = 0;
form = XtCreateManagedWidget("form", formWidgetClass, searchWid, args, nargs);
/*
** Create title for form
*/
nargs = 0;
XtSetArg(args[nargs], XtNborderWidth, 0); nargs++;
XtSetArg(args[nargs], XtNlabel, "Search Window"); nargs++;
label = XtCreateManagedWidget("label", labelWidgetClass, form, args, nargs);
/*
** Create buttons for search direction
*/
nargs = 0;
XtSetArg(args[nargs], XtNfromVert, label); nargs++;
XtSetArg(args[nargs], XtNborderWidth, 0); nargs++;
#define XtOrientHorizontal "horizontal"
XtSetArg(args[nargs], XtNorientation, XtOrientHorizontal); nargs++;
dir_box = XtCreateManagedWidget("dir_box", boxWidgetClass, form, args, nargs);
nargs = 0;
XtSetArg(args[nargs], XtNborderWidth, 0); nargs++;
XtSetArg(args[nargs], XtNlabel, "Direction:"); nargs++;
(void) XtCreateManagedWidget("label", labelWidgetClass, dir_box, args, nargs);
nargs = 0;
XtSetArg(args[nargs],XtNradioData,BACKWARDS); nargs++;
backwards = XtCreateManagedWidget("backwards", toggleWidgetClass, dir_box, args, nargs);
nargs = 0;
XtSetArg(args[nargs],XtNradioGroup, backwards); nargs++;
XtSetArg(args[nargs],XtNstate, True); nargs++;
XtSetArg(args[nargs],XtNradioData,FORWARDS); nargs++;
forwards = XtCreateManagedWidget("forwards", toggleWidgetClass, dir_box, args, nargs);
/*
** Create buttons for operation selection
*/
nargs = 0;
XtSetArg(args[nargs], XtNfromVert, dir_box); nargs++;
XtSetArg(args[nargs], XtNborderWidth, 0); nargs++;
#define XtOrientHorizontal "horizontal"
XtSetArg(args[nargs], XtNorientation, XtOrientHorizontal); nargs++;
opt_box = XtCreateManagedWidget("opt_box", boxWidgetClass, form, args, nargs);
nargs = 0;
XtSetArg(args[nargs], XtNborderWidth, 0); nargs++;
XtSetArg(args[nargs], XtNlabel, "Search by:"); nargs++;
(void) XtCreateManagedWidget("label", labelWidgetClass, opt_box, args, nargs);
nargs = 0;
XtSetArg(args[nargs],XtNstate, True); nargs++;
XtSetArg(args[nargs],XtNlabel,"Position"); nargs++;
XtSetArg(args[nargs],XtNradioData,OptByPosition); nargs++;
by_pos = XtCreateManagedWidget("by_pos", toggleWidgetClass, opt_box, args, nargs);
nargs = 0;
XtSetArg(args[nargs],XtNradioGroup, by_pos); nargs++;
XtSetArg(args[nargs],XtNlabel,"Reading Name"); nargs++;
XtSetArg(args[nargs],XtNradioData,OptByGelName); nargs++;
by_name = XtCreateManagedWidget("by_name", toggleWidgetClass, opt_box, args, nargs);
nargs = 0;
XtSetArg(args[nargs],XtNradioGroup, by_pos); nargs++;
XtSetArg(args[nargs],XtNlabel,"Tag Type"); nargs++;
XtSetArg(args[nargs],XtNradioData,OptByTagType); nargs++;
by_tag_type = XtCreateManagedWidget("by_tag_type", toggleWidgetClass, opt_box, args, nargs);
nargs = 0;
XtSetArg(args[nargs],XtNradioGroup, by_pos); nargs++;
XtSetArg(args[nargs],XtNlabel,"Annotation"); nargs++;
XtSetArg(args[nargs],XtNradioData,OptByAnnotation); nargs++;
by_tag_val = XtCreateManagedWidget("by_tag_val", toggleWidgetClass, opt_box, args, nargs);
nargs = 0;
XtSetArg(args[nargs],XtNradioGroup, by_pos); nargs++;
XtSetArg(args[nargs],XtNlabel,"Sequence"); nargs++;
XtSetArg(args[nargs],XtNradioData,OptBySequence); nargs++;
by_seq = XtCreateManagedWidget("by_seq", toggleWidgetClass, opt_box, args, nargs);
nargs = 0;
XtSetArg(args[nargs],XtNradioGroup, by_pos); nargs++;
XtSetArg(args[nargs],XtNlabel,"Problem"); nargs++;
XtSetArg(args[nargs],XtNradioData,OptByProblem); nargs++;
by_prob = XtCreateManagedWidget("by_prob", toggleWidgetClass, opt_box, args, nargs);
nargs = 0;
XtSetArg(args[nargs],XtNradioGroup, by_pos); nargs++;
XtSetArg(args[nargs],XtNlabel,"Quality"); nargs++;
XtSetArg(args[nargs],XtNradioData,OptByQuality); nargs++;
by_qual = XtCreateManagedWidget("by_qual", toggleWidgetClass, opt_box, args, nargs);
/*
** Create selection criteria box
*/
nargs = 0;
XtSetArg(args[nargs], XtNfromVert, opt_box); nargs++;
XtSetArg(args[nargs], XtNborderWidth, 0); nargs++;
XtSetArg(args[nargs], XtNorientation, XtOrientHorizontal); nargs++;
val_box = XtCreateManagedWidget("val_box", boxWidgetClass, form, args, nargs);
nargs = 0;
XtSetArg(args[nargs], XtNborderWidth, 0); nargs++;
XtSetArg(args[nargs], XtNlabel, " Value:"); nargs++;
(void) XtCreateManagedWidget("label", labelWidgetClass, val_box, args, nargs);
nargs = 0;
XtSetArg(args[nargs], XtNresizable, True); nargs++;
XtSetArg(args[nargs], XtNresize, XawtextResizeBoth); nargs++;
XtSetArg(args[nargs], XtNeditType, XawtextEdit); nargs++;
text = XtCreateManagedWidget("text",asciiTextWidgetClass, val_box, args, nargs);
my_translations(text);
nargs = 0;
XtSetArg(args[nargs], XtNmenuName, "tagMenu"); nargs++;
type = XtCreateManagedWidget("type",menuButtonWidgetClass, val_box, args, nargs);
createTagTypeMenu(type,tagMenuCallback);
/* Set default type */
setButtonName(type, tag_db[0].type);
strncpy(tag_type,tag_db[0].id,4);
/*
** Create Exit Action Buttons
*/
nargs = 0;
XtSetArg(args[nargs], XtNfromVert, val_box); nargs++;
XtSetArg(args[nargs], XtNborderWidth, 0); nargs++;
XtSetArg(args[nargs], XtNorientation, XtOrientHorizontal); nargs++;
act_box = XtCreateManagedWidget("act_box", boxWidgetClass, form, args, nargs);
nargs = 0;
XtSetArg(args[nargs], XtNlabel, "Search"); nargs++;
search = XtCreateManagedWidget("search", commandWidgetClass, act_box, args, nargs);
XtAddCallback(search, XtNcallback, searchCallback, (XtPointer) NULL);
nargs = 0;
XtSetArg(args[nargs], XtNlabel, "Quit"); nargs++;
quit = XtCreateManagedWidget("quit", commandWidgetClass, act_box, args, nargs);
XtAddCallback(quit, XtNcallback, quitCallback, (XtPointer) NULL);
}
int invokeSearchGeneric(EdStruct *xx)
/*
** Pop up the search window, if it isn't already up
*/
{
if (up) return 0;
XX = xx;
if (searchWid == NULL) {
create_search_wid(oldFogieWid);
}
XtPopup(searchWid, XtGrabNone);
up = 1;
return 0;
}
int destroySearchWindow()
/*
** Shut this baby down
** Called by the routine that takes the contig editor down.
*/
{
if (up)
XtCallCallbacks(quit, XtNcallback, (XtPointer) NULL);
return 0;
}
void createSearchWidget(Widget parentWid)
/*
** Prtend to create it now
*/
{
oldFogieWid = parentWid;
}
Reference in New Issue View Git Blame Copy Permalink