---

bmapp.cpp

Go to the documentation of this file.

// $Id$

//**********************************************************************
//                                                                     *
//    Description:   'Bell Master' TurboVision application class.      *
//                                                                     *
//    Author:        Chris White (whitecf@bcs.org.uk)                  *
//                                                                     *
//    Copyright (C) 2003  Monitor Computing Services Ltd.              *
//                                                                     *
//    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 any later version.                            *
//                                                                     *
//    This program is distributed in the hope that it will be useful,  *
//    but WITHOUT ANY WARRANTY; without even the implied warranty of   *
//    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the    *
//    GNU General Public License for more details.                     *
//                                                                     *
//    You should have received a copy of the GNU General Public        *
//    License (http://www.gnu.org/copyleft/gpl.html) along with this   *
//    program; if not, write to:                                       *
//       The Free Software Foundation Inc.,                            *
//       59 Temple Place - Suite 330,                                  *
//       Boston, MA  02111-1307,                                       *
//       USA.                                                          *
//                                                                     *
//**********************************************************************
//                                                                     *
//    Notes:                                                           *
//                                                                     *
//**********************************************************************

#define Uses_MsgBox
#define Uses_TDeskTop
#define Uses_TEvent
#define Uses_TFileDialog
#define Uses_TKeys
#define Uses_TMenuBar
#define Uses_TMenuItem
#define Uses_TStatusDef
#define Uses_TStatusItem
#define Uses_TStatusLine
#define Uses_TSubMenu

#include <cstring.h>
#include <fstream.h>

#include <bcarchst.h>
#include <bclarch.h>
#include <bclist.h>
#include <bellcode.h>
#include <callback.h>
#include <lptnote.h>
#include <mytrace.h>
#include <pcbell.h>
#include <sgarchst.h>
#include <sgmlist.h>
#include <sgnlman.h>
#include <spkrnote.h>
#include <tapper.h>
#include <timeout.h>
#include <tmoutlst.h>

#include "bmcdwin.h"
#include "bmconst.h"
#include "bmsgwin.h"
#include "bmsplwin.h"
#include "bmsqwin.h"
#include "bmtprwin.h"


#include "bmapp.h"



using namespace Monitor::BellMaster;
namespace Ut = Monitor::Utility;



static LptNote        appLpt(1, 7);
static SpeakerNote    appSpeaker(587, 93);
static PcBell         localBell(appLpt);
static PcBell         remoteBell(appSpeaker);
static Tapper         localTapper(remoteBell);
static Tapper         remoteTapper(localBell);
static const char*    applicationVersion = "2.0";



class AppStatusLine : public TStatusLine
{
public:
    AppStatusLine(const TRect&    bounds, TStatusDef&    aDefs) :
        TStatusLine(bounds, aDefs)
        {
            _USEMYTRACE_("AppStatusLine::AppStatusLine")
        }

    virtual const char* hint(ushort aHelpCtx);
};



const char*
AppStatusLine::hint(ushort aHelpCtx)
{
    _USEMYTRACE_("AppStatusLine::hint")

    const char    *commandHint("Guess");

    switch (aHelpCtx)
    {
    case Const::hcLoadCodes:
    {
        commandHint = "Load bell codes from a file";
        break;
    }
    case Const::hcQuit:
    {
        commandHint = "Exit Bellmaster";
        break;
    }
    case Const::hcBeatCode:
    {
        commandHint = "Beat a bell code";
        break;
    }
    case Const::hcSignalmanRingCode:
    {
        commandHint = "Get a signalman to beat out a bell code";
        break;
    }
    case Const::hcLoadSignalman:
    {
        commandHint = "Load a signalman from a description file";
        break;
    }
    case Const::hcUnloadSignalman:
    {
        commandHint = "Remove a signalman from the simulation";
        break;
    }
    case Const::hcAbout:
    {
        commandHint = "Display Bell Master build information";
        break;
    }
    default:
    {
        commandHint = "";
        break;
    }
    }

    return commandHint;
}



App::App() :
  TProgInit(&App::initStatusLine,
            &App::initMenuBar,
            &App::initDeskTop),
  bellCodes(new BellCodeList), signalmen(new SignalmanList),
  listeningSignalman(0)
{
    _USEMYTRACE_("App::App")


    SplashWin*    splashWindow = new SplashWin(applicationVersion);

    new Ut::Timeout(Ut::DataCallback< App, TView* >(*this,
                                                    &App::closeModal,
                                                    splashWindow),
                    3000,
                    "close splash");

    TEvent    initialEvent;

    initialEvent.what            = evCommand;
    initialEvent.message.command = Const::cmDisplayModal;
    initialEvent.message.infoPtr = splashWindow;

    putEvent(initialEvent);

    loadBellCodesFromFile("default.bcd");
    loadSignalmanFromFile("default.sgm");
}



App::~App()
{
    _USEMYTRACE_("App::~App")

    delete bellCodes, bellCodes = 0;
    delete signalmen, signalmen = 0;
}



TStatusLine*
App::initStatusLine(TRect r)
{
    _USEMYTRACE_("App::initStatusLine")

  r.a.y = r.b.y - 1;
  return new AppStatusLine(r,
                           *new TStatusDef(0,-1) +
                           *new TStatusItem(0,
                                            kbF10,
                                            cmMenu));
}



TMenuBar*
App::initMenuBar(TRect    r)
{
    _USEMYTRACE_("App::initMenuBar")

  r.b.y = r.a.y + 1;
  return new TMenuBar(
    r,
    *new TSubMenu("~S~imulation",
                  kbAltS) +
        *new TMenuItem("E~x~it",
                       cmQuit,
                       kbAltX,
                       Const::hcQuit,
                       "Alt-X") +
    *new TSubMenu("~C~ode",
                  kbAltC) +
        *new TMenuItem("~B~eat",
                    Const::cmBeatCode,
                    kbAltB,
                    Const::hcBeatCode,
                    "Alt-B") +
        newLine() +
        *new TMenuItem("~L~oad",
                       Const::cmLoadCodes,
                       kbAltL,
                       Const::hcLoadCodes,
                       "Alt-L") +
    *new TSubMenu("Si~g~nalman",
                  kbAltG) +
        *new TMenuItem("~R~ing code",
                        Const::cmSignalmanRingCode,
                        kbAltR,
                        Const::hcSignalmanRingCode,
                        "Alt-R") +
        newLine() +
        *new TMenuItem("l~O~ad",
                        Const::cmLoadSignalman,
                        kbAltO,
                        Const::hcLoadSignalman,
                        "Alt-O") +
        *new TMenuItem("~U~nload",
                       Const::cmUnloadSignalman,
                       kbAltU,
                       Const::hcUnloadSignalman,
                       "Alt-U") +
    *new TSubMenu("~H~elp",
                  kbAltH) +
        *new TMenuItem("~A~bout",
                    Const::cmAbout,
                    kbAltA,
                    Const::hcAbout,
                    "Alt-A"));
}



void
App::handleEvent(TEvent&   event)
{
    TApplication::handleEvent(event);

    if (event.what == evCommand)
    {
        switch (event.message.command)
        {
        case Const::cmLoadCodes:
            loadBellCodeFile();
            break;
        case Const::cmBeatCode:
            beatBellCode(localTapper);
            break;
        case Const::cmSignalmanRingCode:
            signalmanRingCode(remoteTapper);
            break;
        case Const::cmLoadSignalman:
            loadSignalmanFile();
            break;
        case Const::cmUnloadSignalman:
            unloadSignalman();
            break;
        case Const::cmAbout:
            event.message.infoPtr = new SplashWin(applicationVersion);
        case Const::cmDisplayModal:
            showModal((TView*)event.message.infoPtr);
            break;
        default:
            return;
        }

        clearEvent(event);
    }
}



void
App::idle()
{
    TApplication::idle();

    TimeoutList::runTimeouts();
}



void
App::loadBellCodeFile()
{
    _USEMYTRACE_("App::loadBellCodeFile")

    TFileDialog*    fileDialog = new TFileDialog("*.bcd",
                                                 "Load localBell codes",
                                                 "Bell code file",
                                                 fdOpenButton,
                                                 0);

    if (cmCancel != deskTop->execView(fileDialog))
    {
        char    fileName[MAXPATH] = { '\0' };

        fileDialog->getFileName(fileName);

        loadBellCodesFromFile(fileName);
    }

    destroy(fileDialog);
}



void
App::loadBellCodesFromFile(const char*    fileName)
{
    _USEMYTRACE_("App::loadBellCodesFromFile")

    fstream    localBellCodeStream;

    localBellCodeStream.open(fileName, ios::in);

    if (localBellCodeStream.rdbuf()->is_open())
    {
        BellCodeArchiveStream
            localBellCodeArchive(localBellCodeStream);
        BellCodeListArchive 
            localBellCodeListArchive(localBellCodeArchive);

        localBellCodeListArchive.retrieve(*bellCodes);
    }
}



BellCode*
App::selectBellCode(BellCodeList    &availableCodes)
{
    _USEMYTRACE_("App::selectBellCode")

    BellCode    *selectedBellCode = 0;

    if (1 > availableCodes.size())
    {
        messageBox("There are no localBell codes available",
                   mfError | mfOKButton);
    }
    else
    {
        TRect    bounds = getExtent();
        TRect    r(bounds.a.x, bounds.a.y, bounds.b.x, bounds.b.y - 2);

        CodeWindow*    window = new CodeWindow(availableCodes, r);

        if (cmCancel != deskTop->execView(window))
        {
            selectedBellCode = window->getSelectedBellCode();
        }

        destroy(window);
    }

    return selectedBellCode;
}



void
App::beatBellCode(Tapper&    tapper)
{
    _USEMYTRACE_("App::beatBellCode(tapper)")


    TapperWin*    tapperWindow = new TapperWin(tapper);

    remoteBell.addListener(
        Ut::DataCallback< App, TapperWin* >(*this,
                                            &App::signalmanHearBell,
                                            tapperWindow));

    deskTop->execView(tapperWindow);

    destroy(tapperWindow);


    if (0 != listeningSignalman)
    {
        remoteBell.removeListener(listeningSignalman);

        const string
            heardSequence(listeningSignalman->stopListeningToBell());

        TRect    bounds = getExtent();
        TRect    r(bounds.a.x, bounds.a.y, bounds.b.x, bounds.b.y - 2);


        BellCodeList    matchingBellCodes =
            bellCodes->matchSequence(heardSequence);

        SequenceWindow*    window =
            new SequenceWindow(heardSequence, matchingBellCodes, r);

        if (cmOK == deskTop->execView(window))
        {
            listeningSignalman->beatSequence(remoteTapper,
                                             heardSequence);
        }

        destroy(window);

        listeningSignalman = 0;
    }
}



void
App::signalmanHearBell(TapperWin*    tapperWindow)
{
    _USEMYTRACE_("App::signalmanHearBell(tapperWindow)")

    listeningSignalman = selectSignalman(*signalmen);

    if ((0 != listeningSignalman) && (!listeningSignalman->isBusy()))
    {
        remoteBell.removeListener(this);

        listeningSignalman->listenToBell(
            remoteBell,
            Ut::DataCallback< App, TView* >(*this,
                                            &App::closeModal,
                                            tapperWindow));
    }
}



void
App::signalmanRingCode(Tapper&    tapper)
{
    _USEMYTRACE_("App::signalmanRingCode(tapper)")

    Signalman    *selectedSignalman = selectSignalman(*signalmen);

    if (0 != selectedSignalman)
    {
        BellCode    *selectedBellCode = selectBellCode(*bellCodes);

        if (0 != selectedBellCode)
        {
            selectedSignalman->beatSequence(tapper,
                                            selectedBellCode->getSequence());
        }
    }
}



void
App::loadSignalmanFile()
{
    _USEMYTRACE_("App::loadSignalmanFile")

    TFileDialog*    fileDialog = new TFileDialog("*.sgm",
                                                 "Load signalman",
                                                 "Signalman file",
                                                 fdOpenButton,
                                                 0);

    if (cmCancel != deskTop->execView(fileDialog))
    {
        char    fileName[MAXPATH] = { '\0' };

        fileDialog->getFileName(fileName);

        loadSignalmanFromFile(fileName);
    }

    destroy(fileDialog);
}



void
App::loadSignalmanFromFile(const char*    fileName)
{
    _USEMYTRACE_("App::loadSignalmanFromFile")

    fstream    signalmanStream;

    signalmanStream.open(fileName, ios::in);

    if (signalmanStream.rdbuf()->is_open())
    {
        SignalmanArchiveStream    signalmanArchive(signalmanStream);

        Signalman    retrievedSignalman;

        signalmanArchive.retrieve(retrievedSignalman);

        signalmen->addSignalman(retrievedSignalman);
    }
}



void
App::unloadSignalman()
{
    _USEMYTRACE_("App::unloadSignalman")

    Signalman    *selectedSignalman = selectSignalman(*signalmen);

    if (0 != selectedSignalman)
    {
        signalmen->removeSignalman(*selectedSignalman);
    }
}



Signalman*
App::selectSignalman(SignalmanList&    availableSignalmen)
{
    _USEMYTRACE_("App::selectSignalman")

    Signalman    *selectedSignalman = 0;

    if (1 > availableSignalmen.size())
    {
        messageBox("There are no signalmen available", mfError | mfOKButton);
    }
    else if (1 == availableSignalmen.size())
    {
        selectedSignalman = &availableSignalmen[0];
    }
    else
    {
        TRect    bounds = getExtent();
        TRect    r(bounds.a.x, bounds.a.y, bounds.b.x / 2, bounds.b.y / 2);

        SignalmanWindow*    window =
            new SignalmanWindow(availableSignalmen, r);

        if (cmCancel != deskTop->execView(window))
        {
            selectedSignalman = window->getSelectedSignalman();
        }

        destroy(window);
    }

    return selectedSignalman;
}



void
App::closeModal(TView*    oldView)
{
    _USEMYTRACE_("App::closeModal(oldView)")


    if (deskTop->TopView() == oldView)
    {
        oldView->endModal(cmCancel);
    }
}



void
App::showModal(TView*    newView)
{
    _USEMYTRACE_("App::showModal(newView)")


    deskTop->execView(newView);
    destroy(newView);
}

---