tech
/
engine
2
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity
engine/engine/client/textedit.c

1387 lines
28 KiB
C
Raw Blame History

//DMW
/*
F1 will return to progs.src
F2 will try to open a file with the name of which is on that line. (excluding comments/tabs). Needs conditions.
F3 will give a prompt for typing in a value name to see the value.
F4 will save
F5 will run (unbreak).
F6 will list the stack.
F7 will compile.
F8 will move execution
F9 will set a break point.
F10 will step over.
F11 will step into.
*/
#include "quakedef.h"
#ifdef TEXTEDITOR
#include "pr_common.h"
#ifdef _WIN32
#define editaddcr_default "1"
#else
#define editaddcr_default "0"
#endif
//#if defined(ANDROID) || defined(SERVERONLY)
#define debugger_default "0"
//#else
//#define debugger_default "1"
//#endif
static cvar_t editstripcr = CVARD("edit_stripcr", "1", "remove \\r from eols (on load)");
static cvar_t editaddcr = CVARD("edit_addcr", editaddcr_default, "make sure that each line ends with a \\r (on save)");
static cvar_t edittabspacing = CVARD("edit_tabsize", "4", "How wide tab alignment is");
cvar_t pr_debugger = CVARAFD("pr_debugger", debugger_default, "debugger", CVAR_SAVE, "When enabled, QC errors and debug events will enable step-by-step tracing.");
extern cvar_t pr_sourcedir;
static pubprogfuncs_t *editprogfuncs;
typedef struct fileblock_s {
struct fileblock_s *next;
struct fileblock_s *prev;
int allocatedlength;
int datalength;
int flags;
char *data;
} fileblock_t;
#define FB_BREAK 1
static fileblock_t *cursorblock, *firstblock, *executionblock, *viewportystartblock;
static void *E_Malloc(int size)
{
char *mem;
mem = Z_Malloc(size);
if (!mem)
Sys_Error("Failed to allocate enough mem for editor\n");
return mem;
}
static void E_Free(void *mem)
{
Z_Free(mem);
}
#define GETBLOCK(s, ret) ret = (void *)E_Malloc(sizeof(fileblock_t) + s);ret->allocatedlength = s;ret->data = (char *)ret + sizeof(fileblock_t)
fileblock_t *GenAsm(int statement)
{
char linebuf[256];
fileblock_t *b;
int l;
if (!editprogfuncs)
return NULL;
editprogfuncs->GenerateStatementString(editprogfuncs, statement, linebuf, sizeof(linebuf));
l = strlen(linebuf);
b = E_Malloc(sizeof(fileblock_t) + l);
b->allocatedlength = l;
b->datalength = l;
b->data = (char *)b + sizeof(fileblock_t);
memcpy(b->data, linebuf, l);
return b;
}
static char OpenEditorFile[256];
qboolean editoractive; //(export)
qboolean editormodal; //doesn't return. (export)
int editorstep;
static qboolean madechanges;
static qboolean editenabled;
static qboolean insertkeyhit=true;
static qboolean useeval;
static qboolean stepasm;
static char evalstring[256];
static int executionlinenum; //step by step debugger
static int cursorlinenum, cursorx;
static int viewportx;
static int viewporty;
static int VFS_GETC(vfsfile_t *fp)
{
unsigned char c;
VFS_READ(fp, &c, 1);
return c;
}
//newsize = number of chars, EXCLUDING terminator.
static void MakeNewSize(fileblock_t *block, int newsize) //this is used to resize a block. It allocates a new one, copys the data frees the old one and links it into the right place
//it is called when the user is typing
{
fileblock_t *newblock;
newsize = (newsize + 4)&~3; //We allocate a bit extra, so we don't need to keep finding a new block for each and every character.
if (block->allocatedlength >= newsize)
return; //Ignore. This block is too large already. Don't bother resizeing, cos that's pretty much pointless.
GETBLOCK(newsize, newblock);
memcpy(newblock->data, block->data, block->datalength);
newblock->prev = block->prev;
newblock->next = block->next;
if (newblock->prev)
newblock->prev->next = newblock;
if (newblock->next)
newblock->next->prev = newblock;
newblock->datalength = block->datalength;
newblock->flags = block->flags;
E_Free(block);
if (firstblock == block)
firstblock = newblock;
if (cursorblock == block)
cursorblock = newblock;
}
static int positionacross;
static void GetCursorpos(void)
{
int a;
char *s;
int ts = edittabspacing.value;
if (ts < 1)
ts = 4;
for (a=0,positionacross=0,s=cursorblock->data;a < cursorx && *s;s++,a++)
{
if (*s == '\t')
{
positionacross += ts;
positionacross -= cursorx%ts;
}
else
positionacross++;
}
// positionacross = cursorofs;
}
static void SetCursorpos(void)
{
int a=0;
char *s;
int ts = edittabspacing.value;
if (ts < 1)
ts = 4;
for (cursorx=0,s=cursorblock->data;cursorx < positionacross && *s;s++,a++)
{
if (*s == '\t')
{
cursorx += ts;
cursorx -= cursorx%ts;
}
else
cursorx++;
}
cursorx=a;
//just in case
if (cursorx > cursorblock->datalength)
cursorx = cursorblock->datalength;
}
static void CloseEditor(void)
{
fileblock_t *b;
Key_Dest_Remove(kdm_editor);
editoractive = false;
editprogfuncs = NULL;
cursorblock = NULL;
if (!firstblock)
return;
OpenEditorFile[0] = '\0';
while(firstblock)
{
b = firstblock;
firstblock=firstblock->next;
E_Free(b);
}
madechanges = false;
editormodal = false;
editorstep = DEBUG_TRACE_OFF;
firstblock = NULL;
executionlinenum = 0;
}
static qboolean EditorSaveFile(char *s) //returns true if succesful
{
// FILE *F;
fileblock_t *b;
int len=0;
int pos=0;
char *data;
char native[MAX_OSPATH];
if (!FS_NativePath(s, FS_GAMEONLY, native, sizeof(native)))
Con_Printf("Not saving.\n");
Con_Printf("Saving to \"%s\"\n", native);
for (b = firstblock; b; b = b->next) //find total length required.
{
len += b->datalength;
len+=2; //extra for \n
}
data = Hunk_TempAlloc(len);
for (b = firstblock; b; b = b->next) //find total length required.
{
memcpy(data + pos, b->data, b->datalength);
pos += b->datalength;
if (editaddcr.ival)
{
data[pos]='\r';
pos++;
}
data[pos]='\n';
pos++;
}
COM_WriteFile(s, FS_GAMEONLY, data, len);
madechanges = false;
editenabled = true;
executionlinenum = 0;
return true;
}
static void EditorNewFile(void)
{
fileblock_t *b;
while(firstblock)
{
b = firstblock;
firstblock=firstblock->next;
E_Free(b);
}
GETBLOCK(64, firstblock);
GETBLOCK(64, firstblock->next);
firstblock->next->prev = firstblock;
cursorblock = firstblock;
cursorlinenum = 0;
cursorx = 0;
viewportystartblock = NULL;
madechanges = true;
executionlinenum = 0;
Key_Dest_Add(kdm_editor);
editoractive = true;
editenabled = true;
}
static void EditorOpenFile(const char *name, qboolean readonly)
{
int i;
char line[8192];
int len, flen, pos=0;
vfsfile_t *F;
fileblock_t *b;
char *prname;
pubprogfuncs_t *epf = editprogfuncs;
CloseEditor();
strcpy(OpenEditorFile, name);
if (!(F = FS_OpenVFS(OpenEditorFile, "rb", FS_GAME)))
{
Q_snprintfz(OpenEditorFile, sizeof(OpenEditorFile), "%s/%s", pr_sourcedir.string, name);
if (!(F = FS_OpenVFS(OpenEditorFile, "rb", FS_GAME)))
{
Con_Printf("Couldn't open file \"%s\"\nA new file will be created\n", name);
strcpy(OpenEditorFile, name);
Key_Dest_Add(kdm_console);
EditorNewFile();
return;
}
}
i=1;
prname = OpenEditorFile;
if (!strncmp(prname, "src/", 4))
prname += 4;
if (!strncmp(prname, "source/", 7))
prname += 7;
flen = VFS_GETLEN(F);
while(pos < flen)
{
len = 0;
for(;;)
{
if (pos+len >= flen || len > sizeof(line) - 16)
break;
line[len] = VFS_GETC(F);
if (line[len] == '\n')
break;
len++;
}
pos+=len;
pos++; //and a \n
if (editstripcr.ival)
{
if (line[len-1] == '\r')
len--;
}
b = firstblock;
GETBLOCK(len+1, firstblock);
firstblock->prev = b;
if (b)
b->next = firstblock;
firstblock->datalength = len;
memcpy(firstblock->data, line, len);
if (epf)
{
if (epf->ToggleBreak(epf, prname, i, 3))
{
firstblock->flags |= FB_BREAK;
}
}
#ifndef CLIENTONLY
else
{
if (svprogfuncs)
{
if (svprogfuncs->ToggleBreak(svprogfuncs, prname, i, 3))
{
firstblock->flags |= FB_BREAK;
}
}
}
#endif
i++;
}
if (firstblock == NULL)
{
GETBLOCK(10, firstblock);
}
else
for (; firstblock->prev; firstblock=firstblock->prev);
VFS_CLOSE(F);
cursorblock = firstblock;
cursorx = 0;
viewportystartblock = NULL;
madechanges = false;
executionlinenum = 0;
editenabled = !readonly;
Key_Dest_Add(kdm_editor);
editoractive = true;
editprogfuncs = epf;
}
extern qboolean keydown[K_MAX];
void Editor_Key(int key, int unicode)
{
int i;
fileblock_t *nb;
if (keybindings[key][0])
if (!strcmp(keybindings[key][0], "toggleconsole"))
{
Key_Dest_Add(kdm_console);
return;
}
/* if (CmdAfterSave)
{
switch (key)
{
case 'Y':
case 'y':
if (!EditorSaveFile(OpenEditorFile))
{
Con_Printf("Couldn't save file \"%s\"\n", OpenEditorFile);
key_dest = key_console;
}
else if (!CmdAfterSaveCalled)
{
CmdAfterSaveCalled=true;
(*CmdAfterSave)();
CmdAfterSaveCalled=false;
}
CmdAfterSave = NULL;
break;
case 'N':
case 'n':
(*CmdAfterSave)();
CmdAfterSave = NULL;
break;
case 'C':
case 'c':
CmdAfterSave = NULL;
break;
}
return;
}
*/
if (key == K_SHIFT)
return;
if (useeval)
{
switch(key)
{
case K_ESCAPE:
if (editprogfuncs)
editprogfuncs->debug_trace = DEBUG_TRACE_OFF;
useeval = false;
return;
case K_F3:
useeval = false;
return;
case K_DEL:
evalstring[0] = '\0';
return;
case K_BACKSPACE:
i = strlen(evalstring);
if (i < 1)
return;
evalstring[i-1] = '\0';
return;
default:
if (unicode)
{
i = strlen(evalstring);
evalstring[i] = unicode;
evalstring[i+1] = '\0';
}
return;
case K_F5:
case K_F9:
case K_F11:
case K_MWHEELUP:
case K_UPARROW:
case K_PGUP:
case K_MWHEELDOWN:
case K_DOWNARROW:
case K_PGDN:
case K_LEFTARROW:
case K_RIGHTARROW:
break;
}
}
/* if (ctrl_down && (key == 'c' || key == K_INS))
key = K_F9;
if ((ctrl_down && key == 'v') || (shift_down && key == K_INS))
key = K_F10;
*/
switch (key)
{
case K_LSHIFT:
case K_RSHIFT:
break;
case K_LALT:
case K_RALT:
break;
case K_LCTRL:
case K_RCTRL:
break;
case K_MWHEELUP:
case K_UPARROW:
case K_PGUP:
if (!cursorblock)
break;
GetCursorpos();
{
int a;
if (key == K_PGUP)
a =(vid.height/8)/2;
else if (key == K_MWHEELUP)
a = 5;
else
a = 1;
while(a)
{
a--;
if (cursorblock->prev)
{
cursorblock = cursorblock->prev;
cursorlinenum--;
}
else if (cursorlinenum>1)
{
cursorlinenum--;
nb = GenAsm(cursorlinenum);
nb->next = cursorblock;
cursorblock->prev = nb;
firstblock = cursorblock = nb;
}
}
}
SetCursorpos();
break;
case K_MWHEELDOWN:
case K_DOWNARROW:
case K_PGDN:
GetCursorpos();
{
int a;
if (key == K_PGDN)
a =(vid.height/8)/2;
else if (key == K_MWHEELDOWN)
a = 5;
else
a = 1;
while(a)
{
a--;
if (cursorblock->next)
{
cursorblock = cursorblock->next;
cursorlinenum++;
}
else
{
nb = GenAsm(cursorlinenum+1);
if (nb)
{
cursorlinenum++;
nb->prev = cursorblock;
cursorblock->next = nb;
cursorblock = nb;
}
}
}
}
SetCursorpos();
break;
// case K_BACK:
case K_F1:
Con_Printf(
"Editor help:\n"
"F1: Show help\n"
"F2: Open file named on cursor line\n"
"F3: Toggle expression evaluator\n"
"F4: Save file\n"
"F5: Stop tracing (resume)\n"
"F6: Print stack trace\n"
"F7: Save file and recompile\n"
"F8: Change current point of execution\n"
"F9: Set breakpoint\n"
"F10: Save file, recompile, reload vm\n"
"F11: Single step\n"
"F12: \n"
"Escape: Abort call, close editor\n"
);
Cbuf_AddText("toggleconsole\n", RESTRICT_LOCAL);
break;
// case K_FORWARD:
case K_F2:
{
char file[1024];
char *s;
Q_strncpyz(file, cursorblock->data, sizeof(file));
s = file;
while (*s)
{
if ((*s == '/' && s[1] == '/') || (*s == '\t'))
{
*s = '\0';
break;
}
s++;
}
if (*file)
EditorOpenFile(file, false);
}
break;
case K_F3:
if (editprogfuncs)
useeval = true;
break;
case K_F4:
EditorSaveFile(OpenEditorFile);
break;
case K_F5: /*stop debugging*/
editormodal = false;
editorstep = DEBUG_TRACE_OFF;
break;
case K_F6:
if (editprogfuncs)
PR_StackTrace(editprogfuncs, 2);
break;
case K_F7: /*save+recompile*/
EditorSaveFile(OpenEditorFile);
if (!editprogfuncs)
Cbuf_AddText("compile; toggleconsole\n", RESTRICT_LOCAL);
break;
case K_F8: /*move execution point to here - I hope you move to the same function!*/
executionlinenum = cursorlinenum;
executionblock = cursorblock;
break;
case K_F9: /*set breakpoint*/
{
int f = 0;
char *fname = OpenEditorFile;
if (!strncmp(fname, "src/", 4))
fname += 4;
if (!strncmp(fname, "source/", 7))
fname += 7;
if (editprogfuncs)
{
if (editprogfuncs->ToggleBreak(editprogfuncs, fname, cursorlinenum, 2))
f |= 1;
else
f |= 2;
}
#ifndef CLIENTONLY
else if (svprogfuncs)
{
if (svprogfuncs->ToggleBreak(svprogfuncs, fname, cursorlinenum, 2))
f |= 1;
else
f |= 2;
}
#endif
if (f & 1)
cursorblock->flags |= FB_BREAK;
else
cursorblock->flags &= ~FB_BREAK;
}
break;
case K_F10:
editormodal = false;
editorstep = DEBUG_TRACE_OVER;
break;
case K_F11: //single step
editormodal = false;
editorstep = DEBUG_TRACE_INTO;
break;
case K_F12: //save+apply changes, supposedly
EditorSaveFile(OpenEditorFile);
Cbuf_AddText("applycompile\n", RESTRICT_LOCAL);
break;
// case K_STOP:
case K_ESCAPE:
if (editprogfuncs && editormodal)
{
editprogfuncs->AbortStack(editprogfuncs);
CloseEditor();
executionlinenum = 0;
stepasm = true;
}
else
CloseEditor();
editormodal = false;
editorstep = DEBUG_TRACE_ABORT;
break;
case K_HOME:
cursorx = 0;
break;
case K_END:
cursorx = cursorblock->datalength;
break;
case K_LEFTARROW:
cursorx--;
if (keydown[K_LCTRL] || keydown[K_RCTRL])
{
//skip additional whitespace
while(cursorx > 0 && (cursorblock->data[cursorx-1] == ' ' || cursorblock->data[cursorx-1] <= '\t'))
cursorx--;
//skip over the word, to the start of it
while(cursorx > 0 && ((cursorblock->data[cursorx-1] >= 'a' && cursorblock->data[cursorx-1] <= 'z') ||
(cursorblock->data[cursorx-1] >= 'A' && cursorblock->data[cursorx-1] <= 'Z') ||
(cursorblock->data[cursorx-1] >= '0' && cursorblock->data[cursorx-1] <= '9')))
cursorx--;
}
if (cursorx < 0)
cursorx = 0;
break;
case K_RIGHTARROW:
if (keydown[K_LCTRL] || keydown[K_RCTRL])
{
while(cursorx+1 < cursorblock->datalength && ((cursorblock->data[cursorx] >= 'a' && cursorblock->data[cursorx] <= 'z') ||
(cursorblock->data[cursorx] >= 'A' && cursorblock->data[cursorx] <= 'Z') ||
(cursorblock->data[cursorx] >= '0' && cursorblock->data[cursorx] <= '9')))
cursorx++;
cursorx++;
while(cursorx+1 < cursorblock->datalength && (cursorblock->data[cursorx] == ' ' || cursorblock->data[cursorx] <= '\t'))
cursorx++;
}
else
{
cursorx++;
if (cursorx > cursorblock->datalength)
cursorx = cursorblock->datalength;
}
break;
case K_BACKSPACE:
cursorx--;
if (cursorx < 0)
{
fileblock_t *b = cursorblock;
if (b == firstblock) //no line above to remove to
{
cursorx=0;
break;
}
if (editenabled)
{
cursorlinenum-=1;
madechanges = true;
cursorblock = b->prev;
MakeNewSize(cursorblock, b->datalength + cursorblock->datalength+5);
cursorx = cursorblock->datalength;
memcpy(cursorblock->data + cursorblock->datalength, b->data, b->datalength);
cursorblock->datalength += b->datalength;
cursorblock->next = b->next;
if (b->next)
b->next->prev = cursorblock;
// cursorblock->prev->next = cursorblock->next;
// cursorblock->next->prev = cursorblock->prev;
E_Free(b);
// cursorblock = b;
}
else
{
cursorblock = cursorblock->prev;
cursorx = cursorblock->datalength;
}
break;
}
case K_DEL: //bksp falls through.
if (editenabled)
{
int a;
fileblock_t *b;
cursorlinenum=-1;
madechanges = true;
//FIXME: does this work right?
if (!cursorblock->datalength && cursorblock->next && cursorblock->prev) //blank line
{
b = cursorblock;
if (b->next)
b->next->prev = b->prev;
if (b->prev)
b->prev->next = b->next;
if (cursorblock->next)
cursorblock = cursorblock->next;
else
cursorblock = cursorblock->prev;
E_Free(b);
}
else
{
for (a = cursorx; a < cursorblock->datalength;a++)
cursorblock->data[a] = cursorblock->data[a+1];
cursorblock->datalength--;
}
if (cursorx > cursorblock->datalength)
cursorx = cursorblock->datalength;
}
break;
case K_ENTER:
case K_KP_ENTER:
if (editenabled)
{
fileblock_t *b = cursorblock;
cursorlinenum=-1;
madechanges = true;
GETBLOCK(b->datalength - cursorx, cursorblock);
cursorblock->next = b->next;
cursorblock->prev = b;
b->next = cursorblock;
if (cursorblock->next)
cursorblock->next->prev = cursorblock;
if (cursorblock->prev)
cursorblock->prev->next = cursorblock;
cursorblock->datalength = b->datalength - cursorx;
memcpy(cursorblock->data, b->data+cursorx, cursorblock->datalength);
b->datalength = cursorx;
cursorx = 0;
}
else if (cursorblock->next)
{
cursorblock = cursorblock->next;
cursorlinenum++;
cursorx = 0;
}
break;
case K_INS:
insertkeyhit = insertkeyhit?false:true;
break;
default:
if (!editenabled)
break;
if (unicode < ' ' && unicode != '\t') //we deem these as unprintable
break;
if (insertkeyhit) //insert a char
{
char *s;
madechanges = true;
MakeNewSize(cursorblock, cursorblock->datalength+5); //allocate a bit extra, so we don't need to keep resizing it and shifting loads a data about
s = cursorblock->data + cursorblock->datalength;
while (s >= cursorblock->data + cursorx)
{
s[1] = s[0];
s--;
}
cursorx++;
cursorblock->datalength++;
*(s+1) = unicode;
}
else //over write a char
{
MakeNewSize(cursorblock, cursorblock->datalength+5); //not really needed
cursorblock->data[cursorx] = unicode;
cursorx++;
if (cursorx > cursorblock->datalength)
cursorblock->datalength = cursorx;
}
break;
}
}
static void Draw_Line(int vy, fileblock_t *b, int cursorx)
{
int nx = 0;
int y;
char *tooltip = NULL, *t;
int nnx;
qbyte *d = b->data;
qbyte *c;
int i;
int smx = (mousecursor_x * vid.pixelwidth) / vid.width, smy = (mousecursor_y * vid.pixelheight) / vid.height;
unsigned int colour;
int ts = edittabspacing.value;
char linebuf[128];
if (cursorx >= 0)
c = d + cursorx;
else
c = NULL;
Font_BeginString(font_default, nx, vy, &nx, &y);
if (ts < 1)
ts = 4;
ts*=8;
//figure out the colour
if (b->flags & (FB_BREAK))
{
if (executionblock == b)
colour = COLOR_MAGENTA<<CON_FGSHIFT;
else
colour = COLOR_RED<<CON_FGSHIFT;
}
else
{
if (executionblock == b)
colour = COLOR_YELLOW<<CON_FGSHIFT; //yellow
else
colour = COLOR_WHITE<<CON_FGSHIFT;
}
//if this line currently holds the mouse cursor, figure out the word that is highighted, and evaluate that word for debugging.
//self.ammo_shells is just 'self' if you highlight 'self', but if you highlight ammo_shells, it'll include the self, for easy debugging.
//use the f3 evaulator for more explicit debugging.
if (editprogfuncs && smy >= y && smy < y + Font_CharHeight())
{
int e, s;
nx = -viewportx;
for (i = 0; i < b->datalength; i++)
{
if (d[i] == '\t')
{
nnx=nx+ts;
nnx-=(nnx - -viewportx)%ts;
}
else
nnx = Font_CharEndCoord(font_default, nx, (int)d[i] | (colour));
if (smx >= nx && smx <= nnx)
{
for(s = i; s > 0; )
{
if ((d[s-1] >= 'a' && d[s-1] <= 'z') ||
(d[s-1] >= 'A' && d[s-1] <= 'Z') ||
(d[s-1] >= '0' && d[s-1] <= '9') ||
d[s-1] == '.' || d[s-1] == '_')
s--;
else
break;
}
for (e = i; e < b->datalength; )
{
if ((d[e] >= 'a' && d[e] <= 'z') ||
(d[e] >= 'A' && d[e] <= 'Z') ||
(d[e] >= '0' && d[e] <= '9') ||
/*d[e] == '.' ||*/ d[e] == '_')
e++;
else
break;
}
if (e >= s+sizeof(linebuf))
e = s+sizeof(linebuf) - 1;
memcpy(linebuf, d+s, e - s);
linebuf[e-s] = 0;
if (*linebuf)
tooltip = editprogfuncs->EvaluateDebugString(editprogfuncs, linebuf);
break;
}
nx = nnx;
}
}
nx = -viewportx;
for (i = 0; i < b->datalength; i++)
{
if (*d == '\t')
{
if (d == c)
{
int e = Font_DrawChar(nx, y, (int)0xe00b | (CON_WHITEMASK|CON_BLINKTEXT));
if (e >= vid.pixelwidth)
viewportx += e - vid.pixelwidth;
if (nx < 0)
{
viewportx -= -nx;
if (viewportx < 0)
viewportx = 0;
}
}
nx+=ts;
nx-=(nx - -viewportx)%ts;
d++;
continue;
}
if (nx <= (int)vid.pixelwidth || cursorx>=0)
nnx = Font_DrawChar(nx, y, (int)*d | (colour));
else nnx = vid.pixelwidth;
if (d == c)
{
int e = Font_DrawChar(nx, y, (int)0xe00b | (CON_WHITEMASK|CON_BLINKTEXT));
if (e >= vid.pixelwidth)
viewportx += e - vid.pixelwidth;
if (nx < 0)
{
viewportx -= -nx;
if (viewportx < 0)
viewportx = 0;
}
}
nx = nnx;
d++;
}
/*we didn't do the cursor! stick it at the end*/
if (c && c >= d)
{
int e = Font_DrawChar(nx, y, (int)0xe00b | (CON_WHITEMASK|CON_BLINKTEXT));
if (e >= vid.pixelwidth)
viewportx += e - vid.pixelwidth;
if (nx < 0)
{
viewportx -= -nx;
if (viewportx < 0)
viewportx = 0;
}
}
if (tooltip)
{
nx = ((mousecursor_x+16) * vid.pixelwidth) / vid.width;
while(*tooltip)
{
for (t = tooltip, smx = nx; *tooltip; tooltip++)
{
if (*tooltip == '\n')
break;
smx = Font_CharEndCoord(font_default, smx, *tooltip);
}
y = Font_CharHeight();
Font_EndString(font_default);
R2D_ImageColours(0, 0, 0, 1);
R2D_FillBlock(((nx)*vid.width) / vid.pixelwidth, ((smy)*vid.height) / vid.pixelheight, ((smx - nx)*vid.width) / vid.pixelwidth, (y*vid.height) / vid.pixelheight);
R2D_ImageColours(1, 1, 1, 1);
Font_BeginString(font_default, nx, vy, &y, &y);
for(smx = nx; t < tooltip; t++)
{
smx = Font_DrawChar(smx, smy, (COLOR_CYAN<<CON_FGSHIFT) | *t);
}
if (*tooltip == '\n')
tooltip++;
smy += Font_CharHeight();
}
}
Font_EndString(font_default);
}
static fileblock_t *firstline(void)
{
int lines;
fileblock_t *b;
lines = (vid.height/8)/2-1;
b = cursorblock;
if (!b)
return NULL;
while (1)
{
if (!b->prev)
return b;
b = b->prev;
lines--;
if (lines <= 0)
return b;
}
return NULL;
}
void Editor_Draw(void)
{
int y;
int c;
fileblock_t *b;
if ((editoractive && cls.state == ca_disconnected) || editormodal)
R2D_EditorBackground();
if (cursorlinenum < 0) //look for the cursor line num
{
cursorlinenum = 0;
for (b = firstblock; b; b=b->next)
{
cursorlinenum++;
if (b == cursorblock)
break;
}
}
if (!viewportystartblock) //look for the cursor line num
{
y = 0;
for (viewportystartblock = firstblock; viewportystartblock; viewportystartblock=viewportystartblock->prev)
{
y++;
if (y == viewporty)
break;
}
}
if (madechanges)
Draw_FunString (vid.width - 8, 0, "!");
if (!insertkeyhit)
Draw_FunString (vid.width - 16, 0, "O");
if (!editenabled)
Draw_FunString (vid.width - 24, 0, "R");
Draw_FunString(0, 0, va("%6i:%4i:%s", cursorlinenum, cursorx+1, OpenEditorFile));
if (useeval)
{
if (!editprogfuncs)
useeval = false;
else
{
char *eq, *term;
Draw_FunString(0, 8, evalstring);
eq = strchr(evalstring, '=');
if (eq)
{
term = strchr(eq, ';');
if (!term)
term = strchr(eq, '\n');
if (!term)
term = strchr(eq, '\r');
if (term)
{
*term = '\0';
eq = NULL;
}
else
*eq = '\0';
}
Draw_FunString(vid.width/2, 8, editprogfuncs->EvaluateDebugString(editprogfuncs, evalstring));
if (eq)
*eq = '=';
}
y = 16;
}
else
y=8;
b = firstline();
for (; b; b=b->next)
{
c = -1;
if (b == cursorblock)
c = cursorx;
Draw_Line(y, b, c);
y+=8;
if (y > vid.height)
break;
}
/* if (CmdAfterSave)
{
if (madechanges)
{
M_DrawTextBox (0, 0, 36, 5);
M_PrintWhite (16, 12, OpenEditorFile);
M_PrintWhite (16, 28, "Do you want to save the open file?");
M_PrintWhite (16, 36, "[Y]es/[N]o/[C]ancel");
}
else
{
if (!CmdAfterSaveCalled)
{
CmdAfterSaveCalled = true;
(*CmdAfterSave) ();
CmdAfterSaveCalled = false;
}
CmdAfterSave = NULL;
}
}
*/
}
int QCLibEditor(pubprogfuncs_t *prfncs, const char *filename, int *line, int *statement, int nump, char **parms)
{
const char *f1, *f2;
if (!pr_debugger.ival)
{
Con_Printf("Set %s to trace\n", pr_debugger.name);
return DEBUG_TRACE_OFF; //get lost
}
//we can cope with no line info by displaying asm
if (editormodal || !statement)
return DEBUG_TRACE_OFF; //whoops
if (qrenderer == QR_NONE)
{
int i;
char buffer[8192];
char *r;
vfsfile_t *f;
f = FS_OpenVFS(filename, "rb", FS_GAME);
if (!f)
Con_Printf("%s - %i\n", filename, *line);
else
{
for (i = 0; i < *line; i++)
{
VFS_GETS(f, buffer, sizeof(buffer));
}
if ((r = strchr(buffer, '\r')))
{ r[0] = '\n';r[1]='\0';}
Con_Printf("%s", buffer);
VFS_CLOSE(f);
}
//PF_break(NULL);
return DEBUG_TRACE_OUT;
}
editprogfuncs = prfncs;
f1 = OpenEditorFile;
f2 = filename;
if (!strncmp(f1, "src/", 4))
f1 += 4;
if (!strncmp(f2, "src/", 4))
f2 += 4;
if (!strncmp(f1, "source/", 7))
f1 += 7;
if (!strncmp(f2, "source/", 7))
f2 += 7;
stepasm = !line;
if (stepasm)
{
fileblock_t *nb, *lb;
int i;
EditorNewFile();
E_Free(firstblock->next);
E_Free(firstblock);
cursorlinenum = *statement;
firstblock = GenAsm(cursorlinenum);
cursorblock = firstblock;
for (i = cursorlinenum; i > 0 && i > cursorlinenum - 20; )
{
i--;
firstblock->prev = GenAsm(i);
firstblock->prev->next = firstblock;
firstblock = firstblock->prev;
}
lb = cursorblock;
for (i = cursorlinenum; i < cursorlinenum+20; )
{
i++;
nb = GenAsm(i);
lb->next = nb;
nb->prev = lb;
lb = nb;
}
}
else
{
if (!editoractive || strcmp(f1, f2))
{
if (editoractive && madechanges)
EditorSaveFile(OpenEditorFile);
EditorOpenFile(filename, true);
}
for (cursorlinenum = 1, cursorblock = firstblock; cursorlinenum < *line && cursorblock->next; cursorlinenum++)
cursorblock=cursorblock->next;
}
executionlinenum = cursorlinenum;
executionblock = cursorblock;
if (!parms)
{
double oldrealtime = realtime;
editormodal = true;
editorstep = DEBUG_TRACE_OFF;
while(editormodal && editoractive && editprogfuncs)
{
realtime = Sys_DoubleTime();
// key_dest = key_editor;
scr_disabled_for_loading=false;
SCR_UpdateScreen();
Sys_SendKeyEvents();
IN_Commands ();
S_ExtraUpdate();
NET_Sleep(20/1000.0, false); //any os.
}
realtime = oldrealtime;
editormodal = false;
}
if (stepasm)
{
if (line)
*line = 0;
*statement = executionlinenum;
}
else if (line)
*line = executionlinenum;
return editorstep;
}
void Editor_ProgsKilled(pubprogfuncs_t *dead)
{
if (editprogfuncs == dead)
{
editprogfuncs = NULL;
editormodal = false;
editorstep = DEBUG_TRACE_OFF;
}
}
static void Editor_f(void)
{
int argc = Cmd_Argc();
if (argc != 2 && argc != 3)
{
Con_Printf("edit <filename> [line]\n");
return;
}
editprogfuncs = NULL;
useeval = false;
if (editoractive && madechanges)
EditorSaveFile(OpenEditorFile);
EditorOpenFile(Cmd_Argv(1), false);
// EditorNewFile();
if (argc == 3)
{
int line = atoi(Cmd_Argv(2));
for (cursorlinenum = 1, cursorblock = firstblock; cursorlinenum < line && cursorblock->next; cursorlinenum++)
cursorblock=cursorblock->next;
}
}
void Editor_Init(void)
{
Cmd_AddCommand("edit", Editor_f);
Cvar_Register(&editstripcr, "Text editor");
Cvar_Register(&editaddcr, "Text editor");
Cvar_Register(&edittabspacing, "Text editor");
Cvar_Register(&pr_debugger, "Text editor");
}
#endif
Reference in New Issue View Git Blame Copy Permalink