---

bytstpr.cpp

Go to the documentation of this file.

// $Id$

//**********************************************************************
//                                                                     *
//    Description:   TurboVision byte stepper 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_TEvent
#define Uses_TKeys

#include <stdio.h>
#include <stdlib.h>

#include <mytrace.h>

#include "bytstpr.h"


using namespace Monitor::Utility;



ByteStepper::ByteStepper(const TRect&    newBounds,
                         int             newMaxLen,
                         const char*     newFormat,
                         const float     newDisplayScaler)
    :
    Watchable(),
    TInputLine(newBounds, newMaxLen), maxValue(255), minValue(0),
    displayScaler(newDisplayScaler)
{
    _USEMYTRACE_("ByteStepper::ByteStepper"
                 "(newBounds, newMaxLen, newFormat, newDisplayScaler)")

    format = strdup(newFormat);
    setValue(0);
}



ByteStepper::~ByteStepper()
{
    _USEMYTRACE_("ByteStepper::~ByteStepper()")

    free(const_cast< char* >(format)), format = 0;
}



void
ByteStepper::setState(ushort    aState, Boolean    enable)
{
    if ((True != enable) && (sfFocused & aState))
    {
        displayValue();
    }

    TInputLine::setState(aState, enable);
}



void
ByteStepper::handleEvent(TEvent&    event)
{
    if (getState(sfFocused) && (evKeyDown == event.what))
    {
        switch (event.keyDown.keyCode)
        {
        case kbCtrlHome:
            changeValue(0xFF);
            clearEvent(event);
            return;
        case kbPgUp:
            if (255 > value)
            {
                changeValue(value + 16);
            }
            clearEvent(event);
            return;
        case kbUp:
        case kbPlus:
        case kbGrayPlus:
            if (255 > value)
            {
                changeValue(value + 1);
            }
            clearEvent(event);
            return;
        case kbDown:
        case kbMinus:
        case kbGrayMinus:
            if (0 < value)
            {
                changeValue(value - 1);
            }
            clearEvent(event);
            return;
        case kbPgDn:
            if (0 < value)
            {
                changeValue(value - 16);
            }
            clearEvent(event);
            return;
        case kbCtrlEnd:
            changeValue(0);
            clearEvent(event);
            return;
        case kbEnter:
            readValue();
            clearEvent(event);
            return;
        case kbEsc:
            *data = '\0';
            draw();
            selectAll(True);
            clearEvent(event);
            return;
        default:
            break;
        }
    }

    TInputLine::handleEvent(event);
}



void
ByteStepper::setScaler(const float     newDisplayScaler)
{
    _USEMYTRACE_("ByteStepper::setScaler(newDisplayScaler))")

    displayScaler = newDisplayScaler;
    displayValue();
}



void
ByteStepper::setMaxValue(const unsigned char    newMaxValue)
{
    _USEMYTRACE_("ByteStepper::setMaxValue(newMaxValue))")

    maxValue = newMaxValue;
    changeValue(value);
}



void
ByteStepper::setMinValue(const unsigned char    newMinValue)
{
    _USEMYTRACE_("ByteStepper::setMinValue(newMinValue))")

    minValue = newMinValue;
    changeValue(value);
}



void
ByteStepper::displayValue()
{
    _USEMYTRACE_("ByteStepper::displayValue()")

    float    scaledValue = value;

    scaledValue *= displayScaler;

    sprintf(data, format, scaledValue);
    draw();

    selectAll(False);
}



void
ByteStepper::getData(void    *rec)
{
    _USEMYTRACE_("ByteStepper::getData(rec)")

    *(static_cast< int* >(rec)) = value;
}



void
ByteStepper::setData(void    *rec)
{
    _USEMYTRACE_("ByteStepper::setData(rec)")

    changeValue(*(static_cast< int* >(rec)));
}



int
ByteStepper::setValue(int    newValue)
{
    _USEMYTRACE_("ByteStepper::setValue(newValue))")

    if (minValue > newValue)
    {
        newValue = minValue;
    }
    if (maxValue < newValue)
    {
        newValue = maxValue;
    }

    int    valueSet = 0;

    if (newValue != value)
    {
        value = newValue;
        valueSet = !0;
    }

    displayValue();

    return valueSet;
}



void
ByteStepper::changeValue(int    newValue)
{
    _USEMYTRACE_("ByteStepper::changeValue(newValue))")

    if (setValue(newValue))
    {
        updated();
    }
}



void
ByteStepper::readValue()
{
    _USEMYTRACE_("ByteStepper::readValue()")

    float    scaledValue = atof(data);

    scaledValue /= displayScaler;

    int newValue = scaledValue;

    changeValue(newValue);
}

---