wx_debugging_base.cpp

Go to the documentation of this file.

#ifndef WX_DEBUGGING_BASE_IMPLEMENTATION_FILE
#define WX_DEBUGGING_BASE_IMPLEMENTATION_FILE

/*****************************************************************************\
*                                                                             *
*  Name   : wx_debugging_base                                                 *
*  Author : Aaron Buchanan                                                    *
*  Author : Chris Koeritz                                                     *
*                                                                             *
*******************************************************************************
* Copyright (c) 1995-$now By Author.  This program is free software; you can  *
* redistribute it and/or modify it under the terms of the GNU General Public  *
* License as published by the Free Software Foundation; either version 2 of   *
* the License or (at your option) any later version.  This is online at:      *
*     http://www.fsf.org/copyleft/gpl.html                                    *
* Please send any updates to: fred@gruntose.com                               *
\*****************************************************************************/

#include "wx_debugging_base.h"

#include <basis/convert_utf.h>
#include <basis/function.h>
#include <basis/istring.h>
#include <basis/version_record.h>
#include <data_struct/static_memory_gremlin.h>
#include <loggers/file_logger.h>
#ifdef LIGHTLINK_CODEBASE
  #include <uls/uls.h>
#endif

#undef GetClassInfo
#include <wx/textctrl.h>

using namespace portable;

//#define DEBUG_DEBUGGING
  // uncomment for the noisy version of the debugging support.

const u_int LENGTH_CHOP_FACTOR = 8192;
  // the amount clipped out of the window at one time.

//hmmm: make this a configurable parameter.
const int ULS_BUFFER_SIZE = 164 * KILOBYTE;
  // our uls stream size that's kept.

// some strings we'll make constant to avoid recreating all the time.
const wxString wxstring_crlf = to_unicode_wx("\r\n");
const wxString wxstring_lf = to_unicode_wx("\n");

#define DISABLE 
#define REENABLE 


wx_debugging_base::wx_debugging_base(wxTextCtrl &editor, int buffer_size, int file_size)
: log_base(),
  _editor(editor),
  _length(0),
  _maximum_active_length(0),
  _file_limit(0),
  _log_name(new istring),
  _the_log(NIL)
{
  buffer_limit(buffer_size);
  file_limit(file_size);
}

wx_debugging_base::~wx_debugging_base()
{
  shut_down();
  WHACK(_log_name);
}

int wx_debugging_base::buffer_limit() { return _maximum_active_length; }

void wx_debugging_base::buffer_limit(int new_limit)
{
  _maximum_active_length = new_limit;
}

int wx_debugging_base::file_limit() const { return _file_limit; }

//hmmm: if the file limit was zero and now it's not, we should
//      open anew the logger.
void wx_debugging_base::file_limit(int new_limit)
{
  _file_limit = new_limit;
  if (!_file_limit) {
    // no length means no output file.
    WHACK(_the_log);
  }
  if (_the_log) {
#ifndef LIGHTLINK_CODEBASE
    _the_log->limit(_file_limit);
#else
    _the_log->reopen(name(), _maximum_active_length, _file_limit);
#endif
  }
}

wxTextCtrl &wx_debugging_base::get_editor() { return _editor; }

istring wx_debugging_base::name() const { return *_log_name; }

void wx_debugging_base::name(const istring &new_name)
{
  *_log_name = new_name;
  if (!_log_name->t()) {
    // if no name, then no log file.
    WHACK(_the_log);
  }
  if (_the_log) {
#ifndef LIGHTLINK_CODEBASE
    _the_log->name(new_name);
#else
    _the_log->reopen(new_name, _maximum_active_length, _file_limit);
#endif
  }
}

void wx_debugging_base::setup()
{
  _editor.SetMaxLength(0);
    // the zero used to be documented in msdn, but no longer.  i think it's
    // intended to indicate that there's no fixed limit.

  if (_file_limit && _log_name->t()) {
#ifndef LIGHTLINK_CODEBASE
    _the_log = new file_logger(*_log_name, _file_limit);
#else
    _the_log = new uls(*_log_name, ULS_BUFFER_SIZE, _file_limit);
#endif
  }

}

void wx_debugging_base::shut_down()
{
  // reset our uls prior to program close.
  WHACK(_the_log);
}

bool wx_debugging_base::get_selection(int &start, int &end)
{
  DISABLE;
  long s, e;
  _editor.GetSelection(&s, &e);
  start = int(s);
  e = int(e);
  int curr = locked_current_length();
  if ( (start >= curr) && (end >= curr) ) {
    // the position is past where it could be a selection.
    REENABLE;
    return false;
  }
  REENABLE;
  return true;
}

void wx_debugging_base::select(int start, int end)
{
  DISABLE;
  _editor.SetSelection(start, end);
  REENABLE;
}

int wx_debugging_base::current_length()
{
  int to_return = 0;
  DISABLE;
  to_return = locked_current_length();
  REENABLE;
  return to_return;
}

int wx_debugging_base::locked_current_length()
{
  long old_start, old_end;
  _editor.GetSelection(&old_start, &old_end);
  _editor.SetSelection(-1, -1);  // force selection of all.
  long new_start, new_end;
  _editor.GetSelection(&new_start, &new_end);
  _editor.SetSelection(old_start, old_end);  // redo the old selection.
  int len = int(new_end - new_start);
  _length = len;  // reset our internal length, since they gave us the chance.
  return len;
}

void wx_debugging_base::log_ending(const istring &to_show,
    int filter, line_ending ending)
{
  line_ending temp = eol();
  eol(ending);
  log(to_show, filter);
  eol(temp);
}

outcome wx_debugging_base::log(const istring &to_show_in, int filter)
{
  DISABLE;
    // turn off the user's ability to mess with this for a bit.
  // show in edit window if the message's filter is in filter set.
  if (member(filter)) {
    // set the file_logger's line ending temporarily.
    if (_the_log) {
      line_ending temp = _the_log->eol();
      if (eol() == NO_ENDING) _the_log->eol(NO_ENDING);
      _the_log->log(to_show_in, ALWAYS_PRINT);  // override the filter.
      _the_log->eol(temp);  // reset the ending.
    }

    wxString to_show = to_unicode_wx(to_show_in);
      // create a malleable copy of the text.

    // process the text to fix CRs.
    // the wxTextCtrl needs to not have any CRs in it.
    to_show.Replace(wxstring_crlf, wxstring_lf);

    // line break for edit boxes is now added to the message:
    if (eol() != NO_ENDING)
      to_show += to_unicode_wx(get_ending());

    _editor.Freeze();  // turn off redraw during the update.

    // record any selection / cursor position before the changes.
    long sel_start, sel_end;
    _editor.GetSelection(&sel_start, &sel_end);
    bool at_end = (sel_start == sel_end) && (sel_end >= _length);  
        // was the cursor at the end of the thing?

#ifdef DEBUG_DEBUGGING
    to_show += istring(istring::SPRINTF, "<%d %d>:len=%d", sel_start,
        sel_end, _length);
    if (eol() != NO_ENDING) get_ending(to_show);
#endif

    // iterate over the string in chunks to ensure that the window doesn't
    // get choked up and that we never go over our allocation limit for huge
    // strings.
    while (to_show.length() > 0) {
      locked_current_length();  // make sure we get the correct current size.
      int num_to_show = minimum(512, int(to_show.length()));
      wxString chunk_to_show = to_show.Left(num_to_show);
      to_show = to_show.Mid(num_to_show);

      // check to make sure the edit buffer isn't getting too long...
      if (_length + int(chunk_to_show.length()) >= _maximum_active_length) {
        // oops, it's going to be too big.  chop a chunk.
        locked_current_length();  // get the real current size.
        int old_len = _length;  // record the old actual size.
        // when the length gets unmanageable, a chunk is chopped out.
        _editor.Remove(0, LENGTH_CHOP_FACTOR);
        locked_current_length();  // make sure we get the correct new size.
        int difference = old_len - _length;
        // ensure that the selection skips back too.
        sel_start -= difference;
        sel_end -= difference;
        if ( (sel_start < 0) || (sel_end < 0) ) {
          // if the selected area was whacked, reset at the front.
          sel_start = 0;
          sel_end = 0;
        }
      }
      _editor.AppendText(chunk_to_show);
      // we add to the length to record the new text.
      _length += int(chunk_to_show.length());
    }

    // reset the selection to the prior value.  if it was at the end, select
    // the new end.
    if (at_end) {
      sel_start = _length;
      sel_end = _length;
    }
    _editor.Thaw();   // allow drawing again.
    _editor.SetSelection(sel_start, sel_end);
  }
  REENABLE;
  return common::OKAY;
}

void wx_debugging_base::go_to_end()
{
  DISABLE;
  // make sure we know the real length.
  locked_current_length();
  // the edit box's text is selected at the last position.
  _editor.SetSelection(_length, _length);
  REENABLE;
}

bool wx_debugging_base::get_contents(istring &to_fill)
{
  DISABLE;
  to_fill = from_unicode_wx(_editor.GetValue());
  REENABLE;
  return true;
}

void wx_debugging_base::reset()
{
  DISABLE;
  _editor.Clear();
  locked_current_length();  // recalculate the length.
  REENABLE;
}

void wx_debugging_base::display_message(byte_array &message)
{
  line_ending ending;
  int filter;
  istring to_show = debugger::crack_debug_message((void *)&message, ending, filter);
  log_ending(to_show, filter, ending);
}

#endif //WX_DEBUGGING_BASE_IMPLEMENTATION_FILE

---