conbuffer_t con;
-#define CON_LINES_IDX(i) CONBUF_LINES_IDX(&con, i)
-#define CON_LINES_UNIDX(i) CONBUF_LINES_UNIDX(&con, i)
-#define CON_LINES_LAST CONBUF_LINES_LAST(&con)
-#define CON_LINES(i) CONBUF_LINES(&con, i)
-#define CON_LINES_PRED(i) CONBUF_LINES_PRED(&con, i)
-#define CON_LINES_SUCC(i) CONBUF_LINES_SUCC(&con, i)
+#define CON_LINES_IDX(i) CONBUFFER_LINES_IDX(&con, i)
+#define CON_LINES_UNIDX(i) CONBUFFER_LINES_UNIDX(&con, i)
+#define CON_LINES_LAST CONBUFFER_LINES_LAST(&con)
+#define CON_LINES(i) CONBUFFER_LINES(&con, i)
+#define CON_LINES_PRED(i) CONBUFFER_LINES_PRED(&con, i)
+#define CON_LINES_SUCC(i) CONBUFFER_LINES_SUCC(&con, i)
+#define CON_LINES_FIRST CONBUFFER_LINES_FIRST(&con)
+#define CON_LINES_COUNT CONBUFFER_LINES_COUNT(&con)
cvar_t con_notifytime = {CVAR_SAVE, "con_notifytime","3", "how long notify lines last, in seconds"};
cvar_t con_notify = {CVAR_SAVE, "con_notify","4", "how many notify lines to show"};
{
Mem_Free(buf->text);
Mem_Free(buf->lines);
+ buf->text = NULL;
+ buf->lines = NULL;
}
/*
int i;
if(buf->lines_count >= 1)
{
- double diff = cl.time - (buf->lines + CONBUF_LINES_LAST(buf))->addtime;
+ double diff = cl.time - (buf->lines + CONBUFFER_LINES_LAST(buf))->addtime;
if(diff < 0)
{
for(i = 0; i < buf->lines_count; ++i)
- CONBUF_LINES(buf, i).addtime += diff;
+ CONBUFFER_LINES(buf, i).addtime += diff;
}
}
}
if(buf->lines_count == 0)
return;
--buf->lines_count;
- buf->lines_first = CONBUF_LINES_IDX(buf, 1);
+ buf->lines_first = CONBUFFER_LINES_IDX(buf, 1);
}
/*
else
{
char *firstline_start = buf->lines[buf->lines_first].start;
- char *lastline_onepastend = buf->lines[CONBUF_LINES_LAST(buf)].start + buf->lines[CONBUF_LINES_LAST(buf)].len;
+ char *lastline_onepastend = buf->lines[CONBUFFER_LINES_LAST(buf)].start + buf->lines[CONBUFFER_LINES_LAST(buf)].len;
// the buffer is cyclic, so we first have two cases...
if(firstline_start < lastline_onepastend) // buffer is contiguous
{
//fprintf(stderr, "Now have %d lines (%d -> %d).\n", buf->lines_count, buf->lines_first, CON_LINES_LAST);
- p = buf->lines + CONBUF_LINES_LAST(buf);
+ p = buf->lines + CONBUFFER_LINES_LAST(buf);
p->start = putpos;
p->len = len;
p->addtime = cl.time;
start = buf->lines_count;
for(i = start - 1; i >= 0; --i)
{
- con_lineinfo_t *l = &CONBUF_LINES(buf, i);
+ con_lineinfo_t *l = &CONBUFFER_LINES(buf, i);
if((l->mask & mask_must) != mask_must)
continue;
int i;
for(i = start + 1; i < buf->lines_count; ++i)
{
- con_lineinfo_t *l = &CONBUF_LINES(buf, i);
+ con_lineinfo_t *l = &CONBUFFER_LINES(buf, i);
if((l->mask & mask_must) != mask_must)
continue;
const char *ConBuffer_GetLine(conbuffer_t *buf, int i)
{
static char copybuf[MAX_INPUTLINE];
- con_lineinfo_t *l = &CONBUF_LINES(buf, i);
+ con_lineinfo_t *l = &CONBUFFER_LINES(buf, i);
size_t sz = l->len+1 > sizeof(copybuf) ? sizeof(copybuf) : l->len+1;
strlcpy(copybuf, l->start, sz);
return copybuf;
void Con_ClearNotify (void)
{
int i;
- for(i = 0; i < con.lines_count; ++i)
+ for(i = 0; i < CON_LINES_COUNT; ++i)
CON_LINES(i).mask |= CON_MASK_HIDENOTIFY;
}
Cvar_SetValueQuick(&con_textsize, f);
width = (int)floor(vid_conwidth.value / con_textsize.value);
width = bound(1, width, con.textsize/4);
+ // FIXME uses con in a non abstracted way
if (width == con_linewidth)
return;
con_linewidth = width;
- for(i = 0; i < con.lines_count; ++i)
+ for(i = 0; i < CON_LINES_COUNT; ++i)
CON_LINES(i).height = -1; // recalculate when next needed
Con_ClearNotify();
Con_Printf("condump: unable to write file \"%s\"\n", Cmd_Argv(1));
return;
}
- for(i = 0; i < con.lines_count; ++i)
+ for(i = 0; i < CON_LINES_COUNT; ++i)
{
FS_Write(file, CON_LINES(i).start, CON_LINES(i).len);
FS_Write(file, "\n", 1);
Con_DPrint("Console initialized.\n");
}
+void Con_Shutdown (void)
+{
+ ConBuffer_Shutdown(&con);
+}
/*
================
static char buf[CON_TEXTSIZE];
static int bufpos = 0;
+ if(!con.text) // FIXME uses a non-abstracted property of con
+ return;
+
for(; *txt; ++txt)
{
if(cr_pending)
break;
default:
buf[bufpos++] = *txt;
- if(bufpos >= con.textsize - 1)
+ if(bufpos >= con.textsize - 1) // FIXME uses a non-abstracted property of con
{
ConBuffer_AddLine(&con, buf, bufpos, mask);
bufpos = 0;
continuationWidth = (int) Con_WordWidthFunc(&ti, continuationString, &l, -1);
// first find the first line to draw by backwards iterating and word wrapping to find their length...
- startidx = con.lines_count;
- for(i = con.lines_count - 1; i >= 0; --i)
+ startidx = CON_LINES_COUNT;
+ for(i = CON_LINES_COUNT - 1; i >= 0; --i)
{
con_lineinfo_t *l = &CON_LINES(i);
int mylines;
ti.y = y + alignment_y * (height - lines * fontsize) - nskip * fontsize;
// then actually draw
- for(i = startidx; i < con.lines_count; ++i)
+ for(i = startidx; i < CON_LINES_COUNT; ++i)
{
con_lineinfo_t *l = &CON_LINES(i);
ti.font = FONT_CONSOLE;
return COM_Wordwrap(con.lines[lineno].start, con.lines[lineno].len, 0, width, Con_WordWidthFunc, &ti, Con_CountLineFunc, NULL);
+ // FIXME uses con in a non abstracted way
}
/*
if(h != -1)
return h;
return con.lines[i].height = Con_MeasureConsoleLine(i);
+ // FIXME uses con in a non abstracted way
}
/*
ti.width = width;
return COM_Wordwrap(con.lines[lineno].start, con.lines[lineno].len, 0, width, Con_WordWidthFunc, &ti, Con_DisplayLineFunc, &ti);
+ // FIXME uses con in a non abstracted way
}
/*
con_backscroll = 0;
// now count until we saw con_backscroll actual lines
- for(ic = 0; ic < con.lines_count; ++ic)
+ for(ic = 0; ic < CON_LINES_COUNT; ++ic)
{
- int i = CON_LINES_IDX(con.lines_count - 1 - ic);
+ int i = CON_LINES_IDX(CON_LINES_COUNT - 1 - ic);
int h = Con_LineHeight(i);
// line is the last visible line?
// visible then.
con_backscroll = lines_seen - 1;
*last = con.lines_first;
+ // FIXME uses con in a non abstracted way
*limitlast = 1;
}
DrawQ_String_Font(vid_conwidth.integer - DrawQ_TextWidth_Font(engineversion, 0, false, FONT_CONSOLE) * con_textsize.value, lines - con_textsize.value, engineversion, 0, con_textsize.value, con_textsize.value, 1, 0, 0, 1, 0, NULL, true, FONT_CONSOLE);
// draw the text
- if(con.lines_count > 0)
+ if(CON_LINES_COUNT > 0)
{
float ymax = con_vislines - 2 * con_textsize.value;
Con_LastVisibleLine(&last, &limitlast);
if(limitlast)
y += (con.lines[last].height - limitlast) * con_textsize.value;
+ // FIXME uses con in a non abstracted way
i = last;
for(;;)
{
y -= Con_DrawConsoleLine(y, i, 0, ymax) * con_textsize.value;
if(i == con.lines_first)
+ // FIXME uses con in a non abstracted way
break; // top of console buffer
if(y < 0)
break; // top of console window
void Con_CheckResize (void);
void Con_Init (void);
void Con_Init_Commands (void);
+void Con_Shutdown (void);
void Con_DrawConsole (int lines);
void Con_Print(const char *txt);
void Con_Printf(const char *fmt, ...) DP_FUNC_PRINTF(1);
}
conbuffer_t;
-#define CONBUF_LINES_IDX(buf, i) (((buf)->lines_first + (i)) % (buf)->maxlines)
-#define CONBUF_LINES_UNIDX(buf, i) (((i) - (buf)->lines_first + (buf)->maxlines) % (buf)->maxlines)
-#define CONBUF_LINES_LAST(buf) CONBUF_LINES_IDX(buf, (buf)->lines_count - 1)
-#define CONBUF_LINES(buf, i) (buf)->lines[CONBUF_LINES_IDX(buf, i)]
-#define CONBUF_LINES_PRED(buf, i) (((i) + (buf)->maxlines - 1) % (buf)->maxlines)
-#define CONBUF_LINES_SUCC(buf, i) (((i) + 1) % (buf)->maxlines)
+#define CONBUFFER_LINES_IDX(buf, i) (((buf)->lines_first + (i)) % (buf)->maxlines)
+#define CONBUFFER_LINES_UNIDX(buf, i) (((i) - (buf)->lines_first + (buf)->maxlines) % (buf)->maxlines)
+#define CONBUFFER_LINES_LAST(buf) CONBUFFER_LINES_IDX(buf, (buf)->lines_count - 1)
+#define CONBUFFER_LINES(buf, i) (buf)->lines[CONBUFFER_LINES_IDX(buf, i)]
+#define CONBUFFER_LINES_PRED(buf, i) (((i) + (buf)->maxlines - 1) % (buf)->maxlines)
+#define CONBUFFER_LINES_SUCC(buf, i) (((i) + 1) % (buf)->maxlines)
+#define CONBUFFER_LINES_FIRST(buf) ((buf)->lines_first)
+#define CONBUFFER_LINES_COUNT(buf) ((buf)->lines_count)
void ConBuffer_Init(conbuffer_t *buf, int textsize, int maxlines, mempool_t *mempool);
void ConBuffer_Clear (conbuffer_t *buf);