xref: /development/simulator/app/LogWindow.cpp

//
// Copyright 2005 The Android Open Source Project
//
// Display runtime log output.
//

// For compilers that support precompilation, include "wx/wx.h".
#include "wx/wxprec.h"

// Otherwise, include all standard headers
#ifndef WX_PRECOMP
# include "wx/wx.h"
#endif
#include "wx/image.h"   // needed for Windows build
#include "wx/dcbuffer.h"

#include "LogWindow.h"
#include "LogMessage.h"
#include "LogPrefsDialog.h"
#include "MyApp.h"
#include "Preferences.h"
#include "Resource.h"
#include "UserEventMessage.h"

#include <errno.h>

static int android_snprintfBuffer(char** pBuf, int bufLen, const char* format, ...);
static int android_vsnprintfBuffer(char** pBuf, int bufLen, const char* format, va_list args);


using namespace android;

#if 0   // experiment -- works on Win32, but not with GTK
class MyTextCtrl : public wxTextCtrl {
public:
    MyTextCtrl(wxWindow* parent, wxWindowID id, const wxString& value,
        const wxPoint& pos, const wxSize& size, int style = 0)
        : wxTextCtrl(parent, id, value, pos, size, style)
        {
            printf("***************** MyTextCtrl!\n");
        }

    void OnScroll(wxScrollWinEvent& event);
    void OnScrollBottom(wxScrollWinEvent& event);

private:
    DECLARE_EVENT_TABLE()
};

BEGIN_EVENT_TABLE(MyTextCtrl, wxTextCtrl)
    EVT_SCROLLWIN(MyTextCtrl::OnScroll)
    EVT_SCROLLWIN_BOTTOM(MyTextCtrl::OnScrollBottom)
END_EVENT_TABLE()

void MyTextCtrl::OnScroll(wxScrollWinEvent& event)
{
    printf("OnScroll!\n");
}

void MyTextCtrl::OnScrollBottom(wxScrollWinEvent& event)
{
    printf("OnScrollBottom!\n");
}
#endif


BEGIN_EVENT_TABLE(LogWindow, wxDialog)
    EVT_CLOSE(LogWindow::OnClose)
    EVT_MOVE(LogWindow::OnMove)
    EVT_COMBOBOX(IDC_LOG_LEVEL, LogWindow::OnLogLevel)
    EVT_BUTTON(IDC_LOG_CLEAR, LogWindow::OnLogClear)
    EVT_BUTTON(IDC_LOG_PAUSE, LogWindow::OnLogPause)
    EVT_BUTTON(IDC_LOG_PREFS, LogWindow::OnLogPrefs)
END_EVENT_TABLE()

/*
 * Information about log levels.
 *
 * Each entry here corresponds to an entry in the combo box.  The first
 * letter of each name should be unique.
 */
static const struct {
    wxString    name;
    android_LogPriority priority;
} gLogLevels[] = {
    { wxT("Verbose"),    ANDROID_LOG_VERBOSE },
    { wxT("Debug"),      ANDROID_LOG_DEBUG },
    { wxT("Info"),       ANDROID_LOG_INFO },
    { wxT("Warn"),       ANDROID_LOG_WARN },
    { wxT("Error"),      ANDROID_LOG_ERROR }
};


/*
 * Create a new LogWindow.  This should be a child of the main frame.
 */
LogWindow::LogWindow(wxWindow* parent)
    : wxDialog(parent, wxID_ANY, wxT("Log Output"), wxDefaultPosition,
        wxDefaultSize,
        wxCAPTION | wxSYSTEM_MENU | wxCLOSE_BOX | wxRESIZE_BORDER),
      mDisplayArray(NULL), mMaxDisplayMsgs(0), mPaused(false),
      mMinPriority(ANDROID_LOG_VERBOSE),
      mHeaderFormat(LogPrefsDialog::kHFFull),
      mSingleLine(false), mExtraSpacing(0), mPointSize(10), mUseColor(true),
      mFontMonospace(true), mWriteFile(false), mTruncateOld(true), mLogFp(NULL),
      mNewlyShown(false), mLastPosition(wxDefaultPosition), mVisible(false)
{
    ConstructControls();

    Preferences* pPrefs = ((MyApp*)wxTheApp)->GetPrefs();

    int poolSize = 10240;       // 10MB
    pPrefs->GetInt("log-pool-size-kbytes", &poolSize);
    assert(poolSize > 0);
    mPool.Resize(poolSize * 1024);

    mMaxDisplayMsgs = 1000;
    pPrefs->GetInt("log-display-msg-count", &mMaxDisplayMsgs);
    assert(mMaxDisplayMsgs > 0);
    mDisplayArray = new LogMessage*[mMaxDisplayMsgs];
    memset(mDisplayArray, 0, sizeof(LogMessage*) * mMaxDisplayMsgs);
    mTopPtr = -1;
    mNextPtr = 0;

    int tmpInt = (int) mHeaderFormat;
    pPrefs->GetInt("log-header-format", &tmpInt);
    mHeaderFormat = (LogPrefsDialog::HeaderFormat) tmpInt;
    pPrefs->GetBool("log-single-line", &mSingleLine);
    pPrefs->GetInt("log-extra-spacing", &mExtraSpacing);
    pPrefs->GetInt("log-point-size", &mPointSize);
    pPrefs->GetBool("log-use-color", &mUseColor);
    pPrefs->SetBool("log-font-monospace", &mFontMonospace);
    SetTextStyle();

    mFileName = wxT("/tmp/android-log.txt");
    pPrefs->GetBool("log-write-file", &mWriteFile);
    pPrefs->GetString("log-filename", /*ref*/mFileName);
    pPrefs->GetBool("log-truncate-old", &mTruncateOld);

    PrepareLogFile();
}

/*
 * Destroy everything we own.
 */
LogWindow::~LogWindow(void)
{
    ClearDisplay();
    delete[] mDisplayArray;

    if (mLogFp != NULL)
        fclose(mLogFp);
}

/*
 * Set the text style, based on our preferences.
 */
void LogWindow::SetTextStyle(void)
{
    wxTextCtrl* pTextCtrl;
    pTextCtrl = (wxTextCtrl*) FindWindow(IDC_LOG_TEXT);
    wxTextAttr style;
    style = pTextCtrl->GetDefaultStyle();

    if (mFontMonospace) {
        wxFont font(mPointSize, wxFONTFAMILY_MODERN, wxFONTSTYLE_NORMAL,
            wxFONTWEIGHT_NORMAL);
        style.SetFont(font);
    } else {
        wxFont font(mPointSize, wxFONTFAMILY_SWISS, wxFONTSTYLE_NORMAL,
            wxFONTWEIGHT_NORMAL);
        style.SetFont(font);
    }

    pTextCtrl->SetDefaultStyle(style);
}

/*
 * Set up the goodies in the window.
 *
 * Also initializes mMinPriority.
 */
void LogWindow::ConstructControls(void)
{
    Preferences* pPrefs = ((MyApp*)wxTheApp)->GetPrefs();
    wxPanel* base = new wxPanel(this, wxID_ANY);
    wxBoxSizer* masterSizer = new wxBoxSizer(wxVERTICAL);
    wxBoxSizer* indentSizer = new wxBoxSizer(wxHORIZONTAL);
    wxBoxSizer* configPrioritySizer = new wxBoxSizer(wxHORIZONTAL);
    wxGridSizer* configSizer = new wxGridSizer(4, 1);

    /*
     * Configure log level combo box.
     */
    wxComboBox* logLevel;
    int defaultLogLevel = 1;
    pPrefs->GetInt("log-display-level", &defaultLogLevel);
    logLevel = new wxComboBox(base, IDC_LOG_LEVEL, wxT(""),
        wxDefaultPosition, wxDefaultSize, 0, NULL,
        wxCB_READONLY /*| wxSUNKEN_BORDER*/);
    for (int i = 0; i < NELEM(gLogLevels); i++) {
        logLevel->Append(gLogLevels[i].name);
        logLevel->SetClientData(i, (void*) gLogLevels[i].priority);
    }
    logLevel->SetSelection(defaultLogLevel);
    mMinPriority = gLogLevels[defaultLogLevel].priority;

    /*
     * Set up stuff at the bottom, starting with the options
     * at the bottom left.
     */
    configPrioritySizer->Add(new wxStaticText(base, wxID_ANY, wxT("Log level:"),
            wxDefaultPosition, wxDefaultSize, wxALIGN_LEFT),
        0, wxALIGN_CENTER_VERTICAL);
    configPrioritySizer->AddSpacer(kInterSpacing);
    configPrioritySizer->Add(logLevel);

    wxButton* clear = new wxButton(base, IDC_LOG_CLEAR, wxT("&Clear"),
        wxDefaultPosition, wxDefaultSize, 0);
    wxButton* pause = new wxButton(base, IDC_LOG_PAUSE, wxT("&Pause"),
        wxDefaultPosition, wxDefaultSize, 0);
    wxButton* prefs = new wxButton(base, IDC_LOG_PREFS, wxT("C&onfigure"),
        wxDefaultPosition, wxDefaultSize, 0);

    configSizer->Add(configPrioritySizer, 0, wxALIGN_LEFT);
    configSizer->Add(clear, 0, wxALIGN_CENTER);
    configSizer->Add(pause, 0, wxALIGN_CENTER);
    configSizer->Add(prefs, 0, wxALIGN_RIGHT);

    /*
     * Create text ctrl.
     */
    wxTextCtrl* pTextCtrl;
    pTextCtrl = new wxTextCtrl(base, IDC_LOG_TEXT, wxT(""),
        wxDefaultPosition, wxDefaultSize,
        wxTE_MULTILINE | wxTE_READONLY | wxTE_RICH2 | wxTE_NOHIDESEL |
            wxHSCROLL);

    /*
     * Add components to master sizer.
     */
    masterSizer->AddSpacer(kEdgeSpacing);
    masterSizer->Add(pTextCtrl, 1, wxEXPAND);
    masterSizer->AddSpacer(kInterSpacing);
    masterSizer->Add(configSizer, 0, wxEXPAND);
    masterSizer->AddSpacer(kEdgeSpacing);

    /*
     * Indent from sides.
     */
    indentSizer->AddSpacer(kEdgeSpacing);
    indentSizer->Add(masterSizer, 1, wxEXPAND);
    indentSizer->AddSpacer(kEdgeSpacing);

    base->SetSizer(indentSizer);

    indentSizer->Fit(this);             // shrink-to-fit
    indentSizer->SetSizeHints(this);    // define minimum size
}

/*
 * In some cases, this means the user has clicked on our "close" button.
 * We don't really even want one, but both WinXP and KDE put one on our
 * window whether we want it or not.  So, we make it work as a "hide"
 * button instead.
 *
 * This also gets called when the app is shutting down, and we do want
 * to destroy ourselves then, saving various information about our state.
 */
void LogWindow::OnClose(wxCloseEvent& event)
{
    /* just hide the window, unless we're shutting down */
    if (event.CanVeto()) {
        event.Veto();
        Show(false);
        return;
    }

    /*
     * Save some preferences.
     */
    SaveWindowPrefs();

    /* if we can't veto the Close(), destroy ourselves */
    Destroy();
}

/*
 * Save all of our preferences to the config file.
 */
void LogWindow::SaveWindowPrefs(void)
{
    Preferences* pPrefs = ((MyApp*)wxTheApp)->GetPrefs();

    /*
     * Save shown/hidden state.
     */
    pPrefs->SetBool("window-log-show", IsShown());

    /*
     * Limits and formatting prefs.
     */
    pPrefs->SetInt("log-display-msg-count", mMaxDisplayMsgs);
    pPrefs->SetInt("log-pool-size-kbytes", mPool.GetMaxSize() / 1024);

    pPrefs->SetInt("log-header-format", mHeaderFormat);
    pPrefs->SetBool("log-single-line", mSingleLine);
    pPrefs->SetInt("log-extra-spacing", mExtraSpacing);
    pPrefs->SetInt("log-point-size", mPointSize);
    pPrefs->SetBool("log-use-color", mUseColor);
    pPrefs->SetBool("log-font-monospace", mFontMonospace);

    pPrefs->SetBool("log-write-file", mWriteFile);
    pPrefs->SetString("log-filename", mFileName.ToAscii());
    pPrefs->SetBool("log-truncate-old", mTruncateOld);

    /*
     * Save window size and position.
     */
    wxPoint posn;
    wxSize size;

    assert(pPrefs != NULL);

    posn = GetPosition();
    size = GetSize();

    pPrefs->SetInt("window-log-x", posn.x);
    pPrefs->SetInt("window-log-y", posn.y);
    pPrefs->SetInt("window-log-width", size.GetWidth());
    pPrefs->SetInt("window-log-height", size.GetHeight());

    /*
     * Save current setting of debug level combo box.
     */
    wxComboBox* pCombo;
    int selection;
    pCombo = (wxComboBox*) FindWindow(IDC_LOG_LEVEL);
    selection = pCombo->GetSelection();
    pPrefs->SetInt("log-display-level", selection);
}

/*
 * Return the desired position and size.
 */
/*static*/ wxRect LogWindow::GetPrefWindowRect(void)
{
    Preferences* pPrefs = ((MyApp*)wxTheApp)->GetPrefs();
    int x, y, width, height;

    assert(pPrefs != NULL);

    x = y = 10;
    width = 500;
    height = 200;

    /* these don't modify the arg if the pref doesn't exist */
    pPrefs->GetInt("window-log-x", &x);
    pPrefs->GetInt("window-log-y", &y);
    pPrefs->GetInt("window-log-width", &width);
    pPrefs->GetInt("window-log-height", &height);

    return wxRect(x, y, width, height);
}

/*
 * Under Linux+GTK, the first time you show the window, it appears where
 * it's supposed to.  If you then hide it and show it again, it gets
 * moved on top of the parent window.  After that, you can reposition it
 * and it remembers its position across hide/show.
 *
 * To counter this annoyance, we save the position when we hide, and
 * reset the position after a show.  The "newly shown" flag ensures that
 * we only reposition the window as the result of a Show(true) call.
 *
 * Sometimes, something helpful will shift the window over if it's
 * partially straddling a seam between two monitors.  I don't see an easy
 * way to block this, and I'm not sure I want to anyway.
 */
void LogWindow::OnMove(wxMoveEvent& event)
{
    wxPoint point;
    point = event.GetPosition();
    //printf("Sim: log window is at (%d,%d) (new=%d)\n", point.x, point.y,
    //    mNewlyShown);

    if (mNewlyShown) {
        if (mLastPosition == wxDefaultPosition) {
            //printf("Sim: no last position established\n");
        } else {
            Move(mLastPosition);
        }

        mNewlyShown = false;
    }
}

/*
 * Set the "newly shown" flag.
 */
bool LogWindow::Show(bool show)
{
    if (show) {
        mNewlyShown = true;
        Redisplay();
    } else {
        mLastPosition = GetPosition();
    }

    mVisible = show;
    return wxDialog::Show(show);
}

/*
 * User has adjusted the log level.  Update the display appropriately.
 *
 * This is a wxEVT_COMMAND_COMBOBOX_SELECTED event.
 */
void LogWindow::OnLogLevel(wxCommandEvent& event)
{
    int selection;
    android_LogPriority priority;

    selection = event.GetInt();
    wxComboBox* pCombo = (wxComboBox*) FindWindow(IDC_LOG_LEVEL);
    priority = (android_LogPriority) (long)pCombo->GetClientData(event.GetInt());

    printf("Sim: log level selected: %d (%s)\n", (int) priority,
        (const char*) gLogLevels[selection].name.ToAscii());
    mMinPriority = priority;
    Redisplay();
}

/*
 * Clear out the log.
 */
void LogWindow::OnLogClear(wxCommandEvent& event)
{
    ClearDisplay();
    mPool.Clear();
}

/*
 * Handle the pause/resume button.
 *
 * If we're un-pausing, we need to get caught up.
 */
void LogWindow::OnLogPause(wxCommandEvent& event)
{
    mPaused = !mPaused;

    wxButton* pButton = (wxButton*) FindWindow(IDC_LOG_PAUSE);
    if (mPaused) {
        pButton->SetLabel(wxT("&Resume"));

        mPool.SetBookmark();
    } else {
        pButton->SetLabel(wxT("&Pause"));

        LogMessage* pMsg = mPool.GetBookmark();
        if (pMsg == NULL) {
            /* bookmarked item fell out of pool */
            printf("--- bookmark was lost, redisplaying\n");
            Redisplay();
        } else {
            /*
             * The bookmark points to the last item added to the display.
             * We want to chase its "prev" pointer to walk toward the head
             * of the list, adding items from oldest to newest.
             */
            pMsg = pMsg->GetPrev();
            while (pMsg != NULL) {
                if (FilterMatches(pMsg))
                    AddToDisplay(pMsg);
                pMsg = pMsg->GetPrev();
            }
        }
    }
}

/*
 * Open log preferences dialog.
 */
void LogWindow::OnLogPrefs(wxCommandEvent& event)
{
    LogPrefsDialog dialog(this);

    /*
     * Set up the dialog.
     */
    dialog.mHeaderFormat = mHeaderFormat;
    dialog.mSingleLine = mSingleLine;
    dialog.mExtraSpacing = mExtraSpacing;
    dialog.mPointSize = mPointSize;
    dialog.mUseColor = mUseColor;
    dialog.mFontMonospace = mFontMonospace;

    dialog.mDisplayMax = mMaxDisplayMsgs;
    dialog.mPoolSizeKB = mPool.GetMaxSize() / 1024;

    dialog.mWriteFile = mWriteFile;
    dialog.mFileName = mFileName;
    dialog.mTruncateOld = mTruncateOld;

    /*
     * Show it.  If they hit "OK", copy the updated values out, and
     * re-display the log output.
     */
    if (dialog.ShowModal() == wxID_OK) {
        /* discard old display arra */
        ClearDisplay();
        delete[] mDisplayArray;

        mHeaderFormat = dialog.mHeaderFormat;
        mSingleLine = dialog.mSingleLine;
        mExtraSpacing = dialog.mExtraSpacing;
        mPointSize = dialog.mPointSize;
        mUseColor = dialog.mUseColor;
        mFontMonospace = dialog.mFontMonospace;

        assert(dialog.mDisplayMax > 0);
        assert(dialog.mPoolSizeKB > 0);
        mMaxDisplayMsgs = dialog.mDisplayMax;
        mPool.Resize(dialog.mPoolSizeKB * 1024);

        mWriteFile = dialog.mWriteFile;
        if (mLogFp != NULL && mFileName != dialog.mFileName) {
            printf("--- log file name changed, closing\n");
            fclose(mLogFp);
            mLogFp = NULL;
        }
        mFileName = dialog.mFileName;
        mTruncateOld = dialog.mTruncateOld;

        mDisplayArray = new LogMessage*[mMaxDisplayMsgs];
        memset(mDisplayArray, 0, sizeof(LogMessage*) * mMaxDisplayMsgs);
        Redisplay();

        PrepareLogFile();
    }
}

/*
 * Handle a log message "user event".  This should only be called in
 * the main UI thread.
 *
 * We take ownership of "*pLogMessage".
 */
void LogWindow::AddLogMessage(LogMessage* pLogMessage)
{
    mPool.Add(pLogMessage);

    if (!mPaused && mVisible && FilterMatches(pLogMessage)) {
        /*
         * Thought: keep a reference to the previous message.  If it
         * matches in most fields (all except timestamp?), hold it and
         * increment a counter.  If we get a message that doesn't match,
         * or a timer elapses, synthesize a "previous message repeated N
         * times" string.
         */
        AddToDisplay(pLogMessage);
    }

    // release the initial ref caused by allocation
    pLogMessage->Release();

    if (mLogFp != NULL)
        LogToFile(pLogMessage);
}

/*
 * Clear out the display, releasing any log messages held in the display
 * array.
 */
void LogWindow::ClearDisplay(void)
{
    wxTextCtrl* pTextCtrl;
    pTextCtrl = (wxTextCtrl*) FindWindow(IDC_LOG_TEXT);
    pTextCtrl->Clear();

    /*
     * Just run through the entire array.
     */
    for (int i = 0; i < mMaxDisplayMsgs; i++) {
        if (mDisplayArray[i] != NULL) {
            mDisplayArray[i]->Release();
            mDisplayArray[i] = NULL;
        }
    }
    mTopPtr = -1;
    mNextPtr = 0;
}

/*
 * Clear the current display and regenerate it from the log pool.  We need
 * to do this whenever we change filters or log message formatting.
 */
void LogWindow::Redisplay(void)
{
    /*
     * Freeze output rendering so it doesn't flash during update.  Doesn't
     * seem to help for GTK, and it leaves garbage on the screen in WinXP,
     * so I'm leaving it commented out.
     */
    //wxTextCtrl* pText = (wxTextCtrl*) FindWindow(IDC_LOG_TEXT);
    //pText->Freeze();

    //printf("--- redisplay\n");
    ClearDisplay();

    /*
     * Set up the default wxWidgets text style stuff.
     */
    SetTextStyle();

    /*
     * Here's the plan:
     * - Start at the head of the pool (where the most recently added
     *   items are).
     * - Check to see if the current item passes our filter.  If it does,
     *   increment the "found count".
     * - Continue in this manner until we run out of pool or have
     *   sufficient items to fill the screen.
     * - Starting from the current position, walk back toward the head,
     *   adding the items that meet the current filter criteria.
     *
     * Don't forget that the log pool could be empty.
     */
    LogMessage* pMsg = mPool.GetHead();

    if (pMsg != NULL) {
        int foundCount = 0;

        // note this stops before it runs off the end
        while (pMsg->GetNext() != NULL && foundCount < mMaxDisplayMsgs) {
            if (FilterMatches(pMsg))
                foundCount++;
            pMsg = pMsg->GetNext();
        }

        while (pMsg != NULL) {
            if (FilterMatches(pMsg))
                AddToDisplay(pMsg);
            pMsg = pMsg->GetPrev();
        }
    }

    //pText->Thaw();
}


/*
 * Returns "true" if the currently specified filters would allow this
 * message to be shown.
 */
bool LogWindow::FilterMatches(const LogMessage* pLogMessage)
{
    if (pLogMessage->GetPriority() >= mMinPriority)
        return true;
    else
        return false;
}

/*
 * Realloc the array of pointers, and remove anything from the display
 * that should no longer be there.
 */
void LogWindow::SetMaxDisplayMsgs(int max)
{
    Preferences* pPrefs = ((MyApp*)wxTheApp)->GetPrefs();

    pPrefs->SetInt("log-display-msg-count", max);
}

/*
 * Add the message to the display array and to the screen.
 */
void LogWindow::AddToDisplay(LogMessage* pLogMessage)
{
    wxTextCtrl* pTextCtrl;
    pTextCtrl = (wxTextCtrl*) FindWindow(IDC_LOG_TEXT);

    if (mNextPtr == mTopPtr) {
        /*
         * The display array is full.
         *
         * We need to eliminate the topmost entry.  This requires removing
         * it from the array and removing the text from the wxTextCtrl.
         */
        pTextCtrl->Remove(0, mDisplayArray[mTopPtr]->GetTextCtrlLen());
        mDisplayArray[mTopPtr]->Release();
        mTopPtr = (mTopPtr + 1) % mMaxDisplayMsgs;
    }

    /*
     * Add formatted text to the text ctrl.  Track how much actual space
     * is required.  The space may be different on Win32 (CRLF-based) vs.
     * GTK (LF-based), so we need to measure it, not compute it from the
     * text string.
     */
    long lastBefore, lastAfter;
    //long insertBefore;
    //insertBefore = pTextCtrl->GetInsertionPoint();
    lastBefore = pTextCtrl->GetLastPosition();
    FormatMessage(pLogMessage, pTextCtrl);
    lastAfter = pTextCtrl->GetLastPosition();
    pLogMessage->SetTextCtrlLen(lastAfter - lastBefore);

    /*
     * If we restore the old insertion point, we will be glued to where
     * we were.  This is okay until we start deleting text from the top,
     * at which point we need to adjust it to retain our position.
     *
     * If we set the insertion point to the bottom, we effectively
     * implement "scroll to bottom on output".
     *
     * If we don't set it at all, we get slightly strange behavior out
     * of GTK, which seems to be par for the course here.
     */
    //pTextCtrl->SetInsertionPoint(insertBefore);     // restore insertion pt
    pTextCtrl->SetInsertionPoint(lastAfter);

    /* add it to array, claim ownership */
    mDisplayArray[mNextPtr] = pLogMessage;
    pLogMessage->Acquire();

    /* adjust pointers */
    if (mTopPtr < 0)        // first time only
        mTopPtr = 0;
    mNextPtr = (mNextPtr + 1) % mMaxDisplayMsgs;
}


/*
 * Return a human-readable string for the priority level.  Always returns
 * a valid string.
 */
static const wxCharBuffer GetPriorityString(android_LogPriority priority)
{
    int idx;

    idx = (int) priority - (int) ANDROID_LOG_VERBOSE;
    if (idx < 0 || idx >= NELEM(gLogLevels))
        return "?unknown?";
    return gLogLevels[idx].name.ToAscii();
}

/*
 * Format a message and write it to the text control.
 */
void LogWindow::FormatMessage(const LogMessage* pLogMessage,
    wxTextCtrl* pTextCtrl)
{
#if defined(HAVE_LOCALTIME_R)
    struct tm tmBuf;
#endif
    struct tm* ptm;
    char timeBuf[32];
    char msgBuf[256];
    int msgLen = 0;
    char* outBuf;
    char priChar;
    LogPrefsDialog::HeaderFormat headerFmt;

    headerFmt = mHeaderFormat;
    if (pLogMessage->GetInternal())
        headerFmt = LogPrefsDialog::kHFInternal;

    priChar = ((const char*)GetPriorityString(pLogMessage->GetPriority()))[0];

    /*
     * Get the current date/time in pretty form
     *
     * It's often useful when examining a log with "less" to jump to
     * a specific point in the file by searching for the date/time stamp.
     * For this reason it's very annoying to have regexp meta characters
     * in the time stamp.  Don't use forward slashes, parenthesis,
     * brackets, asterisks, or other special chars here.
     */
    time_t when = pLogMessage->GetWhen();
    const char* fmt = NULL;
#if defined(HAVE_LOCALTIME_R)
    ptm = localtime_r(&when, &tmBuf);
#else
    ptm = localtime(&when);
#endif
    switch (headerFmt) {
    case LogPrefsDialog::kHFFull:
    case LogPrefsDialog::kHFInternal:
        fmt = "%m-%d %H:%M:%S";
        break;
    case LogPrefsDialog::kHFBrief:
    case LogPrefsDialog::kHFMinimal:
        fmt = "%H:%M:%S";
        break;
    default:
        break;
    }
    if (fmt != NULL)
        strftime(timeBuf, sizeof(timeBuf), fmt, ptm);
    else
        strcpy(timeBuf, "-");

    const int kMaxExtraNewlines = 2;
    char hdrNewline[2];
    char finalNewlines[kMaxExtraNewlines+1 +1];

    if (mSingleLine)
        hdrNewline[0] = ' ';
    else
        hdrNewline[0] = '\n';
    hdrNewline[1] = '\0';

    assert(mExtraSpacing <= kMaxExtraNewlines);
    int i;
    for (i = 0; i < mExtraSpacing+1; i++)
        finalNewlines[i] = '\n';
    finalNewlines[i] = '\0';

    wxTextAttr msgColor;
    switch (pLogMessage->GetPriority()) {
    case ANDROID_LOG_WARN:
        msgColor.SetTextColour(*wxBLUE);
        break;
    case ANDROID_LOG_ERROR:
        msgColor.SetTextColour(*wxRED);
        break;
    case ANDROID_LOG_VERBOSE:
    case ANDROID_LOG_DEBUG:
    case ANDROID_LOG_INFO:
    default:
        msgColor.SetTextColour(*wxBLACK);
        break;
    }
    if (pLogMessage->GetInternal())
        msgColor.SetTextColour(*wxGREEN);

    /*
     * Construct a buffer containing the log header.
     */
    bool splitHeader = true;
    outBuf = msgBuf;
    switch (headerFmt) {
    case LogPrefsDialog::kHFFull:
        splitHeader = true;
        msgLen = android_snprintfBuffer(&outBuf, sizeof(msgBuf),
                    "[ %s %5d %c/%-6.6s]%s",
                    timeBuf, pLogMessage->GetPid(), priChar,
                    pLogMessage->GetTag(), hdrNewline);
        break;
    case LogPrefsDialog::kHFBrief:
        splitHeader = true;
        msgLen = android_snprintfBuffer(&outBuf, sizeof(msgBuf),
                    "[%s %5d]%s",
                    timeBuf, pLogMessage->GetPid(), hdrNewline);
        break;
    case LogPrefsDialog::kHFMinimal:
        splitHeader = false;
        msgLen = android_snprintfBuffer(&outBuf, sizeof(msgBuf),
                    "%s %5d- %s",
                    timeBuf, pLogMessage->GetPid(), pLogMessage->GetMsg());
        break;
    case LogPrefsDialog::kHFInternal:
        splitHeader = false;
        msgLen = android_snprintfBuffer(&outBuf, sizeof(msgBuf),
                    "[%s] %s", timeBuf, pLogMessage->GetMsg());
        break;
    default:
        fprintf(stderr, "Sim: unexpected header format %d\n", headerFmt);
        assert(false);
        break;
    }

    if (msgLen < 0) {
        fprintf(stderr, "WHOOPS\n");
        assert(outBuf == msgBuf);
        return;
    }

    if (splitHeader) {
        if (mUseColor)
            pTextCtrl->SetDefaultStyle(wxTextAttr(*wxLIGHT_GREY));
        pTextCtrl->AppendText(wxString::FromAscii(outBuf));
        if (mUseColor)
            pTextCtrl->SetDefaultStyle(msgColor);
        pTextCtrl->AppendText(wxString::FromAscii(pLogMessage->GetMsg()));
        if (mUseColor)
            pTextCtrl->SetDefaultStyle(*wxBLACK);
        pTextCtrl->AppendText(wxString::FromAscii(finalNewlines));
    } else {
        if (mUseColor)
            pTextCtrl->SetDefaultStyle(msgColor);
        pTextCtrl->AppendText(wxString::FromAscii(outBuf));
        if (mUseColor)
            pTextCtrl->SetDefaultStyle(*wxBLACK);
        pTextCtrl->AppendText(wxString::FromAscii(finalNewlines));
    }

    /* if we allocated storage for this message, free it */
    if (outBuf != msgBuf)
        free(outBuf);
}

/*
 * Write the message to the log file.
 *
 * We can't just do this in FormatMessage(), because that re-writes all
 * messages on the display whenever the output format or filter changes.
 *
 * Use a one-log-per-line format here to make "grep" useful.
 */
void LogWindow::LogToFile(const LogMessage* pLogMessage)
{
#if defined(HAVE_LOCALTIME_R)
    struct tm tmBuf;
#endif
    struct tm* ptm;
    char timeBuf[32];
    char msgBuf[256];
    int msgLen;
    char* outBuf;
    char priChar;

    assert(mLogFp != NULL);

    time_t when = pLogMessage->GetWhen();
#if defined(HAVE_LOCALTIME_R)
    ptm = localtime_r(&when, &tmBuf);
#else
    ptm = localtime(&when);
#endif

    strftime(timeBuf, sizeof(timeBuf), "%m-%d %H:%M:%S", ptm);
    priChar = ((const char*)GetPriorityString(pLogMessage->GetPriority()))[0];

    outBuf = msgBuf;
    if (pLogMessage->GetInternal()) {
        msgLen = android_snprintfBuffer(&outBuf, sizeof(msgBuf),
                    "[%s %5d *] %s\n",
                    timeBuf, pLogMessage->GetPid(), pLogMessage->GetMsg());
    } else {
        msgLen = android_snprintfBuffer(&outBuf, sizeof(msgBuf),
                    "[%s %5d %c] %s)\n",
                    timeBuf, pLogMessage->GetPid(), priChar,
                    pLogMessage->GetMsg());
    }
    if (fwrite(outBuf, msgLen, 1, mLogFp) != 1)
        fprintf(stderr, "Sim: WARNING: partial log write\n");
    fflush(mLogFp);

    /* if we allocated storage for this message, free it */
    if (outBuf != msgBuf)
        free(outBuf);
}

/*
 * Get the modification date of a file.
 */
static bool GetFileModDate(const char* fileName, time_t* pModWhen)
{
    struct stat sb;

    if (stat(fileName, &sb) < 0)
        return false;

    *pModWhen = sb.st_mtime;
    return true;
}

/*
 * Open or close the log file as appropriate.
 */
void LogWindow::PrepareLogFile(void)
{
    const int kLogFileMaxAge = 8 * 60 * 60;     // 8 hours

    if (!mWriteFile && mLogFp != NULL) {
        printf("Sim: closing log file\n");
        fclose(mLogFp);
        mLogFp = NULL;
    } else if (mWriteFile && mLogFp == NULL) {
        printf("Sim: opening log file '%s'\n", (const char*)mFileName.ToAscii());
        time_t now, modWhen = 0;
        const char* openFlags;

        now = time(NULL);
        if (!mTruncateOld ||
            (GetFileModDate(mFileName.ToAscii(), &modWhen) &&
             modWhen + kLogFileMaxAge > now))
        {
            if (modWhen != 0) {
                printf("--- log file is %.3f hours old, appending\n",
                    (now - modWhen) / 3600.0);
            }
            openFlags = "a";        // open for append (text mode)
        } else {
            if (modWhen != 0) {
                printf("--- log file is %.3f hours old, truncating\n",
                    (now - modWhen) / 3600.0);
            }
            openFlags = "w";        // open for writing, truncate (text mode)
        }

        mLogFp = fopen(mFileName.ToAscii(), openFlags);
        if (mLogFp == NULL) {
            fprintf(stderr, "Sim: failed opening log file '%s': %s\n",
                (const char*) mFileName.ToAscii(), strerror(errno));
        } else {
            fprintf(mLogFp, "\n\n");
            fflush(mLogFp);
        }
    }
}

/*
 * Add a new log message.
 *
 * This function can be called from any thread.  It makes a copy of the
 * stuff in "*pBundle" and sends it to the main UI thread.
 */
/*static*/ void LogWindow::PostLogMsg(const android_LogBundle* pBundle)
{
    LogMessage* pNewMessage = LogMessage::Create(pBundle);

    SendToWindow(pNewMessage);
}

/*
 * Post a simple string to the log.
 */
/*static*/ void LogWindow::PostLogMsg(const char* msg)
{
    LogMessage* pNewMessage = LogMessage::Create(msg);

    SendToWindow(pNewMessage);
}

/*
 * Post a simple wxString to the log.
 */
/*static*/ void LogWindow::PostLogMsg(const wxString& msg)
{
    LogMessage* pNewMessage = LogMessage::Create(msg.ToAscii());

    SendToWindow(pNewMessage);
}

/*
 * Send a log message to the log window.
 */
/*static*/ void LogWindow::SendToWindow(LogMessage* pMessage)
{
    if (pMessage != NULL) {
        wxWindow* pMainFrame = ((MyApp*)wxTheApp)->GetMainFrame();
        UserEventMessage* pUem = new UserEventMessage;
        pUem->CreateLogMessage(pMessage);

        UserEvent uev(0, (void*) pUem);

        pMainFrame->AddPendingEvent(uev);
    } else {
        fprintf(stderr, "Sim: failed to add new log message\n");
    }
}


/*
 * This is a sanity check.  We need to stop somewhere to avoid trashing
 * the system on bad input.
 */
#define kMaxLen 65536

#define VSNPRINTF vsnprintf     // used to worry about _vsnprintf


/*
 * Print a formatted message into a buffer.  Pass in a buffer to try to use.
 *
 * If the buffer isn't big enough to hold the message, allocate storage
 * with malloc() and return that instead.  The caller is responsible for
 * freeing the storage.
 *
 * Returns the length of the string, or -1 if the printf call failed.
 */
static int android_vsnprintfBuffer(char** pBuf, int bufLen, const char* format, va_list args)
{
    int charsOut;
    char* localBuf = NULL;

    assert(pBuf != NULL && *pBuf != NULL);
    assert(bufLen > 0);
    assert(format != NULL);

    while (1) {
        /*
         * In some versions of libc, vsnprintf only returns 0 or -1, where
         * -1 indicates the the buffer wasn't big enough.  In glibc 2.1
         * and later, it returns the actual size needed.
         *
         * MinGW is just returning -1, so we have to retry there.
         */
        char* newBuf;

        charsOut = VSNPRINTF(*pBuf, bufLen, format, args);

        if (charsOut >= 0 && charsOut < bufLen)
            break;

        //fprintf(stderr, "EXCEED: %d vs %d\n", charsOut, bufLen);
        if (charsOut < 0) {
            /* exact size not known, double previous size */
            bufLen *= 2;
            if (bufLen > kMaxLen)
                goto fail;
        } else {
            /* exact size known, just use that */

            bufLen = charsOut + 1;
        }
        //fprintf(stderr, "RETRY at %d\n", bufLen);

        newBuf = (char*) realloc(localBuf, bufLen);
        if (newBuf == NULL)
            goto fail;
        *pBuf = localBuf = newBuf;
    }

    // On platforms where snprintf() doesn't return the number of
    // characters output, we would need to call strlen() here.

    return charsOut;

fail:
    if (localBuf != NULL) {
        free(localBuf);
        *pBuf = NULL;
    }
    return -1;
}

/*
 * Variable-arg form of the above.
 */
static int android_snprintfBuffer(char** pBuf, int bufLen, const char* format, ...)
{
    va_list args;
    int result;

    va_start(args, format);
    result = android_vsnprintfBuffer(pBuf, bufLen, format, args);
    va_end(args);

    return result;
}