wx_debugging_base.h

Go to the documentation of this file.

#ifndef WX_DEBUGGER_BASE_CLASS
#define WX_DEBUGGER_BASE_CLASS

/*****************************************************************************\
*                                                                             *
*  Name   : wx_debugging_base                                                 *
*  Author : Aaron Buchanan                                                    *
*  Author : Chris Koeritz                                                     *
*                                                                             *
*  Purpose:                                                                   *
*                                                                             *
*    A shared set of operations on edit controls that permits different       *
*  manners of creating and presenting the windows that really show the info.  *
*                                                                             *
*******************************************************************************
* 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_debugger.h"

#include <basis/log_base.h>
#include <basis/portable.h>

// forward.
class file_logger;
class uls;
class wxTextCtrl;

class WX_EXTENSIONS_CLASS_STYLE wx_debugging_base : public log_base
{
public:
  wx_debugging_base(wxTextCtrl &to_manipulate, int buffer_size = 2 * MEGABYTE,
          int file_size = int(1.2 * MEGABYTE));
    // the editor "to_manipulate" is managed by this object as the repository
    // for the debugging information.  the "buffer_size" is the maximum number
    // of characters allowed in the editor.  the size is ignored on w9x.

  virtual ~wx_debugging_base();

  IMPLEMENT_CLASS_NAME("wx_debugging_base");

  void setup();
    // this must be called when appropriate.  the wxTextCtrl must be a valid window
    // at the time this method is invoked.

  void shut_down();
    // prepares the object for destruction by closing down any networked
    // logging support.

  int current_length();
    // returns the current length of the edit buffer.

  // logs a message to the log file and window, as required by log_base.
  // it uses the current ending as set in our members.
  virtual outcome log(const istring &info, int filter = ALWAYS_PRINT);

  // logs a message to the logging file, if one exists, and allows the ending
  // to be specified separately.
  void log_ending(const istring &to_show, int filter = ALWAYS_PRINT,
          line_ending ending = CRLF_AT_END);

  void display_message(byte_array &message);
    // logging a message through the debugger after cracking it open

  // prints a message to the window and logs it.  this is just a synonym for
  // log() above.
  outcome print(const istring &to_show, int filter = ALWAYS_PRINT)
          { return log(to_show, filter); }

  istring name() const;
  void name(const istring &new_name);
    // allows the file name for logging to be observed or modified.

  int buffer_limit();
  void buffer_limit(int new_limit);
    // observes or modifies the limit on the buffer length.

  int file_limit() const;
  void file_limit(int new_limit);
    // allows the log file size limit to be observed or modified.

  void go_to_end();
    // causes the window to jump to the last line such that all future output
    // scrolls from there.

  bool get_contents(istring &to_fill);
    // returns the entire current contents of the window as a string.  true is
    // returned if we succeeded in getting the contents.

  bool get_selection(int &start, int &end);
    // returns the selection position for the edit window.  false is returned
    // if nothing is currently selected, although the "start" and "end" will
    // still be set correctly.

  void select(int start, int end);
    // selects the text in the window between "start" and "end" if possible.

  void reset();
    // clears all text out of the debugging console.

  wxTextCtrl &get_editor();
    // allows access to the lower-level object used for the editing window.

private:
  wxTextCtrl &_editor;  // the edit window object.
  int _length;
    // current length (our internal count; might not be accurate to exact
    // buffer contents).
  int _maximum_active_length;  
    // this is the point at which the information in the debugging window is
    // shortened.  the top chunk is clipped to ensure that the buffer doesn't
    // overflow (because there are varying results when this happens, depending
    // on the platform).
  int _file_limit;  // the maximum length the log file can attain.
  istring *_log_name;  // the name of the log file or stream.
#ifndef LIGHTLINK_CODEBASE
  file_logger *_the_log;  // handles logging to files.
#else
  uls *_the_log;  // handles logging to a uls stream.
#endif

  int locked_current_length();  // the real function, for internal use only.
};

#endif

---