Console Class Reference

#include <Console.h>

Classes
class	CliRunnable

Public Member Functions
	Console ()
	~Console ()

Protected Member Functions
void	Initialize ()
void	SetLoading (bool show, const char *caption="Initializing")
void	SetLoadingLabel (const char *label, bool br=true)
void	FatalError (const char *msg)
void	MainLoop ()
void	RunCommandLoop ()
void	RunLogViewLoop ()
void	DrawLogo ()
bool	IsEnabled () const
void	Beep ()
void	Restore ()

Private Types
typedef std::list< std::string >	History
typedef HANDLE	PipeType

Private Member Functions
void	SetTitle (const char *title)
void	Refresh ()
int	GetChar ()
void	DrawLoading ()
void	UpdateLog ()
Window *	MakeWindow (int h, int w, int y, int x)
void	ResizeWindow (Window *win, int h, int w, int y, int x)
void	DestroyWindow (Window *win)

Private Attributes
std::set< Window * >	m_windows
bool	m_IamEnabled
History	m_cmdHistory
PipeType	m_loggerFd
Window *	m_logoWindow
Window *	m_loadWindow
Window *	m_logViewer
Window *	m_cmdOutput

Friends
class	World
class	Master
class	Log
class	UnixDebugger
void	LoadSQLUpdates ()

Detailed Description

Definition at line 13 of file Console.h.

Member Typedef Documentation

typedef std::list<std::string> Console::History

private

Definition at line 83 of file Console.h.

typedef HANDLE Console::PipeType

private

Definition at line 85 of file Console.h.

Constructor & Destructor Documentation

Console::Console

(

)

Definition at line 57 of file Console.cpp.

References HandleConsoleInterrupt(), and SetTitle().

                 : m_IamEnabled(false), m_loggerFd(0), m_logoWindow(0), m_loadWindow(0)
{
    SetTitle("OregonCore");
    #if PLATFORM == PLATFORM_WINDOWS
    SetConsoleCtrlHandler(&HandleConsoleInterrupt, TRUE);
    #endif
}

Console::~Console

(

)

Definition at line 65 of file Console.cpp.

References DestroyWindow(), m_IamEnabled, m_loggerFd, and m_windows.

{
    if (!m_IamEnabled)
        return;

    for (std::set<Window*>::const_iterator it = m_windows.begin(); it != m_windows.end(); )
    {
        DestroyWindow(*it);
        it = m_windows.begin();
    }

    endwin();

    if (m_loggerFd)
    #if PLATFORM == PLATFORM_WINDOWS
        CloseHandle(m_loggerFd);
    #else
        close(m_loggerFd);
    #endif
}

Member Function Documentation

void Console::Beep ( )

inlineprotected

Definition at line 44 of file Console.h.

        {
            beep();
        }

void Console::DestroyWindow ( Window *  win )

private

Definition at line 201 of file Console.cpp.

References m_windows.

Referenced by FatalError(), MainLoop(), RunCommandLoop(), RunLogViewLoop(), SetLoading(), SetTitle(), and ~Console().

{
    if (!win)
        return;

    werase(win);   // make it blank
    wrefresh(win); // apply
    m_windows.erase(win);
    delwin(win);
}

void Console::DrawLoading ( )

private

Referenced by SetTitle().

void Console::DrawLogo ( )

protected

Definition at line 760 of file Console.cpp.

References m_IamEnabled, m_logoWindow, sLog, and TermColor.

Referenced by FatalError(), and MainLoop().

{
    static const char FavString[] = "Your Favourite TBC Server";

    if (m_IamEnabled)
    {
        werase(m_logoWindow);
        scrollok(m_logoWindow, TRUE);
        wattrset(m_logoWindow, A_BOLD | TermColor(COLOR_GREEN));
        mvwprintw(m_logoWindow, 0, 0, "%s", sOregonLogo);
        wattroff(m_logoWindow, TermColor(COLOR_GREEN));
        wattron(m_logoWindow, TermColor(COLOR_CYAN));

        mvwprintw(m_logoWindow, 1, sOregonLogoCols / 2 - (sizeof(FavString) - 1) / 2, "%s", FavString);
        mvwprintw(m_logoWindow, sOregonLogoRows - 1, 0, "%s", "https://www.oregon-core.net");

        wattroff(m_logoWindow, TermColor(COLOR_CYAN));
        wrefresh(m_logoWindow);
    }
    else
    {
        sLog.outString();
        for (uint32 i = 0; i < sOregonLogoRows; i++)
            sLog.outString("%.*s", sOregonLogoCols, &sOregonLogo[i * sOregonLogoCols]);
        sLog.outString("https://www.oregon-core.net\n");
    }
}

void Console::FatalError ( const char *  msg )

protected

Definition at line 734 of file Console.cpp.

References ASSERT, DestroyWindow(), DrawLogo(), GetChar(), m_IamEnabled, MakeWindow(), and TermColor.

{
    ASSERT(m_IamEnabled);

    erase();

    Window* errWin = MakeWindow(LINES - (2 + sOregonLogoRows), sOregonLogoCols, 2 + sOregonLogoRows, COLS / 2 - sOregonLogoCols / 2);
    wattrset(errWin, A_BOLD | TermColor(COLOR_RED));
    wprintw(errWin, "FATAL ERROR:"
            "\n\n"
            "%s"
            "\n\n"
            "Press enter to exit", msg);
    wrefresh(stdscr);
    DrawLogo();
    wrefresh(errWin);

    timeout(-1);
    for (int c = GetChar(); (c != KEY_ENTER && c != '\n' && c != '\r'); c = GetChar())
        ;

    DestroyWindow(errWin);

    endwin();
}

int Console::GetChar ( )

private

Definition at line 218 of file Console.cpp.

References SCROLLDN_MASK, and SCROLLUP_MASK.

Referenced by FatalError(), MainLoop(), RunCommandLoop(), RunLogViewLoop(), and SetTitle().

{
    int ch = getch();
    if (ch == KEY_MOUSE)
    {
        MEVENT event;
        if (getmouse(&event) == OK)
        {
            if (event.bstate & SCROLLUP_MASK)
                ch = KEY_SR; // scroll up
            else if (event.bstate & SCROLLDN_MASK)
                ch = KEY_SF; // scroll down
        }
    }
    return ch;
}

void Console::Initialize ( void  )

protected

Definition at line 86 of file Console.cpp.

References dup2, fileno, m_cmdOutput, m_IamEnabled, m_loadWindow, m_loggerFd, m_logoWindow, m_logViewer, MakeWindow(), Refresh(), and sConfig.

{
    m_IamEnabled = true;

    initscr();              // init curses
    cbreak();               // turn off line buffering
    noecho();               // turn off echoing of chars by terminal
    keypad(stdscr, TRUE);   // enable use of F1-F12 keys, arrows, etc.
    curs_set(0);            // try to make the cursor invisible
    idlok(stdscr, TRUE);    // allow terminal controls line ins/del
    idcok(stdscr, TRUE);    // allow terminal controls char ins/del
    scrollok(stdscr, TRUE); // allow scrolling
    leaveok(stdscr, TRUE);  // dont move cursor (performance)
    nonl();                 // disable new line feed translating
    start_color();          // initialize colors

    use_default_colors();
    if (has_colors())
        for (int i = 1; i <= COLORS; i++)
            init_pair(i + 1, i, -1);

    mousemask(ALL_MOUSE_EVENTS & ~REPORT_MOUSE_POSITION, NULL); // allow mouse interaction
    mouseinterval(0);

    int width = sConfig.GetIntDefault("Console.Width", 0);
    int height = sConfig.GetIntDefault("Console.Height", 0);

    if (width > 0 && height > 0)
        resizeterm(height, width);

    if (!m_logoWindow)
    {
        // win                       height         width                          y                              x
        m_logoWindow = MakeWindow(sOregonLogoRows, sOregonLogoCols, 1,                               COLS / 2 - sOregonLogoCols / 2);
        m_loadWindow = MakeWindow(3,               sOregonLogoCols, 2 + sOregonLogoRows,             COLS / 2 - sOregonLogoCols / 2);

        int rows = 0xFFFF / COLS;
        m_logViewer = newpad(rows, COLS);
        idlok(m_logViewer, TRUE);
        idcok(m_logViewer, TRUE);
        scrollok(m_logViewer, TRUE);
        wmove(m_logViewer, rows - 1, COLS - 1);
        wprintw(m_logViewer, " ");

        m_cmdOutput = dupwin(m_logViewer);
    }

    Refresh();

    // we abuse stderr to bring us data from logger
    #if PLATFORM == PLATFORM_WINDOWS
    HANDLE writer, reader;
    char pipeName[MAX_PATH];
    sprintf(pipeName, "\\\\.\\Pipe\\LocalOCAnon.%u", GetCurrentProcessId());
    SetLastError(0);
    reader = CreateNamedPipeA(pipeName, PIPE_ACCESS_INBOUND, PIPE_TYPE_BYTE, 1, 4096, 0xFFFF, 1000, NULL);
    writer = CreateFileA(pipeName, GENERIC_WRITE, 0, NULL, OPEN_EXISTING, FILE_FLAG_OVERLAPPED | FILE_FLAG_NO_BUFFERING | FILE_FLAG_WRITE_THROUGH, NULL);

    if (GetLastError())
    {
        if (!reader || reader == INVALID_HANDLE_VALUE)
            CloseHandle(reader);
        if (!writer || writer == INVALID_HANDLE_VALUE)
            CloseHandle(writer);
        fclose(stderr);
        return;
    }

    SetStdHandle(STD_ERROR_HANDLE, writer);
    //stderr->_file = _open_osfhandle((long) writer, _O_TEXT);
    dup2(_open_osfhandle((long) writer, 0), fileno(stderr));
    m_loggerFd = reader;
    #else
    int fds[2];
    if (!pipe(fds))
    {
        // 0 - reader, 1 - writer
        if (-1 == dup2(fds[1], STDERR_FILENO))
            fclose(stderr);
        else
        {
            fcntl(fds[0], F_SETFL, fcntl(fds[0], F_GETFL) | O_NONBLOCK | O_CLOEXEC);
            fcntl(fds[1], F_SETFL, fcntl(fds[1], F_GETFL) | O_NONBLOCK | O_CLOEXEC);
            m_loggerFd = fds[0];

            setvbuf(stderr, NULL, _IOLBF, 0);
        }
    }
    else
        fclose(stderr);
    #endif
}

bool Console::IsEnabled ( ) const

inlineprotected

Definition at line 39 of file Console.h.

References m_IamEnabled.

        {
            return m_IamEnabled;
        }

void Console::MainLoop ( )

protected

Definition at line 243 of file Console.cpp.

References DestroyWindow(), DrawLogo(), GetChar(), World::IsStopped(), m_loadWindow, m_logoWindow, MakeWindow(), Refresh(), ResizeWindow(), RunCommandLoop(), RunLogViewLoop(), sLog, sWorld, TermColor, ticketmgr, UpdateLog(), and value.

{
    DestroyWindow(m_loadWindow);

    int MenuActiveItem = 0;
    time_t startTime = time(0); // we use our own timer due to thread-safety

    //                                height            width                    y                         x
    Window* menuWindow = MakeWindow(MenuItems + 2,     19,              1 + sOregonLogoRows + 1,         COLS / 2 - 10 - 2);
    Window* infoWindow = MakeWindow(4,               sOregonLogoCols, 5 + sOregonLogoRows + MenuItems, COLS / 2 - sOregonLogoCols / 2);

    flushinp();

    wattron(menuWindow, A_BOLD | TermColor(COLOR_CYAN));
    wborder(menuWindow, '|', '|', '-', '-', '+', '+', '+', '+');
    wattroff(menuWindow, A_BOLD | TermColor(COLOR_CYAN));

    DrawLogo();

    while (!World::IsStopped())
    {
        // draw menu
        for (int i = 0; i < MenuItems; i++)
        {
            if (MenuActiveItem == i)
            {
                wattron(menuWindow, A_BOLD | TermColor(COLOR_GREEN));
                mvwprintw(menuWindow, i + 1, 1, "* %s *", Menu[i]);
                wattroff(menuWindow, A_BOLD | TermColor(COLOR_GREEN));
            }
            else if (Menu[i][0] == '-')
                mvwprintw(menuWindow, i + 1, 1, "--%s--", Menu[i]);
            else
                mvwprintw(menuWindow, i + 1, 1, "  %s  ", Menu[i]);
        }

        // draw info
        enum InfoValue
        {
            INFO_EMPTY,

            INFO_PLAYERS_ONLINE,
            INFO_PLAYERS_QUEUED,
            INFO_PLAYERS_MAX,

            INFO_REVISION,
            INFO_LOGMASK,
            INFO_UPTIME,
            INFO_TICKETS
        };

        struct
        {
            int y;
            int x;
            const char* type;
            InfoValue value;
        } InfoTable[]
        =
        {
            { 0,    0,    "Players:",    INFO_PLAYERS_ONLINE },
            { 1,    0,    "        ",    INFO_PLAYERS_QUEUED },
            { 2,    0,    "        ",    INFO_PLAYERS_MAX,   },
            { 3,    0,    "        ",    INFO_EMPTY,         },

            { 0,   34,    "Revision:",   INFO_REVISION,      },
            { 1,   34,    "LogMask:",    INFO_LOGMASK,      },
            { 2,   34,    "Uptime:  ",   INFO_UPTIME,        },
            { 3,   34,    "Tickets: ",   INFO_TICKETS,       }
        };

        for (uint32 i = 0; i < sizeof(InfoTable) / sizeof(*InfoTable); i++)
        {
            wmove(infoWindow, InfoTable[i].y, InfoTable[i].x);
            wattron(infoWindow, A_BOLD | TermColor(COLOR_GREEN));
            wprintw(infoWindow, "%s", InfoTable[i].type);
            wattroff(infoWindow, A_BOLD | TermColor(COLOR_GREEN));
            switch (InfoTable[i].value)
            {
            case INFO_PLAYERS_ONLINE:
                wprintw(infoWindow, " %u (online)", sWorld.GetActiveSessionCount());
                break;
            case INFO_PLAYERS_QUEUED:
                wprintw(infoWindow, " %u (queued)", sWorld.GetQueuedSessionCount());
                break;
            case INFO_PLAYERS_MAX:
                wprintw(infoWindow, " %u (max)", sWorld.GetMaxActiveSessionCount() + sWorld.GetMaxQueuedSessionCount());
                break;
            case INFO_REVISION:
                wprintw(infoWindow, " %s", _REVISION);
                break;
            case INFO_LOGMASK:
                wprintw(infoWindow, " %lu", sLog.GetLogMask());
                break;
            case INFO_UPTIME:
                {
                    time_t diff = time(0) - startTime;
                    uint32 mins = diff / 60;
                    uint32 hours = mins / 60;
                    uint32 days = hours / 24;
                    wprintw(infoWindow, " %ud %uh %um", days, hours % 24, mins % 60);
                }
                break;
            case INFO_TICKETS:
                wprintw(infoWindow, " %lu", ticketmgr.GM_TicketList.size());
            default:
                break;
            }
        }

        wrefresh(m_logoWindow);
        wrefresh(menuWindow);
        wrefresh(infoWindow);

        UpdateLog();

        // align timeout to the next minute
        timeout((60 - ((time(0) - startTime) % 60)) * 1000);
        int ch = GetChar();

        switch (ch)
        {
        case KEY_UP:
            MenuActiveItem = (MenuActiveItem == 0) ? MenuItems - 1 : (MenuActiveItem - 1);
            if (Menu[MenuActiveItem][0] == '-')
                MenuActiveItem--;
            break;
        case KEY_DOWN:
            MenuActiveItem = (MenuActiveItem >= MenuItems - 1) ? 0 : (MenuActiveItem + 1);
            if (Menu[MenuActiveItem][0] == '-')
                MenuActiveItem++;
            break;
        case KEY_ENTER:
        case '\n':
        case '\r':

            switch (MenuActiveItem)
            {
            case 0: /* Run a Command */
                RunCommandLoop();
                break;
            case 1: /* Real-time logs */
                RunLogViewLoop();
                break;
            case 3: /* shutdown */
                endwin();
                raise(SIGINT);
                break;
            }

        /* Fallthrough */
        case KEY_RESIZE:

            erase();

            //           win             height         width                 y                            x
            ResizeWindow(m_logoWindow, sOregonLogoRows, sOregonLogoCols, 1,                       COLS / 2 - sOregonLogoCols / 2);
            ResizeWindow(menuWindow, MenuItems + 2,     19,              1 + sOregonLogoRows + 1, std::max<int>(0, COLS / 2 - 10 - 2));
            ResizeWindow(infoWindow, 4,               sOregonLogoCols, 5 + sOregonLogoRows + MenuItems, COLS / 2 - sOregonLogoCols / 2);

            wattron(menuWindow, A_BOLD | TermColor(COLOR_CYAN));
            wborder(menuWindow, '|', '|', '-', '-', '+', '+', '+', '+');
            wattroff(menuWindow, A_BOLD | TermColor(COLOR_CYAN));

            Refresh();
            DrawLogo();
            break;
        default:
            break;;
        }
    }

    DestroyWindow(menuWindow);
    DestroyWindow(infoWindow);
}

Window * Console::MakeWindow ( int  h, int  w, int  y, int  x  )

private

Definition at line 193 of file Console.cpp.

References m_windows.

Referenced by FatalError(), Initialize(), MainLoop(), RunCommandLoop(), RunLogViewLoop(), and SetTitle().

{
    Window* win = newwin(h, w, y, x);
    leaveok(win, TRUE);
    m_windows.insert(win);
    return win;
}

void Console::Refresh ( )

private

Definition at line 179 of file Console.cpp.

References m_windows.

Referenced by Initialize(), MainLoop(), and SetTitle().

{
    wrefresh(stdscr);

    for (std::set<Window*>::const_iterator it = m_windows.begin(); it != m_windows.end(); it++)
        wrefresh(*it);
}

void Console::ResizeWindow ( Window *  win, int  h, int  w, int  y, int  x  )

private

Definition at line 212 of file Console.cpp.

Referenced by MainLoop(), RunCommandLoop(), RunLogViewLoop(), and SetTitle().

{
    mvwin(win, y, x);
    wresize(win, h, w);
}

void Console::Restore ( )

protected

Definition at line 187 of file Console.cpp.

References m_IamEnabled.

{
    endwin();
    m_IamEnabled = false;
}

void Console::RunCommandLoop ( )

protected

Definition at line 455 of file Console.cpp.

References CMD_FINISHED, CMD_SUCCESS, CBArg::colored, DestroyWindow(), GetChar(), World::IsStopped(), m_cmdHistory, m_cmdOutput, MakeWindow(), ResizeWindow(), ACE_Based::Thread::Sleep(), CBArg::status, sWorld, TermColor, and CBArg::win.

Referenced by MainLoop().

{
    History::iterator historyCur = m_cmdHistory.begin();
    if (m_cmdHistory.size())
        std::advance(historyCur, m_cmdHistory.size() - 1);

    int no = 1;

    int lineWidth = COLS - (sizeof("Oregon>") - 1);
    Window* cmdLine = MakeWindow(1, lineWidth, LINES - 1, (sizeof("Oregon>") - 1));

    erase();
    curs_set(1);

    attron(A_BOLD | TermColor(COLOR_GREEN));
    mvprintw(LINES - 1, 0, "Oregon> ");
    attroff(A_BOLD | TermColor(COLOR_GREEN));
    wattrset(cmdLine, A_PROTECT | TermColor(COLOR_WHITE));

    int y, mx, my;
    int pageSize = LINES - 1;
    getmaxyx(m_cmdOutput, my, mx);
    y = my - 1 - pageSize;

    leaveok(cmdLine, FALSE);
    wmove(cmdLine, 0, 0);

    pnoutrefresh(m_cmdOutput, y, 0, 0, 0, LINES - 2, COLS);
    wrefresh(stdscr);
    wrefresh(cmdLine);

    bool update = true;

    std::string buffer = "";

    while (!World::IsStopped())
    {
        if (update)
        {
            pnoutrefresh(m_cmdOutput, y, 0, 0, 0, LINES - 2, COLS);

            attron(A_BOLD | TermColor(COLOR_GREEN));
            mvprintw(LINES - 1, 0, "Oregon> ");
            attroff(A_BOLD | TermColor(COLOR_GREEN));

            wrefresh(stdscr);

            update = false;
        }

        werase(cmdLine);
        wrefresh(cmdLine);
        mvwprintw(cmdLine, 0, 0, "%s", buffer.c_str() + std::max<int>(0, (buffer.size() - (lineWidth - 1))));
        wmove(cmdLine, 0, std::min<size_t>(lineWidth - 1, buffer.size()));
        wrefresh(cmdLine);

        int ch = GetChar();
        if (ch >= 0x20 && ch < 0x7F)
        {
            if (buffer.empty() && ch != '.')
                buffer.append(1, '.');
            buffer.append(1, ch);
        }
        else if (ch == KEY_UP)
        {
            historyCur--;
            if (historyCur != m_cmdHistory.end())
                buffer = *historyCur;
            else
                buffer.clear();
        }
        else if (ch == KEY_DOWN)
        {
            historyCur++;
            if (historyCur != m_cmdHistory.end())
                buffer = *historyCur;
            else
                buffer.clear();
        }
        else if (ch == KEY_BACKSPACE || ch == 0x7F || ch == 0x08)
        {
            if (buffer.size())
                buffer.resize(buffer.size() - 1);
        }
        else if (ch == KEY_PPAGE) // page up
        {
            update = true;
            y = std::max<int>(0, y - pageSize);
        }
        else if (ch == KEY_NPAGE) // page down
        {
            update = true;
            y = std::min<int>(my - 1 - pageSize, y + pageSize);
        }
        else if (ch == KEY_SR) // scroll up
        {
            update = true;
            y = std::max<int>(0, y - 1);
        }
        else if (ch == KEY_SF) // scroll  down
        {
            update = true;
            y = std::min<int>(my - 1 - pageSize, y + 1);
        }
        else if ((ch == KEY_ENTER || ch == '\n' || ch == '\r'))
        {
            if (buffer.empty() || buffer == ".exit" || buffer == ".quit")
                break;

            curs_set(0);

            CBArg result;
            result.win = m_cmdOutput;
            result.status = 0;
            result.colored = (no ^= 1);

            sWorld.QueueCliCommand(new CliCommandHolder(&result, buffer.c_str(), &PrintCommandResultCallback, &CommandFinishedCallback));

            /* command is issued we now block until command is executed, to prevent crash in PrintCommandResultCallback:
               when server shuts down and we destroy output window before last World::Update() which calls PrintCmdResCB;
               also this ensures thread-safety between curses calls */
            do
                ACE_Based::Thread::Sleep(50);
            while (!(result.status & CMD_FINISHED) && !World::IsStopped());

            #if OREGON_DEBUG
            if (!(result.status & CMD_SUCCESS))
            {
                wattron(m_cmdOutput, A_BOLD | TermColor(COLOR_RED));
                wprintw(m_cmdOutput, "Command failed :(\n");
                wattroff(m_cmdOutput, A_BOLD | TermColor(COLOR_RED));
            }
            #endif

            update = true;

            m_cmdHistory.push_back(buffer);
            historyCur = m_cmdHistory.begin();
            std::advance(historyCur, m_cmdHistory.size() - 1);

            buffer.clear();
            curs_set(1);
        }
        else if (ch == KEY_RESIZE)
        {
            lineWidth = COLS - (sizeof("Oregon>") - 1);

            wresize(m_cmdOutput, 0xFFFF / COLS, COLS);

            ResizeWindow(cmdLine, 1, lineWidth, LINES - 1, (sizeof("Oregon>") - 1));
            wmove(m_cmdOutput, LINES - 2, COLS - 1);

            werase(stdscr);

            pageSize = LINES - 4;
            getmaxyx(m_cmdOutput, my, mx);
            wmove(m_cmdOutput, my - 1, mx - 1);
            waddch(m_cmdOutput, ' ');

            y = my - pageSize;

            update = true;
        }

    }

    curs_set(0);
    DestroyWindow(cmdLine);
}

void Console::RunLogViewLoop ( )

protected

Definition at line 625 of file Console.cpp.

References DestroyWindow(), GetChar(), World::IsStopped(), m_logViewer, MakeWindow(), ResizeWindow(), TermColor, and UpdateLog().

Referenced by MainLoop().

{
    const char info[] = "Use arrows, PgUp/PgDn to scroll. Enter to return. (%lu%%)";
    size_t len = sizeof(info) - 1;

    int y, mx, my;
    int pageSize = LINES - 4;
    getmaxyx(m_logViewer, my, mx);
    my--;

    y = my - pageSize;

    Window* infoWindow = MakeWindow(2, len, LINES - 2, COLS / 2 - len / 2);
    wattron(infoWindow, A_BOLD | TermColor(COLOR_GREEN));

    erase();
    refresh();

    wrefresh(infoWindow);
    timeout(1000);

    while (!World::IsStopped())
    {
        if (y == my - pageSize)
        {
            UpdateLog();
            prefresh(m_logViewer, y, 0, 0, 0, pageSize + 1, COLS);
        }
        else
            prefresh(m_logViewer, y, 0, 0, 0, pageSize, COLS);

        werase(infoWindow);
        mvwprintw(infoWindow, 0, 0, info, (100 * y) / (my - pageSize));
        wrefresh(infoWindow);

        int ch = GetChar();

        if (ch == KEY_ENTER || ch == '\r' || ch == '\n')
            break;
        else if (ch == KEY_PPAGE) // page up
            y = std::max<int>(0, y - pageSize);
        else if (ch == KEY_NPAGE) // page down
            y = std::min<int>(my - pageSize, y + pageSize);
        else if (ch == KEY_UP || ch == KEY_SR)
            y = std::max<int>(0, y - 1);
        else if (ch == KEY_DOWN || ch == KEY_SF)
            y = std::min<int>(my - pageSize, y + 1);
        else if (ch == KEY_RESIZE)
        {
            ResizeWindow(infoWindow, 2, len, LINES - 2, COLS / 2 - len / 2);

            wresize(m_logViewer, 0xFFFF / COLS, COLS);

            pageSize = LINES - 4;
            getmaxyx(m_logViewer, my, mx);
            wmove(m_logViewer, my - 1, mx - 1);
            waddch(m_logViewer, ' ');

            y = my - pageSize;
        }
    }

    DestroyWindow(infoWindow);
}

void Console::SetLoading ( bool  show, const char *  caption = "Initializing"  )

protected

Definition at line 690 of file Console.cpp.

References DestroyWindow(), m_IamEnabled, and m_loadWindow.

{
    if (!m_loadWindow || !m_IamEnabled)
        return;

    if (on)
    {
        const char stop[] = "Press <CTRL-C> to stop";

        wattron(m_loadWindow, A_BOLD);

        wprintw(m_loadWindow, "%s ", caption);
        mvwprintw(m_loadWindow, 0, sOregonLogoCols - (sizeof(stop) - 1), "%s", stop);

        wattroff(m_loadWindow, A_BOLD);
        wrefresh(m_loadWindow);
    }
    else
    {
        DestroyWindow(m_loadWindow);
        m_loadWindow = NULL;
    }
}

void Console::SetLoadingLabel ( const char *  label, bool  br = true  )

protected

Definition at line 714 of file Console.cpp.

References m_IamEnabled, m_loadWindow, and sLog.

{
    if (m_IamEnabled)
    {
        if (!m_loadWindow)
            return;

        wmove(m_loadWindow, 2, 0);
        wclrtoeol(m_loadWindow);
        mvwprintw(m_loadWindow, 2, 0, "%s", label);
        wrefresh(m_loadWindow);
    }
    else
    {
        if (br)
            sLog.outString();
        sLog.outString("%s", label);
    }
}

void Console::SetTitle ( const char *  title )

inlineprivate

Definition at line 59 of file Console.h.

References DestroyWindow(), DrawLoading(), GetChar(), MakeWindow(), Refresh(), ResizeWindow(), and UpdateLog().

Referenced by Console().

        {
            #if PLATFORM == PLATFORM_WINDOWS
            SetConsoleTitle("OregonCore");
            #elif PLATFORM == PLATFORM_UNIX
            printf("\033]0;%s\007", title);
            fflush(stdout);
            #endif
        }

void Console::UpdateLog ( )

private

Definition at line 788 of file Console.cpp.

References m_loggerFd, m_logViewer, and TermColor.

Referenced by MainLoop(), RunLogViewLoop(), and SetTitle().

{
    /* Before you start optimizing or "repairing" this functions bear in mind:
       * we read from pipe (we try to read atomic chunks)
       * read() calls are used in non-blocking I/O
       * ReadFile() calls are used with PeekNamedPipe() to achieve non-blocking I/O
       * read()/ReadFile() don't guarantee to read exactly *size* bytes
       * we call this function to *free* bytes so logger can send another data

       So to properly handle colors we use our own special escapes:
       * to apply a color we send 0xFF byte following with the color value
       * to unapply color we send 0xFE byte
       * 0xFF and 0xFE are chosen because they are invalid for utf8
       * one call to this function may read 0xFF byte but not the actual color
         so we use *static* control to check if the previous byte was 0xFF

       I admit this function is terrible for performance, although:
       * it's run from separate thread (cliThread)
       * user probably won't notice a delay
    */

    static long control = 0;
    unsigned char buffer[PIPE_BUF];

    #if PLATFORM == PLATFORM_WINDOWS
    unsigned long len, i, total;
    while (PeekNamedPipe(m_loggerFd, NULL, 0, NULL, &total, NULL) &&
           total &&
           ReadFile(m_loggerFd, buffer, std::min<unsigned long>(total, sizeof(buffer)), &len, NULL))
    #else
    ssize_t len, i;
    while ((len = read(m_loggerFd, (char*)buffer, sizeof(buffer))) > 0)
    #endif
    {
        for (i = 0; i < len; i++)
        {
            switch (buffer[i])
            {
            case 0xFF:
                control = 1;
                continue;
            case 0xFE:
                wattrset(m_logViewer, A_NORMAL);
                continue;
            default:
                if (control)
                {
                    control = 0;
                    if (buffer[i] > 7)
                        wattrset(m_logViewer, A_BOLD | TermColor(buffer[i] - 8));
                    else
                        wattrset(m_logViewer, TermColor(buffer[i]));
                    continue;
                }

                waddch(m_logViewer, buffer[i]);
            }
        }
    }
}

Friends And Related Function Documentation

void LoadSQLUpdates ( )

friend

friend class Log

friend

Definition at line 22 of file Console.h.

friend class Master

friend

Definition at line 21 of file Console.h.

friend class UnixDebugger

friend

Definition at line 23 of file Console.h.

friend class World

friend

Definition at line 20 of file Console.h.

Member Data Documentation

History Console::m_cmdHistory

private

Definition at line 90 of file Console.h.

Referenced by RunCommandLoop().

Window* Console::m_cmdOutput

private

Definition at line 96 of file Console.h.

Referenced by Initialize(), and RunCommandLoop().

bool Console::m_IamEnabled

private

Definition at line 81 of file Console.h.

Referenced by DrawLogo(), FatalError(), Initialize(), IsEnabled(), Restore(), SetLoading(), SetLoadingLabel(), and ~Console().

Window* Console::m_loadWindow

private

Definition at line 94 of file Console.h.

Referenced by Initialize(), MainLoop(), SetLoading(), and SetLoadingLabel().

PipeType Console::m_loggerFd

private

Definition at line 91 of file Console.h.

Referenced by Initialize(), UpdateLog(), and ~Console().

Window* Console::m_logoWindow

private

Definition at line 93 of file Console.h.

Referenced by DrawLogo(), Initialize(), and MainLoop().

Window* Console::m_logViewer

private

Definition at line 95 of file Console.h.

Referenced by Initialize(), RunLogViewLoop(), and UpdateLog().

std::set<Window*> Console::m_windows

private

Definition at line 80 of file Console.h.

Referenced by DestroyWindow(), MakeWindow(), Refresh(), and ~Console().

---

The documentation for this class was generated from the following files:

• /home/travis/build/OregonCore/OregonCore/src/shared/Console.h
• /home/travis/build/OregonCore/OregonCore/src/oregoncore/Console.cpp