Cube  Diff

vector<cline> conlines;

const int ndraw = 5;
const int WORDWRAP = 80;
int conskip = 0;

bool saycommandon = false;
string commandbuf;
static OFMutableString *commandbuf;

void
setconskip(int n)
{
	conskip += n;
	if (conskip < 0)
		conskip = 0;

	}

	conoutf(@"unknown key \"%@\"", key);
}
COMMANDN(bind, bindkey, ARG_2STR)

void
saycommand(char *init) // turns input to the command line on or off
saycommand(const char *init) // turns input to the command line on or off
{
	saycommandon = (init != NULL);
	if (saycommandon)
		SDL_StartTextInput();
	else
		SDL_StopTextInput();

	if (!editmode)
		Cube.sharedInstance.repeatsKeys = saycommandon;

	if (!init)
		init = "";
	strcpy_s(commandbuf, init);

	commandbuf = [[OFMutableString alloc] initWithUTF8String:init];
}
COMMAND(saycommand, ARG_VARI)

void
mapmsg(OFString *s)
{
	@autoreleasepool {
		strn0cpy(hdr.maptitle, s.UTF8String, 128);
	}
}
COMMAND(mapmsg, ARG_1STR)

void
pasteconsole()
{
	@autoreleasepool {
	char *cb = SDL_GetClipboardText();
		[commandbuf appendString:@(SDL_GetClipboardText())];
	strcat_s(commandbuf, cb);
	}
}

static OFMutableArray<OFString *> *vhistory;
int histpos = 0;
static int histpos = 0;

void
history(int n)
{
	static bool rec = false;

	if (!rec && n >= 0 && n < vhistory.count) {

		if (isdown) {
			switch (code) {
			case SDLK_RETURN:
				break;

			case SDLK_BACKSPACE:
			case SDLK_LEFT: {
				for (int i = 0; commandbuf[i]; i++)
					if (!commandbuf[i + 1])
						commandbuf[i] = 0;
				[commandbuf
				    deleteCharactersInRange:
				        OFMakeRange(commandbuf.length - 1, 1)];

				resetcomplete();
				break;
			}

			case SDLK_UP:
				if (histpos) {
				if (histpos)
					@autoreleasepool {
						strcpy_s(commandbuf,
						    vhistory[--histpos]
					commandbuf =
					    [vhistory[--histpos] mutableCopy];
						        .UTF8String);
					}
				}
				break;

			case SDLK_DOWN:
				if (histpos < vhistory.count) {
				if (histpos < vhistory.count)
					@autoreleasepool {
						strcpy_s(commandbuf,
						    vhistory[histpos++]
					commandbuf =
					    [vhistory[histpos++] mutableCopy];
						        .UTF8String);
					}
				}
				break;

			case SDLK_TAB:
				complete(commandbuf);
				break;

			case SDLK_v:
				if (SDL_GetModState() &
				    (KMOD_LCTRL | KMOD_RCTRL)) {
					pasteconsole();
					return;
				};
				}

			default:
				resetcomplete();
				if (cooked) {
				if (cooked)
					char add[] = {(char)cooked, 0};
					strcat_s(commandbuf, add);
					[commandbuf appendFormat:@"%c", cooked];
				}
			}
		} else {
			if (code == SDLK_RETURN) {
				if (commandbuf[0]) {
				if (commandbuf.length > 0) {
					@autoreleasepool {
						OFString *cmdbuf =
						    @(commandbuf);

						if (vhistory == nil)
							vhistory =
							    [[OFMutableArray
							        alloc] init];

						if (vhistory.count == 0 ||
						    ![vhistory.lastObject
						        isEqual:cmdbuf]) {
						        isEqual:commandbuf]) {
							// cap this?
							[vhistory
							    addObject:cmdbuf];
							    addObject:
							        [commandbuf
							            copy]];
						}
					}
					histpos = vhistory.count;
					if ([commandbuf hasPrefix:@"/"]) {
						std::unique_ptr<char> copy(
						    strdup(
					if (commandbuf[0] == '/')
						execute(commandbuf, true);
					else
						toserver(commandbuf);
						        commandbuf.UTF8String));
						execute(copy.get(), true);
					} else
						toserver(commandbuf.UTF8String);
				}
				saycommand(NULL);
			} else if (code == SDLK_ESCAPE) {
				saycommand(NULL);
			}
		}
	} else if (!menukey(code, isdown)) {

				execute(temp, isdown);
				return;
			}
		}
	}
}

char *
OFString *
getcurcommand()
{
	return saycommandon ? commandbuf : NULL;
}

void
writebinds(OFStream *stream)
{
	for (KeyMapping *mapping in keyMappings)
		if (mapping.action.length > 0)
			[stream writeFormat:@"bind \"%@\" [%@]\n", mapping.name,
			        mapping.action];
}