tiny_shell.cpp

Go to the documentation of this file.

#ifndef TINY_SHELL_IMPLEMENTATION_FILE
#define TINY_SHELL_IMPLEMENTATION_FILE

/*****************************************************************************\
*                                                                             *
*  Name   : tiny_shell                                                        *
*  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 "debugging_console_window.h"
#include "tiny_shell.h"

#include <geometric/rectangle.cpp>
#include <geometric/screen_rectangle.h>
#include <opsystem/ini_config.h>
#include <opsystem/path_configuration.h>

using namespace geometric;

#define INI_NAME(root) (root + istring(".ini"))

#define LOG_NAME(root) (path_configuration::make_logfile_name(root + istring(".log")))

DECLARE_BUG_EVENT;


#define START_EXECUTION (WM_USER + 298)
  // a special event that is generated during window creation.  it allows us
  // to decouple the process for creation of the window from the execute()
  // method, which allows execute() to make assumptions about window validity.

BEGIN_MESSAGE_MAP(tiny_shell, CFrameWnd)
  //{{AFX_MSG_MAP(tiny_shell)
  ON_WM_CREATE()
  ON_WM_CLOSE()
  ON_WM_MOVE()
  ON_WM_SIZE()
  //}}AFX_MSG_MAP
  ON_MESSAGE(START_EXECUTION, do_execute)
  ADD_DEBUGGER_MAP(print_debug)
END_MESSAGE_MAP()


tiny_shell::tiny_shell(const istring &window_title, const istring &root,
    int file_size, const istring &logfile_name)
: CFrameWnd(), 
  application_shell(root),
  _console(new debugging_console_window(file_size)),
  _debug(new debugger(0, debugger::delayed)),
  _icon(NIL),
  _menu(NIL),
  _win_title(new istring(window_title)),
  _exiting(false),
  _held_logger(NIL),
  _logfile_name(new istring(logfile_name)),
  _execute_returned(0)
{}

tiny_shell::~tiny_shell()
{
  WHACK(_debug);
  WHACK(_console);
  WHACK(_win_title);
  WHACK(_logfile_name);
}

debugging_console_window &tiny_shell::console() const { return *_console; }

debugger &tiny_shell::debug() const { return *_debug; }

bool tiny_shell::good_version() const { return true; }

bool tiny_shell::Create()
{
  // get the window parameters...
  screen_rectangle win_size;
  CRect mfc_default = CFrameWnd::rectDefault;
  screen_rectangle default_size(mfc_default.TopLeft().x,
      mfc_default.TopLeft().y, mfc_default.BottomRight().x,
      mfc_default.BottomRight().y);
  istring tmp = ini().load(filename_root(), istring("window_size"),
      default_size.text_form());
  win_size.from_text(tmp);

  CRect size(win_size.top_left().x(), win_size.top_left().y(),
      win_size.bottom_right().x(), win_size.bottom_right().y());

  // create the base visual component of this object.
  if (!CFrameWnd::Create(NIL, to_unicode_temp(*_win_title),
      WS_OVERLAPPEDWINDOW, size, NIL, NIL, 0, NIL)) return false;

  return true;
}

void tiny_shell::OnSetFocus(CWnd *old_window)
{
  CFrameWnd::OnSetFocus(old_window);
  if (::IsWindow(_console->GetSafeHwnd())) _console->SetFocus();
}

afx_msg int tiny_shell::OnCreate(LPCREATESTRUCT lpCreateStruct) 
{
  if (CFrameWnd::OnCreate(lpCreateStruct) == -1) return -1;
  
  // create the debugging console.
  if (_logfile_name->t())
    _console->name(*_logfile_name);
  else
    _console->name(LOG_NAME(filename_root()));

  if (!_console->Create(NIL, to_unicode_temp(filename_root()
      + istring(" Console")), WS_CHILD, CFrameWnd::rectDefault, this, 0, NIL))
    return false;

  _console->show();

#ifndef OMIT_PROGRAM_WIDE_LOGGER
  // swap out the prior logger to send diagnostics to our window.
  _held_logger = retask_program_wide_logger(&debug());
#endif

  if (menu()) {
    _mfc_menu.LoadMenu(menu());
    SetMenu(&_mfc_menu);
  }

  if (icon()) {
    HICON tshell_icon = LoadIcon(AfxGetInstanceHandle(),
        MAKEINTRESOURCE(icon()));
    SetIcon(tshell_icon, false);  // set small icon.
    SetIcon(tshell_icon, true);  // set big icon.
  }

  // set up debugging window.
  _debug->reset_recipient(*_console);

  // post the special tiny shell message to cause the window to begin
  // executing its main activity.
  ::PostMessage(*this, START_EXECUTION, 0, 0);
  
  return 0;
}

afx_msg void tiny_shell::OnClose() 
{  
  FUNCDEF("OnClose");
  if (_exiting)
    non_continuable_error(class_name(), func, "exiting twice?  already trying to exit.");
  _exiting = true;  // set our flag to indicate we're leaving.
  if (!IsIconic()) {
    // save the window parameters...
    CRect rect;
    GetWindowRect(&rect);
    screen_rectangle win_size(rect.TopLeft().x, rect.TopLeft().y,
        rect.BottomRight().x, rect.BottomRight().y);
    ini().store(filename_root(), istring("window_size"), win_size.text_form());
  }

  if (menu()) {
    // Destroy the menu if there is one.
    _mfc_menu.DestroyMenu();
  }   

#ifndef OMIT_PROGRAM_WIDE_LOGGER
  log_base *ignore = retask_program_wide_logger(_held_logger);
    // ignore the returned log_base since it's destroyed elsewhere!
  _held_logger = NIL;
#endif

  CFrameWnd::OnClose();
}

afx_msg void tiny_shell::OnMove(int x, int y)
{
  CFrameWnd::OnMove(x, y);
  RECT client_size;
  GetClientRect(&client_size);
  _console->MoveWindow(&client_size);
}

afx_msg void tiny_shell::OnSize(u_int nType, int cx, int cy)
{
  CFrameWnd::OnSize(nType, cx, cy);
  if ( !(nType & SIZE_MINIMIZED) ) {
    // the sizing is not due to minimization.
    RECT client_size;
    GetClientRect(&client_size);
    _console->MoveWindow(&client_size);
  }
}

LRESULT tiny_shell::do_execute(WPARAM , LPARAM )
{
  _execute_returned = execute();
  return 0;
}

LRESULT tiny_shell::print_debug(WPARAM wparam, LPARAM lparam)
{
  if (_exiting) return 0;
  return _console->display_debug_message(wparam, lparam);
}

outcome tiny_shell::print(const istring &to_print)
{
  if (_exiting) return 0;
  return _debug->print(to_print);
}

outcome tiny_shell::log(const istring &to_print)
{
  if (_exiting) return 0;
  return _debug->log(to_print);
}


#endif //TINY_SHELL_IMPLEMENTATION_FILE

---