fteqw/engine/client/textedit.c

1086 lines
19 KiB
C
Raw Normal View 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 apply code changes.
F11 will step through.
*/
#include "quakedef.h"
#ifdef TEXTEDITOR
cvar_t alloweditor = SCVAR("alloweditor", "1"); //disallow loading editor for stepbystep debugging.
cvar_t editstripcr = SCVAR("edit_stripcr", "1"); //remove \r from eols (on load).
cvar_t editaddcr = SCVAR("edit_addcr", "1"); //make sure that each line ends with a \r (on save).
cvar_t edittabspacing = SCVAR("edit_tabsize", "4");
#undef pr_trace
progfuncs_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;
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;
}
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)
char OpenEditorFile[256];
qboolean editoractive; //(export)
qboolean editormodal; //doesn't return. (export)
qboolean editorblocking;
qboolean madechanges;
qboolean insertkeyhit=true;
qboolean useeval;
char evalstring[256];
int executionlinenum; //step by step debugger
int cursorlinenum, cursorx;
int viewportx;
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.
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;
}
int positionacross;
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;
}
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;
}
void CloseEditor(void)
{
fileblock_t *b;
key_dest = key_console;
editoractive = false;
if (!firstblock)
return;
OpenEditorFile[0] = '\0';
for (b = firstblock; b;)
{
firstblock = b;
b=b->next;
E_Free(firstblock);
}
madechanges = false;
editormodal = false;
firstblock = NULL;
executionlinenum = -1;
}
qboolean EditorSaveFile(char *s) //returns true if succesful
{
// FILE *F;
fileblock_t *b;
int len=0;
int pos=0;
char *data;
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.value)
{
data[pos]='\r';
pos++;
}
data[pos]='\n';
pos++;
}
COM_WriteFile(s, data, len);
/*
F = fopen(s, "wt");
if (!F)
return false;
for (b = firstblock; b; b = b->next)
{
fprintf(F, "%s\n", b->data);
}
fclose(F);
*/
madechanges = false;
executionlinenum = -1;
return true;
}
void EditorNewFile()
{
GETBLOCK(64, firstblock);
GETBLOCK(64, firstblock->next);
firstblock->next->prev = firstblock;
cursorblock = firstblock;
cursorlinenum = 0;
cursorx = 0;
viewportystartblock = NULL;
madechanges = true;
executionlinenum = -1;
key_dest = key_editor;
editoractive = true;
}
void EditorOpenFile(char *name)
{
int i;
char line[8192];
int len, flen, pos=0;
vfsfile_t *F;
fileblock_t *b;
CloseEditor();
strcpy(OpenEditorFile, name);
if (!(F = FS_OpenVFS(OpenEditorFile, "rb", FS_GAME)))
{
sprintf(OpenEditorFile, "src/%s", 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 = key_console;
EditorNewFile();
return;
}
}
i=1;
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.value)
{
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 (editprogfuncs)
{
if (editprogfuncs->ToggleBreak(editprogfuncs, OpenEditorFile, i, 3))
{
firstblock->flags |= FB_BREAK;
}
}
else
{
if (svprogfuncs)
{
if (svprogfuncs->ToggleBreak(svprogfuncs, OpenEditorFile, i, 3))
{
firstblock->flags |= FB_BREAK;
}
}
}
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 = -1;
key_dest = key_editor;
editoractive = true;
}
void Editor_Key(int key, int unicode)
{
int i;
if (keybindings[key][0])
if (!strcmp(keybindings[key][0], "toggleconsole"))
{
key_dest = key_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 && key != K_F11 && key != K_F5)
{
switch(key)
{
case K_ESCAPE:
if (editprogfuncs)
*editprogfuncs->pr_trace = 0;
useeval = false;
break;
case K_F3:
useeval = false;
break;
case K_DEL:
evalstring[0] = '\0';
break;
case K_BACKSPACE:
i = strlen(evalstring);
if (i < 1)
break;
evalstring[i-1] = '\0';
break;
default:
if (unicode)
{
i = strlen(evalstring);
evalstring[i] = unicode;
evalstring[i+1] = '\0';
}
break;
}
return;
}
/* 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_SHIFT:
break;
case K_ALT:
break;
case K_CTRL:
break;
case K_PGUP:
GetCursorpos();
{int a=(vid.height/8)/2;
while(a) {a--;
if (cursorblock->prev)
{
cursorblock = cursorblock->prev;
cursorlinenum--;
}
}
}
SetCursorpos();
break;
case K_PGDN:
GetCursorpos();
{int a=(vid.height/8)/2;
while(a)
{
a--;
if (cursorblock->next)
{
cursorblock = cursorblock->next;
cursorlinenum++;
}
}
}
SetCursorpos();
break;
// case K_BACK:
case K_F1:
// Editor_f();
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);
}
break;
case K_F3:
if (editprogfuncs)
useeval = true;
break;
case K_F4:
EditorSaveFile(OpenEditorFile);
break;
case K_F5:
editormodal = false;
if (editprogfuncs)
*editprogfuncs->pr_trace = false;
break;
case K_F6:
if (editprogfuncs)
PR_StackTrace(editprogfuncs);
break;
case K_F7:
EditorSaveFile(OpenEditorFile);
if (editprogfuncs)
Cbuf_AddText("compile\n", RESTRICT_LOCAL);
break;
case K_F8:
executionlinenum = cursorlinenum;
executionblock = cursorblock;
break;
case K_F9:
{
int f = 0;
if (editprogfuncs)
{
if (editprogfuncs->ToggleBreak(editprogfuncs, OpenEditorFile+4, cursorlinenum, 2))
f |= 1;
else
f |= 2;
}
#ifndef CLIENTONLY
else if (svprogfuncs)
{
if (svprogfuncs->ToggleBreak(svprogfuncs, OpenEditorFile+4, cursorlinenum, 2))
f |= 1;
else
f |= 2;
}
#endif
if (f & 1)
cursorblock->flags |= FB_BREAK;
else
cursorblock->flags &= ~FB_BREAK;
}
break;
case K_F10:
EditorSaveFile(OpenEditorFile);
Cbuf_AddText("applycompile\n", RESTRICT_LOCAL);
break;
case K_F11:
editormodal = false;
break;
// case K_STOP:
case K_ESCAPE:
if (editprogfuncs)
editprogfuncs->AbortStack(editprogfuncs);
CloseEditor();
break;
case K_HOME:
cursorx = 0;
break;
case K_END:
cursorx = cursorblock->datalength;
break;
case K_LEFTARROW:
cursorx--;
if (cursorx < 0)
cursorx = 0;
break;
case K_RIGHTARROW:
cursorx++;
if (cursorx > cursorblock->datalength)
cursorx = cursorblock->datalength;
break;
case K_MWHEELUP:
case K_UPARROW:
GetCursorpos();
if (cursorblock->prev)
{
cursorblock = cursorblock->prev;
cursorlinenum--;
}
SetCursorpos();
break;
case K_MWHEELDOWN:
case K_DOWNARROW:
GetCursorpos();
if (cursorblock->next)
{
cursorblock = cursorblock->next;
cursorlinenum++;
}
SetCursorpos();
break;
case K_BACKSPACE:
cursorx--;
if (cursorx < 0)
{
fileblock_t *b = cursorblock;
if (b == firstblock) //no line above to remove to
{
cursorx=0;
break;
}
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;
break;
}
case K_DEL: //bksp falls through.
{
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:
{
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;
}
break;
case K_INS:
insertkeyhit = insertkeyhit?false:true;
break;
default:
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;
}
}
void Draw_CursorLine(int ox, int y, fileblock_t *b)
{
int x=0;
qbyte *d = b->data;
int cx;
int a = 0, i;
int colour=COLOR_BLUE;
int ts = edittabspacing.value;
if (ts < 1)
ts = 4;
ts*=8;
if (b->flags & (FB_BREAK))
colour = COLOR_RED; //red
if (executionblock == b)
{
if (colour) //break point too
colour = COLOR_GREEN; //green
else
colour = COLOR_YELLOW; //yellow
}
if (cursorx <= strlen(d)+1 && (int)(Sys_DoubleTime()*4.0) & 1)
cx = -1;
else
cx = cursorx;
for (i = 0; i < b->datalength; i++)
{
if (*d == '\t')
{
if (a == cx)
Draw_ColouredCharacter (x+ox, y, 11|CON_WHITEMASK);
x+=ts;
x-=x%ts;
d++;
a++;
continue;
}
if (x+ox< vid.width)
{
if (a == cx)
Draw_ColouredCharacter (x+ox, y, 11|CON_WHITEMASK);
else
Draw_ColouredCharacter (x+ox, y, (int)*d | (colour<<CON_FGSHIFT));
}
d++;
x += 8;
a++;
}
if (a == cx)
Draw_ColouredCharacter (x+ox, y, 11|CON_WHITEMASK);
}
void Draw_NonCursorLine(int x, int y, fileblock_t *b)
{
int nx = 0;
qbyte *d = b->data;
int i;
int colour=COLOR_WHITE;
int ts = edittabspacing.value;
if (ts < 1)
ts = 4;
ts*=8;
if (b->flags & (FB_BREAK))
colour = COLOR_RED; //red
if (executionblock == b)
{
if (colour) //break point too
colour = COLOR_GREEN; //green
else
colour = COLOR_YELLOW; //yellow
}
for (i = 0; i < b->datalength; i++)
{
if (*d == '\t')
{
nx+=ts;
nx-=nx%ts;
d++;
continue;
}
if (x+nx < vid.width)
Draw_ColouredCharacter (x+nx, y, (int)*d | (colour<<CON_FGSHIFT));
d++;
nx += 8;
}
}
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 x;
int y;
fileblock_t *b;
if (key_dest != key_console)
key_dest = key_editor;
if ((editoractive && cls.state == ca_disconnected) || editormodal)
Draw_EditorBackground (vid.height);
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;
}
}
x=0;
for (y = 0; y < cursorx; y++)
{
if (cursorblock->data[y] == '\0')
break;
else if (cursorblock->data[y] == '\t')
{
x+=32;
x&=~31;
}
else
x+=8;
}
x=-x + vid.width/2;
if (x > 0)
x = 0;
if (madechanges)
Draw_Character (vid.width - 8, 0, '!'|CON_HIGHCHARSMASK);
if (!insertkeyhit)
Draw_Character (vid.width - 16, 0, 'O'|CON_HIGHCHARSMASK);
Draw_String(0, 0, va("%6i:%4i:%s", cursorlinenum, cursorx+1, OpenEditorFile));
if (useeval)
{
if (!editprogfuncs)
useeval = false;
else
{
char *eq;
Draw_String(0, 8, evalstring);
eq = strchr(evalstring, '=');
if (eq)
{
if (strchr(eq, ';'))
{
*strchr(eq, ';') = '\0';
eq = NULL;
}
else
*eq = '\0';
}
Draw_String(vid.width/2, 8, editprogfuncs->EvaluateDebugString(editprogfuncs, evalstring));
if (eq)
*eq = '=';
}
y = 16;
}
else
y=8;
b = firstline();
for (; b; b=b->next)
{
if (b == cursorblock)
Draw_CursorLine(x, y, b);
else
Draw_NonCursorLine(x, y, b);
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(progfuncs_t *prfncs, char *filename, int line, int nump, char **parms)
{
if (editormodal || !developer.value)
return line; //whoops
if (!qrenderer)
{
int i;
char buffer[8192];
char *r;
vfsfile_t *f;
if (line == -1)
return -1;
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 line;
}
editprogfuncs = prfncs;
if (!strncmp(OpenEditorFile, "src/", 4))
{
if (!editoractive || strcmp(OpenEditorFile+4, filename))
{
if (editoractive)
EditorSaveFile(OpenEditorFile);
EditorOpenFile(filename);
}
}
else
{
if (!editoractive || strcmp(OpenEditorFile, filename))
{
if (editoractive)
EditorSaveFile(OpenEditorFile);
EditorOpenFile(filename);
}
}
for (cursorlinenum = 1, cursorblock = firstblock; cursorlinenum < line && cursorblock->next; cursorlinenum++)
cursorblock=cursorblock->next;
executionblock = cursorblock;
if (!parms)
{
editormodal = true;
while(editormodal && editoractive && editprogfuncs)
{
// key_dest = key_editor;
scr_disabled_for_loading=false;
SCR_UpdateScreen();
Sys_SendKeyEvents();
S_ExtraUpdate();
NET_Sleep(100, false); //any os.
}
editormodal = false;
}
return line;
}
void Editor_f(void)
{
if (Cmd_Argc() != 2)
{
Con_Printf("edit <filename>\n");
return;
}
editprogfuncs = NULL;
useeval = false;
if (editoractive)
EditorSaveFile(OpenEditorFile);
EditorOpenFile(Cmd_Argv(1));
// EditorNewFile();
}
void Editor_Init(void)
{
Cmd_AddCommand("edit", Editor_f);
Cvar_Register(&alloweditor, "Text editor");
Cvar_Register(&editstripcr, "Text editor");
Cvar_Register(&editaddcr, "Text editor");
Cvar_Register(&edittabspacing, "Text editor");
}
#endif