debugging_console_view.cpp

Go to the documentation of this file.

#ifndef DEBUGGING_CONSOLE_VIEW_IMPLEMENTATION_FILE
#define DEBUGGING_CONSOLE_VIEW_IMPLEMENTATION_FILE

/*****************************************************************************\
*                                                                             *
*  Name   : debugging_console_view                                            *
*  Author : Chris Koeritz                                                     *
*  Credits: Thanks to Andy Tan for initial help with OWL to MFC conversion    *
*                                                                             *
*******************************************************************************
* 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 "debugging_console_view.h"
#include "mfc_extensions.rh"

#include <basis/convert_utf.h>
#include <basis/istring.h>
#include <data_struct/amorph.cpp>

DECLARE_BUG_EVENT;
  // set the nasty variable for use in the message map.

BEGIN_MESSAGE_MAP(debugging_console_view, CEditView)
  //{{AFX_MSG_MAP(debugging_console_view)
  ON_WM_CREATE()
  ON_WM_CLOSE()
  ON_WM_SIZE()
  ON_WM_MOVE()
  ON_WM_SETFOCUS()
  ON_COMMAND(ID_FILE_PRINT, CEditView::OnFilePrint)
  ON_COMMAND(ID_FILE_PRINT_DIRECT, CEditView::OnFilePrint)
  ON_COMMAND(ID_FILE_PRINT_PREVIEW, CEditView::OnFilePrintPreview)
  //}}AFX_MSG_MAP
  ADD_DEBUGGER_MAP(display_debug_message)
END_MESSAGE_MAP()

IMPLEMENT_DYNCREATE(debugging_console_view, CEditView)

#undef LOG
#define LOG(s) CLASS_EMERGENCY_LOG(program_wide_logger(), s)


const int PRINTING_MARGIN = 2;
  // the space we leave blank on each side of printout.


class printed_page : public amorph<istring>
{
};

class printed_lines_list : public amorph<printed_page>
{
};


debugging_console_view::debugging_console_view(bool file_logging)
: CEditView(),
  debugging_base(GetEditCtrl(), debugging_base::MAX_BUFFER_SIZE,
      debugging_base::MAX_FILE_SIZE, file_logging),
  _printed(new printed_lines_list),
  _curr_page(0),
  _char_size_x(0),
  _char_size_y(0),
  _lines_per_page(0),
  _chars_per_line(0),
  _x_offset(0),
  _x_width(0)
{}

debugging_console_view::~debugging_console_view()
{
  WHACK(_printed);
}

LRESULT debugging_console_view::display_debug_message(WPARAM wp, LPARAM lp)
{
  display_message(wp, lp);
  return 0;
}

void debugging_console_view::OnUpdate(CView *pSender, LPARAM lHint,
    CObject *pHint)
{
  CEditView::OnUpdate(pSender, lHint, pHint);
  CDocument *pDoc = GetDocument();
  ASSERT_VALID(pDoc);
}

BOOL debugging_console_view::Create(LPCTSTR class_name, LPCTSTR title,
    DWORD win_style, const RECT &dimensions, CWnd *parent, UINT id,
    CCreateContext *context)
{
  // create the base class windows.
  if (!CEditView::Create(class_name, title, win_style, dimensions, parent,
      id, context))
    return 0;
  debugging_base::setup();

  // sets the limit on the size of the text buffer to be unlimited.
  GetEditCtrl().SetLimitText(0);

  // change to a fixed width font in the edit window.
  GetEditCtrl().SendMessage(WM_SETFONT, (WPARAM)GetStockObject
      (SYSTEM_FIXED_FONT), 0);

  return 1;
}

void debugging_console_view::hide()
{
  ShowWindow(SW_HIDE);
}

void debugging_console_view::show()
{ 
  ShowWindow(SW_RESTORE); 
  UpdateWindow();
}

bool debugging_console_view::is_hidden() const
{ return !IsWindowVisible(); }

bool debugging_console_view::is_visible() const
{ return !!IsWindowVisible(); }

int debugging_console_view::OnCreate(LPCREATESTRUCT lpcs)
{
  if (CEditView::OnCreate(lpcs) == -1) return -1;

  // set the icons for the window.
  HICON debugger_icon = LoadIcon(GET_INSTANCE_HANDLE(),
      MAKEINTRESOURCE(IDI_BUG));
  SetIcon(debugger_icon, true);  // set big icon.
  SetIcon(debugger_icon, false);  // set small icon.

  CDocument *pDoc = GetDocument();
  ASSERT_VALID(pDoc);

  return 0;
}

//consider removing these methods since they're no longer needed.

void debugging_console_view::OnClose()
{
  debugging_base::shut_down();
  CEditView::OnClose();
}

BOOL debugging_console_view::OnPreparePrinting(CPrintInfo *pInfo)
{
  FUNCDEF("OnPreparePrinting");
  LOG("entry");
  pInfo->SetMinPage(1);
  if (pInfo->m_bPreview) {
    // set the page to be viewed; for real printing we are handed this.
    pInfo->m_nCurPage = 1;
LOG(isprintf("*setting* current page to %d.", pInfo->m_nCurPage));
  }
  BOOL to_return = DoPreparePrinting(pInfo);
  LOG("exit");
  return to_return;
}

void debugging_console_view::OnBeginPrinting(CDC *pDC, CPrintInfo *pInfo)
{
  FUNCDEF("OnBeginPrinting");
  LOG("entry");

  CEditView::OnBeginPrinting(pDC, pInfo);

  _printed->reset();  // clean up existing print state.

pInfo->m_bContinuePrinting = true;

  // get font info.
  int font_height = -((pDC->GetDeviceCaps(LOGPIXELSY) * 10) / 72);
//hmmm: is that 72 lines imagined for the page???
  _print_font.CreateFont(font_height, 0, 0, 0, FW_NORMAL, 0, 0, 0,
      DEFAULT_CHARSET, OUT_CHARACTER_PRECIS, CLIP_CHARACTER_PRECIS,
      DEFAULT_QUALITY, DEFAULT_PITCH | FF_DONTCARE,
      to_unicode_temp("Courier New"));
  CFont *old_font = pDC->SelectObject(&_print_font);
    // use our printer font.

  TEXTMETRIC tm;
  pDC->GetTextMetrics(&tm);

  CSize size = pDC->GetTextExtent(to_unicode_temp("---------1---------"
      "2---------3---------4---------5---------6---------7---------8"), 80);
  _char_size_y = tm.tmHeight + tm.tmExternalLeading;
    // add in the size between rows.
  _char_size_x = size.cx / 80;
    // count on the dash and numbers being as big as any other chars.

  _x_offset = (pDC->GetDeviceCaps (HORZRES) - size.cx) / 2;
  _x_width = size.cx;

  // calculate how much we can fit on the page.
  _chars_per_line = (pDC->GetDeviceCaps(HORZRES) -
      (_char_size_x * (2 * PRINTING_MARGIN))) / _char_size_x;
  _lines_per_page = (pDC->GetDeviceCaps(VERTRES) -
      (_char_size_y * (3 + (2 * PRINTING_MARGIN)))) / _char_size_y;

LOG(isprintf("chars per line=%d and lines per page=%d", _chars_per_line, _lines_per_page).s());

  pDC->SelectObject(old_font);  // put old font back in.


/*
  // get the size of the printing region.
  int horiz = 0, vert = 0;
  CPrintDialog dlg(false);
  if (dlg.GetDefaults()) {
    CDC dc;
    dc.Attach (dlg.GetPrinterDC());
    horiz = pDC->GetDeviceCaps(HORZRES);
    vert = pDC->GetDeviceCaps(VERTRES);
  } else {
    MessageBox("No printers are available for this request.");
    return;
  }
*/

  // the following turns the document content into a series of pages.
  istring content;
  get_contents(content);
  istring accumulator;
  int line_number = 0;
  int current_page = 0;
  _printed->append(new printed_page);
  for (int i = 0; i < content.length(); i++) {
    if ( (content[i] != '\n') && (content[i] != '\r') )
      accumulator += content[i];
    if ( (content[i] == '\n') || (accumulator.length() >= _chars_per_line) ) {
      printed_page *page = _printed->borrow(current_page);
      page->append(new istring(accumulator));
      line_number++;
      accumulator = "";
      if (line_number >= _lines_per_page) {
        current_page++;
        _printed->append(new printed_page);
        line_number = 0;
      }
    }
  }
  if (accumulator.t()) {
    // get the last partial line into the printing.
    _printed->borrow(current_page)->append(new istring(accumulator));
  }

  pInfo->SetMaxPage(current_page + 1);
LOG(isprintf("largest page is %d", current_page + 1).s());

  LOG("exit");
}

void debugging_console_view::OnPrepareDC(CDC* pDC, CPrintInfo* pInfo)
{
  ASSERT_VALID(this);
  ASSERT_VALID(pDC);
  ASSERT(pInfo != NULL);  // overriding OnPaint -- never get this.

  pInfo->m_bContinuePrinting = (int(pInfo->m_nCurPage) <= _printed->elements());
/*
  if (pInfo->m_nCurPage > (UINT)m_aPageStart.GetSize() &&
      !PaginateTo(pDC, pInfo))
        {
                // can't paginate to that page, thus cannot print it.
                pInfo->m_bContinuePrinting = false;
        }
        ASSERT_VALID(this);
*/
}

void debugging_console_view::OnEndPrinting(CDC *pDC, CPrintInfo *pInfo)
{
  FUNCDEF("OnEndPrinting");
  LOG("entry");
  // reclaim our temporary font.
  CEditView::OnEndPrinting(pDC, pInfo);
  _print_font.DeleteObject();
  LOG("exit");
}

void debugging_console_view::print_header(CDC* pDC, UINT nPageNumber)
{
  CString strHeader = GetDocument ()->GetPathName();
  if (strHeader.GetLength () > 68)
    strHeader = GetDocument ()->GetTitle();

  CString strPageNumber;
//hmmm: need i18n here.
  strPageNumber.Format(to_unicode_temp("Page %d"), nPageNumber);

  UINT nSpaces = 80 - strPageNumber.GetLength () - strHeader.GetLength ();
  for (UINT i=0; i<nSpaces; i++)
    strHeader += ' ';
  strHeader += strPageNumber;

  UINT y = _char_size_y * PRINTING_MARGIN;
  CFont *pOldFont = pDC->SelectObject (&_print_font);
  pDC->TextOut(_x_offset, y, strHeader);

  y += (_char_size_y * 3) / 2;
  pDC->MoveTo(_x_offset, y);
  pDC->LineTo(_x_offset + _x_width, y);

  pDC->SelectObject (pOldFont);
}

void debugging_console_view::OnPrint(CDC *pDC, CPrintInfo *pInfo)
{
  FUNCDEF("OnPrint");
  LOG("entry");

LOG(isprintf("num pages is %d", pInfo->GetMaxPage()));

  ASSERT_VALID(pDC);
  _curr_page = pInfo->m_nCurPage;
  print_header(pDC, _curr_page);
pInfo->m_bContinuePrinting = true;
  OnDraw(pDC);
pInfo->m_bContinuePrinting = true;
  if (pInfo->m_bPreview) {
//    pInfo->m_nCurPage++;
  }

  LOG("exit");
}

void debugging_console_view::OnDraw(CDC *pDC)
{
  FUNCDEF("OnDraw");
  LOG("entry");
  CFont *pOldFont = pDC->SelectObject (&_print_font);

LOG(isprintf("current page is %d.", _curr_page).s());
  printed_page *page = _printed->borrow(_curr_page - 1);
  if (!page) {
LOG("no prepared page existed to show.");
    LOG("exit");
    pDC->SelectObject (pOldFont);
    return;
  }
  for (int i = 0; i < page->elements(); i++) {
    pDC->TextOut(PRINTING_MARGIN * _char_size_x,
        (3 + PRINTING_MARGIN) * _char_size_y + (i * _char_size_y),
        page->borrow(i)->s());
  }

  pDC->SelectObject (pOldFont);
  LOG("exit");
}


void debugging_console_view::OnSetFocus(CWnd *old_window)
{
  CEditView::OnSetFocus(old_window);
}

void debugging_console_view::OnMove(int x, int y)
{
  CEditView::OnMove(x, y);
}

void debugging_console_view::OnSize(UINT nType, int cx, int cy)
{
  CEditView::OnSize(nType, cx, cy);
}

/*
void debugging_console_view::OnFilePrint()
{
  CEditView::OnFilePrint();
}

void debugging_console_view::OnFilePrintPreview()
{
  CEditView::OnFilePrintPreview();
}
*/


#endif //DEBUGGING_CONSOLE_VIEW_IMPLEMENTATION_FILE

---