---

fltstpr.cpp

Go to the documentation of this file.

// $Id: fltstpr.cpp,v 1.2 2003/10/29 19:54:14 whitecf Exp $

//**********************************************************************
//                                                                     *
//    Description:   TurboVision float 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 "fltstpr.h"


using namespace Monitor::Utility;



FloatStepper::FloatStepper(const TRect&    newBounds,
                           int             newMaxLen,
                           const char*     newFormat,
                           const float     newDisplayScaler)
    :
    Watchable(),
    TInputLine(newBounds, newMaxLen),
    displayScaler(newDisplayScaler)
{
    _USEMYTRACE_("FloatStepper::FloatStepper"
                 "(newBounds, newMaxLen, newFormat, newDisplayScaler)")


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



FloatStepper::~FloatStepper()
{
    _USEMYTRACE_("FloatStepper::~FloatStepper()")


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



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

    TInputLine::setState(aState, enable);
}



void
FloatStepper::handleEvent(TEvent&    event)
{
    if (getState(sfFocused) && (evKeyDown == event.what))
    {
        switch (event.keyDown.keyCode)
        {
        case kbUp:
        case kbPlus:
        case kbGrayPlus:
            changeValue(value + 1.0);
            clearEvent(event);
            return;
        case kbDown:
        case kbMinus:
        case kbGrayMinus:
            changeValue(value - 1.0);
            clearEvent(event);
            return;
        case kbPgDn:
            changeValue(value - 10.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
FloatStepper::setScaler(const float     newDisplayScaler)
{
    _USEMYTRACE_("FloatStepper::setScaler(newDisplayScaler))")


    displayScaler = newDisplayScaler;
    displayValue();
}



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


    float    scaledValue = value * displayScaler;


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

    selectAll(False);
}



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


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



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


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



int
FloatStepper::setValue(float    newValue)
{
    _USEMYTRACE_("FloatStepper::setValue(newValue))")


    int    valueSet = 0;


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

    displayValue();

    return valueSet;
}



void
FloatStepper::changeValue(float    newValue)
{
    _USEMYTRACE_("FloatStepper::changeValue(newValue))")


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



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


    float    scaledValue = atof(data);


    scaledValue /= displayScaler;

    changeValue(scaledValue);
}

---