void Console::verifyRegistration(const std::string &proc, const std::string &name, bool isNull) {
if (name.empty()) {
D6_THROW(ConsoleException, CON_Format(CON_Lang("{0} : cannot register empty name")) << proc);
}
if (findCommand(name) != nullptr || findVar(name) != nullptr || findAlias(name) != nullptr) {
D6_THROW(ConsoleException,
CON_Format(CON_Lang("{0} : name \"{1}\" is already registered")) << proc << name);
}
if (isNull) {
D6_THROW(ConsoleException,
CON_Format(CON_Lang("{0} : attempt to register \"{1}\" with null pointer")) << proc << name);
}
}
void Console::registerAlias(const std::string &name, const std::string &cmd) {
AliasRecord *a = findAlias(name);
if (a == nullptr) {
verifyRegistration(CON_Lang("Alias registration"), name, false);
AliasRecord newAlias(name, cmd);
// Zaradi novy alias tak, aby byly setridene podle abecedy
size_t position = 0;
for (const AliasRecord &alias : aliases) {
if (alias.getName().compare(name) > 0) {
break;
}
++position;
}
aliases.insert(aliases.begin() + position, newAlias);
} else {
a->setCommand(cmd);
}
if (hasFlag(RegInfoFlag)) {
print(CON_Format(CON_Lang("Alias registration: \"{0}\" as \"{1}\" has been successful\n")) << name << cmd);
}
}
void Console::VarRecord::printInfo(Console &console) const {
const char *flagstr = "ra";
int i, f = 1;
for (i = 0; i < 2; i++, f <<= 1) {
if (hasFlag(f)) {
console.print(std::string(1, flagstr[i]));
} else {
console.print("-");
}
}
console.print(
CON_Format(CON_Lang(" {0} \"{1}\" with value {2}\n")) << var->getTypeName() << name << getValue());
}
void Console::varCmd(VarRecord &var, Arguments &args) {
Size c = args.length();
if (c > 2) {
print(CON_Lang("CONSTR0041|Variables : Usage variable_name [new_value]\n"));
return;
}
if (c == 1) {
var.printInfo(*this);
} else {
if (!(var.hasFlag(Variable::ReadOnlyFlag))) {
var.setValue(args.get(1));
} else {
print(CON_Format(CON_Lang("Variable \"{0}\" is read-only\n")) << var.getName());
}
}
}
void Console::registerVariable(const std::string &name, Uint32 flags, Variable::Pointer &&ptr) {
verifyRegistration(name, CON_Lang("Variable registration"), ptr == nullptr);
// Sort lexicographically
Size position = 0;
for (const VarRecord &var : vars) {
if (var.getName().compare(name) > 0) {
break;
}
++position;
}
vars.emplace(vars.begin() + position, name, flags, std::forward<Variable::Pointer>(ptr));
if (hasFlag(RegInfoFlag)) {
print(CON_Format(CON_Lang("Variable registration: \"{0}\" has been successful\n")) << name);
}
}
void Console::registerCommand(const std::string &name, Command command) {
verifyRegistration(CON_Lang("Command registration"), name, !command);
CommandRecord newCommand(name, command);
// Zaradi novy prikaz tak, aby byly setridene podle abecedy
size_t position = 0;
for (const CommandRecord &cmd : cmds) {
if (cmd.getName().compare(name) > 0) {
break;
}
++position;
}
cmds.insert(cmds.begin() + position, newCommand);
if (hasFlag(RegInfoFlag)) {
print(CON_Format(CON_Lang("Command registration: \"{0}\" has been successful\n")) << name);
}
}
Console::Console(Uint32 flags) {
visible = false;
insert = false;
curpos = 0;
inputscroll = 0;
this->flags = flags;
histcnt = 0;
histscroll = 0;
width = CON_DEF_WIDTH;
show = CON_DEF_SHOWLAST;
text.resize(CON_TEXT_SIZE);
clear();
printLine("==========================");
printLine(CON_Lang("Console -- author O.Danek"));
printLine(CON_Format(CON_Lang("Version {0}")) << CON_VERSION);
printLine("==========================");
}
void Console::completeCmd()
{
if (input.empty())
{
return;
}
std::vector<std::string> fittingCommands;
for (const CommandRecord& command : cmds)
{
if (startsWith(command.getName(), input))
{
fittingCommands.push_back(command.getName());
}
}
for (const VarRecord& var : vars)
{
if (startsWith(var.getName(), input))
{
fittingCommands.push_back(var.getName());
}
}
for (const AliasRecord& alias : aliases)
{
if (startsWith(alias.getName(), input))
{
fittingCommands.push_back(alias.getName());
}
}
if (fittingCommands.size() == 1)
{
input = fittingCommands.front();
input.append(" ");
curpos = input.length();
}
else if (fittingCommands.size() > 1)
{
print(CON_Format(CON_Lang("Searching: \"{0}\"\n")) << input);
for (const std::string& command : fittingCommands)
{
print(CON_Format("\t{0}\n") << command);
}
std::string largestFit = fittingCommands.front();
for (const std::string& command : fittingCommands)
{
size_t prefix = input.length();
while (prefix < largestFit.length() && prefix < command.length() && largestFit[prefix] == command[prefix])
{
++prefix;
}
if (prefix < largestFit.length())
{
largestFit = largestFit.substr(0, prefix);
}
}
input = largestFit;
curpos = input.length();
}
}
/*
==================================================
Reakce na stisk klavesy
==================================================
*/
void Console::keyEvent(SDL_Keycode keyCode, Uint16 keyModifiers)
{
int len = (int)input.length();
switch (keyCode)
{
case CON_C_SCROLL_UP:
scroll++;
break;
case CON_C_SCROLL_DOWN:
if (scroll > 0)
scroll--;
break;
case CON_C_HIST_UP:
if (histscroll < CON_REM_HIST && histcnt - histscroll > 0)
{
histscroll++;
input = hist[(histcnt - histscroll) % CON_REM_HIST];
curpos = (int)input.length();
}
break;
case CON_C_HIST_DOWN:
if (histscroll > 0)
{
histscroll--;
if (!histscroll)
{
input.clear();
}
else
{
input = hist[(histcnt - histscroll) % CON_REM_HIST];
}
curpos = (int)input.length();
}
break;
case CON_C_INSERT:
insert = !insert;
break;
case CON_C_BACK:
if (curpos > 0)
{
input.erase(input.begin() + curpos - 1);
curpos--;
}
break;
case CON_C_DELETE:
if (curpos < len)
{
input.erase(input.begin() + curpos);
}
break;
case CON_C_ENTER:
if (len)
{
hist[histcnt % CON_REM_HIST] = input;
histcnt++;
histscroll = 0;
print(CON_Format("]{0}\n") << input);
exec(input);
input.clear();
curpos = 0;
}
break;
case CON_C_TAB:
completeCmd();
break;
case CON_C_LEFT:
if (curpos > 0)
{
curpos--;
}
break;
case CON_C_RIGHT:
if (curpos < len)
{
curpos++;
}
break;
case CON_C_HOME:
curpos = 0;
break;
case CON_C_END:
curpos = len;
break;
}
setInputScroll();
}
