Subversion Repositories svn1-original

/*************************************************************************
*       Copyright (C) 1995 Embbedded Solutions
*                       All rights reserved
*
* file:     src\times.c
*
* purpose:  This module contains routines associated with the
*           time calculations
*
*           As the storage and display of a time is machine dependent so
*           these routines may need to be altered
*
* functions
*       time_a                  - Convert time to ascii
*       time_fa                 - Convert time to ascii
*       conv_time               - Convert hh,mm,ss to time
*       get_time                - Read/Edit time from user
*
* programmer: David Purdie
*
* revision  date        by      reason
*           17-Oct-88   DDP     Added new routine time_fa()
*   00.0    27/01/95    DDP     Tidies up the program and formatted the file
*   01.0    18/09/2005  DDP     Allow editing of time fields
*                               Simplied the conversion of text to time
*
**************************************************************************/

#include    <ctype.h>
#include    <time.h>
#include    "consts.h"
#include    "structs.h"
#include    "proto.h"

/*========================================================================
 *
 *  Convert time to ascii
 *
 *  Purpose:
 *      This routine will convert the time ( as held in tim ) into an ascii
 *      string. The address of the string is returned to the user. The
 *      string is internally static and is of a fixed format
 *
 *      The string format is
 *
 *      HH:MM:SS(null)  - if the time is valid.
 *      ** ** **(null)  - if the time is unknown
 * 
 *
 *  Parameters:
 *      tim         Time to convert
 *
 *  Returns:
 *      Address of an internal buffer that holds the ascii time
 *
 *========================================================================*/

char       *time_a( time_t tim )
{
    static char buf[] = "00:00:00";              /* Hold return string here */
    static char invalid[] = "** ** **";          /* Invalid string */

    time_t      hours, mins, secs;

    if( tim >= 0 && tim < 359999L )
    {
        hours = tim / 3600L;                     /* Calc the hours */
        tim -= hours * 3600L;                    /* secs left */
        mins = tim / 60L;
        tim -= mins * 60L;
        secs = tim;
        sprintf( buf, "%2.2ld:%2.2ld:%2.2ld", hours, mins, secs );
        return ( buf );
    }
    else
        return ( invalid );
}

/*========================================================================
 *
 *  Convert time to ascii
 *
 *  Purpose:
 *      This routine will convert the time ( as held in tim ) into an ascii
 *      string. The address of the string is returned to the user. The
 *      string is internally static and is of a fixed format
 *
 *      The string format is
 *
 *      HH:MM:SS(null)  - if the time is valid.
 *      -- -- --(null)  - if the time is unknown and "flag" is true
 *      ** ** **(null)  - if the time is unknown and flag is false
 *
 *
 *  Parameters:
 *      tim         Time to convert
 *      flag        Control display if time is not valid
 *                      TRUE  "-- -- --"
 *                      FALSE "** ** **"
 *
 *  Returns:
 *      Address of an internal buffer that holds the ascii time
 *
 *========================================================================*/

char       *time_fa( time_t tim, char flag )
{
    static char buf1[] = "00:00:00";             /* Hold return string here */
    static char finvalid[] = "** ** **";         /* Invalid string */
    static char tinvalid[] = "-- -- --";
    time_t      hours, mins, secs;

    if( tim >= 0 && tim < 359999L )
    {
        hours = tim / 3600L;                     /* Calc the hours */
        tim -= hours * 3600L;                    /* secs left */
        mins = tim / 60L;
        tim -= mins * 60L;
        secs = tim;
        sprintf( buf1, "%2.2ld:%2.2ld:%2.2ld", hours, mins, secs );
        return ( buf1 );
    }
    else if( flag )
    {
        return ( tinvalid );
    }
    else
    {
        return ( finvalid );
    }
}

/*========================================================================
 *
 *  Convert hh,mm,ss to time
 *
 *  Purpose:
 *      This function is convert hours, mins and seconds into the internal
 *      format of time
 *
 *  Parameters:
 *      hh          hours 0..
 *      mm          minutes 0..59
 *      ss          Seconds 0..59
 *
 *  Returns:
 *      Time
 *
 *========================================================================*/

time_t conv_time( int hh, int mm, int ss )
{
    time_t      time;                            /* The final result */

    time = ( ( ( time_t ) hh * 60L ) + ( time_t ) mm ) * 60L + ( time_t ) ss;
    return ( time );
}


/*========================================================================
 *
 *  Read/Edit time from user
 *
 *  Purpose:
 *      This function is called accept a time field from user and allow
 *      the operator to edit the time as it is entered.
 *
 *  Parameters:
 *      tim         - Time to edit
 *
 *  Returns:
 *      Time entered
 *      Will return an illegal time if the entry is not complete
 *
 *========================================================================*/

//time_t get_time(time_t utim)
//{
//    char        c;                              /* One of those */
//    int         i = 0;                          /* Counts user input */
//    int         maxi = 0;                       /* Max user input */
//    static char buf[] = "00:00:00";             /* Build up a string here */
//    static char max_digit[] = "29:59:59";       /* Maximum digit's allowed in entry */
//    int         hh = 0, mm = 0, ss = 0;

//    /*
//    **  Insert the base time into the edit buffer
//    **  Invalid times are treated as 00:00:00
//    */
//    if ( utim == -1L )
//    {
//        utim = 0;
//    }
    
//    {
//        char * ctime;
//        ctime = time_a(utim);
//        if ( ctime[0] != '*' )
//            memcpy( buf, ctime, sizeof(buf)-1);
//        else
//            memcpy( buf, "00:00:00", sizeof(buf)-1);
//    }

//    /*
//    **  Edit the string
//    */
//    while( TRUE )
//    {
//        c = getinp();
//        if( c == ABORT_CHAR )
//        {
//            i = 0;
//            break;
//        }
//        if( c == '\n' || c == '\t' )
//            break;

//        if( ( c == rubout ) && i > 0 )           /* rubout character */
//        {
//            i--;
//            if( max_digit[i] == ':' )
//            {
//                printf( "\010:\010" );
//                buf[i--] = ':';
//            }
//            buf[i] = '0';
//            printf( "\010" "0" "\010" );
//        }

//        else if ( (c == (char)LEFTARROW)  && i > 0 )
//        {
//            i--;
//            if( max_digit[i] == ':' )
//            {
//                printf( "\010" );
//                buf[i--] = ':';
//            }
//            printf( "\010" );
//        }

//        else if ( (c == (char)DELETE_KEY)  && i < 8 )
//        {
//            buf[i]='0';
//            printf( "0" "\010");
//        }

//        else if ( (c == (char)RIGHTARROW)  && i < 8 )
//        {
//            printf( "%c", buf[i++] );
//            if( max_digit[i] == ':' )
//            {
//                printf( ":" );
//                buf[i++] = ':';
//            }
//        }

//        else if( ( i < 9 ) && isascii( c ) && isdigit( c )
//                 && max_digit[i] >= c )
//        {
//            printf( "%c", c );
//            buf[i++] = c;
//            if( max_digit[i] == ':' )
//            {
//                printf( ":" );
//                buf[i++] = ':';
//            }
//        }
//        else
//        {
//            beep();
//        }

//        if ( i > maxi )
//            maxi = i;
//    }

//    if( maxi > 0 )
//    {
//        /*
//         * Parse the buffer extracting the required fields
//         */
//        if( sscanf( buf, "%d:%d:%d", &hh, &mm, &ss ) == 3 )
//        {
//            return ( conv_time( hh, mm, ss ) );
//        }
//    }
//    return ( ( time_t ) -1L );
//}

/********************************* EOF ***********************************/