--- a/sources/interface.cpp Wed Jul 20 13:29:03 2016 +0300
+++ b/sources/interface.cpp Wed Jul 20 15:03:37 2016 +0300
@@ -41,30 +41,30 @@
// -------------------------------------------------------------------------------------------------
//
-chtype Interface::color_pair (Color fg, Color bg)
+chtype Interface::getColorPair(Color fg, Color bg)
{
if (fg == DEFAULT && bg == DEFAULT)
return 0;
else
- return COLOR_PAIR (1 + (int (fg) * NUM_COLORS) + int (bg));
+ return COLOR_PAIR(1 + (int(fg) * NUM_COLORS) + int(bg));
}
// -------------------------------------------------------------------------------------------------
//
-const String& Interface::current_input()
+const String& Interface::getCurrentInput()
{
return m_inputHistory[m_inputCursor];
}
// -------------------------------------------------------------------------------------------------
//
-// Makes current_input() the lastmost input (so that we won't modify history)
+// Makes current_input() the lastmost input(so that we won't modify history)
//
-void Interface::detach_input()
+void Interface::detachInput()
{
if (m_inputCursor > 0)
{
- m_inputHistory[0] = current_input();
+ m_inputHistory[0] = getCurrentInput();
m_inputCursor = 0;
}
}
@@ -72,15 +72,15 @@
// -------------------------------------------------------------------------------------------------
// A version of current_input() that allows changing the contents of it.
//
-String& Interface::mutable_current_input()
+String& Interface::getEditableInput()
{
- detach_input();
+ detachInput();
return m_inputHistory[m_inputCursor];
}
// -------------------------------------------------------------------------------------------------
//
-void Interface::move_input_cursor (int delta)
+void Interface::moveInputCursor(int delta)
{
// No input history when inputting addresses or passwords
if (m_inputState != INPUTSTATE_NORMAL)
@@ -90,18 +90,18 @@
}
int oldcursor = m_inputCursor;
- m_inputCursor = clamp (m_inputCursor + delta, 0, m_inputHistory.size() - 1);
+ m_inputCursor = clamp(m_inputCursor + delta, 0, m_inputHistory.size() - 1);
if (m_inputCursor != oldcursor)
{
- m_cursorPosition = current_input().length();
+ m_cursorPosition = getCurrentInput().length();
m_needInputRender = true;
}
}
// -------------------------------------------------------------------------------------------------
//
-String Interface::prompt_string()
+String Interface::getPromptString()
{
String prompt;
@@ -118,21 +118,21 @@
// -------------------------------------------------------------------------------------------------
//
-void Interface::set_input_state (InputState newstate)
+void Interface::setInputState(InputState newstate)
{
- // Clear the input row (unless going to or from confirm state)
+ // Clear the input row(unless going to or from confirm state)
if (newstate != INPUTSTATE_CONFIRM_DISCONNECTION
and m_inputState != INPUTSTATE_CONFIRM_DISCONNECTION)
{
m_inputCursor = 0;
- mutable_current_input().clear();
+ getEditableInput().clear();
}
switch (newstate)
{
case INPUTSTATE_ADDRESS:
if (m_remoteAddress.host != 0)
- mutable_current_input() = m_remoteAddress.to_string (IPAddress::WITH_PORT);
+ getEditableInput() = m_remoteAddress.to_string(IPAddress::WITH_PORT);
break;
default:
@@ -146,73 +146,73 @@
// -------------------------------------------------------------------------------------------------
//
Interface::Interface() :
- m_inputCursor (0),
- m_cursorPosition (0),
- m_inputPanning (0),
- m_needRefresh (false),
- m_needStatusBarRender (false),
- m_needInputRender (false),
- m_needOutputRender (false),
- m_needNicklistRender (false),
- m_outputScroll (0),
- m_inputState (INPUTSTATE_NORMAL),
- m_disconnectCallback (nullptr)
+ m_inputCursor(0),
+ m_cursorPosition(0),
+ m_inputPanning(0),
+ m_needRefresh(false),
+ m_needStatusBarRender(false),
+ m_needInputRender(false),
+ m_needOutputRender(false),
+ m_needNicklistRender(false),
+ m_outputScroll(0),
+ m_inputState(INPUTSTATE_NORMAL),
+ m_disconnectCallback(nullptr)
{
::initscr();
::raw();
- ::keypad (stdscr, true);
+ ::keypad(stdscr, true);
::noecho();
::refresh();
- ::timeout (0);
+ ::timeout(0);
m_inputHistory.clear();
m_inputHistory << "";
m_outputLines.clear();
m_outputLines << ColoredLine();
- m_session.set_interface (this);
- reset_title();
+ m_session.set_interface(this);
+ resetTitle();
if (::has_colors())
{
::start_color();
- bool hasDefaultColors = (::use_default_colors() == OK);
+ bool hasDefaultColors =(::use_default_colors() == OK);
int defaultFg = hasDefaultColors ? -1 : COLOR_WHITE;
int defaultBg = hasDefaultColors ? -1 : COLOR_BLACK;
// Initialize color pairs
- for (int i = 0; i < NUM_COLORS; ++i)
- for (int j = 0; j < NUM_COLORS; ++j)
+ for (int i : range<int>(NUM_COLORS))
+ for (int j : range<int>(NUM_COLORS))
{
int pairnum = 1 + (i * NUM_COLORS + j);
- int fg = (i == DEFAULT) ? defaultFg : i;
- int bg = (j == DEFAULT) ? defaultBg : j;
+ int fg =(i == DEFAULT) ? defaultFg : i;
+ int bg =(j == DEFAULT) ? defaultBg : j;
if (fg != -1 || bg != -1)
{
- if (::init_pair (pairnum, fg, bg) == ERR)
- print_warning ("Unable to initialize color pair %d (%d, %d)\n", pairnum, fg, bg);
+ if (::init_pair(pairnum, fg, bg) == ERR)
+ printWarning("Unable to initialize color pair %d(%d, %d)\n", pairnum, fg, bg);
}
}
}
- render_full();
+ renderFull();
refresh();
m_needRefresh = false;
}
// -------------------------------------------------------------------------------------------------
//
-void Interface::render_titlebar()
+void Interface::renderTitlebar()
{
if (m_title.length() <= COLS)
{
- chtype pair = color_pair (WHITE, BLUE);
- int startx = (COLS - m_title.length()) / 2;
+ chtype pair = getColorPair(WHITE, BLUE);
+ int startx =(COLS - m_title.length()) / 2;
int endx = startx + m_title.length();
- attron (pair);
- mvprintw (0, startx, "%s", m_title.chars());
- mvhline (0, 0, ' ', startx);
- mvhline (0, endx, ' ', COLS - endx);
- attroff (pair);
+ attron(pair);
+ mvprintw(0, startx, "%s", m_title.chars());
+ mvhline(0, 0, ' ', startx);
+ mvhline(0, endx, ' ', COLS - endx);
+ attroff(pair);
}
m_needRefresh = true;
@@ -220,20 +220,20 @@
// -------------------------------------------------------------------------------------------------
//
-void Interface::set_title (const String& title)
+void Interface::setTitle(const String& title)
{
m_title = title;
- render_titlebar();
+ renderTitlebar();
}
// -------------------------------------------------------------------------------------------------
//
-void Interface::safe_disconnect (std::function<void(bool)> afterwards)
+void Interface::safeDisconnect(std::function<void(bool)> afterwards)
{
if (m_session.is_active())
{
m_disconnectCallback = afterwards;
- set_input_state (INPUTSTATE_CONFIRM_DISCONNECTION);
+ setInputState(INPUTSTATE_CONFIRM_DISCONNECTION);
}
else
afterwards(false);
@@ -241,30 +241,28 @@
// -------------------------------------------------------------------------------------------------
//
-int Interface::nicklist_width()
+int Interface::nicklistWidth()
{
// Allocate at least 12 characters, at most 24 characters, for the nicklist. If we cannot
- // afford that (o_O) then we probably shouldn't draw the nicklist at all I think.
+ // afford that(o_O) then we probably shouldn't draw the nicklist at all I think.
int nicklistWidth = COLS / 4;
if (nicklistWidth < 12)
return 0;
- return min (nicklistWidth, 24);
+ return min(nicklistWidth, 24);
}
// -------------------------------------------------------------------------------------------------
// Renders the given colored line onto the screen. Will wrap if allowWrap is true. Returns the
// 'y' value for the next line.
//
-int Interface::render_colorline (int y, int x0, int width, const ColoredLine& line, bool allowWrap)
+int Interface::renderColorline(int y, int x0, int width, const ColoredLine& line, bool allowWrap)
{
int x = x0;
- for (int i = 0; i < line.data().size(); ++i)
+ for (int byte : line.data())
{
- int byte = line.data()[i];
-
if (x == x0 + width)
{
if (not allowWrap)
@@ -274,24 +272,24 @@
++y;
}
- if (byte < 256 && isprint (byte))
+ if (byte < 256 && isprint(byte))
{
- mvaddch (y, x, char (byte));
+ mvaddch(y, x, char(byte));
++x;
}
- else if (byte >= RLINE_ON_COLOR and byte < (RLINE_ON_COLOR + 16))
+ else if (byte >= RLINE_ON_COLOR and byte <(RLINE_ON_COLOR + 16))
{
- auto attrfunction = (byte < RLINE_OFF_COLOR ? &attron : &attroff);
- (*attrfunction) (color_pair (Color ((byte - RLINE_ON_COLOR) & 7), DEFAULT));
+ auto attrfunction =(byte < RLINE_OFF_COLOR ? &attron : &attroff);
+ (*attrfunction)(getColorPair(Color((byte - RLINE_ON_COLOR) & 7), DEFAULT));
}
else switch (byte)
{
case RLINE_ON_BOLD:
- attron (A_BOLD);
+ attron(A_BOLD);
break;
case RLINE_OFF_BOLD:
- attroff (A_BOLD);
+ attroff(A_BOLD);
break;
}
}
@@ -301,15 +299,15 @@
// -------------------------------------------------------------------------------------------------
//
-void Interface::render_output()
+void Interface::renderOutput()
{
if (m_outputLines.size() == 1)
return;
- m_outputScroll = clamp (m_outputScroll, 0, m_outputLines.size() - 1);
+ m_outputScroll = clamp(m_outputScroll, 0, m_outputLines.size() - 1);
int height = LINES - 3;
- int width = COLS - nicklist_width();
+ int width = COLS - nicklistWidth();
int printOffset = 0;
int end = m_outputLines.size() - 1 - m_outputScroll;
int start = end;
@@ -320,7 +318,7 @@
// Where to start?
while (start > 0)
{
- int rows = m_outputLines[start - 1].rows (width);
+ int rows = m_outputLines[start - 1].rows(width);
if (usedHeight + rows > height)
{
@@ -333,12 +331,12 @@
usedHeight += rows;
}
- // See if there's any more rows to use (end may be too small)
+ // See if there's any more rows to use(end may be too small)
if (not tightFit)
{
while (end < m_outputLines.size())
{
- int rows = m_outputLines[end].rows (width);
+ int rows = m_outputLines[end].rows(width);
if (usedHeight + rows > height)
{
@@ -359,17 +357,17 @@
if (start < 0 or start == end or printOffset >= height)
return;
- assert (start <= end and start - end <= height);
+ assert(start <= end and start - end <= height);
// Clear the display
- for (int i = y; i < y + height; ++i)
- mvhline (i, 0, ' ', width);
+ for (int i : range(height))
+ mvhline(y + i, 0, ' ', width);
// Print the lines
y += printOffset;
- for (int i = start; i < end; ++i)
- y = render_colorline (y, 0, width, m_outputLines[i], true);
+ for (int i : range(start, end))
+ y = renderColorline(y, 0, width, m_outputLines[i], true);
m_needOutputRender = false;
m_needRefresh = true;
@@ -377,22 +375,22 @@
// -------------------------------------------------------------------------------------------------
//
-void Interface::render_nicklist()
+void Interface::renderNicklist()
{
- int width = nicklist_width();
+ int width = nicklistWidth();
int height = LINES- 3;
int y = 1;
int x = COLS - width;
- if (width == 0)
+ if (width > 0)
return;
- for (int i = 0; i < height; ++i)
+ for (int i : range(height))
{
- mvhline (y, x, ' ', width);
+ mvhline(y, x, ' ', width);
if (i < m_playerNames.size())
- render_colorline (y, x, width, m_playerNames[i], false);
+ renderColorline(y, x, width, m_playerNames[i], false);
y++;
}
@@ -403,36 +401,36 @@
// -------------------------------------------------------------------------------------------------
//
-void Interface::render_input()
+void Interface::renderInput()
{
- chtype promptColor = color_pair (WHITE, BLUE);
+ chtype promptColor = getColorPair(WHITE, BLUE);
// If we're asking the user if they want to disconnect, we don't render any input strings,
// just the confirmation message.
if (m_inputState == INPUTSTATE_CONFIRM_DISCONNECTION)
{
- attron (promptColor);
- mvhline (LINES - 2, 0, ' ', COLS);
- mvprintw (LINES - 2, 0, "Are you sure you want to disconnect? y/n");
- attroff (promptColor);
+ attron(promptColor);
+ mvhline(LINES - 2, 0, ' ', COLS);
+ mvprintw(LINES - 2, 0, "Are you sure you want to disconnect? y/n");
+ attroff(promptColor);
m_needRefresh = true;
return;
}
- String prompt = prompt_string();
+ String prompt = getPromptString();
int displayLength = COLS - prompt.length() - 2;
- String displayString = current_input();
+ String displayString = getCurrentInput();
int y = LINES - 2;
// If we're inputting a password, replace it with asterisks
if (m_inputState == INPUTSTATE_PASSWORD)
{
- for (int i = 0; i < displayString.length(); ++i)
- displayString[i] = '*';
+ for (char &ch : displayString)
+ ch = '*';
}
// Ensure the cursor is within bounds
- m_cursorPosition = clamp (m_cursorPosition, 0, displayString.length());
+ m_cursorPosition = clamp(m_cursorPosition, 0, displayString.length());
// Ensure that the cursor is always in view, adjust panning if this is not the case
if (m_cursorPosition > m_inputPanning + displayLength)
@@ -442,19 +440,19 @@
// What part of the string to draw?
int start = m_inputPanning;
- int end = min<int> (displayString.length(), start + displayLength);
- assert (m_cursorPosition >= start and m_cursorPosition <= end);
+ int end = min<int>(displayString.length(), start + displayLength);
+ assert(m_cursorPosition >= start and m_cursorPosition <= end);
// Render the input string
- mvhline (LINES - 2, 0, ' ', COLS);
- mvprintw (y, prompt.length() + 1, "%s", displayString.mid (start, end).chars());
+ mvhline(LINES - 2, 0, ' ', COLS);
+ mvprintw(y, prompt.length() + 1, "%s", displayString.mid(start, end).chars());
// Render the prompt
- attron (promptColor);
- mvprintw (y, 0, "%s", prompt.chars());
- attroff (promptColor);
+ attron(promptColor);
+ mvprintw(y, 0, "%s", prompt.chars());
+ attroff(promptColor);
- // Store in memory where the cursor is now (so that we can re-draw it to position the terminal
+ // Store in memory where the cursor is now(so that we can re-draw it to position the terminal
// cursor).
m_cursorCharacter.ch = m_cursorPosition != 0 ? displayString[m_cursorPosition - 1] : '\0';
m_cursorCharacter.x = prompt.length() + (m_cursorPosition - m_inputPanning);
@@ -464,21 +462,21 @@
// -------------------------------------------------------------------------------------------------
//
-void Interface::render_statusbar()
+void Interface::renderStatusBar()
{
- chtype color = color_pair (WHITE, BLUE);
+ chtype color = getColorPair(WHITE, BLUE);
int y = LINES - 1;
- attron (color);
- mvhline (y, 0, ' ', COLS);
- mvprintw (y, 0, "%s", m_statusBarText.chars());
- attroff (color);
+ attron(color);
+ mvhline(y, 0, ' ', COLS);
+ mvprintw(y, 0, "%s", m_statusBarText.chars());
+ attroff(color);
m_needRefresh = true;
m_needStatusBarRender = false;
}
// -------------------------------------------------------------------------------------------------
//
-void Interface::update_statusbar()
+void Interface::updateStatusBar()
{
String text;
@@ -490,7 +488,7 @@
case RCON_CONNECTING:
case RCON_AUTHENTICATING:
- text = "Connecting to " + m_session.address().to_string (IPAddress::WITH_PORT) + "...";
+ text = "Connecting to " + m_session.address().to_string(IPAddress::WITH_PORT) + "...";
break;
case RCON_CONNECTED:
@@ -503,12 +501,12 @@
}
else
{
- adminText.sprintf ("%d other admin%s", m_session.num_admins(),
+ adminText.sprintf("%d other admin%s", m_session.num_admins(),
m_session.num_admins() != 1 ? "s" : "");
}
- text.sprintf ("%s | %s | %s",
- m_session.address().to_string (IPAddress::WITH_PORT).chars(),
+ text.sprintf("%s | %s | %s",
+ m_session.address().to_string(IPAddress::WITH_PORT).chars(),
m_session.level().chars(),
adminText.chars());
}
@@ -519,7 +517,7 @@
text += " | ";
text += "Ctrl+N to connect, Ctrl+Q to ";
- text += (m_session.state() == RCON_DISCONNECTED) ? "quit" : "disconnect";
+ text +=(m_session.state() == RCON_DISCONNECTED) ? "quit" : "disconnect";
if (text != m_statusBarText)
{
@@ -530,19 +528,19 @@
// -------------------------------------------------------------------------------------------------
//
-void Interface::render_full()
+void Interface::renderFull()
{
- update_statusbar();
- render_titlebar();
- render_output();
- render_statusbar();
- render_input();
- render_nicklist();
+ updateStatusBar();
+ renderTitlebar();
+ renderOutput();
+ renderStatusBar();
+ renderInput();
+ renderNicklist();
}
// -------------------------------------------------------------------------------------------------
//
-void Interface::position_cursor()
+void Interface::positionCursor()
{
// This is only relevant if the input string is being drawn
if (m_inputState == INPUTSTATE_CONFIRM_DISCONNECTION)
@@ -551,24 +549,24 @@
int y = LINES - 2;
if (m_cursorCharacter.ch != '\0')
- mvprintw (y, m_cursorCharacter.x, "%c", m_cursorCharacter.ch);
+ mvprintw(y, m_cursorCharacter.x, "%c", m_cursorCharacter.ch);
else
- mvprintw (y, prompt_string().length(), " ");
+ mvprintw(y, getPromptString().length(), " ");
}
// -------------------------------------------------------------------------------------------------
//
-int Interface::find_previous_word()
+int Interface::findPreviousWord()
{
- const String& input = current_input();
+ const String& input = getCurrentInput();
int pos = m_cursorPosition;
// Move past whitespace
- while (pos > 0 and isspace (input[pos - 1]))
+ while (pos > 0 and isspace(input[pos - 1]))
pos--;
// Move past the word
- while (pos > 0 and not isspace (input[pos - 1]))
+ while (pos > 0 and not isspace(input[pos - 1]))
pos--;
return pos;
@@ -576,17 +574,17 @@
// -------------------------------------------------------------------------------------------------
//
-int Interface::find_next_word()
+int Interface::findNextWord()
{
- const String& input = current_input();
+ const String& input = getCurrentInput();
int pos = m_cursorPosition;
// Move past current whitespace
- while (pos < input.length() and isspace (input[pos]))
+ while (pos < input.length() and isspace(input[pos]))
pos++;
// Move past the word
- while (input[pos] != '\0' and not isspace (input[pos]))
+ while (input[pos] != '\0' and not isspace(input[pos]))
pos++;
return pos;
@@ -594,7 +592,7 @@
// -------------------------------------------------------------------------------------------------
//
-void Interface::yank (int a, int b)
+void Interface::yank(int a, int b)
{
if (a >= b)
return;
@@ -602,15 +600,15 @@
if (m_cursorPosition > a and m_cursorPosition <= b)
m_cursorPosition = a;
- String& input = mutable_current_input();
- m_pasteBuffer = input.mid (a, b);
- input.remove (a, b - a);
+ String& input = getEditableInput();
+ m_pasteBuffer = input.mid(a, b);
+ input.remove(a, b - a);
m_needInputRender = true;
}
// -------------------------------------------------------------------------------------------------
//
-void Interface::handle_input()
+void Interface::handleInput()
{
int ch = ::getch();
@@ -620,7 +618,7 @@
if (ch == KEY_RESIZE)
{
::clear();
- render_full();
+ renderFull();
return;
}
@@ -632,14 +630,14 @@
m_disconnectCallback(true);
}
else if (ch == 'n' or ch == 'N')
- set_input_state (INPUTSTATE_NORMAL);
+ setInputState(INPUTSTATE_NORMAL);
return;
}
if (ch >= 0x20 and ch <= 0x7E)
{
- mutable_current_input().insert (m_cursorPosition++, char (ch));
+ getEditableInput().insert(m_cursorPosition++, char(ch));
m_needInputRender = true;
}
else switch (ch)
@@ -651,11 +649,11 @@
break;
case INPUTSTATE_NORMAL:
- safe_disconnect ([&](bool hadsession)
+ safeDisconnect([&](bool hadsession)
{
if (hadsession)
{
- set_input_state (INPUTSTATE_NORMAL);
+ setInputState(INPUTSTATE_NORMAL);
}
else
{
@@ -666,11 +664,11 @@
break;
case INPUTSTATE_PASSWORD:
- set_input_state (INPUTSTATE_ADDRESS);
+ setInputState(INPUTSTATE_ADDRESS);
break;
case INPUTSTATE_ADDRESS:
- set_input_state (INPUTSTATE_NORMAL);
+ setInputState(INPUTSTATE_NORMAL);
}
break;
@@ -685,7 +683,7 @@
case KEY_RIGHT:
case 'F' - 'A' + 1: // readline ^F
- if (m_cursorPosition < current_input().length())
+ if (m_cursorPosition < getCurrentInput().length())
{
m_cursorPosition++;
m_needInputRender = true;
@@ -694,7 +692,7 @@
case KEY_DOWN:
case KEY_UP:
- move_input_cursor (ch == KEY_DOWN ? -1 : 1);
+ moveInputCursor(ch == KEY_DOWN ? -1 : 1);
break;
case KEY_HOME:
@@ -708,9 +706,9 @@
case KEY_END:
case 'E' - 'A' + 1: // readline ^E
- if (m_cursorPosition != current_input().length())
+ if (m_cursorPosition != getCurrentInput().length())
{
- m_cursorPosition = current_input().length();
+ m_cursorPosition = getCurrentInput().length();
m_needInputRender = true;
}
break;
@@ -719,50 +717,50 @@
case '\b':
if (m_cursorPosition > 0)
{
- mutable_current_input().remove_at (--m_cursorPosition);
+ getEditableInput().remove_at(--m_cursorPosition);
m_needInputRender = true;
}
break;
case KEY_DC:
case 'D' - 'A' + 1: // readline ^D
- if (m_cursorPosition < current_input().length())
+ if (m_cursorPosition < getCurrentInput().length())
{
- mutable_current_input().remove_at (m_cursorPosition);
+ getEditableInput().remove_at(m_cursorPosition);
m_needInputRender = true;
}
break;
case KEY_PPAGE:
- m_outputScroll += min (PAGE_SIZE, LINES / 2);
+ m_outputScroll += min(PAGE_SIZE, LINES / 2);
m_needOutputRender = true;
break;
case KEY_NPAGE:
- m_outputScroll -= min (PAGE_SIZE, LINES / 2);
+ m_outputScroll -= min(PAGE_SIZE, LINES / 2);
m_needOutputRender = true;
break;
case 'U' - 'A' + 1: // readline ^U - delete from start to cursor
if (m_cursorPosition > 0)
{
- yank (0, m_cursorPosition);
+ yank(0, m_cursorPosition);
m_cursorPosition = 0;
}
break;
case 'K' - 'A' + 1: // readline ^K - delete from cursor to end
- yank (m_cursorPosition, mutable_current_input().length());
+ yank(m_cursorPosition, getEditableInput().length());
break;
case 'W' - 'A' + 1: // readline ^W - delete from previous word bounary to current
- yank (find_previous_word(), m_cursorPosition);
+ yank(findPreviousWord(), m_cursorPosition);
break;
case 'Y' - 'A' + 1: // readline ^Y - paste previously deleted text
if (not m_pasteBuffer.is_empty())
{
- mutable_current_input().insert (m_cursorPosition, m_pasteBuffer);
+ getEditableInput().insert(m_cursorPosition, m_pasteBuffer);
m_cursorPosition += m_pasteBuffer.length();
m_needInputRender = true;
}
@@ -770,14 +768,14 @@
case '\t':
{
- int space = current_input().find (" ");
+ int space = getCurrentInput().find(" ");
if (m_inputState == INPUTSTATE_NORMAL
and m_cursorPosition > 0
- and (space == -1 or space >= m_cursorPosition))
+ and(space == -1 or space >= m_cursorPosition))
{
- String start = current_input().mid (0, m_cursorPosition);
- m_session.request_tab_complete (start);
+ String start = getCurrentInput().mid(0, m_cursorPosition);
+ m_session.request_tab_complete(start);
}
}
break;
@@ -793,39 +791,39 @@
case INPUTSTATE_ADDRESS:
try
{
- m_remoteAddress = IPAddress::from_string (current_input());
+ m_remoteAddress = IPAddress::from_string(getCurrentInput());
}
catch (std::exception& e)
{
- print ("%s\n", e.what());
+ print("%s\n", e.what());
return;
}
if (m_remoteAddress.port == 0)
m_remoteAddress.port = 10666;
- set_input_state (INPUTSTATE_PASSWORD);
+ setInputState(INPUTSTATE_PASSWORD);
break;
case INPUTSTATE_PASSWORD:
- if (m_inputState == INPUTSTATE_PASSWORD and not current_input().is_empty())
+ if (m_inputState == INPUTSTATE_PASSWORD and not getCurrentInput().is_empty())
{
m_session.disconnect();
- m_session.set_password (current_input());
- m_session.connect (m_remoteAddress);
- set_input_state (INPUTSTATE_NORMAL);
+ m_session.set_password(getCurrentInput());
+ m_session.connect(m_remoteAddress);
+ setInputState(INPUTSTATE_NORMAL);
}
break;
case INPUTSTATE_NORMAL:
- if (current_input()[0] == '/')
+ if (getCurrentInput()[0] == '/')
{
- handle_command(current_input());
- flush_input();
+ handleCommand(getCurrentInput());
+ flushInput();
}
- else if (m_session.send_command (current_input()))
+ else if (m_session.send_command(getCurrentInput()))
{
- flush_input();
+ flushInput();
}
break;
}
@@ -833,7 +831,7 @@
case 'N' - 'A' + 1: // ^N
if (m_inputState == INPUTSTATE_NORMAL)
- safe_disconnect ([&](bool){set_input_state (INPUTSTATE_ADDRESS);});
+ safeDisconnect([&](bool){setInputState(INPUTSTATE_ADDRESS);});
break;
case '\x1b': // Escape
@@ -847,26 +845,26 @@
case 'b':
case 'B':
// readline alt-b - move one word to the left
- m_cursorPosition = find_previous_word();
+ m_cursorPosition = findPreviousWord();
m_needInputRender = true;
break;
case 'f':
case 'F':
// readline alt-f - move one word to the right
- m_cursorPosition = find_next_word();
+ m_cursorPosition = findNextWord();
m_needInputRender = true;
break;
case 'd':
case 'D':
// readline alt-d - delete from here till next word boundary
- yank (m_cursorPosition, find_next_word());
+ yank(m_cursorPosition, findNextWord());
break;
case KEY_BACKSPACE: // alt+backspace, remove previous word
case '\b':
- yank (find_previous_word(), m_cursorPosition);
+ yank(findPreviousWord(), m_cursorPosition);
break;
}
}
@@ -874,9 +872,9 @@
{
// No alt-key, handle pure escape
if (m_inputState == INPUTSTATE_PASSWORD)
- set_input_state (INPUTSTATE_ADDRESS);
+ setInputState(INPUTSTATE_ADDRESS);
else if (m_inputState == INPUTSTATE_ADDRESS)
- set_input_state (INPUTSTATE_NORMAL);
+ setInputState(INPUTSTATE_NORMAL);
}
break;
}
@@ -888,14 +886,14 @@
//
void Interface::render()
{
- if (m_needStatusBarRender) render_statusbar();
- if (m_needInputRender) render_input();
- if (m_needOutputRender) render_output();
- if (m_needNicklistRender) render_nicklist();
+ if (m_needStatusBarRender) renderStatusBar();
+ if (m_needInputRender) renderInput();
+ if (m_needOutputRender) renderOutput();
+ if (m_needNicklistRender) renderNicklist();
if (m_needRefresh)
{
- position_cursor();
+ positionCursor();
refresh();
m_needRefresh = false;
}
@@ -903,68 +901,66 @@
// -------------------------------------------------------------------------------------------------
//
-void Interface::vprint (const char* fmtstr, va_list args)
+void Interface::vprint(const char* fmtstr, va_list args)
{
String message;
- message.vsprintf (fmtstr, args);
- print_to_console (message);
+ message.vsprintf(fmtstr, args);
+ printToConsole(message);
}
// -------------------------------------------------------------------------------------------------
//
-void __cdecl Interface::print_text (const char* fmtstr, ...)
+void __cdecl Interface::printText(const char* fmtstr, ...)
{
va_list args;
- va_start (args, fmtstr);
- vprint (fmtstr, args);
- va_end (args);
+ va_start(args, fmtstr);
+ vprint(fmtstr, args);
+ va_end(args);
}
// -------------------------------------------------------------------------------------------------
//
-void __cdecl Interface::print (const char* fmtstr, ...)
+void __cdecl Interface::print(const char* fmtstr, ...)
{
va_list args;
- va_start (args, fmtstr);
- print_to_console (TEXTCOLOR_BrightBlue);
- vprint (fmtstr, args);
- va_end (args);
+ va_start(args, fmtstr);
+ printToConsole(TEXTCOLOR_BrightBlue);
+ vprint(fmtstr, args);
+ va_end(args);
}
// -------------------------------------------------------------------------------------------------
//
-void __cdecl Interface::print_warning (const char* fmtstr, ...)
+void __cdecl Interface::printWarning(const char* fmtstr, ...)
{
va_list args;
- va_start (args, fmtstr);
- print_to_console (TEXTCOLOR_BrightYellow "-!- ");
- vprint (fmtstr, args);
- va_end (args);
+ va_start(args, fmtstr);
+ printToConsole(TEXTCOLOR_BrightYellow "-!- ");
+ vprint(fmtstr, args);
+ va_end(args);
}
// -------------------------------------------------------------------------------------------------
//
-void __cdecl Interface::print_error (const char* fmtstr, ...)
+void __cdecl Interface::printError(const char* fmtstr, ...)
{
va_list args;
- va_start (args, fmtstr);
- print_to_console (TEXTCOLOR_BrightRed "!!! ");
- vprint (fmtstr, args);
- va_end (args);
+ va_start(args, fmtstr);
+ printToConsole(TEXTCOLOR_BrightRed "!!! ");
+ vprint(fmtstr, args);
+ va_end(args);
}
// -------------------------------------------------------------------------------------------------
//
-void Interface::print_to_console (String message)
+void Interface::printToConsole(String message)
{
// Zandronum sometimes sends color codes as "\\c" and sometimes as "\x1C".
// Let's correct that on our end and hope this won't cause conflicts.
- message.replace ("\\c", "\x1C");
+ message.replace("\\c", "\x1C");
- for (int i = 0; i < message.length(); ++i)
+ for (char ch : message)
{
- char ch = message[i];
-
if (ch == '\n')
{
m_outputLines.last().finalize();
@@ -975,19 +971,19 @@
if (m_outputLines.last().length() == 0)
{
time_t now;
- time (&now);
+ time(&now);
char timestamp[32];
- strftime (timestamp, sizeof timestamp, "[%H:%M:%S] ", localtime (&now));
+ strftime(timestamp, sizeof timestamp, "[%H:%M:%S] ", localtime(&now));
- for (char* cp = timestamp; *cp != '\0'; ++cp)
- m_outputLines.last().add_char (*cp);
+ for (char ch : String(timestamp))
+ m_outputLines.last().add_char(ch);
}
// Remove some lines if there's too many of them. 20,000 should be enough, I hope.
while (m_outputLines.size() > 20000)
m_outputLines.remove_at(0);
- m_outputLines.last().add_char (ch);
+ m_outputLines.last().add_char(ch);
}
m_needOutputRender = true;
@@ -995,15 +991,15 @@
// -------------------------------------------------------------------------------------------------
//
-void Interface::connect (String address, String password)
+void Interface::connect(String address, String password)
{
try
{
- m_remoteAddress = IPAddress::from_string (address);
+ m_remoteAddress = IPAddress::from_string(address);
}
catch (std::exception& e)
{
- print ("%s\n", e.what());
+ print("%s\n", e.what());
return;
}
@@ -1011,22 +1007,22 @@
m_remoteAddress.port = 10666;
m_session.disconnect();
- m_session.set_password (password);
- m_session.connect (m_remoteAddress);
+ m_session.set_password(password);
+ m_session.connect(m_remoteAddress);
}
// -------------------------------------------------------------------------------------------------
//
-void Interface::set_player_names (const StringList& names)
+void Interface::setPlayerNames(const StringList& names)
{
m_playerNames.clear();
for (const String& name : names)
{
ColoredLine coloredname;
- coloredname.add_string (name);
+ coloredname.add_string(name);
coloredname.finalize();
- m_playerNames.append (coloredname);
+ m_playerNames.append(coloredname);
}
m_needNicklistRender = true;
@@ -1034,16 +1030,16 @@
// -------------------------------------------------------------------------------------------------
//
-void Interface::tab_complete (const String& part, String complete)
+void Interface::tabComplete(const String& part, String complete)
{
- String& input = mutable_current_input();
+ String& input = getEditableInput();
- if (input.starts_with (part))
+ if (input.starts_with(part))
{
if (input[part.length()] != ' ')
complete += ' ';
- input.replace (0, part.length(), complete);
+ input.replace(0, part.length(), complete);
m_cursorPosition = complete.length();
m_needInputRender = true;
}
@@ -1051,7 +1047,7 @@
// -------------------------------------------------------------------------------------------------
//
-void Interface::handle_command(const String& input)
+void Interface::handleCommand(const String& input)
{
if (input[0] != '/')
return;
@@ -1064,7 +1060,7 @@
{
if (args.size() != 2)
{
- print_error("Usage: /connect <address> <password>\n");
+ printError("Usage: /connect <address> <password>\n");
}
else
{
@@ -1076,7 +1072,7 @@
}
catch (std::exception& e)
{
- print_error("%s\n", e.what());
+ printError("%s\n", e.what());
return;
}
@@ -1106,7 +1102,7 @@
print_error("No CVars to watch.\n");
}
else
- print_error("Unknown command: %s\n", command.chars());
+ printError("Unknown command: %s\n", command.chars());
}
// -------------------------------------------------------------------------------------------------
@@ -1114,22 +1110,22 @@
void Interface::disconnected()
{
print("Disconnected from %s\n", m_session.address().to_string(IPAddress::WITH_PORT).chars());
- reset_title();
- render_full();
+ resetTitle();
+ renderFull();
}
// -------------------------------------------------------------------------------------------------
//
-void Interface::reset_title()
+void Interface::resetTitle()
{
- m_title.sprintf ("%s %s (%s)", application_name(), full_version_string(), changeset_date_string());
+ m_title.sprintf("%s %s (%s)", application_name(), full_version_string(), changeset_date_string());
}
// -------------------------------------------------------------------------------------------------
//
-void Interface::flush_input()
+void Interface::flushInput()
{
- m_inputHistory.insert (0, "");
+ m_inputHistory.insert(0, "");
m_inputCursor = 0;
m_needInputRender = true;
}