{*********************************************************}
{*                   OVCDATA.PAS 4.06                    *}
{*********************************************************}

{* ***** BEGIN LICENSE BLOCK *****                                            *}
{* Version: MPL 1.1                                                           *}
{*                                                                            *}
{* The contents of this file are subject to the Mozilla Public License        *}
{* Version 1.1 (the "License"); you may not use this file except in           *}
{* compliance with the License. You may obtain a copy of the License at       *}
{* http://www.mozilla.org/MPL/                                                *}
{*                                                                            *}
{* Software distributed under the License is distributed on an "AS IS" basis, *}
{* WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License   *}
{* for the specific language governing rights and limitations under the       *}
{* License.                                                                   *}
{*                                                                            *}
{* The Original Code is TurboPower Orpheus                                    *}
{*                                                                            *}
{* The Initial Developer of the Original Code is TurboPower Software          *}
{*                                                                            *}
{* Portions created by TurboPower Software Inc. are Copyright (C)1995-2002    *}
{* TurboPower Software Inc. All Rights Reserved.                              *}
{*                                                                            *}
{* Contributor(s):                                                            *}
{*                                                                            *}
{* ***** END LICENSE BLOCK *****                                              *}

{$I OVC.INC}

{$B-} {Complete Boolean Evaluation}
{$I+} {Input/Output-Checking}
{$P+} {Open Parameters}
{$T-} {Typed @ Operator}
{.W-} {Windows Stack Frame}
{$X+} {Extended Syntax}

unit ovcdata;
  {-Miscellaneous type and constant declarations}

interface

uses
  {$IFNDEF LCL} Windows, Messages, {$ELSE} LclIntf, LMessages, LclType, MyMisc, {$ENDIF}
  Controls, Forms, Graphics, StdCtrls, SysUtils, OvcConst, OvcDate, O32SR;

const
  BorderStyles    : array[TBorderStyle] of LongInt =
                    (0, WS_BORDER);
  ScrollBarStyles : array [TScrollStyle] of LongInt =
                    (0, WS_HSCROLL, WS_VSCROLL, WS_HSCROLL or WS_VSCROLL
{$IFDEF LCL}
                    ,WS_HSCROLL, WS_VSCROLL, WS_HSCROLL or WS_VSCROLL
{$ENDIF}
                    );

{$IFNDEF VERSION4}
type
  PDateTime     = ^TDateTime;
{$ENDIF}

{some colors that are not defined by Delphi}
const
  clCream      = TColor($A6CAF0);
  clMoneyGreen = TColor($C0DCC0);
  clSkyBlue    = TColor($FFFBF0);

type
  TCharSet = set of AnsiChar; {a Pascal set of characters}

type
  PPointer = ^Pointer;

type
  {secondary field options--internal}
  TsefOption = (
    sefValPending,      {field needs validation}
    sefInvalid,         {field is invalid}
    sefNoHighlight,     {Don't highlight field initially}
    sefIgnoreFocus,     {We're ignoring the focus}
    sefValidating,      {We're validating a field}
    sefModified,        {Field recently modified}
    sefEverModified,    {Field has been modified after last data transfer}
    sefFixSemiLits,     {Semi-literals were stripped}
    sefHexadecimal,     {Field's value is shown in hex}
    sefOctal,           {Field's value is shown in octal}
    sefBinary,          {Field's value is shown in binary}
    sefNumeric,         {Edit from right to left--for numbers only}
    sefRealVar,         {Field is of a real/8087 type}
    sefNoLiterals,      {Picture mask has no literals}
    sefHaveFocus,       {Control has the focus}
    sefRetainPos,       {Retain caret position}
    sefErrorPending,    {Error pending?}
    sefInsert,          {Insert mode on}
    sefLiteral,         {Next char is literal}
    sefAcceptChar,      {Accept next character}
    sefCharOK,          {OK to add a character}
    sefUpdating,        {field is being updated}
    sefGettingValue,    {field contents are being retrieved}
    sefUserValidating,  {user validation in progress}
    sefNoUserValidate); {don't perform user validation}

  {Set of current secondary options for entry fields}
  TsefOptionSet = set of TsefOption;

const
  {default secondary field options}
  sefDefOptions      : TsefOptionSet = [sefCharOK, sefInsert];

const
  DefPadChar         = ' '; {Default character used to pad the end of a display string}
  MaxEditLen         = 255; {Maximum length of edit string}
  MaxPicture         = 255; {Maximum length of a picture mask}

{*** Picture masks ***}
const
  {the following characters are meaningful in Picture masks}
  pmAnyChar     = 'X';         {allows any character}
  pmForceUpper  = '!';         {allows any character, forces upper case}
  pmForceLower  = 'L';         {allows any character, forces lower case}
  pmForceMixed  = 'x';         {allows any character, forces mixed case}
  pmAlpha       = 'a';         {allows alphas only}
  pmUpperAlpha  = 'A';         {allows alphas only, forces upper case}
  pmLowerAlpha  = 'l';         {allows alphas only, forces lower case}
  pmPositive    = '9';         {allows numbers and spaces only}
  pmWhole       = 'i';         {allows numbers, spaces, minus}
  pmDecimal     = '#';         {allows numbers, spaces, minus, period}
  pmScientific  = 'E';         {allows numbers, spaces, minus, period, 'e'}
  pmHexadecimal = 'K';         {allows 0-9, A-F, and space forces upper case}
  pmOctal       = 'O';         {allows 0-7, space}
  pmBinary      = 'b';         {allows 0-1, space}
  pmTrueFalse   = 'B';         {allows T, t, F, f}
  pmYesNo       = 'Y';         {allows Y, y, N, n}

  pmUser1       = '1';         {User-defined picture mask characters}
  pmUser2       = '2';
  pmUser3       = '3';
  pmUser4       = '4';
  pmUser5       = '5';
  pmUser6       = '6';
  pmUser7       = '7';
  pmUser8       = '8';

  Subst1        = #241;        {User-defined substitution characters}
  Subst2        = #242;
  Subst3        = #243;
  Subst4        = #244;
  Subst5        = #245;
  Subst6        = #246;
  Subst7        = #247;
  Subst8        = #248;

const
  {Other special characters allowed in Picture strings}
  pmDecimalPt   = '.';         {insert decimal point}
  pmComma       = ',';         {character used to separate numbers}
  pmFloatDollar = '$';         {floating dollar sign}
  pmCurrencyLt  = 'c';         {currency to left of the amount}
  pmCurrencyRt  = 'C';         {currency to right of the amount}
  pmNegParens   = 'p';         {indicates () should be used for negative #'s}
  pmNegHere     = 'g';         {placeholder for minus sign}
  {NOTE: Comma and FloatDollar are allowed only in fields containing fixed
   decimal points and/or numeric fields. NegParens and NegHere should be used
   only in numeric fields.}

const
  {the following characters are meaningful in date Picture masks}
  pmMonth  = 'm';  {formatting character for a date string picture mask}
  pmMonthU = 'M';  {formatting character for a date string picture mask.
                    Uppercase means pad with ' ' rather than '0'}
  pmDay    = 'd';  {formatting character for a date string picture mask}
  pmDayU   = 'D';  {formatting character for a date string picture mask.
                    Uppercase means pad with ' ' rather then '0'}
  pmYear   = 'y';  {formatting character for a date string picture mask}
  pmDateSlash  = '/';  {formatting character for a date string picture mask}

  {'n'/'N' may be used in place of 'm'/'M' when the name of the month is
   desired instead of its number. E.g., 'dd/nnn/yyyy' -\> '01-Jan-1980'.
   'dd/NNN/yyyy' -\> '01-JAN-1980' (if SlashChar = '-'). The abbreviation used
   is based on the width of the subfield (3 in the example) and the current
   contents of the MonthString array.}
  pmMonthName   = 'n';  {formatting character for a date string picture mask}
  pmMonthNameU  = 'N';  {formatting character for a date string picture mask.
                        Uppercase causes the output to be in uppercase}

  {'w'/'W' may be used to include the day of the week in a date string. E.g.,
  'www dd nnn yyyy' -\> 'Mon 01 Jan 1989'. The abbreviation used is based on
  the width of the subfield (3 in the example) and the current contents of the
  DayString array. Note that entry field will not allow the user to enter
  text into a subfield containing 'w' or 'W'. The day of the week will be
  supplied automatically when a valid date is entered.}
  pmWeekDay  = 'w';   {formatting character for a date string picture mask}
  pmWeekDayU = 'W';   {formatting character for a date string picture mask.
                       Uppercase causes the output to be in uppercase}

  pmLongDateSub1 = 'f';   {mask character used with Window's long date format}
  pmLongDateSub2 = 'g';   {mask character used with Window's long date format}
  pmLongDateSub3 = 'h';   {mask character used with Window's long date format}

const
  {if uppercase letters are used, numbers are padded with ' ' rather than '0'}
  pmHour     = 'h';   {formatting character for a time string picture mask}
  pmHourU    = 'H';   {formatting character for a time string picture mask}
  pmMinute   = 'm';   {formatting character for a time string picture mask}
  pmMinuteU  = 'M';   {formatting character for a time string picture mask}
  pmSecond   = 's';   {formatting character for a time string picture mask}
  pmSecondU  = 'S';   {formatting character for a time string picture mask}
  {'hh:mm:ss tt' -\> '12:00:00 pm', 'hh:mmt' -\> '12:00p'}
  pmAmPm      = 't';  {formatting character for a time string picture mask.
                      This generates 'AM' or 'PM'}
  pmTimeColon = ':';  {formatting character for a time string picture mask}

const
  PictureChars : TCharSet = [
    pmAnyChar, pmForceUpper, pmForceLower, pmForceMixed,
    pmAlpha, pmUpperAlpha, pmLowerAlpha,
    pmPositive, pmWhole, pmDecimal, pmScientific,
    pmHexadecimal, pmOctal, pmBinary,
    pmTrueFalse, pmYesNo,
    pmMonthName, pmMonthNameU, pmMonth,
    pmMonthU, pmDay, pmDayU, pmYear, pmHour, pmHourU, {$IFNDEF FPC} pmMinute,
    pmMinuteU, {$ENDIF} pmSecond, pmSecondU, pmAmPm, pmUser1..pmUser8];

const
  {set of allowable picture characters for simple fields}
  SimplePictureChars : TCharSet = [
    pmAnyChar, pmForceUpper, pmForceLower, pmForceMixed,
    pmAlpha, pmUpperAlpha, pmLowerAlpha,
    pmPositive, pmWhole, pmDecimal, pmScientific,
    pmHexadecimal, pmOctal, pmBinary,
    pmTrueFalse, pmYesNo,
    pmUser1..pmUser8];

type
  {types of case change operations associated with a picture mask character}
  TCaseChange = (mcNoChange, mcUpperCase, mcLowerCase, mcMixedCase);

type
  TUserSetRange   = pmUser1..pmUser8;
  TForceCaseRange = pmUser1..pmUser8;
  TSubstCharRange = Subst1..Subst8;

  TUserCharSets   = array[TUserSetRange] of TCharSet;
  TForceCase      = array[TForceCaseRange] of TCaseChange;
  TSubstChars     = array[TSubstCharRange] of AnsiChar;

const
  MaxDateLen     = 40;        {maximum length of date picture strings}
  MaxMonthName   = 15;        {maximum length for month names}
  MaxDayName     = 15;        {maximum length for day names}

const
  otf_SizeData = 0; {These three constants are used in data transfers to}
  otf_GetData  = 1; {specify the type of transfer operation being requested}
  otf_SetData  = 2;

type
  TEditString  = array[0..MaxEditLen] of AnsiChar;
  TPictureMask = array[0..MaxPicture] of AnsiChar;

  {An array of flags that indicate the type of mask character at a given
   location in a picture mask}
  TPictureFlags = array[0..MaxEditLen+1] of Byte;

  {Each entry field maintains two data structures of this type, one to store
   the lower limit of a field's value, and another to store the upper limit}
  PRangeType = ^TRangeType;
  TRangeType = packed record
    case Byte of                         {size}
    00 : (rtChar : AnsiChar);             {01}
    01 : (rtByte : Byte);                 {01}
    02 : (rtSht  : ShortInt);             {01}
    03 : (rtInt  : SmallInt);             {02}
    04 : (rtWord : Word);                 {02}
    05 : (rtLong : LongInt);              {04}
    06 : (rtSgl  : Single);               {04}
    07 : (rtPtr  : Pointer);              {04}
    {$IFDEF CBuilder}
    08 : (rtReal : Double);               {06}
    {$ELSE}
    08 : (rtReal : Real);                 {06}
    {$ENDIF CBuilder}
    09 : (rtDbl  : Double);               {08}
    {$IFDEF CBuilder}
    10 : (rtComp : Double);               {08}
    {$ELSE}
     {$IFNDEF FPC}  {Delphi}
    10 : (rtComp : Comp);                 {08}
     {$ELSE}        {FPC}
      {$IFDEF CPU86}  
    10 : (rtComp : Comp);                 {08}
      {$ELSE}  {Comp is true integer with non-Intel}
    10 : (rtComp : Double);               {08}
      {$ENDIF}
     {$ENDIF} 
    {$ENDIF CBuilder}
    11 : (rtExt  : Extended);             {10}
    12 : (rtDate : LongInt);              {04}
    13 : (rtTime : LongInt);              {04}
    14 : (rt10   : array[1..10] of Byte); {10} {forces structure to size of 10 bytes}
  end;

const
  BlankRange : TRangeType = (rt10 : (0, 0, 0, 0, 0, 0, 0, 0, 0, 0));

{*** Date/Time declarations ***}
type
  TOvcDate  = TStDate;
  TOvcTime  = TStTime;
  TDayType = TStDayType;

type
  {states for data aware entry fields}
  TDbEntryFieldStates = (esFocused, esSelected, esReset);
  TDbEntryFieldState  = set of TDbEntryFieldStates;

type
  {Search option flags for editor and viewer}
  TSearchOptions = (
     soFind,        {find  (this option is assumed)        }
     soBackward,    {search backwards                      }
     soMatchCase,   {don't ignore case when searching      }
     soGlobal,      {search globally                       }
     soReplace,     {find and replace         (editor only)}
     soReplaceAll,  {find and replace all     (editor only)}
     soWholeWord,   {match on whole word only (editor only)}
     soSelText);    {search in selected text  (editor only)}
  TSearchOptionSet = set of TSearchOptions;

const
  {maximum length of a search/replacement string}
  MaxSearchString = 255;

type
  {types of tabs supported in the editor}
  TTabType   = (ttReal, ttFixed, ttSmart);

  {entry field flag for display of number field with zero value}
  TZeroDisplay = (zdShow, zdHide, zdHideUntilModified);

type
  {structrue of the commands stored in the command table}
  POvcCmdRec = ^TOvcCmdRec;
  TOvcCmdRec = packed record
    case Byte of
      0 : (Key1  : Byte;     {first keys' virtual key code}
           SS1   : Byte;     {shift state of first key}
           Key2  : Byte;     {second keys' virtual key code, if any}
           SS2   : Byte;     {shift state of second key}
           Cmd   : Word);    {command to return for this entry}
      1 : (Keys  : LongInt); {used for sorting, searching, and storing}
  end;

const
  {shift state flags for command processors}
  ss_None     = $00; {no shift key is pressed}
  ss_Shift    = $02; {the shift key is pressed}
  ss_Ctrl     = $04; {the control key is pressed}
  ss_Alt      = $08; {the alt key is pressed}
  ss_Wordstar = $80; {2nd key of a twokey wordstar command: ss_Ctrl or ss_None}
    {the second key of a two-key wordstar command is accepted if}
    {pressed by itself of with the ctrl key. case is ignored}

const
  {virtual key constants not already defined}
  VK_NONE = 0;
  VK_ALT  = VK_MENU;
  VK_A = Ord('A');  VK_B = Ord('B');  VK_C = Ord('C'); VK_D = Ord('D');
  VK_E = Ord('E');  VK_F = Ord('F');  VK_G = Ord('G');  VK_H = Ord('H');
  VK_I = Ord('I');  VK_J = Ord('J');  VK_K = Ord('K');  VK_L = Ord('L');
  VK_M = Ord('M');  VK_N = Ord('N');  VK_O = Ord('O');  VK_P = Ord('P');
  VK_Q = Ord('Q');  VK_R = Ord('R');  VK_S = Ord('S');  VK_T = Ord('T');
  VK_U = Ord('U');  VK_V = Ord('V');  VK_W = Ord('W');  VK_X = Ord('X');
  VK_Y = Ord('Y');  VK_Z = Ord('Z');  VK_0 = Ord('0');  VK_1 = Ord('1');
  VK_2 = Ord('2');  VK_3 = Ord('3');  VK_4 = Ord('4');  VK_5 = Ord('5');
  VK_6 = Ord('6');  VK_7 = Ord('7');  VK_8 = Ord('8');  VK_9 = Ord('9');

var
  AlphaCharSet  : TCharSet;

const
  IntegerCharSet: TCharSet = ['0'..'9', ' '];
  RealCharSet   : TCharSet = ['0'..'9', ' ', '-', '.'];

const
  {Picture flag values for elements in a TPictureFlags array}
  pflagLiteral = 0;  {Corresponding char in the mask is a literal}
  pflagFormat  = 1;  {Corresponding char in the mask is a formatting character}
  pflagSemiLit = 2;  {Corresponding char in the mask is a semi-literal character}

const
  {------------------- Windows messages -----------------------}
  {Not a message code. Value of the first of the message codes used}
  OM_FIRST = $7F00; {***}

  {entry field error}
  OM_REPORTERROR         = OM_FIRST + 0;
    {messages for/from viewer/editor controls}
  OM_SETFOCUS            = OM_FIRST + 1;
    {sent by an entry field to the controller to request return of the
    focus. lParam is pointer of the object to return the focus to}
  OM_SHOWSTATUS          = OM_FIRST + 2;
    {sent by a viewer or editor control to itself when the caret moves, or
    when text is inserted or deleted. wParam is the current column (an
    effective column number), and lParam is the current line}
  OM_GETDATASIZE         = OM_FIRST + 3;
    {sent to an entry field to obtain its data size}
  OM_RECREATEWND         = OM_FIRST + 5;
    {sent to force a call to RecreateWnd}
  OM_PREEDIT             = OM_FIRST + 6;
    {sent to preform pre-edit notification for entry fields}
  OM_POSTEDIT            = OM_FIRST + 7;
    {sent to preform post-edit notification for entry fields}
  OM_AFTERENTER          = OM_FIRST + 8;
    {sent to preform after-enter notification}
  OM_AFTEREXIT           = OM_FIRST + 9;
    {sent to preform after-exit notification}
  OM_DELAYNOTIFY         = OM_FIRST + 10;
    {sent to preform delayed notification}
  OM_POSITIONLABEL       = OM_FIRST + 11;
    {sent to cause the label to be repositioned}
  OM_RECORDLABELPOSITION = OM_FIRST + 12;
    {sent to cause the current position of the label to be recorded}
  OM_ASSIGNLABEL         = OM_FIRST + 13;
    {sent to assign a albel to a control}
  OM_FONTUPDATEPREVIEW   = OM_FIRST + 14;
    {sent to postpone the font change of the preview control}
  OM_DESTROYHOOK         = OM_FIRST + 15;
    {send to cause the window hook to be destroyed}
  OM_PROPCHANGE          = OM_FIRST + 16;
    {sent by a collection to its property editor when a property is changed}
  OM_ISATTACHED          = OM_FIRST + 17;
    {sent to other controls to see if they are attached. Used by attached
     button components and components that use an internal validator.
     Result is LongInt(Self) if true}
  OM_VALIDATE            = OM_FIRST + 18;
    {Sent to the FlexEdit as a call for it to Validate Itself}

{message crackers for the above Orpheus messages}

type
  TOMReportError = packed record
    Msg    : Cardinal;
    Error  : Word;
    Unused : Word;
    lParam : LongInt;
    Result : LongInt;
  end;

  TOMSetFocus = packed record
    Msg    : Cardinal;
    wParam : Integer;
    Control: TWinControl;
    Result : LongInt;
  end;

  TOMShowStatus = packed record
    Msg    : Cardinal;
    Column : Integer;
    Line   : LongInt;
    Result : LongInt;
  end;


type
  TShowStatusEvent =
    procedure(Sender : TObject; LineNum : LongInt; ColNum : Integer)
    of object;
    {-event to notify of a viewer or editor caret position change}

  TTopLineChangedEvent =
    procedure(Sender : TObject; Line : LongInt)
    of object;
    {-event to notify when the top line changes for the editor or viewer}

const
  {*** Error message codes ***}
  oeFirst             = 256;

  oeRangeError        = oeFirst + 0;
    {This error occurs when a user enters a value that is not within the
    accepted range of values for the field}
  oeInvalidNumber     = oeFirst + 1;
    {This error is reported if the user enters a string that does not represent
    a number in a field that should contain a numeric value}
  oeRequiredField     = oeFirst + 2;
    {This error occurs when the user leaves blank a field that is marked as
    required}
  oeInvalidDate       = oeFirst + 3;
    {This error occurs when the user enters a value in a date field that does
    not represent a valid date}
  oeInvalidTime       = oeFirst + 4;
    {This error occurs when the user enters a value in a time field that does
    not represent a valid time of day}
  oeBlanksInField     = oeFirst + 5;
    {This error is reported only by the validation helper routines
    ValidateNoBlanks and ValidateSubfields. It indicates that a blank was left
    in a field or subfield in which no blanks are allowed}
  oePartialEntry      = oeFirst + 6;
    {This error is reported only by the validation helper routines
    ValidateNotPartial and ValidateSubfields in OODEWCC. It indicates that a
    partial entry was given in a field or subfield in which the field/subfield
    must be either entirely empty or entirely full}
  oeOutOfMemory       = oeFirst + 7;
    {This error is reported by a viewer or editor control when there is
    insufficient memory to perform the requested operation. A viewer control
    reports this error only when copying selected text to the clipboard}
  oeRegionSize        = oeFirst + 8;
    {This error is reported by an editor control when the user asks to
    copy selected text to the clipboard, and the selected region exceeds
    64K in size}
  oeTooManyParas      = oeFirst + 9;
    {This error is reported by an editor control when the limit on the number
    of paragraphs is reached, and the requested operation would cause it to be
    exceeded}
  oeCannotJoin        = oeFirst + 10;
    {This error is reported by an editor control when the user attempts to join
    two paragraphs that cannot be joined. Typically this occurs when joining
    the two paragraphs would cause the new paragraph to exceed its size limit}
  oeTooManyBytes      = oeFirst + 11;
    {This error is reported by an editor control when the limit on the total
    number of bytes is reached, and the requested operation would cause it to
    be exceeded}
  oeParaTooLong       = oeFirst + 12;
    {This error is reported by an editor control when the limit on the length
    of an individual paragraph is reached, and the requested operation would
    cause it to be exceeded}
  oeCustomError       = 32768;
    {the first error code reserved for user applications. All }
    {error values less than this value are reserved for use by}
    {Orpheus}

{*** Field class and type constant id's ***}

const
  {Field class codes}
  fcSimple     =  0;
  fcPicture    =  1;
  fcNumeric    =  2;

  {Field class divisor}
  fcpDivisor   = $40;

  {Field class prefixes}
  fcpSimple    = fcpDivisor*fcSimple;
  fcpPicture   = fcpDivisor*fcPicture;
  fcpNumeric   = fcpDivisor*fcNumeric;

  {Field type IDs for simple fields}
  fidSimpleString    = fcpSimple+fsubString;
  fidSimpleChar      = fcpSimple+fsubChar;
  fidSimpleBoolean   = fcpSimple+fsubBoolean;
  fidSimpleYesNo     = fcpSimple+fsubYesNo;
  fidSimpleLongInt   = fcpSimple+fsubLongInt;
  fidSimpleWord      = fcpSimple+fsubWord;
  fidSimpleInteger   = fcpSimple+fsubInteger;
  fidSimpleByte      = fcpSimple+fsubByte;
  fidSimpleShortInt  = fcpSimple+fsubShortInt;
  fidSimpleReal      = fcpSimple+fsubReal;
  fidSimpleExtended  = fcpSimple+fsubExtended;
  fidSimpleDouble    = fcpSimple+fsubDouble;
  fidSimpleSingle    = fcpSimple+fsubSingle;
  fidSimpleComp      = fcpSimple+fsubComp;

  {Field type IDs for picture fields}
  fidPictureString   = fcpPicture+fsubString;
  fidPictureChar     = fcpPicture+fsubChar;
  fidPictureBoolean  = fcpPicture+fsubBoolean;
  fidPictureYesNo    = fcpPicture+fsubYesNo;
  fidPictureLongInt  = fcpPicture+fsubLongInt;
  fidPictureWord     = fcpPicture+fsubWord;
  fidPictureInteger  = fcpPicture+fsubInteger;
  fidPictureByte     = fcpPicture+fsubByte;
  fidPictureShortInt = fcpPicture+fsubShortInt;
  fidPictureReal     = fcpPicture+fsubReal;
  fidPictureExtended = fcpPicture+fsubExtended;
  fidPictureDouble   = fcpPicture+fsubDouble;
  fidPictureSingle   = fcpPicture+fsubSingle;
  fidPictureComp     = fcpPicture+fsubComp;
  fidPictureDate     = fcpPicture+fsubDate;
  fidPictureTime     = fcpPicture+fsubTime;

  {Field type IDs for numeric fields}
  fidNumericLongInt  = fcpNumeric+fsubLongInt;
  fidNumericWord     = fcpNumeric+fsubWord;
  fidNumericInteger  = fcpNumeric+fsubInteger;
  fidNumericByte     = fcpNumeric+fsubByte;
  fidNumericShortInt = fcpNumeric+fsubShortInt;
  fidNumericReal     = fcpNumeric+fsubReal;
  fidNumericExtended = fcpNumeric+fsubExtended;
  fidNumericDouble   = fcpNumeric+fsubDouble;
  fidNumericSingle   = fcpNumeric+fsubSingle;
  fidNumericComp     = fcpNumeric+fsubComp;


function GetOrphStr(Index : Word) : string;
  {-return a string from our RCDATA string resource}

implementation

function GetOrphStr(Index : Word) : string;
begin
  Result := ResourceStrByNumber(Index);
  if Result = '' then
    Result := 'Unknown';
end;


procedure InitAlphaCharSet;
  {-Initialize AlphaOnlySet}
var
  C : AnsiChar;
begin
  AlphaCharSet  := ['A'..'Z', 'a'..'z', ' ', '-', '.', ','];
  for C := #128 to #255 do
    {ask windows what other characters are considered alphas}
    if IsCharAlpha(C) then
      AlphaCharSet := AlphaCharSet + [C];
end;

initialization
  InitAlphaCharSet;

end.
