//// LogDisplay.cpp// interface//// Created by Tobias Schwinger on 4/14/13.// Copyright (c) 2013 High Fidelity, Inc. All rights reserved.// #include "LogDisplay.h" #include <stdio.h>#include <stdarg.h>#include <string.h> #include "Util.h" using namespace std;FILE* const LogDisplay::DEFAULT_STREAM = 0l; //// Singleton constructor//LogDisplay LogDisplay::instance; //// State management// LogDisplay::LogDisplay() :        _textRenderer(SANS_FONT_FAMILY, -1, -1, false, TextRenderer::SHADOW_EFFECT),    _stream(DEFAULT_STREAM),    _chars(0l),    _lines(0l),    _logWidth(DEFAULT_CONSOLE_WIDTH) {     pthread_mutex_init(& _mutex, 0l);     // allocate twice as much (so we have spare space for a copy not to block     // logging from other threads during 'render')    _chars = new char[CHARACTER_BUFFER_SIZE * 2];    _charsEnd = _chars + CHARACTER_BUFFER_SIZE;    _lines = new char*[LINE_BUFFER_SIZE * 2];    _linesEnd = _lines + LINE_BUFFER_SIZE;     // initialize the log to all empty lines    _chars[0] = '\0';    _writePos = _chars;    _writeLineStartPos = _chars;    _lastLinePos = _lines;    _writtenInLine = 0;    memset(_lines, 0, LINE_BUFFER_SIZE * sizeof(char*));     setCharacterSize(DEFAULT_CHAR_WIDTH, DEFAULT_CHAR_HEIGHT);}  LogDisplay::~LogDisplay() {     delete[] _chars;    delete[] _lines;} void LogDisplay::setStream(FILE* stream) {     pthread_mutex_lock(& _mutex);    _stream = stream;    pthread_mutex_unlock(& _mutex);} void LogDisplay::setLogWidth(unsigned pixels) {     pthread_mutex_lock(& _mutex);    _logWidth = pixels;    _lineLength = _logWidth / _charWidth;    pthread_mutex_unlock(& _mutex);} void LogDisplay::setCharacterSize(unsigned width, unsigned height) {     pthread_mutex_lock(& _mutex);    _charWidth = width;    _charHeight = height;    _lineLength = _logWidth / _charWidth;    pthread_mutex_unlock(& _mutex);} //// Logging// void LogDisplay::addMessage(const char* ptr) {     pthread_mutex_lock(& _mutex);     // T-pipe, if requested    if (_stream != 0l) {        fprintf(_stream, "%s", ptr);    }     while (*ptr != '\0') {        // process the characters        char c = *ptr++;         if (c == '\t') {              // found TAB -> write SPACE            c = ' ';          } else if (c == '\n') {             // found LF -> write NUL (c == '\0' tells us to wrap, below)            c = '\0';        }        *_writePos++ = c;         if (_writePos == _charsEnd) {            // reached the end of the circular character buffer? -> start over            _writePos = _chars;        }         if (++_writtenInLine >= _lineLength || c == '\0') {             // new line? store its start to the line buffer and mark next line as empty            ++_lastLinePos;                        if (_lastLinePos == _linesEnd) {                _lastLinePos = _lines;                _lastLinePos[1] = 0l;            } else if (_lastLinePos + 1 != _linesEnd) {                _lastLinePos[1] = 0l;            } else {                _lines[0] = 0l;            }             *_lastLinePos = _writeLineStartPos;             // debug mode: make sure all line pointers we write here are valid            assert(! (_lastLinePos < _lines || _lastLinePos >= _linesEnd));            assert(! (*_lastLinePos < _chars || *_lastLinePos >= _charsEnd));             // terminate line, unless done already            if (c != '\0') {                *_writePos++ = '\0';                 if (_writePos == _charsEnd) {                    _writePos = _chars;                }            }             // remember start position in character buffer for next line and reset character count            _writeLineStartPos = _writePos;            _writtenInLine = 0;        }    }     pthread_mutex_unlock(& _mutex);} //// Rendering// void LogDisplay::render(unsigned screenWidth, unsigned screenHeight) {     // rendering might take some time, so create a local copy of the portion we need    // instead of having to hold the mutex all the time    pthread_mutex_lock(& _mutex);     // determine number of visible lines (integer division rounded up)    unsigned showLines = (screenHeight + _charHeight - 1) / _charHeight;     char** lastLine = _lastLinePos;    char** firstLine = _lastLinePos;     if (! *lastLine) {        // empty log        pthread_mutex_unlock(& _mutex);        return;    }     // scan for first line    for (int n = 2; n <= showLines; ++n) {         char** prevFirstLine = firstLine;        --firstLine;        if (firstLine < _lines) {            firstLine = _linesEnd - 1;        }        if (! *firstLine) {            firstLine = prevFirstLine;            showLines = n - 1;            break;        }         // debug mode: make sure all line pointers we find here are valid        assert(! (firstLine < _lines || firstLine >= _linesEnd));        assert(! (*firstLine < _chars || *firstLine >= _charsEnd));    }     // copy the line buffer portion into a contiguous region at _linesEnd    if (firstLine <= lastLine) {         memcpy(_linesEnd, firstLine, showLines * sizeof(char*));     } else {         unsigned atEnd = _linesEnd - firstLine;        memcpy(_linesEnd, firstLine, atEnd * sizeof(char*));        memcpy(_linesEnd + atEnd, _lines, (showLines - atEnd) * sizeof(char*));    }     // copy relevant char buffer portion and determine information to remap the pointers    char* firstChar = *firstLine;    char* lastChar = *lastLine + strlen(*lastLine) + 1;    ptrdiff_t charOffset = _charsEnd - firstChar, charOffsetBeforeFirst = 0;    if (firstChar <= lastChar) {         memcpy(_charsEnd, firstChar, lastChar - firstChar + 1);     } else {         unsigned atEnd = _charsEnd - firstChar;        memcpy(_charsEnd, firstChar, atEnd);        memcpy(_charsEnd + atEnd, _chars, lastChar + 1 - _chars);         charOffsetBeforeFirst = _charsEnd + atEnd - _chars;    }     // determine geometry information from font metrics    QFontMetrics const& fontMetrics = _textRenderer.metrics();    int yStep = fontMetrics.lineSpacing();    // scale    float xScale = float(_charWidth) / fontMetrics.width('*');    float yScale = float(_charHeight) / yStep;    // scaled translation    int xStart = int((screenWidth - _logWidth) / xScale);    int yStart = screenHeight / yScale - fontMetrics.descent();     // first line to render    char** line = _linesEnd + showLines;     // ok, now the lock can be released - we have all we need    // and won't hold it while talking to OpenGL    pthread_mutex_unlock(& _mutex);     glPushMatrix();    glScalef(xScale, yScale, 1.0f);    glColor3ub(GLubyte(TEXT_COLOR >> 16),               GLubyte((TEXT_COLOR >> 8) & 0xff),               GLubyte(TEXT_COLOR & 0xff));    for (int y = yStart; y > 0; y -= yStep) {         // debug mode: check line pointer is valid        assert(! (line < _linesEnd || line >= _linesEnd + (_linesEnd - _lines)));         // get character pointer        if (--line < _linesEnd) {            break;        }        char* chars = *line;         // debug mode: check char pointer we find is valid        assert(! (chars < _chars || chars >= _charsEnd));         // remap character pointer it to copied buffer        chars += chars >= firstChar ? charOffset : charOffsetBeforeFirst;         // debug mode: check char pointer is still valid (in new range)        assert(! (chars < _charsEnd || chars >= _charsEnd + (_charsEnd - _chars)));         // render the string        _textRenderer.draw(xStart, y, chars); //fprintf(stderr, "LogDisplay::render, message = \"%s\"\n", chars);    }    glPopMatrix();}