void trace_draw_confidence(DNATrace *t, Display *d, Pixmap p,
int x0, int xn, int height) {
int ind, pos, x1, fw, cfw, cfh;
char b[5];
if (!p || t->Ned <= 0)
return;
x1 = x0 + xn < t->read->NPoints ? x0+xn : t->read->NPoints - 1;
x1 = t->tracePos[x1] + 1;
if (x1 >= t->read->NBases) x1--;
x1 = t->read->basePos[x1];
ind = t->tracePosE[x0]; /* Index of first base on screen */
fw = t->font_width/2 + 1;
cfh = t->conf_font_height;
cfw = t->conf_font_width;
while (ind < t->read->NBases && (pos = trace_get_pos(t, ind)) <= x1) {
int conf;
conf = t->edConf[ind];
if (conf < 100)
sprintf(b, "%02d", conf);
else
strcpy(b, "XX");
pos = point_to_pixel(t, pos) - fw;
XFillRectangle(d, p, t->ConfGC, pos, cfh,
cfw, (int)(conf * t->scale_conf));
Tk_DrawChars(d, p, t->ConfGC, t->conf_font, b, 2,
pos, cfh);
ind++;
}
}
static void
DisplayVerticalScale(
TkScale *scalePtr, /* Widget record for scale. */
Drawable drawable, /* Where to display scale (window or
* pixmap). */
XRectangle *drawnAreaPtr) /* Initally contains area of window; if only a
* part of the scale is redrawn, gets modified
* to reflect the part of the window that was
* redrawn. */
{
Tk_Window tkwin = scalePtr->tkwin;
int x, y, width, height, shadowWidth;
double tickValue, tickInterval = scalePtr->tickInterval;
Tk_3DBorder sliderBorder;
/*
* Display the information from left to right across the window.
*/
if (!(scalePtr->flags & REDRAW_OTHER)) {
drawnAreaPtr->x = scalePtr->vertTickRightX;
drawnAreaPtr->y = scalePtr->inset;
drawnAreaPtr->width = scalePtr->vertTroughX + scalePtr->width
+ 2*scalePtr->borderWidth - scalePtr->vertTickRightX;
drawnAreaPtr->height -= 2*scalePtr->inset;
}
Tk_Fill3DRectangle(tkwin, drawable, scalePtr->bgBorder,
drawnAreaPtr->x, drawnAreaPtr->y, drawnAreaPtr->width,
drawnAreaPtr->height, 0, TK_RELIEF_FLAT);
if (scalePtr->flags & REDRAW_OTHER) {
/*
* Display the tick marks.
*/
if (tickInterval != 0) {
double ticks, maxTicks;
/*
* Ensure that we will only draw enough of the tick values such
* that they don't overlap
*/
ticks = fabs((scalePtr->toValue - scalePtr->fromValue)
/ tickInterval);
maxTicks = (double) Tk_Height(tkwin)
/ (double) scalePtr->fontHeight;
if (ticks > maxTicks) {
tickInterval *= (ticks / maxTicks);
}
for (tickValue = scalePtr->fromValue; ;
tickValue += tickInterval) {
/*
* The TkRoundToResolution call gets rid of accumulated
* round-off errors, if any.
*/
tickValue = TkRoundToResolution(scalePtr, tickValue);
if (scalePtr->toValue >= scalePtr->fromValue) {
if (tickValue > scalePtr->toValue) {
break;
}
} else {
if (tickValue < scalePtr->toValue) {
break;
}
}
DisplayVerticalValue(scalePtr, drawable, tickValue,
scalePtr->vertTickRightX);
}
}
}
/*
* Display the value, if it is desired.
*/
if (scalePtr->showValue) {
DisplayVerticalValue(scalePtr, drawable, scalePtr->value,
scalePtr->vertValueRightX);
}
/*
* Display the trough and the slider.
*/
Tk_Draw3DRectangle(tkwin, drawable,
scalePtr->bgBorder, scalePtr->vertTroughX, scalePtr->inset,
scalePtr->width + 2*scalePtr->borderWidth,
Tk_Height(tkwin) - 2*scalePtr->inset, scalePtr->borderWidth,
TK_RELIEF_SUNKEN);
XFillRectangle(scalePtr->display, drawable, scalePtr->troughGC,
scalePtr->vertTroughX + scalePtr->borderWidth,
scalePtr->inset + scalePtr->borderWidth,
(unsigned) scalePtr->width,
(unsigned) (Tk_Height(tkwin) - 2*scalePtr->inset
- 2*scalePtr->borderWidth));
if (scalePtr->state == STATE_ACTIVE) {
sliderBorder = scalePtr->activeBorder;
} else {
sliderBorder = scalePtr->bgBorder;
}
width = scalePtr->width;
height = scalePtr->sliderLength/2;
x = scalePtr->vertTroughX + scalePtr->borderWidth;
y = TkScaleValueToPixel(scalePtr, scalePtr->value) - height;
shadowWidth = scalePtr->borderWidth/2;
if (shadowWidth == 0) {
shadowWidth = 1;
}
Tk_Draw3DRectangle(tkwin, drawable, sliderBorder, x, y, width,
2*height, shadowWidth, scalePtr->sliderRelief);
x += shadowWidth;
y += shadowWidth;
width -= 2*shadowWidth;
height -= shadowWidth;
Tk_Fill3DRectangle(tkwin, drawable, sliderBorder, x, y, width,
height, shadowWidth, scalePtr->sliderRelief);
Tk_Fill3DRectangle(tkwin, drawable, sliderBorder, x, y+height,
width, height, shadowWidth, scalePtr->sliderRelief);
/*
* Draw the label to the right of the scale.
*/
if ((scalePtr->flags & REDRAW_OTHER) && (scalePtr->labelLength != 0)) {
Tk_FontMetrics fm;
Tk_GetFontMetrics(scalePtr->tkfont, &fm);
Tk_DrawChars(scalePtr->display, drawable, scalePtr->textGC,
scalePtr->tkfont, scalePtr->label,
scalePtr->labelLength, scalePtr->vertLabelX,
scalePtr->inset + (3*fm.ascent)/2);
}
}
static void
DisplayHorizontalScale(
TkScale *scalePtr, /* Widget record for scale. */
Drawable drawable, /* Where to display scale (window or
* pixmap). */
XRectangle *drawnAreaPtr) /* Initally contains area of window; if only a
* part of the scale is redrawn, gets modified
* to reflect the part of the window that was
* redrawn. */
{
register Tk_Window tkwin = scalePtr->tkwin;
int x, y, width, height, shadowWidth;
double tickValue, tickInterval = scalePtr->tickInterval;
Tk_3DBorder sliderBorder;
/*
* Display the information from bottom to top across the window.
*/
if (!(scalePtr->flags & REDRAW_OTHER)) {
drawnAreaPtr->x = scalePtr->inset;
drawnAreaPtr->y = scalePtr->horizValueY;
drawnAreaPtr->width -= 2*scalePtr->inset;
drawnAreaPtr->height = scalePtr->horizTroughY + scalePtr->width
+ 2*scalePtr->borderWidth - scalePtr->horizValueY;
}
Tk_Fill3DRectangle(tkwin, drawable, scalePtr->bgBorder,
drawnAreaPtr->x, drawnAreaPtr->y, drawnAreaPtr->width,
drawnAreaPtr->height, 0, TK_RELIEF_FLAT);
if (scalePtr->flags & REDRAW_OTHER) {
/*
* Display the tick marks.
*/
if (tickInterval != 0) {
char valueString[PRINT_CHARS];
double ticks, maxTicks;
/*
* Ensure that we will only draw enough of the tick values such
* that they don't overlap. We base this off the width that
* fromValue would take. Not exact, but better than no constraint.
*/
ticks = fabs((scalePtr->toValue - scalePtr->fromValue)
/ tickInterval);
sprintf(valueString, scalePtr->format, scalePtr->fromValue);
maxTicks = (double) Tk_Width(tkwin)
/ (double) Tk_TextWidth(scalePtr->tkfont, valueString, -1);
if (ticks > maxTicks) {
tickInterval *= (ticks / maxTicks);
}
for (tickValue = scalePtr->fromValue; ;
tickValue += tickInterval) {
/*
* The TkRoundToResolution call gets rid of accumulated
* round-off errors, if any.
*/
tickValue = TkRoundToResolution(scalePtr, tickValue);
if (scalePtr->toValue >= scalePtr->fromValue) {
if (tickValue > scalePtr->toValue) {
break;
}
} else {
if (tickValue < scalePtr->toValue) {
break;
}
}
DisplayHorizontalValue(scalePtr, drawable, tickValue,
scalePtr->horizTickY);
}
}
}
/*
* Display the value, if it is desired.
*/
if (scalePtr->showValue) {
DisplayHorizontalValue(scalePtr, drawable, scalePtr->value,
scalePtr->horizValueY);
}
/*
* Display the trough and the slider.
*/
y = scalePtr->horizTroughY;
Tk_Draw3DRectangle(tkwin, drawable,
scalePtr->bgBorder, scalePtr->inset, y,
Tk_Width(tkwin) - 2*scalePtr->inset,
scalePtr->width + 2*scalePtr->borderWidth,
scalePtr->borderWidth, TK_RELIEF_SUNKEN);
XFillRectangle(scalePtr->display, drawable, scalePtr->troughGC,
scalePtr->inset + scalePtr->borderWidth,
y + scalePtr->borderWidth,
(unsigned) (Tk_Width(tkwin) - 2*scalePtr->inset
- 2*scalePtr->borderWidth),
(unsigned) scalePtr->width);
if (scalePtr->state == STATE_ACTIVE) {
sliderBorder = scalePtr->activeBorder;
} else {
sliderBorder = scalePtr->bgBorder;
}
width = scalePtr->sliderLength/2;
height = scalePtr->width;
x = TkScaleValueToPixel(scalePtr, scalePtr->value) - width;
y += scalePtr->borderWidth;
shadowWidth = scalePtr->borderWidth/2;
if (shadowWidth == 0) {
shadowWidth = 1;
}
Tk_Draw3DRectangle(tkwin, drawable, sliderBorder,
x, y, 2*width, height, shadowWidth, scalePtr->sliderRelief);
x += shadowWidth;
y += shadowWidth;
width -= shadowWidth;
height -= 2*shadowWidth;
Tk_Fill3DRectangle(tkwin, drawable, sliderBorder, x, y, width, height,
shadowWidth, scalePtr->sliderRelief);
Tk_Fill3DRectangle(tkwin, drawable, sliderBorder, x+width, y,
width, height, shadowWidth, scalePtr->sliderRelief);
/*
* Draw the label at the top of the scale.
*/
if ((scalePtr->flags & REDRAW_OTHER) && (scalePtr->labelLength != 0)) {
Tk_FontMetrics fm;
Tk_GetFontMetrics(scalePtr->tkfont, &fm);
Tk_DrawChars(scalePtr->display, drawable, scalePtr->textGC,
scalePtr->tkfont, scalePtr->label,
scalePtr->labelLength, scalePtr->inset + fm.ascent/2,
scalePtr->horizLabelY + fm.ascent);
}
}
static void
DrawMenuEntryLabel(
TkMenu *menuPtr, /* The menu we are drawing. */
TkMenuEntry *mePtr, /* The entry we are drawing. */
Drawable d, /* What we are drawing into. */
GC gc, /* The gc we are drawing into.*/
Tk_Font tkfont, /* The precalculated font. */
const Tk_FontMetrics *fmPtr,/* The precalculated font metrics. */
int x, /* Left edge. */
int y, /* Top edge. */
int width, /* width of entry. */
int height) /* height of entry. */
{
int indicatorSpace = mePtr->indicatorSpace;
int activeBorderWidth, leftEdge, imageHeight, imageWidth;
int textHeight = 0, textWidth = 0; /* stop GCC warning */
int haveImage = 0, haveText = 0;
int imageXOffset = 0, imageYOffset = 0;
int textXOffset = 0, textYOffset = 0;
Tk_GetPixelsFromObj(NULL, menuPtr->tkwin, menuPtr->activeBorderWidthPtr,
&activeBorderWidth);
leftEdge = x + indicatorSpace + activeBorderWidth;
if (menuPtr->menuType == MENUBAR) {
leftEdge += 5;
}
/*
* Work out what we will need to draw first.
*/
if (mePtr->image != NULL) {
Tk_SizeOfImage(mePtr->image, &imageWidth, &imageHeight);
haveImage = 1;
} else if (mePtr->bitmapPtr != NULL) {
Pixmap bitmap = Tk_GetBitmapFromObj(menuPtr->tkwin, mePtr->bitmapPtr);
Tk_SizeOfBitmap(menuPtr->display, bitmap, &imageWidth, &imageHeight);
haveImage = 1;
}
if (!haveImage || (mePtr->compound != COMPOUND_NONE)) {
if (mePtr->labelLength > 0) {
const char *label = Tcl_GetString(mePtr->labelPtr);
textWidth = Tk_TextWidth(tkfont, label, mePtr->labelLength);
textHeight = fmPtr->linespace;
haveText = 1;
}
}
/*
* Now work out what the relative positions are.
*/
if (haveImage && haveText) {
int fullWidth = (imageWidth > textWidth ? imageWidth : textWidth);
switch ((enum compound) mePtr->compound) {
case COMPOUND_TOP:
textXOffset = (fullWidth - textWidth)/2;
textYOffset = imageHeight/2 + 2;
imageXOffset = (fullWidth - imageWidth)/2;
imageYOffset = -textHeight/2;
break;
case COMPOUND_BOTTOM:
textXOffset = (fullWidth - textWidth)/2;
textYOffset = -imageHeight/2;
imageXOffset = (fullWidth - imageWidth)/2;
imageYOffset = textHeight/2 + 2;
break;
case COMPOUND_LEFT:
/*
* Position image in the indicator space to the left of the
* entries, unless this entry is a radio|check button because then
* the indicator space will be used.
*/
textXOffset = imageWidth + 2;
textYOffset = 0;
imageXOffset = 0;
imageYOffset = 0;
if ((mePtr->type != CHECK_BUTTON_ENTRY)
&& (mePtr->type != RADIO_BUTTON_ENTRY)) {
textXOffset -= indicatorSpace;
if (textXOffset < 0) {
textXOffset = 0;
}
imageXOffset = -indicatorSpace;
}
break;
case COMPOUND_RIGHT:
textXOffset = 0;
textYOffset = 0;
imageXOffset = textWidth + 2;
imageYOffset = 0;
break;
case COMPOUND_CENTER:
textXOffset = (fullWidth - textWidth)/2;
textYOffset = 0;
imageXOffset = (fullWidth - imageWidth)/2;
imageYOffset = 0;
break;
case COMPOUND_NONE:
break;
}
} else {
textXOffset = 0;
textYOffset = 0;
imageXOffset = 0;
imageYOffset = 0;
}
/*
* Draw label and/or bitmap or image for entry.
*/
if (mePtr->image != NULL) {
if ((mePtr->selectImage != NULL)
&& (mePtr->entryFlags & ENTRY_SELECTED)) {
Tk_RedrawImage(mePtr->selectImage, 0, 0,
imageWidth, imageHeight, d, leftEdge + imageXOffset,
(int) (y + (mePtr->height-imageHeight)/2 + imageYOffset));
} else {
Tk_RedrawImage(mePtr->image, 0, 0, imageWidth,
imageHeight, d, leftEdge + imageXOffset,
(int) (y + (mePtr->height-imageHeight)/2 + imageYOffset));
}
} else if (mePtr->bitmapPtr != None) {
Pixmap bitmap = Tk_GetBitmapFromObj(menuPtr->tkwin, mePtr->bitmapPtr);
XCopyPlane(menuPtr->display, bitmap, d, gc, 0, 0,
(unsigned) imageWidth, (unsigned) imageHeight,
leftEdge + imageXOffset,
(int) (y + (mePtr->height - imageHeight)/2 + imageYOffset), 1);
}
if ((mePtr->compound != COMPOUND_NONE) || !haveImage) {
int baseline = y + (height + fmPtr->ascent - fmPtr->descent) / 2;
if (mePtr->labelLength > 0) {
const char *label = Tcl_GetString(mePtr->labelPtr);
Tk_DrawChars(menuPtr->display, d, gc, tkfont, label,
mePtr->labelLength, leftEdge + textXOffset,
baseline + textYOffset);
DrawMenuUnderline(menuPtr, mePtr, d, gc, tkfont, fmPtr,
x + textXOffset, y + textYOffset,
width, height);
}
}
if (mePtr->state == ENTRY_DISABLED) {
if (menuPtr->disabledFgPtr == NULL) {
XFillRectangle(menuPtr->display, d, menuPtr->disabledGC, x, y,
(unsigned) width, (unsigned) height);
} else if ((mePtr->image != NULL)
&& (menuPtr->disabledImageGC != None)) {
XFillRectangle(menuPtr->display, d, menuPtr->disabledImageGC,
leftEdge + imageXOffset,
(int) (y + (mePtr->height - imageHeight)/2 + imageYOffset),
(unsigned) imageWidth, (unsigned) imageHeight);
}
}
}
/*
** Display a single HtmlBlock. This is where all the drawing
** happens.
*/
void HtmlBlockDraw(
HtmlWidget *htmlPtr, /* The main HTML widget */
HtmlBlock *pBlock, /* Block which needs to be drawn */
Drawable drawable, /* Draw the line on this */
int drawableLeft, /* Virtual coordinate of left edge of drawable */
int drawableTop, /* Virtual coordinate of top edge of drawable */
int drawableWidth, /* Width of the drawable */
int drawableHeight /* Height of the drawable */
){
Tk_Font font; /* Font to use to render text */
GC gc; /* A graphics context */
HtmlElement *src; /* HtmlElement holding style information */
HtmlElement *pTable; /* The table (when drawing part of a table) */
int x, y; /* Where to draw */
if( pBlock==0 ){ TestPoint(0); return; }
src = pBlock->base.pNext;
while( src && (src->base.flags & HTML_Visible)==0 ){
src = src->base.pNext;
TestPoint(0);
}
if( src==0 ){ TestPoint(0); return; }
if( pBlock->n>0 ){
/* We must be dealing with plain old text */
if( src->base.type==Html_Text ){
x = src->text.x;
y = src->text.y;
TestPoint(0);
}else{
CANT_HAPPEN;
return;
}
if( pBlock->base.flags & HTML_Selected ){
HtmlLock(htmlPtr);
DrawSelectionBackground(htmlPtr, pBlock, drawable,
drawableLeft, drawableTop);
if( HtmlUnlock(htmlPtr) ) return;
}
gc = HtmlGetGC(htmlPtr, src->base.style.color, src->base.style.font);
font = HtmlGetFont(htmlPtr, src->base.style.font);
if( font==0 ) return;
Tk_DrawChars(htmlPtr->display,
drawable,
gc, font,
pBlock->z, pBlock->n,
x - drawableLeft, y - drawableTop);
if( src->base.style.flags & STY_Underline ){
Tk_UnderlineChars(htmlPtr->display, drawable, gc, font, pBlock->z,
x - drawableLeft, y-drawableTop, 0, pBlock->n);
}
if( src->base.style.flags & STY_StrikeThru ){
XRectangle xrec;
xrec.x = pBlock->left - drawableLeft;
xrec.y = (pBlock->top + pBlock->bottom)/2 - drawableTop;
xrec.width = pBlock->right - pBlock->left;
xrec.height = 1 + (pBlock->bottom - pBlock->top > 15);
XFillRectangles(htmlPtr->display, drawable, gc, &xrec, 1);
}
if( pBlock==htmlPtr->pInsBlock && htmlPtr->insStatus>0 ){
int x;
XRectangle xrec;
if( htmlPtr->insIndex < pBlock->n ){
x = src->text.x - drawableLeft;
x += Tk_TextWidth(font, pBlock->z, htmlPtr->insIndex);
}else{
x = pBlock->right - drawableLeft;
}
if( x>0 ){ TestPoint(0); x--; }
xrec.x = x;
xrec.y = pBlock->top - drawableTop;
xrec.width = 2;
xrec.height = pBlock->bottom - pBlock->top;
XFillRectangles(htmlPtr->display, drawable, gc, &xrec, 1);
}
}else{
/* We are dealing with a single HtmlElement which contains something
** other than plain text. */
int top, btm, cntr;
int cnt, w;
char zBuf[30];
switch( src->base.type ){
case Html_LI:
x = src->li.x;
y = src->li.y;
cntr = (top+btm)/2;
switch( src->li.type ){
case LI_TYPE_Enum_1:
sprintf(zBuf,"%d.",src->li.cnt);
TestPoint(0);
break;
case LI_TYPE_Enum_A:
GetLetterIndex(zBuf,src->li.cnt,1);
TestPoint(0);
break;
case LI_TYPE_Enum_a:
GetLetterIndex(zBuf,src->li.cnt,0);
TestPoint(0);
break;
case LI_TYPE_Enum_I:
GetRomanIndex(zBuf,src->li.cnt,1);
TestPoint(0);
break;
case LI_TYPE_Enum_i:
GetRomanIndex(zBuf,src->li.cnt,0);
TestPoint(0);
break;
default:
zBuf[0] = 0;
TestPoint(0);
break;
}
gc = HtmlGetGC(htmlPtr, src->base.style.color, src->base.style.font);
switch( src->li.type ){
case LI_TYPE_Undefined:
case LI_TYPE_Bullet1:
XFillArc(htmlPtr->display,
drawable,
gc,
x - 7 - drawableLeft, y - 8 - drawableTop, 7, 7,
0, 360*64);
TestPoint(0);
break;
case LI_TYPE_Bullet2:
XDrawArc(htmlPtr->display,
drawable,
gc,
x - 7 - drawableLeft, y - 8 - drawableTop, 7, 7,
0, 360*64);
TestPoint(0);
break;
case LI_TYPE_Bullet3:
XDrawRectangle(htmlPtr->display,
drawable,
gc,
x - 7 - drawableLeft, y - 8 - drawableTop, 7, 7);
TestPoint(0);
break;
case LI_TYPE_Enum_1:
case LI_TYPE_Enum_A:
case LI_TYPE_Enum_a:
case LI_TYPE_Enum_I:
case LI_TYPE_Enum_i:
cnt = strlen(zBuf);
font = HtmlGetFont(htmlPtr, src->base.style.font);
if( font==0 ) return;
w = Tk_TextWidth(font, zBuf, cnt);
Tk_DrawChars(htmlPtr->display,
drawable,
gc, font,
zBuf, cnt,
x - w - drawableLeft, y - drawableTop);
TestPoint(0);
break;
}
break;
case Html_HR: {
int relief = htmlPtr->ruleRelief;
switch( relief ){
case TK_RELIEF_RAISED:
case TK_RELIEF_SUNKEN:
break;
default:
relief = TK_RELIEF_FLAT;
break;
}
HtmlDrawRect(htmlPtr, drawable, src,
src->hr.x - drawableLeft,
src->hr.y - drawableTop,
src->hr.w,
src->hr.h,
1, relief);
break;
}
case Html_TABLE: {
int relief = htmlPtr->tableRelief;
switch( relief ){
case TK_RELIEF_RAISED:
case TK_RELIEF_SUNKEN:
break;
default:
relief = TK_RELIEF_FLAT;
break;
}
HtmlDrawRect(htmlPtr, drawable, src,
src->table.x - drawableLeft,
src->table.y - drawableTop,
src->table.w,
src->table.h,
src->table.borderWidth,
relief);
break;
}
case Html_TH:
case Html_TD: {
int depth, relief;
pTable = src->cell.pTable;
depth = pTable && pTable->table.borderWidth>0;
switch( htmlPtr->tableRelief ){
case TK_RELIEF_RAISED: relief = TK_RELIEF_SUNKEN; break;
case TK_RELIEF_SUNKEN: relief = TK_RELIEF_RAISED; break;
default: relief = TK_RELIEF_FLAT; break;
}
HtmlDrawRect(htmlPtr, drawable, src,
src->cell.x - drawableLeft,
src->cell.y - drawableTop,
src->cell.w,
src->cell.h,
depth,
relief);
break;
}
case Html_IMG:
if( src->image.pImage ){
HtmlDrawImage(src, drawable, drawableLeft, drawableTop,
drawableLeft + drawableWidth,
drawableTop + drawableHeight);
}else if( src->image.zAlt ){
gc = HtmlGetGC(htmlPtr, src->base.style.color, src->base.style.font);
font = HtmlGetFont(htmlPtr, src->base.style.font);
if( font==0 ) return;
Tk_DrawChars(htmlPtr->display,
drawable,
gc, font,
src->image.zAlt, strlen(src->image.zAlt),
src->image.x - drawableLeft,
src->image.y - drawableTop);
TestPoint(0);
}
break;
default:
TestPoint(0);
break;
}
}
}
/*
* Draw the edited seq. from pixel coordinates (x,y) to (x+width, y+height).
*/
void trace_draw_edits(DNATrace *t, Display *d, Pixmap p,
int x0, int xn, int yoff, int height) {
int ind, pos, x1, fw, fh;
if( !p || !t || !t->read || (t->read->NBases==0) )
return;
x0 -= 4;
if (x0 < 0) x0 = 0;
xn += 8;
x1 = x0 + xn < t->read->NPoints ? x0+xn : t->read->NPoints - 1;
x1 = t->tracePos[x1] + 1;
if (x1 >= t->read->NBases) x1--;
x1 = t->read->basePos[x1];
ind = t->tracePosE[x0]; /* Index of first base on screen */
fw = t->font_width/2 + 1;
fh = t->fm.ascent + yoff;
while (ind < t->Ned && (pos = trace_get_pos(t, ind)) <= x1) {
char base;
GC gc;
base = t->edBases[ind];
switch (base) {
case 'A':
case 'a':
gc = t->Agc;
break;
case 'C':
case 'c':
gc = t->Cgc;
break;
case 'G':
case 'g':
gc = t->Ggc;
break;
case 'T':
case 't':
gc = t->Tgc;
break;
default:
gc = t->CursorGC;
}
/* XDrawString(d, p, gc, point_to_pixel(t, pos) - fw, fh, &base, 1); */
Tk_DrawChars(d, p, gc, t->font, &base, 1,
point_to_pixel(t, pos) - fw, fh);
ind++;
}
/* Cursor */
if (t->cursor_pos > 0)
pos = trace_get_pos(t, t->cursor_pos-1);
else
pos = 0;
XFillRectangle(d, p, t->CursorGC, point_to_pixel(t, pos)+4,
t->fm.linespace-3, 8, 3);
}
/*
* Draws the 4 confidence values produced by Solexa in their +/- log-odds
* encoding.
*
* NB: Only works when trace editing hasn't been performed
*/
void trace_draw_confidence4(DNATrace *t, Display *d, Pixmap p,
int x0, int xn, int height) {
int ind, x1, fw, cfh, cfw;
char b[5];
double pos;
if (!p || t->Ned <= 0)
return;
x1 = x0 + xn < t->read->NPoints ? x0+xn : t->read->NPoints - 1;
x1 = t->tracePos[x1] + 1;
if (x1 >= t->read->NBases) x1--;
x1 = t->read->basePos[x1];
ind = t->tracePosE[x0]; /* Index of first base on screen */
fw = t->font_width/2 + 1;
cfh = t->conf_font_height;
cfw = t->conf_font_width;
while (ind < t->read->NBases && (pos = trace_get_pos(t, ind)) <= x1) {
int conf;
int edind;
double xoff;
/* Called confidence value */
conf = (signed char)(t->edConf[ind]);
if (conf < 100)
sprintf(b, "%02d", conf);
else
strcpy(b, "XX");
xoff = 0;
switch (t->read->base[ind]) {
case 'A': case 'a': xoff = 0.00; break;
case 'C': case 'c': xoff = 0.15; break;
case 'G': case 'g': xoff = 0.30; break;
case 'T': case 't': xoff = 0.45; break;
}
Tk_DrawChars(d, p, t->ConfGC, t->conf_font, b, 2,
point_to_pixel(t, pos + xoff)-fw, cfh);
/* Graphics bars for 4 confidence values */
edind = t->edPos[ind];
pos = point_to_pixel(t, pos);
if (edind) {
int i;
for (i = 0; i < 4; i++, pos += .15 * t->scale_x) {
int v;
switch(i) {
case 0: v = t->read->prob_A[ind]; break;
case 1: v = t->read->prob_C[ind]; break;
case 2: v = t->read->prob_G[ind]; break;
case 3: v = t->read->prob_T[ind]; break;
}
if (v >= 0)
XFillRectangle(d, p, t->ConfGC, pos-fw, cfh+30-v, cfw, v);
else
XFillRectangle(d, p, t->ConfNegGC, pos, cfh+30, 3, -v);
/*
if (v >= 0)
XFillRectangle(d, p, t->ConfGC, pos-1, cfh, 5, v);
else
XFillRectangle(d, p, t->ConfNegGC, pos, cfh, 3, -v);
*/
}
}
ind++;
}
}
static void
imfsample_display(ClientData cldata)
{
char *str;
int row, col, namex, namey, n, sx, sy, update = FALSE, done;
Imfsample *imfsample = (Imfsample *) cldata;
Display *dpy = imfsample->display;
Tk_Window tkwin = imfsample->tkwin;
GC gc;
Pixmap pm = None;
Drawable d;
Tk_Font tkfont;
int winwidth = Tk_Width(Tk_Parent(tkwin));
int winheight = Tk_Height(Tk_Parent(tkwin));
char tclbuf[100];
int rslt;
imfsample->update_pending = 0;
if (!Tk_IsMapped(tkwin)) {
return;
}
/* Check if we need to redraw the entire imfsample. */
if (imfsample->imfapp) {
if (imfsample->oldfirst != imfsample->firstvisrow
|| imfsample->redraw) {
imfsample->oldfirst = imfsample->firstvisrow;
update = TRUE;
}
}
/* Create a pixmap for double-buffering if necessary. */
if (imfsample->double_buffer) {
update = TRUE;
pm = Tk_GetPixmap(imfsample->display, Tk_WindowId(tkwin),
Tk_Width(tkwin), Tk_Height(tkwin),
DefaultDepthOfScreen(Tk_Screen(tkwin)));
d = pm;
} else {
d = Tk_WindowId(tkwin);
}
if (black_color == NULL) {
black_color = Tk_GetColor(interp, tkwin, Tk_GetUid("black"));
}
if (white_color == NULL) {
white_color = Tk_GetColor(interp, tkwin, Tk_GetUid("white"));
}
if (black_border == NULL) {
black_border = Tk_Get3DBorder(interp, tkwin, "black");
}
if (white_border == NULL) {
white_border = Tk_Get3DBorder(interp, tkwin, "white");
}
/* Collect GC and font for subsequent work. */
gc = imfsample->gc;
XSetClipMask(dpy, gc, None);
if (imfsample->show_names) {
#ifdef WIN32
tkfont = Tk_GetFont(interp, tkwin, "-family arial -size 8");
#elif defined (MAC)
tkfont = Tk_GetFont(interp, tkwin, "-family helvetica -size 11");
#else
tkfont = Tk_GetFont(interp, tkwin, "-family helvetica -size 12");
#endif
XSetFont(imfsample->display, gc, Tk_FontId(tkfont));
}
/* Redraw the entire widget background/border, but not if we
are just updating the selected image. */
if (imfsample->selected == imfsample->previous
/* Always redraw if we have only one image (e.g. closeups). */
|| (imfsample->numimages == 1 && imfsample->selected == -1)
|| update) {
done = FALSE;
if (imfsample->with_terrain >= 0
/* Terrain tiles are not supported on Windows yet. */
&& use_clip_mask) {
ImageFamily *timf =
imfsample->imf_list[imfsample->with_terrain];
Image *timg;
TkImage *tkimg;
timg = best_image(timf, 64, 64);
if (timg) {
tkimg = (TkImage *) timg->hook;
if (tkimg && tkimg->colr) {
XSetFillStyle(dpy, gc, FillTiled);
XSetTile(dpy, gc, tkimg->colr);
XFillRectangle(dpy, d, gc, 0, 0,
Tk_Width(tkwin), Tk_Height(tkwin));
done = TRUE;
}
}
}
if (!done) {
Tk_Fill3DRectangle(tkwin, d, imfsample->bg_border, 0, 0,
Tk_Width(tkwin), Tk_Height(tkwin),
imfsample->border_width, imfsample->relief);
}
}
#if 0
for (i = 0; i < imfsample->numimages; i++) {
if (imf_interp_hook)
imfsample->imf_list[i] =
(*imf_interp_hook)(imfsample->imf_list[i], NULL, TRUE);
}
#endif
/* Tweak the default item width/height to something better. */
if (imfsample->iheight == 0) {
imfsample->iheight = 32;
if (imfsample->numimages == 1)
imfsample->iheight = imfsample->height;
}
if (imfsample->iwidth == 0) {
imfsample->iwidth = 32;
if (imfsample->numimages == 1)
imfsample->iwidth = imfsample->width;
}
imfsample->eltw = imfsample->iwidth;
if (imfsample->show_grid)
imfsample->eltw += 2;
else
imfsample->eltw += 2 * imfsample->pad;
if (imfsample->show_names && !imfsample->show_grid)
imfsample->eltw += 80;
imfsample->elth = imfsample->iheight;
if (imfsample->show_grid)
imfsample->elth += 2;
else
imfsample->elth += 2 * imfsample->pad;
/* Fix a lower bound on the vertical spacing. */
/* (should be determined by choice of app font) */
if (imfsample->elth < 10 && !imfsample->show_grid)
imfsample->elth = 10;
/* Compute and save the number of columns to use. */
imfsample->cols = winwidth / imfsample->eltw;
if (imfsample->cols <= 0)
imfsample->cols = 1;
/* We can get a little wider spacing by recalculating the element
width. */
if (imfsample->show_names && !imfsample->show_grid)
imfsample->eltw = (winwidth - 10) / imfsample->cols;
imfsample->rows = imfsample->numimages / imfsample->cols;
/* Account for a last partial row. */
if (imfsample->rows * imfsample->cols < imfsample->numimages)
++(imfsample->rows);
/* Compute the number of visible rows. It would be time-consuming
to render all the images, so try to do only the visible ones. */
imfsample->numvisrows = winheight / imfsample->elth;
if (imfsample->numvisrows > imfsample->rows)
imfsample->numvisrows = imfsample->rows;
if (imfsample->numvisrows < 1)
imfsample->numvisrows = min(1, imfsample->rows);
if (imfsample->firstvisrow + imfsample->numvisrows > imfsample->rows)
imfsample->firstvisrow = imfsample->rows - imfsample->numvisrows;
/* Imfapp-specific code that adjusts the canvas content to fit a resized
window and also sets the canvas scrollregion correctly. */
if (imfsample->imfapp
&& imfsample->redraw) {
imfsample->width = Tk_Width(Tk_Parent(tkwin));
imfsample->height = imfsample->rows * imfsample->elth + 7;
Tk_GeometryRequest(tkwin, imfsample->width, imfsample->height);
/* There must be a better way to do this ... */
sprintf(tclbuf,
".images.canvas configure -scrollregion [ list 0 0 0 %d ]",
imfsample->height);
rslt = Tcl_Eval(interp, tclbuf);
if (rslt == TCL_ERROR) {
fprintf(stderr, "Error: %s\n", Tcl_GetStringResult(interp));
}
/* Force a redraw of the scrollbar if the window was resized. */
if (imfsample->numimages) {
sprintf(tclbuf, ".images.canvas.content yview scroll 0 units");
} else {
sprintf(tclbuf, ".images.scroll set 0 1");
}
rslt = Tcl_Eval(interp, tclbuf);
if (rslt == TCL_ERROR) {
fprintf(stderr, "Error: %s\n", Tcl_GetStringResult(interp));
}
}
/* Now iterate through all the images we want to draw. */
for (row = imfsample->firstvisrow;
row <= (imfsample->firstvisrow + imfsample->numvisrows);
++row) {
if (row < 0)
continue;
for (col = 0; col < imfsample->cols; ++col) {
n = row * imfsample->cols + col;
if (n >= imfsample->numimages)
break;
sx = col * imfsample->eltw;
sy = (row - imfsample->firstvisrow) * imfsample->elth;
/* Erase the old selected imf if we picked a new one. */
if (n == imfsample->previous && n != imfsample->selected) {
done = FALSE;
if (imfsample->with_terrain >= 0
/* Terrain tiles are not supported on Windows yet. */
&& use_clip_mask) {
ImageFamily *timf =
imfsample->imf_list[imfsample->with_terrain];
Image *timg;
TkImage *tkimg;
timg = best_image(timf, 64, 64);
if (timg) {
tkimg = (TkImage *) timg->hook;
if (tkimg && tkimg->colr) {
XSetFillStyle(dpy, gc, FillTiled);
XSetTile(dpy, gc, tkimg->colr);
if (imfsample->show_grid) {
XFillRectangle(dpy, d, gc, sx, sy + 2,
imfsample->eltw,
imfsample->elth);
} else {
XFillRectangle(dpy, d, gc, sx, sy + 7,
imfsample->eltw,
imfsample->elth);
}
done = TRUE;
}
}
}
if (!done) {
if (imfsample->show_grid) {
Tk_Fill3DRectangle(tkwin, d, imfsample->bg_border,
sx, sy + 2,
imfsample->eltw, imfsample->elth,
imfsample->border_width,
imfsample->relief);
} else {
Tk_Fill3DRectangle(tkwin, d, imfsample->bg_border,
sx, sy + 7,
imfsample->eltw, imfsample->elth,
imfsample->border_width,
imfsample->relief);
}
}
}
/* Just draw the old erased image if we selected a new one, else
draw every image. */
if (imfsample->selected == imfsample->previous
|| n == imfsample->previous
|| update) {
if (imfsample->show_grid) {
Tk_Fill3DRectangle(tkwin, d, imfsample->cu_border,
sx + 2, sy + 2,
imfsample->iwidth, imfsample->iheight,
imfsample->border_width, imfsample->relief);
draw_one_main_image(imfsample, d, gc,
imfsample->imf_list[n],
sx + 2, sy + 2,
imfsample->iwidth,
imfsample->iheight);
} else {
draw_one_main_image(imfsample, d, gc,
imfsample->imf_list[n],
sx + imfsample->pad,
sy + imfsample->pad,
imfsample->iwidth,
imfsample->iheight);
}
if (imfsample->show_names && !imfsample->show_grid) {
namex = sx + 5;
namey = sy + imfsample->elth + 3;
XSetClipMask(dpy, gc, None);
XSetFillStyle(dpy, gc, FillSolid);
XSetForeground(dpy, gc,
Tk_3DBorderColor(
imfsample->fg_border)->pixel);
str = imfsample->imf_list[n]->name;
Tk_DrawChars(dpy, d, gc, tkfont, str, strlen(str),
namex, namey);
}
}
/* Box the selected imf. */
if (n == imfsample->selected) {
XSetClipMask(dpy, gc, None);
XSetFillStyle(dpy, gc, FillSolid);
XSetForeground(dpy, gc, Tk_3DBorderColor(imfsample->fg_border)->pixel);
if (imfsample->show_grid) {
/* A rectangle on the Mac is 1 pixel smaller in both directions. */
#ifdef MAC
XDrawRectangle(dpy, d, gc, sx + 2, sy + 2,
imfsample->eltw - 2, imfsample->elth - 2);
#else
XDrawRectangle(dpy, d, gc, sx + 2, sy + 2,
imfsample->eltw - 3, imfsample->elth - 3);
#endif
} else {
#ifdef MAC
XDrawRectangle(dpy, d, gc, sx, sy + 7,
imfsample->eltw, imfsample->elth);
#else
XDrawRectangle(dpy, d, gc, sx, sy + 7,
imfsample->eltw - 1, imfsample->elth - 1);
#endif
}
}
}
}
/* Reset the old selected image to the new one if it exists. */
if (imfsample->selected != -1) {
imfsample->previous = imfsample->selected;
}
/* Reset the redraw flag. */
imfsample->redraw = FALSE;
/* If double-buffered, copy to the screen and release the pixmap. */
if (imfsample->double_buffer) {
XCopyArea(imfsample->display, pm, Tk_WindowId(tkwin),
imfsample->copygc,
0, 0, (unsigned) winwidth, (unsigned) winheight, 0, 0);
Tk_FreePixmap(imfsample->display, pm);
}
if (imfsample->show_names) {
Tk_FreeFont(tkfont);
}
/* In theory this shouldn't be necessary, but in practice the
interface widgets (esp. the progress bar fill color) are
affected by the last value of the foreground left over from
drawing, so set to a consistent value. */
/* (Note that as of 2000-09-16, some color errors persist, so
this might not really be necessary -sts) */
XSetForeground(imfsample->display, imfsample->gc, black_color->pixel);
XSetBackground(imfsample->display, imfsample->gc, white_color->pixel);
XSetForeground(imfsample->display, imfsample->copygc, black_color->pixel);
XSetBackground(imfsample->display, imfsample->copygc, white_color->pixel);
}
