debugging_base.h

Go to the documentation of this file.

#ifndef DEBUGGING_BASE_CLASS
#define DEBUGGING_BASE_CLASS

/*****************************************************************************\
*                                                                             *
*  Name   : debugging_base_support                                            *
*  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 "mfc_dll.h"

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

// forward.
class file_logger;
class uls;

class MFC_EXTENSIONS_CLASS_STYLE debugging_base : public log_base
{
public:
  enum debugging_defaults {
    MAX_BUFFER_SIZE = 2 * MEGABYTE,
    MAX_FILE_SIZE = int(1.2 * MEGABYTE)
  };

  debugging_base(CEdit &to_manipulate, int buffer_size = MAX_BUFFER_SIZE,
          int file_size = MAX_FILE_SIZE, bool logging_to_file = false);
    // 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.
    // if "logging_to_file" is true, then the ULS will not be used and output
    // will simply be written to a file.

  virtual ~debugging_base();

  IMPLEMENT_CLASS_NAME("debugging_base");

  void setup(bool fixed_width = true);
    // this must be called when appropriate.  the CEdit must be a valid window
    // at the time this method is invoked.  the "fixed_width" flag specifies
    // if the text in the edit control should be changed to a fixed width font
    // (when flag is true) or if it should be left unchanged (flag is false).

  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);

  // 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, bool scroll = true);
    // selects the text in the window between "start" and "end" if possible.
    // if "scroll" is true, then the selected text is scrolled into view.

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

  // internal functions: messy but sometimes useful as public.

  #define DECLARE_BUG_EVENT 
  #define DEFINE_BUG_EVENT 
  #define ADD_DEBUGGER_MAP(to_invoke) \
       ON_REGISTERED_MESSAGE(debugger::EVENT(), to_invoke)
    // these macros can be used to hook a function to the debugging info event.
    // DEFINE_BUG_EVENT must be used before the message map for a window that
    // wants to handle these events.  it defines a variable used by the
    // ADD_DEBUGGER_MAP macro (which is required due to how mfc does registered
    // messages in the map).  the function "to_invoke" must have the form of
    // an ON_MESSAGE event handler like:
    //   LRESULT display_debug_message(WPARAM wparam, LPARAM lparam);
    // that method just needs to invoke the display_message() method below.

  void display_message(WPARAM wparam, LPARAM lparam);
    // prints the debugging information that is sent to a window.  this can
    // be invoked by windows that are receiving debugging messages.

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

  log_base &logging();
    // allows the underlying logging support to be accessed.

private:
  CEdit &_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.
  log_base *_the_log;  // our polymorphic logging support.
  bool _file_logging;  // true if we log to a file.

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

  bool get_contents_via_clipboard(istring &to_fill);
};

#endif

---