#include <unistd.h>
#include <time.h>
#include "quakedef.h"
#include "thread.h"
#include "ft2.h"

Include dependency graph for console.c:

Data Structures
struct	con_text_info_t

Macros
#define	CON_LINES(i)

#define	CON_LINES_COUNT CONBUFFER_LINES_COUNT(&con)

#define	CON_LINES_LAST CONBUFFER_LINES_LAST(&con)

#define	NICKS_ADD_COLOR 1

#define	NICKS_ADD_QUOTE 2

#define	NICKS_ALPHANUMERICS_ONLY 8

#define	NICKS_FORCE_COLOR 4

#define	NICKS_NO_SPACES 16

Functions
void	ConBuffer_AddLine (conbuffer_t buf, const char line, int len, unsigned mask)
	Appends a given string as a new line to the console.

static char *	ConBuffer_BytesLeft (conbuffer_t *buf, int len)

void	ConBuffer_Clear (conbuffer_t *buf)

void	ConBuffer_DeleteLastLine (conbuffer_t *buf)
	Deletes the last line from the console history.

void	ConBuffer_DeleteLine (conbuffer_t *buf)
	Deletes the first line from the console history.

int	ConBuffer_FindPrevLine (conbuffer_t *buf, unsigned mask_must, unsigned mask_mustnot, int start)

void	ConBuffer_FixTimes (conbuffer_t *buf)

const char *	ConBuffer_GetLine (conbuffer_t *buf, int i)

void	ConBuffer_Init (conbuffer_t buf, int textsize, int maxlines, mempool_t mempool)

void	ConBuffer_Shutdown (conbuffer_t *buf)

static void	SanitizeString (char in, char out)

Variables
conbuffer_t	con

int	con_backscroll

cvar_t	con_chat = {CF_CLIENT \| CF_ARCHIVE, "con_chat","0", "how many chat lines to show in a dedicated chat area"}

cvar_t	con_chatpos = {CF_CLIENT \| CF_ARCHIVE, "con_chatpos","0", "where to put chat (negative: lines from bottom of screen, positive: lines below notify, 0: at top)"}

cvar_t	con_chatrect = {CF_CLIENT \| CF_ARCHIVE, "con_chatrect","0", "use con_chatrect_x and _y to position con_notify and con_chat freely instead of con_chatpos"}

cvar_t	con_chatrect_x = {CF_CLIENT \| CF_ARCHIVE, "con_chatrect_x","", "where to put chat, relative x coordinate of left edge on screen (use con_chatwidth for width)"}

cvar_t	con_chatrect_y = {CF_CLIENT \| CF_ARCHIVE, "con_chatrect_y","", "where to put chat, relative y coordinate of top edge on screen (use con_chat for line count)"}

cvar_t	con_chatsize = {CF_CLIENT \| CF_ARCHIVE, "con_chatsize","8", "chat text size in virtual 2D pixels (if con_chat is enabled)"}

cvar_t	con_chatsound = {CF_CLIENT \| CF_ARCHIVE, "con_chatsound","1", "enables chat sound to play on message"}

cvar_t	con_chatsound_file = {CF_CLIENT, "con_chatsound_file","sound/misc/talk.wav", "The sound to play for chat messages"}

cvar_t	con_chatsound_team_file = {CF_CLIENT, "con_chatsound_team_file","sound/misc/talk2.wav", "The sound to play for team chat messages"}

cvar_t	con_chatsound_team_mask = {CF_CLIENT, "con_chatsound_team_mask","40","Magic ASCII code that denotes a team chat message"}

cvar_t	con_chattime = {CF_CLIENT \| CF_ARCHIVE, "con_chattime","30", "how long chat lines last, in seconds"}

cvar_t	con_chatwidth = {CF_CLIENT \| CF_ARCHIVE, "con_chatwidth","1.0", "relative chat window width"}

cvar_t	con_completion_exec = {CF_CLIENT \| CF_ARCHIVE, "con_completion_exec", "*.cfg", "completion pattern for the exec command"}

cvar_t	con_completion_playdemo = {CF_CLIENT \| CF_ARCHIVE, "con_completion_playdemo", "*.dem", "completion pattern for the playdemo command"}

cvar_t	con_completion_timedemo = {CF_CLIENT \| CF_ARCHIVE, "con_completion_timedemo", "*.dem", "completion pattern for the timedemo command"}

float	con_cursorspeed = 4

qbool	con_initialized

int	con_linewidth

void *	con_mutex = NULL

cvar_t	con_nickcompletion = {CF_CLIENT \| CF_ARCHIVE, "con_nickcompletion", "1", "tab-complete nicks in console and message input"}

cvar_t	con_nickcompletion_flags

cvar_t	con_notify = {CF_CLIENT \| CF_ARCHIVE, "con_notify","4", "how many notify lines to show"}

cvar_t	con_notifyalign = {CF_CLIENT \| CF_ARCHIVE, "con_notifyalign", "", "how to align notify lines: 0 = left, 0.5 = center, 1 = right, empty string = game default)"}

cvar_t	con_notifysize = {CF_CLIENT \| CF_ARCHIVE, "con_notifysize","8", "notify text size in virtual 2D pixels"}

cvar_t	con_notifytime = {CF_CLIENT \| CF_ARCHIVE, "con_notifytime","3", "how long notify lines last, in seconds"}

cvar_t	con_textsize = {CF_CLIENT \| CF_ARCHIVE, "con_textsize","8", "console text size in virtual 2D pixels"}

int	con_vislines

cvar_t	condump_stripcolors = {CF_CLIENT \| CF_SERVER\| CF_ARCHIVE, "condump_stripcolors", "0", "strip color codes from console dumps"}

static char	qfont_table [256]

cvar_t	rcon_address = {CF_CLIENT, "rcon_address", "", "server address to send rcon commands to (when not connected to a server)"}

cvar_t	rcon_password = {CF_CLIENT \| CF_SERVER \| CF_PRIVATE, "rcon_password", "", "password to authenticate rcon commands; NOTE: changing rcon_secure clears rcon_password, so set rcon_secure always before rcon_password; may be set to a string of the form user1:pass1 user2:pass2 user3:pass3 to allow multiple user accounts - the client then has to specify ONE of these combinations"}

char	rcon_redirect_buffer [1400]

int	rcon_redirect_bufferpos = 0

lhnetaddress_t *	rcon_redirect_dest = NULL

qbool	rcon_redirect_proquakeprotocol = false

lhnetsocket_t *	rcon_redirect_sock = NULL

cvar_t	rcon_secure = {CF_CLIENT \| CF_SERVER, "rcon_secure", "0", "force secure rcon authentication (1 = time based, 2 = challenge based); NOTE: changing rcon_secure clears rcon_password, so set rcon_secure always before rcon_password"}

cvar_t	rcon_secure_challengetimeout = {CF_CLIENT, "rcon_secure_challengetimeout", "5", "challenge-based secure rcon: time out requests if no challenge came within this time interval"}

cvar_t	sys_colortranslation = {CF_CLIENT \| CF_SERVER, "sys_colortranslation", "1", "terminal console color translation (supported values: -1 = print codes without translation, 0 = strip color codes, 1 = translate to ANSI codes, 2 = translate DP RGB to 24-bit and Quake colors to ANSI, 3 = translate all colors to 24-bit RGB)"}

cvar_t	sys_specialcharactertranslation = {CF_CLIENT \| CF_SERVER, "sys_specialcharactertranslation", "1", "terminal console conchars to ASCII translation (set to 0 if your conchars.tga is for an 8bit character set or if you want raw output)"}

Logging
static void	Cmd_CompleteNicksPrint (int count)

void	Con_CenterPrint (const char *str)
	Prints a center-aligned message to the console.

void	Con_CenterPrintf (int maxLineLength, const char *fmt,...)
	Left-pad a string with spaces to make it appear centered.

void	Con_CheckResize (void)
	If the line width has changed, reformat the buffer.

void	Con_Clear_f (cmd_state_t *cmd)

void	Con_ClearNotify (void)
	Clear all notify lines.

static void	Con_CommandMode_f (cmd_state_t *cmd)

int	Con_CompleteCommandLine (cmd_state_t *cmd, qbool is_console)
	wrapper function to attempt to either complete the command line or to list possible matches grouped by type (i.e.

static void	Con_ConDump_f (cmd_state_t *cmd)

static int	Con_CountLineFunc (void passthrough, const char line, size_t length, float width, qbool isContinuation)

static int	Con_DisplayLineFunc (void passthrough, const char line, size_t length, float width, qbool isContinuation)

void	Con_DisplayList (const char **list)
	Generic libs/util/console.c function to display a list formatted in columns on the console.

void	Con_DPrint (const char *msg)
	A Con_Print that only shows up if the "developer" cvar is set.

void	Con_DPrintf (const char *fmt,...)
	A Con_Printf that only shows up if the "developer" cvar is set.

void	Con_DrawConsole (int lines, qbool forcedfullscreen)

static int	Con_DrawConsoleLine (unsigned mask_must, unsigned mask_mustnot, float y, int lineno, float ymin, float ymax)

static void	Con_DrawInput (qbool is_console, float x, float v, float inputsize)

void	Con_DrawNotify (void)

static int	Con_DrawNotifyRect (unsigned mask_must, unsigned mask_mustnot, float maxage, float x, float y, float width, float height, float fontsize, float alignment_x, float alignment_y, const char *continuationString)

void	Con_Init (void)

static void	Con_LastVisibleLine (unsigned mask_must, unsigned mask_mustnot, int last, int limitlast)

static int	Con_LineHeight (int lineno)

static void	Con_Maps_f (cmd_state_t *cmd)

void	Con_MaskPrint (unsigned additionalmask, const char *msg)
	Prints to a chosen console target.

void	Con_MaskPrintf (unsigned mask, const char *fmt,...)

static void	Con_MessageMode2_f (cmd_state_t *cmd)

static void	Con_MessageMode_f (cmd_state_t *cmd)

static void	Con_MsgCmdMode (cmd_state_t *cmd, signed char mode)

void	Con_Print (const char *msg)
	Prints to all appropriate console targets, and adds timestamps.

void	Con_Printf (const char *fmt,...)
	Prints to all appropriate console targets.

static void	Con_PrintToHistory (const char *txt, int mask)

const char *	Con_Quakebar (int len, char *bar, size_t barsize)
	Returns a horizontal line.

static void	Con_Rcon_AddChar (int c)
	Adds a character to the rcon buffer.

static void	Con_RCon_ClearPassword_c (cvar_t *var)

void	Con_Rcon_Redirect_Abort (void)

void	Con_Rcon_Redirect_End (void)

static void	Con_Rcon_Redirect_Flush (void)

void	Con_Rcon_Redirect_Init (lhnetsocket_t sock, lhnetaddress_t dest, qbool proquakeprotocol)

void	Con_Shutdown (void)

void	Con_ToggleConsole_f (cmd_state_t *cmd)

static float	Con_WordWidthFunc (void passthrough, const char w, size_t *length, float maxWidth)

char	crt_log_file [MAX_OSPATH] = ""

qbool	GetMapList (const char s, char completedname, int completednamebufferlength)

void	Log_Close (void)

void	Log_ConPrint (const char *msg)

char	log_dest_buffer [1400]

unsigned int	log_dest_buffer_appending

size_t	log_dest_buffer_pos

cvar_t	log_dest_udp = {CF_CLIENT \| CF_SERVER, "log_dest_udp", "", "UDP address to log messages to (in QW rcon compatible format); multiple destinations can be separated by spaces; DO NOT SPECIFY DNS NAMES HERE"}

void	Log_DestBuffer_Flush (void)
	call this once per frame to send out replies to rcon streaming clients

static void	Log_DestBuffer_Flush_NoLock (void)

static void	Log_DestBuffer_Init (void)

cvar_t	log_file = {CF_CLIENT \| CF_SERVER, "log_file", "", "filename to log messages to"}

cvar_t	log_file_stripcolors = {CF_CLIENT \| CF_SERVER, "log_file_stripcolors", "0", "strip color codes from log messages"}

static void	Log_Open (void)

void	Log_Printf (const char logfilename, const char fmt,...)

void	Log_Start (void)

static const char *	Log_Timestamp (const char *desc)

qfile_t *	logfile = NULL

size_t	logq_ind = 0

size_t	logq_size = 0

unsigned char *	logqueue = NULL

static int	Nicks_AddLastColor (char *buffer, int pos)

static const char **	Nicks_CompleteBuildList (int count)

static int	Nicks_CompleteCountPossible (char line, int pos, char s, qbool isCon)

static void	Nicks_CutMatches (int count)

static void	Nicks_CutMatchesAlphaNumeric (int count)

static void	Nicks_CutMatchesNormal (int count)

static void	Nicks_CutMatchesNoSpaces (int count)

static char	Nicks_list [MAX_SCOREBOARD][MAX_SCOREBOARDNAME]

static int	Nicks_matchpos

static int	Nicks_offset [MAX_SCOREBOARD]

static char	Nicks_sanlist [MAX_SCOREBOARD][MAX_SCOREBOARDNAME]

static unsigned int	Nicks_strcleanlen (const char *s)

static int	Nicks_strncasecmp (char a, char b, unsigned int a_len)

static int	Nicks_strncasecmp_nospaces (char a, char b, unsigned int a_len)

cvar_t	r_textbrightness

cvar_t	r_textcontrast

static char	Sys_Con_NearestColor (const unsigned char _r, const unsigned char _g, const unsigned char _b)
	Convert an RGB color to its nearest quake color.

cvar_t	timeformat

cvar_t	timestamps

Macro Definition Documentation

◆ CON_LINES

#define CON_LINES ( i )

Value:

CONBUFFER_LINES(&con, i)

con

conbuffer_t con

Definition console.c:39

CONBUFFER_LINES

#define CONBUFFER_LINES(buf, i)

Definition console.h:136

i

int i

Definition prvm_execprogram.h:2

Definition at line 42 of file console.c.

Referenced by Con_CheckResize(), Con_ClearNotify(), Con_ConDump_f(), Con_DrawConsole(), Con_DrawConsoleLine(), Con_DrawNotifyRect(), Con_LastVisibleLine(), and Con_LineHeight().

◆ CON_LINES_COUNT

#define CON_LINES_COUNT CONBUFFER_LINES_COUNT(&con)

Definition at line 44 of file console.c.

Referenced by Con_CheckResize(), Con_ClearNotify(), Con_ConDump_f(), Con_DrawConsole(), Con_DrawNotifyRect(), and Con_LastVisibleLine().

◆ CON_LINES_LAST

#define CON_LINES_LAST CONBUFFER_LINES_LAST(&con)

Definition at line 43 of file console.c.

◆ NICKS_ADD_COLOR

#define NICKS_ADD_COLOR 1

Definition at line 77 of file console.c.

Referenced by Nicks_AddLastColor().

◆ NICKS_ADD_QUOTE

#define NICKS_ADD_QUOTE 2

Definition at line 78 of file console.c.

Referenced by Nicks_AddLastColor().

◆ NICKS_ALPHANUMERICS_ONLY

#define NICKS_ALPHANUMERICS_ONLY 8

Definition at line 80 of file console.c.

Referenced by Nicks_CutMatches(), and Nicks_strncasecmp().

◆ NICKS_FORCE_COLOR

#define NICKS_FORCE_COLOR 4

Definition at line 79 of file console.c.

Referenced by Nicks_AddLastColor().

◆ NICKS_NO_SPACES

#define NICKS_NO_SPACES 16

Definition at line 81 of file console.c.

Referenced by Nicks_CutMatches(), Nicks_CutMatchesAlphaNumeric(), and Nicks_strncasecmp().

Function Documentation

◆ Cmd_CompleteNicksPrint()

static void Cmd_CompleteNicksPrint ( int count )

static

Definition at line 2636 of file console.c.

{
    int i;
    for(i = 0; i < count; ++i)
        Con_Printf("%s\n", Nicks_list[i]);
}

References Con_Printf(), count, i, and Nicks_list.

Referenced by Con_CompleteCommandLine().

◆ Con_CenterPrint()

void Con_CenterPrint ( const char * str )

Prints a center-aligned message to the console.

Note: Authored by johnfitz

Parameters

[in] str A multiline string to print

Definition at line 1655 of file console.c.

{
    char bar[42];
 
    Con_MaskPrintf(CON_MASK_HIDENOTIFY, "%s", Con_Quakebar(40, bar, sizeof(bar)));
    Con_CenterPrintf(40, "%s\n", str);
    Con_MaskPrintf(CON_MASK_HIDENOTIFY, "%s", bar);
}

References Con_CenterPrintf(), CON_MASK_HIDENOTIFY, Con_MaskPrintf(), and Con_Quakebar().

Referenced by SCR_CenterPrint().

◆ Con_CenterPrintf()

void Con_CenterPrintf	(	int	maxLineLength,
		const char *	fmt,
			... )

Left-pad a string with spaces to make it appear centered.

Note: Authored by johnfitz

Parameters

[in]	maxLineLength	Center-align
[in]	fmt	A printf format string
[in]	<unnamed>	Zero or more values used by fmt

Definition at line 1600 of file console.c.

{
    va_list argptr;
    char    msg[MAX_INPUTLINE];  // the original message
    char    spaces[21];          // buffer for spaces
    char   *msgCursor, *lineEnding;
    int     lineLength, msgLength;
    size_t  indentSize;
 
    va_start(argptr, fmt);
    msgLength = dpvsnprintf(msg, sizeof (msg), fmt, argptr);
    va_end(argptr);
 
    if (msgLength < 0)
    {
        Con_Printf(CON_WARN "The message given to Con_CenterPrintf was too long\n");
        return;
    }
 
    maxLineLength = min(maxLineLength, con_linewidth);
 
    for (msgCursor = msg; *msgCursor;)
    {
        lineEnding = strchr(msgCursor, '\n');
        if (lineEnding)
        {
            lineLength = lineEnding - msgCursor;  // print just the line
            lineEnding++;  // set cursor to next character after new line
        }
        else // last line
        {
            lineLength = msgLength;  // print entire message
            lineEnding = msgCursor + lineLength;  // set next line cursor to terminator
        }
 
        if (lineLength < maxLineLength)
        {
            indentSize = min(sizeof(spaces) - 1, (size_t)(maxLineLength - lineLength) / 2);
            memset(spaces, ' ', indentSize);
            spaces[indentSize] = 0;
            Con_MaskPrintf(CON_MASK_HIDENOTIFY, "%s%.*s\n", spaces, lineLength, msgCursor);
        }
        else
            Con_MaskPrintf(CON_MASK_HIDENOTIFY, "%.*s\n", lineLength, msgCursor);
        msgLength -= lineEnding - msgCursor;  // Consume all characters until end of line
        msgCursor = lineEnding;  // Update message cursor
    }
}

References con_linewidth, CON_MASK_HIDENOTIFY, Con_MaskPrintf(), Con_Printf(), CON_WARN, dpvsnprintf(), MAX_INPUTLINE, and min.

Referenced by Con_CenterPrint().

◆ Con_CheckResize()

void Con_CheckResize ( void )

If the line width has changed, reformat the buffer.

Definition at line 763 of file console.c.

{
    int i, width;
    float f;
 
    f = bound(1, con_textsize.value, 128);
    if(f != con_textsize.value)
        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)
        CON_LINES(i).height = -1; // recalculate when next needed
 
    Con_ClearNotify();
    con_backscroll = 0;
}

References bound, con, con_backscroll, Con_ClearNotify(), CON_LINES, CON_LINES_COUNT, con_linewidth, con_textsize, Cvar_SetValueQuick(), f, floor(), i, int(), conbuffer_t::textsize, cvar_t::value, vid_conwidth, and width.

Referenced by SCR_SetUpToDrawConsole().

◆ Con_Clear_f()

void Con_Clear_f ( cmd_state_t * cmd )

Definition at line 840 of file console.c.

{
    if (con_mutex) Thread_LockMutex(con_mutex);
    ConBuffer_Clear(&con);
    if (con_mutex) Thread_UnlockMutex(con_mutex);
}

References con, con_mutex, ConBuffer_Clear(), Thread_LockMutex, and Thread_UnlockMutex.

Referenced by Con_Init().

◆ Con_ClearNotify()

void Con_ClearNotify ( void )

Clear all notify lines.

Definition at line 702 of file console.c.

{
    int i;
    for(i = 0; i < CON_LINES_COUNT; ++i)
        if(!(CON_LINES(i).mask & CON_MASK_CHAT))
            CON_LINES(i).mask |= CON_MASK_HIDENOTIFY;
}

References CON_LINES, CON_LINES_COUNT, CON_MASK_CHAT, CON_MASK_HIDENOTIFY, i, and mask.

Referenced by CL_SignonReply(), Con_CheckResize(), and Con_ToggleConsole_f().

◆ Con_CommandMode_f()

static void Con_CommandMode_f ( cmd_state_t * cmd )

static

Definition at line 753 of file console.c.

{
    Con_MsgCmdMode(cmd, -1);
}

References cmd(), and Con_MsgCmdMode().

Referenced by Con_Init().

◆ Con_CompleteCommandLine()

int Con_CompleteCommandLine	(	cmd_state_t *	cmd,
		qbool	is_console )

wrapper function to attempt to either complete the command line or to list possible matches grouped by type (i.e.

will display possible variables, aliases, commands that match what they've typed so far)

Definition at line 2898 of file console.c.

{
    const char *text = "";
    char *s;
    const char **list[4] = {0, 0, 0, 0};
    char s2[512];
    char command[512];
    int c, v, a, i, cmd_len, pos, k;
    int n; // nicks --blub
    const char *space, *patterns;
    char vabuf[1024];
 
    char *line;
    int linestart, linepos;
    unsigned int linesize;
    if (is_console)
    {
        line = key_line;
        linepos = key_linepos;
        linesize = sizeof(key_line);
        linestart = 1;
    }
    else
    {
        line = chat_buffer;
        linepos = chat_bufferpos;
        linesize = sizeof(chat_buffer);
        linestart = 0;
    }
 
    //find what we want to complete
    pos = linepos;
    while(--pos >= linestart)
    {
        k = line[pos];
        if(k == '\"' || k == ';' || k == ' ' || k == '\'')
            break;
    }
    pos++;
 
    s = line + pos;
    dp_strlcpy(s2, line + linepos, sizeof(s2)); //save chars after cursor
    line[linepos] = 0; //hide them
 
    c = v = a = n = cmd_len = 0;
    if (!is_console)
        goto nicks;
 
    space = strchr(line + 1, ' ');
    if(space && pos == (space - line) + 1)
    {
        // adding 1 to line drops the leading ]
        dp_ustr2stp(command, sizeof(command), line + 1, space - (line + 1));
 
        patterns = Cvar_VariableString(cmd->cvars, va(vabuf, sizeof(vabuf), "con_completion_%s", command), CF_CLIENT | CF_SERVER); // TODO maybe use a better place for this?
        if(patterns && !*patterns)
            patterns = NULL; // get rid of the empty string
 
        if(!strcmp(command, "map") || !strcmp(command, "changelevel") || (patterns && !strcmp(patterns, "map")))
        {
            //maps search
            char t[MAX_QPATH];
            if (GetMapList(s, t, sizeof(t)))
            {
                // first move the cursor
                linepos += (int)strlen(t) - (int)strlen(s);
 
                // and now do the actual work
                *s = 0;
                dp_strlcat(line, t, MAX_INPUTLINE);
                dp_strlcat(line, s2, MAX_INPUTLINE); //add back chars after cursor
 
                // and fix the cursor
                if(linepos > (int) strlen(line))
                    linepos = (int) strlen(line);
            }
            return linepos;
        }
        else
        {
            if(patterns)
            {
                char t[MAX_QPATH];
                stringlist_t resultbuf, dirbuf;
 
                // Usage:
                //   // store completion patterns (space separated) for command foo in con_completion_foo
                //   set con_completion_foo "foodata/*.foodefault *.foo"
                //   foo <TAB>
                //
                // Note: patterns with slash are always treated as absolute
                // patterns; patterns without slash search in the innermost
                // directory the user specified. There is no way to "complete into"
                // a directory as of now, as directories seem to be unknown to the
                // FS subsystem.
                //
                // Examples:
                //   set con_completion_playermodel "models/player/*.zym models/player/*.md3 models/player/*.psk models/player/*.dpm"
                //   set con_completion_playdemo "*.dem"
                //   set con_completion_play "*.wav *.ogg"
                //
                // TODO somehow add support for directories; these shall complete
                // to their name + an appended slash.
 
                stringlistinit(&resultbuf);
                stringlistinit(&dirbuf);
                while(COM_ParseToken_Simple(&patterns, false, false, true))
                {
                    fssearch_t *search;
                    if(strchr(com_token, '/'))
                    {
                        search = FS_Search(com_token, true, true, NULL);
                    }
                    else
                    {
                        const char *slash = strrchr(s, '/');
                        if(slash)
                        {
                            dp_strlcpy(t, s, min(sizeof(t), (unsigned int)(slash - s + 2))); // + 2, because I want to include the slash
                            dp_strlcat(t, com_token, sizeof(t));
                            search = FS_Search(t, true, true, NULL);
                        }
                        else
                            search = FS_Search(com_token, true, true, NULL);
                    }
                    if(search)
                    {
                        for(i = 0; i < search->numfilenames; ++i)
                            if(!strncmp(search->filenames[i], s, strlen(s)))
                                if(FS_FileType(search->filenames[i]) == FS_FILETYPE_FILE)
                                    stringlistappend(&resultbuf, search->filenames[i]);
                        FS_FreeSearch(search);
                    }
                }
 
                // In any case, add directory names
                {
                    fssearch_t *search;
                    const char *slash = strrchr(s, '/');
                    if(slash)
                    {
                        dp_strlcpy(t, s, min(sizeof(t), (unsigned int)(slash - s + 2))); // + 2, because I want to include the slash
                        dp_strlcat(t, "*", sizeof(t));
                        search = FS_Search(t, true, true, NULL);
                    }
                    else
                        search = FS_Search("*", true, true, NULL);
                    if(search)
                    {
                        for(i = 0; i < search->numfilenames; ++i)
                            if(!strncmp(search->filenames[i], s, strlen(s)))
                                if(FS_FileType(search->filenames[i]) == FS_FILETYPE_DIRECTORY)
                                    stringlistappend(&dirbuf, search->filenames[i]);
                        FS_FreeSearch(search);
                    }
                }
 
                if(resultbuf.numstrings > 0 || dirbuf.numstrings > 0)
                {
                    const char *p, *q;
                    unsigned int matchchars;
                    if(resultbuf.numstrings == 0 && dirbuf.numstrings == 1)
                    {
                        dpsnprintf(t, sizeof(t), "%s/", dirbuf.strings[0]);
                    }
                    else
                    if(resultbuf.numstrings == 1 && dirbuf.numstrings == 0)
                    {
                        dpsnprintf(t, sizeof(t), "%s ", resultbuf.strings[0]);
                    }
                    else
                    {
                        stringlistsort(&resultbuf, true); // dirbuf is already sorted
                        Con_Printf("\n%i possible filenames\n", resultbuf.numstrings + dirbuf.numstrings);
                        for(i = 0; i < dirbuf.numstrings; ++i)
                        {
                            Con_Printf("^4%s^7/\n", dirbuf.strings[i]);
                        }
                        for(i = 0; i < resultbuf.numstrings; ++i)
                        {
                            Con_Printf("%s\n", resultbuf.strings[i]);
                        }
                        matchchars = sizeof(t) - 1;
                        if(resultbuf.numstrings > 0)
                        {
                            p = resultbuf.strings[0];
                            q = resultbuf.strings[resultbuf.numstrings - 1];
                            for(; *p && *p == *q; ++p, ++q);
                            matchchars = (unsigned int)(p - resultbuf.strings[0]);
                        }
                        if(dirbuf.numstrings > 0)
                        {
                            p = dirbuf.strings[0];
                            q = dirbuf.strings[dirbuf.numstrings - 1];
                            for(; *p && *p == *q; ++p, ++q);
                            matchchars = min(matchchars, (unsigned int)(p - dirbuf.strings[0]));
                        }
                        // now p points to the first non-equal character, or to the end
                        // of resultbuf.strings[0]. We want to append the characters
                        // from resultbuf.strings[0] to (not including) p as these are
                        // the unique prefix
                        dp_strlcpy(t, (resultbuf.numstrings > 0 ? resultbuf : dirbuf).strings[0], min(matchchars + 1, sizeof(t)));
                    }
 
                    // first move the cursor
                    linepos += (int)strlen(t) - (int)strlen(s);
 
                    // and now do the actual work
                    *s = 0;
                    dp_strlcat(line, t, MAX_INPUTLINE);
                    dp_strlcat(line, s2, MAX_INPUTLINE); //add back chars after cursor
 
                    // and fix the cursor
                    if(linepos > (int) strlen(line))
                        linepos = (int) strlen(line);
                }
                stringlistfreecontents(&resultbuf);
                stringlistfreecontents(&dirbuf);
 
                return linepos; // bail out, when we complete for a command that wants a file name
            }
        }
    }
 
    // Count number of possible matches and print them
    c = Cmd_CompleteCountPossible(cmd, s);
    if (c)
    {
        Con_Printf("\n%i possible command%s\n", c, (c > 1) ? "s: " : ":");
        Cmd_CompleteCommandPrint(cmd, s);
    }
    v = Cvar_CompleteCountPossible(cmd->cvars, s, CF_CLIENT | CF_SERVER);
    if (v)
    {
        Con_Printf("\n%i possible variable%s\n", v, (v > 1) ? "s: " : ":");
        Cvar_CompleteCvarPrint(cmd->cvars, s, CF_CLIENT | CF_SERVER);
    }
    a = Cmd_CompleteAliasCountPossible(cmd, s);
    if (a)
    {
        Con_Printf("\n%i possible alias%s\n", a, (a > 1) ? "es: " : ":");
        Cmd_CompleteAliasPrint(cmd, s);
    }
 
nicks:
    n = Nicks_CompleteCountPossible(line, linepos, s, is_console);
    if (n)
    {
        Con_Printf("\n%i possible nick%s\n", n, (n > 1) ? "s: " : ":");
        Cmd_CompleteNicksPrint(n);
    }
 
    if (!(c + v + a + n))   // No possible matches
    {
        if(s2[0])
            dp_strlcpy(&line[linepos], s2, linesize - linepos);
        return linepos;
    }
 
    if (c)
        text = *(list[0] = Cmd_CompleteBuildList(cmd, s));
    if (v)
        text = *(list[1] = Cvar_CompleteBuildList(cmd->cvars, s, cmd->cvars_flagsmask));
    if (a)
        text = *(list[2] = Cmd_CompleteAliasBuildList(cmd, s));
    if (n)
    {
        if (is_console)
            text = *(list[3] = Nicks_CompleteBuildList(n));
        else
            text = *(Nicks_CompleteBuildList(n));
    }
 
    for (cmd_len = (int)strlen(s);;cmd_len++)
    {
        const char **l;
        for (i = 0; i < 3; i++)
            if (list[i])
                for (l = list[i];*l;l++)
                    if ((*l)[cmd_len] != text[cmd_len])
                        goto done;
        // all possible matches share this character, so we continue...
        if (!text[cmd_len])
        {
            // if all matches ended at the same position, stop
            // (this means there is only one match)
            break;
        }
    }
done:
 
    // prevent a buffer overrun by limiting cmd_len according to remaining space
    cmd_len = min(cmd_len, (int)linesize - 1 - pos);
    if (text)
    {
        linepos = pos;
        memcpy(&line[linepos], text, cmd_len);
        linepos += cmd_len;
        // if there is only one match, add a space after it
        if (c + v + a + n == 1 && linepos < (int)linesize - 1)
        {
            if(n)
            { // was a nick, might have an offset, and needs colors ;) --blub
                linepos = pos - Nicks_offset[0];
                cmd_len = (int)strlen(Nicks_list[0]);
                cmd_len = min(cmd_len, (int)linesize - 3 - pos);
 
                memcpy(&line[linepos] , Nicks_list[0], cmd_len);
                linepos += cmd_len;
                if(linepos < (int)(linesize - 7)) // space for color code (^[0-9] or ^xrgb), space and \0
                    linepos = Nicks_AddLastColor(line, linepos);
            }
            line[linepos++] = ' ';
        }
    }
 
    // use strlcat to avoid a buffer overrun
    line[linepos] = 0;
    dp_strlcat(line, s2, linesize);
 
    if (!is_console)
        return linepos;
 
    // free the command, cvar, and alias lists
    for (i = 0; i < 4; i++)
        if (list[i])
            Mem_Free((void *)list[i]);
 
    return linepos;
}

References a, CF_CLIENT, CF_SERVER, chat_buffer, chat_bufferpos, cmd(), Cmd_CompleteAliasBuildList(), Cmd_CompleteAliasCountPossible(), Cmd_CompleteAliasPrint(), Cmd_CompleteBuildList(), Cmd_CompleteCommandPrint(), Cmd_CompleteCountPossible(), Cmd_CompleteNicksPrint(), COM_ParseToken_Simple(), com_token, Con_Printf(), Cvar_CompleteBuildList(), Cvar_CompleteCountPossible(), Cvar_CompleteCvarPrint(), Cvar_VariableString(), dp_strlcat, dp_strlcpy, dp_ustr2stp(), dpsnprintf(), fssearch_t::filenames, FS_FileType(), FS_FILETYPE_DIRECTORY, FS_FILETYPE_FILE, FS_FreeSearch(), FS_Search(), GetMapList(), i, int(), key_line, key_linepos, MAX_INPUTLINE, MAX_QPATH, Mem_Free, min, n, Nicks_AddLastColor(), Nicks_CompleteBuildList(), Nicks_CompleteCountPossible(), Nicks_list, Nicks_offset, NULL, fssearch_t::numfilenames, stringlist_t::numstrings, stringlistappend(), stringlistfreecontents(), stringlistinit(), stringlistsort(), stringlist_t::strings, strlen(), v, and va().

Referenced by Key_Parse_CommonKeys().

◆ Con_ConDump_f()

static void Con_ConDump_f ( cmd_state_t * cmd )

static

Definition at line 802 of file console.c.

{
    int i;
    qfile_t *file;
    if (Cmd_Argc(cmd) != 2)
    {
        Con_Printf("usage: condump <filename>\n");
        return;
    }
    file = FS_OpenRealFile(Cmd_Argv(cmd, 1), "w", false);
    if (!file)
    {
        Con_Printf(CON_ERROR "condump: unable to write file \"%s\"\n", Cmd_Argv(cmd, 1));
        return;
    }
    if (con_mutex) Thread_LockMutex(con_mutex);
    for(i = 0; i < CON_LINES_COUNT; ++i)
    {
        if (condump_stripcolors.integer)
        {
            // sanitize msg
            size_t len = CON_LINES(i).len;
            char* sanitizedmsg = (char*)Mem_Alloc(tempmempool, len + 1);
            memcpy (sanitizedmsg, CON_LINES(i).start, len);
            SanitizeString(sanitizedmsg, sanitizedmsg); // SanitizeString's in pointer is always ahead of the out pointer, so this should work.
            FS_Write(file, sanitizedmsg, strlen(sanitizedmsg));
            Mem_Free(sanitizedmsg);
        }
        else 
        {
            FS_Write(file, CON_LINES(i).start, CON_LINES(i).len);
        }
        FS_Write(file, "\n", 1);
    }
    if (con_mutex) Thread_UnlockMutex(con_mutex);
    FS_Close(file);
}

References cmd(), Cmd_Argc(), Cmd_Argv(), CON_ERROR, CON_LINES, CON_LINES_COUNT, con_mutex, Con_Printf(), condump_stripcolors, FS_Close(), FS_OpenRealFile(), FS_Write(), i, cvar_t::integer, Mem_Alloc, Mem_Free, SanitizeString(), strlen(), tempmempool, Thread_LockMutex, and Thread_UnlockMutex.

Referenced by Con_Init().

◆ Con_CountLineFunc()

static int Con_CountLineFunc	(	void *	passthrough,
		const char *	line,
		size_t	length,
		float	width,
		qbool	isContinuation )

static

Definition at line 1832 of file console.c.

{
    (void) passthrough;
    (void) line;
    (void) length;
    (void) width;
    (void) isContinuation;
    return 1;
}

References length, void(), and width.

Referenced by Con_DrawNotifyRect(), and Con_LineHeight().

◆ Con_DisplayLineFunc()

static int Con_DisplayLineFunc	(	void *	passthrough,
		const char *	line,
		size_t	length,
		float	width,
		qbool	isContinuation )

static

Definition at line 1842 of file console.c.

{
    con_text_info_t *ti = (con_text_info_t *) passthrough;
 
    if(ti->y < ti->ymin - 0.001)
        (void) 0;
    else if(ti->y > ti->ymax - ti->fontsize + 0.001)
        (void) 0;
    else
    {
        int x = (int) (ti->x + (ti->width - width) * ti->alignment);
        if(isContinuation && *ti->continuationString)
            x = (int) DrawQ_String(x, ti->y, ti->continuationString, strlen(ti->continuationString), ti->fontsize, ti->fontsize, 1.0, 1.0, 1.0, 1.0, 0, NULL, false, ti->font);
        if(length > 0)
            DrawQ_String(x, ti->y, line, length, ti->fontsize, ti->fontsize, 1.0, 1.0, 1.0, 1.0, 0, &(ti->colorindex), false, ti->font);
    }
 
    ti->y += ti->fontsize;
    return 1;
}

References con_text_info_t::alignment, con_text_info_t::colorindex, con_text_info_t::continuationString, DrawQ_String(), con_text_info_t::font, con_text_info_t::fontsize, int(), length, NULL, strlen(), void(), con_text_info_t::width, width, con_text_info_t::x, x, con_text_info_t::y, con_text_info_t::ymax, and con_text_info_t::ymin.

Referenced by Con_DrawConsoleLine(), and Con_DrawNotifyRect().

◆ Con_DisplayList()

void Con_DisplayList ( const char ** list )

Generic libs/util/console.c function to display a list formatted in columns on the console.

Definition at line 2452 of file console.c.

{
    int i = 0, pos = 0, len = 0, maxlen = 0, width = (con_linewidth - 4);
    const char **walk = list;
 
    while (*walk) {
        len = (int)strlen(*walk);
        if (len > maxlen)
            maxlen = len;
        walk++;
    }
    maxlen += 1;
 
    while (*list) {
        len = (int)strlen(*list);
        if (pos + maxlen >= width) {
            Con_Print("\n");
            pos = 0;
        }
 
        Con_Print(*list);
        for (i = 0; i < (maxlen - len); i++)
            Con_Print(" ");
 
        pos += maxlen;
        list++;
    }
 
    if (pos)
        Con_Print("\n\n");
}

References con_linewidth, Con_Print(), i, int(), strlen(), and width.

◆ Con_DPrint()

void Con_DPrint ( const char * msg )

A Con_Print that only shows up if the "developer" cvar is set.

Definition at line 1531 of file console.c.

{
    if(developer.integer < 0) // at 0, we still add to the buffer but hide
        return;
 
    Con_MaskPrint(CON_MASK_DEVELOPER, msg);
}

References CON_MASK_DEVELOPER, Con_MaskPrint(), developer, and cvar_t::integer.

Referenced by CL_DisconnectEx(), CL_NewBeam(), CL_ParseServerInfo(), CL_SetSignonStage_WithMsg(), CL_VM_ShutDown(), Collision_NewBrushFromPlanes(), Cvar_Command(), Cvar_RestoreInitState(), Cvar_Set_f(), Cvar_SetA_f(), Font_LoadMap(), GL_CheckExtension(), GL_Setup(), Host_Init(), M_Menu_Main_f(), Mod_LoadQ3Shaders(), NetConn_ReceivedMessage(), Palette_Load(), PRVM_ED_CallSpawnFunction(), S_PaintAndSubmit(), SndSys_Init(), SV_Color_f(), SV_Prepare_CSQC(), SV_Spawn_f(), and VID_InitModeGL().

◆ Con_DPrintf()

void Con_DPrintf	(	const char *	fmt,
			... )

A Con_Printf that only shows up if the "developer" cvar is set.

Definition at line 1544 of file console.c.

{
    va_list argptr;
    char msg[MAX_INPUTLINE];
 
    if(developer.integer < 0) // at 0, we still add to the buffer but hide
        return;
 
    va_start(argptr,fmt);
    dpvsnprintf(msg,sizeof(msg),fmt,argptr);
    va_end(argptr);
 
    Con_MaskPrint(CON_MASK_DEVELOPER, msg);
}

References CON_MASK_DEVELOPER, Con_MaskPrint(), developer, dpvsnprintf(), cvar_t::integer, and MAX_INPUTLINE.

Referenced by _Mem_Alloc(), _Mem_Free(), _Mem_FreeBlock(), alert_legacy_font_api(), Buffer_Callback(), CDAudio_Play_byName(), CheckPendingDownloads(), CL_DisconnectEx(), CL_ExaminePrintString(), CL_IPLog_Add(), CL_LinkEdict(), CL_NetworkTimeReceived(), CL_NewParticlesFromEffectinfo(), CL_OpenVideo(), CL_ParseServerMessage(), CL_ParseStatic(), CL_ParticleEffect_Fallback(), CL_SignonReply(), CL_Startdemos_f(), CL_StopDownload(), CL_ValidateState(), CL_VM_Init(), CLVM_ExecuteProgram(), Cmd_AddCommand(), Cmd_RestoreInitState(), Collision_CalcPlanesForTriangleBrushFloat(), Collision_NewBrushFromPlanes(), Crypto_ServerError(), Crypto_SoftClientError(), Crypto_SoftServerError(), Curl_Begin(), Curl_CheckCommandWhenDone(), curl_default_callback(), Cvar_Get(), Cvar_RegisterCallback(), Cvar_RegisterVariable(), Cvar_RegisterVirtual(), Cvar_RestoreInitState(), Cvar_SetQuick(), Draw_CachePic_Flags(), Draw_Frame(), Draw_FreePic(), Draw_GetPicTexture(), Draw_IsPicLoaded(), Draw_NewPic(), EntityFrame5_WriteFrame(), EntityFrameCSQC_LostFrame(), EntityFrameQW_CL_ReadFrame(), EntityState5_Priority(), Font_LoadFile(), Font_LoadMap(), FS_FindFile(), FS_Init_Dir(), FS_LoadPackPAK(), FS_LoadPackPK3FromFD(), FS_LoadPackVirtual(), FS_OpenReadFile(), FS_UnloadPacks_dlcache(), FS_WriteFileInBlocks(), GetMapList(), GL_Backend_CompileProgram(), GL_CheckExtension(), GL_InitFunctions(), gl_main_start(), GL_Setup(), JPEG_SaveImage_to_Buffer(), Key_Event(), LHNET_OpenSocket_Connectionless(), LHNET_Read(), LHNET_Write(), LoadFont(), LoadFont_f(), loadimagepixelsbgra(), LoadSubtitles(), Mod_BuildAliasSkinsFromSkinFiles(), Mod_LoadCustomMaterial(), Mod_LoadModel(), Mod_LoadQ3Shaders(), Mod_LoadQ3Shaders_EnumerateWaveFunc(), Mod_LoadTextureFromQ3Shader(), Mod_Mesh_Validate(), Mod_OBJ_Load(), Mod_PSKMODEL_Load(), Mod_Q1BSP_Load(), Mod_Q1BSP_LoadTextures(), Mod_Q2BSP_Load(), Mod_Q2BSP_LoadBrushes(), Mod_Q3BSP_Load(), Mod_Q3BSP_LoadFaces(), Mod_Q3BSP_LoadLightmaps(), NetConn_ClientParsePacket(), NetConn_ServerParsePacket(), PRVM_ED_LoadFromFile(), PRVM_ED_ParseEdict(), PRVM_ED_ParseEpair(), PRVM_ED_ParseGlobals(), PRVM_GarbageCollection(), PRVM_Init(), PRVM_MarkReferencedEdicts(), PRVM_Prog_Load(), PRVM_SetEngineString(), PRVM_SetTempString(), Q3Shader_AddToHash(), QW_CL_NextUpload_f(), QW_CL_ServerInfo(), QW_CL_StartUpload(), R_BuildFogTexture(), R_GLSL_CompilePermutation(), R_LoadCubemap(), R_LoadTextureDDSFile(), R_Mesh_Draw(), R_Mesh_VertexPointer(), R_Modules_Shutdown(), R_Modules_Start(), R_Q1BSP_CallRecursiveGetLightInfo(), R_RTLight_Compile(), R_SetupShader_SetPermutationGLSL(), R_UpdateTexture(), S_PaintAndSubmit(), S_PlaySfxOnChannel(), Sbar_DeathmatchOverlay(), SCR_CaptureVideo_Ogg_BeginVideo(), SCR_CaptureVideo_RIFF_Finish(), SCR_DrawInfobar(), SCR_PopLoadingScreen(), ShaderModeInfo_GetShaderText(), SV_ConnectClient(), SV_Download_f(), SV_DropClient(), SV_LinkEdict(), SV_Prepare_CSQC(), SV_ReadClientMessage(), SV_ReadClientMove(), SV_SendServerinfo(), SV_Shutdown(), SV_ThreadFunc(), SV_UnstickEntity(), SV_VM_Setup(), SVVM_ExecuteProgram(), Sys_LoadDependency(), Sys_LoadDependencyFunctions(), Sys_SDL_HandleEvents(), VID_ApplyDisplayMode(), VID_ApplyDisplayMode_c(), VID_EnableJoystick(), VID_ListModes(), VID_SetMouse(), VID_SetVsync_c(), VM_CL_gettagindex(), VM_CL_gettaginfo(), VM_CL_R_AddDynamicLight(), VM_CL_setattachment(), VM_dprint(), VM_fclose(), VM_fgets(), VM_fopen(), VM_fputs(), VM_FrameBlendFromFrameGroupBlend(), VM_SV_gettagindex(), VM_SV_gettaginfo(), VM_SV_setattachment(), VM_SV_sound(), and World_SetSize().

◆ Con_DrawConsole()

void Con_DrawConsole	(	int	lines,
		qbool	forcedfullscreen )

Definition at line 2138 of file console.c.

{
    float alpha, alpha0;
    double sx, sy;
    int mask_must = 0;
    int mask_mustnot = (developer.integer>0) ? 0 : CON_MASK_DEVELOPER;
    cachepic_t *conbackpic;
    unsigned int conbackflags;
 
    if (lines <= 0)
        return;
 
    if (con_mutex) Thread_LockMutex(con_mutex);
 
    if (con_backscroll < 0)
        con_backscroll = 0;
 
    con_vislines = lines;
 
    r_draw2d_force = true;
 
// draw the background
    alpha0 = forcedfullscreen ? 1.0f : scr_conalpha.value; // always full alpha when not forced fullscreen
    if((alpha = alpha0 * scr_conalphafactor.value) > 0)
    {
        sx = scr_conscroll_x.value;
        sy = scr_conscroll_y.value;
        conbackflags = CACHEPICFLAG_FAILONMISSING; // So console is readable when game content is missing
        if (sx != 0 || sy != 0)
            conbackflags &= CACHEPICFLAG_NOCLAMP;
        conbackpic = scr_conbrightness.value >= 0.01f ? Draw_CachePic_Flags("gfx/conback", conbackflags) : NULL;
        sx *= host.realtime; sy *= host.realtime;
        sx -= floor(sx); sy -= floor(sy);
        if (Draw_IsPicLoaded(conbackpic))
            DrawQ_SuperPic(0, lines - vid_conheight.integer, conbackpic, vid_conwidth.integer, vid_conheight.integer,
                    0 + sx, 0 + sy, scr_conbrightness.value, scr_conbrightness.value, scr_conbrightness.value, alpha,
                    1 + sx, 0 + sy, scr_conbrightness.value, scr_conbrightness.value, scr_conbrightness.value, alpha,
                    0 + sx, 1 + sy, scr_conbrightness.value, scr_conbrightness.value, scr_conbrightness.value, alpha,
                    1 + sx, 1 + sy, scr_conbrightness.value, scr_conbrightness.value, scr_conbrightness.value, alpha,
                    0);
        else
            DrawQ_Fill(0, lines - vid_conheight.integer, vid_conwidth.integer, vid_conheight.integer, 0.0f, 0.0f, 0.0f, alpha, 0);
    }
    if((alpha = alpha0 * scr_conalpha2factor.value) > 0)
    {
        sx = scr_conscroll2_x.value;
        sy = scr_conscroll2_y.value;
        conbackpic = Draw_CachePic_Flags("gfx/conback2", (sx != 0 || sy != 0) ? CACHEPICFLAG_NOCLAMP : 0);
        sx *= host.realtime; sy *= host.realtime;
        sx -= floor(sx); sy -= floor(sy);
        if(Draw_IsPicLoaded(conbackpic))
            DrawQ_SuperPic(0, lines - vid_conheight.integer, conbackpic, vid_conwidth.integer, vid_conheight.integer,
                    0 + sx, 0 + sy, scr_conbrightness.value, scr_conbrightness.value, scr_conbrightness.value, alpha,
                    1 + sx, 0 + sy, scr_conbrightness.value, scr_conbrightness.value, scr_conbrightness.value, alpha,
                    0 + sx, 1 + sy, scr_conbrightness.value, scr_conbrightness.value, scr_conbrightness.value, alpha,
                    1 + sx, 1 + sy, scr_conbrightness.value, scr_conbrightness.value, scr_conbrightness.value, alpha,
                    0);
    }
    if((alpha = alpha0 * scr_conalpha3factor.value) > 0)
    {
        sx = scr_conscroll3_x.value;
        sy = scr_conscroll3_y.value;
        conbackpic = Draw_CachePic_Flags("gfx/conback3", (sx != 0 || sy != 0) ? CACHEPICFLAG_NOCLAMP : 0);
        sx *= host.realtime; sy *= host.realtime;
        sx -= floor(sx); sy -= floor(sy);
        if(Draw_IsPicLoaded(conbackpic))
            DrawQ_SuperPic(0, lines - vid_conheight.integer, conbackpic, vid_conwidth.integer, vid_conheight.integer,
                    0 + sx, 0 + sy, scr_conbrightness.value, scr_conbrightness.value, scr_conbrightness.value, alpha,
                    1 + sx, 0 + sy, scr_conbrightness.value, scr_conbrightness.value, scr_conbrightness.value, alpha,
                    0 + sx, 1 + sy, scr_conbrightness.value, scr_conbrightness.value, scr_conbrightness.value, alpha,
                    1 + sx, 1 + sy, scr_conbrightness.value, scr_conbrightness.value, scr_conbrightness.value, alpha,
                    0);
    }
    DrawQ_String(vid_conwidth.integer - DrawQ_TextWidth(engineversion, 0, con_textsize.value, con_textsize.value, false, FONT_CONSOLE), 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 0
    {
        int i;
        int count = CON_LINES_COUNT;
        float ymax = con_vislines - 2 * con_textsize.value;
        float y = ymax + con_textsize.value * con_backscroll;
        for (i = 0;i < count && y >= 0;i++)
            y -= Con_DrawConsoleLine(mask_must, mask_mustnot, y - con_textsize.value, CON_LINES_COUNT - 1 - i, 0, ymax) * con_textsize.value;
        // fix any excessive scrollback for the next frame
        if (i >= count && y >= 0)
        {
            con_backscroll -= (int)(y / con_textsize.value);
            if (con_backscroll < 0)
                con_backscroll = 0;
        }
    }
#else
    if(CON_LINES_COUNT > 0)
    {
        int i, last, limitlast;
        float y;
        float ymax = con_vislines - 2 * con_textsize.value;
        Con_LastVisibleLine(mask_must, mask_mustnot, &last, &limitlast);
        //Con_LastVisibleLine(mask_must, mask_mustnot, &last, &limitlast);
        y = ymax - con_textsize.value;
 
        if(limitlast)
            y += (CON_LINES(last).height - limitlast) * con_textsize.value;
        i = last;
 
        for(;;)
        {
            y -= Con_DrawConsoleLine(mask_must, mask_mustnot, y, i, 0, ymax) * con_textsize.value;
            if(i == 0)
                break; // top of console buffer
            if(y < 0)
                break; // top of console window
            limitlast = 0;
            --i;
        }
    }
#endif
 
// draw the input prompt, user text, and cursor if desired
    Con_DrawInput(true, 0, con_vislines - con_textsize.value * 2, con_textsize.value);
 
    r_draw2d_force = false;
    if (con_mutex) Thread_UnlockMutex(con_mutex);
}

References alpha, CACHEPICFLAG_FAILONMISSING, CACHEPICFLAG_NOCLAMP, con_backscroll, Con_DrawConsoleLine(), Con_DrawInput(), Con_LastVisibleLine(), CON_LINES, CON_LINES_COUNT, CON_MASK_DEVELOPER, con_mutex, con_textsize, con_vislines, count, developer, Draw_CachePic_Flags(), Draw_IsPicLoaded(), DrawQ_Fill(), DrawQ_String(), DrawQ_SuperPic(), DrawQ_TextWidth(), engineversion, floor(), FONT_CONSOLE, host, i, int(), cvar_t::integer, NULL, r_draw2d_force, host_static_t::realtime, scr_conalpha, scr_conalpha2factor, scr_conalpha3factor, scr_conalphafactor, scr_conbrightness, scr_conscroll2_x, scr_conscroll2_y, scr_conscroll3_x, scr_conscroll3_y, scr_conscroll_x, scr_conscroll_y, Thread_LockMutex, Thread_UnlockMutex, cvar_t::value, vid_conheight, vid_conwidth, and y.

Referenced by SCR_DrawConsole().

◆ Con_DrawConsoleLine()

static int Con_DrawConsoleLine	(	unsigned	mask_must,
		unsigned	mask_mustnot,
		float	y,
		int	lineno,
		float	ymin,
		float	ymax )

static

Definition at line 2064 of file console.c.

{
    float width = vid_conwidth.value;
    con_text_info_t ti;
    con_lineinfo_t *li = &CON_LINES(lineno);
 
    if((li->mask & mask_must) != mask_must)
        return 0;
    if((li->mask & mask_mustnot) != 0)
        return 0;
 
    ti.continuationString = "";
    ti.alignment = 0;
    ti.fontsize = con_textsize.value;
    ti.font = FONT_CONSOLE;
    ti.x = 0;
    ti.y = y - (Con_LineHeight(lineno) - 1) * ti.fontsize;
    ti.ymin = ymin;
    ti.ymax = ymax;
    ti.width = width;
 
    return COM_Wordwrap(li->start, li->len, 0, width, Con_WordWidthFunc, &ti, Con_DisplayLineFunc, &ti);
}

References con_text_info_t::alignment, COM_Wordwrap(), Con_DisplayLineFunc(), Con_LineHeight(), CON_LINES, con_textsize, Con_WordWidthFunc(), con_text_info_t::continuationString, con_text_info_t::font, FONT_CONSOLE, con_text_info_t::fontsize, con_lineinfo_t::len, con_lineinfo_t::mask, con_lineinfo_t::start, cvar_t::value, vid_conwidth, con_text_info_t::width, width, con_text_info_t::x, con_text_info_t::y, y, con_text_info_t::ymax, and con_text_info_t::ymin.

Referenced by Con_DrawConsole().

◆ Con_DrawInput()

static void Con_DrawInput	(	qbool	is_console,
		float	x,
		float	v,
		float	inputsize )

static

Definition at line 1684 of file console.c.

{
    int y, i, col_out, linepos, text_start, prefix_start = 0;
    char text[MAX_INPUTLINE + 5 + 9 + 1]; // space for ^xRGB, "say_team:" and \0
    float xo;
    size_t len_out;
    const char *prefix;
    dp_font_t *fnt;
 
    if (is_console && !key_consoleactive)
        return;     // don't draw anything
 
    if (is_console)
    {
        // empty prefix because ] is part of the console edit line
        prefix = "";
        dp_strlcpy(text, key_line, sizeof(text));
        linepos = key_linepos;
        fnt = FONT_CONSOLE;
    }
    else
    {
        if (chat_mode < 0)
            prefix = "]";
        else if(chat_mode)
            prefix = "say_team:";
        else
            prefix = "say:";
        dp_strlcpy(text, chat_buffer, sizeof(text));
        linepos = chat_bufferpos;
        fnt = FONT_CHAT;
    }
 
    y = (int)strlen(text);
 
    // make the color code visible when the cursor is inside it
    if(text[linepos] != 0)
    {
        for(i=1; i < 5 && linepos - i > 0; ++i)
            if(text[linepos-i] == STRING_COLOR_TAG)
            {
                int caret_pos, ofs = 0;
                caret_pos = linepos - i;
                if(i == 1 && text[caret_pos+1] == STRING_COLOR_TAG)
                    ofs = 1;
                else if(i == 1 && isdigit(text[caret_pos+1]))
                    ofs = 2;
                else if(text[caret_pos+1] == STRING_COLOR_RGB_TAG_CHAR && isxdigit(text[caret_pos+2]) && isxdigit(text[caret_pos+3]) && isxdigit(text[caret_pos+4]))
                    ofs = 5;
                if(ofs && (size_t)(y + ofs + 1) < sizeof(text))
                {
                    int carets = 1;
                    while(caret_pos - carets >= 1 && text[caret_pos - carets] == STRING_COLOR_TAG)
                        ++carets;
                    if(carets & 1)
                    {
                        // str^2ing (displayed as string) --> str^2^^2ing (displayed as str^2ing)
                        // str^^ing (displayed as str^ing) --> str^^^^ing (displayed as str^^ing)
                        memmove(&text[caret_pos + ofs + 1], &text[caret_pos], y - caret_pos);
                        text[caret_pos + ofs] = STRING_COLOR_TAG;
                        y += ofs + 1;
                        text[y] = 0;
                    }
                }
                break;
            }
    }
 
    if (!is_console)
    {
        prefix_start = x;
        x += DrawQ_TextWidth(prefix, 0, inputsize, inputsize, false, fnt);
    }
 
    len_out = linepos;
    col_out = -1;
    xo = 0;
    if (linepos > 0)
        xo = DrawQ_TextWidth_UntilWidth_TrackColors(text, &len_out, inputsize, inputsize, &col_out, false, fnt, 1000000000);
 
    text_start = x + (vid_conwidth.value - x) * 0.95 - xo; // scroll
    if(text_start >= x)
        text_start = x;
    else if (!is_console)
        prefix_start -= (x - text_start);
 
    if (!is_console)
        DrawQ_String(prefix_start, v, prefix, 0, inputsize, inputsize, 1.0, 1.0, 1.0, 1.0, 0, NULL, false, fnt);
 
    DrawQ_String(text_start, v, text, y + 3, inputsize, inputsize, 1.0, 1.0, 1.0, 1.0, 0, NULL, false, fnt);
 
    // draw a cursor on top of this
    if ((int)(host.realtime*con_cursorspeed) & 1)       // cursor is visible
    {
        if (!utf8_enable.integer)
        {
            text[0] = 11 + 130 * key_insert;    // either solid or triangle facing right
            text[1] = 0;
        }
        else
        {
            size_t len;
            const char *curbuf;
            char charbuf16[16];
            curbuf = u8_encodech(0xE000 + 11 + 130 * key_insert, &len, charbuf16);
            memcpy(text, curbuf, len);
            text[len] = 0;
        }
        DrawQ_String(text_start + xo, v, text, 0, inputsize, inputsize, 1.0, 1.0, 1.0, 1.0, 0, &col_out, false, fnt);
    }
}

References chat_buffer, chat_bufferpos, chat_mode, con_cursorspeed, dp_strlcpy, DrawQ_String(), DrawQ_TextWidth(), DrawQ_TextWidth_UntilWidth_TrackColors(), FONT_CHAT, FONT_CONSOLE, host, i, int(), cvar_t::integer, key_consoleactive, key_insert, key_line, key_linepos, MAX_INPUTLINE, NULL, ofs, prefix, host_static_t::realtime, STRING_COLOR_RGB_TAG_CHAR, STRING_COLOR_TAG, strlen(), u8_encodech(), utf8_enable, v, cvar_t::value, vid_conwidth, x, and y.

Referenced by Con_DrawConsole(), and Con_DrawNotify().

◆ Con_DrawNotify()

void Con_DrawNotify ( void )

Definition at line 1945 of file console.c.

{
    float x, v;
    float chatstart, notifystart, inputsize, height;
    float align;
    int numChatlines;
    int chatpos;
 
    if (con_mutex) Thread_LockMutex(con_mutex);
    ConBuffer_FixTimes(&con);
 
    numChatlines = con_chat.integer;
 
    chatpos = con_chatpos.integer;
 
    if (con_notify.integer < 0)
        Cvar_SetValueQuick(&con_notify, 0);
    if (gamemode == GAME_TRANSFUSION)
        v = 8; // vertical offset
    else
        v = 0;
 
    // GAME_NEXUIZ: center, otherwise left justify
    align = con_notifyalign.value;
    if(!*con_notifyalign.string) // empty string, evaluated to 0 above
    {
        if(IS_OLDNEXUIZ_DERIVED(gamemode))
            align = 0.5;
    }
 
    if(numChatlines || !con_chatrect.integer)
    {
        if(chatpos == 0)
        {
            // first chat, input line, then notify
            chatstart = v;
            notifystart = v + (numChatlines + 1) * con_chatsize.value;
        }
        else if(chatpos > 0)
        {
            // first notify, then (chatpos-1) empty lines, then chat, then input
            notifystart = v;
            chatstart = v + (con_notify.value + (chatpos - 1)) * con_notifysize.value;
        }
        else // if(chatpos < 0)
        {
            // first notify, then much space, then chat, then input, then -chatpos-1 empty lines
            notifystart = v;
            chatstart = vid_conheight.value - (-chatpos-1 + numChatlines + 1) * con_chatsize.value;
        }
    }
    else
    {
        // just notify and input
        notifystart = v;
        chatstart = 0; // shut off gcc warning
    }
 
    v = notifystart + con_notifysize.value * Con_DrawNotifyRect(0, CON_MASK_INPUT | CON_MASK_HIDENOTIFY | (numChatlines ? CON_MASK_CHAT : 0) | CON_MASK_DEVELOPER, con_notifytime.value, 0, notifystart, vid_conwidth.value, con_notify.value * con_notifysize.value, con_notifysize.value, align, 0.0, "");
 
    if(con_chatrect.integer)
    {
        x = con_chatrect_x.value * vid_conwidth.value;
        v = con_chatrect_y.value * vid_conheight.value;
    }
    else
    {
        x = 0;
        if(numChatlines) // only do this if chat area is enabled, or this would move the input line wrong
            v = chatstart;
    }
    height = numChatlines * con_chatsize.value;
 
    if(numChatlines)
    {
        Con_DrawNotifyRect(CON_MASK_CHAT, CON_MASK_INPUT, con_chattime.value, x, v, vid_conwidth.value * con_chatwidth.value, height, con_chatsize.value, 0.0, 1.0, "^3 ... ");
        v += height;
    }
    if (key_dest == key_message)
    {
        inputsize = (numChatlines ? con_chatsize : con_notifysize).value;
        Con_DrawInput(false, x, v, inputsize);
    }
    else
        chat_bufferpos = 0;
 
    if (con_mutex) Thread_UnlockMutex(con_mutex);
}

References chat_bufferpos, con, con_chat, con_chatpos, con_chatrect, con_chatrect_x, con_chatrect_y, con_chatsize, con_chattime, con_chatwidth, Con_DrawInput(), Con_DrawNotifyRect(), CON_MASK_CHAT, CON_MASK_DEVELOPER, CON_MASK_HIDENOTIFY, CON_MASK_INPUT, con_mutex, con_notify, con_notifyalign, con_notifysize, con_notifytime, ConBuffer_FixTimes(), Cvar_SetValueQuick(), GAME_TRANSFUSION, gamemode, height, cvar_t::integer, IS_OLDNEXUIZ_DERIVED, key_dest, key_message, cvar_t::string, Thread_LockMutex, Thread_UnlockMutex, v, cvar_t::value, value, vid_conheight, vid_conwidth, and x.

Referenced by SCR_DrawScreen().

◆ Con_DrawNotifyRect()

static int Con_DrawNotifyRect	(	unsigned	mask_must,
		unsigned	mask_mustnot,
		float	maxage,
		float	x,
		float	y,
		float	width,
		float	height,
		float	fontsize,
		float	alignment_x,
		float	alignment_y,
		const char *	continuationString )

static

Definition at line 1863 of file console.c.

{
    int i;
    int lines = 0;
    int maxlines = (int) floor(height / fontsize + 0.01f);
    int startidx;
    int nskip = 0;
    int continuationWidth = 0;
    size_t len;
    double t = cl.time; // saved so it won't change
    con_text_info_t ti;
 
    ti.font = (mask_must & CON_MASK_CHAT) ? FONT_CHAT : FONT_NOTIFY;
    ti.fontsize = fontsize;
    ti.alignment = alignment_x;
    ti.width = width;
    ti.ymin = y;
    ti.ymax = y + height;
    ti.continuationString = continuationString;
 
    len = 0;
    Con_WordWidthFunc(&ti, NULL, &len, -1);
    len = strlen(continuationString);
    continuationWidth = (int) Con_WordWidthFunc(&ti, continuationString, &len, -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)
    {
        con_lineinfo_t *l = &CON_LINES(i);
        int mylines;
 
        if((l->mask & mask_must) != mask_must)
            continue;
        if(l->mask & mask_mustnot)
            continue;
        if(maxage && (l->addtime < t - maxage))
            continue;
 
        // WE FOUND ONE!
        // Calculate its actual height...
        mylines = COM_Wordwrap(l->start, l->len, continuationWidth, width, Con_WordWidthFunc, &ti, Con_CountLineFunc, &ti);
        if(lines + mylines >= maxlines)
        {
            nskip = lines + mylines - maxlines;
            lines = maxlines;
            startidx = i;
            break;
        }
        lines += mylines;
        startidx = i;
    }
 
    // then center according to the calculated amount of lines...
    ti.x = x;
    ti.y = y + alignment_y * (height - lines * fontsize) - nskip * fontsize;
 
    // then actually draw
    for(i = startidx; i < CON_LINES_COUNT; ++i)
    {
        con_lineinfo_t *l = &CON_LINES(i);
 
        if((l->mask & mask_must) != mask_must)
            continue;
        if(l->mask & mask_mustnot)
            continue;
        if(maxage && (l->addtime < t - maxage))
            continue;
 
        COM_Wordwrap(l->start, l->len, continuationWidth, width, Con_WordWidthFunc, &ti, Con_DisplayLineFunc, &ti);
    }
 
    return lines;
}

References con_lineinfo_t::addtime, con_text_info_t::alignment, cl, COM_Wordwrap(), Con_CountLineFunc(), Con_DisplayLineFunc(), CON_LINES, CON_LINES_COUNT, CON_MASK_CHAT, Con_WordWidthFunc(), con_text_info_t::continuationString, floor(), con_text_info_t::font, FONT_CHAT, FONT_NOTIFY, con_text_info_t::fontsize, height, i, int(), con_lineinfo_t::len, con_lineinfo_t::mask, NULL, con_lineinfo_t::start, strlen(), client_state_t::time, con_text_info_t::width, width, con_text_info_t::x, x, con_text_info_t::y, y, con_text_info_t::ymax, and con_text_info_t::ymin.

Referenced by Con_DrawNotify().

◆ Con_Init()

void Con_Init ( void )

Definition at line 861 of file console.c.

{
    con_linewidth = 80;
    ConBuffer_Init(&con, CON_TEXTSIZE, CON_MAXLINES, zonemempool);
    if (Thread_HasThreads())
        con_mutex = Thread_CreateMutex();
 
    // Allocate a log queue, this will be freed after configs are parsed
    logq_size = MAX_INPUTLINE;
    logqueue = (unsigned char *)Mem_Alloc (tempmempool, logq_size);
    logq_ind = 0;
 
    Cvar_RegisterVariable (&sys_colortranslation);
    Cvar_RegisterVariable (&sys_specialcharactertranslation);
#if defined(__linux__)
    // Linux terminals natively support RGB 8bpc codes or convert them to a palette.
    Cvar_SetQuick(&sys_colortranslation, "2");
#elif defined(WIN32)
    // Windows 10 default PowerShell and cmd.exe have no RGB or ANSI support by default.
    // TODO: it can be enabled on current versions using a platform-specific call,
    // issue: https://gitlab.com/xonotic/darkplaces/-/issues/426
    Cvar_SetQuick(&sys_colortranslation, "0");
#endif
 
    Cvar_RegisterVariable (&log_file);
    Cvar_RegisterVariable (&log_file_stripcolors);
    Cvar_RegisterVariable (&log_dest_udp);
 
    // support for the classic Quake option
// COMMANDLINEOPTION: Console: -condebug logs console messages to qconsole.log, see also log_file
    if (Sys_CheckParm ("-condebug") != 0)
        Cvar_SetQuick (&log_file, "qconsole.log");
 
    // register our cvars
    Cvar_RegisterVariable (&con_chat);
    Cvar_RegisterVariable (&con_chatpos);
    Cvar_RegisterVariable (&con_chatrect_x);
    Cvar_RegisterVariable (&con_chatrect_y);
    Cvar_RegisterVariable (&con_chatrect);
    Cvar_RegisterVariable (&con_chatsize);
    Cvar_RegisterVariable (&con_chattime);
    Cvar_RegisterVariable (&con_chatwidth);
    Cvar_RegisterVariable (&con_notify);
    Cvar_RegisterVariable (&con_notifyalign);
    Cvar_RegisterVariable (&con_notifysize);
    Cvar_RegisterVariable (&con_notifytime);
    Cvar_RegisterVariable (&con_textsize);
    Cvar_RegisterVariable (&con_chatsound);
    Cvar_RegisterVariable (&con_chatsound_file);
    Cvar_RegisterVariable (&con_chatsound_team_file);
    Cvar_RegisterVariable (&con_chatsound_team_mask);
 
    // --blub
    Cvar_RegisterVariable (&con_nickcompletion);
    Cvar_RegisterVariable (&con_nickcompletion_flags);
 
    Cvar_RegisterVariable (&con_completion_playdemo); // *.dem
    Cvar_RegisterVariable (&con_completion_timedemo); // *.dem
    Cvar_RegisterVariable (&con_completion_exec); // *.cfg
 
    Cvar_RegisterVariable (&condump_stripcolors);
 
    Cvar_RegisterVariable(&rcon_address);
    Cvar_RegisterVariable(&rcon_secure);
    Cvar_RegisterCallback(&rcon_secure, Con_RCon_ClearPassword_c);
    Cvar_RegisterVariable(&rcon_secure_challengetimeout);
    Cvar_RegisterVariable(&rcon_password);
 
    // register our commands
    Cmd_AddCommand(CF_CLIENT, "toggleconsole", Con_ToggleConsole_f, "opens or closes the console");
    Cmd_AddCommand(CF_CLIENT, "messagemode", Con_MessageMode_f, "input a chat message to say to everyone");
    Cmd_AddCommand(CF_CLIENT, "messagemode2", Con_MessageMode2_f, "input a chat message to say to only your team");
    Cmd_AddCommand(CF_CLIENT, "commandmode", Con_CommandMode_f, "input a console command");
    Cmd_AddCommand(CF_SHARED, "clear", Con_Clear_f, "clear console history");
    Cmd_AddCommand(CF_SHARED, "maps", Con_Maps_f, "list information about available maps");
    Cmd_AddCommand(CF_SHARED, "condump", Con_ConDump_f, "output console history to a file (see also log_file)");
 
    con_initialized = true;
}

References CF_CLIENT, CF_SHARED, Cmd_AddCommand(), con, con_chat, con_chatpos, con_chatrect, con_chatrect_x, con_chatrect_y, con_chatsize, con_chatsound, con_chatsound_file, con_chatsound_team_file, con_chatsound_team_mask, con_chattime, con_chatwidth, Con_Clear_f(), Con_CommandMode_f(), con_completion_exec, con_completion_playdemo, con_completion_timedemo, Con_ConDump_f(), con_initialized, con_linewidth, Con_Maps_f(), CON_MAXLINES, Con_MessageMode2_f(), Con_MessageMode_f(), con_mutex, con_nickcompletion, con_nickcompletion_flags, con_notify, con_notifyalign, con_notifysize, con_notifytime, Con_RCon_ClearPassword_c(), CON_TEXTSIZE, con_textsize, Con_ToggleConsole_f(), ConBuffer_Init(), condump_stripcolors, Cvar_RegisterCallback(), Cvar_RegisterVariable(), Cvar_SetQuick(), log_dest_udp, log_file, log_file_stripcolors, logq_ind, logq_size, logqueue, MAX_INPUTLINE, Mem_Alloc, rcon_address, rcon_password, rcon_secure, rcon_secure_challengetimeout, Sys_CheckParm(), sys_colortranslation, sys_specialcharactertranslation, tempmempool, Thread_CreateMutex, Thread_HasThreads(), and zonemempool.

Referenced by Host_Init().

◆ Con_LastVisibleLine()

static void Con_LastVisibleLine	(	unsigned	mask_must,
		unsigned	mask_mustnot,
		int *	last,
		int *	limitlast )

static

Definition at line 2096 of file console.c.

{
    int lines_seen = 0;
    int i;
 
    if(con_backscroll < 0)
        con_backscroll = 0;
 
    *last = 0;
 
    // now count until we saw con_backscroll actual lines
    for(i = CON_LINES_COUNT - 1; i >= 0; --i)
    if((CON_LINES(i).mask & mask_must) == mask_must)
    if((CON_LINES(i).mask & mask_mustnot) == 0)
    {
        int h = Con_LineHeight(i);
 
        // line is the last visible line?
        *last = i;
        if(lines_seen + h > con_backscroll && lines_seen <= con_backscroll)
        {
            *limitlast = lines_seen + h - con_backscroll;
            return;
        }
 
        lines_seen += h;
    }
 
    // if we get here, no line was on screen - scroll so that one line is
    // visible then.
    con_backscroll = lines_seen - 1;
    *limitlast = 1;
}

References con_backscroll, Con_LineHeight(), CON_LINES, CON_LINES_COUNT, i, and mask.

Referenced by Con_DrawConsole().

◆ Con_LineHeight()

static int Con_LineHeight ( int lineno )

static

Definition at line 2041 of file console.c.

{
    con_lineinfo_t *li = &CON_LINES(lineno);
    if(li->height == -1)
    {
        float width = vid_conwidth.value;
        con_text_info_t ti;
        ti.fontsize = con_textsize.value;
        ti.font = FONT_CONSOLE;
        li->height = COM_Wordwrap(li->start, li->len, 0, width, Con_WordWidthFunc, &ti, Con_CountLineFunc, NULL);
    }
    return li->height;
}

References COM_Wordwrap(), Con_CountLineFunc(), CON_LINES, con_textsize, Con_WordWidthFunc(), con_text_info_t::font, FONT_CONSOLE, con_text_info_t::fontsize, con_lineinfo_t::height, con_lineinfo_t::len, NULL, con_lineinfo_t::start, cvar_t::value, vid_conwidth, and width.

Referenced by Con_DrawConsoleLine(), and Con_LastVisibleLine().

◆ Con_Maps_f()

static void Con_Maps_f ( cmd_state_t * cmd )

static

Definition at line 789 of file console.c.

{
    if (Cmd_Argc(cmd) > 2)
    {
        Con_Printf("usage: maps [mapnameprefix]\n");
        return;
    }
    else if (Cmd_Argc(cmd) == 2)
        GetMapList(Cmd_Argv(cmd, 1), NULL, 0);
    else
        GetMapList("", NULL, 0);
}

References cmd(), Cmd_Argc(), Cmd_Argv(), Con_Printf(), GetMapList(), and NULL.

Referenced by Con_Init().

◆ Con_MaskPrint()

void Con_MaskPrint	(	unsigned	additionalmask,
		const char *	msg )

Prints to a chosen console target.

Definition at line 1161 of file console.c.

{
    static unsigned mask = 0;
    static unsigned index = 0;
    static char line[MAX_INPUTLINE];
 
    if (con_mutex)
        Thread_LockMutex(con_mutex);
 
    for (;*msg;msg++)
    {
        Con_Rcon_AddChar(*msg);
        // if this is the beginning of a new line, print timestamp
        if (index == 0)
        {
            // reset the color
            // FIXME: 1. perhaps we should use a terminal system 2. use a constant instead of 7!
            line[index++] = STRING_COLOR_TAG;
            // assert( STRING_COLOR_DEFAULT < 10 )
            line[index++] = STRING_COLOR_DEFAULT + '0';
            // special color codes for chat messages must always come first
            // for Con_PrintToHistory to work properly
            if (*msg == 1 || *msg == 2 || *msg == 3)
            {
                // play talk wav
                if (*msg == 1)
                {
                    if (con_chatsound.value)
                    {
                        if(msg[1] == con_chatsound_team_mask.integer && cl.foundteamchatsound)
                            S_LocalSound (con_chatsound_team_file.string);
                        else
                            S_LocalSound (con_chatsound_file.string);
                    }
                }
                // Send to chatbox for say/tell (1) and messages (3)
                // 3 is just so that a message can be sent to the chatbox without a sound.
                if (*msg == 1 || *msg == 3)
                    mask = CON_MASK_CHAT;
 
                line[index++] = STRING_COLOR_TAG;
                line[index++] = '3';
                msg++;
                Con_Rcon_AddChar(*msg);
            }
            // store timestamp
            if (timestamps.integer)
                index += Sys_TimeString(&line[index], sizeof(line) - index, timeformat.string);
            // add the mask
            mask |= additionalmask;
        }
        // append the character
        line[index++] = *msg;
        // if this is a newline character, we have a complete line to print
        // bones_was_here: why do we only use half the line buffer?
        if (*msg == '\n' || index >= (int)sizeof(line) / 2)
        {
            // terminate the line
            line[index] = 0;
            // send to log file
            Log_ConPrint(line);
            // send to scrollable buffer
            if (con_initialized && cls.state != ca_dedicated)
            {
                Con_PrintToHistory(line, mask);
            }
            // send to terminal or dedicated server window
            if (sys.outfd >= 0)
            if (developer.integer || !(mask & CON_MASK_DEVELOPER))
            {
                if(sys_specialcharactertranslation.integer)
                {
                    char *p;
                    const char *q;
                    p = line;
                    while(*p)
                    {
                        int ch = u8_getchar(p, &q);
                        if(ch >= 0xE000 && ch <= 0xE0FF && ((unsigned char) qfont_table[ch - 0xE000]) >= 0x20)
                        {
                            *p = qfont_table[ch - 0xE000];
                            if(q > p+1)
                                memmove(p+1, q, strlen(q)+1);
                            p = p + 1;
                        }
                        else
                            p = p + (q - p);
                    }
                }
 
                if(sys_colortranslation.integer > 0) // ANSI, RGB, or both
                {
                    // ANSI translation:
                        // 2 can become 7 bytes, rounding that up to 8, and 3 bytes are added at the end
                        // a newline can transform into four bytes, but then prevents the three extra bytes from appearing
                    // 8bpc RGB brings new worst-cases:
                        // 5 can become 21 bytes, rounding that up to * 5, plenty of space for extra bytes at the end.
                        // sys_colortranslation 3: 2 can become 21 bytes, rounding that up to * 11
                    char printline[sizeof(line) * 11];
                    int lastcolor = 0;
                    const char *in;
                    char *out;
                    int color;
                    u8 rgb[3];
                    for(in = line, out = printline; *in; ++in)
                    {
                        switch(*in)
                        {
                            case STRING_COLOR_TAG:
                                if( in[1] == STRING_COLOR_RGB_TAG_CHAR && isxdigit(in[2]) && isxdigit(in[3]) && isxdigit(in[4]) )
                                {
                                    VectorCopy(in + 2, rgb);
                                    // it's a hex digit already, so the else part needs no check --blub
                                    for (int i = 0; i < 3; ++i)
                                    {
                                        if (isdigit(rgb[i])) rgb[i] -= '0';
                                        else rgb[i] = tolower(rgb[i]) - 87;
                                        rgb[i] *= 17;
                                    }
 
                                    if (sys_colortranslation.integer > 1) // 8bpc RGB
                                    {
                                        char *p;
                                        float B;
 
                                        in += 4;
                                    rgbout:
                                        color = rgb[0]<<16 | rgb[1]<<8 | rgb[2] | /* disambiguates from quake colours */ 0x40000000;
                                        if (lastcolor == color)
                                            break;
                                        else
                                            lastcolor = color;
 
                                        B = r_textbrightness.value * 255;
                                        for (int i = 0; i < 3; ++i)
                                            rgb[i] = bound(0, rgb[i] * r_textcontrast.value + B, 255);
 
                                        // format must be decimal 0-255, max length is 21 bytes
                                        if (sys_colortranslation.integer == 2)
                                            memcpy(out, "\x1B[1;38;2", 8);
                                        else
                                            memcpy(out, "\x1B[0;38;2", 8);
                                        out += 8;
                                        for (int i = 0; i < 3; ++i)
                                        {
                                            *out++ = ';';
                                            p = out += ((rgb[i] > 99) ? 3 : (rgb[i] > 9) ? 2 : 1);
                                            do { *--p = (rgb[i] % 10) + '0';
                                            } while ((rgb[i] /= 10) > 0);
                                        }
                                        *out++ = 'm';
 
                                        break;
                                    }
                                    
                                    color = Sys_Con_NearestColor(rgb[0], rgb[1], rgb[2]);
                                    in += 3; // 3 only, the switch down there does the fourth
                                }
                                else
                                {
                                    color = in[1];
                                
                                    if (sys_colortranslation.integer == 3 && isdigit(color)) // Quake to RGB
                                    {
                                        color -= '0';
                                        VectorScale(string_colors[color], 255 * string_colors[color][3], rgb);
                                        ++in;
                                        goto rgbout;
                                    }
                                }
 
                                switch(color)
                                {
                                    case STRING_COLOR_TAG:
                                        ++in;
                                        *out++ = STRING_COLOR_TAG;
                                        break;
                                    case '0':
                                    case '7':
                                        // normal color
                                        ++in;
                                        if(lastcolor == 0) break; else lastcolor = 0;
                                        *out++ = 0x1B; *out++ = '['; *out++ = 'm';
                                        break;
                                    case '1':
                                        // light red
                                        ++in;
                                        if(lastcolor == 1) break; else lastcolor = 1;
                                        *out++ = 0x1B; *out++ = '['; *out++ = '1'; *out++ = ';'; *out++ = '3'; *out++ = '1'; *out++ = 'm';
                                        break;
                                    case '2':
                                        // light green
                                        ++in;
                                        if(lastcolor == 2) break; else lastcolor = 2;
                                        *out++ = 0x1B; *out++ = '['; *out++ = '1'; *out++ = ';'; *out++ = '3'; *out++ = '2'; *out++ = 'm';
                                        break;
                                    case '3':
                                        // yellow
                                        ++in;
                                        if(lastcolor == 3) break; else lastcolor = 3;
                                        *out++ = 0x1B; *out++ = '['; *out++ = '1'; *out++ = ';'; *out++ = '3'; *out++ = '3'; *out++ = 'm';
                                        break;
                                    case '4':
                                        // light blue
                                        ++in;
                                        if(lastcolor == 4) break; else lastcolor = 4;
                                        *out++ = 0x1B; *out++ = '['; *out++ = '1'; *out++ = ';'; *out++ = '3'; *out++ = '4'; *out++ = 'm';
                                        break;
                                    case '5':
                                        // light cyan
                                        ++in;
                                        if(lastcolor == 5) break; else lastcolor = 5;
                                        *out++ = 0x1B; *out++ = '['; *out++ = '1'; *out++ = ';'; *out++ = '3'; *out++ = '6'; *out++ = 'm';
                                        break;
                                    case '6':
                                        // light magenta
                                        ++in;
                                        if(lastcolor == 6) break; else lastcolor = 6;
                                        *out++ = 0x1B; *out++ = '['; *out++ = '1'; *out++ = ';'; *out++ = '3'; *out++ = '5'; *out++ = 'm';
                                        break;
                                    // 7 handled above
                                    case '8':
                                    case '9':
                                        // bold normal color
                                        ++in;
                                        if(lastcolor == 8) break; else lastcolor = 8;
                                        *out++ = 0x1B; *out++ = '['; *out++ = '0'; *out++ = ';'; *out++ = '1'; *out++ = 'm';
                                        break;
                                    default:
                                        *out++ = STRING_COLOR_TAG;
                                        break;
                                }
                                break;
                            case '\n':
                                if(lastcolor != 0)
                                {
                                    *out++ = 0x1B; *out++ = '['; *out++ = 'm';
                                    lastcolor = 0;
                                }
                                *out++ = *in;
                                break;
                            default:
                                *out++ = *in;
                                break;
                        }
                    }
                    if(lastcolor != 0)
                    {
                        *out++ = 0x1B;
                        *out++ = '[';
                        *out++ = 'm';
                    }
                    *out = '\0';
                    Sys_Print(printline, out - printline);
                }
                else if(sys_colortranslation.integer == -1) // print as text
                {
                    Sys_Print(line, index);
                }
                else // strip
                {
                    char printline[MAX_INPUTLINE]; // it can only get shorter here
                    const char *in;
                    char *out;
                    for(in = line, out = printline; *in; ++in)
                    {
                        switch(*in)
                        {
                            case STRING_COLOR_TAG:
                                switch(in[1])
                                {
                                    case STRING_COLOR_RGB_TAG_CHAR:
                                        if ( isxdigit(in[2]) && isxdigit(in[3]) && isxdigit(in[4]) )
                                        {
                                            in+=4;
                                            break;
                                        }
                                        *out++ = STRING_COLOR_TAG;
                                        *out++ = STRING_COLOR_RGB_TAG_CHAR;
                                        ++in;
                                        break;
                                    case STRING_COLOR_TAG:
                                        ++in;
                                        *out++ = STRING_COLOR_TAG;
                                        break;
                                    case '0':
                                    case '1':
                                    case '2':
                                    case '3':
                                    case '4':
                                    case '5':
                                    case '6':
                                    case '7':
                                    case '8':
                                    case '9':
                                        ++in;
                                        break;
                                    default:
                                        *out++ = STRING_COLOR_TAG;
                                        break;
                                }
                                break;
                            default:
                                *out++ = *in;
                                break;
                        }
                    }
                    *out = '\0';
                    Sys_Print(printline, out - printline);
                }
            }
            // empty the line buffer
            index = 0;
            mask = 0;
        }
    }
 
    if (con_mutex)
        Thread_UnlockMutex(con_mutex);
}

References bound, ca_dedicated, cl, cls, color, con_chatsound, con_chatsound_file, con_chatsound_team_file, con_chatsound_team_mask, con_initialized, CON_MASK_CHAT, CON_MASK_DEVELOPER, con_mutex, Con_PrintToHistory(), Con_Rcon_AddChar(), developer, client_state_t::foundteamchatsound, i, index, cvar_t::integer, Log_ConPrint(), mask, MAX_INPUTLINE, sys_t::outfd, qfont_table, r_textbrightness, r_textcontrast, rgb, S_LocalSound(), client_static_t::state, cvar_t::string, STRING_COLOR_DEFAULT, STRING_COLOR_RGB_TAG_CHAR, STRING_COLOR_TAG, string_colors, strlen(), sys, sys_colortranslation, Sys_Con_NearestColor(), Sys_Print(), sys_specialcharactertranslation, Sys_TimeString(), Thread_LockMutex, Thread_UnlockMutex, timeformat, timestamps, u8_getchar, cvar_t::value, VectorCopy, and VectorScale.

Referenced by Con_DPrint(), Con_DPrintf(), Con_MaskPrintf(), Con_Print(), and Con_Printf().

◆ Con_MaskPrintf()

void Con_MaskPrintf	(	unsigned	mask,
		const char *	fmt,
			... )

Definition at line 1487 of file console.c.

{
    va_list argptr;
    char msg[MAX_INPUTLINE];
 
    va_start(argptr,fmt);
    dpvsnprintf(msg,sizeof(msg),fmt,argptr);
    va_end(argptr);
 
    Con_MaskPrint(mask, msg);
}

References Con_MaskPrint(), dpvsnprintf(), mask, and MAX_INPUTLINE.

Referenced by Con_CenterPrint(), and Con_CenterPrintf().

◆ Con_MessageMode2_f()

static void Con_MessageMode2_f ( cmd_state_t * cmd )

static

Definition at line 743 of file console.c.

{
    Con_MsgCmdMode(cmd, 1);
}

References cmd(), and Con_MsgCmdMode().

Referenced by Con_Init().

◆ Con_MessageMode_f()

static void Con_MessageMode_f ( cmd_state_t * cmd )

static

Definition at line 731 of file console.c.

{
    Con_MsgCmdMode(cmd, 0);
}

References cmd(), and Con_MsgCmdMode().

Referenced by Con_Init().

◆ Con_MsgCmdMode()

static void Con_MsgCmdMode	(	cmd_state_t *	cmd,
		signed char	mode )

static

Definition at line 710 of file console.c.

{
    if (cls.demoplayback && mode >= 0)
        return;
    key_dest = key_message;
    chat_mode = mode;
    if(Cmd_Argc(cmd) > 1)
    {
        chat_bufferpos = dpsnprintf(chat_buffer, sizeof(chat_buffer), "%s ", Cmd_Args(cmd));
        if (chat_bufferpos < 0)
            chat_bufferpos = 0;
    }
}

References chat_buffer, chat_bufferpos, chat_mode, cls, cmd(), Cmd_Argc(), Cmd_Args(), client_static_t::demoplayback, dpsnprintf(), key_dest, key_message, and mode.

Referenced by Con_CommandMode_f(), Con_MessageMode2_f(), and Con_MessageMode_f().

◆ Con_Print()

void Con_Print ( const char * msg )

Prints to all appropriate console targets, and adds timestamps.

Definition at line 1504 of file console.c.

{
    Con_MaskPrint(CON_MASK_PRINT, msg);
}

References CON_MASK_PRINT, and Con_MaskPrint().

◆ Con_Printf()

void Con_Printf	(	const char *	fmt,
			... )

Prints to all appropriate console targets.

Definition at line 1514 of file console.c.

{
    va_list argptr;
    char msg[MAX_INPUTLINE];
 
    va_start(argptr,fmt);
    dpvsnprintf(msg,sizeof(msg),fmt,argptr);
    va_end(argptr);
 
    Con_MaskPrint(CON_MASK_PRINT, msg);
}

References CON_MASK_PRINT, Con_MaskPrint(), dpvsnprintf(), and MAX_INPUTLINE.

Referenced by AnglesFromVectors(), Cbuf_AddText(), Cbuf_Execute(), Cbuf_InsertText(), CD_f(), CheckPendingDownloads(), CL_BeginDownloads(), CL_BeginDownloads_f(), CL_Cache_TraceLineSurfaces(), CL_ClearTempEntities(), CL_Color_f(), CL_DisconnectEx(), CL_DownloadBegin_f(), CL_DownloadFinished_f(), CL_Effect(), CL_EstablishConnection(), CL_ExaminePrintString(), CL_FinishTimeDemo(), CL_Fog_f(), CL_Fog_HeightTexture_f(), CL_ForwardToServer(), CL_Frame(), CL_FullInfo_f(), CL_FullServerinfo_f(), CL_Init(), CL_IPLog_List_f(), CL_IPLog_Load(), CL_LinkEdict(), CL_Locs_Add_f(), CL_Locs_FreeNode(), CL_Locs_Reload_f(), CL_Locs_RemoveNearest_f(), CL_Locs_Save_f(), CL_ModelIndexList_f(), CL_Name_f(), CL_NewBeam(), CL_NewFrameReceived(), CL_OpenVideo(), CL_Packet_f(), CL_ParseBeam(), CL_ParseDownload(), CL_ParseServerInfo(), CL_ParseServerMessage(), CL_ParseStartSoundPacket(), CL_ParseStaticSound(), CL_ParticleRain(), CL_Particles_ParseEffectInfo(), CL_PlayDemo(), CL_PQRcon_f(), CL_PrintEntities_f(), CL_Rcon_f(), CL_ReadPointFile_f(), CL_Reconnect_f(), CL_Record_f(), CL_SendMove(), CL_SetInfo(), CL_SetInfo_f(), CL_SoundIndexList_f(), CL_Startdemos_f(), CL_StopDownload(), CL_StopDownload_f(), CL_TimeRefresh_f(), CL_TraceBox(), CL_TraceLine(), CL_TracePoint(), CL_User_f(), CL_Users_f(), CL_VM_Init(), CLVM_count_edicts(), Cmd_AddCommand(), Cmd_Alias_f(), Cmd_Apropos_f(), Cmd_Callback(), Cmd_CheckParm(), Cmd_CL_Callback(), Cmd_CompleteAliasPrint(), Cmd_CompleteCommandPrint(), Cmd_CompleteNicksPrint(), Cmd_Defer_f(), Cmd_Echo_f(), Cmd_Exec(), Cmd_Exec_f(), Cmd_ExecuteString(), Cmd_GetCvarValue(), Cmd_List_f(), Cmd_Toggle_f(), Cmd_TokenizeString(), Cmd_UnAlias_f(), Collision_ClipLineToGenericEntity(), Collision_ClipPointToGenericEntity(), Collision_ClipToGenericEntity(), Collision_ClipTrace_Box(), Collision_PrintBrushAsQHull(), Collision_ValidateBrush(), COM_ChangeGameTypeForGameDirs(), Con_CenterPrintf(), Con_CompleteCommandLine(), Con_ConDump_f(), Con_Maps_f(), Crypto_DecryptPacket(), Crypto_EncryptPacket(), Crypto_FinishInstance(), Crypto_HostKey_Clear_f(), Crypto_HostKeys_f(), Crypto_Init(), Crypto_KeyGen_f(), Crypto_KeyGen_Finished(), Crypto_Keys_f(), Crypto_LoadKeys(), Crypto_ServerParsePacket(), Crypto_StoreHostKey(), Curl_Begin(), Curl_Curl_f(), Curl_EndDownload(), Curl_Info_f(), Curl_Select(), Curl_SendRequirements(), Cvar_Del_f(), Cvar_Delete(), Cvar_Get(), Cvar_List_f(), Cvar_PrintHelp(), Cvar_Readonly(), Cvar_RegisterVariable(), Cvar_RegisterVirtual(), Cvar_Set(), Cvar_Set_f(), Cvar_SetA_f(), Cvar_SetQuick(), decode_image(), dp__strlcpy(), dp_stpecpy(), dp_ustr2stp(), em_savefs_f(), EntityFrame4_AckFrame(), EntityFrame4_CL_ReadFrame(), EntityFrame4_WriteFrame(), EntityFrame5_CL_ReadFrame(), EntityFrame5_WriteFrame(), EntityFrame_CL_ReadFrame(), EntityFrameCSQC_DeallocFrame(), EntityFrameCSQC_LostFrame(), EntityFrameQW_CL_ReadFrame(), EntityState5_ReadUpdate(), EntityState_ReadFields(), EntityStateQW_ReadEntityUpdate(), FindFont(), Font_GetKerningForMap(), Font_LoadFile(), Font_LoadFont(), Font_LoadMap(), Font_LoadSize(), Font_SearchSize(), fractalnoise(), fractalnoisequick(), FS_AddFileToPack(), FS_AddPack(), FS_AddPack_Fullpath(), FS_Deflate(), FS_GameDir_f(), FS_Inflate(), FS_ListDirectory(), FS_ListDirectoryCmd(), FS_LoadAndCloseQFile(), FS_LoadPackPAK(), FS_LoadPackPK3FromFD(), FS_OpenPackedFile(), FS_OpenReadFile(), FS_OpenRealFile(), FS_OpenVirtualFile(), FS_Path_f(), FS_Read(), FS_Search(), FS_Seek(), FS_SetGameDirs(), FS_SysOpenFiledesc(), FS_Which_f(), FS_Write(), FS_WriteFileInBlocks(), GetMapList(), GetWavinfo(), GL_Backend_CompileShader(), gl_backend_start(), GL_DebugOutputCallback(), GL_Mesh_ListVBOs(), GL_Setup(), GL_TextureMode_f(), Host_Error(), Host_Init(), Host_LockSession(), Host_Quit_f(), Host_SaveConfig(), Host_Version_f(), Image_Compress(), Image_FixTransparentPixels_f(), Image_MipReduce32(), Image_Resample32(), IN_BestWeapon_f(), IN_BestWeapon_Register(), IN_BestWeapon_Register_f(), InfoString_GetValue(), InfoString_Print(), InfoString_SetValue(), jam_video(), JPEG_LoadImage_BGRA(), JPEG_OpenLibrary(), JPEG_SaveImage_to_Buffer(), Key_Bind_f(), Key_Event(), Key_History_f(), Key_History_Find_All(), Key_History_Find_Backwards(), Key_History_Find_Forwards(), Key_History_Push(), Key_In_Bind_f(), Key_In_BindList_f(), Key_In_Bindmap_f(), Key_In_Unbind_f(), Key_Parse_CommonKeys(), Key_PrintBindList(), Key_Unbind_f(), LHNET_OpenSocket_Connectionless(), LHNETADDRESS_FromString(), LibAV_LoadLibrary(), libavw_decodeframe(), libavw_message(), LibAvW_OpenLibrary(), LoadConChars_BGRA(), LoadFont_f(), loadimagepixelsbgra(), LoadLMP_BGRA(), LoadPCX_BGRA(), LoadSky_f(), LoadSubtitles(), LoadTGA_BGRA(), LoadWAL_BGRA(), Matrix4x4_Print(), Mem_PrintList(), Mem_PrintStats(), Mod_AliasInit(), Mod_BSP_DecompressVis(), Mod_BuildVBOs(), Mod_DARKPLACESMODEL_Load(), Mod_Decompile_OBJ(), Mod_Decompile_SMD(), Mod_FrameGroupify(), Mod_FrameGroupify_ParseGroups(), Mod_GenerateLightmaps_CreateLightmaps(), Mod_GenerateLightmaps_f(), Mod_IDP0_Load(), Mod_IDP2_Load(), Mod_IDS2_Load(), Mod_INTERQUAKEMODEL_Load(), Mod_LoadModel(), Mod_LoadQ3Shaders(), Mod_LoadSkinFiles(), Mod_LoadTextureFromQ3Shader(), Mod_MDL_LoadFrames(), Mod_Print_f(), Mod_PSKMODEL_Load(), Mod_Q1BSP_Load(), Mod_Q1BSP_LoadEdges(), Mod_Q1BSP_LoadLeafs(), Mod_Q1BSP_LoadLighting(), Mod_Q1BSP_LoadMapBrushes(), Mod_Q1BSP_LoadNodes(), Mod_Q1BSP_LoadTexinfo(), Mod_Q1BSP_LoadTextures(), Mod_Q1BSP_TraceBox(), Mod_Q1BSP_TraceLine(), Mod_Q2BSP_Load(), Mod_Q2BSP_LoadLeafs(), Mod_Q2BSP_LoadNodes(), Mod_Q2BSP_LoadTexinfo(), Mod_Q3BSP_LoadEffects(), Mod_Q3BSP_LoadEntities(), Mod_Q3BSP_LoadFaces(), Mod_Q3BSP_LoadLightGrid(), Mod_Q3BSP_LoadLightmaps(), Mod_Q3BSP_LoadTriangles(), Mod_UnloadModel(), Mod_ValidateElements(), Mod_VBSP_LoadEdges(), Mod_VBSP_LoadTexinfo(), Mod_VBSP_LoadTextures(), Mod_ZYMOTICMODEL_Load(), ModList_Enable(), MVM_count_edicts(), MVM_error_cmd(), NetConn_ClientFrame(), NetConn_ClientParsePacket(), NetConn_ConnectionEstablished(), NetConn_Init(), NetConn_OpenClientPort(), NetConn_OpenClientPorts(), NetConn_OpenServerPort(), NetConn_Read(), NetConn_ReceivedMessage(), NetConn_SendUnreliableMessage(), NetConn_ServerParsePacket(), NetConn_UpdateSockets(), NetConn_Write(), OGG_LoadVorbisFile(), OpenStream(), PHYS_TestEntityPosition(), PK3_GetTrueFileOffset(), PNG_error_fn(), PNG_fReadData(), PNG_LoadImage_BGRA(), PNG_warning_fn(), Portal_CheckPolygon(), Portal_Visibility(), PrintFrameName(), PrintStats(), PrintTargaHeader(), PRVM_Breakpoint(), PRVM_Breakpoint_f(), PRVM_CallProfile(), PRVM_ChildProfile_f(), PRVM_Crash(), PRVM_ED_EdictGet_f(), PRVM_ED_EdictSet_f(), PRVM_ED_GlobalGet_f(), PRVM_ED_ParseEdict(), PRVM_ED_ParseEpair(), PRVM_ED_ParseGlobals(), PRVM_ED_Print(), PRVM_ED_PrintEdicts_f(), PRVM_ED_Write(), PRVM_ED_WriteGlobals(), PRVM_EdictWatchpoint_f(), PRVM_ExplicitCoverageEvent(), PRVM_Fields_f(), PRVM_FriendlyProgFromString(), PRVM_FunctionCoverageEvent(), PRVM_GameCommand(), PRVM_Global_f(), PRVM_Globals_f(), PRVM_GlobalSet_f(), PRVM_GlobalWatchpoint_f(), PRVM_LeakTest(), PRVM_MarkReferencedEdicts(), PRVM_PrintFunction_f(), PRVM_PrintFunctionStatements(), PRVM_PrintState(), PRVM_PrintStatement(), PRVM_Profile(), PRVM_Profile_f(), PRVM_Prog_Load(), PRVM_StackTrace(), PRVM_StatementCoverageEvent(), PRVM_UpdateBreakpoints(), QW_CL_Changing_f(), QW_CL_CheckOrDownloadFile(), QW_CL_NextUpload_f(), QW_CL_ParseDownload(), QW_CL_RequestNextDownload(), QW_CL_SetInfo(), QW_CL_UpdateUserInfo(), R_Envmap_f(), R_GLSL_CompilePermutation(), R_GLSL_DumpShader_f(), R_InitParticleTexture(), R_ListWorldTextures_f(), R_LoadCubemap(), R_LoadQWSkin(), R_LoadSkyBox(), R_LoadTextureDDSFile(), R_Mesh_CreateFramebufferObject(), R_Mesh_Draw(), R_Mesh_Start(), R_Model_Sprite_Draw_TransparentCallback(), R_Modules_Start(), R_RegisterModule(), R_ReplaceWorldTexture_f(), R_SetSkyBox(), R_SetupTexture(), R_Shadow_ComputeShadowCasterCullingPlanes(), R_Shadow_EditLights_Edit_f(), R_Shadow_LoadLightsFile(), R_Shadow_LoadWorldLights(), R_Shadow_RenderLighting(), R_SkinFrame_LoadExternal_SkinFrame(), R_SkinFrame_LoadInternal8bit(), R_SkinFrame_LoadInternalBGRA(), R_SkinFrame_LoadInternalQuake(), R_SkinFrame_LoadInternalUsingTexture(), R_TextureStats_Print(), R_UnloadSkyBox(), R_Viewport_InitOrtho(), R_Water_ProcessPlanes(), RCon_Execute(), S_FindName(), S_FreeSfx(), S_LoadSound(), S_LoadWavFile(), S_LocalSoundEx(), S_PaintAndSubmit(), S_PlaySfxOnChannel(), S_Restart_f(), S_SetChannelLayout(), S_SoundInfo_f(), S_SoundList_f(), S_Startup(), S_StaticSound(), S_UnloadAllSounds_f(), S_Update(), SCR_CaptureVideo_Avi_BeginVideo(), SCR_CaptureVideo_Ogg_BeginVideo(), SCR_CaptureVideo_RIFF_Pop(), SCR_InfoBar_f(), SCR_ScreenShot_f(), SndSys_Init(), SV_Begin_f(), SV_CanSeeBox(), SV_CheckVelocity(), SV_ConnectClient(), SV_DropClient(), SV_Ent_Create_f(), SV_Ent_Remove_All_f(), SV_Ent_Remove_f(), SV_ExecuteClientMoves(), SV_FlyMove(), SV_Impact(), SV_LinkEdict(), SV_LinkEdict_TouchAreaGrid(), SV_Loadgame_f(), SV_MaxPlayers_f(), SV_ModelIndex(), SV_ParticleEffectIndex(), SV_Pause_f(), SV_Physics_ClientEntity(), SV_Physics_ClientEntity_NoThink(), SV_Physics_Entity(), SV_Ping_f(), SV_PointSuperContents(), SV_PushEntity(), SV_PushMove(), SV_ReadClientMessage(), SV_ReadClientMove(), SV_Savegame_to(), SV_ServerOptions(), SV_SoundIndex(), SV_Spawn_f(), SV_SpawnServer(), SV_StartDemoRecording(), SV_StartPointSound(), SV_StartSound(), SV_Status_f(), SV_StopDemoRecording(), SV_TraceBox(), SV_TraceLine(), SV_TracePoint(), SV_UnstickEntity(), SV_Viewmodel_f(), SV_WriteEntitiesToClient(), SVVM_count_edicts(), Sys_DirtyTime(), Sys_Error(), Sys_LoadDependency(), Sys_SDL_HandleEvents(), Sys_Sleep(), Sys_UpdateTime(), testmul128(), Thread_Init(), V_BonusFlash_f(), VID_ApplyDisplayMode(), VID_ApplyJoyState(), VID_EnableJoystick(), VID_Init(), VID_InitModeGL(), VID_Mode(), VID_Restart_f(), VID_SetVsync_c(), VID_Shared_SetJoystick(), VM_CL_effect(), VM_CL_findbox(), VM_CL_findradius(), VM_CL_makestatic(), VM_error(), VM_GetFileHandle(), VM_objerror(), VM_SV_findbox(), VM_SV_findradius(), VM_Warning(), W_LoadTextureWadFile(), World_LinkEdict_AreaGrid(), World_PrintAreaStats(), XMP_LoadModFile(), and XMP_OpenLibrary().

◆ Con_PrintToHistory()

static void Con_PrintToHistory	(	const char *	txt,
		int	mask )

static

Definition at line 959 of file console.c.

{
    // process:
    //   \n goes to next line
    //   \r deletes current line and makes a new one
 
    static int cr_pending = 0;
    static char buf[CON_TEXTSIZE]; // con_mutex
    static int bufpos = 0;
 
    if(!con.text) // FIXME uses a non-abstracted property of con
        return;
 
    for(; *txt; ++txt)
    {
        if(cr_pending)
        {
            ConBuffer_DeleteLastLine(&con);
            cr_pending = 0;
        }
        switch(*txt)
        {
            case 0:
                break;
            case '\r':
                ConBuffer_AddLine(&con, buf, bufpos, mask);
                bufpos = 0;
                cr_pending = 1;
                break;
            case '\n':
                ConBuffer_AddLine(&con, buf, bufpos, mask);
                bufpos = 0;
                break;
            default:
                buf[bufpos++] = *txt;
                if(bufpos >= con.textsize - 1) // FIXME uses a non-abstracted property of con
                {
                    ConBuffer_AddLine(&con, buf, bufpos, mask);
                    bufpos = 0;
                }
                break;
        }
    }
}

References buf, con, CON_TEXTSIZE, ConBuffer_AddLine(), ConBuffer_DeleteLastLine(), mask, conbuffer_t::text, and conbuffer_t::textsize.

Referenced by Con_MaskPrint().

◆ Con_Quakebar()

const char * Con_Quakebar	(	int	len,
		char *	bar,
		size_t	barsize )

Returns a horizontal line.

Returns a graphical horizontal line of length len, but never wider than the console. Includes a newline, unless len is >= to the console width

Note: Authored by johnfitz

Parameters

[in] len Length of the horizontal line

Returns: A string of the line

Definition at line 1570 of file console.c.

{
    assert(barsize >= 5);
 
    len = min(len, (int)barsize - 2);
    len = min(len, con_linewidth);
 
    bar[0] = '\35';
    memset(&bar[1], '\36', len - 2);
    bar[len - 1] = '\37';
 
    if (len < con_linewidth)
    {
        bar[len] = '\n';
        bar[len + 1] = 0;
    }
    else
        bar[len] = 0;
 
    return bar;
}

References con_linewidth, and min.

Referenced by Con_CenterPrint().

◆ Con_Rcon_AddChar()

static void Con_Rcon_AddChar ( int c )

static

Adds a character to the rcon buffer.

Definition at line 1060 of file console.c.

{
    if(log_dest_buffer_appending)
        return;
    ++log_dest_buffer_appending;
 
    // if this print is in response to an rcon command, add the character
    // to the rcon redirect buffer
 
    if (rcon_redirect_dest)
    {
        rcon_redirect_buffer[rcon_redirect_bufferpos++] = c;
        if(rcon_redirect_bufferpos >= (int)sizeof(rcon_redirect_buffer) - 1)
            Con_Rcon_Redirect_Flush();
    }
    else if(*log_dest_udp.string) // don't duplicate rcon command responses here, these are sent another way
    {
        if(log_dest_buffer_pos == 0)
            Log_DestBuffer_Init();
        log_dest_buffer[log_dest_buffer_pos++] = c;
        if(log_dest_buffer_pos >= sizeof(log_dest_buffer) - 1) // minus one, to allow for terminating zero
            Log_DestBuffer_Flush_NoLock();
    }
    else
        log_dest_buffer_pos = 0;
 
    --log_dest_buffer_appending;
}

References Con_Rcon_Redirect_Flush(), log_dest_buffer, log_dest_buffer_appending, log_dest_buffer_pos, log_dest_udp, Log_DestBuffer_Flush_NoLock(), Log_DestBuffer_Init(), rcon_redirect_buffer, rcon_redirect_bufferpos, rcon_redirect_dest, and cvar_t::string.

Referenced by Con_MaskPrint().

◆ Con_RCon_ClearPassword_c()

static void Con_RCon_ClearPassword_c ( cvar_t * var )

static

Definition at line 847 of file console.c.

{
    // whenever rcon_secure is changed to 0, clear rcon_password for
    // security reasons (prevents a send-rcon-password-as-plaintext
    // attack based on NQ protocol session takeover and svc_stufftext)
    if(var->integer <= 0)
        Cvar_SetQuick(&rcon_password, "");
}

References Cvar_SetQuick(), cvar_t::integer, and rcon_password.

Referenced by Con_Init().

◆ Con_Rcon_Redirect_Abort()

void Con_Rcon_Redirect_Abort ( void )

Definition at line 1048 of file console.c.

{
    rcon_redirect_dest = NULL;
    rcon_redirect_sock = NULL;
}

References NULL, rcon_redirect_dest, and rcon_redirect_sock.

Referenced by Host_Error().

◆ Con_Rcon_Redirect_End()

void Con_Rcon_Redirect_End ( void )

Definition at line 1041 of file console.c.

{
    Con_Rcon_Redirect_Flush();
    rcon_redirect_dest = NULL;
    rcon_redirect_sock = NULL;
}

References Con_Rcon_Redirect_Flush(), NULL, rcon_redirect_dest, and rcon_redirect_sock.

Referenced by RCon_Execute().

◆ Con_Rcon_Redirect_Flush()

static void Con_Rcon_Redirect_Flush ( void )

static

Definition at line 1024 of file console.c.

{
    if(rcon_redirect_sock)
    {
        rcon_redirect_buffer[rcon_redirect_bufferpos] = 0;
        if (rcon_redirect_proquakeprotocol)
        {
            // update the length in the packet header
            StoreBigLong((unsigned char *)rcon_redirect_buffer, NETFLAG_CTL | (rcon_redirect_bufferpos & NETFLAG_LENGTH_MASK));
        }
        NetConn_Write(rcon_redirect_sock, rcon_redirect_buffer, rcon_redirect_bufferpos, rcon_redirect_dest);
    }
    memcpy(rcon_redirect_buffer, "\377\377\377\377n", 5); // QW rcon print
    rcon_redirect_bufferpos = 5;
    rcon_redirect_proquakeprotocol = false;
}

References NetConn_Write(), NETFLAG_CTL, NETFLAG_LENGTH_MASK, rcon_redirect_buffer, rcon_redirect_bufferpos, rcon_redirect_dest, rcon_redirect_proquakeprotocol, rcon_redirect_sock, and StoreBigLong().

Referenced by Con_Rcon_AddChar(), and Con_Rcon_Redirect_End().

◆ Con_Rcon_Redirect_Init()

void Con_Rcon_Redirect_Init	(	lhnetsocket_t *	sock,
		lhnetaddress_t *	dest,
		qbool	proquakeprotocol )

Definition at line 1004 of file console.c.

{
    rcon_redirect_sock = sock;
    rcon_redirect_dest = dest;
    rcon_redirect_proquakeprotocol = proquakeprotocol;
    if (rcon_redirect_proquakeprotocol)
    {
        // reserve space for the packet header
        rcon_redirect_buffer[0] = 0;
        rcon_redirect_buffer[1] = 0;
        rcon_redirect_buffer[2] = 0;
        rcon_redirect_buffer[3] = 0;
        // this is a reply to a CCREQ_RCON
        rcon_redirect_buffer[4] = (unsigned char)CCREP_RCON;
    }
    else
        memcpy(rcon_redirect_buffer, "\377\377\377\377n", 5); // QW rcon print
    rcon_redirect_bufferpos = 5;
}

References CCREP_RCON, rcon_redirect_buffer, rcon_redirect_bufferpos, rcon_redirect_dest, rcon_redirect_proquakeprotocol, and rcon_redirect_sock.

Referenced by RCon_Execute().

◆ Con_Shutdown()

void Con_Shutdown ( void )

Definition at line 941 of file console.c.

{
    if (con_mutex) Thread_LockMutex(con_mutex);
    ConBuffer_Shutdown(&con);
    if (con_mutex) Thread_UnlockMutex(con_mutex);
    if (con_mutex) Thread_DestroyMutex(con_mutex);
    con_mutex = NULL;
}

References con, con_mutex, ConBuffer_Shutdown(), NULL, Thread_DestroyMutex, Thread_LockMutex, and Thread_UnlockMutex.

Referenced by Host_Shutdown().

◆ Con_ToggleConsole_f()

void Con_ToggleConsole_f ( cmd_state_t * cmd )

Definition at line 686 of file console.c.

{
    if (Sys_CheckParm ("-noconsole"))
        if (!(key_consoleactive & KEY_CONSOLEACTIVE_USER))
            return; // only allow the key bind to turn off console
 
    // toggle the 'user wants console' bit
    key_consoleactive ^= KEY_CONSOLEACTIVE_USER;
    Con_ClearNotify();
}

References Con_ClearNotify(), key_consoleactive, KEY_CONSOLEACTIVE_USER, and Sys_CheckParm().

Referenced by Con_Init(), IN_Move_TouchScreen_Quake(), Key_Event(), M_Main_Key(), and M_Options_Key().

◆ Con_WordWidthFunc()

static float Con_WordWidthFunc	(	void *	passthrough,
		const char *	w,
		size_t *	length,
		float	maxWidth )

static

Definition at line 1812 of file console.c.

{
    con_text_info_t *ti = (con_text_info_t *) passthrough;
    if(w == NULL)
    {
        ti->colorindex = -1;
        return ti->fontsize * ti->font->maxwidth;
    }
    if(maxWidth >= 0)
        return DrawQ_TextWidth_UntilWidth(w, length, ti->fontsize, ti->fontsize, false, ti->font, -maxWidth); // -maxWidth: we want at least one char
    else if(maxWidth == -1)
        return DrawQ_TextWidth(w, *length, ti->fontsize, ti->fontsize, false, ti->font);
    else
    {
        Sys_Printf("Con_WordWidthFunc: can't get here (maxWidth should never be %f)\n", maxWidth);
        // Note: this is NOT a Con_Printf, as it could print recursively
        return 0;
    }
}

References con_text_info_t::colorindex, DrawQ_TextWidth(), DrawQ_TextWidth_UntilWidth(), con_text_info_t::font, con_text_info_t::fontsize, length, dp_font_t::maxwidth, NULL, Sys_Printf(), and w.

Referenced by Con_DrawConsoleLine(), Con_DrawNotifyRect(), and Con_LineHeight().

◆ ConBuffer_AddLine()

void ConBuffer_AddLine	(	conbuffer_t *	buf,
		const char *	line,
		int	len,
		unsigned	mask )

Appends a given string as a new line to the console.

Definition at line 332 of file console.c.

{
    char *putpos;
    con_lineinfo_t *p;
 
    // developer_memory 1 during shutdown prints while conbuffer_t is being freed
    if (!buf->active)
        return;
 
    ConBuffer_FixTimes(buf);
 
    if(len >= buf->textsize)
    {
        // line too large?
        // only display end of line.
        line += len - buf->textsize + 1;
        len = buf->textsize - 1;
    }
    while(!(putpos = ConBuffer_BytesLeft(buf, len + 1)) || buf->lines_count >= buf->maxlines)
        ConBuffer_DeleteLine(buf);
    memcpy(putpos, line, len);
    putpos[len] = 0;
    ++buf->lines_count;
 
    //fprintf(stderr, "Now have %d lines (%d -> %d).\n", buf->lines_count, buf->lines_first, CON_LINES_LAST);
 
    p = &CONBUFFER_LINES_LAST(buf);
    p->start = putpos;
    p->len = len;
    p->addtime = cl.time;
    p->mask = mask;
    p->height = -1; // calculate when needed
}

References con_lineinfo_t::addtime, buf, cl, ConBuffer_BytesLeft(), ConBuffer_DeleteLine(), ConBuffer_FixTimes(), CONBUFFER_LINES_LAST, con_lineinfo_t::height, con_lineinfo_t::len, con_lineinfo_t::mask, mask, con_lineinfo_t::start, and client_state_t::time.

Referenced by Con_PrintToHistory(), Key_History_Init(), and Key_History_Push().

◆ ConBuffer_BytesLeft()

static char * ConBuffer_BytesLeft	(	conbuffer_t *	buf,
		int	len )

static

Definition at line 293 of file console.c.

{
    if(len > buf->textsize)
        return NULL;
    if(buf->lines_count == 0)
        return buf->text;
    else
    {
        char *firstline_start = buf->lines[buf->lines_first].start;
        char *lastline_onepastend = CONBUFFER_LINES_LAST(buf).start + CONBUFFER_LINES_LAST(buf).len;
        // the buffer is cyclic, so we first have two cases...
        if(firstline_start < lastline_onepastend) // buffer is contiguous
        {
            // put at end?
            if(len <= buf->text + buf->textsize - lastline_onepastend)
                return lastline_onepastend;
            // put at beginning?
            else if(len <= firstline_start - buf->text)
                return buf->text;
            else
                return NULL;
        }
        else // buffer has a contiguous hole
        {
            if(len <= firstline_start - lastline_onepastend)
                return lastline_onepastend;
            else
                return NULL;
        }
    }
}

References buf, CONBUFFER_LINES_LAST, and NULL.

Referenced by ConBuffer_AddLine().

◆ ConBuffer_Clear()

void ConBuffer_Clear ( conbuffer_t * buf )

Definition at line 212 of file console.c.

{
    buf->lines_count = 0;
}

References buf.

Referenced by Con_Clear_f(), and Key_History_f().

◆ ConBuffer_DeleteLastLine()

void ConBuffer_DeleteLastLine ( conbuffer_t * buf )

Deletes the last line from the console history.

Definition at line 278 of file console.c.

{
    if(buf->lines_count == 0)
        return;
    --buf->lines_count;
}

References buf.

Referenced by Con_PrintToHistory().

◆ ConBuffer_DeleteLine()

void ConBuffer_DeleteLine ( conbuffer_t * buf )

Deletes the first line from the console history.

Definition at line 263 of file console.c.

{
    if(buf->lines_count == 0)
        return;
    --buf->lines_count;
    buf->lines_first = (buf->lines_first + 1) % buf->maxlines;
}

References buf.

Referenced by ConBuffer_AddLine().

◆ ConBuffer_FindPrevLine()

int ConBuffer_FindPrevLine	(	conbuffer_t *	buf,
		unsigned	mask_must,
		unsigned	mask_mustnot,
		int	start )

Definition at line 366 of file console.c.

{
    int i;
    if(start == -1)
        start = buf->lines_count;
    for(i = start - 1; i >= 0; --i)
    {
        con_lineinfo_t *l = &CONBUFFER_LINES(buf, i);
 
        if((l->mask & mask_must) != mask_must)
            continue;
        if(l->mask & mask_mustnot)
            continue;
 
        return i;
    }
 
    return -1;
}

References buf, CONBUFFER_LINES, i, and con_lineinfo_t::mask.

◆ ConBuffer_FixTimes()

void ConBuffer_FixTimes ( conbuffer_t * buf )

Notifies the console code about the current time (and shifts back times of other entries when the time went backwards)

Definition at line 242 of file console.c.

{
    int i;
    if(buf->lines_count >= 1)
    {
        double diff = cl.time - CONBUFFER_LINES_LAST(buf).addtime;
        if(diff < 0)
        {
            for(i = 0; i < buf->lines_count; ++i)
                CONBUFFER_LINES(buf, i).addtime += diff;
        }
    }
}

References buf, cl, CONBUFFER_LINES, CONBUFFER_LINES_LAST, i, and client_state_t::time.

Referenced by Con_DrawNotify(), and ConBuffer_AddLine().

◆ ConBuffer_GetLine()

const char * ConBuffer_GetLine	(	conbuffer_t *	buf,
		int	i )

Definition at line 386 of file console.c.

{
    static char copybuf[MAX_INPUTLINE]; // client only
    con_lineinfo_t *l = &CONBUFFER_LINES(buf, i);
 
    dp_ustr2stp(copybuf, sizeof(copybuf), l->start, l->len);
    return copybuf;
}

References buf, CONBUFFER_LINES, dp_ustr2stp(), i, con_lineinfo_t::len, MAX_INPUTLINE, and con_lineinfo_t::start.

Referenced by Key_History_Down(), Key_History_f(), Key_History_Find_All(), Key_History_Find_Backwards(), Key_History_Find_Forwards(), Key_History_First(), Key_History_Get_foundCommand(), Key_History_Last(), Key_History_Shutdown(), and Key_History_Up().

◆ ConBuffer_Init()

void ConBuffer_Init	(	conbuffer_t *	buf,
		int	textsize,
		int	maxlines,
		mempool_t *	mempool )

Definition at line 108 of file console.c.

{
    buf->active = true;
    buf->textsize = textsize;
    buf->text = (char *) Mem_Alloc(mempool, textsize);
    buf->maxlines = maxlines;
    buf->lines = (con_lineinfo_t *) Mem_Alloc(mempool, maxlines * sizeof(*buf->lines));
    buf->lines_first = 0;
    buf->lines_count = 0;
}

References buf, and Mem_Alloc.

Referenced by Con_Init(), and Key_History_Init().

◆ ConBuffer_Shutdown()

void ConBuffer_Shutdown ( conbuffer_t * buf )

Definition at line 222 of file console.c.

{
    buf->active = false;
    if (buf->text)
        Mem_Free(buf->text);
    if (buf->lines)
        Mem_Free(buf->lines);
    buf->text = NULL;
    buf->lines = NULL;
}

References buf, Mem_Free, and NULL.

Referenced by Con_Shutdown(), and Key_History_Shutdown().

◆ GetMapList()

qbool GetMapList	(	const char *	s,
		char *	completedname,
		int	completednamebufferlength )

Definition at line 2275 of file console.c.

{
    fssearch_t  *t;
    char        message[1024];
    int         i, k, max, p, o, min;
    unsigned char *len;
    qfile_t     *f;
    unsigned char buf[1024];
 
    dpsnprintf(message, sizeof(message), "maps/%s*.bsp", s);
    t = FS_Search(message, 1, true, NULL);
    if(!t)
        return false;
    if (t->numfilenames > 1)
        Con_Printf("^1 %i maps found :\n", t->numfilenames);
    len = (unsigned char *)Z_Malloc(t->numfilenames);
    min = 666;
    for(max=i=0;i<t->numfilenames;i++)
    {
        k = (int)strlen(t->filenames[i]);
        k -= 9;
        if(max < k)
            max = k;
        else
        if(min > k)
            min = k;
        len[i] = k;
    }
    o = (int)strlen(s);
    for(i=0;i<t->numfilenames;i++)
    {
        int lumpofs = 0, lumplen = 0;
        char *entities = NULL;
        const char *data = NULL;
        char keyname[64];
        char entfilename[MAX_QPATH];
        char desc[64];
        desc[0] = 0;
        dp_strlcpy(message, "^1ERROR: open failed^7", sizeof(message));
        p = 0;
        f = FS_OpenVirtualFile(t->filenames[i], true);
        if(f)
        {
            dp_strlcpy(message, "^1ERROR: not a known map format^7", sizeof(message));
            memset(buf, 0, 1024);
            FS_Read(f, buf, 1024);
            if (!memcmp(buf, "IBSP", 4))
            {
                p = LittleLong(((int *)buf)[1]);
                if (p == Q3BSPVERSION || p == Q3BSPVERSION_LIVE || p == Q3BSPVERSION_IG)
                {
                    q3dheader_t *header = (q3dheader_t *)buf;
                    lumpofs = LittleLong(header->lumps[Q3LUMP_ENTITIES].fileofs);
                    lumplen = LittleLong(header->lumps[Q3LUMP_ENTITIES].filelen);
                    dpsnprintf(desc, sizeof(desc), "Q3BSP%i", p);
                }
                else if (p == Q2BSPVERSION)
                {
                    q2dheader_t *header = (q2dheader_t *)buf;
                    lumpofs = LittleLong(header->lumps[Q2LUMP_ENTITIES].fileofs);
                    lumplen = LittleLong(header->lumps[Q2LUMP_ENTITIES].filelen);
                    dpsnprintf(desc, sizeof(desc), "Q2BSP%i", p);
                }
                else
                    dpsnprintf(desc, sizeof(desc), "IBSP%i", p);
            }
            else if (BuffLittleLong(buf) == BSPVERSION)
            {
                lumpofs = BuffLittleLong(buf + 4 + 8 * LUMP_ENTITIES);
                lumplen = BuffLittleLong(buf + 4 + 8 * LUMP_ENTITIES + 4);
                dpsnprintf(desc, sizeof(desc), "BSP29");
            }
            else if (BuffLittleLong(buf) == 30)
            {
                lumpofs = BuffLittleLong(buf + 4 + 8 * LUMP_ENTITIES);
                lumplen = BuffLittleLong(buf + 4 + 8 * LUMP_ENTITIES + 4);
                dpsnprintf(desc, sizeof(desc), "BSPHL");
            }
            else if (!memcmp(buf, "BSP2", 4))
            {
                lumpofs = BuffLittleLong(buf + 4 + 8 * LUMP_ENTITIES);
                lumplen = BuffLittleLong(buf + 4 + 8 * LUMP_ENTITIES + 4);
                dpsnprintf(desc, sizeof(desc), "BSP2");
            }
            else if (!memcmp(buf, "2PSB", 4))
            {
                lumpofs = BuffLittleLong(buf + 4 + 8 * LUMP_ENTITIES);
                lumplen = BuffLittleLong(buf + 4 + 8 * LUMP_ENTITIES + 4);
                dpsnprintf(desc, sizeof(desc), "BSP2RMQe");
            }
            else if(!memcmp(buf, "VBSP", 4))
            {
                hl2dheader_t *header = (hl2dheader_t *)buf;
                lumpofs = LittleLong(header->lumps[HL2LUMP_ENTITIES].fileofs);
                lumplen = LittleLong(header->lumps[HL2LUMP_ENTITIES].filelen);
                dpsnprintf(desc, sizeof(desc), "VBSP%i", LittleLong(((int *)buf)[1]));
            }
            else
                dpsnprintf(desc, sizeof(desc), "unknown%i", BuffLittleLong(buf));
            dp_strlcpy(entfilename, t->filenames[i], sizeof(entfilename));
            memcpy(entfilename + strlen(entfilename) - 4, ".ent", 5);
            entities = (char *)FS_LoadFile(entfilename, tempmempool, true, NULL);
            if (!entities && lumplen >= 10)
            {
                FS_Seek(f, lumpofs, SEEK_SET);
                entities = (char *)Z_Malloc(lumplen + 1);
                FS_Read(f, entities, lumplen);
            }
            if (entities)
            {
                // if there are entities to parse, a missing message key just
                // means there is no title, so clear the message string now
                message[0] = 0;
                data = entities;
                for (;;)
                {
                    int l;
                    if (!COM_ParseToken_Simple(&data, false, false, true))
                        break;
                    if (com_token[0] == '{')
                        continue;
                    if (com_token[0] == '}')
                        break;
                    // skip leading whitespace
                    for (k = 0;com_token[k] && ISWHITESPACE(com_token[k]);k++);
                    for (l = 0;l < (int)sizeof(keyname) - 1 && com_token[k+l] && !ISWHITESPACE(com_token[k+l]);l++)
                        keyname[l] = com_token[k+l];
                    keyname[l] = 0;
                    if (!COM_ParseToken_Simple(&data, false, false, true))
                        break;
                    if (developer_extra.integer)
                        Con_DPrintf("key: %s %s\n", keyname, com_token);
                    if (!strcmp(keyname, "message"))
                    {
                        // get the message contents
                        dp_strlcpy(message, com_token, sizeof(message));
                        break;
                    }
                }
            }
        }
        if (entities)
            Z_Free(entities);
        if(f)
            FS_Close(f);
        *(t->filenames[i]+len[i]+5) = 0;
        Con_Printf("%16s (%-8s) %s\n", t->filenames[i]+5, desc, message);
    }
    Con_Print("\n");
    for(p=o;p<min;p++)
    {
        k = *(t->filenames[0]+5+p);
        if(k == 0)
            goto endcomplete;
        for(i=1;i<t->numfilenames;i++)
            if(*(t->filenames[i]+5+p) != k)
                goto endcomplete;
    }
endcomplete:
    if(p > o && completedname && completednamebufferlength > 0)
    {
        memset(completedname, 0, completednamebufferlength);
        memcpy(completedname, (t->filenames[0]+5), min(p, completednamebufferlength - 1));
    }
    Z_Free(len);
    FS_FreeSearch(t);
    return p > o;
}

References BSPVERSION, buf, BuffLittleLong(), COM_ParseToken_Simple(), com_token, Con_DPrintf(), Con_Print(), Con_Printf(), data, developer_extra, dp_strlcpy, dpsnprintf(), f, hl2lump_t::filelen, lump_t::filelen, fssearch_t::filenames, hl2lump_t::fileofs, lump_t::fileofs, FS_Close(), FS_FreeSearch(), FS_LoadFile(), FS_OpenVirtualFile(), FS_Read(), FS_Search(), FS_Seek(), HL2LUMP_ENTITIES, i, int(), cvar_t::integer, ISWHITESPACE, LittleLong, LUMP_ENTITIES, hl2dheader_t::lumps, q2dheader_t::lumps, q3dheader_t::lumps, max, MAX_QPATH, message, min, NULL, fssearch_t::numfilenames, Q2BSPVERSION, Q2LUMP_ENTITIES, Q3BSPVERSION, Q3BSPVERSION_IG, Q3BSPVERSION_LIVE, Q3LUMP_ENTITIES, strlen(), tempmempool, Z_Free, and Z_Malloc.

Referenced by Con_CompleteCommandLine(), and Con_Maps_f().

◆ Log_Close()

void Log_Close ( void )

Definition at line 521 of file console.c.

{
    qfile_t* l = logfile;
 
    if (l == NULL)
        return;
 
    FS_Print (l, Log_Timestamp ("Log stopped"));
    FS_Print (l, "\n");
    logfile = NULL;
    FS_Close (l);
 
    crt_log_file[0] = '\0';
}

References crt_log_file, FS_Close(), FS_Print(), Log_Timestamp(), logfile, and NULL.

Referenced by Host_Shutdown(), and Log_ConPrint().

◆ Log_ConPrint()

void Log_ConPrint ( const char * msg )

Definition at line 584 of file console.c.

{
    static qbool inprogress = false;
 
    // don't allow feedback loops with memory error reports
    if (inprogress)
        return;
    inprogress = true;
 
    // Until the host is completely initialized, we maintain a log queue
    // to store the messages, since the log can't be started before
    if (logqueue != NULL)
    {
        size_t remain = logq_size - logq_ind;
        size_t len = strlen (msg);
 
        // If we need to enlarge the log queue
        if (len > remain)
        {
            size_t factor = ((logq_ind + len) / logq_size) + 1;
            unsigned char* newqueue;
 
            logq_size *= factor;
            newqueue = (unsigned char *)Mem_Alloc (tempmempool, logq_size);
            memcpy (newqueue, logqueue, logq_ind);
            Mem_Free (logqueue);
            logqueue = newqueue;
            remain = logq_size - logq_ind;
        }
        memcpy (&logqueue[logq_ind], msg, len);
        logq_ind += len;
 
        inprogress = false;
        return;
    }
 
    // Check if log_file has changed
    if (strcmp (crt_log_file, log_file.string) != 0)
    {
        Log_Close ();
        Log_Open ();
    }
 
    // If a log file is available
    if (logfile != NULL)
    {
        if (log_file_stripcolors.integer)
        {
            // sanitize msg
            size_t len = strlen(msg);
            char* sanitizedmsg = (char*)Mem_Alloc(tempmempool, len + 1);
            memcpy (sanitizedmsg, msg, len);
            SanitizeString(sanitizedmsg, sanitizedmsg); // SanitizeString's in pointer is always ahead of the out pointer, so this should work.
            FS_Print (logfile, sanitizedmsg);
            Mem_Free(sanitizedmsg);
        }
        else 
        {
            FS_Print (logfile, msg);
        }
    }
 
    inprogress = false;
}

References crt_log_file, FS_Print(), cvar_t::integer, Log_Close(), log_file, log_file_stripcolors, Log_Open(), logfile, logq_ind, logq_size, logqueue, Mem_Alloc, Mem_Free, NULL, SanitizeString(), cvar_t::string, strlen(), and tempmempool.

Referenced by Con_MaskPrint().

◆ Log_DestBuffer_Flush()

void Log_DestBuffer_Flush ( void )

call this once per frame to send out replies to rcon streaming clients

Definition at line 465 of file console.c.

{
    if (con_mutex)
        Thread_LockMutex(con_mutex);
    Log_DestBuffer_Flush_NoLock();
    if (con_mutex)
        Thread_UnlockMutex(con_mutex);
}

References con_mutex, Log_DestBuffer_Flush_NoLock(), Thread_LockMutex, and Thread_UnlockMutex.

Referenced by Host_Frame().

◆ Log_DestBuffer_Flush_NoLock()

static void Log_DestBuffer_Flush_NoLock ( void )

static

Definition at line 426 of file console.c.

{
    lhnetaddress_t log_dest_addr;
    lhnetsocket_t *log_dest_socket;
    const char *s = log_dest_udp.string;
    qbool have_opened_temp_sockets = false;
    if(s) if(log_dest_buffer_pos > 5)
    {
        ++log_dest_buffer_appending;
        log_dest_buffer[log_dest_buffer_pos++] = 0;
 
        if(!NetConn_HaveServerPorts() && !NetConn_HaveClientPorts()) // then temporarily open one
        {
            have_opened_temp_sockets = true;
            NetConn_OpenServerPorts(true);
        }
 
        while(COM_ParseToken_Console(&s))
            if(LHNETADDRESS_FromString(&log_dest_addr, com_token, 26000))
            {
                log_dest_socket = NetConn_ChooseClientSocketForAddress(&log_dest_addr);
                if(!log_dest_socket)
                    log_dest_socket = NetConn_ChooseServerSocketForAddress(&log_dest_addr);
                if(log_dest_socket)
                    NetConn_WriteString(log_dest_socket, log_dest_buffer, &log_dest_addr);
            }
 
        if(have_opened_temp_sockets)
            NetConn_CloseServerPorts();
        --log_dest_buffer_appending;
    }
    log_dest_buffer_pos = 0;
}

References COM_ParseToken_Console(), com_token, LHNETADDRESS_FromString(), log_dest_buffer, log_dest_buffer_appending, log_dest_buffer_pos, log_dest_udp, NetConn_ChooseClientSocketForAddress(), NetConn_ChooseServerSocketForAddress(), NetConn_CloseServerPorts(), NetConn_HaveClientPorts(), NetConn_HaveServerPorts(), NetConn_OpenServerPorts(), NetConn_WriteString(), and cvar_t::string.

Referenced by Con_Rcon_AddChar(), Log_DestBuffer_Flush(), and Log_Start().

◆ Log_DestBuffer_Init()

static void Log_DestBuffer_Init ( void )

static

Definition at line 420 of file console.c.

{
    memcpy(log_dest_buffer, "\377\377\377\377n", 5); // QW rcon print
    log_dest_buffer_pos = 5;
}

References log_dest_buffer, and log_dest_buffer_pos.

Referenced by Con_Rcon_AddChar(), and Log_Start().

◆ Log_Open()

static void Log_Open ( void )

static

Definition at line 503 of file console.c.

{
    if (logfile != NULL || log_file.string[0] == '\0')
        return;
 
    logfile = FS_OpenRealFile(log_file.string, "a", false);
    if (logfile != NULL)
    {
        dp_strlcpy (crt_log_file, log_file.string, sizeof (crt_log_file));
        FS_Print (logfile, Log_Timestamp ("Log started"));
    }
}

References crt_log_file, dp_strlcpy, FS_OpenRealFile(), FS_Print(), log_file, Log_Timestamp(), logfile, NULL, and cvar_t::string.

Referenced by Log_ConPrint(), and Log_Start().

◆ Log_Printf()

void Log_Printf	(	const char *	logfilename,
		const char *	fmt,
			... )

Definition at line 655 of file console.c.

{
    qfile_t *file;
 
    file = FS_OpenRealFile(logfilename, "a", true);
    if (file != NULL)
    {
        va_list argptr;
 
        va_start (argptr, fmt);
        FS_VPrintf (file, fmt, argptr);
        va_end (argptr);
 
        FS_Close (file);
    }
}

References FS_Close(), FS_OpenRealFile(), FS_VPrintf(), and NULL.

Referenced by CL_FinishTimeDemo(), CL_IPLog_Add(), loadimagepixelsbgra(), and R_LoadTextureDDSFile().

◆ Log_Start()

void Log_Start ( void )

Definition at line 542 of file console.c.

{
    size_t pos;
    size_t n;
    Log_Open ();
 
    // Dump the contents of the log queue into the log file and free it
    if (logqueue != NULL)
    {
        unsigned char *temp = logqueue;
        logqueue = NULL;
        if(logq_ind != 0)
        {
            if (logfile != NULL)
                FS_Write (logfile, temp, logq_ind);
            if(*log_dest_udp.string)
            {
                for(pos = 0; pos < logq_ind; )
                {
                    if(log_dest_buffer_pos == 0)
                        Log_DestBuffer_Init();
                    n = min(sizeof(log_dest_buffer) - log_dest_buffer_pos - 1, logq_ind - pos);
                    memcpy(log_dest_buffer + log_dest_buffer_pos, temp + pos, n);
                    log_dest_buffer_pos += n;
                    Log_DestBuffer_Flush_NoLock();
                    pos += n;
                }
            }
        }
        Mem_Free (temp);
        logq_ind = 0;
        logq_size = 0;
    }
}

References FS_Write(), log_dest_buffer, log_dest_buffer_pos, log_dest_udp, Log_DestBuffer_Flush_NoLock(), Log_DestBuffer_Init(), Log_Open(), logfile, logq_ind, logq_size, logqueue, Mem_Free, min, n, NULL, and cvar_t::string.

Referenced by Host_Init().

◆ Log_Timestamp()

static const char * Log_Timestamp ( const char * desc )

static

Definition at line 474 of file console.c.

{
    static char timestamp [128]; // init/shutdown only
    time_t crt_time;
#if _MSC_VER >= 1400
    struct tm crt_tm;
#else
    struct tm *crt_tm;
#endif
    char timestring [64];
 
    // Build the time stamp (ex: "Wed Jun 30 21:49:08 1993");
    time (&crt_time);
#if _MSC_VER >= 1400
    localtime_s (&crt_tm, &crt_time);
    strftime (timestring, sizeof (timestring), "%a %b %d %H:%M:%S %Y", &crt_tm);
#else
    crt_tm = localtime (&crt_time);
    strftime (timestring, sizeof (timestring), "%a %b %d %H:%M:%S %Y", crt_tm);
#endif
 
    if (desc != NULL)
        dpsnprintf (timestamp, sizeof (timestamp), "====== %s (%s) ======\n", desc, timestring);
    else
        dpsnprintf (timestamp, sizeof (timestamp), "====== %s ======\n", timestring);
 
    return timestamp;
}

References dpsnprintf(), NULL, and time.

Referenced by Log_Close(), and Log_Open().

◆ Nicks_AddLastColor()

static int Nicks_AddLastColor	(	char *	buffer,
		int	pos )

static

Definition at line 2826 of file console.c.

{
    qbool quote_added = false;
    int match;
    int color = STRING_COLOR_DEFAULT + '0';
    char r = 0, g = 0, b = 0;
 
    if(con_nickcompletion_flags.integer & NICKS_ADD_QUOTE && buffer[Nicks_matchpos-1] == '\"')
    {
        // we'll have to add a quote :)
        buffer[pos++] = '\"';
        quote_added = true;
    }
 
    if((!quote_added && con_nickcompletion_flags.integer & NICKS_ADD_COLOR) || con_nickcompletion_flags.integer & NICKS_FORCE_COLOR)
    {
        // add color when no quote was added, or when flags &4?
        // find last color
        for(match = Nicks_matchpos-1; match >= 0; --match)
        {
            if(buffer[match] == STRING_COLOR_TAG)
            {
                if( isdigit(buffer[match+1]) )
                {
                    color = buffer[match+1];
                    break;
                }
                else if(buffer[match+1] == STRING_COLOR_RGB_TAG_CHAR)
                {
                    if ( isxdigit(buffer[match+2]) && isxdigit(buffer[match+3]) && isxdigit(buffer[match+4]) )
                    {
                        r = buffer[match+2];
                        g = buffer[match+3];
                        b = buffer[match+4];
                        color = -1;
                        break;
                    }
                }
            }
        }
        if(!quote_added)
        {
            if( pos >= 2 && buffer[pos-2] == STRING_COLOR_TAG && isdigit(buffer[pos-1]) ) // when thes use &4
                pos -= 2;
            else if( pos >= 5 && buffer[pos-5] == STRING_COLOR_TAG && buffer[pos-4] == STRING_COLOR_RGB_TAG_CHAR
                     && isxdigit(buffer[pos-3]) && isxdigit(buffer[pos-2]) && isxdigit(buffer[pos-1]) )
                pos -= 5;
        }
        buffer[pos++] = STRING_COLOR_TAG;
        if (color == -1)
        {
            buffer[pos++] = STRING_COLOR_RGB_TAG_CHAR;
            buffer[pos++] = r;
            buffer[pos++] = g;
            buffer[pos++] = b;
        }
        else
            buffer[pos++] = color;
    }
    return pos;
}

References b, buffer, color, con_nickcompletion_flags, g, cvar_t::integer, NICKS_ADD_COLOR, NICKS_ADD_QUOTE, NICKS_FORCE_COLOR, Nicks_matchpos, r, STRING_COLOR_DEFAULT, STRING_COLOR_RGB_TAG_CHAR, and STRING_COLOR_TAG.

Referenced by Con_CompleteCommandLine().

◆ Nicks_CompleteBuildList()

static const char ** Nicks_CompleteBuildList ( int count )

static

Definition at line 2806 of file console.c.

{
    const char **buf;
    int bpos = 0;
    // the list is freed by Con_CompleteCommandLine, so create a char**
    buf = (const char **)Mem_Alloc(tempmempool, count * sizeof(const char *) + sizeof (const char *));
 
    for(; bpos < count; ++bpos)
        buf[bpos] = Nicks_sanlist[bpos] + Nicks_offset[bpos];
 
    Nicks_CutMatches(count);
 
    buf[bpos] = NULL;
    return buf;
}

References buf, count, Mem_Alloc, Nicks_CutMatches(), Nicks_offset, Nicks_sanlist, NULL, and tempmempool.

Referenced by Con_CompleteCommandLine().

◆ Nicks_CompleteCountPossible()

static int Nicks_CompleteCountPossible	(	char *	line,
		int	pos,
		char *	s,
		qbool	isCon )

static

Definition at line 2570 of file console.c.

{
    char name[MAX_SCOREBOARDNAME];
    int i, p;
    int match;
    int spos;
    int count = 0;
 
    if(!con_nickcompletion.integer)
        return 0;
 
    // changed that to 1
    if(!line[0])// || !line[1]) // we want at least... 2 written characters
        return 0;
 
    for(i = 0; i < cl.maxclients; ++i)
    {
        p = i;
        if(!cl.scores[p].name[0])
            continue;
 
        SanitizeString(cl.scores[p].name, name);
        //Con_Printf(" ^2Sanitized: ^7%s -> %s", cl.scores[p].name, name);
 
        if(!name[0])
            continue;
 
        match = -1;
        spos = pos - 1; // no need for a minimum of characters :)
 
        while(spos >= 0)
        {
            if(spos > 0 && line[spos-1] != ' ' && line[spos-1] != ';' && line[spos-1] != '\"' && line[spos-1] != '\'')
            {
                if(!(isCon && spos == 1)) // console start
                {
                    --spos;
                    continue;
                }
            }
            if(isCon && spos == 0)
                break;
            if(Nicks_strncasecmp(line+spos, name, pos-spos) == 0)
                match = spos;
            --spos;
        }
        if(match < 0)
            continue;
        //Con_Printf("Possible match: %s|%s\n", cl.scores[p].name, name);
        dp_strlcpy(Nicks_list[count], cl.scores[p].name, sizeof(Nicks_list[count]));
 
        // the sanitized list
        dp_strlcpy(Nicks_sanlist[count], name, sizeof(Nicks_sanlist[count]));
        if(!count)
        {
            Nicks_matchpos = match;
        }
 
        Nicks_offset[count] = s - (&line[match]);
        //Con_Printf("offset for %s: %i\n", name, Nicks_offset[count]);
 
        ++count;
    }
    return count;
}

References cl, con_nickcompletion, count, dp_strlcpy, i, cvar_t::integer, MAX_SCOREBOARDNAME, client_state_t::maxclients, name, scoreboard_t::name, Nicks_list, Nicks_matchpos, Nicks_offset, Nicks_sanlist, Nicks_strncasecmp(), SanitizeString(), and client_state_t::scores.

Referenced by Con_CompleteCommandLine().

◆ Nicks_CutMatches()

static void Nicks_CutMatches ( int count )

static

Definition at line 2796 of file console.c.

{
    if(con_nickcompletion_flags.integer & NICKS_ALPHANUMERICS_ONLY)
        Nicks_CutMatchesAlphaNumeric(count);
    else if(con_nickcompletion_flags.integer & NICKS_NO_SPACES)
        Nicks_CutMatchesNoSpaces(count);
    else
        Nicks_CutMatchesNormal(count);
}

References con_nickcompletion_flags, count, cvar_t::integer, NICKS_ALPHANUMERICS_ONLY, Nicks_CutMatchesAlphaNumeric(), Nicks_CutMatchesNormal(), Nicks_CutMatchesNoSpaces(), and NICKS_NO_SPACES.

Referenced by Nicks_CompleteBuildList().

◆ Nicks_CutMatchesAlphaNumeric()

static void Nicks_CutMatchesAlphaNumeric ( int count )

static

Definition at line 2681 of file console.c.

{
    // cut match 0 down to the longest possible completion
    int i;
    unsigned int c, l;
    char tempstr[sizeof(Nicks_sanlist[0])];
    char *a, *b;
    char space_char = (con_nickcompletion_flags.integer & NICKS_NO_SPACES) ? 'a' : ' '; // yes this is correct, we want NO spaces when no spaces
 
    c = (unsigned int)strlen(Nicks_sanlist[0]);
    for(i = 0, l = 0; i < (int)c; ++i)
    {
        if( (Nicks_sanlist[0][i] >= 'a' && Nicks_sanlist[0][i] <= 'z') ||
            (Nicks_sanlist[0][i] >= 'A' && Nicks_sanlist[0][i] <= 'Z') ||
            (Nicks_sanlist[0][i] >= '0' && Nicks_sanlist[0][i] <= '9') || Nicks_sanlist[0][i] == space_char) // this is what's COPIED
        {
            tempstr[l++] = Nicks_sanlist[0][i];
        }
    }
    tempstr[l] = 0;
 
    for(i = 1; i < count; ++i)
    {
        a = tempstr;
        b = Nicks_sanlist[i];
        while(1)
        {
            if(!*a)
                break;
            if(!*b)
            {
                *a = 0;
                break;
            }
            if(tolower(*a) == tolower(*b))
            {
                ++a;
                ++b;
                continue;
            }
            if( (*b >= 'a' && *b <= 'z') || (*b >= 'A' && *b <= 'Z') || (*b >= '0' && *b <= '9') || *b == space_char)
            {
                // b is alnum, so cut
                *a = 0;
                break;
            }
            ++b;
        }
    }
    // Just so you know, if cutmatchesnormal doesn't kill the first entry, then even the non-alnums fit
    Nicks_CutMatchesNormal(count);
    //if(!Nicks_sanlist[0][0])
    if(Nicks_strcleanlen(Nicks_sanlist[0]) < strlen(tempstr))
    {
        // if the clean sanitized one is longer than the current one, use it, it has crap chars which definitely are in there
        dp_strlcpy(Nicks_sanlist[0], tempstr, sizeof(Nicks_sanlist[0]));
    }
}

References a, b, con_nickcompletion_flags, count, dp_strlcpy, i, int(), cvar_t::integer, Nicks_CutMatchesNormal(), NICKS_NO_SPACES, Nicks_sanlist, Nicks_strcleanlen(), and strlen().

Referenced by Nicks_CutMatches().

◆ Nicks_CutMatchesNormal()

static void Nicks_CutMatchesNormal ( int count )

static

Definition at line 2643 of file console.c.

{
    // cut match 0 down to the longest possible completion
    int i;
    unsigned int c, l;
    c = (unsigned int)strlen(Nicks_sanlist[0]) - 1;
    for(i = 1; i < count; ++i)
    {
        l = (unsigned int)strlen(Nicks_sanlist[i]) - 1;
        if(l < c)
            c = l;
 
        for(l = 0; l <= c; ++l)
            if(tolower(Nicks_sanlist[0][l]) != tolower(Nicks_sanlist[i][l]))
            {
                c = l-1;
                break;
            }
    }
    Nicks_sanlist[0][c+1] = 0;
    //Con_Printf("List0: %s\n", Nicks_sanlist[0]);
}

References count, i, int(), Nicks_sanlist, and strlen().

Referenced by Nicks_CutMatches(), Nicks_CutMatchesAlphaNumeric(), and Nicks_CutMatchesNoSpaces().

◆ Nicks_CutMatchesNoSpaces()

static void Nicks_CutMatchesNoSpaces ( int count )

static

Definition at line 2740 of file console.c.

{
    // cut match 0 down to the longest possible completion
    int i;
    unsigned int c, l;
    char tempstr[sizeof(Nicks_sanlist[0])];
    char *a, *b;
 
    c = (unsigned int)strlen(Nicks_sanlist[0]);
    for(i = 0, l = 0; i < (int)c; ++i)
    {
        if(Nicks_sanlist[0][i] != ' ') // here it's what's NOT copied
        {
            tempstr[l++] = Nicks_sanlist[0][i];
        }
    }
    tempstr[l] = 0;
 
    for(i = 1; i < count; ++i)
    {
        a = tempstr;
        b = Nicks_sanlist[i];
        while(1)
        {
            if(!*a)
                break;
            if(!*b)
            {
                *a = 0;
                break;
            }
            if(tolower(*a) == tolower(*b))
            {
                ++a;
                ++b;
                continue;
            }
            if(*b != ' ')
            {
                *a = 0;
                break;
            }
            ++b;
        }
    }
    // Just so you know, if cutmatchesnormal doesn't kill the first entry, then even the non-alnums fit
    Nicks_CutMatchesNormal(count);
    //if(!Nicks_sanlist[0][0])
    //Con_Printf("TS: %s\n", tempstr);
    if(Nicks_strcleanlen(Nicks_sanlist[0]) < strlen(tempstr))
    {
        // if the clean sanitized one is longer than the current one, use it, it has crap chars which definitely are in there
        dp_strlcpy(Nicks_sanlist[0], tempstr, sizeof(Nicks_sanlist[0]));
    }
}

References a, b, count, dp_strlcpy, i, int(), Nicks_CutMatchesNormal(), Nicks_sanlist, Nicks_strcleanlen(), and strlen().

Referenced by Nicks_CutMatches().

◆ Nicks_strcleanlen()

static unsigned int Nicks_strcleanlen ( const char * s )

static

Definition at line 2666 of file console.c.

{
    unsigned int l = 0;
    while(*s)
    {
        if( (*s >= 'a' && *s <= 'z') ||
            (*s >= 'A' && *s <= 'Z') ||
            (*s >= '0' && *s <= '9') ||
            *s == ' ')
            ++l;
        ++s;
    }
    return l;
}

Referenced by Nicks_CutMatchesAlphaNumeric(), and Nicks_CutMatchesNoSpaces().

◆ Nicks_strncasecmp()

static int Nicks_strncasecmp	(	char *	a,
		char *	b,
		unsigned int	a_len )

static

Definition at line 2519 of file console.c.

{
    char space_char;
    if(!(con_nickcompletion_flags.integer & NICKS_ALPHANUMERICS_ONLY))
    {
        if(con_nickcompletion_flags.integer & NICKS_NO_SPACES)
            return Nicks_strncasecmp_nospaces(a, b, a_len);
        return strncasecmp(a, b, a_len);
    }
 
    space_char = (con_nickcompletion_flags.integer & NICKS_NO_SPACES) ? 'a' : ' ';
 
    // ignore non alphanumerics of B
    // if A contains a non-alphanumeric, B must contain it as well though!
    while(a_len)
    {
        qbool alnum_a, alnum_b;
 
        if(tolower(*a) == tolower(*b))
        {
            if(*a == 0) // end of both strings, they're equal
                return 0;
            --a_len;
            ++a;
            ++b;
            continue;
        }
        // not equal, end of one string?
        if(!*a)
            return -1;
        if(!*b)
            return 1;
        // ignore non alphanumerics
        alnum_a = ( (*a >= 'a' && *a <= 'z') || (*a >= 'A' && *a <= 'Z') || (*a >= '0' && *a <= '9') || *a == space_char);
        alnum_b = ( (*b >= 'a' && *b <= 'z') || (*b >= 'A' && *b <= 'Z') || (*b >= '0' && *b <= '9') || *b == space_char);
        if(!alnum_a) // b must contain this
            return (*a < *b) ? -1 : 1;
        if(!alnum_b)
            ++b;
        // otherwise, both are alnum, they're just not equal, return the appropriate number
        else
            return (*a < *b) ? -1 : 1;
    }
    return 0;
}

References a, b, con_nickcompletion_flags, cvar_t::integer, NICKS_ALPHANUMERICS_ONLY, NICKS_NO_SPACES, and Nicks_strncasecmp_nospaces().

Referenced by Nicks_CompleteCountPossible().

◆ Nicks_strncasecmp_nospaces()

static int Nicks_strncasecmp_nospaces	(	char *	a,
		char *	b,
		unsigned int	a_len )

static

Definition at line 2493 of file console.c.

{
    while(a_len)
    {
        if(tolower(*a) == tolower(*b))
        {
            if(*a == 0)
                return 0;
            --a_len;
            ++a;
            ++b;
            continue;
        }
        if(!*a)
            return -1;
        if(!*b)
            return 1;
        if(*a == ' ')
            return (*a < *b) ? -1 : 1;
        if(*b == ' ')
            ++b;
        else
            return (*a < *b) ? -1 : 1;
    }
    return 0;
}

References a, and b.

Referenced by Nicks_strncasecmp().

◆ SanitizeString()

static void SanitizeString	(	char *	in,
		char *	out )

static

Definition at line 160 of file console.c.

{
    while(*in)
    {
        if(*in == STRING_COLOR_TAG)
        {
            ++in;
            if(!*in)
            {
                out[0] = STRING_COLOR_TAG;
                out[1] = 0;
                return;
            }
            else if (*in >= '0' && *in <= '9') // ^[0-9] found
            {
                ++in;
                if(!*in)
                {
                    *out = 0;
                    return;
                } else if (*in == STRING_COLOR_TAG) // ^[0-9]^ found, don't print ^[0-9]
                    continue;
            }
            else if (*in == STRING_COLOR_RGB_TAG_CHAR) // ^x found
            {
                if ( isxdigit(in[1]) && isxdigit(in[2]) && isxdigit(in[3]) )
                {
                    in+=4;
                    if (!*in)
                    {
                        *out = 0;
                        return;
                    } else if (*in == STRING_COLOR_TAG) // ^xrgb^ found, don't print ^xrgb
                        continue;
                }
                else in--;
            }
            else if (*in != STRING_COLOR_TAG)
                --in;
        }
        *out = qfont_table[*(unsigned char*)in];
        ++in;
        ++out;
    }
    *out = 0;
}

References qfont_table, STRING_COLOR_RGB_TAG_CHAR, and STRING_COLOR_TAG.

Referenced by Con_ConDump_f(), Log_ConPrint(), and Nicks_CompleteCountPossible().

◆ Sys_Con_NearestColor()

static char Sys_Con_NearestColor	(	const unsigned char	_r,
		const unsigned char	_g,
		const unsigned char	_b )

static

Convert an RGB color to its nearest quake color.

I'll cheat on this a bit by translating the colors to HSV first, S and V decide if it's black or white, otherwise, H will decide the actual color.

Parameters

_r	Red (0-255)
_g	Green (0-255)
_b	Blue (0-255)

Returns: A quake color character.

< Hue angle [0,360]

< Saturation [0,1]

< In HSV v == max [0,1]

Definition at line 1099 of file console.c.

{
    float r = ((float)_r)/255.0;
    float g = ((float)_g)/255.0;
    float b = ((float)_b)/255.0;
    float min = min(r, min(g, b));
    float max = max(r, max(g, b));
 
    int h; 
    float s; 
    float v = max; 
 
    if(max == min)
        s = 0;
    else
        s = 1.0 - (min/max);
 
    // Saturation threshold. We now say 0.2 is the minimum value for a color!
    if(s < 0.2)
    {
        // If the value is less than half, return a black color code.
        // Otherwise return a white one.
        if(v < 0.5)
            return '0';
        return '7';
    }
 
    // Let's get the hue angle to define some colors:
    if(max == min)
        h = 0;
    else if(max == r)
        h = (int)(60.0 * (g-b)/(max-min))%360;
    else if(max == g)
        h = (int)(60.0 * (b-r)/(max-min) + 120);
    else // if(max == b) redundant check
        h = (int)(60.0 * (r-g)/(max-min) + 240);
 
    if(h < 36) // *red* to orange
        return '1';
    else if(h < 80) // orange over *yellow* to evilish-bright-green
        return '3';
    else if(h < 150) // evilish-bright-green over *green* to ugly bright blue
        return '2';
    else if(h < 200) // ugly bright blue over *bright blue* to darkish blue
        return '5';
    else if(h < 270) // darkish blue over *dark blue* to cool purple
        return '4';
    else if(h < 330) // cool purple over *purple* to ugly swiny red
        return '6';
    else // ugly red to red closes the circly
        return '1';
}

References b, float, g, int(), max, min, r, and v.

Referenced by Con_MaskPrint().

Variable Documentation

◆ con

conbuffer_t con

Definition at line 39 of file console.c.

Referenced by Con_CheckResize(), Con_Clear_f(), Con_DrawNotify(), Con_Init(), Con_PrintToHistory(), and Con_Shutdown().

◆ con_backscroll

int con_backscroll

Definition at line 37 of file console.c.

Referenced by Con_CheckResize(), Con_DrawConsole(), Con_LastVisibleLine(), Key_Console(), and Key_Parse_CommonKeys().

◆ con_chat

cvar_t con_chat = {CF_CLIENT | CF_ARCHIVE, "con_chat","0", "how many chat lines to show in a dedicated chat area"}

Definition at line 51 of file console.c.

51{CF_CLIENT | CF_ARCHIVE, "con_chat","0", "how many chat lines to show in a dedicated chat area"};

CF_ARCHIVE

#define CF_ARCHIVE

cvar should have its set value saved to config.cfg and persist across sessions

Definition cmd.h:53

Referenced by Con_DrawNotify(), and Con_Init().

◆ con_chatpos

cvar_t con_chatpos = {CF_CLIENT | CF_ARCHIVE, "con_chatpos","0", "where to put chat (negative: lines from bottom of screen, positive: lines below notify, 0: at top)"}

Definition at line 52 of file console.c.

52{CF_CLIENT | CF_ARCHIVE, "con_chatpos","0", "where to put chat (negative: lines from bottom of screen, positive: lines below notify, 0: at top)"};

Referenced by Con_DrawNotify(), and Con_Init().

◆ con_chatrect

cvar_t con_chatrect = {CF_CLIENT | CF_ARCHIVE, "con_chatrect","0", "use con_chatrect_x and _y to position con_notify and con_chat freely instead of con_chatpos"}

Definition at line 53 of file console.c.

53{CF_CLIENT | CF_ARCHIVE, "con_chatrect","0", "use con_chatrect_x and _y to position con_notify and con_chat freely instead of con_chatpos"};

Referenced by Con_DrawNotify(), and Con_Init().

◆ con_chatrect_x

cvar_t con_chatrect_x = {CF_CLIENT | CF_ARCHIVE, "con_chatrect_x","", "where to put chat, relative x coordinate of left edge on screen (use con_chatwidth for width)"}

Definition at line 54 of file console.c.

54{CF_CLIENT | CF_ARCHIVE, "con_chatrect_x","", "where to put chat, relative x coordinate of left edge on screen (use con_chatwidth for width)"};

Referenced by Con_DrawNotify(), and Con_Init().

◆ con_chatrect_y

cvar_t con_chatrect_y = {CF_CLIENT | CF_ARCHIVE, "con_chatrect_y","", "where to put chat, relative y coordinate of top edge on screen (use con_chat for line count)"}

Definition at line 55 of file console.c.

55{CF_CLIENT | CF_ARCHIVE, "con_chatrect_y","", "where to put chat, relative y coordinate of top edge on screen (use con_chat for line count)"};

Referenced by Con_DrawNotify(), and Con_Init().

◆ con_chatsize

cvar_t con_chatsize = {CF_CLIENT | CF_ARCHIVE, "con_chatsize","8", "chat text size in virtual 2D pixels (if con_chat is enabled)"}

Definition at line 59 of file console.c.

59{CF_CLIENT | CF_ARCHIVE, "con_chatsize","8", "chat text size in virtual 2D pixels (if con_chat is enabled)"};

Referenced by Con_DrawNotify(), and Con_Init().

◆ con_chatsound

cvar_t con_chatsound = {CF_CLIENT | CF_ARCHIVE, "con_chatsound","1", "enables chat sound to play on message"}

Definition at line 60 of file console.c.

60{CF_CLIENT | CF_ARCHIVE, "con_chatsound","1", "enables chat sound to play on message"};

Referenced by Con_Init(), and Con_MaskPrint().

◆ con_chatsound_file

cvar_t con_chatsound_file = {CF_CLIENT, "con_chatsound_file","sound/misc/talk.wav", "The sound to play for chat messages"}

Definition at line 61 of file console.c.

61{CF_CLIENT, "con_chatsound_file","sound/misc/talk.wav", "The sound to play for chat messages"};

Referenced by Con_Init(), and Con_MaskPrint().

◆ con_chatsound_team_file

cvar_t con_chatsound_team_file = {CF_CLIENT, "con_chatsound_team_file","sound/misc/talk2.wav", "The sound to play for team chat messages"}

Definition at line 62 of file console.c.

62{CF_CLIENT, "con_chatsound_team_file","sound/misc/talk2.wav", "The sound to play for team chat messages"};

Referenced by CL_SetupWorldModel(), Con_Init(), and Con_MaskPrint().

◆ con_chatsound_team_mask

cvar_t con_chatsound_team_mask = {CF_CLIENT, "con_chatsound_team_mask","40","Magic ASCII code that denotes a team chat message"}

Definition at line 63 of file console.c.

63{CF_CLIENT, "con_chatsound_team_mask","40","Magic ASCII code that denotes a team chat message"};

Referenced by Con_Init(), and Con_MaskPrint().

◆ con_chattime

cvar_t con_chattime = {CF_CLIENT | CF_ARCHIVE, "con_chattime","30", "how long chat lines last, in seconds"}

Definition at line 50 of file console.c.

50{CF_CLIENT | CF_ARCHIVE, "con_chattime","30", "how long chat lines last, in seconds"};

Referenced by Con_DrawNotify(), and Con_Init().

◆ con_chatwidth

cvar_t con_chatwidth = {CF_CLIENT | CF_ARCHIVE, "con_chatwidth","1.0", "relative chat window width"}

Definition at line 56 of file console.c.

56{CF_CLIENT | CF_ARCHIVE, "con_chatwidth","1.0", "relative chat window width"};

Referenced by Con_DrawNotify(), and Con_Init().

◆ con_completion_exec

cvar_t con_completion_exec = {CF_CLIENT | CF_ARCHIVE, "con_completion_exec", "*.cfg", "completion pattern for the exec command"}

Definition at line 85 of file console.c.

85{CF_CLIENT | CF_ARCHIVE, "con_completion_exec", "*.cfg", "completion pattern for the exec command"};

Referenced by Con_Init().

◆ con_completion_playdemo

cvar_t con_completion_playdemo = {CF_CLIENT | CF_ARCHIVE, "con_completion_playdemo", "*.dem", "completion pattern for the playdemo command"}

Definition at line 83 of file console.c.

83{CF_CLIENT | CF_ARCHIVE, "con_completion_playdemo", "*.dem", "completion pattern for the playdemo command"};

Referenced by Con_Init().

◆ con_completion_timedemo

cvar_t con_completion_timedemo = {CF_CLIENT | CF_ARCHIVE, "con_completion_timedemo", "*.dem", "completion pattern for the timedemo command"}

Definition at line 84 of file console.c.

84{CF_CLIENT | CF_ARCHIVE, "con_completion_timedemo", "*.dem", "completion pattern for the timedemo command"};

Referenced by Con_Init().

◆ con_cursorspeed

float con_cursorspeed = 4

Definition at line 34 of file console.c.

Referenced by Con_DrawInput().

◆ con_initialized

qbool con_initialized

Definition at line 97 of file console.c.

Referenced by CL_UpdateScreen(), Con_Init(), and Con_MaskPrint().

◆ con_linewidth

int con_linewidth

Definition at line 94 of file console.c.

Referenced by Con_CenterPrintf(), Con_CheckResize(), Con_DisplayList(), Con_Init(), Con_Quakebar(), FS_ListDirectory(), and LoadFont().

◆ con_mutex

void* con_mutex = NULL

Definition at line 40 of file console.c.

Referenced by Con_Clear_f(), Con_ConDump_f(), Con_DrawConsole(), Con_DrawNotify(), Con_Init(), Con_MaskPrint(), Con_Shutdown(), and Log_DestBuffer_Flush().

◆ con_nickcompletion

cvar_t con_nickcompletion = {CF_CLIENT | CF_ARCHIVE, "con_nickcompletion", "1", "tab-complete nicks in console and message input"}

Definition at line 69 of file console.c.

69{CF_CLIENT | CF_ARCHIVE, "con_nickcompletion", "1", "tab-complete nicks in console and message input"};

Referenced by Con_Init(), and Nicks_CompleteCountPossible().

◆ con_nickcompletion_flags

cvar_t con_nickcompletion_flags

Initial value:

= {CF_CLIENT | CF_ARCHIVE, "con_nickcompletion_flags", "11", "Bitfield: "
                   "0: add nothing after completion. "
                   "1: add the last color after completion. "
                   "2: add a quote when starting a quote instead of the color. "
                   "4: will replace 1, will force color, even after a quote. "
                   "8: ignore non-alphanumerics. "
                   "16: ignore spaces. "}

Definition at line 70 of file console.c.

                                  {CF_CLIENT | CF_ARCHIVE, "con_nickcompletion_flags", "11", "Bitfield: "
                   "0: add nothing after completion. "
                   "1: add the last color after completion. "
                   "2: add a quote when starting a quote instead of the color. "
                   "4: will replace 1, will force color, even after a quote. "
                   "8: ignore non-alphanumerics. "
                   "16: ignore spaces. "};

Referenced by Con_Init(), Nicks_AddLastColor(), Nicks_CutMatches(), Nicks_CutMatchesAlphaNumeric(), and Nicks_strncasecmp().

◆ con_notify

cvar_t con_notify = {CF_CLIENT | CF_ARCHIVE, "con_notify","4", "how many notify lines to show"}

Definition at line 47 of file console.c.

47{CF_CLIENT | CF_ARCHIVE, "con_notify","4", "how many notify lines to show"};

Referenced by Con_DrawNotify(), and Con_Init().

◆ con_notifyalign

cvar_t con_notifyalign = {CF_CLIENT | CF_ARCHIVE, "con_notifyalign", "", "how to align notify lines: 0 = left, 0.5 = center, 1 = right, empty string = game default)"}

Definition at line 48 of file console.c.

48{CF_CLIENT | CF_ARCHIVE, "con_notifyalign", "", "how to align notify lines: 0 = left, 0.5 = center, 1 = right, empty string = game default)"};

Referenced by Con_DrawNotify(), and Con_Init().

◆ con_notifysize

cvar_t con_notifysize = {CF_CLIENT | CF_ARCHIVE, "con_notifysize","8", "notify text size in virtual 2D pixels"}

Definition at line 58 of file console.c.

58{CF_CLIENT | CF_ARCHIVE, "con_notifysize","8", "notify text size in virtual 2D pixels"};

Referenced by Con_DrawNotify(), and Con_Init().

◆ con_notifytime

cvar_t con_notifytime = {CF_CLIENT | CF_ARCHIVE, "con_notifytime","3", "how long notify lines last, in seconds"}

Definition at line 46 of file console.c.

46{CF_CLIENT | CF_ARCHIVE, "con_notifytime","3", "how long notify lines last, in seconds"};

Referenced by Con_DrawNotify(), and Con_Init().

◆ con_textsize

cvar_t con_textsize = {CF_CLIENT | CF_ARCHIVE, "con_textsize","8", "console text size in virtual 2D pixels"}

Definition at line 57 of file console.c.

57{CF_CLIENT | CF_ARCHIVE, "con_textsize","8", "console text size in virtual 2D pixels"};

Referenced by Con_CheckResize(), Con_DrawConsole(), Con_DrawConsoleLine(), Con_Init(), Con_LineHeight(), and Key_Console().

◆ con_vislines

int con_vislines

Definition at line 95 of file console.c.

Referenced by Con_DrawConsole(), and SCR_DrawConsole().

◆ condump_stripcolors

cvar_t condump_stripcolors = {CF_CLIENT | CF_SERVER| CF_ARCHIVE, "condump_stripcolors", "0", "strip color codes from console dumps"}

Definition at line 87 of file console.c.

87{CF_CLIENT | CF_SERVER| CF_ARCHIVE, "condump_stripcolors", "0", "strip color codes from console dumps"};

Referenced by Con_ConDump_f(), and Con_Init().

◆ crt_log_file

char crt_log_file[MAX_OSPATH] = ""

Definition at line 411 of file console.c.

Referenced by Log_Close(), Log_ConPrint(), and Log_Open().

◆ log_dest_buffer

char log_dest_buffer[1400]

Definition at line 408 of file console.c.

Referenced by Con_Rcon_AddChar(), Log_DestBuffer_Flush_NoLock(), Log_DestBuffer_Init(), and Log_Start().

◆ log_dest_buffer_appending

unsigned int log_dest_buffer_appending

Definition at line 410 of file console.c.

Referenced by Con_Rcon_AddChar(), and Log_DestBuffer_Flush_NoLock().

◆ log_dest_buffer_pos

size_t log_dest_buffer_pos

Definition at line 409 of file console.c.

Referenced by Con_Rcon_AddChar(), Log_DestBuffer_Flush_NoLock(), Log_DestBuffer_Init(), and Log_Start().

◆ log_dest_udp

cvar_t log_dest_udp = {CF_CLIENT | CF_SERVER, "log_dest_udp", "", "UDP address to log messages to (in QW rcon compatible format); multiple destinations can be separated by spaces; DO NOT SPECIFY DNS NAMES HERE"}

Definition at line 407 of file console.c.

407{CF_CLIENT | CF_SERVER, "log_dest_udp", "", "UDP address to log messages to (in QW rcon compatible format); multiple destinations can be separated by spaces; DO NOT SPECIFY DNS NAMES HERE"};

Referenced by Con_Init(), Con_Rcon_AddChar(), Log_DestBuffer_Flush_NoLock(), and Log_Start().

◆ log_file

cvar_t log_file = {CF_CLIENT | CF_SERVER, "log_file", "", "filename to log messages to"}

Definition at line 405 of file console.c.

405{CF_CLIENT | CF_SERVER, "log_file", "", "filename to log messages to"};

Referenced by Con_Init(), Log_ConPrint(), and Log_Open().

◆ log_file_stripcolors

cvar_t log_file_stripcolors = {CF_CLIENT | CF_SERVER, "log_file_stripcolors", "0", "strip color codes from log messages"}

Definition at line 406 of file console.c.

406{CF_CLIENT | CF_SERVER, "log_file_stripcolors", "0", "strip color codes from log messages"};

Referenced by Con_Init(), and Log_ConPrint().

◆ logfile

qfile_t* logfile = NULL

Definition at line 412 of file console.c.

Referenced by Log_Close(), Log_ConPrint(), Log_Open(), and Log_Start().

◆ logq_ind

size_t logq_ind = 0

Definition at line 415 of file console.c.

Referenced by Con_Init(), Log_ConPrint(), and Log_Start().

◆ logq_size

size_t logq_size = 0

Definition at line 416 of file console.c.

Referenced by Con_Init(), Log_ConPrint(), and Log_Start().

◆ logqueue

unsigned char* logqueue = NULL

Definition at line 414 of file console.c.

Referenced by Con_Init(), Log_ConPrint(), and Log_Start().

◆ Nicks_list

char Nicks_list[MAX_SCOREBOARD][MAX_SCOREBOARDNAME]

static

Definition at line 2486 of file console.c.

Referenced by Cmd_CompleteNicksPrint(), Con_CompleteCommandLine(), and Nicks_CompleteCountPossible().

◆ Nicks_matchpos

int Nicks_matchpos

static

Definition at line 2490 of file console.c.

Referenced by Nicks_AddLastColor(), and Nicks_CompleteCountPossible().

◆ Nicks_offset

int Nicks_offset[MAX_SCOREBOARD]

static

Definition at line 2489 of file console.c.

Referenced by Con_CompleteCommandLine(), Nicks_CompleteBuildList(), and Nicks_CompleteCountPossible().

◆ Nicks_sanlist

char Nicks_sanlist[MAX_SCOREBOARD][MAX_SCOREBOARDNAME]

static

Definition at line 2487 of file console.c.

Referenced by Nicks_CompleteBuildList(), Nicks_CompleteCountPossible(), Nicks_CutMatchesAlphaNumeric(), Nicks_CutMatchesNormal(), and Nicks_CutMatchesNoSpaces().

◆ qfont_table

char qfont_table[256]

static

The translation table between the graphical font and plain ASCII –KB

Definition at line 120 of file console.c.

                               {
    '\0', '#',  '#',  '#',  '#',  '.',  '#',  '#',
    '#',  9,    10,   '#',  ' ',  13,   '.',  '.',
    '[',  ']',  '0',  '1',  '2',  '3',  '4',  '5',
    '6',  '7',  '8',  '9',  '.',  '<',  '=',  '>',
    ' ',  '!',  '"',  '#',  '$',  '%',  '&',  '\'',
    '(',  ')',  '*',  '+',  ',',  '-',  '.',  '/',
    '0',  '1',  '2',  '3',  '4',  '5',  '6',  '7',
    '8',  '9',  ':',  ';',  '<',  '=',  '>',  '?',
    '@',  'A',  'B',  'C',  'D',  'E',  'F',  'G',
    'H',  'I',  'J',  'K',  'L',  'M',  'N',  'O',
    'P',  'Q',  'R',  'S',  'T',  'U',  'V',  'W',
    'X',  'Y',  'Z',  '[',  '\\', ']',  '^',  '_',
    '`',  'a',  'b',  'c',  'd',  'e',  'f',  'g',
    'h',  'i',  'j',  'k',  'l',  'm',  'n',  'o',
    'p',  'q',  'r',  's',  't',  'u',  'v',  'w',
    'x',  'y',  'z',  '{',  '|',  '}',  '~',  '<',
 
    '<',  '=',  '>',  '#',  '#',  '.',  '#',  '#',
    '#',  '#',  ' ',  '#',  ' ',  '>',  '.',  '.',
    '[',  ']',  '0',  '1',  '2',  '3',  '4',  '5',
    '6',  '7',  '8',  '9',  '.',  '<',  '=',  '>',
    ' ',  '!',  '"',  '#',  '$',  '%',  '&',  '\'',
    '(',  ')',  '*',  '+',  ',',  '-',  '.',  '/',
    '0',  '1',  '2',  '3',  '4',  '5',  '6',  '7',
    '8',  '9',  ':',  ';',  '<',  '=',  '>',  '?',
    '@',  'A',  'B',  'C',  'D',  'E',  'F',  'G',
    'H',  'I',  'J',  'K',  'L',  'M',  'N',  'O',
    'P',  'Q',  'R',  'S',  'T',  'U',  'V',  'W',
    'X',  'Y',  'Z',  '[',  '\\', ']',  '^',  '_',
    '`',  'a',  'b',  'c',  'd',  'e',  'f',  'g',
    'h',  'i',  'j',  'k',  'l',  'm',  'n',  'o',
    'p',  'q',  'r',  's',  't',  'u',  'v',  'w',
    'x',  'y',  'z',  '{',  '|',  '}',  '~',  '<'
};

Referenced by Con_MaskPrint(), and SanitizeString().

◆ r_textbrightness

cvar_t r_textbrightness

extern

Definition at line 55 of file gl_draw.c.

55{CF_SHARED | CF_ARCHIVE, "r_textbrightness", "0", "additional brightness for text color codes (0 keeps colors as is, 1 makes them all white)"};

Referenced by Con_MaskPrint(), DrawQ_GetTextColor(), and GL_Draw_Init().

◆ r_textcontrast

cvar_t r_textcontrast

extern

Definition at line 56 of file gl_draw.c.

56{CF_SHARED | CF_ARCHIVE, "r_textcontrast", "1", "additional contrast for text color codes (1 keeps colors as is, 0 makes them all black)"};

Referenced by Con_MaskPrint(), DrawQ_GetTextColor(), and GL_Draw_Init().

◆ rcon_address

cvar_t rcon_address = {CF_CLIENT, "rcon_address", "", "server address to send rcon commands to (when not connected to a server)"}

Definition at line 92 of file console.c.

92{CF_CLIENT, "rcon_address", "", "server address to send rcon commands to (when not connected to a server)"};

Referenced by CL_PQRcon_f(), CL_Rcon_f(), and Con_Init().

◆ rcon_password

cvar_t rcon_password = {CF_CLIENT | CF_SERVER | CF_PRIVATE, "rcon_password", "", "password to authenticate rcon commands; NOTE: changing rcon_secure clears rcon_password, so set rcon_secure always before rcon_password; may be set to a string of the form user1:pass1 user2:pass2 user3:pass3 to allow multiple user accounts - the client then has to specify ONE of these combinations"}

Definition at line 89 of file console.c.

89{CF_CLIENT | CF_SERVER | CF_PRIVATE, "rcon_password", "", "password to authenticate rcon commands; NOTE: changing rcon_secure clears rcon_password, so set rcon_secure always before rcon_password; may be set to a string of the form user1:pass1 user2:pass2 user3:pass3 to allow multiple user accounts - the client then has to specify ONE of these combinations"};

CF_PRIVATE

#define CF_PRIVATE

cvar should not be $ expanded or sent to the server under any circumstances (rcon_password,...

Definition cmd.h:59

Referenced by CL_Connect_f(), CL_PQRcon_f(), CL_Rcon_f(), Con_Init(), Con_RCon_ClearPassword_c(), NetConn_ClientParsePacket(), and RCon_Authenticate().

◆ rcon_redirect_buffer

char rcon_redirect_buffer[1400]

Definition at line 103 of file console.c.

Referenced by Con_Rcon_AddChar(), Con_Rcon_Redirect_Flush(), and Con_Rcon_Redirect_Init().

◆ rcon_redirect_bufferpos

int rcon_redirect_bufferpos = 0

Definition at line 102 of file console.c.

Referenced by Con_Rcon_AddChar(), Con_Rcon_Redirect_Flush(), and Con_Rcon_Redirect_Init().

◆ rcon_redirect_dest

lhnetaddress_t* rcon_redirect_dest = NULL

Definition at line 101 of file console.c.

Referenced by Con_Rcon_AddChar(), Con_Rcon_Redirect_Abort(), Con_Rcon_Redirect_End(), Con_Rcon_Redirect_Flush(), and Con_Rcon_Redirect_Init().

◆ rcon_redirect_proquakeprotocol

qbool rcon_redirect_proquakeprotocol = false

Definition at line 104 of file console.c.

Referenced by Con_Rcon_Redirect_Flush(), and Con_Rcon_Redirect_Init().

◆ rcon_redirect_sock

lhnetsocket_t* rcon_redirect_sock = NULL

Definition at line 100 of file console.c.

Referenced by Con_Rcon_Redirect_Abort(), Con_Rcon_Redirect_End(), Con_Rcon_Redirect_Flush(), and Con_Rcon_Redirect_Init().

◆ rcon_secure

cvar_t rcon_secure = {CF_CLIENT | CF_SERVER, "rcon_secure", "0", "force secure rcon authentication (1 = time based, 2 = challenge based); NOTE: changing rcon_secure clears rcon_password, so set rcon_secure always before rcon_password"}

Definition at line 90 of file console.c.

90{CF_CLIENT | CF_SERVER, "rcon_secure", "0", "force secure rcon authentication (1 = time based, 2 = challenge based); NOTE: changing rcon_secure clears rcon_password, so set rcon_secure always before rcon_password"};

Referenced by CL_Connect_f(), CL_PQRcon_f(), CL_Rcon_f(), Con_Init(), and NetConn_ServerParsePacket().

◆ rcon_secure_challengetimeout

cvar_t rcon_secure_challengetimeout = {CF_CLIENT, "rcon_secure_challengetimeout", "5", "challenge-based secure rcon: time out requests if no challenge came within this time interval"}

Definition at line 91 of file console.c.

91{CF_CLIENT, "rcon_secure_challengetimeout", "5", "challenge-based secure rcon: time out requests if no challenge came within this time interval"};

Referenced by CL_Rcon_f(), Con_Init(), and NetConn_ClientParsePacket().

◆ sys_colortranslation

cvar_t sys_colortranslation = {CF_CLIENT | CF_SERVER, "sys_colortranslation", "1", "terminal console color translation (supported values: -1 = print codes without translation, 0 = strip color codes, 1 = translate to ANSI codes, 2 = translate DP RGB to 24-bit and Quake colors to ANSI, 3 = translate all colors to 24-bit RGB)"}

Definition at line 66 of file console.c.

66{CF_CLIENT | CF_SERVER, "sys_colortranslation", "1", "terminal console color translation (supported values: -1 = print codes without translation, 0 = strip color codes, 1 = translate to ANSI codes, 2 = translate DP RGB to 24-bit and Quake colors to ANSI, 3 = translate all colors to 24-bit RGB)"};

Referenced by Con_Init(), and Con_MaskPrint().

◆ sys_specialcharactertranslation

cvar_t sys_specialcharactertranslation = {CF_CLIENT | CF_SERVER, "sys_specialcharactertranslation", "1", "terminal console conchars to ASCII translation (set to 0 if your conchars.tga is for an 8bit character set or if you want raw output)"}

Definition at line 65 of file console.c.

65{CF_CLIENT | CF_SERVER, "sys_specialcharactertranslation", "1", "terminal console conchars to ASCII translation (set to 0 if your conchars.tga is for an 8bit character set or if you want raw output)"};

Referenced by Con_Init(), and Con_MaskPrint().

◆ timeformat

cvar_t timeformat

extern

Definition at line 56 of file host.c.

56{CF_CLIENT | CF_SERVER | CF_ARCHIVE, "timeformat", "[%Y-%m-%d %H:%M:%S] ", "time format to use on timestamped console messages"};

Referenced by Con_MaskPrint(), Host_InitLocal(), and Sys_TimeString().

◆ timestamps

cvar_t timestamps

extern

Definition at line 55 of file host.c.

55{CF_CLIENT | CF_SERVER | CF_ARCHIVE, "timestamps", "0", "prints timestamps on console messages"};

Referenced by Con_MaskPrint(), and Host_InitLocal().

Data Structures

Macros

Functions

Variables

Logging

Macro Definition Documentation

◆ CON_LINES

◆ CON_LINES_COUNT

◆ CON_LINES_LAST

◆ NICKS_ADD_COLOR

◆ NICKS_ADD_QUOTE

◆ NICKS_ALPHANUMERICS_ONLY

◆ NICKS_FORCE_COLOR

◆ NICKS_NO_SPACES

Function Documentation

◆ Cmd_CompleteNicksPrint()

◆ Con_CenterPrint()

◆ Con_CenterPrintf()

◆ Con_CheckResize()

◆ Con_Clear_f()

◆ Con_ClearNotify()

◆ Con_CommandMode_f()

◆ Con_CompleteCommandLine()

◆ Con_ConDump_f()

◆ Con_CountLineFunc()

◆ Con_DisplayLineFunc()

◆ Con_DisplayList()

◆ Con_DPrint()

◆ Con_DPrintf()

◆ Con_DrawConsole()

◆ Con_DrawConsoleLine()

◆ Con_DrawInput()

◆ Con_DrawNotify()

◆ Con_DrawNotifyRect()

◆ Con_Init()

◆ Con_LastVisibleLine()

◆ Con_LineHeight()

◆ Con_Maps_f()

◆ Con_MaskPrint()

◆ Con_MaskPrintf()

◆ Con_MessageMode2_f()

◆ Con_MessageMode_f()

◆ Con_MsgCmdMode()

◆ Con_Print()

◆ Con_Printf()

◆ Con_PrintToHistory()

◆ Con_Quakebar()

◆ Con_Rcon_AddChar()

◆ Con_RCon_ClearPassword_c()

◆ Con_Rcon_Redirect_Abort()

◆ Con_Rcon_Redirect_End()

◆ Con_Rcon_Redirect_Flush()

◆ Con_Rcon_Redirect_Init()

◆ Con_Shutdown()

◆ Con_ToggleConsole_f()

◆ Con_WordWidthFunc()

◆ ConBuffer_AddLine()

◆ ConBuffer_BytesLeft()

◆ ConBuffer_Clear()

◆ ConBuffer_DeleteLastLine()

◆ ConBuffer_DeleteLine()

◆ ConBuffer_FindPrevLine()

◆ ConBuffer_FixTimes()

◆ ConBuffer_GetLine()

◆ ConBuffer_Init()

◆ ConBuffer_Shutdown()

◆ GetMapList()

◆ Log_Close()

◆ Log_ConPrint()

◆ Log_DestBuffer_Flush()

◆ Log_DestBuffer_Flush_NoLock()

◆ Log_DestBuffer_Init()

◆ Log_Open()

◆ Log_Printf()

◆ Log_Start()

◆ Log_Timestamp()

◆ Nicks_AddLastColor()

◆ Nicks_CompleteBuildList()

◆ Nicks_CompleteCountPossible()

◆ Nicks_CutMatches()