doom

hu_lib.c (4585B)

---

 #include <ctype.h>
 
 #include "doomdef.h"
 
 #include "v_video.h"
 #include "hu_lib.h"
 #include "r_local.h"
 #include "r_draw.h"
 
 
 #define noterased viewwindowx
 
 extern boolean	automapactive;	
 
 void HUlib_init(void)
 {
 }
 
 void HUlib_clearTextLine(hu_textline_t* t)
 {
     t->len = 0;
     t->l[0] = 0;
     t->needsupdate = true;
 }
 
 void
 HUlib_initTextLine
 ( hu_textline_t*	t,
   int			x,
   int			y,
   patch_t**		f,
   int			sc )
 {
     t->x = x;
     t->y = y;
     t->f = f;
     t->sc = sc;
     HUlib_clearTextLine(t);
 }
 
 boolean
 HUlib_addCharToTextLine
 ( hu_textline_t*	t,
   char			ch )
 {
 
     if (t->len == HU_MAXLINELENGTH)
 	return false;
     else
     {
 	t->l[t->len++] = ch;
 	t->l[t->len] = 0;
 	t->needsupdate = 4;
 	return true;
     }
 
 }
 
 boolean HUlib_delCharFromTextLine(hu_textline_t* t)
 {
 
     if (!t->len) return false;
     else
     {
 	t->l[--t->len] = 0;
 	t->needsupdate = 4;
 	return true;
     }
 
 }
 
 void
 HUlib_drawTextLine
 ( hu_textline_t*	l,
   boolean		drawcursor )
 {
 
     int			i;
     int			w;
     int			x;
     unsigned char	c;
 
     
     x = l->x;
     for (i=0;i<l->len;i++)
     {
 	c = toupper(l->l[i]);
 	if (c != ' '
 	    && c >= l->sc
 	    && c <= '_')
 	{
 	    w = l->f[c - l->sc]->width;
 	    if (x+w > SCREENWIDTH)
 		break;
 	    V_DrawPatch(x, l->y, FG, l->f[c - l->sc]);
 	    x += w;
 	}
 	else
 	{
 	    x += 4;
 	    if (x >= SCREENWIDTH)
 		break;
 	}
     }
 
     
     if (drawcursor
 	&& x + l->f['_' - l->sc]->width <= SCREENWIDTH)
     {
 	V_DrawPatch(x, l->y, FG, l->f['_' - l->sc]);
     }
 }
 
 
 
 void HUlib_eraseTextLine(hu_textline_t* l)
 {
     int			lh;
     int			y;
     int			yoffset;
 
     
     
     
 
     if (!automapactive &&
 	viewwindowx && l->needsupdate)
     {
 	lh = l->f[0]->height + 1;
 	for (y=l->y,yoffset=y*SCREENWIDTH ; y<l->y+lh ; y++,yoffset+=SCREENWIDTH)
 	{
 	    if (y < viewwindowy || y >= viewwindowy + viewheight)
 		R_VideoErase(yoffset, SCREENWIDTH); 
 	    else
 	    {
 		R_VideoErase(yoffset, viewwindowx); 
 		R_VideoErase(yoffset + viewwindowx + viewwidth, viewwindowx);
 		
 	    }
 	}
     }
 
     if (l->needsupdate) l->needsupdate--;
 
 }
 
 void
 HUlib_initSText
 ( hu_stext_t*	s,
   int		x,
   int		y,
   int		h,
   patch_t**	font,
   int		startchar,
   boolean*	on )
 {
 
     int i;
 
     s->h = h;
     s->on = on;
     s->laston = true;
     s->cl = 0;
     for (i=0;i<h;i++)
 	HUlib_initTextLine(&s->l[i], x, y - i*(font[0]->height+1), font, startchar);
 
 }
 
 void HUlib_addLineToSText(hu_stext_t* s)
 {
 
     int i;
 
     
     if (++s->cl == s->h)
 	s->cl = 0;
     HUlib_clearTextLine(&s->l[s->cl]);
 
     
     for (i=0 ; i<s->h ; i++)
 	s->l[i].needsupdate = 4;
 
 }
 
 void
 HUlib_addMessageToSText
 ( hu_stext_t*	s,
   char*		prefix,
   char*		msg )
 {
     HUlib_addLineToSText(s);
     if (prefix)
 	while (*prefix)
 	    HUlib_addCharToTextLine(&s->l[s->cl], *(prefix++));
 
     while (*msg)
 	HUlib_addCharToTextLine(&s->l[s->cl], *(msg++));
 }
 
 void HUlib_drawSText(hu_stext_t* s)
 {
     int i, idx;
     hu_textline_t *l;
 
     if (!*s->on)
 	return; 
 
     
     for (i=0 ; i<s->h ; i++)
     {
 	idx = s->cl - i;
 	if (idx < 0)
 	    idx += s->h; 
 	
 	l = &s->l[idx];
 
 	
 	HUlib_drawTextLine(l, false); 
     }
 
 }
 
 void HUlib_eraseSText(hu_stext_t* s)
 {
 
     int i;
 
     for (i=0 ; i<s->h ; i++)
     {
 	if (s->laston && !*s->on)
 	    s->l[i].needsupdate = 4;
 	HUlib_eraseTextLine(&s->l[i]);
     }
     s->laston = *s->on;
 
 }
 
 void
 HUlib_initIText(hu_itext_t* it, int x, int y, patch_t** font, int startchar, boolean* on)
 {
     it->lm = 0; 
     it->on = on;
     it->laston = true;
     HUlib_initTextLine(&it->l, x, y, font, startchar);
 }
 
 
 
 void HUlib_delCharFromIText(hu_itext_t* it)
 {
     if (it->l.len != it->lm)
 	HUlib_delCharFromTextLine(&it->l);
 }
 
 void HUlib_eraseLineFromIText(hu_itext_t* it)
 {
     while (it->lm != it->l.len)
 	HUlib_delCharFromTextLine(&it->l);
 }
 
 
 void HUlib_resetIText(hu_itext_t* it)
 {
     it->lm = 0;
     HUlib_clearTextLine(&it->l);
 }
 
 void
 HUlib_addPrefixToIText
 ( hu_itext_t*	it,
   char*		str )
 {
     while (*str)
 	HUlib_addCharToTextLine(&it->l, *(str++));
     it->lm = it->l.len;
 }
 
 
 
 boolean
 HUlib_keyInIText
 ( hu_itext_t*	it,
   unsigned char ch )
 {
 
     if (ch >= ' ' && ch <= '_') 
   	HUlib_addCharToTextLine(&it->l, (char) ch);
     else 
 	if (ch == KEY_BACKSPACE) 
 	    HUlib_delCharFromIText(it);
 	else 
 	    if (ch != KEY_ENTER) 
 		return false; 
 
     return true; 
 
 }
 
 void HUlib_drawIText(hu_itext_t* it)
 {
 
     hu_textline_t *l = &it->l;
 
     if (!*it->on)
 	return;
     HUlib_drawTextLine(l, true); 
 
 }
 
 void HUlib_eraseIText(hu_itext_t* it)
 {
     if (it->laston && !*it->on)
 	it->l.needsupdate = 4;
     HUlib_eraseTextLine(&it->l);
     it->laston = *it->on;
 }