home *** CD-ROM | disk | FTP | other *** search
/ Piper's Pit BBS/FTP: ibm 0040 - 0049 / ibm0040-0049 / ibm0040.tar / ibm0040 / ZINC_5.ZIP / WINSRC.ZIP / FMTSTR.CPP < prev    next >
Encoding:
C/C++ Source or Header  |  1991-06-01  |  15.8 KB  |  672 lines
  1. //    Zinc Interface Library - FMTSTR.CPP
  2. //    COPYRIGHT (C) 1990, 1991.  All Rights Reserved.
  3. //    Zinc Software Incorporated.  Pleasant Grove, Utah  USA
  4.  
  5. #include "ui_win.hpp"
  6. #include <ctype.h>
  7. #include <stdlib.h>
  8. #include <string.h>
  9.  
  10. FS_STATE::FS_STATE(FS_STATE& src)
  11. {
  12.     isMarked = src.isMarked;
  13.     cursor = src.cursor;
  14.     int srcTextLen = (src.text) ? strlen(src.text) : 0;
  15.     text = new char[srcTextLen + 1];
  16.     strcpy(text, src.text);
  17. }
  18.  
  19. void FS_STATE::operator = (FS_STATE& src)
  20. {
  21.     isMarked = src.isMarked;
  22.     cursor = src.cursor;
  23.     strcpy(text, src.text);
  24. }
  25.  
  26. int FS_STATE::operator == (FS_STATE& rightOperand)
  27. {
  28.     return (isMarked == rightOperand.isMarked &&
  29.         cursor == rightOperand.cursor && !strcmp(text, rightOperand.text));
  30. }
  31.  
  32. int FS_STATE::operator != (FS_STATE& rightOperand)
  33. {
  34.     return (isMarked != rightOperand.isMarked ||
  35.         cursor != rightOperand.cursor || strcmp(this->text, rightOperand.text));
  36. }
  37.  
  38. UIW_FORMATTED_STRING::UIW_FORMATTED_STRING(int left, int top, int width,
  39.     char *_text, char *_editMask, char *_literalMask, USHORT _woFlags,
  40.     int (*_validate)(void *object, int ccode)) :
  41.     UI_WINDOW_OBJECT(left, top, width, 1, _woFlags, WOAF_NO_FLAGS)
  42. {
  43.     windowID[0] = ID_STRING;
  44.     windowID[1] = ID_FORMATTED_STRING;
  45.     search.type = ID_FORMATTED_STRING;
  46.  
  47.     Validate = _validate;
  48.     int editMaskLen = strlen(_editMask);
  49.     editMaskLen = Min(editMaskLen, width);
  50.     int litMaskLen = strlen(_literalMask);
  51.     editMask = new char[editMaskLen+1];
  52.     memcpy(editMask, _editMask, editMaskLen);
  53.     editMask[editMaskLen] = '\0';
  54.     literalMask = new char[editMaskLen+1];
  55.     memcpy(literalMask, _literalMask, editMaskLen);
  56.     literalMask[editMaskLen] = '\0';
  57.     if (litMaskLen < editMaskLen)
  58.         memset(literalMask + litMaskLen, '?', editMaskLen - litMaskLen);
  59.     maskLen = editMaskLen;
  60.     fieldWidth = width;
  61.     int textLen = TextLength();
  62.     int passedLength = ui_strlen(_text);
  63.     if (FlagSet(_woFlags, WOF_NO_ALLOCATE_DATA))
  64.         state.text = _text;
  65.     else
  66.     {
  67.         state.text = new char[textLen + 1];
  68.         int actualLen = Min(textLen, passedLength);
  69.         if (_text)
  70.             memcpy(state.text, _text, actualLen);
  71.         state.text[actualLen] = '\0';
  72.     }
  73.  
  74.     // Match with the appropriate Windows 3.0 flags.
  75.     if (FlagSet(woFlags, WOF_BORDER) && !FlagSet(woFlags, WOF_NON_FIELD_REGION))
  76.         MSWindowsStyle |= WS_BORDER;
  77.     if (FlagSet(woFlags, WOF_JUSTIFY_CENTER))
  78.         MSWindowsStyle |= ES_CENTER | ES_MULTILINE;
  79.     if (FlagSet(woFlags, WOF_JUSTIFY_RIGHT))
  80.         MSWindowsStyle |= ES_RIGHT | ES_MULTILINE;
  81. }
  82.  
  83. UIW_FORMATTED_STRING::~UIW_FORMATTED_STRING()
  84. {
  85.     if (FlagSet(woFlags, WOF_NO_ALLOCATE_DATA))
  86.         state.text = 0;                      // So FS_STATE destructor doesn't free it.
  87.     delete editMask;
  88.     delete literalMask;
  89. }
  90.  
  91. void UIW_FORMATTED_STRING::DataSet(char *newText)
  92. {
  93.     if (newText)
  94.     {
  95.         if (FlagSet(woFlags, WOF_NO_ALLOCATE_DATA))
  96.             state.text = newText;
  97.         else
  98.         {
  99.             delete state.text;
  100.             int textLen = TextLength();
  101.             state.text = new char[textLen + 1];
  102.             int actualLen = strlen(newText);
  103.             actualLen = Min(textLen, actualLen);
  104.             memcpy(state.text, newText, actualLen);
  105.             state.text[actualLen] = '\0';
  106.         }
  107.     }
  108.     UI_WINDOW_OBJECT::Redisplay(FALSE);
  109. }
  110.  
  111. int UIW_FORMATTED_STRING::Event(const UI_EVENT &event)
  112. {
  113.     int viewOnly = FlagSet(woFlags, WOF_VIEW_ONLY) ? TRUE : FALSE;
  114.      int ccode = UI_WINDOW_OBJECT::LogicalEvent(event, ID_STRING);
  115.     int cellWidth = display->TextWidth("W");
  116.     UI_REGION region;
  117.     UI_WINDOW_OBJECT::Border(0, region, 0);
  118.     int width = (region.right + 1 - region.left) / cellWidth;
  119.     USHORT key;
  120.     if (ccode == S_SIZE)
  121.     {
  122.         fieldWidth = width;
  123.         maskLen = strlen(editMask);
  124.         if (maskLen > fieldWidth)
  125.             maskLen = fieldWidth;
  126.         ccode = S_CREATE;
  127.     }
  128.     if (ccode == S_CREATE)
  129.     {
  130.         state.isMarked = FALSE;
  131.         state.cursor = 0;
  132.         FixText();
  133.  
  134.         ccode = UI_WINDOW_OBJECT::Event(event);
  135.  
  136.         true.bottom += 1;
  137.         true.right += 1;
  138.         if (FlagSet(woFlags, WOF_BORDER))
  139.             true.bottom -= 2 * HIWORD(GetDialogBaseUnits()) / 8;
  140.  
  141.         UI_WINDOW_OBJECT *root = parent;
  142.         while (root->parent && !root->hWnd)
  143.             root = root->parent;
  144.         if (!root->hWnd)
  145.             return(S_UNKNOWN);
  146.  
  147.         POINT client = { 0, 0 };
  148.         ClientToScreen(root->hWnd, &client);
  149.  
  150.         if (!hWnd)
  151.         {
  152.             hWnd = CreateWindow("Edit", NULL,
  153.                 WS_CHILD | WS_VISIBLE | MSWindowsStyle,
  154.                 true.left - client.x, true.top - client.y,
  155.                 true.right - true.left, true.bottom - true.top,
  156.                 root->hWnd, 1, ((UI_MSWINDOWS_DISPLAY *)display)->hInstance, NULL);
  157.             screenID = hWnd;
  158.  
  159.             SendMessage(hWnd, EM_LIMITTEXT, TextLength(), 0L);
  160.         }
  161.         else if (hWnd)
  162.         {
  163.             RECT windowRect;
  164.             GetWindowRect(hWnd, &windowRect);
  165.             if (true.left != windowRect.left || true.top != windowRect.top ||
  166.                 true.right != windowRect.right || true.bottom != windowRect.bottom)
  167.             {
  168.                 MoveWindow(hWnd, true.left - client.x, true.top - client.y,
  169.                     true.right - true.left, true.bottom - true.top, TRUE);
  170.                 SendMessage(hWnd, WM_NCPAINT, 0, 0x0L);
  171.             }
  172.         }
  173.  
  174.         if (FlagSet(woAdvancedStatus, WOAS_TOO_SMALL))
  175.         {
  176.             SendMessage(hWnd, WM_KILLFOCUS, parent->hWnd, 0L);
  177.             SendMessage(hWnd, WM_ENABLE, 0, 0);
  178.         }
  179.         else
  180.             SendMessage(hWnd, WM_ENABLE, 1, 0);
  181.     }
  182.     FS_STATE oldStateInfo(state);
  183.     UCHAR forceDisplay = FALSE;
  184.     UCHAR reDisplay = TRUE;
  185.     UCHAR displayCheckRegion = FALSE;
  186.     int needValidate = NeedsValidation();
  187.  
  188.     if (!FlagSet(woStatus, WOS_CURRENT))
  189.         state.isMarked = FALSE;
  190.     switch (ccode)
  191.     {
  192.     case E_KEY:
  193.         key = event.rawCode & 0xFF;
  194.         if ((key == '\b' || key >= ' ') && !viewOnly)
  195.         {
  196.             if (key == '\b')
  197.                 BackspaceKey();
  198.             else
  199.                 RegularKey(key);
  200.         }
  201.         else
  202.         {
  203.             reDisplay = FALSE;
  204.             ccode = S_UNKNOWN;
  205.         }
  206.         break;
  207.  
  208.     case L_LEFT:
  209.         woStatus |= WOS_NO_AUTO_CLEAR;
  210.         if (state.cursor > 0)
  211.             state.cursor--;
  212.         else
  213.             ccode = S_UNKNOWN;
  214.         break;
  215.  
  216.     case L_RIGHT:
  217.         woStatus |= WOS_NO_AUTO_CLEAR;
  218.         if (state.text[state.cursor + 1])
  219.             state.cursor++;
  220.         else
  221.             ccode = S_UNKNOWN;
  222.         break;
  223.  
  224.     case L_BOL:
  225.         woStatus |= WOS_NO_AUTO_CLEAR;
  226.         state.cursor = 0;
  227.         break;
  228.  
  229.     case L_EOL:
  230.         woStatus |= WOS_NO_AUTO_CLEAR;
  231.         state.cursor = ui_strlen(state.text) - 1;
  232.         break;
  233.  
  234.     case L_DELETE:
  235.         if (viewOnly)
  236.             break;
  237.         else if (state.isMarked)
  238.             CutBlock();
  239.         else
  240.             DeleteKey();
  241.         woStatus |= WOS_NO_AUTO_CLEAR;
  242.         break;
  243.  
  244.     case L_DELETE_EOL:
  245.         if (viewOnly)
  246.             break;
  247.         else if (state.isMarked)
  248.             CutBlock();
  249.         else
  250.         {
  251.             int originalCursor = state.cursor;
  252.             while (state.text[state.cursor])
  253.             {
  254.                 DeleteKey();
  255.                 state.cursor++;
  256.             }
  257.             state.cursor = originalCursor;
  258.         }
  259.         woStatus |= WOS_NO_AUTO_CLEAR;
  260.         break;
  261.  
  262.     case L_MARK:
  263.         state.isMarked = !state.isMarked;
  264.         break;
  265.  
  266.     case L_VIEW:
  267.         eventManager->DeviceState(event.type, DM_EDIT);
  268.         reDisplay = FALSE;
  269.         break;
  270.  
  271.     case L_CUT:
  272.         if (!viewOnly)
  273.         {
  274.             if (state.isMarked)
  275.                 CutBlock();
  276.             else
  277.                 reDisplay = FALSE;
  278.             break;
  279.         }
  280.         // If view only, treat a CUT as a copy.
  281.  
  282.     case L_COPY_MARK:
  283.         if (state.isMarked)
  284.             CopyBlock();
  285.         else
  286.             reDisplay = FALSE;
  287.         break;
  288.  
  289.     case L_CUT_PASTE:
  290.         if (state.isMarked)
  291.         {
  292.             if (viewOnly)
  293.                 CopyBlock();
  294.             else
  295.                 CutBlock();
  296.             break;
  297.         }
  298.         // Continue to L_PASTE.
  299.  
  300.     case L_PASTE:
  301.         if (!viewOnly)
  302.         {
  303.             if (event.type != E_KEY)
  304.                 SetCursor((event.position.column - region.left) / cellWidth, width);
  305.             PasteBlock();
  306.         }
  307.         break;
  308.  
  309.     case L_CONTINUE_MARK:
  310.         if (markColumn != (event.position.column - region.left) / cellWidth)
  311.             state.isMarked = TRUE;
  312.         break;
  313.  
  314.     case L_BEGIN_MARK:
  315.         state.isMarked = FALSE;
  316.         markColumn = (event.position.column - region.left) / cellWidth;
  317.         SetCursor(markColumn, width);
  318.         forceDisplay = TRUE;            // Force cursor to get updated.
  319.         break;
  320.  
  321.     case S_CURRENT:
  322.         woStatus &= ~WOS_UNANSWERED;
  323.         if (needValidate)
  324.             (*Validate)(this, ccode);
  325.         displayCheckRegion = TRUE;
  326.  
  327.         if (!FlagSet(woFlags, WOF_VIEW_ONLY))
  328.             SendMessage(hWnd, WM_SETFOCUS, parent->hWnd, 0L);
  329.         break;
  330.  
  331.     case S_DISPLAY_ACTIVE:
  332.         displayCheckRegion = TRUE;
  333.         if (FlagSet(woStatus, WOS_CURRENT) && !FlagSet(woFlags, WOF_VIEW_ONLY))
  334.             SendMessage(hWnd, WM_SETFOCUS, parent->hWnd, 0L);
  335.         break;
  336.  
  337.     case S_NON_CURRENT:
  338.         if ( needValidate && (*Validate)(this, ccode) != 0 )
  339.         {
  340.             ccode = S_ERROR;
  341.             woStatus |= WOS_INVALID;
  342.             reDisplay = FALSE;
  343.             break;
  344.         }
  345.         woStatus &= ~WOS_INVALID;
  346.         // else fall through to S_DISPLAY_INACTIVE.
  347.  
  348.     case S_DISPLAY_INACTIVE:
  349.         state.isMarked = FALSE;
  350.         displayCheckRegion = TRUE;
  351.         SendMessage(hWnd, WM_KILLFOCUS, parent->hWnd, 0L);
  352.         break;
  353.  
  354.     case S_ERROR_RESPONSE:
  355.         woStatus |= event.rawCode;
  356.         forceDisplay = TRUE;
  357.         if (event.rawCode == WOS_UNANSWERED)
  358.         {
  359.             state.text[0] = '\0';
  360.             FixText();
  361.         }
  362.         displayCheckRegion = TRUE;
  363.         if (FlagSet(woStatus, WOS_CURRENT) && !FlagSet(woFlags, WOF_VIEW_ONLY))
  364.             SendMessage(hWnd, WM_SETFOCUS, parent->hWnd, 0L);
  365.         break;
  366.  
  367.     default:
  368.         ccode = UI_WINDOW_OBJECT::Event(event);
  369.         reDisplay = FALSE;
  370.         break;
  371.     }
  372.  
  373.     if (displayCheckRegion)
  374.     {
  375.         forceDisplay = TRUE;
  376.         if ( !UI_WINDOW_OBJECT::NeedsUpdate(event, ccode) &&
  377.               oldStateInfo == state )
  378.             reDisplay = FALSE;
  379.  
  380.     }
  381.  
  382.     char dText[256];
  383.     int cursorColumn;
  384.     if (reDisplay)
  385.     {
  386.         if (FlagSet(woStatus, WOS_UNANSWERED))
  387.             FixText();
  388.         if (forceDisplay || oldStateInfo != state)
  389.         {
  390.             cursorColumn = Expand(dText);
  391.             Redisplay(region, width, dText);
  392.             if (ccode == S_CURRENT)
  393.                 UpdateCursor(region, width, dText, cursorColumn);
  394.         }
  395.     }
  396.     else if (ccode == S_CURRENT)
  397.     {
  398.         cursorColumn = Expand(dText);
  399.         UpdateCursor(region, width, dText, cursorColumn);
  400.     }
  401.     return (ccode);
  402. }
  403.  
  404. void UIW_FORMATTED_STRING::BackspaceKey()
  405. {
  406.     if (state.cursor > 0)
  407.     {
  408.         state.cursor--;
  409.         DeleteKey();
  410.     }
  411.     woStatus |= WOS_CHANGED | WOS_NO_AUTO_CLEAR;
  412. }
  413.  
  414. int UIW_FORMATTED_STRING::CalcLeading(int width, char *dText)
  415. {
  416.     int textLen = strlen(dText);
  417.     int leading = 0;
  418.     if (woFlags & WOF_JUSTIFY_CENTER)
  419.         leading = Min((fieldWidth - textLen) / 2, width);
  420.     else if (woFlags & WOF_JUSTIFY_RIGHT)
  421.         leading = Min(fieldWidth - textLen, width);
  422.     if (leading < 0)
  423.         leading = 0;
  424.     return leading;
  425. }
  426.  
  427. void UIW_FORMATTED_STRING::CopyBlock()
  428. {
  429.     char dText[40];
  430.  
  431.     Expand(dText);
  432.  
  433.     pasteLength = (USHORT) strlen(dText);
  434.     if (pasteBuffer)
  435.         delete pasteBuffer;
  436.     pasteBuffer = new char[pasteLength];
  437.     if (pasteBuffer)
  438.         memcpy(pasteBuffer, dText, pasteLength);
  439.  
  440.     state.isMarked = FALSE;
  441.     woStatus |= WOS_CHANGED | WOS_NO_AUTO_CLEAR;
  442. }
  443.  
  444. void UIW_FORMATTED_STRING::CutBlock()
  445. {
  446.     CopyBlock();
  447.     int textIndex = 0;
  448.     for (int i = 0; state.text[textIndex] && i < maskLen; i++)
  449.     {
  450.         if (editMask[i] != 'L')
  451.             state.text[textIndex++] = literalMask[i];
  452.     }
  453.     state.cursor = 0;
  454.     woStatus |= WOS_CHANGED | WOS_NO_AUTO_CLEAR;
  455. }
  456.  
  457. void UIW_FORMATTED_STRING::DeleteKey()
  458. {
  459.     int column = ExpandedColumn();
  460.     // ## Borland bug: large model code generation problem on following line:
  461.     // state.text[state.cursor] = literalMask[column];
  462.     char literalChar = literalMask[column];
  463.     state.text[state.cursor] = literalChar;
  464.     woStatus |= WOS_CHANGED | WOS_NO_AUTO_CLEAR;
  465. }
  466.  
  467. int UIW_FORMATTED_STRING::Expand(char *destText)
  468. {
  469.     char *src = state.text;
  470.     int column = maskLen - 1;
  471.     for (int i = 0; i < maskLen; i++)
  472.     {
  473.         if (src - state.text == state.cursor)
  474.             column = i;
  475.         if ( editMask[i] == 'L' )
  476.             *destText++ = literalMask[i];
  477.         else
  478.             *destText++ = *src++;
  479.     }
  480.     *destText = 0;
  481.     return column;
  482. }
  483.  
  484. int UIW_FORMATTED_STRING::ExpandedColumn()
  485. {
  486.     char *src = state.text;
  487.     int column = maskLen - 1;
  488.     for (int i = 0; i < maskLen; i++)
  489.     {
  490.         if (src - state.text == state.cursor)
  491.             column = i;
  492.         if (editMask[i] != 'L')
  493.             src++;
  494.     }
  495.     return column;
  496. }
  497.  
  498. void UIW_FORMATTED_STRING::FixText()
  499. {
  500.     int textLen = TextLength();
  501.     if (FlagSet(woStatus, WOS_UNANSWERED))
  502.         memset(state.text, '\0', textLen + 1);
  503.     int copyLen = strlen(state.text);
  504.     int t = 0;
  505.     for (int i = 0; i < maskLen; i++)
  506.     {
  507.         if (editMask[i] != 'L')
  508.         {
  509.             int textValue = ValidateMask(editMask[i], state.text[t]);
  510.             if (t >= copyLen || !textValue)
  511.                 state.text[t] = literalMask[i];
  512.             else
  513.                 state.text[t] = textValue;
  514.             t++;
  515.         }
  516.     }
  517.     state.text[textLen] = '\0';
  518. }
  519.  
  520. void UIW_FORMATTED_STRING::PasteBlock()
  521. {
  522.     if (pasteBuffer && !state.isMarked)
  523.     {
  524.         int textIndex = 0;
  525.         int p = 0;
  526.         for (int i = 0; i < maskLen && p < pasteLength; i++)
  527.         {
  528.             if (editMask[i] != 'L')
  529.             {
  530.                 int textValue;
  531.                 do
  532.                 {
  533.                     textValue = ValidateMask(editMask[i], pasteBuffer[p]);
  534.                     p++;
  535.                 } while (!textValue && p < pasteLength);
  536.                 if (textValue)
  537.                     state.text[textIndex++] = textValue;
  538.             }
  539.         }
  540.         state.text[textIndex] = '\0';
  541.         FixText();
  542.         state.cursor = 0;
  543.         woStatus |= WOS_CHANGED | WOS_NO_AUTO_CLEAR;
  544.     }
  545. }
  546.  
  547. #pragma argsused
  548. void UIW_FORMATTED_STRING::Redisplay(UI_REGION ®ion, short width, char *dText)
  549. {
  550.     if (!hWnd)
  551.         return;
  552.     SetWindowText(hWnd, dText);
  553.     if (state.isMarked)
  554.         SendMessage(hWnd, EM_SETSEL, 0, 0x7FFF0000L);
  555. }
  556.  
  557. void UIW_FORMATTED_STRING::RegularKey(USHORT key)
  558. {
  559.     int textValue = ValidateMask(editMask[ExpandedColumn()], key);
  560.     if (textValue)
  561.     {
  562.         if (FlagSet(woFlags, WOF_AUTO_CLEAR) && !FlagSet(woStatus, WOS_NO_AUTO_CLEAR))
  563.         {
  564.             int textIndex = 0;
  565.             for (int i = 0; state.text[textIndex] && i < maskLen; i++)
  566.             {
  567.                 if (editMask[i] != 'L')
  568.                     state.text[textIndex++] = literalMask[i];
  569.             }
  570.             state.cursor = 0;
  571.         }
  572.         state.text[state.cursor] = textValue;
  573.         if (state.text[state.cursor + 1])
  574.             state.cursor++;
  575.         woStatus |= WOS_CHANGED | WOS_NO_AUTO_CLEAR;
  576.     }
  577. }
  578.  
  579. void UIW_FORMATTED_STRING::SetCursor(int column, int width)
  580. {
  581.     char expandedText[40];
  582.     Expand(expandedText);
  583.     int leading = 0;
  584.     int textLen = strlen(expandedText);
  585.     if (woFlags & WOF_JUSTIFY_CENTER)
  586.         leading = Min((fieldWidth - textLen) / 2, width);
  587.     else if (woFlags & WOF_JUSTIFY_RIGHT)
  588.         leading = Min(fieldWidth - textLen, width);
  589.     column -= leading;
  590.     column = Min(column, maskLen);
  591.     int match = 0;
  592.     for (int i = 0; i < column; i++)
  593.     {
  594.         if (editMask[i] != 'L')
  595.             match++;
  596.     }
  597.     state.cursor = match;
  598. }
  599.  
  600. int UIW_FORMATTED_STRING::TextLength()
  601. {
  602.     int textLen = 0;
  603.     for (int i = 0; i < maskLen; i++)
  604.     {
  605.         if (editMask[i] != 'L')
  606.             textLen++;
  607.     }
  608.     return textLen;
  609. }
  610.  
  611. #pragma argsused
  612. void UIW_FORMATTED_STRING::UpdateCursor(UI_REGION ®ion, int width,
  613.     char *dText, int cursorColumn)
  614. {
  615.     int leading = CalcLeading(width, dText);
  616.     if (FlagSet(woStatus, WOS_CURRENT) && (leading + cursorColumn < width))
  617.     {
  618.         dText[cursorColumn] = '\0';
  619.         POINT position;
  620.         GetCaretPos(&position);
  621.         position.x += display->TextWidth(dText, screenID);
  622.         SetCaretPos(position.x, position.y);
  623.     }
  624. }
  625.  
  626. int UIW_FORMATTED_STRING::ValidateMask(int editValue, int textValue)
  627. {
  628.     int isAlpha = (textValue == ' ' || isalpha(textValue));
  629.     int isDigit = isdigit(textValue);
  630.     if (isupper(editValue))
  631.         textValue = toupper(textValue);
  632.     editValue = toupper(editValue);
  633.     if ((editValue == 'X' && textValue >= ' ' && textValue <= '~') ||
  634.         (editValue == 'N' && isDigit) ||
  635.         (editValue == 'A' && isAlpha) ||
  636.         (editValue == 'C' && (isDigit || isAlpha)))
  637.         return (textValue);
  638.     else
  639.         return (0);
  640. }
  641.  
  642. #ifdef ZIL_LOAD
  643. UIW_FORMATTED_STRING::UIW_FORMATTED_STRING(const char *name, UI_STORAGE *file, USHORT loadFlags) :
  644.     UI_WINDOW_OBJECT(name, file, loadFlags | L_SUB_LEVEL),
  645.     fieldWidth(relative.right - relative.left + 1)
  646. {
  647.     windowID[0] = ID_FORMATTED_STRING;
  648.  
  649.     if (!file)
  650.         file = _storage;
  651.     file->Load(&editMask);
  652.     file->Load(&literalMask);
  653.     file->Load(&state.text);
  654.     maskLen = strlen(editMask);
  655.     if (!FlagSet(loadFlags, L_SUB_LEVEL) && FlagSet(file->stStatus, STS_TEMPORARY))
  656.         delete file;
  657. }
  658. #endif
  659.  
  660. #ifdef ZIL_STORE
  661. void UIW_FORMATTED_STRING::Store(const char *name, UI_STORAGE *file, USHORT storeFlags)
  662. {
  663.     UI_WINDOW_OBJECT::Store(name, file, storeFlags | S_SUB_LEVEL);
  664.     file->Store(editMask);
  665.     file->Store(literalMask);
  666.     file->Store(state.text);
  667.     if (!FlagSet(storeFlags, S_SUB_LEVEL))
  668.         file->ObjectSize(name, search);
  669. }
  670. #endif
  671.  
  672.