ODEdStr.c

/* OpenDoors Online Software Programming Toolkit
 * (C) Copyright 1991 - 1999 by Brian Pirie.
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2 of the License, or (at your option) any later version.
 *
 * This library 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
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with this library; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
 *
 *
 *        File: ODEdStr.c
 *
 * Description: Implementation of od_edit_str(). This is the advanced line
 *              editing function which requires ANSI or AVATAR graphics.
 *
 *   Revisions: Date          Ver   Who  Change
 *              ---------------------------------------------------------------
 *              Oct 13, 1994  6.00  BP   New file header format.
 *              Dec 09, 1994  6.00  BP   Standardized coding style.
 *              Dec 31, 1994  6.00  BP   Use ODTimerSleep() instead of loop.
 *              Aug 19, 1995  6.00  BP   32-bit portability.
 *              Nov 11, 1995  6.00  BP   Removed register keyword.
 *              Nov 16, 1995  6.00  BP   Removed oddoor.h, added odcore.h.
 *              Nov 17, 1995  6.00  BP   Use new input queue mechanism.
 *              Dec 12, 1995  6.00  BP   Added entry, exit and kernel macros.
 *              Dec 23, 1995  6.00  BP   Added EDIT_FLAG_SHOW_SIZE.
 *              Dec 30, 1995  6.00  BP   Added ODCALL for calling convention.
 *              Jan 04, 1996  6.00  BP   Use od_get_input().
 *              Jan 12, 1996  6.00  BP   Claim exclusive use of arrow keys.
 *              Jan 31, 1996  6.00  BP   Added timeout for od_get_input().
 *              Feb 10, 1996  6.00  BP   Fixed ...SHOW_SIZE /w ...PERMALITERAL.
 *              Feb 13, 1996  6.00  BP   Added od_get_input() flags parameter.
 *              Feb 19, 1996  6.00  BP   Changed version number to 6.00.
 *              Mar 03, 1996  6.10  BP   Begin version 6.10.
 *              Apr 08, 1996  6.10  BP   Make 'C' use word capitalization.
 *              Aug 10, 2003  6.23  SH   *nix support
 */

#define BUILDING_OPENDOORS

#include <ctype.h>
#include <stddef.h>
#include <string.h>

#include "OpenDoor.h"
#include "ODCore.h"
#include "ODGen.h"
#include "ODPlat.h"
#include "ODKrnl.h"
#include "ODStat.h"


/* Current od_edit_str() state and settings. */
static INT anCurrentFormatOffset[80];
static BOOL abCurrentFormatLiteral[80];
static char szCurrentOriginalString[81];
static char *pszCurrentInput;
static char *pszCurrentFormat;
static unsigned char nCurrentStringLength;
static char chCurrentBlank;


/* Private helper functions used by od_edit_str(). */
static BOOL ODEditIsCharValidForPos(char chEntered, INT nPosition);
static char ODEditAsCharForPos(char chEntered, INT nPosition);
static void ODEditDisplayPermaliteral(WORD nFlags);


/* ----------------------------------------------------------------------------
 * od_edit_str()
 *
 * Provides more advanced editing capabilities than od_get_str(), requiring
 * ANSI, AVATAR or RIP modes.
 *
 * Parameters: pszInput          - Pointer to string where inputted text is
 *                                 stored.
 *
 *             pszFormat         - Pointer to format string, which specifies
 *                                 the format of inputted text.
 *
 *             nRow              - The row number where the input field should
 *                                 begin.
 *
 *             nColumn           - The column number where the input field
 *                                 should begin.
 *
 *             btNormalColour    - Color of normal text.
 *
 *             btHighlightColour - Color of highlighted text.
 *
 *             chBlank           - Character to display blanks with.
 *
 *             nFlags            - Specifies one or more flags, combined with
 *                                 the bitwise-or operator.
 *
 *     Return: One of a number of possible EDIT_RETURN_ values, which indicate
 *             why the function returned.
 */
ODAPIDEF WORD ODCALL od_edit_str(char *pszInput, char *pszFormat, INT nRow,
   INT nColumn, BYTE btNormalColour, BYTE btHighlightColour,
   char chBlank, WORD nFlags)
{
   char chTemp;
   unsigned int nCount;
   unsigned char chCurrentValue;
   char *pchCurrent;
   unsigned int nCursorPos;
   INT nKeysPressed = 0;
   WORD wToReturn;
   BOOL bInsertMode = TRUE;
   char chAddAtEnd = '\0';
   BOOL bNormal = TRUE;
   tODInputEvent InputEvent;

   /* Log function entry if running in trace mode */
   TRACE(TRACE_API, "od_edit_str()");

   /* Verify that OpenDoors has been initialized. */
   if(!bODInitialized) od_init();

   OD_API_ENTRY();

   /* Store pointers to current input string and current format string. */
   pszCurrentInput=(char *)pszInput;
   pszCurrentFormat=(char *)pszFormat;

   /* Check that the parameters passed in are valid. */
   if(pszCurrentInput == NULL || pszCurrentFormat == NULL || nRow < 1
      || nColumn < 1)
   {
      od_control.od_error = ERR_PARAMETER;
      OD_API_EXIT();
      return(EDIT_RETURN_ERROR);
   }

   /* Initially, the maximum length of input string is 0. */
   nCurrentStringLength = 0;

   /* The type that is being examined. */
   chCurrentValue = 0;

   /* Counter of position in format string. */
   nCount = 0;

   /* Loop until we reach the end fo the format string. */
   for(pchCurrent = pszCurrentFormat; *pchCurrent;)
   {
      /* Get next character from format string. */
      chTemp = *pchCurrent++;

      /* If current character is not a literal value. */
      if(chCurrentValue == '\0')
      {
         /* If format string has " or ' characters, then this is the */
         /* beginning of a literal string.                           */
         if(chTemp == 39 || chTemp == 34)
         {
            chCurrentValue = chTemp;
         }

         /* If this is not a literal character, and not a space character... */
         else if(chTemp != 32)
         {
            /* Check that we haven't exceeded the maximum allowable string */
            /* length.                                                     */
            if(nCurrentStringLength >= 80)
            {
               od_control.od_error = ERR_PARAMETER;
               OD_API_EXIT();
               return(EDIT_RETURN_ERROR);
            }

            /* Record format character's position. */
            anCurrentFormatOffset[nCurrentStringLength] = nCount;

            /* Record that this character is not a literal. */
            abCurrentFormatLiteral[nCurrentStringLength] = FALSE;

            /* Increment length of input string. */
            ++nCurrentStringLength;
         }
      }

      /* If this is a literal character. */
      else
      {
         /* Check for end of literal string. */
         if(chTemp == chCurrentValue)
         {
            /* If found, stop literal string processing */
            chCurrentValue = '\0';
         }
         else
         {
            /* Check that we haven't exceeded the maximum allowable string */
            /* length.                                                     */
            if(nCurrentStringLength >= 80)
            {
               od_control.od_error = ERR_PARAMETER;
               OD_API_EXIT();
               return(EDIT_RETURN_ERROR);
            }

            /* Record character's position. */
            anCurrentFormatOffset[nCurrentStringLength] = nCount;

            /* Record that character IS a literal value. */
            abCurrentFormatLiteral[nCurrentStringLength] = TRUE;

            /* Increment length of input string. */
            ++nCurrentStringLength;
         }
      }

      /* Increment format string position. */
      ++nCount;
   }

   /* Check that there is at least one character permitted in the input */
   /* string. If not, return with a parameter error.                    */
   if(nCurrentStringLength==0)
   {
      od_control.od_error = ERR_PARAMETER;
      OD_API_EXIT();
      return(EDIT_RETURN_ERROR);
   }

   /* If editing an existing string. */
   if(nFlags & EDIT_FLAG_EDIT_STRING)
   {
      /* Check for valid existing input string. */
      if(strlen(pszCurrentInput) > nCurrentStringLength)
      {
         pszCurrentInput[nCurrentStringLength] = '\0';
      }

      /* Start with cursor at the end of the string. */
      nCursorPos = strlen(pszCurrentInput);
   }

   /* If we are not editing an existing string. */
   else
   {
      /* Blank-out current string contents. */
      pszCurrentInput[0] = '\0';

      /* Set cursor to beginning of string. */
      nCursorPos = 0;
   }

   /* Store original string, in case user cancels. */
   strcpy(szCurrentOriginalString,pszCurrentInput);

   /* Set appropriate text color. */
   od_set_attrib(btHighlightColour);

   /* Determine appropriate blank character */
   chCurrentBlank = (nFlags & EDIT_FLAG_PASSWORD_MODE) ? ' ' : chBlank;

   /* Turn off insert mode if the strict input or permaliteral flags were */
   /* specified.                                                          */
   if((nFlags & EDIT_FLAG_STRICT_INPUT) || (nFlags & EDIT_FLAG_PERMALITERAL))
   {
      bInsertMode = FALSE;
   }

   /* If the no-initial-redraw flag is not set, then do initial redraw. */
   if(!(nFlags & EDIT_FLAG_NO_REDRAW))
   {
      /* Set to redraw position. */
      od_set_cursor(nRow, nColumn);

      if(nFlags & EDIT_FLAG_PASSWORD_MODE)
      {
         /* If we are in password mode, then just draw password blanks. */
         od_repeat(chBlank, (BYTE)strlen(pszCurrentInput));
      }
      else
      {
         /* Otherwise, display the actual string. */
         od_disp_str(pszCurrentInput);
      }

      if(nFlags & EDIT_FLAG_PERMALITERAL)
      {
         /* If we are in permaliteral mode, then fill the remaining edit */
         /* field with the literal characters.                           */
         ODEditDisplayPermaliteral(nFlags);
      }
      else
      {
         /* Otherwise, fill the remaining edit field with the blank */
         /* character.                                              */
         BYTE btRemaining
            = (BYTE)(nCurrentStringLength - strlen(pszCurrentInput));
         if(!(nFlags & EDIT_FLAG_SHOW_SIZE)) ++btRemaining;
         od_repeat(chCurrentBlank, btRemaining);
      }
   }

   /* Claim exclusive use of arrow keys. */
   ODStatStartArrowUse();

   /* Set the cursor to appropriate position. */
   od_set_cursor(nRow, nColumn + nCursorPos);

   /* Normally, we start the input loop at the keep_going tag. */
   if(bNormal) goto keep_going;

   for(;;)
   {
      /* If auto-accept mode has been specified ... */
      if(nFlags & EDIT_FLAG_AUTO_ENTER)
      {
         /* ... then check whether we have reached the end of the string. */
         if(strlen(pszCurrentInput) == nCurrentStringLength)
         {
            /* Indicate that input has been accepted, rather than cancelled. */
            wToReturn = EDIT_RETURN_ACCEPT;

            /* Return the current string to the caller, if it is valid. */
            goto try_to_accept;
         }
      }

keep_going:
      /* Check whether we have reached a literal character in permaliteral */
      /* mode. If so, we will move past the permanent literal characters   */
      /* automatically.                                                    */
      if((nFlags & EDIT_FLAG_PERMALITERAL)
         && (nCursorPos < nCurrentStringLength))
      {
         if(abCurrentFormatLiteral[nCursorPos])
         {
            if(nCursorPos < strlen(pszCurrentInput))
            {
               goto pressed_right_arrow;
            }
            chTemp = pszCurrentFormat[anCurrentFormatOffset[nCursorPos]];
            ++nKeysPressed;
            goto try_this_character;
         }
      }

get_another_key:
      /* Block, waiting for the next key pressed by the user. */

      od_get_input(&InputEvent, OD_NO_TIMEOUT, GETIN_NORMAL);
      
      /* Increment total number of keystrokes. */
      ++nKeysPressed;

      if(InputEvent.EventType == EVENT_EXTENDED_KEY)
      {
         switch(InputEvent.chKeyPress)
         {
            case OD_KEY_UP:
            case OD_KEY_SHIFTTAB:
               if(nFlags & EDIT_FLAG_FIELD_MODE)
               {
                  wToReturn = EDIT_RETURN_PREVIOUS;
                  goto try_to_accept;
               }
               break;

            case OD_KEY_DOWN:
pressed_down_arrow:
               if(nFlags & EDIT_FLAG_FIELD_MODE)
               {
                  wToReturn = EDIT_RETURN_NEXT;
                  goto try_to_accept;
               }
               break;

            case OD_KEY_RIGHT:
pressed_right_arrow:
               /* If we are not at the end of the string. */
               if(nCursorPos < strlen(pszCurrentInput))
               {
                  /* Move input position right. */
                  nCursorPos++;

                  /* Move the cursor on screen. */
                  od_set_cursor(nRow, nColumn + nCursorPos);
               }
               if(chAddAtEnd)
               {
                  chAddAtEnd = 0;
                  goto add_another_key;
               }
               break;

            case OD_KEY_LEFT:
pressed_left_arrow:
               /* If we are not at the beginning of the string. */
               if(nCursorPos > 0)
               {
                  /* Move input position left. */
                  nCursorPos--;

                  /* Move cursor on screen. */
                  od_set_cursor(nRow, nColumn + nCursorPos);
               }

               /* If we are moving past a permanent literal character, */
               /* then continue moving further left, if possible.      */
               if((nFlags & EDIT_FLAG_PERMALITERAL)
                  && abCurrentFormatLiteral[nCursorPos] && nCursorPos > 0)
               {
                  goto pressed_left_arrow;
               }
               break;

         case OD_KEY_HOME:
            /* If we are not at the beginning of the string. */
            if(nCursorPos != 0)
            {
               /* Move input position to the beginning of the string. */
               nCursorPos = 0;

               /* Move the cursor on the screen. */
               od_set_cursor(nRow, nColumn);
            }
            break;

         case OD_KEY_END:
            /* If we are not at the end of the string .*/
            if(nCursorPos != strlen(pszCurrentInput))
            {
               /* Set the input position to the end of the string. */
               nCursorPos=strlen(pszCurrentInput);

               /* Move cursor on screen. */
               od_set_cursor(nRow,nColumn+nCursorPos);
            }
            break;

         case OD_KEY_DELETE:
pressed_delete:
            /* Check whether delete key is permitted at this time. */
            if(!(nFlags & EDIT_FLAG_STRICT_INPUT)
               && nCursorPos < strlen(pszCurrentInput)
               && !(nFlags & EDIT_FLAG_PERMALITERAL))
            {
               /* Move remaining line, if any, to the left */
               chCurrentValue = strlen(pszCurrentInput) - 1;
               for(nCount = nCursorPos; nCount < chCurrentValue; ++nCount)
               {
                  od_putch(
                     pszCurrentInput[nCount] = pszCurrentInput[nCount + 1]);
               }

               /* Erase the last character. */
               pszCurrentInput[chCurrentValue] = '\0';  

               /* Blank out last character. */
               od_putch(chCurrentBlank);

               /* Move the cursor on the screen. */
               od_set_cursor(nRow, nColumn + nCursorPos);

               /* Update changes to string. */
               goto check_cursor_char;
            }
            break;

         case OD_KEY_INSERT:
            if(!(nFlags & EDIT_FLAG_STRICT_INPUT)
               && !(nFlags & EDIT_FLAG_PERMALITERAL))
            {
               /* Toggle insert setting. */
               bInsertMode = !bInsertMode;
            }
            break;

         }
      }
      else if(InputEvent.EventType == EVENT_CHARACTER)
      {
         chTemp = InputEvent.chKeyPress;
try_this_character:

         if(chTemp == 27)
         {
            /* If cancel key is allowed ... */
            if(nFlags & EDIT_FLAG_ALLOW_CANCEL)
            {
               /* Reset the input string to the original contents. */
               strcpy(pszCurrentInput, szCurrentOriginalString);

               /* Indicate that return reason was due to user cancelling. */
               wToReturn = EDIT_RETURN_CANCEL;

               /* Return after redrawing the original string in the input */
               /* field.                                                  */
               goto exit_and_redraw;
            }
         }


         /* If user pressed [Enter] or [Ctrl]-[Z]. */
         else if(chTemp == 13 || chTemp == 26)
         {
            /* User has accepted input. */
            wToReturn = EDIT_RETURN_ACCEPT;

            /* Return if input string is valid. */
            goto try_to_accept;
         }

         /* If the backspace key has been pressed. */
         else if(chTemp == 8)
         {
   backspace_again:
            /* If we are not already at the beginning of the string. */
            if(nCursorPos > 0)
            {
               if(nFlags & EDIT_FLAG_PERMALITERAL)
               {
                  for(nCount = 0;nCount < nCursorPos; ++nCount)
                  {
                     if(!abCurrentFormatLiteral[nCount]) goto continue_deletion;
                  }
                  goto get_another_key;
               }

   continue_deletion:
               /* If we are at the end of the string. */
               if(nCursorPos == strlen(pszCurrentInput))
               {
                  /* Erase last char in string. */
                  pszCurrentInput[--nCursorPos] = '\0';

                  if((nFlags & EDIT_FLAG_PERMALITERAL)
                     && abCurrentFormatLiteral[nCursorPos])
                  {
                     goto backspace_again;
                  }
                  else
                  {
                     /* Move to new cursor pos. */
                     od_set_cursor(nRow,nColumn+nCursorPos);

                     /* Blank old character. */
                     od_putch(chCurrentBlank);

                     /* Move again to cursor pos. */
                     od_set_cursor(nRow,nColumn+nCursorPos);
                  }
               }

               /* If we are in the middle of the string and we are not in */
               /* string input mode.                                      */
               else if(!(nFlags & EDIT_FLAG_STRICT_INPUT)
                  && !(nFlags & EDIT_FLAG_PERMALITERAL))
               {
                  /* Move cursor left. */
                  --nCursorPos;

                  /* Move cursor on screen. */
                  od_set_cursor(nRow, nColumn + nCursorPos);

                  /* Goto standard delete handler. */
                  goto pressed_delete;
               }
            }
         }

         /* If this is a next field request. */
         else if(chTemp == 9)
         {
            /* Goto down arrow handler. */
            goto pressed_down_arrow;
         }

         /* If Control-Y. */
         else if(chTemp == 25)
         {
            /* Erase entire contents of line. */
            goto kill_whole_line;
         }

         else
         {
            /* If this is the first key pressed, and we are in autodelete mode. */
            if(nKeysPressed == 1 && (nFlags & EDIT_FLAG_AUTO_DELETE))
            {
   kill_whole_line:
               /* If string is not empty. */
               if(strlen(pszCurrentInput) != 0)
               {
                  /* Move to beginning of string. */
                  od_set_cursor(nRow,nColumn);

                  /* Blank out the entire string contents. */
                  od_repeat(chCurrentBlank, (BYTE)strlen(pszCurrentInput));
               }

               /* Move to new cursor position. */
               od_set_cursor(nRow,nColumn);

               /* Update insert position. */
               nCursorPos = 0;

               /* Blank out the current string contents. */
               pszCurrentInput[0] = '\0';
            }

   add_another_key:
            if(!ODEditIsCharValidForPos(chTemp,nCursorPos))
            {
               /* If character is not a valid input char. */
               if(abCurrentFormatLiteral[nCursorPos])
               {
                  if(nCursorPos < strlen(pszCurrentInput))
                  {
                     if(pszCurrentInput[nCursorPos] == 
                        pszCurrentFormat[anCurrentFormatOffset[nCursorPos]])
                     {
                        chAddAtEnd = chTemp;
                        goto pressed_right_arrow;
                     }
                  }
                  chAddAtEnd = chTemp;
                  chTemp = pszCurrentFormat[anCurrentFormatOffset[nCursorPos]];
               }
               else
               {
                  continue;
               }
            }

            /* Convert character to correct value, if applicable. */
            chTemp = ODEditAsCharForPos(chTemp, nCursorPos);

            /* If we are at end of string. */
            if(nCursorPos >= strlen(pszCurrentInput))
            {
               /* Reset original cursor position */
               nCursorPos = strlen(pszCurrentInput);

               /* If there is room to add a char. */
               if(nCursorPos < nCurrentStringLength)
               {
                  /* If password mode */
                  if(nFlags & EDIT_FLAG_PASSWORD_MODE)
                  {
                     /* Display the password character. */
                     od_putch(chBlank);
                  }
                  /* If not in password mode. */
                  else
                  {
                     /* Display the character. */
                     od_putch(chTemp);
                  }

                  /* Store the character. */
                  pszCurrentInput[nCursorPos] = chTemp;

                  /* Add a new string terminator. */
                  pszCurrentInput[++nCursorPos] = '\0';
               }
            }

            /* If in insert mode, but not at end of string. */
            else if(bInsertMode)
            {
               /* If room in string. */
               if(strlen(pszCurrentInput) < nCurrentStringLength)
               {
                  /* If in password mode. */
                  if(nFlags & EDIT_FLAG_PASSWORD_MODE)
                  {
                     /* Move to end. */
                     od_set_cursor(nRow,nColumn+strlen(pszCurrentInput));

                     /* Add another password character. */
                     od_putch(chBlank);
                  }

                  /* If not in password mode. */
                  else
                  {
                     /* Display the new character. */
                     od_putch(chTemp);

                     /* Loop through rest of string. */
                     for(nCount = nCursorPos; nCount < strlen(pszCurrentInput);
                        ++nCount)
                     {
                        /* Display the next remaining character. */
                        od_putch(pszCurrentInput[nCount]);
                     }
                  }

                  pszCurrentInput[(strlen(pszCurrentInput) + 1)] = '\0';

                  /* Sift remaining characters forward. */
                  for(nCount = strlen(pszCurrentInput); nCount > nCursorPos;
                     --nCount)
                  {                     
                     pszCurrentInput[nCount] = pszCurrentInput[nCount-1];
                  }

                  /* Add new char in space. */
                  pszCurrentInput[nCursorPos++] = chTemp;

                  /* Move to new cursor position. */
                  od_set_cursor(nRow, nColumn + nCursorPos);
               }
               else
               {
                  goto get_another_key;
               }
            }

            /* If we are in overwrite mode, but not at end of string. */
            else
            {
               /* If password mode. */
               if(nFlags & EDIT_FLAG_PASSWORD_MODE)
               {
                  /* Display the password character. */
                  od_putch(chBlank);
               }
               /* If not in password mode. */
               else
               {
                  /* Display the character. */
                  od_putch(chTemp);
               }

               /* Add character to string. */
               pszCurrentInput[nCursorPos++] = chTemp;
            }

            /* If not at end of possible string. */
            if(nCursorPos < nCurrentStringLength)
            {
               /* If the next character is literal constant. */
               if(abCurrentFormatLiteral[nCursorPos])
               {
                  chTemp = pszCurrentFormat[anCurrentFormatOffset[nCursorPos]];
                  goto add_another_key;
               }
            }

            if(chAddAtEnd)
            {
               chTemp = chAddAtEnd;
               chAddAtEnd = 0;
               goto add_another_key;
            }


   check_cursor_char:
            /* If there is a character under cursor. */
            if(nCursorPos < strlen(pszCurrentInput))
            {
               /* If character corresponds to the format string. */
               if(ODEditIsCharValidForPos(pszCurrentInput[nCursorPos],
                  nCursorPos))
               {
                  /* Determine correct character for this position. */
                  chTemp = ODEditAsCharForPos(pszCurrentInput[nCursorPos],
                     nCursorPos);

                  /* If actual character is not correct. */
                  if(chTemp != pszCurrentInput[nCursorPos])
                  {                        
                     /* Change character to correct value. */
                     pszCurrentInput[nCursorPos] = chTemp;

                     /* If password mode. */
                     if(nFlags & EDIT_FLAG_PASSWORD_MODE)
                     {
                        /* Display the password character. */
                        od_putch(chBlank);
                     }

                     /* If not in password mode. */
                     else
                     {
                        /* Display the character. */
                        od_putch(chTemp);
                     }

                     /* Reset cursor position. */
                     od_set_cursor(nRow, nColumn + nCursorPos);
                  }
               }
            }
         }
      }
   }

   /* Accept string if it is valid. */
try_to_accept:
   /* If string must be filled. */
   if(nFlags & EDIT_FLAG_FILL_STRING)
   {
      /* If string is not filled, don't return. */
      if(strlen(pszCurrentInput) != nCurrentStringLength) goto keep_going;
   }

   /* Loop through string .... */
   for(nCount = 0; nCount < strlen(pszCurrentInput); ++nCount)
   {
      /* ... testing each character for validity. */
      if(!ODEditIsCharValidForPos(pszCurrentInput[nCount], nCount))
         goto keep_going;
   }

   /* Initially, assume that the string has not been changed. */
   chCurrentValue = FALSE;

   /* Loop through the string. */
   for(nCount = 0; nCount < strlen(pszCurrentInput); ++nCount)
   {
      /* Find correct value for each character. */
      chTemp = ODEditAsCharForPos(pszCurrentInput[nCount], nCount);

      /* If character is not correct. */
      if(chTemp != pszCurrentInput[nCount])           
      {
         /* Change char to correct value */
         pszCurrentInput[nCount] = chTemp;

         /* Remember that string has been changed. */
         chCurrentValue = TRUE;
      }
   }

   /* If permaliteral mode. */
   if(nFlags & EDIT_FLAG_LEAVE_BLANK)
   {
      /* Count # of literal characters. */
      nCount = 0;
      while(nCount<strlen(pszCurrentInput))
      {
         if(abCurrentFormatLiteral[nCount])
         {
            ++nCount;
         }
         else
         {
            break;
         }
      }

      /* If only literals in string. */
      if(strlen(pszCurrentInput) == nCount && nCount > 0)
      {
         /* Then they shouldn't be here. */
         pszCurrentInput[0] = '\0';
         goto exit_and_redraw;
      }
   }

   /* Always redraw if string was changed. */
   if(chCurrentValue) goto exit_and_redraw;

   /* If no-redraw flag not set. */
   if(!(nFlags & EDIT_FLAG_NO_REDRAW))
   {
exit_and_redraw:
      /* Set appropriate text colour. */
      od_set_attrib(btNormalColour);

      /* Set to redraw position. */
      od_set_cursor(nRow,nColumn);

      /* If password mode. */
      if(nFlags & EDIT_FLAG_PASSWORD_MODE)
      {
         /* Display blanked-out string. */
         od_repeat(chBlank, (BYTE)strlen(pszCurrentInput));
      }
      else
      {
         /* Display actual string. */
         od_disp_str(pszCurrentInput);
      }

      /* If we should keep the background. */
      if(nFlags & EDIT_FLAG_KEEP_BLANK)
      {
         /* Then redraw background. */
         if(nFlags & EDIT_FLAG_PERMALITERAL)
         {
            ODEditDisplayPermaliteral(nFlags);
         }
         else
         {
            od_repeat(chCurrentBlank,
               (BYTE)(nCurrentStringLength - strlen(pszCurrentInput) + 1));
         }
      }
      /* If we should erase the background ... */
      else
      {
         /* ... then do it. */
         od_repeat(' ',
            (BYTE)(nCurrentStringLength - strlen(pszCurrentInput) + 1));
      }
   }

   /* Release exclusive use of arrow keys. */
   ODStatEndArrowUse();

   /* Return with appropriate return value. */
   OD_API_EXIT();
   return(wToReturn);
}



/* ----------------------------------------------------------------------------
 * ODEditIsCharValidForPos()                           *** PRIVATE FUNCTION ***
 *
 * Determines whether or not the entered character can be accepted as a valid
 * character (after any possible conversion by ODEditAsCharForPos() is applied)
 * for the specified position in the string.
 *
 * Parameters: chEntered   - The character entered by the user.
 *
 *             nPosition   - The position in the string where this character
 *                           would be inserted.
 *
 *     Return: TRUE if this character should be accepted, FALSE if not.
 */
static BOOL ODEditIsCharValidForPos(char chEntered, INT nPosition)
{
   /* If this character is a literal. */
   if(abCurrentFormatLiteral[nPosition])
   {                                     
      /* Check required literal character. */
      if(chEntered != pszCurrentFormat[anCurrentFormatOffset[nPosition]])
      {                                          
         /* If this is not the correct literal character, then do not */
         /* permit it to be entered in this position. */
         return(FALSE);
      }
      return(TRUE);
   }

   /* If this position has a corresponding format control character, */
   /* then check that control character. The execution path will     */
   /* continue out of this switch statement (rather than returning   */
   /* to the calling function) if and only if the entered character  */
   /* is valid for the format character specified.                   */
   switch(pszCurrentFormat[anCurrentFormatOffset[nPosition]])
   {
      /* Only numerical characters are to be permitted. */
      case '#':
         if(chEntered < '0' || chEntered > '9') return(FALSE);
         break;

      /* Only numerical and space characters are to be permitted. */
      case '%':
         if((chEntered < '0' || chEntered > '9') && chEntered != ' ')
         {
            return(FALSE);
         }
         break;

      /* Only floating point number characters are to be permitted. */
      case '9':
         if(chEntered >= '0' && chEntered <= '9') break;
         if(chEntered == '.' || chEntered == '+' || chEntered == '-') break;
         return(FALSE);

      /* Only "printable" characters are to be permitted. */
      case '*':
         if(chEntered < 32) return(FALSE);
         break;

      /* City name characters are to be permitted. */
      case 'C':
      case 'c':
         if(chEntered >= 'A' && chEntered <= 'Z') break;
         if(chEntered >= 'a' && chEntered <= 'z') break;
         if(chEntered == ' ' || chEntered == ',' || chEntered == '.') break;
         if(chEntered == '*' || chEntered == '?') break;
         return(FALSE);

      /* If only alphabetic characters are to be permitted. */
      case 'A':
      case 'a':
      case 'L':
      case 'l':
      case 'M':
      case 'm':
      case 'U':
      case 'u':
         if(chEntered>='A' && chEntered<='Z') break;
         if(chEntered>='a' && chEntered<='z') break;
         if(chEntered==' ') break;
         return(FALSE);

      /* If only date characters are to be permitted. */
      case 'D':
      case 'd':
         if(chEntered>='0' && chEntered<='9') break;
         if(chEntered=='-' || chEntered=='/') break;
         return(FALSE);

      /* If only MS-DOS filename characters are to be permitted. */
      case 'F':
      case 'f':
         if(chEntered >= 'A' && chEntered <= 'Z') break;
         if(chEntered >= '0' && chEntered <= '9') break;
         if(chEntered >= 'a' && chEntered <= 'z') break;
         switch(chEntered)
         {
            /* Filename separators. */
            case ':':
            case '.':
            case DIRSEP:

            /* Wildcard characters. */
            case '?':
            case '*':

            /* Other valid symbols in filenames */
            case '#':
            case '$':
            case '&':
            case '\'':
            case '(':
            case '>':
            case '-':
            case '@':
            case '_':
            case '!':
            case '{':
            case '}':
            case '~':
               return(TRUE);
         }

         return(FALSE);

      /* If only hexidecimal characters are to be permitted. */
      case 'H':
      case 'h':
         if(chEntered>='0' && chEntered<='9') break;
         if(chEntered>='A' && chEntered<='F') break;
         if(chEntered>='a' && chEntered<='f') break;
         return(FALSE);

      /* If only telephone number characters are to be permitted. */
      case 'T':                                          
      case 't':
         if(chEntered >= '0' && chEntered <= '9') break;
         if(chEntered == '-' || chEntered == '(' || chEntered == ')'
            || chEntered == ' ' || chEntered == '+')
         {
            break;
         }
         return(FALSE);

      /* If filenames with wildcards are to be permitted. */
      case 'W':
      case 'w':
         if(chEntered >= 'A' && chEntered <= 'Z') break;
         if(chEntered >= 'a' && chEntered <= 'z') break;
         if(chEntered == ':' || chEntered == '.' || chEntered == DIRSEP
            || chEntered == '*' || chEntered == '?')
         {
            break;
         }
         return(FALSE);

      /* If alpha-numeric characters are to be permitted. */
      case 'X':
      case 'x':
         if(chEntered >= 'A' && chEntered <= 'Z') break;
         if(chEntered >= 'a' && chEntered <= 'z') break;
         if(chEntered >= '0' && chEntered <= '9') break;
         if(chEntered == ' ') break;
         return(FALSE);

      /* If this is a Yes/No field. */
      case 'Y':
      case 'y':
         if(chEntered == 'y' || chEntered == 'n' || chEntered == 'Y'
            || chEntered == 'N')
         {
            break;
         }
         return(FALSE);
   }

   /* If execution gets to this point, then the character has been approved. */
   return(TRUE);
}



/* ----------------------------------------------------------------------------
 * ODEditAsCharForPos()                                *** PRIVATE FUNCTION ***
 *
 * Converts the character entered by the user to a valid character for this
 * position in the string. For example, for fields that are set to all
 * upper case, this function converts the entered characte to its upper case
 * equivalent.
 *
 * Parameters: chEntered   - Character that was entered by the user.
 *
 *             nPosition   - Position in the string where the character is to
 *                           be entered.
 *
 *     Return: The actual character to add to the input string at this
 *             position.
 */
static char ODEditAsCharForPos(char chEntered, INT nPosition)
{
   /* If this character is a literal. */
   if(abCurrentFormatLiteral[nPosition])
   {                                      
      /* Return the only valid char for this position. */
      return(pszCurrentFormat[anCurrentFormatOffset[nPosition]]);
   }

   /* If this position has a corresponding format control character, */
   /* then check that control character. */
   switch(pszCurrentFormat[anCurrentFormatOffset[nPosition]])
   {
      /* If Yes/No characters are required. */
      case 'Y':
      case 'y':
         return(toupper(chEntered));

      /* If filename characters are required. */
      case 'F':                                       
      case 'f':
         return(toupper(chEntered));

      /* If lower case characters are required. */
      case 'L':
      case 'l':
         return(tolower(chEntered));

      /* If upper case characters are required. */
      case 'U':
      case 'u':
         return(toupper(chEntered));

      /* If automatic capitalization is required. */
      case 'M':
      case 'm':
      case 'C':
      case 'c':
         /* First character is always upper case. */
         if(nPosition == 0) return(toupper(chEntered));

         /* Check for other base cases. */
         if(abCurrentFormatLiteral[nPosition-1]) return(toupper(chEntered));
         if(toupper(pszCurrentFormat[anCurrentFormatOffset[nPosition]]) != 'M'
            && toupper(pszCurrentFormat[anCurrentFormatOffset[nPosition]])
            != 'C')
         {
            return(toupper(chEntered));
         }

         /* If previous character is a word delimiter, then this character */
         /* should be uppper case.                                         */
         if(pszCurrentInput[nPosition-1] == ' '
            || pszCurrentInput[nPosition-1] == '.'
            || pszCurrentInput[nPosition-1] == ','
            || pszCurrentInput[nPosition-1] == '-')
         {
            return(toupper(chEntered));                                             /* Otherwise, this should be lower */
         }

         /* Otherwise, this character should be lower-case. */
         return(tolower(chEntered));
   }

   return(chEntered);
}


/* ----------------------------------------------------------------------------
 * ODEditDisplayPermaliteral()                         *** PRIVATE FUNCTION ***
 *
 * Displays permaliterals (characters specified in the format string that
 * should be returned in the input string, but which the user may never
 * change).
 *
 * Parameters: nFlags - Flags parameter that was passed into od_edit_str().
 *
 *     Return: void
 */
static void ODEditDisplayPermaliteral(WORD nFlags)
{
   INT nCount;
   BYTE btRepeat = 0;

   for(nCount = strlen(pszCurrentInput); nCount <= nCurrentStringLength;
      ++nCount)
   {
      if(nCount != nCurrentStringLength)
      {
         if(abCurrentFormatLiteral[nCount])
         {
            if(btRepeat > 0)
            {
               od_repeat(chCurrentBlank, btRepeat);
               btRepeat = 0;
            }
            od_putch(pszCurrentFormat[anCurrentFormatOffset[nCount]]);
         }
         else
         {
            ++btRepeat;
         }
      }
      else
      {
         if(!(nFlags & EDIT_FLAG_SHOW_SIZE))
         {
            ++btRepeat;
         }
      }
   }

   if(btRepeat > 0) od_repeat(chCurrentBlank, btRepeat);
}