home *** CD-ROM | disk | FTP | other *** search
/ PC World Komputer 1997 May / Pcwk0597.iso / borland / cb / setup / cbuilder / data.z / PENWIN.PAS < prev    next >
Pascal/Delphi Source File  |  1997-02-28  |  103KB  |  2,158 lines
  1.  
  2. {*******************************************************}
  3. {                                                       }
  4. {       Delphi Runtime Library                          }
  5. {       Windows 32bit API Interface Unit                }
  6. {                                                       }
  7. {       Copyright (c) 1994,96 Borland International     }
  8. {                                                       }
  9. {*******************************************************}
  10.  
  11. unit PenWin;
  12.  
  13. { Pen Windows functions, types, and definitions  }
  14.  
  15. { "FBC" in the comments means that the feature exists only for
  16.   backward compatibility. It should not be used by new applications. }
  17.   
  18. interface
  19.  
  20. uses Windows, Messages, MMSystem;
  21.  
  22. { Enabled Alphabet: }
  23.  
  24. const
  25.   ALC_DEFAULT              = $00000000;  { nothing }
  26.   ALC_LCALPHA              = $00000001;  { a..z }
  27.   ALC_UCALPHA              = $00000002;  { A..Z }
  28.   ALC_NUMERIC              = $00000004;  { 0..9 }
  29.   ALC_PUNC                 = $00000008;  { !-;`"?()&.,; and backslash }
  30.   ALC_MATH                 = $00000010;  // %^*()-+={}<>,/.
  31.   ALC_MONETARY             = $00000020;  { ,.$ or local }
  32.   ALC_OTHER                = $00000040;  { @#|_~[] }
  33.   ALC_ASCII                = $00000080;  { restrict to 7-bit chars 20..7f }
  34.   ALC_WHITE                = $00000100;  { white space }
  35.   ALC_NONPRINT             = $00000200;  { sp tab ret ctrl glyphs }
  36.   ALC_DBCS                 = $00000400;  { allow DBCS variety of SBCS }
  37.   ALC_JIS1                 = $00000800;  { kanji JPN, ShiftJIS 1 only }
  38.   ALC_GESTURE              = $00004000;  { gestures }
  39.   ALC_USEBITMAP            = $00008000;  { use rc.rgbfAlc to enable chars }
  40.   ALC_HIRAGANA             = $00010000;  { hiragana JPN }
  41.   ALC_KATAKANA             = $00020000;  { katakana JPN }
  42.   ALC_KANJI                = $00040000;  { kanji JPN, ShiftJIS 1+2+3 }
  43.   ALC_GLOBALPRIORITY       = $10000000; 
  44.   ALC_OEM                  = $0FF80000;  { OEM recognizer-specific }
  45.   ALC_RESERVED             = $E0003000;  { avail for future use }
  46.   ALC_NOPRIORITY           = $00000000;  { for alcPriority = none }
  47.  
  48.   ALC_ALPHA                = ALC_LCALPHA or ALC_UCALPHA;
  49.   ALC_ALPHANUMERIC         = ALC_ALPHA or ALC_NUMERIC;
  50.   ALC_SYSMINIMUM = ALC_ALPHANUMERIC or ALC_PUNC or ALC_WHITE or ALC_GESTURE;
  51.   ALC_ALL = ALC_SYSMINIMUM or ALC_MATH or ALC_MONETARY or ALC_OTHER or ALC_NONPRINT;
  52.   ALC_KANJISYSMINIMUM = ALC_SYSMINIMUM or ALC_HIRAGANA or ALC_KATAKANA or ALC_JIS1;
  53.   ALC_KANJIALL = ALC_ALL or ALC_HIRAGANA or ALC_KATAKANA or ALC_KANJI;
  54.  
  55. { box edit styles: }
  56.  
  57.   BXS_NONE                 = $0000;  { none }
  58.   BXS_RECT                 = $0001;  { use rectangle instead of cusp }
  59.   BXS_BOXCROSS             = $0004;  { use cross at box center }
  60.   BXS_MASK                 = $0007;  { mask for above }
  61.  
  62. { Public Bitmaps : }
  63.  
  64.   OBM_SKBBTNUP                = 32767; 
  65.   OBM_SKBBTNDOWN              = 32766; 
  66.   OBM_SKBBTNDISABLED          = 32765; 
  67.  
  68.   OBM_ZENBTNUP                = 32764; 
  69.   OBM_ZENBTNDOWN              = 32763; 
  70.   OBM_ZENBTNDISABLED          = 32762; 
  71.  
  72.   OBM_HANBTNUP                = 32761; 
  73.   OBM_HANBTNDOWN              = 32760; 
  74.   OBM_HANBTNDISABLED          = 32759; 
  75.  
  76.   OBM_KKCBTNUP                = 32758; 
  77.   OBM_KKCBTNDOWN              = 32757; 
  78.   OBM_KKCBTNDISABLED          = 32756; 
  79.  
  80.   OBM_SIPBTNUP                = 32755; 
  81.   OBM_SIPBTNDOWN              = 32754; 
  82.   OBM_SIPBTNDISABLED          = 32753; 
  83.  
  84.   OBM_PTYBTNUP                = 32752; 
  85.   OBM_PTYBTNDOWN              = 32751; 
  86.   OBM_PTYBTNDISABLED          = 32750; 
  87.  
  88. { Default pen cursor to indicate writing, points northwest }
  89.   IDC_PEN             = MAKEINTRESOURCE(32631); 
  90.  
  91. { alternate select cursor: upsidedown standard arrow, points southeast }
  92.   IDC_ALTSELECT       = MAKEINTRESOURCE(32501); 
  93.  
  94. { special SYV values: }
  95.   SYV_NULL                    = $00000000; 
  96.   SYV_UNKNOWN                 = $00000001; 
  97.   SYV_EMPTY                   = $00000003; 
  98.   SYV_BEGINOR                 = $00000010; 
  99.   SYV_ENDOR                   = $00000011; 
  100.   SYV_OR                      = $00000012; 
  101.   SYV_SOFTNEWLINE             = $00000020; 
  102.   SYV_SPACENULL               = $00010000;    { SyvCharacterToSymbol('\0') }
  103.  
  104. { SYV values for gestures: }
  105.   SYV_SELECTFIRST             = $0002FFC0;    { . means circle in following }
  106.   SYV_LASSO                   = $0002FFC1;    { lasso o-tap }
  107.   SYV_SELECTLEFT              = $0002FFC2;    { no glyph }
  108.   SYV_SELECTRIGHT             = $0002FFC3;    { no glyph }
  109.   SYV_SELECTLAST              = $0002FFCF;    { 16 SYVs reserved for selection }
  110.  
  111.   SYV_CLEARCHAR               = $0002FFD2;    { d. }
  112.   SYV_HELP                    = $0002FFD3;    { no glyph }
  113.   SYV_KKCONVERT               = $0002FFD4;    { k. }
  114.   SYV_CLEAR                   = $0002FFD5;    { d. }
  115.   SYV_INSERT                  = $0002FFD6;    { ^. }
  116.   SYV_CONTEXT                 = $0002FFD7;    { m. }
  117.   SYV_EXTENDSELECT            = $0002FFD8;    { no glyph }
  118.   SYV_UNDO                    = $0002FFD9;    { u. }
  119.   SYV_COPY                    = $0002FFDA;    { c. }
  120.   SYV_CUT                     = $0002FFDB;    { x. }
  121.   SYV_PASTE                   = $0002FFDC;    { p. }
  122.   SYV_CLEARWORD               = $0002FFDD;    { no glyph }
  123.   SYV_USER                    = $0002FFDE;    { reserved }
  124.   SYV_CORRECT                 = $0002FFDF;    { check. }
  125.  
  126.   SYV_BACKSPACE               = $00020008;    { no glyph }
  127.   SYV_TAB                     = $00020009;    { t. }
  128.   SYV_RETURN                  = $0002000D;    { n. }
  129.   SYV_SPACE                   = $00020020;    { s. }
  130.  
  131. { Application specific gestures, Circle a-z and Circle A-Z: }
  132.   SYV_APPGESTUREMASK          = $00020000; 
  133.   SYV_CIRCLEUPA               = $000224B6;    { map into Unicode space }
  134.   SYV_CIRCLEUPZ               = $000224CF;    {  for circled letters }
  135.   SYV_CIRCLELOA               = $000224D0; 
  136.   SYV_CIRCLELOZ               = $000224E9; 
  137.  
  138. { SYV definitions for shapes: }
  139.   SYV_SHAPELINE               = $00040001; 
  140.   SYV_SHAPEELLIPSE            = $00040002; 
  141.   SYV_SHAPERECT               = $00040003; 
  142.   SYV_SHAPEMIN                = SYV_SHAPELINE; { alias }
  143.   SYV_SHAPEMAX                = SYV_SHAPERECT; { alias }
  144.  
  145. { SYV classes: }
  146.   SYVHI_SPECIAL               = 0; 
  147.   SYVHI_ANSI                  = 1; 
  148.   SYVHI_GESTURE               = 2; 
  149.   SYVHI_KANJI                 = 3; 
  150.   SYVHI_SHAPE                 = 4; 
  151.   SYVHI_UNICODE               = 5; 
  152.   SYVHI_VKEY                  = 6; 
  153.  
  154. { IEdit Pop-up Menu Command Items }
  155.  
  156.   IEM_UNDO                    = 1;         { Undo }
  157.   IEM_CUT                     = 2;         { Cut }
  158.   IEM_COPY                    = 3;         { Copy }
  159.   IEM_PASTE                   = 4;         { Paste }
  160.   IEM_CLEAR                   = 5;         { Clear }
  161.   IEM_SELECTALL               = 6;         { Select All Strokes }
  162.   IEM_ERASE                   = 7;         { Use Eraser }
  163.   IEM_PROPERTIES              = 8;         { DoProperties }
  164.   IEM_LASSO                   = 9;         { Use Lasso }
  165.   IEM_RESIZE                  = 10;        { Resize }
  166.  
  167.   IEM_USER                        = 100;   { first menu item# available to app }
  168.  
  169. { IEdit Style Attributes }
  170.   IES_BORDER                  = $0001;   { ctl has a border }
  171.   IES_HSCROLL                 = $0002;   { ctl is horizontally scrollable }
  172.   IES_VSCROLL                 = $0004;   { ctl is vertically scrollable }
  173.   IES_OWNERDRAW               = $0008;   { ctl will be drawn by parent window }
  174.  
  175. { PenData API constants: }
  176.  
  177. { ANIMATEINFO callback options: }
  178.   AI_CBSTROKE                 = $FFFF;  { Animate callback after every stroke }
  179.  
  180. { ANIMATEINFO options: }
  181.   AI_SKIPUPSTROKES            = $0001;  { ignore upstrokes in animation }
  182.  
  183. { CompressPenData() API options: }
  184.   CMPD_COMPRESS               = $0001; 
  185.   CMPD_DECOMPRESS             = $0002; 
  186.  
  187. { CreatePenDataRegion types: }
  188.   CPDR_BOX                    = 1;      { bounding box }
  189.   CPDR_LASSO                  = 2;      { lasso }
  190.  
  191. { CreatePenData (CPD) and Pen Hardware (PHW) Flags; }
  192. { The order of PHW flags is important: }
  193.   CPD_DEFAULT                 = $047F;  { CPD_TIME | PHW_ALL }
  194.   CPD_USERBYTE                = $0100;  { alloc 8 bits/stroke }
  195.   CPD_USERWORD                = $0200;  { alloc 16 bits/stroke }
  196.   CPD_USERDWORD               = $0300;  { alloc 32 bits/stroke }
  197.   CPD_TIME                    = $0400;  { maintain abs time info per stroke }
  198.  
  199. { DrawPenDataEx() flags/options: }
  200.   DPD_HDCPEN                  = $0001;  { use pen selected in HDC }
  201.   DPD_DRAWSEL                 = $0002;  { draw the selection }
  202.  
  203. { ExtractPenDataPoints options (EPDP_xx): }
  204.   EPDP_REMOVE                 = $0001;  { Remove points from the pendata }
  205.  
  206. { ExtractPenDataStrokes options and modifiers (EPDS_xx): }
  207.   EPDS_SELECT                 = 1;      { selected strokes }
  208.   EPDS_STROKEINDEX            = 2;      { index }
  209.   EPDS_USER                   = 3;      { user-specific value }
  210.   EPDS_PENTIP                 = 4;      { complete pentip }
  211.   EPDS_TIPCOLOR               = 5;      { pentip color }
  212.   EPDS_TIPWIDTH               = 6;      { pentip width }
  213.   EPDS_TIPNIB                 = 7;      { pentip nib style }
  214.   EPDS_INKSET                 = 8;      { inkset match }
  215.  
  216.   EPDS_EQ                     = $0000;  { default: same as }
  217.   EPDS_LT                     = $0010;  { all strokes less than }
  218.   EPDS_GT                     = $0020;  { all strokes greater than }
  219.   EPDS_NOT                    = $0040;  { all strokes not matching }
  220.   EPDS_NE                     = $0040;  { alias }
  221.   EPDS_GTE                    = $0050;  { alias for NOT LT }
  222.   EPDS_LTE                    = $0060;  { alias for NOT GT }
  223.  
  224.   EPDS_REMOVE                 = $8000;  { remove matching strokes from source }
  225.  
  226. { GetPenDataAttributes options (GPA_xx): }
  227.   GPA_MAXLEN                  = 1;  { length of longest stroke }
  228.   GPA_POINTS                  = 2;  { total number of points }
  229.   GPA_PDTS                    = 3;  { PDTS_xx bits }
  230.   GPA_RATE                    = 4;  { get sampling rate }
  231.   GPA_RECTBOUND               = 5;  { bounding rect of all points }
  232.   GPA_RECTBOUNDINK            = 6;  { ditto, adj for fat ink }
  233.   GPA_SIZE                    = 7;  { size of pendata in bytes }
  234.   GPA_STROKES                 = 8;  { total number of strokes }
  235.   GPA_TIME                    = 9;  { absolute time at creation of pendata }
  236.   GPA_USER                    = 10; { number of user bytes available: 0, 1, 2, 4 }
  237.   GPA_VERSION                 = 11; { version number of pendata }
  238.  
  239. { GetStrokeAttributes options (GSA_xx): }
  240.   GSA_PENTIP                  = 1;  { get stroke pentip (color, width, nib) }
  241.   GSA_PENTIPCLASS             = 2;  { same as GSA_PENTIP }
  242.   GSA_USER                    = 3;  { get stroke user value }
  243.   GSA_USERCLASS               = 4;  { get stroke's class user value }
  244.   GSA_TIME                    = 5;  { get time of stroke }
  245.   GSA_SIZE                    = 6;  { get size of stroke in points and bytes }
  246.   GSA_SELECT                  = 7;  { get selection status of stroke }
  247.   GSA_DOWN                    = 8;  { get up/down state of stroke }
  248.   GSA_RECTBOUND               = 9;  { get the bounding rectangle of the stroke }
  249.  
  250. { GetStrokeTableAttributes options (GSA_xx): }
  251.   GSA_PENTIPTABLE             = 10; { get table-indexed pentip }
  252.   GSA_SIZETABLE               = 11; { get count of Stroke Class Table entries }
  253.   GSA_USERTABLE               = 12; { get table-indexed user value }
  254.  
  255.   IX_END                      = $FFFF;  { to or past last available index }
  256.  
  257. { PenTip: }
  258.   PENTIP_NIBDEFAULT           = (0);            { default pen tip nib style }
  259.   PENTIP_HEIGHTDEFAULT        = (0);            { default pen tip nib height }
  260.   PENTIP_OPAQUE               = $FF;            { default opaque ink }
  261.   PENTIP_HILITE               = $80; 
  262.   PENTIP_TRANSPARENT          = (0); 
  263.  
  264. { General PenData API return values (PDR_xx): }
  265.   PDR_NOHIT                   = 3;      { hit test failed }
  266.   PDR_HIT                     = 2;      { hit test succeeded }
  267.   PDR_OK                      = 1;      { success }
  268.   PDR_CANCEL                  = 0;      { callback cancel or impasse }
  269.  
  270.   PDR_ERROR                   = -1;     { parameter or unspecified error }
  271.   PDR_PNDTERR                 = -2;     { bad pendata }
  272.   PDR_VERSIONERR              = -3;     { pendata version error }
  273.   PDR_COMPRESSED              = -4;     { pendata is compressed }
  274.   PDR_STRKINDEXERR            = -5;     { stroke index error }
  275.   PDR_PNTINDEXERR             = -6;     { point index error }
  276.   PDR_MEMERR                  = -7;     { memory error }
  277.   PDR_INKSETERR               = -8;     { bad inkset }
  278.   PDR_ABORT                   = -9;     { pendata has become invalid, e.g. }
  279.   PDR_NA                      = -10;    { option not available (pw kernel) }
  280.  
  281.   PDR_USERDATAERR             = -16;    { user data error }
  282.   PDR_SCALINGERR              = -17;    { scale error }
  283.   PDR_TIMESTAMPERR            = -18;    { timestamp error }
  284.   PDR_OEMDATAERR              = -19;    { OEM data error }
  285.   PDR_SCTERR                  = -20;    { SCT error (full) }
  286.  
  287. { PenData Scaling (PDTS): }
  288.   PDTS_LOMETRIC               = 0;      { 0.01mm }
  289.   PDTS_HIMETRIC               = 1;      { 0.001mm }
  290.   PDTS_HIENGLISH              = 2;      { 0.001" }
  291.   PDTS_STANDARDSCALE          = 2;      { PDTS_HIENGLISH   alias }
  292.   PDTS_DISPLAY                = 3;      { display pixel }
  293.   PDTS_ARBITRARY              = 4;      { app-specific scaling }
  294.   PDTS_SCALEMASK              = $000F;  { scaling values in low nibble }
  295.  
  296. { CompactPenData API trim options: }
  297.   PDTT_DEFAULT                = $0000; 
  298.   PDTT_PENINFO                = $0100; 
  299.   PDTT_UPPOINTS               = $0200; 
  300.   PDTT_OEMDATA                = $0400; 
  301.   PDTT_COLLINEAR              = $0800; 
  302.   PDTT_COLINEAR               = $0800;  { alt sp alias }
  303.   PDTT_DECOMPRESS             = $4000;  { decompress the data }
  304.   PDTT_COMPRESS               = $8000; 
  305.   PDTT_ALL                    = $0F00;  { PENINFO|UPPOINTS|OEMDATA|COLLINEAR }
  306.  
  307.   PHW_NONE                    = $0000;  { no OEMdata }
  308.   PHW_PRESSURE                = $0001;  { report pressure in OEMdata if avail }
  309.   PHW_HEIGHT                  = $0002;  { ditto height }
  310.   PHW_ANGLEXY                 = $0004;  { ditto xy angle }
  311.   PHW_ANGLEZ                  = $0008;  { ditto z angle }
  312.   PHW_BARRELROTATION          = $0010;  { ditto barrel rotation }
  313.   PHW_OEMSPECIFIC             = $0020;  { ditto OEM-specific value }
  314.   PHW_PDK                     = $0040;  { report per-point PDK_xx in OEM data }
  315.   PHW_ALL                     = $007F;  { report everything }
  316.  
  317. { compact pen data trim options: matches PDTT_values (see above) }
  318.   PDTS_COMPRESS2NDDERIV       = $0010;  { compress using 2nd deriv }
  319.   PDTS_COMPRESSMETHOD         = $00F0;  { sum of compress method flags }
  320.   PDTS_NOPENINFO              = $0100;  { removes PENINFO struct from header }
  321.   PDTS_NOUPPOINTS             = $0200;  { remove up pts }
  322.   PDTS_NOOEMDATA              = $0400;  { remove OEM data }
  323.   PDTS_NOCOLLINEAR            = $0800;  { remove successive identical pts }
  324.   PDTS_NOCOLINEAR             = $0800;  { alt sp alias }
  325.   PDTS_NOTICK                 = $1000;  { remove timing info (2.0) }
  326.   PDTS_NOUSER                 = $2000;  { remove user info (2.0) }
  327.   PDTS_NOEMPTYSTROKES         = $4000;  { remove empty strokes (2.0) }
  328.   PDTS_COMPRESSED             = $8000;  { perform lossless compression }
  329.  
  330. { SetStrokeAttributes options (SSA_xx): }
  331.   SSA_PENTIP                  = 1;      { set stroke tip (color, width, nib) }
  332.   SSA_PENTIPCLASS             = 2;      { set stroke's class pentip }
  333.   SSA_USER                    = 3;      { set stroke user value }
  334.   SSA_USERCLASS               = 4;      { set stroke's class user value }
  335.   SSA_TIME                    = 5;      { set time of stroke }
  336.   SSA_SELECT                  = 6;      { set selection status of stroke }
  337.   SSA_DOWN                    = 7;      { set up/down state of stroke }
  338.  
  339. { SetStrokeTableAttributes options (SSA_xx): }
  340.   SSA_PENTIPTABLE             = 8;      { set table-indexed pentip }
  341.   SSA_USERTABLE               = 9;      { set table-indexed user value }
  342.  
  343. { PenTip flag bits: }
  344.   TIP_ERASECOLOR              = 1;      { erase specific color pentip.rgb }
  345.  
  346. { TrimPenData() API options: }
  347.   TPD_RECALCSIZE              = $0000;  { no trim, used for resize calc }
  348.   TPD_USER                    = $0080;  { per-stroke user info }
  349.   TPD_TIME                    = $0100;  { per-stroke timing info }
  350.   TPD_UPPOINTS                = $0200;  { x-y data up points }
  351.   TPD_COLLINEAR               = $0400;  { colinear and coincident points }
  352.   TPD_COLINEAR                = $0400;  { alt sp alias }
  353.   TPD_PENINFO                 = $0800;  { PenInfo struct and all OEM }
  354.   TPD_PHW                     = $1000;  { OEM & pdk except stroke tick or user }
  355.   TPD_OEMDATA                 = $1000;  { ditto }
  356.   TPD_EMPTYSTROKES            = $2000;  { strokes with zero points }
  357.   TPD_EVERYTHING              = $3FFF;  { everything (incl PHW_xx) except down pts }
  358.  
  359. { Dictionary: }
  360.  
  361.   cbDictPathMax               = 255; 
  362.   DIRQ_QUERY                  = 1; 
  363.   DIRQ_DESCRIPTION            = 2; 
  364.   DIRQ_CONFIGURE              = 3; 
  365.   DIRQ_OPEN                   = 4; 
  366.   DIRQ_CLOSE                  = 5; 
  367.   DIRQ_SETWORDLISTS           = 6; 
  368.   DIRQ_STRING                 = 7; 
  369.   DIRQ_SUGGEST                = 8; 
  370.   DIRQ_ADD                    = 9; 
  371.   DIRQ_DELETE                 = 10; 
  372.   DIRQ_FLUSH                  = 11; 
  373.   DIRQ_RCCHANGE               = 12; 
  374.   DIRQ_SYMBOLGRAPH            = 13; 
  375.   DIRQ_INIT                   = 14; 
  376.   DIRQ_CLEANUP                = 15; 
  377.   DIRQ_COPYRIGHT              = 16; 
  378.   DIRQ_USER                   = 4096; 
  379.  
  380. { Pen driver: }
  381.  
  382.   BITPENUP                    = $8000; 
  383.  
  384. { Pen Driver messages: }
  385.   DRV_SetPenDriverEntryPoints         = DRV_RESERVED+1; 
  386.   DRV_SetEntryPoints                  = DRV_RESERVED+1; { alias }
  387.   DRV_RemovePenDriverEntryPoints      = DRV_RESERVED+2; 
  388.   DRV_RemoveEntryPoints               = DRV_RESERVED+2; { alias }
  389.   DRV_SetPenSamplingRate              = DRV_RESERVED+3; 
  390.   DRV_SetPenSamplingDist              = DRV_RESERVED+4; 
  391.   DRV_GetName                         = DRV_RESERVED+5; 
  392.   DRV_GetVersion                      = DRV_RESERVED+6; 
  393.   DRV_GetPenInfo                      = DRV_RESERVED+7; 
  394.   DRV_PenPlayStart                    = DRV_RESERVED+8; 
  395.   DRV_PenPlayBack                     = DRV_RESERVED+9; 
  396.   DRV_PenPlayStop                     = DRV_RESERVED+10; 
  397.   DRV_GetCalibration                  = DRV_RESERVED+11; 
  398.   DRV_SetCalibration                  = DRV_RESERVED+12; 
  399.   DRV_Reserved1                       = DRV_RESERVED+13; 
  400.   DRV_Reserved2                       = DRV_RESERVED+14; 
  401.   DRV_Query                           = DRV_RESERVED+15; 
  402.   DRV_GetPenSamplingRate              = DRV_RESERVED+16; 
  403.   DRV_Calibrate                       = DRV_RESERVED+17; 
  404.  
  405. { Pen Driver Playback constants: }
  406.   PLAY_VERSION_10_DATA     = 0; 
  407.   PLAY_VERSION_20_DATA     = 1; 
  408.  
  409. { Pen Driver return values: }
  410.   DRV_FAILURE                 = $00000000; 
  411.   DRV_SUCCESS                 = $00000001; 
  412.   DRV_BADPARAM1               = $FFFFFFFF; 
  413.   DRV_BADPARAM2               = $FFFFFFFE; 
  414.   DRV_BADSTRUCT               = $FFFFFFFD; 
  415.  
  416. { Pen Driver register messages flags: }
  417.   PENREG_DEFAULT              = $00000002; 
  418.   PENREG_WILLHANDLEMOUSE      = $00000001; 
  419.  
  420.   MAXOEMDATAWORDS             = 6;            { rgwOemData[MAXOEMDATAWORDS] }
  421.   
  422.   RC_LDEFAULTFLAGS            = $80000000;
  423.  
  424. { Pen Collection Mode termination conditions: }
  425. { (note update doc for PCMINFO struct if change these) }
  426.   PCM_PENUP                   = $00000001;    { stop on penup }
  427.   PCM_RANGE                   = $00000002;    { stop on leaving range }
  428.   PCM_INVERT                  = $00000020;    { stop on tap of opposite end }
  429.   PCM_RECTEXCLUDE             = $00002000;    { click in exclude rect }
  430.   PCM_RECTBOUND               = $00004000;    { click outside bounds rect }
  431.   PCM_TIMEOUT                 = $00008000;    { no activity for timeout ms }
  432. { new for 2.0: }
  433.   PCM_RGNBOUND                = $00010000;    { click outside bounding region }
  434.   PCM_RGNEXCLUDE              = $00020000;    { click in exclude region }
  435.   PCM_DOPOLLING               = $00040000;    { polling mode }
  436.   PCM_TAPNHOLD                = $00080000;    { check for Tap And Hold }
  437.   PCM_ADDDEFAULTS             = RC_LDEFAULTFLAGS; { $80000000 }
  438.  
  439. { Pen Device Capabilities: }
  440.   PDC_INTEGRATED              = $00000001;    { display=digitizer }
  441.   PDC_PROXIMITY               = $00000002;    { detect non-contacting pen }
  442.   PDC_RANGE                   = $00000004;    { event on out-of-range }
  443.   PDC_INVERT                  = $00000008;    { pen opposite end detect }
  444.   PDC_RELATIVE                = $00000010;    { pen driver coords }
  445.   PDC_BARREL1                 = $00000020;    { barrel button 1 present }
  446.   PDC_BARREL2                 = $00000040;    { ditto 2 }
  447.   PDC_BARREL3                 = $00000080;    { ditto 3 }
  448.  
  449. { Pen Driver Kit states: }
  450.   PDK_NULL                    = $0000;  { default to no flags set }
  451.   PDK_UP                      = $0000;  { PDK_NULL alias }
  452.   PDK_DOWN                    = $0001;  { pentip switch ON due to contact }
  453.   PDK_BARREL1                 = $0002;  { barrel1 switch depressed }
  454.   PDK_BARREL2                 = $0004;  { ditto 2 }
  455.   PDK_BARREL3                 = $0008;  { ditto 3 }
  456.   PDK_SWITCHES                = $000F;  { sum of down + barrels 1,2,3 }
  457.   PDK_UNUSED10                = $0020; 
  458.   PDK_UNUSED20                = $0040; 
  459.   PDK_INVERTED                = $0080;  { other end of pen used as tip }
  460.   PDK_PENIDMASK               = $0F00;  { bits 8..11 physical pen id (0..15) }
  461.   PDK_UNUSED1000              = $1000; 
  462.   PDK_INKSTOPPED              = $2000;  { Inking stopped }
  463.   PDK_OUTOFRANGE              = $4000;  { pen left range (OEM data invalid) }
  464.   PDK_DRIVER                  = $8000;  { pen (not mouse) event }
  465.  
  466.   PDK_TIPMASK                 = $0001;  { mask for testing PDK_DOWN }
  467.  
  468. { OEM-specific values for Pen Driver: }
  469.   PDT_NULL                    = 0; 
  470.   PDT_PRESSURE                = 1;      { pressure supported }
  471.   PDT_HEIGHT                  = 2;      { height above tablet }
  472.   PDT_ANGLEXY                 = 3;      { xy (horiz) angle supported }
  473.   PDT_ANGLEZ                  = 4;      { z (vert) angle supported }
  474.   PDT_BARRELROTATION          = 5;      { barrel is rotated }
  475.   PDT_OEMSPECIFIC             = 16;     { max }
  476.  
  477. { Denotes the ID of the current packet }
  478.   PID_CURRENT                 = -1; 
  479.  
  480. { Handwriting Recognizer: }
  481.  
  482. { GetResultsHRC options: }
  483.   GRH_ALL                     = 0;      { get all results }
  484.   GRH_GESTURE                 = 1;      { get only gesture results }
  485.   GRH_NONGESTURE              = 2;      { get all but gesture results }
  486.  
  487. { Gesture sets for EnableGestureSetHRC (bit flags): }
  488.   GST_SEL                     = $00000001;    { sel & lasso }
  489.   GST_CLIP                    = $00000002;    { cut copy paste }
  490.   GST_WHITE                   = $00000004;    { sp tab ret }
  491.   GST_KKCONVERT               = $00000008;    { kkconvert }
  492.   GST_EDIT                    = $00000010;    { insert correct undo clear }
  493.   GST_SYS                     = $00000017;    { all of the above }
  494.   GST_CIRCLELO                = $00000100;    { lowercase circle }
  495.   GST_CIRCLEUP                = $00000200;    { uppercase circle }
  496.   GST_CIRCLE                  = $00000300;    { all circle }
  497.   GST_ALL                     = $00000317;    { all of the above }
  498.  
  499. { General HRC API return values (HRCR_xx): }
  500.   HRCR_NORESULTS              = 4;      { No possible results  to be found }
  501.   HRCR_COMPLETE               = 3;      { finished recognition }
  502.   HRCR_GESTURE                = 2;      { recognized gesture }
  503.   HRCR_OK                     = 1;      { success }
  504.   HRCR_INCOMPLETE             = 0;      { recognizer is processing input }
  505.   HRCR_ERROR                  = -1;     { invalid param or unspecified error }
  506.   HRCR_MEMERR                 = -2;     { memory error }
  507.   HRCR_INVALIDGUIDE           = -3;     { invalid GUIDE struct }
  508.   HRCR_INVALIDPNDT            = -4;     { invalid pendata }
  509.   HRCR_UNSUPPORTED            = -5;     { recognizer does not support feature }
  510.   HRCR_CONFLICT               = -6;     { training conflict }
  511.   HRCR_HOOKED                 = -8;     { hookasaurus ate the result }
  512.  
  513. { system wordlist for AddWordsHWL: }
  514.   HWL_SYSTEM                  = (1);       { magic value means system wordlist }
  515.  
  516. { inkset returns: }
  517.   ISR_ERROR                   = -1;     { Memory or other error }
  518.   ISR_BADINKSET               = -2;     { bad source inkset }
  519.   ISR_BADINDEX                = -3;     { bad inkset index }
  520.  
  521.   MAXHOTSPOT                  = 8;      { max number of hotspots possible }
  522.  
  523. { ProcessHRC time constants: }
  524.   PH_MAX                      = $FFFFFFFF;    { recognize rest of ink }
  525.   PH_DEFAULT                  = $FFFFFFFE;    { reasonable time }
  526.   PH_MIN                      = $FFFFFFFD;    { minimum time }
  527.  
  528. { ResultsHookHRC options: }
  529.   RHH_STD                     = 0;      { GetResultsHRC }
  530.   RHH_BOX                     = 1;      { GetBoxResultsHRC }
  531.  
  532. { SetWordlistCoercionHRC options: }
  533.   SCH_NONE                    = 0;      { turn off coercion }
  534.   SCH_ADVISE                  = 1;      { macro is hint only }
  535.   SCH_FORCE                   = 2;      { some result is forced from macro }
  536.  
  537. { Symbol Context Insert Modes }
  538.   SCIM_INSERT                 = 0;      { insert }
  539.   SCIM_OVERWRITE              = 1;      { overwrite }
  540.  
  541. { SetResultsHookHREC options: }
  542.   SRH_HOOKALL                 = 1;      { hook all recognizers }
  543.  
  544. { SetInternationalHRC options: }
  545.   SSH_RD                      = 1;      { to right and down (English) }
  546.   SSH_RU                      = 2;      { to right and up }
  547.   SSH_LD                      = 3;      { to left and down (Hebrew) }
  548.   SSH_LU                      = 4;      { to left and up }
  549.   SSH_DL                      = 5;      { down and to the left (Chinese) }
  550.   SSH_DR                      = 6;      { down and to the right (Chinese) }
  551.   SSH_UL                      = 7;      { up and to the left }
  552.   SSH_UR                      = 8;      { up and to the right }
  553.  
  554.   SIH_ALLANSICHAR             = 1;      { use all ANSI }
  555.  
  556. { TrainHREC options: }
  557.   TH_QUERY                    = 0;      { query the user if conflict }
  558.   TH_FORCE                    = 1;      { ditto no query }
  559.   TH_SUGGEST                  = 2;      { abandon training if conflict }
  560.  
  561. { Return values for WCR_TRAIN Function }
  562.   TRAIN_NONE                  = $0000; 
  563.   TRAIN_DEFAULT               = $0001; 
  564.   TRAIN_CUSTOM                = $0002; 
  565.   TRAIN_BOTH                  = TRAIN_DEFAULT or TRAIN_CUSTOM; 
  566.  
  567. { Control values for TRAINSAVE }
  568.   TRAIN_SAVE                  = 0;      { save changes that have been made }
  569.   TRAIN_REVERT                = 1;      { discard changes that have been made }
  570.   TRAIN_RESET                 = 2;      { use factory settings }
  571.  
  572. { ConfigRecognizer and ConfigHREC options: }
  573.   WCR_RECOGNAME               = 0;      { ConfigRecognizer 1.0 }
  574.   WCR_QUERY                   = 1; 
  575.   WCR_CONFIGDIALOG            = 2; 
  576.   WCR_DEFAULT                 = 3; 
  577.   WCR_RCCHANGE                = 4; 
  578.   WCR_VERSION                 = 5; 
  579.   WCR_TRAIN                   = 6; 
  580.   WCR_TRAINSAVE               = 7; 
  581.   WCR_TRAINMAX                = 8; 
  582.   WCR_TRAINDIRTY              = 9; 
  583.   WCR_TRAINCUSTOM             = 10; 
  584.   WCR_QUERYLANGUAGE           = 11; 
  585.   WCR_USERCHANGE              = 12; 
  586.  
  587. { ConfigHREC options: }
  588.   WCR_PWVERSION               = 13;     { ver of PenWin recognizer supports }
  589.   WCR_GETALCPRIORITY          = 14;     { get recognizer's ALC priority }
  590.   WCR_SETALCPRIORITY          = 15;     { set recognizer's ALC priority }
  591.   WCR_GETANSISTATE            = 16;     { get ALLANSICHAR state }
  592.   WCR_SETANSISTATE            = 17;     { set ALLANSICHAR if T }
  593.   WCR_GETHAND                 = 18;     { get writing hand }
  594.   WCR_SETHAND                 = 19;     { set writing hand }
  595.   WCR_GETDIRECTION            = 20;     { get writing direction }
  596.   WCR_SETDIRECTION            = 21;     { set writing direction }
  597.   WCR_INITRECOGNIZER          = 22;     { init recognizer and set user name }
  598.   WCR_CLOSERECOGNIZER         = 23;     { close recognizer }
  599.  
  600.   WCR_PRIVATE                 = 1024; 
  601.  
  602. { sub-functions of WCR_USERCHANGE }
  603.   CRUC_NOTIFY                 = 0;      { user name change }
  604.   CRUC_REMOVE                 = 1;      { user name deleted }
  605.  
  606. { Word List Types: }
  607.   WLT_STRING                  = 0;      { one string }
  608.   WLT_STRINGTABLE             = 1;      { array of strings }
  609.   WLT_EMPTY                   = 2;      { empty wordlist }
  610.   WLT_WORDLIST                = 3;      { handle to a wordlist }
  611.  
  612. { IEdit Background Options }
  613.  
  614.   IEB_DEFAULT                 = 0;      { default (use COLOR_WINDOW) }
  615.   IEB_BRUSH                   = 1;      { paint background with brush }
  616.   IEB_BIT_UL                  = 2;      { bitmap, upper-left aligned }
  617.   IEB_BIT_CENTER              = 3;      { bitmap, centered in control }
  618.   IEB_BIT_TILE                = 4;      { bitmap, tiled repeatedly in ctl }
  619.   IEB_BIT_STRETCH             = 5;      { bitmap, stretched to fit ctl }
  620.   IEB_OWNERDRAW               = 6;      { parent window will draw background }
  621.  
  622. { IEdit Drawing Options }
  623.   IEDO_NONE                   = $0000;  { no drawing }
  624.   IEDO_FAST                   = $0001;  { ink drawn as fast as possible (def) }
  625.   IEDO_SAVEUPSTROKES          = $0002;  { save upstrokes }
  626.   IEDO_RESERVED               = $FFFC;  { reserved bits }
  627.  
  628. { IEdit Input Options }
  629.   IEI_MOVE                    = $0001;  { move ink into ctl }
  630.   IEI_RESIZE                  = $0002;  { resize ink to fit within ctl }
  631.   IEI_CROP                    = $0004;  { discard ink outside of ctl }
  632.   IEI_DISCARD                 = $0008;  { discard all ink if any outside ctl }
  633.   IEI_RESERVED                = $FFF0;  { reserved }
  634.  
  635. { IEdit IE_GETINK options }
  636.   IEGI_ALL                    = $0000;  { get all ink from control }
  637.   IEGI_SELECTION              = $0001;  { get selected ink from control }
  638.  
  639. { IEdit IE_SETMODE/IE_GETMODE (mode) options }
  640.   IEMODE_READY                = 0;      { default inking, moving, sizing mode }
  641.   IEMODE_ERASE                = 1;      { erasing Mode }
  642.   IEMODE_LASSO                = 2;      { lasso selection mode }
  643.  
  644. { IEdit    Notification Bits }
  645.   IEN_NULL                    = $0000;  { null notification }
  646.   IEN_PDEVENT                 = $0001;  { notify about pointing device events }
  647.   IEN_PAINT                   = $0002;  { send painting-related notifications }
  648.   IEN_FOCUS                   = $0004;  { send focus-related notifications }
  649.   IEN_SCROLL                  = $0008;  { send scrolling notifications }
  650.   IEN_EDIT                    = $0010;  { send editing/change notifications }
  651.   IEN_PROPERTIES              = $0020;  { send properties dialog notification }
  652.   IEN_RESERVED                = $FF80;  { reserved }
  653.  
  654. { IEdit Return Values }
  655.   IER_OK                      = 0;      { success }
  656.   IER_NO                      = 0;      { ctl cannot do request }
  657.   IER_YES                     = 1;      { ctl can do request }
  658.   IER_ERROR                   = -1;     { unspecified error; operation failed }
  659.   IER_PARAMERR                = -2;     { bogus lParam value, bad handle, etc }
  660.   IER_OWNERDRAW               = -3;     { can't set drawopts in ownerdraw ctl }
  661.   IER_SECURITY                = -4;     { security protection disallows action }
  662.   IER_SELECTION               = -5;     { nothing selected in control }
  663.   IER_SCALE                   = -6;     { merge:  incompatible scaling factors }
  664.   IER_MEMERR                  = -7;     { memory error }
  665.   IER_NOCOMMAND               = -8;     { tried IE_GETCOMMAND w/no command }
  666.   IER_NOGESTURE               = -9;     { tried IE_GETGESTURE w/no gesture }
  667.   IER_NOPDEVENT               = -10;    { tried IE_GETPDEVENT but no event }
  668.   IER_NOTINPAINT              = -11;    { tried IE_GETPAINTSTRUCT but no paint }
  669.   IER_PENDATA                 = -12;    { can't do request with NULL hpd in ctl }
  670.  
  671. { IEdit Recognition Options }
  672.   IEREC_NONE                  = $0000;  { No recognition }
  673.   IEREC_GESTURE               = $0001;  { Gesture recognition }
  674. {$DEFINE IEREC_ALL}
  675.   IEREC_RESERVED              = $FFFE;  { Reserved }
  676.  
  677. { IEdit Security Options }
  678.   IESEC_NOCOPY                = $0001;  { copying disallowed }
  679.   IESEC_NOCUT                 = $0002;  { cutting disallowed }
  680.   IESEC_NOPASTE               = $0004;  { pasting disallowed }
  681.   IESEC_NOUNDO                = $0008;  { undoing disallowed }
  682.   IESEC_NOINK                 = $0010;  { inking  disallowed }
  683.   IESEC_NOERASE               = $0020;  { erasing disallowed }
  684.   IESEC_NOGET                 = $0040;  { IE_GETINK message verboten }
  685.   IESEC_NOSET                 = $0080;  { IE_SETINK message verboten }
  686.   IESEC_RESERVED              = $FF00;  { reserved }
  687.  
  688. { IEdit IE_SETFORMAT/IE_GETFORMAT options }
  689.   IESF_ALL                    = $0001;  { set/get stk fmt of all ink }
  690.   IESF_SELECTION              = $0002;  { set/get stk fmt of selected ink }
  691.   IESF_STROKE                 = $0004;  { set/get stk fmt of specified stroke }
  692.  
  693.   IESF_TIPCOLOR               = $0008;  { set color }
  694.   IESF_TIPWIDTH               = $0010;  { set width }
  695.   IESF_PENTIP                 = IESF_TIPCOLOR or IESF_TIPWIDTH; 
  696.  
  697. { IEdit IE_SETINK options }
  698.   IESI_REPLACE                = $0000;  { replace ink in control }
  699.   IESI_APPEND                 = $0001;  { append ink to existing control ink }
  700.  
  701. { Ink Edit Control (IEdit) definitions }
  702. { IEdit Notifications }
  703.   IN_PDEVENT          = (IEN_PDEVENT shl 8) or 0; { pointing device event occurred }
  704.   IN_ERASEBKGND       = (IEN_NULL shl 8) or 1; { control needs bkgnd erased }
  705.   IN_PREPAINT         = (IEN_PAINT shl 8) or 2; { before control paints its ink }
  706.   IN_PAINT            = (IEN_NULL shl 8) or 3; { control needs to be painted }
  707.   IN_POSTPAINT        = (IEN_PAINT shl 8) or 4; { after control has painted }
  708.   IN_MODECHANGED      = (IEN_EDIT shl 8) or 5; { mode changed }
  709.   IN_CHANGE           = (IEN_EDIT shl 8) or 6; { contents changed & painted }
  710.   IN_UPDATE           = (IEN_EDIT shl 8) or 7; { contents changed & !painted }
  711.   IN_SETFOCUS         = (IEN_FOCUS shl 8) or 8; { IEdit is getting focus }
  712.   IN_KILLFOCUS        = (IEN_FOCUS shl 8) or 9; { IEdit is losing focus }
  713.   IN_MEMERR           = (IEN_NULL shl 8) or 10; { memory error }
  714.   IN_HSCROLL          = (IEN_SCROLL shl 8) or 11; { horz scrolled, not painted }
  715.   IN_VSCROLL          = (IEN_SCROLL shl 8) or 12; { vert scrolled, not painted }
  716.   IN_GESTURE          = (IEN_EDIT shl 8) or 13; { user has gestured on control }
  717.   IN_COMMAND          = (IEN_EDIT shl 8) or 14; { command selected from menu }
  718.   IN_CLOSE            = (IEN_NULL shl 8) or 15; { I-Edit is being closed }
  719.   IN_PROPERTIES       = (IEN_PROPERTIES shl 8) or 16; { properties dialog }
  720.  
  721. { PenIn[k]put API constants }
  722.  
  723. { Default Processing }
  724.   LRET_DONE                   = 1; 
  725.   LRET_ABORT                  = -1; 
  726.   LRET_HRC                    = -2; 
  727.   LRET_HPENDATA               = -3; 
  728.   LRET_PRIVATE                = -4; 
  729.  
  730. { Inkput: }
  731.   PCMR_OK                     = 0; 
  732.   PCMR_ALREADYCOLLECTING      = -1; 
  733.   PCMR_INVALIDCOLLECTION      = -2; 
  734.   PCMR_EVENTLOCK              = -3; 
  735.   PCMR_INVALID_PACKETID       = -4; 
  736.   PCMR_TERMTIMEOUT            = -5; 
  737.   PCMR_TERMRANGE              = -6; 
  738.   PCMR_TERMPENUP              = -7; 
  739.   PCMR_TERMEX                 = -8; 
  740.   PCMR_TERMBOUND              = -9; 
  741.   PCMR_APPTERMINATED          = -10; 
  742.   PCMR_TAP                    = -11;    { alias PCMR_TAPNHOLD_LAST }
  743.   PCMR_SELECT                 = -12;    { ret because of tap & hold }
  744.   PCMR_OVERFLOW               = -13; 
  745.   PCMR_ERROR                  = -14;    { parameter or unspecified error }
  746.   PCMR_DISPLAYERR             = -15;    { inking only }
  747.   PCMR_TERMINVERT             = -16;    { termination due to tapping opposite end of pen }
  748.  
  749.   PII_INKCLIPRECT             = $0001; 
  750.   PII_INKSTOPRECT             = $0002; 
  751.   PII_INKCLIPRGN              = $0004; 
  752.   PII_INKSTOPRGN              = $0008; 
  753.   PII_INKPENTIP               = $0010; 
  754.   PII_SAVEBACKGROUND          = $0020; 
  755.   PII_CLIPSTOP                = $0040; 
  756.  
  757.   PIT_RGNBOUND                = $0001; 
  758.   PIT_RGNEXCLUDE              = $0002; 
  759.   PIT_TIMEOUT                 = $0004; 
  760.   PIT_TAPNHOLD                = $0008; 
  761.  
  762. { Misc RC Definitions: }
  763.  
  764.   CL_NULL                     = 0; 
  765.   CL_MINIMUM                  = 1;      { minimum confidence level }
  766.   CL_MAXIMUM                  = 100;    { max (require perfect recog) }
  767.   cwRcReservedMax             = 8;      { rc.rgwReserved[cwRcReservedMax] }
  768.   ENUM_MINIMUM                = 1; 
  769.   ENUM_MAXIMUM                = 4096; 
  770.  
  771.   HKP_SETHOOK                 = 0;      { SetRecogHook() }
  772.   HKP_UNHOOK                  = $FFFF; 
  773.  
  774.   HWR_RESULTS                 = 0; 
  775.   HWR_APPWIDE                 = 1; 
  776.  
  777.   iSycNull                    = -1; 
  778.   LPDFNULL                    = 0;      { nil }
  779.   MAXDICTIONARIES             = 16;     { rc.rglpdf[MAXDICTIONARIES] }
  780.   wPntAll                     = $FFFF; 
  781.   cbRcLanguageMax             = 44;     { rc.lpLanguage[cbRcLanguageMax] }
  782.   cbRcUserMax                 = 32;     { rc.lpUser[cbRcUserMax] }
  783.   cbRcrgbfAlcMax              = 32;     { rc.rgbfAlc[cbRcrgbfAlcMax] }
  784.   RC_WDEFAULT                 = $FFFF; 
  785.   RC_LDEFAULT                 = $FFFFFFFF; 
  786.   RC_WDEFAULTFLAGS            = $8000; 
  787. //  RC_LDEFAULTFLAGS            = $80000000; defined above
  788.  
  789. { CorrectWriting() API constants: }
  790. { LOWORD values: }
  791.   CWR_REPLACECR               = $0001;  { replace carriage ret (\r) with space }
  792.   CWR_STRIPCR                 = CWR_REPLACECR; { alias for backward compatibility }
  793.   CWR_STRIPLF                 = $0002;  { strip linefeed (\n) }
  794.   CWR_REPLACETAB              = $0004;  { replace tab with space (\t) }
  795.   CWR_STRIPTAB                = CWR_REPLACETAB; { alias for backward compatibility }
  796.   CWR_SINGLELINEEDIT          = CWR_REPLACECR or CWR_STRIPLF or CWR_REPLACETAB; { all of the above }
  797.   CWR_INSERT                  = $0008;  { use "Insert Text" instead of "Edit Text" in the title }
  798.   CWR_TITLE                   = $0010;  { interpret dwParam as title string }
  799.   CWR_KKCONVERT               = $0020;  { JPN initiate IME }
  800.   CWR_SIMPLE                  = $0040;  { simple dialog (lens) }
  801.   CWR_HEDIT                   = $0080;  { HEDIT CorrectWriting }
  802.   CWR_KEYBOARD                = $0100;  { keyboard lens }
  803.   CWR_BOXES                   = $0200;  { bedit lens }
  804.  
  805. { HIWORD values: keyboard types }
  806.   CWRK_DEFAULT                = 0;      { default keyboard type }
  807.   CWRK_BASIC                  = 1;      { basic keyboard }
  808.   CWRK_FULL                   = 2;      { full keyboard }
  809.   CWRK_NUMPAD                 = 3;      { numeric keyboard }
  810.   CWRK_TELPAD                 = 4;      { Telephone type keyboard }
  811.  
  812.   GPMI_OK                     = 0; 
  813.   GPMI_INVALIDPMI             = $8000; 
  814.  
  815. { inkwidth limits }
  816.   INKWIDTH_MINIMUM            = 0;          { 0 invisible, 1..15 pixel widths }
  817.   INKWIDTH_MAXIMUM            = 15;         { max width in pixels }
  818.  
  819. { Get/SetPenMiscInfo: }
  820. { PMI_RCCHANGE is for WM_GLOBALRCCHANGE compatability only: }
  821.   PMI_RCCHANGE                = 0;      { invalid for Get/SetPenMiscInfo }
  822.  
  823.   PMI_BEDIT                   = 1;      { boxed edit info }
  824.   PMI_IMECOLOR                = 2;      { input method editor color }
  825.   PMI_CXTABLET                = 3;      { tablet width }
  826.   PMI_CYTABLET                = 4;      { tablet height }
  827.   PMI_PENTIP                  = 6;      { pen tip: color, width, nib }
  828.   PMI_ENABLEFLAGS             = 7;      { PWE_xx enablements }
  829.   PMI_TIMEOUT                 = 8;      { handwriting timeout }
  830.   PMI_TIMEOUTGEST             = 9;      { gesture timeout }
  831.   PMI_TIMEOUTSEL              = 10;     { select (press&hold) timeout }
  832.   PMI_SYSFLAGS                = 11;     { component load configuration }
  833.   PMI_INDEXFROMRGB            = 12;     { color table index from RGB }
  834.   PMI_RGBFROMINDEX            = 13;     { RGB from color table index }
  835.   PMI_SYSREC                  = 14;     { handle to system recognizer }
  836.   PMI_TICKREF                 = 15;     { reference absolute time }
  837.  
  838.   PMI_SAVE                    = $1000;  { save setting to file }
  839.  
  840. { Set/GetPenMiscInfo/PMI_ENABLEFLAGS flags: }
  841.   PWE_AUTOWRITE               = $0001;  { pen functionality where IBeam }
  842.   PWE_ACTIONHANDLES           = $0002;  { action handles in controls }
  843.   PWE_INPUTCURSOR             = $0004;  { show cursor while writing }
  844.   PWE_LENS                    = $0008;  { allow lens popup }
  845.  
  846. { GetPenMiscInfo/PMI_SYSFLAGS flags: }
  847.   PWF_RC1                     = $0001;  { Windows for Pen 1.0 RC support }
  848.   PWF_PEN                     = $0004;  { pen drv loaded & hdwe init'd }
  849.   PWF_INKDISPLAY              = $0008;  { ink-compatible display drv loaded }
  850.   PWF_RECOGNIZER              = $0010;  { system recognizer installed }
  851.   PWF_BEDIT                   = $0100;  { boxed edit support }
  852.   PWF_HEDIT                   = $0200;  { free input edit support }
  853.   PWF_IEDIT                   = $0400;  { ink edit support }
  854.   PWF_ENHANCED                = $1000;  { enh features (gest, 1ms timing) }
  855.   PWF_FULL    = PWF_RC1 or PWF_PEN or PWF_INKDISPLAY or PWF_RECOGNIZER or 
  856.                 PWF_BEDIT or PWF_HEDIT or PWF_IEDIT or PWF_ENHANCED; 
  857.  
  858. { SetPenAppFlags API constants: }
  859.   RPA_DEFAULT                 = $0001;  { = RPA_HEDIT }
  860.   RPA_HEDIT                   = $0001;  { convert EDIT to HEDIT }
  861.   RPA_KANJIFIXEDBEDIT         = $0002; 
  862.   RPA_DBCSPRIORITY            = $0004;  { assume DBCS has priority (Japan) }
  863.  
  864.   PMIR_OK                     = 0; 
  865.   PMIR_INDEX                  = -1; 
  866.   PMIR_VALUE                  = -2; 
  867.   PMIR_INVALIDBOXEDITINFO     = -3; 
  868.   PMIR_INIERROR               = -4; 
  869.   PMIR_ERROR                  = -5; 
  870.   PMIR_NA                     = -6; 
  871.  
  872.   SPMI_OK                     = 0; 
  873.   SPMI_INVALIDBOXEDITINFO     = 1; 
  874.   SPMI_INIERROR               = 2; 
  875.   SPMI_INVALIDPMI             = $8000; 
  876.  
  877. { RC Options and Flags: }
  878.  
  879. { RC Direction: }
  880.   RCD_DEFAULT                 = 0;      { def none }
  881.   RCD_LR                      = 1;      { left to right like English }
  882.   RCD_RL                      = 2;      { right to left like Arabic }
  883.   RCD_TB                      = 3;      { top to bottom like Japanese }
  884.   RCD_BT                      = 4;      { bottom to top like some Chinese }
  885.  
  886. { RC International Preferences: }
  887.   RCIP_ALLANSICHAR            = $0001;  { all ANSI chars }
  888.   RCIP_MASK                   = $0001; 
  889.  
  890. { RC Options: }
  891.   RCO_NOPOINTEREVENT          = $00000001;    { no recog tap, tap/hold }
  892.   RCO_SAVEALLDATA             = $00000002;    { save pen data like upstrokes }
  893.   RCO_SAVEHPENDATA            = $00000004;    { save pen data for app }
  894.   RCO_NOFLASHUNKNOWN          = $00000008;    { no ? cursor on unknown }
  895.   RCO_TABLETCOORD             = $00000010;    { tablet coords used in RC }
  896.   RCO_NOSPACEBREAK            = $00000020;    { no space break recog -> dict }
  897.   RCO_NOHIDECURSOR            = $00000040;    { display cursor during inking }
  898.   RCO_NOHOOK                  = $00000080;    { disallow ink hook (passwords) }
  899.   RCO_BOXED                   = $00000100;    { valid rc.guide provided }
  900.   RCO_SUGGEST                 = $00000200;    { for dict suggest }
  901.   RCO_DISABLEGESMAP           = $00000400;    { disable gesture mapping }
  902.   RCO_NOFLASHCURSOR           = $00000800;    { no cursor feedback }
  903.   RCO_BOXCROSS                = $00001000;    { show + at boxedit center }
  904.   RCO_COLDRECOG               = $00008000;    { result is from cold recog }
  905.   RCO_SAVEBACKGROUND          = $00010000;    { Save background from ink }
  906.   RCO_DODEFAULT               = $00020000;    { do default gesture processing }
  907.  
  908. { RC Orientation of Tablet: }
  909.   RCOR_NORMAL                 = 1;      { tablet not rotated }
  910.   RCOR_RIGHT                  = 2;      { rotated 90 deg anticlockwise }
  911.   RCOR_UPSIDEDOWN             = 3;      { rotated 180 deg }
  912.   RCOR_LEFT                   = 4;      { rotated 90 deg clockwise }
  913.  
  914. { RC Preferences: }
  915.   RCP_LEFTHAND                = $0001;  { left handed input }
  916.   RCP_MAPCHAR                 = $0004;  { fill in syg.lpsyc (ink) for training }
  917.  
  918. { RCRESULT wResultsType values: }
  919.   RCRT_DEFAULT                = $0000;  { normal ret }
  920.   RCRT_UNIDENTIFIED           = $0001;  { result contains unidentified results }
  921.   RCRT_GESTURE                = $0002;  { result is a gesture }
  922.   RCRT_NOSYMBOLMATCH          = $0004;  { nothing recognized (no ink match) }
  923.   RCRT_PRIVATE                = $4000;  { recognizer-specific symbol }
  924.   RCRT_NORECOG                = $8000;  { no recog attempted, only data ret }
  925.   RCRT_ALREADYPROCESSED       = $0008;  { GestMgr hooked it }
  926.   RCRT_GESTURETRANSLATED      = $0010;  { GestMgr translated it to ANSI value }
  927.   RCRT_GESTURETOKEYS          = $0020;  { ditto to set of virtual keys }
  928.  
  929. { RC Result Return Mode specification: }
  930.   RRM_STROKE                  = 0;      { return results after each stroke }
  931.   RRM_SYMBOL                  = 1;      { per symbol (e.g. boxed edits) }
  932.   RRM_WORD                    = 2;      { on recog of a word }
  933.   RRM_NEWLINE                 = 3;      { on recog of a line break }
  934.   RRM_COMPLETE                = 16;     { on PCM_xx specified completion }
  935.  
  936.   TPT_CLOSEST                 = $0001;   { Assign to the closest target }
  937.   TPT_INTERSECTINK            = $0002;   { target with intersecting ink }
  938.   TPT_TEXTUAL                 = $0004;   { apply textual heuristics }
  939.   TPT_DEFAULT                 = TPT_TEXTUAL or TPT_INTERSECTINK or TPT_CLOSEST; 
  940.  
  941. { Virtual Event Layer: }
  942.   VWM_MOUSEMOVE               = $0001; 
  943.   VWM_MOUSELEFTDOWN           = $0002; 
  944.   VWM_MOUSELEFTUP             = $0004; 
  945.   VWM_MOUSERIGHTDOWN          = $0008; 
  946.   VWM_MOUSERIGHTUP            = $0010; 
  947.  
  948. { Messages and Defines }
  949.  
  950.   WM_RCRESULT                 = WM_PENWINFIRST+1;   { $381 }
  951.   WM_HOOKRCRESULT             = WM_PENWINFIRST+2;   { $382 }
  952.   WM_PENMISCINFO              = WM_PENWINFIRST+3;   { $383 }
  953.   WM_GLOBALRCCHANGE           = WM_PENWINFIRST+3;   { alias }
  954.   WM_SKB                      = WM_PENWINFIRST+4;   { $384 }
  955.   WM_PENCTL                   = WM_PENWINFIRST+5;   { $385 }
  956.   WM_HEDITCTL                 = WM_PENWINFIRST+5;   { FBC: alias }
  957.  
  958. { WM_HEDITCTL (WM_PENCTL) wParam options: }
  959.   HE_GETRC                    = 3;      { FBC: get RC from HEDIT/BEDIT control }
  960.   HE_SETRC                    = 4;      { FBC: ditto set }
  961.   HE_GETINFLATE               = 5;      { FBC: get inflate rect }
  962.   HE_SETINFLATE               = 6;      { FBC: ditto set }
  963.   HE_GETUNDERLINE             = 7;      { get underline mode }
  964.   HE_SETUNDERLINE             = 8;      { ditto set }
  965.   HE_GETINKHANDLE             = 9;      { get handle to captured ink }
  966.   HE_SETINKMODE               = 10;     { begin HEDIT cold recog mode }
  967.   HE_STOPINKMODE              = 11;     { end cold recog mode }
  968.   HE_GETRCRESULTCODE          = 12;     { FBC: result of recog after HN_ENDREC }
  969.   HE_DEFAULTFONT              = 13;     { switch BEDIT to def font }
  970.   HE_CHARPOSITION             = 14;     { BEDIT byte offset -> char position }
  971.   HE_CHAROFFSET               = 15;     { BEDIT char position -> byte offset }
  972.   HE_GETBOXLAYOUT             = 20;     { get BEDIT layout }
  973.   HE_SETBOXLAYOUT             = 21;     { ditto set }
  974.   HE_GETRCRESULT              = 22;     { FBC: get RCRESULT after HN_RCRESULT }
  975.   HE_KKCONVERT                = 30;     { JPN start kana-kanji conversion }
  976.   HE_GETKKCONVERT             = 31;     { JPN get KK state }
  977.   HE_CANCELKKCONVERT          = 32;     { JPN cancel KK conversion }
  978.   HE_FIXKKCONVERT             = 33;     { JPN force KK result }
  979.   HE_GETKKSTATUS              = 34;     { JPN get KK UI state }
  980.   HE_KKNOCONVERT              = 35;     { JPN revert conversion }
  981.   HE_SETIMEDEFAULT            = 36;     { JPN set a range of DCS }
  982.   HE_GETIMEDEFAULT            = 37;     { JPN get a range of DCS }
  983.   HE_ENABLEALTLIST            = 40;     { en/disable dropdown recog alt's }
  984.   HE_SHOWALTLIST              = 41;     { show dropdown (assume enabled) }
  985.   HE_HIDEALTLIST              = 42;     { hide dropdown alternatives }
  986.   HE_GETLENSTYPE              = 43;     { get lens type: CWR_ and CWRK_ flags }
  987.   HE_SETLENSTYPE              = 44;     { set lens type: CWR_ and CWRK_ flags }
  988.  
  989. { JPN Kana-to-Kanji conversion subfunctions: }
  990.   HEKK_DEFAULT                = 0;      { def }
  991.   HEKK_CONVERT                = 1;      { convert in place }
  992.   HEKK_CANDIDATE              = 2;      { start conversion dialog }
  993.   HEKK_DBCSCHAR               = 3;      { convert to DBCS }
  994.   HEKK_SBCSCHAR               = 4;      { convert to SBCS }
  995.   HEKK_HIRAGANA               = 5;      { convert to hiragana }
  996.   HEKK_KATAKANA               = 6;      { convert to katakana }
  997.  
  998. { JPN Return value of HE_GETKKSTATUS }
  999.   HEKKR_PRECONVERT            = 1;      { in pre conversion mode }
  1000.   HEKKR_CONVERT               = 2;      { in mid conversion mode }
  1001.   HEKKR_TEMPCONFIRM           = 3;      { in post conversion mode }
  1002.  
  1003. { HE_STOPINKMODE (stop cold recog) options: }
  1004.   HEP_NORECOG                 = 0;      { don't recog ink }
  1005.   HEP_RECOG                   = 1;      { recog ink }
  1006.   HEP_WAITFORTAP              = 2;      { recog after tap in window }
  1007.  
  1008. { WM_PENCTL notifications: }
  1009.   HN_ENDREC                   = 4;      { recog complete }
  1010.   HN_DELAYEDRECOGFAIL         = 5;      { HE_STOPINKMODE (cold recog) failed }
  1011.   HN_RESULT                   = 20;     { HEDIT/BEDIT has received new ink/recognition result }
  1012.   HN_RCRESULT                 = HN_RESULT; 
  1013.   HN_ENDKKCONVERT             = 30;     { JPN KK conversion complete }
  1014.   HN_BEGINDIALOG              = 40;     { Lens/EditText/garbage detection dialog }
  1015. {  is about to come up on this hedit/bedit }
  1016.   HN_ENDDIALOG                = 41;     { Lens/EditText/garbage detection dialog }
  1017. {  has just been destroyed }
  1018.  
  1019. { Messages common with other controls: }
  1020.  
  1021.   IE_GETMODIFY          = EM_GETMODIFY;        { gets the mod'n (dirty) bit }
  1022.   IE_SETMODIFY          = EM_SETMODIFY;        { sets the mod'n (dirty) bit }
  1023.   IE_CANUNDO            = EM_CANUNDO;          { queries whether can undo }
  1024.   IE_UNDO               = EM_UNDO;             { undo }
  1025.   IE_EMPTYUNDOBUFFER    = EM_EMPTYUNDOBUFFER;  { clears IEDIT undo buffer }
  1026.   IE_MSGFIRST           = WM_USER+150;         { $496 = 1174 }
  1027.  
  1028. { IEdit common messages: }
  1029.   IE_GETINK                 = IE_MSGFIRST+0;    { gets ink from the control }
  1030.   IE_SETINK                 = IE_MSGFIRST+1;    { sets ink into the control }
  1031.   IE_GETPENTIP              = IE_MSGFIRST+2;    { gets the cur def ink pentip }
  1032.   IE_SETPENTIP              = IE_MSGFIRST+3;    { sets the cur def ink pentip }
  1033.   IE_GETERASERTIP           = IE_MSGFIRST+4;    { gets the cur eraser pentip }
  1034.   IE_SETERASERTIP           = IE_MSGFIRST+5;    { sets the cur eraser pentip }
  1035.   IE_GETBKGND               = IE_MSGFIRST+6;    { gets the bkgnd options }
  1036.   IE_SETBKGND               = IE_MSGFIRST+7;    { sets the bkgnd options }
  1037.   IE_GETGRIDORIGIN          = IE_MSGFIRST+8;    { gets the bkgnd grid origin }
  1038.   IE_SETGRIDORIGIN          = IE_MSGFIRST+9;    { sets the bkgnd grid origin }
  1039.   IE_GETGRIDPEN             = IE_MSGFIRST+10;   { gets the bkgnd grid pen }
  1040.   IE_SETGRIDPEN             = IE_MSGFIRST+11;   { sets the bkgnd grid pen }
  1041.   IE_GETGRIDSIZE            = IE_MSGFIRST+12;   { gets the bkgnd grid size }
  1042.   IE_SETGRIDSIZE            = IE_MSGFIRST+13;   { sets the bkgnd grid size }
  1043.   IE_GETMODE                = IE_MSGFIRST+14;   { gets the current pen mode }
  1044.   IE_SETMODE                = IE_MSGFIRST+15;   { sets the current pen mode }
  1045.   IE_GETINKRECT             = IE_MSGFIRST+16;   { gets the rectbound of the ink }
  1046.  
  1047. { IEdit-specific messages: }
  1048.   IE_GETAPPDATA             = IE_MSGFIRST+34;   { gets the user-defined datum }
  1049.   IE_SETAPPDATA             = IE_MSGFIRST+35;   { sets the user-defined data }
  1050.   IE_GETDRAWOPTS            = IE_MSGFIRST+36;   { gets the ink draw options }
  1051.   IE_SETDRAWOPTS            = IE_MSGFIRST+37;   { sets the ink options }
  1052.   IE_GETFORMAT              = IE_MSGFIRST+38;   { gets format of stroke(s) }
  1053.   IE_SETFORMAT              = IE_MSGFIRST+39;   { sets format of stroke(s) }
  1054.   IE_GETINKINPUT            = IE_MSGFIRST+40;   { gets the ink input option }
  1055.   IE_SETINKINPUT            = IE_MSGFIRST+41;   { sets the ink input option }
  1056.   IE_GETNOTIFY              = IE_MSGFIRST+42;   { gets the notification bits }
  1057.   IE_SETNOTIFY              = IE_MSGFIRST+43;   { sets the notification bits }
  1058.   IE_GETRECOG               = IE_MSGFIRST+44;   { gets recognition options }
  1059.   IE_SETRECOG               = IE_MSGFIRST+45;   { sets recognition options }
  1060.   IE_GETSECURITY            = IE_MSGFIRST+46;   { gets the security options }
  1061.   IE_SETSECURITY            = IE_MSGFIRST+47;   { sets the security options }
  1062.   IE_GETSEL                 = IE_MSGFIRST+48;   { gets sel status of a stroke }
  1063.   IE_SETSEL                 = IE_MSGFIRST+49;   { sets sel status of a stroke }
  1064.   IE_DOCOMMAND              = IE_MSGFIRST+50;   { send command to IEdit }
  1065.   IE_GETCOMMAND             = IE_MSGFIRST+51;   { gets user command }
  1066.   IE_GETCOUNT               = IE_MSGFIRST+52;   { gets count of strks in I-Edit }
  1067.   IE_GETGESTURE             = IE_MSGFIRST+53;   { gets details on user gesture }
  1068.   IE_GETMENU                = IE_MSGFIRST+54;   { gets handle to pop-up menu }
  1069.   IE_GETPAINTDC             = IE_MSGFIRST+55;   { gets the HDC for painting }
  1070.   IE_GETPDEVENT             = IE_MSGFIRST+56;   { gets details of last pd event }
  1071.   IE_GETSELCOUNT            = IE_MSGFIRST+57;   { gets count of selected strks }
  1072.   IE_GETSELITEMS            = IE_MSGFIRST+58;   { gets indices of all sel strks }
  1073.   IE_GETSTYLE               = IE_MSGFIRST+59;   { gets IEdit control styles }
  1074.  
  1075. { (H)Edit Control: }
  1076.  
  1077. { CTLINITHEDIT.dwFlags values }
  1078.   CIH_NOGDMSG               = $0001;  { disable garbage detection message box for this edit }
  1079.   CIH_NOACTIONHANDLE        = $0002;  { disable action handles for this edit }
  1080.   CIH_NOEDITTEXT            = $0004;  { disable Lens/Edit/Insert text for this edit }
  1081.   CIH_NOFLASHCURSOR         = $0008;  { don't flash cursor on tap-n-hold in this (h)edit }
  1082.  
  1083. { Boxed Edit Control: }
  1084.  
  1085. { box edit alternative list: }
  1086.   HEAL_DEFAULT                = -1;     { AltList def value for lParam }
  1087.  
  1088. { box edit Info: }
  1089.   BEI_FACESIZE                = 32;     { max size of font name, = LF_FACESIZE }
  1090.   BEIF_BOXCROSS               = $0001; 
  1091.  
  1092. { box edit size: }
  1093.   BESC_DEFAULT                = 0; 
  1094.   BESC_ROMANFIXED             = 1; 
  1095.   BESC_KANJIFIXED             = 2; 
  1096.   BESC_USERDEFINED            = 3; 
  1097.  
  1098. { CTLINITBEDIT.wFlags values }
  1099.   CIB_NOGDMSG               = $0001;  { disable garbage detection message box for this bedit }
  1100.   CIB_NOACTIONHANDLE        = $0002;  { disable action handles for this bedit }
  1101.   CIB_NOFLASHCURSOR         = $0004;  { don't flash cursor on tap-n-hold in this bedit }
  1102.   CIB_NOWRITING             = $0010;  { disallow pen input into control }
  1103.  
  1104.   BXD_CELLWIDTH               = 12; 
  1105.   BXD_CELLHEIGHT              = 16; 
  1106.   BXD_BASEHEIGHT              = 13; 
  1107.   BXD_BASEHORZ                = 0; 
  1108.   BXD_MIDFROMBASE             = 0; 
  1109.   BXD_CUSPHEIGHT              = 2; 
  1110.   BXD_ENDCUSPHEIGHT           = 4; 
  1111.  
  1112.   BXDK_CELLWIDTH              = 32; 
  1113.   BXDK_CELLHEIGHT             = 32; 
  1114.   BXDK_BASEHEIGHT             = 28; 
  1115.   BXDK_BASEHORZ               = 0; 
  1116.   BXDK_MIDFROMBASE            = 0; 
  1117.   BXDK_CUSPHEIGHT             = 28; 
  1118.   BXDK_ENDCUSPHEIGHT          = 10; 
  1119.  
  1120. { IME colors for bedit }
  1121.   COLOR_BE_INPUT                 = 0; 
  1122.   COLOR_BE_INPUT_TEXT            = 1; 
  1123.   COLOR_BE_CONVERT               = 2; 
  1124.   COLOR_BE_CONVERT_TEXT          = 3; 
  1125.   COLOR_BE_CONVERTED             = 4; 
  1126.   COLOR_BE_CONVERTED_TEXT        = 5; 
  1127.   COLOR_BE_UNCONVERT             = 6; 
  1128.   COLOR_BE_UNCONVERT_TEXT        = 7; 
  1129.   COLOR_BE_CURSOR                = 8; 
  1130.   COLOR_BE_CURSOR_TEXT           = 9; 
  1131.   COLOR_BE_PRECONVERT            = 10; 
  1132.   COLOR_BE_PRECONVERT_TEXT       = 11; 
  1133.   MAXIMECOLORS                   = 12; 
  1134.  
  1135.   WM_PENMISC                  = WM_PENWINFIRST+6;   { $386 }
  1136.  
  1137. { WM_PENMISC message constants: }
  1138.   PMSC_BEDITCHANGE            = 1;      { broadcast when BEDIT changes }
  1139.   PMSC_PENUICHANGE            = 2;      { JPN broadcast when PENUI changes }
  1140.   PMSC_SUBINPCHANGE           = 3;      { JPN broadcast when SUBINPUT changes }
  1141.   PMSC_KKCTLENABLE            = 4;      { JPN }
  1142.   PMSC_GETPCMINFO             = 5;      { query the window's PCMINFO }
  1143.   PMSC_SETPCMINFO             = 6;      { set the window's PCMINFO }
  1144.   PMSC_GETINKINGINFO          = 7;      { query the window's INKINGINFO }
  1145.   PMSC_SETINKINGINFO          = 8;      { set the window's INKINGINFO }
  1146.   PMSC_GETHRC                 = 9;      { query the window's HRC }
  1147.   PMSC_SETHRC                 = 10;     { set the window's HRC }
  1148.   PMSC_GETSYMBOLCOUNT         = 11;     { count of symbols in result recd by window }
  1149.   PMSC_GETSYMBOLS             = 12;     { ditto symbols }
  1150.   PMSC_SETSYMBOLS             = 13;     { ditto set symbols }
  1151.   PMSC_LOADPW                 = 15;     { broadcast load state on penwin }
  1152.   PMSC_INKSTOP                = 16; 
  1153.  
  1154. { PMSCL_xx lParam values for PMSC_xx: }
  1155.   PMSCL_UNLOADED              = 0;      { penwin just unloaded }
  1156.   PMSCL_LOADED                = 1;      { penwin just loaded }
  1157.   PMSCL_UNLOADING             = 2;      { penwin about to unload }
  1158.  
  1159.   WM_CTLINIT                  = WM_PENWINFIRST+7;   { $387 }
  1160.  
  1161. { WM_CTLINIT message constants: }
  1162.   CTLINIT_HEDIT               = 1; 
  1163.   CTLINIT_BEDIT               = 7; 
  1164.   CTLINIT_IEDIT               = 9; 
  1165.   CTLINIT_MAX                 = 10; 
  1166.  
  1167.   WM_PENEVENT                 = WM_PENWINFIRST+8;   { $388 }
  1168.  
  1169. { WM_PENEVENT message values for wParam: }
  1170.   PE_PENDOWN                  = 1;      { pen tip down }
  1171.   PE_PENUP                    = 2;      { pen tip went from down to up }
  1172.   PE_PENMOVE                  = 3;      { pen moved without a tip transition }
  1173.   PE_TERMINATING              = 4;      { Peninput about to terminate }
  1174.   PE_TERMINATED               = 5;      { Peninput terminated }
  1175.   PE_BUFFERWARNING            = 6;      { Buffer half full. }
  1176.   PE_BEGININPUT               = 7;      { begin default input }
  1177.   PE_SETTARGETS               = 8;      { set target data structure (TARGINFO) }
  1178.   PE_BEGINDATA                = 9;      { init message to all targets }
  1179.   PE_MOREDATA                 = 10;     { target gets more data }
  1180.   PE_ENDDATA                  = 11;     { termination message to all targets }
  1181.   PE_GETPCMINFO               = 12;     { get input collection info }
  1182.   PE_GETINKINGINFO            = 13;     { get inking info }
  1183.   PE_ENDINPUT                 = 14;     { Input termination message to window }
  1184. { starting default input }
  1185.   PE_RESULT                   = 15;     { sent after ProcessHRC but before GetResultsHRC }
  1186.  
  1187. type
  1188.   HTRG = Integer;
  1189.   HPCM = Integer;
  1190.   HPENDATA = Integer;
  1191.   HREC = Integer;
  1192.   
  1193. { Types }
  1194.  
  1195. { Simple: }
  1196. type
  1197.   ALC = Longint;                                { Enabled Alphabet }
  1198.   CL = Integer;                              { Confidence Level }
  1199.   HKP = UINT;                                { Hook Parameter }
  1200.   REC = Integer;                             { recognition result }
  1201.   SYV = Longint;                                { Symbol Value }
  1202.  
  1203. { Pointer Types: }
  1204. type
  1205.   PALC = ^ALC;                                      { ptr to ALC }
  1206.   POEM = Pointer;                                   { alias }
  1207.   PSYV = ^SYV;                                      { ptr to SYV }
  1208.   PHPENDATA = ^HPENDATA;                            { ptr to HPENDATA }
  1209.  
  1210. { Function Prototypes: }
  1211.   TFNEnumProc = function(p1: PSYV; p2: Integer; p3: Integer): Integer stdcall;
  1212.   PFNLPDF = ^TFNLPDF;
  1213.   TFNLPDF = function(p1: Integer; p2, p3: Pointer; p4: Integer; 
  1214.     p5, p6: DWORD): Integer stdcall;
  1215.   TFNRCYieldProc = function: BOOL stdcall;
  1216.  
  1217. { Structures: }
  1218.  
  1219.   PAbsTime = ^TAbsTime;
  1220.   TAbsTime = packed record    { 2.0 absolute date/time }
  1221.     sec: DWORD;    { number of seconds since 1/1/1970, ret by CRTlib time() fn }
  1222.     ms: UINT;      { additional offset in ms, 0..999 }
  1223.   end;
  1224.  
  1225.   PCtlInitHEdit = ^TCtlInitHEdit;
  1226.   TCtlInitHEdit = packed record { 2.0 init struct for (h)edit }
  1227.     cbSize: DWORD;              { sizeof(CTLINITHEDIT) }
  1228.     hwnd: HWND;                 { (h)edit window handle }
  1229.     id: Integer;                    { its id }
  1230.     dwFlags: DWORD;             { CIE_xx }
  1231.     dwReserved: DWORD;          { for future use }
  1232.   end;
  1233.  
  1234.   PBoxLayout = ^TBoxLayout;
  1235.   TBoxLayout = packed record  { 1.0 box edit layout }
  1236.     cyCusp: Integer;                { pixel height of box (BXS_RECT) or cusp }
  1237.     cyEndCusp: Integer;             { pixel height of cusps at extreme ends }
  1238.     style: UINT;                { BXS_xx style }
  1239.     dwReserved1: DWORD;         { reserved }
  1240.     dwReserved2: DWORD;         { reserved }
  1241.     dwReserved3: DWORD;         { reserved }
  1242.   end;
  1243.  
  1244.   PIMEColors = ^TIMEColors;
  1245.   TIMEColors = packed record  { 2.0 IME undetermined string color info. }
  1246.     cColors: Integer;               { count of colors to be set/get }
  1247.     lpnElem: PINT;             { address of array of elements }
  1248.     lprgbIme: ^COLORREF;        { address of array of RGB values }
  1249.   end;
  1250.  
  1251.   PCtlInitBEdit = ^TCtlInitBEdit;
  1252.   TCtlInitBEdit = packed record { 2.0 init struct for box edit }
  1253.     cbSize: DWORD;              { sizeof(CTLINITBEDIT) }
  1254.     hwnd: HWND;                 { box edit window handle }
  1255.     id: Integer;                    { its id }
  1256.     wSizeCategory: WORD;        { BESC_xx }
  1257.     wFlags: WORD;               { CIB_xx }
  1258.     dwReserved: DWORD;          { for future use }
  1259.   end;
  1260.  
  1261.   PBoxEditInfo = ^TBoxEditInfo;
  1262.   TBoxEditInfo = packed record { 1.1 box edit Size Info }
  1263.     cxBox: Integer;                 { width of a single box }
  1264.     cyBox: Integer;                 { ditto height }
  1265.     cxBase: Integer;                { in-box x-margin to guideline }
  1266.     cyBase: Integer;                { in-box y offset from top to baseline }
  1267.     cyMid: Integer;                 { 0 or distance from baseline to midline }
  1268.     boxlayout: TBoxLayout;       { embedded BOXLAYOUT structure }
  1269.     wFlags: UINT;               { BEIF_xx }
  1270.     szFaceName: packed array[0..BEI_FACESIZE-1] of BYTE;{ font face name }
  1271.     wFontHeight: UINT;          { font height }
  1272.     rgwReserved: packed array[0..7] of UINT;{ for future use }
  1273.   end;
  1274.  
  1275.   PRectOfs = ^TRectOfs;
  1276.   TRectOfs = packed record    { 1.0 rectangle offset for nonisometric inflation }
  1277.     dLeft: Integer;                 { inflation leftwards from left side }
  1278.     dTop: Integer;                  { ditto upwards from top }
  1279.     dRight: Integer;                { ditto rightwards from right }
  1280.     dBottom: Integer;               { ditto downwards from bottom }
  1281.   end;
  1282.  
  1283.   PPenDataHeader = ^TPenDataHeader;
  1284.   TPenDataHeader = packed record { 1.0 main pen data header }
  1285.     wVersion: UINT;             { pen data format version }
  1286.     cbSizeUsed: UINT;           { size of pendata mem block in bytes }
  1287.     cStrokes: UINT;             { number of strokes (incl up-strokes) }
  1288.     cPnt: UINT;                 { count of all points }
  1289.     cPntStrokeMax: UINT;        { length (in points) of longest stroke }
  1290.     rectBound: TRect;            { bounding rect of all down points }
  1291.     wPndts: UINT;               { PDTS_xx bits }
  1292.     nInkWidth: Integer;             { ink width in pixels }
  1293.     rgbInk: DWORD;              { ink color }
  1294.   end;
  1295.  
  1296.   PStrokeInfo = ^TStrokeInfo;
  1297.   TStrokeInfo = packed record { 1.0 stroke header }
  1298.     cPnt: UINT;                 { count of points in stroke }
  1299.     cbPnts: UINT;               { size of stroke in bytes }
  1300.     wPdk: UINT;                 { state of stroke }
  1301.     dwTick: DWORD;              { time at beginning of stroke }
  1302.   end;
  1303.  
  1304.   PPenTip = ^TPenTip;
  1305.   TPenTip = packed record     { 2.0 Pen Tip characteristics }
  1306.     cbSize: DWORD;              { sizeof(PENTIP) }
  1307.     btype: BYTE;                { pen type/nib (calligraphic nib, etc.) }
  1308.     bwidth: BYTE;               { width of Nib (typically = nInkWidth) }
  1309.     bheight: BYTE;              { height of Nib }
  1310.     bOpacity: BYTE;             { 0=transparent, $80=hilite, $FF=opaque }
  1311.     rgb: COLORREF;              { pen color }
  1312.     dwFlags: DWORD;             { TIP_xx flags }
  1313.     dwReserved: DWORD;          { for future expansion }
  1314.   end;
  1315.  
  1316.   TFNAnimateProc = function(p1: HPENDATA; p2, p3: UINT; p4: PUINT; 
  1317.     p5: LPARAM): BOOL stdcall;
  1318.  
  1319.   PAnimateInfo = ^TAnimateInfo;
  1320.   TAnimateInfo = packed record { 2.0 Animation parameters }
  1321.     cbSize: DWORD;              { sizeof(ANIMATEINFO) }
  1322.     uSpeedPct: UINT;            { speed percent to animate at }
  1323.     uPeriodCB: UINT;            { time between calls to callback in ms }
  1324.     fuFlags: UINT;              { animation flags }
  1325.     lParam: LPARAM;             { value to pass to callback }
  1326.     dwReserved: DWORD;          { reserved }
  1327.   end;
  1328.  
  1329.   POEMPenInfo = ^TOEMPenInfo;
  1330.   TOEMPenInfo = packed record { 1.0 OEM pen/tablet hdwe info }
  1331.     wPdt: UINT;                 { pen data type }
  1332.     wValueMax: UINT;            { largest val ret by device }
  1333.     wDistinct: UINT;            { number of distinct readings possible }
  1334.   end;
  1335.  
  1336.   PPenPacket = ^TPenPacket;
  1337.   TPenPacket = packed record
  1338.     wTabletX: UINT;             { x in raw coords }
  1339.     wTabletY: UINT;             { ditto y }
  1340.     wPDK: UINT;                 { state bits }
  1341.     rgwOemData: packed array[0..MAXOEMDATAWORDS-1] of UINT;{ OEM-specific data }
  1342.   end;
  1343.  
  1344.   POEMPenPacket = ^TOEMPenPacket;
  1345.   TOEMPenPacket = packed record
  1346.     wTabletX: UINT;             { x in raw coords }
  1347.     wTabletY: UINT;             { ditto y }
  1348.     wPDK: UINT;                 { state bits }
  1349.     rgwOemData: packed array[0..MAXOEMDATAWORDS-1] of UINT;{ OEM-specific data }
  1350.     dwTime: DWORD;
  1351.   end;
  1352.  
  1353.   PPenInfo = ^TPenInfo;
  1354.   TPenInfo = packed record    { 1.0 pen/tablet hdwe info }
  1355.     cxRawWidth: UINT;           { max x coord and tablet width in 0.001" }
  1356.     cyRawHeight: UINT;          { ditto y, height }
  1357.     wDistinctWidth: UINT;       { number of distinct x values tablet ret }
  1358.     wDistinctHeight: UINT;      { ditto y }
  1359.     nSamplingRate: Integer;         { samples / second }
  1360.     nSamplingDist: Integer;         { min distance to move before generating event }
  1361.     lPdc: Longint;                 { Pen Device Capabilities }
  1362.     cPens: Integer;                 { number of pens supported }
  1363.     cbOemData: Integer;             { width of OEM data packet }
  1364.     rgoempeninfo: packed array[0..MAXOEMDATAWORDS-1] of TOEMPenInfo;{ supported OEM data types }
  1365.     rgwReserved: packed array[0..6] of UINT;{ for internal use }
  1366.     fuOEM: UINT;                { which OEM data, timing, PDK_xx to report }
  1367.   end;
  1368.  
  1369.   PCalbStruct = ^TCalbStruct;
  1370.   TCalbStruct = packed record { 1.0 pen calibration }
  1371.     wOffsetX: Integer;
  1372.     wOffsetY: Integer;
  1373.     wDistinctWidth: Integer;
  1374.     wDistinctHeight: Integer;
  1375.   end;
  1376.  
  1377.   TFNRawHook = function(PenPacket: PPenPacket): BOOL stdcall;
  1378.  
  1379. { Handwriting Recognizer: }
  1380.  
  1381. type
  1382.   HRC = Integer;
  1383.   HRCRESULT = Integer;
  1384.   HWL = Integer;
  1385.   HRECHOOK = Integer;
  1386.   HINKSET = Integer;
  1387.  
  1388.   PHRC = ^HRC; 
  1389.   PHRCRESULT = ^HRCRESULT; 
  1390.   PHWL = ^HWL; 
  1391.  
  1392.   TFNHRCResultHookProc = function(p1: HREC; p2: HRC; p3, p4, p5: UINT; 
  1393.     p6: Pointer): BOOL stdcall;
  1394.  
  1395. { Inksets: }
  1396.  
  1397.   LPHINKSET = ^HINKSET;                                    { ptr to HINKSET }
  1398.  
  1399.   PInterval = ^TInterval;
  1400.   TInterval = packed record   { 2.0 interval structure for inksets }
  1401.     atBegin: TAbsTime;           { begining of 1-ms granularity interval }
  1402.     atEnd: TAbsTime;             { 1 ms past end of interval }
  1403.   end;
  1404.  
  1405.   PBoxResults = ^TBoxResults;
  1406.   TBoxResults = packed record { 2.0 }
  1407.     indxBox: UINT;
  1408.     hinksetBox: HINKSET;
  1409.     rgSyv: packed array[0..0] of SYV;
  1410.   end;
  1411.  
  1412.   PGuide = ^TGuide;
  1413.   TGuide = packed record      { 1.0 guide structure }
  1414.     xOrigin: Integer;               { left edge of first box (screen coord)) }
  1415.     yOrigin: Integer;               { ditto top edge }
  1416.     cxBox: Integer;                 { width of a single box }
  1417.     cyBox: Integer;                 { ditto height }
  1418.     cxBase: Integer;                { in-box x-margin to guideline }
  1419.     cyBase: Integer;                { in-box y offset from top to baseline }
  1420.     cHorzBox: Integer;              { count of boxed columns }
  1421.     cVertBox: Integer;              { ditto rows }
  1422.     cyMid: Integer;                 { 0 or distance from baseline to midline }
  1423.   end;
  1424.  
  1425.   PCtlInitIEdit = ^TCtlInitIEdit;
  1426.   TCtlInitIEdit = packed record { 2.0 init struct for Ink Edit }
  1427.     cbSize: DWORD;              { sizeof(CTLINITIEDIT) }
  1428.     hwnd: HWND;                 { IEdit window handle }
  1429.     id: Integer;                    { its ID }
  1430.     ieb: WORD;                  { IEB_* (background) bits }
  1431.     iedo: WORD;                 { IEDO_* (draw options) bits }
  1432.     iei: WORD;                  { IEI_* (ink input) bits }
  1433.     ien: WORD;                  { IEN_* (notification) bits }
  1434.     ierec: WORD;                { IEREC_* (recognition) bits }
  1435.     ies: WORD;                  { IES_* (style) bits }
  1436.     iesec: WORD;                { IESEC_* (security) bits }
  1437.     pdts: WORD;                 { initial pendata scale factor (PDTS_*) }
  1438.     hpndt: HPENDATA;            { initial pendata (or NULL if none) }
  1439.     hgdiobj: HGDIOBJ;           { background brush or bitmap handle }
  1440.     hpenGrid: HPEN;             { pen to use in drawing grid }
  1441.     ptOrgGrid: TPoint;          { grid lines point of origin }
  1442.     wVGrid: WORD;               { vertical gridline spacing }
  1443.     wHGrid: WORD;               { horizontal gridline spacing }
  1444.     dwApp: DWORD;               { application-defined data }
  1445.     dwReserved: DWORD;          { reserved for future use }
  1446.   end;
  1447.  
  1448.   PPDEvent = ^TPDEvent;
  1449.   TPDEvent = packed record    { 2.0 }
  1450.     cbSize: DWORD;              { sizeof(PDEVENT) }
  1451.     hwnd: HWND;                 { window handle of I-Edit }
  1452.     wm: UINT;                   { WM_* (window message) of event }
  1453.     wParam: WPARAM;             { wParam of message }
  1454.     lParam: LPARAM;             { lParam of message }
  1455.     pt: TPoint;                  { event pt in I-Edit client co-ords }
  1456.     fPen: BOOL;                 { TRUE if pen (or other inking device) }
  1457.     lExInfo: Longint;              { GetMessageExtraInfo() return value }
  1458.     dwReserved: DWORD;          { for future use }
  1459.   end;
  1460.  
  1461.   PStrkFmt = ^TStrkFmt;
  1462.   TStrkFmt = packed record    { 2.0 }
  1463.     cbSize: DWORD;              { sizeof(STRKFMT) }
  1464.     iesf: UINT;                 { stroke format flags and return bits }
  1465.     iStrk: UINT;                { stroke index if IESF_STROKE }
  1466.     tip: TPenTip;                { ink tip attributes }
  1467.     dwUser: DWORD;              { user data for strokes }
  1468.     dwReserved: DWORD;          { for future use }
  1469.   end;
  1470.  
  1471.   PPCMInfo = ^TPCMInfo;
  1472.   TPCMInfo = packed record    { 2.0 Pen Collection Mode Information }
  1473.     cbSize: DWORD;              { sizeof(PCMINFO) }
  1474.     dwPcm: DWORD;               { PCM_xxx flags }
  1475.     rectBound: TRect;            { if finish on pendown outside this rect }
  1476.     rectExclude: TRect;          { if finish on pendown inside this rect }
  1477.     hrgnBound: HRGN;            { if finish on pendown outside this region }
  1478.     hrgnExclude: HRGN;          { if finish on pendown inside this region }
  1479.     dwTimeout: DWORD;           { if finish after timeout, this many ms }
  1480.   end;
  1481.  
  1482.   PInkingInfo = ^TInkingInfo;
  1483.   TInkingInfo = packed record { 2.0 Pen Inking Information }
  1484.     cbSize: DWORD;              { sizeof(INKINGINFO) }
  1485.     wFlags: UINT;               { One of the PII_xx flags }
  1486.     tip: TPenTip;                { Pen type, size and color }
  1487.     rectClip: TRect;             { Clipping rect for the ink }
  1488.     rectInkStop: TRect;          { Rect in which a pen down stops inking }
  1489.     hrgnClip: HRGN;             { Clipping region for the ink }
  1490.     hrgnInkStop: HRGN;          { Region in which a pen down stops inking }
  1491.   end;
  1492.  
  1493.   PSYC = ^TSYC;
  1494.   TSYC = packed record        { 1.0 Symbol Correspondence for Ink }
  1495.     wStrokeFirst: UINT;         { first stroke, inclusive }
  1496.     wPntFirst: UINT;            { first point in first stroke, inclusive }
  1497.     wStrokeLast: UINT;          { last stroke, inclusive }
  1498.     wPntLast: UINT;             { last point in last stroke, inclusive }
  1499.     fLastSyc: BOOL;             { T: no more SYCs follow for current SYE }
  1500.   end;
  1501.  
  1502.   PSYE = ^TSYE;
  1503.   TSYE = packed record        { 1.0 Symbol Element }
  1504.     syv: SYV;                   { symbol value }
  1505.     lRecogVal: Longint;            { for internal use by recognizer }
  1506.     cl: CL;                     { confidence level }
  1507.     iSyc: Integer;                  { SYC index }
  1508.   end;
  1509.  
  1510.   PSYG = ^TSYG;
  1511.   TSYG = packed record        { 1.0 Symbol Graph }
  1512.     rgpntHotSpots: packed array[0..MAXHOTSPOT-1] of TPoint;{ hot spots (max 8) }
  1513.     cHotSpot: Integer;              { number of valid hot spots in rgpntHotSpots }
  1514.     nFirstBox: Integer;             { row-major index to box of 1st char in result }
  1515.     lRecogVal: Longint;            { reserved for use by recoognizer }
  1516.     lpsye: PSYE;               { nodes of symbol graph }
  1517.     cSye: Integer;                  { number of SYEs in symbol graph }
  1518.     lpsyc: PSYC;               { ptr to corresp symbol ink }
  1519.     cSyc: Integer;                  { ditto count }
  1520.   end;
  1521.  
  1522.   PRC = ^TRC;
  1523.   TRC = packed record         { 1.0 Recognition Context (RC) }
  1524.     hrec: HREC;                 { handle of recognizer to use }
  1525.     hwnd: HWND;                 { window to send results to }
  1526.     wEventRef: UINT;            { index into ink buffer }
  1527.     wRcPreferences: UINT;       { flags: RCP_xx Preferences }
  1528.     lRcOptions: Longint;           { RCO_xx options }
  1529.     lpfnYield: TFNRCYieldProc;     { procedure called during Yield() }
  1530.     lpUser: packed array[0..cbRcUserMax-1] of BYTE;{ current writer }
  1531.     wCountry: UINT;             { country code }
  1532.     wIntlPreferences: UINT;     { flags: RCIP_xx }
  1533.     lpLanguage: packed array[0..cbRcLanguageMax-1] of Char;{ language strings }
  1534.     rglpdf: packed array[0..MAXDICTIONARIES-1] of PFNLPDF;{ list of dictionary functions }
  1535.     wTryDictionary: UINT;       { max enumerations to search }
  1536.     clErrorLevel: CL;           { level where recognizer should reject input }
  1537.     alc: ALC;                   { enabled alphabet }
  1538.     alcPriority: ALC;           { prioritizes the ALC_ codes }
  1539.     rgbfAlc: packed array[0..cbRcrgbfAlcMax-1] of BYTE;{ bit field for enabled characters }
  1540.     wResultMode: UINT;          { RRM_xx when to send (asap or when complete) }
  1541.     wTimeOut: UINT;             { recognition timeout in ms }
  1542.     lPcm: Longint;                 { flags: PCM_xx for ending recognition }
  1543.     rectBound: TRect;            { bounding rect for inking (def:screen coords) }
  1544.     rectExclude: TRect;          { pen down inside this terminates recognition }
  1545.     guide: TGuide;               { struct: defines guidelines for recognizer }
  1546.     wRcOrient: UINT;            { RCOR_xx orientation of writing wrt tablet }
  1547.     wRcDirect: UINT;            { RCD_xx direction of writing }
  1548.     nInkWidth: Integer;             { ink width 0 (none) or 1..15 pixels }
  1549.     rgbInk: COLORREF;           { ink color }
  1550.     dwAppParam: DWORD;          { for application use }
  1551.     dwDictParam: DWORD;         { for app use to be passed on to dictionaries }
  1552.     dwRecognizer: DWORD;        { for app use to be passed on to recognizer }
  1553.     rgwReserved: packed array[0..cwRcReservedMax-1] of UINT;{ reserved for future use by Windows }
  1554.   end;
  1555.  
  1556.   PRCResult = ^TRCResult;
  1557.   TRCResult = packed record   { 1.0 Recognition Result }
  1558.     syg: TSYG;                   { symbol graph }
  1559.     wResultsType: UINT;         { see RCRT_xx }
  1560.     cSyv: Integer;                  { count of symbol values }
  1561.     lpsyv: PSYV;               { NULL-term ptr to recog's best guess }
  1562.     hSyv: THandle;               { globally-shared handle to lpsyv mem }
  1563.     nBaseLine: Integer;             { 0 or baseline of input writing }
  1564.     nMidLine: Integer;              { ditto midline }
  1565.     hpendata: HPENDATA;         { pen data mem }
  1566.     rectBoundInk: TRect;         { ink data bounds }
  1567.     pntEnd: TPoint;              { pt that terminated recog }
  1568.     lprc: PRC;                 { recog context used }
  1569.   end;
  1570.  
  1571.   TFNFuncResults = function(p1: PRCResult; p2: REC): Integer stdcall;
  1572.  
  1573.   PTarget = ^TTarget;
  1574.   TTarget = packed record     { 2.0 Geometry for a single target. }
  1575.     dwFlags: DWORD;             { individual target flags }
  1576.     idTarget: DWORD;            { TARGINFO.rgTarget[] index }
  1577.     htrgTarget: HTRG;           { HANDLE32 equiv }
  1578.     rectBound: TRect;           { Bounding rect of the target }
  1579.     dwData: DWORD;              { data collection info per target }
  1580.     rectBoundInk: TRect;        { Reserved for internal use, must be zero }
  1581.     rectBoundLastInk: TRect;    { Reserved for internal use, must be zero }
  1582.   end;
  1583.  
  1584.   PTargInfo = ^TTargInfo;
  1585.   TTargInfo = packed record   { 2.0 A set of targets }
  1586.     cbSize: DWORD;              { sizeof(TARGINFO) }
  1587.     dwFlags: DWORD;             { flags }
  1588.     htrgOwner: HTRG;            { HANDLE32 equiv }
  1589.     cTargets: WORD;             { count of targets }
  1590.     iTargetLast: WORD;          { last target, used by TargetPoints API }
  1591. { if TPT_TEXTUAL flag is set }
  1592.     rgTarget: packed array[0..0] of TTarget;{ variable-length array of targets }
  1593.   end;
  1594.  
  1595.   PInpParams = ^TInpParams;
  1596.   TInpParams = packed record  { 2.0 }
  1597.     cbSize: DWORD;              { sizeof(INPPARAMS) }
  1598.     dwFlags: DWORD;
  1599.     hpndt: HPENDATA;
  1600.     target: TTarget;             { target structure }
  1601.   end;
  1602.  
  1603.   PSKBInfo = ^TSKBInfo;
  1604.   TSKBInfo = packed record
  1605.     handle: HWnd;
  1606.     nPad: Word;
  1607.     fVisible: Bool;
  1608.     fMinimized: Bool;
  1609.     hect: TRect;
  1610.     dwReserved: Longint;
  1611.   end;
  1612.  
  1613. { Utility Functions }
  1614.  
  1615. { Misc }
  1616. function FPenUpX(X: Integer): BOOL;
  1617. function GetWEventRef: Word;
  1618.  
  1619. { ALC: }
  1620. function MpAlcB(lprc: PRC; i: Word): PByte;
  1621. function MpIbf(i: Word): Byte;
  1622. procedure SetAlcBitAnsi(lprc: PRC; i: Word);
  1623. procedure ResetAlcBitAnsi(lprc: PRC; i: Word);
  1624. function IsAlcBitAnsi(lprc: PRC; i: Word): Boolean;
  1625.  
  1626. { draw 2.0 pendata using internal stroke formats: }
  1627. function DrawPenDataFmt(hdc: HDC; lprect: PRect; hpndt: THandle): Integer;
  1628.  
  1629. { Handwriting Recognizer: }
  1630.  
  1631. { Intervals: }
  1632.  
  1633. { difference of two absolute times (at2 > at1 for positive result): }
  1634. function dwDiffAT(at1, at2: TAbsTime): Integer;
  1635.  
  1636. { comparison of two absolute times (TRUE if at1 < at2): }
  1637. function FLTAbsTime(at1, at2: TAbsTime): Boolean;
  1638.  
  1639. function FLTEAbsTime(at1, at2: TAbsTime): Boolean;
  1640.  
  1641. function FEQAbsTime(at1, at2: TAbsTime): Boolean;
  1642.  
  1643. { test if abstime is within an interval: }
  1644. function FAbsTimeInInterval(at: TAbsTime; lpi: PInterval): Boolean;
  1645.  
  1646. { test if interval (lpiT) is within an another interval (lpiS): }
  1647. function FIntervalInInterval(lpiT, lpiS: PInterval): Boolean;
  1648.  
  1649. { test if interval (lpiT) intersects another interval (lpiS): }
  1650. function FIntervalXInterval(lpiT, lpiS: PInterval): Boolean;
  1651.  
  1652. { duration of an PInterval in ms: }
  1653. function dwDurInterval(lpi: PInterval): Integer;
  1654.  
  1655. { fill a pointer to an ABSTIME structure from a count of seconds and ms: }
  1656. procedure MakeAbsTime(var lpat: TAbsTime; sec, ms: Integer);
  1657.  
  1658. { SYV functions: }
  1659.  
  1660. function FIsSpecial(syv: DWORD): Boolean;
  1661. function FIsAnsi(syv: DWORD): Boolean;
  1662. function FIsGesture(syv: DWORD): Boolean;
  1663. function FIsKanji(syv: DWORD): Boolean;
  1664. function FIsShape(syv: DWORD): Boolean;
  1665. function FIsUniCode(syv: DWORD): Boolean;
  1666. function FIsVKey(syv: DWORD): Boolean;
  1667.  
  1668. function ChSyvToAnsi(syv: DWORD): Byte;
  1669. function WSyvToKanji(syv: DWORD): Word;
  1670. function SyvCharacterToSymbol(c: Char): DWORD;
  1671. function SyvKanjiToSymbol(c: Char): DWORD;
  1672.  
  1673. function FIsSelectGesture(syv: DWORD): Boolean;
  1674. function FIsStdGesture(syv: DWORD): Boolean;
  1675. function FIsAnsiGesture(syv: DWORD): Boolean;
  1676.  
  1677. function SubPenMsgFromWpLp(wp, lp: DWORD): Word;
  1678. function EventRefFromWpLp(wp, lp: DWORD): Word;
  1679. function TerminationFromWpLp(wp, lp: DWORD): Integer;
  1680.  
  1681. function HwndFromHtrg(trg: HTRG): HWND;
  1682. function HpcmFromWpLp(wp, lp: DWORD): Integer;
  1683. function HtrgFromHwnd(hwnd: HWND): HTRG;
  1684.  
  1685. { APIs and Prototypes }
  1686.  
  1687. { PenData: }
  1688. function AddPointsPenData(p1: HPENDATA; p2: PPoint; p3: Pointer; 
  1689.   p4: PStrokeInfo): HPENDATA; stdcall;
  1690. function CompressPenData(p1: HPENDATA; p2: UINT; p3: DWORD): Integer; stdcall;
  1691. function CreatePenDataEx(p1: PPenInfo; p2: UINT; p3: UINT; 
  1692.   p4: UINT): HPENDATA; stdcall;
  1693. function CreatePenDataRegion(p1: HPENDATA; p2: UINT): HRGN; stdcall;
  1694. function DestroyPenData(p1: HPENDATA): BOOL; stdcall;
  1695. function DrawPenDataEx(p1: HDC; p2: PRect; p3: HPENDATA; p4: UINT; p5: UINT; 
  1696.   p6: UINT; p7: UINT; p8: TFNAnimateProc; p9: PAnimateInfo; 
  1697.   p10: UINT): Integer; stdcall;
  1698. function DuplicatePenData(p1: HPENDATA; p2: UINT): HPENDATA; stdcall;
  1699. function ExtractPenDataPoints(p1: HPENDATA; p2: UINT; p3: UINT; p4: UINT; 
  1700.   p5: PPoint; p6: Pointer; p7: UINT): Integer; stdcall;
  1701. function ExtractPenDataStrokes(p1: HPENDATA; p2: UINT; p3: LPARAM; 
  1702.   p4: PHPENDATA; p5: UINT): Integer; stdcall;
  1703. function GetPenDataAttributes(p1: HPENDATA; p2: Pointer; p3: UINT): Integer; stdcall;
  1704. function GetPenDataInfo(p1: HPENDATA; p2: PPENDATAHEADER; p3: PPenInfo; 
  1705.   p4: DWORD): BOOL; stdcall;
  1706. function GetPointsFromPenData(p1: HPENDATA; p2: UINT; p3: UINT; p4: UINT; 
  1707.   p5: PPoint): BOOL; stdcall;
  1708. function GetStrokeAttributes(p1: HPENDATA; p2: UINT; p3: Pointer; 
  1709.   p4: UINT): Integer; stdcall;
  1710. function GetStrokeTableAttributes(p1: HPENDATA; p2: UINT; p3: Pointer; 
  1711.   p4: UINT): Integer; stdcall;
  1712. function HitTestPenData(p1: HPENDATA; p2: PPoint; p3: UINT; p4: PUINT; 
  1713.   p5: PUINT): Integer; stdcall;
  1714. function InsertPenData(p1: HPENDATA; p2: HPENDATA; p3: UINT): Integer; stdcall;
  1715. function InsertPenDataPoints(p1: HPENDATA; p2: UINT; p3: UINT; p4: UINT; 
  1716.   p5: PPoint; p6: Pointer): Integer; stdcall;
  1717. function InsertPenDataStroke(p1: HPENDATA; p2: UINT; p3: PPoint; p4: Pointer; 
  1718.   p5: PStrokeInfo): Integer; stdcall;
  1719. function MetricScalePenData(p1: HPENDATA; p2: UINT): BOOL; stdcall;
  1720. function OffsetPenData(p1: HPENDATA; p2: Integer; p3: Integer): BOOL; stdcall;
  1721. function PenDataFromBuffer(p1: PHPENDATA; p2: UINT; p3: PByte; p4: Longint; 
  1722.   p5: PDWORD): Longint; stdcall;
  1723. function PenDataToBuffer(p1: HPENDATA; p2: PByte; p3: Longint; 
  1724.   p4: PDWORD): Longint; stdcall;
  1725. function RedisplayPenData(p1: HDC; p2: HPENDATA; p3: PPoint; p4: PPoint; 
  1726.   p5: Integer; p6: DWORD): BOOL; stdcall;
  1727. function RemovePenDataStrokes(p1: HPENDATA; p2: UINT; p3: UINT): Integer; stdcall;
  1728. function ResizePenData(p1: HPENDATA; p2: PRect): BOOL; stdcall;
  1729. function SetStrokeAttributes(p1: HPENDATA; p2: UINT; p3: LPARAM; 
  1730.   p4: UINT): Integer; stdcall;
  1731. function SetStrokeTableAttributes(p1: HPENDATA; p2: UINT; p3: LPARAM; 
  1732.   p4: UINT): Integer; stdcall;
  1733. function TrimPenData(p1: HPENDATA; p2: DWORD; p3: DWORD): Integer; stdcall;
  1734.  
  1735. { Dictionary: }
  1736. function DictionarySearch(p1: PRC; p2: PSYE; p3: Integer; p4: PSYV; 
  1737.   p5: Integer): BOOL; stdcall;
  1738.  
  1739. { Pen Hardware/Driver: }
  1740. function GetPenAsyncState(p1: UINT): BOOL; stdcall;
  1741. function IsPenEvent(p1: UINT; p2: Longint): BOOL; stdcall;
  1742.  
  1743. { Handwriting Recognizer: }
  1744. function AddPenDataHRC(p1: HRC; p2: HPENDATA): Integer; stdcall;
  1745. function AddPenInputHRC(p1: HRC; p2: PPoint; p3: Pointer; p4: UINT; 
  1746.   p5: PStrokeInfo): Integer; stdcall;
  1747. function AddWordsHWL(p1: HWL; p2: LPSTR; p3: UINT): Integer; stdcall;
  1748. function ConfigHREC(p1: HREC; p2: UINT; p3: WPARAM; p4: LPARAM): Integer; stdcall;
  1749. function CreateCompatibleHRC(p1: HRC; p2: HREC): HRC; stdcall;
  1750. function CreateHWL(p1: HREC; p2: LPSTR; p3: UINT; p4: DWORD): HWL; stdcall;
  1751. function CreateInksetHRCRESULT(p1: HRCRESULT; p2: UINT; 
  1752.   p3: UINT): HINKSET; stdcall;
  1753. function CreatePenDataHRC(p1: HRC): HPENDATA; stdcall;
  1754. function DestroyHRC(p1: HRC): Integer; stdcall;
  1755. function DestroyHRCRESULT(p1: HRCRESULT): Integer; stdcall;
  1756. function DestroyHWL(p1: HWL): Integer; stdcall;
  1757. function EnableGestureSetHRC(p1: HRC; p2: SYV; p3: BOOL): Integer; stdcall;
  1758. function EnableSystemDictionaryHRC(p1: HRC; p2: BOOL): Integer; stdcall;
  1759. function EndPenInputHRC(p1: HRC): Integer; stdcall;
  1760. function GetAlphabetHRC(p1: HRC; p2: PALC; p3: PByte): Integer; stdcall;
  1761. function GetAlphabetPriorityHRC(p1: HRC; p2: PALC; p3: PByte): Integer; stdcall;
  1762. function GetAlternateWordsHRCRESULT(p1: HRCRESULT; p2: UINT; p3: UINT; 
  1763.   p4: PHRCRESULT; p5: UINT): Integer; stdcall;
  1764. function GetBoxMappingHRCRESULT(p1: HRCRESULT; p2, p3: UINT; 
  1765.   p4: PUINT): Integer; stdcall;
  1766. function GetBoxResultsHRC(p1: HRC; p2, p3, p4: UINT; 
  1767.   p5: PBoxResults; p6: BOOL): Integer; stdcall;
  1768. function GetGuideHRC(p1: HRC; p2: PGuide; p3: PUINT): Integer; stdcall;
  1769. function GetHotspotsHRCRESULT(p1: HRCRESULT; p2: UINT; p3: PPoint; 
  1770.   p4: UINT): Integer; stdcall;
  1771. function GetHRECFromHRC(p1: HRC): HREC; stdcall;
  1772. function GetInternationalHRC(p1: HRC; p2: PUINT; p3: LPSTR; p4: PUINT; 
  1773.   p5: PUINT): Integer; stdcall;
  1774. function GetMaxResultsHRC(p1: HRC): Integer; stdcall;
  1775. function GetResultsHRC(p1: HRC; p2: UINT; p3: PHRCRESULT; 
  1776.   p4: UINT): Integer; stdcall;
  1777. function GetSymbolCountHRCRESULT(p1: HRCRESULT): Integer; stdcall;
  1778. function GetSymbolsHRCRESULT(p1: HRCRESULT; p2: UINT; p3: PSYV; 
  1779.   p4: UINT): Integer; stdcall;
  1780. function GetWordlistHRC(p1: HRC; p2: PHWL): Integer; stdcall;
  1781. function GetWordlistCoercionHRC(p1: HRC): Integer; stdcall;
  1782. function ProcessHRC(p1: HRC; p2: DWORD): Integer; stdcall;
  1783. function ReadHWL(p1: HWL; p2: HFILE): Integer; stdcall;
  1784. function SetAlphabetHRC(p1: HRC; p2: ALC; p3: PByte): Integer; stdcall;
  1785. function SetAlphabetPriorityHRC(p1: HRC; p2: ALC; p3: PByte): Integer; stdcall;
  1786. function SetBoxAlphabetHRC(p1: HRC; p2: PALC; p3: UINT): Integer; stdcall;
  1787. function SetGuideHRC(p1: HRC; p2: PGuide; p3: UINT): Integer; stdcall;
  1788. function SetInternationalHRC(p1: HRC; p2: UINT; p3: LPCSTR; p4: UINT; 
  1789.   p5: UINT): Integer; stdcall;
  1790. function SetMaxResultsHRC(p1: HRC; p2: UINT): Integer; stdcall;
  1791. function SetResultsHookHREC(p1: HREC; var p2: TFNHRCResultHookProc): HRECHOOK; stdcall;
  1792. function SetWordlistCoercionHRC(p1: HRC; p2: UINT): Integer; stdcall;
  1793. function SetWordlistHRC(p1: HRC; p2: HWL): Integer; stdcall;
  1794. function TrainHREC(p1: HREC; p2: PSYV; p3: UINT; p4: HPENDATA; 
  1795.   p5: UINT): Integer; stdcall;
  1796. function UnhookResultsHookHREC(p1: HREC; p2: HRECHOOK): Integer; stdcall;
  1797. function WriteHWL(p1: HWL; p2: HFILE): Integer; stdcall;
  1798.  
  1799. { Recognizer Installation: }
  1800. function InstallRecognizer(p1: LPSTR): HREC; stdcall;
  1801. function UninstallRecognizer(p1: HREC): Pointer; stdcall;
  1802.  
  1803. { Inksets: }
  1804. function AddInksetInterval(p1: HINKSET; p2: PInterval): BOOL; stdcall;
  1805. function CreateInkset(p1: UINT): HINKSET; stdcall;
  1806. function DestroyInkset(p1: HINKSET): BOOL; stdcall;
  1807. function GetInksetInterval(p1: HINKSET; p2: UINT; p3: PInterval): Integer; stdcall;
  1808. function GetInksetIntervalCount(p1: HINKSET): Integer; stdcall;
  1809.  
  1810. { Symbol Values: }
  1811. function CharacterToSymbol(p1: LPSTR; p2: Integer; p3: PSYV): Integer; stdcall;
  1812. function SymbolToCharacter(p1: PSYV; p2: Integer; p3: LPSTR; 
  1813.   p4: PINT): BOOL; stdcall;
  1814.  
  1815. { Pen Input/Inking: }
  1816. function DoDefaultPenInput(p1: HWND; p2: UINT): Integer; stdcall;
  1817. function GetPenInput(p1: HPCM; p2: PPoint; p3: Pointer; p4: UINT; p5: UINT; 
  1818.   p6: PStrokeInfo): Integer; stdcall;
  1819. function PeekPenInput(p1: HPCM; p2: UINT; p3: PPoint; p4: Pointer; 
  1820.   p5: UINT): Integer; stdcall;
  1821. function StartInking(p1: HPCM; p2: UINT; p3: PInkingInfo): Integer; stdcall;
  1822. function StartPenInput(p1: HWND; p2: UINT; p3: PPCMInfo; 
  1823.   p4: PINT): HPCM; stdcall;
  1824. function StopInking(p1: HPCM): Integer; stdcall;
  1825. function StopPenInput(p1: HPCM; p2: UINT; p3: Integer): Integer; stdcall;
  1826.  
  1827. { Miscellaneous/Utilities: }
  1828. function BoundingRectFromPoints(p1: PPoint; p2: UINT; 
  1829.   p3: PRect): Pointer; stdcall;
  1830. function DPtoTP(p1: PPoint; p2: Integer): BOOL; stdcall;
  1831. function GetPenAppFlags: UINT; stdcall; 
  1832. function SetPenAppFlags(p1: UINT; p2: UINT): Pointer; stdcall;
  1833. function GetPenMiscInfo(p1: WPARAM; p2: LPARAM): Longint; stdcall;
  1834. function GetVersionPenWin: UINT; stdcall; 
  1835. function SetPenMiscInfo(p1: WPARAM; p2: LPARAM): Longint; stdcall;
  1836. function TPtoDP(p1: PPoint; p2: Integer): BOOL; stdcall;
  1837. function CorrectWriting(p1: HWND; p2: LPSTR; p3: UINT; p4: Pointer; p5: DWORD; 
  1838.   p6: DWORD): BOOL; stdcall;
  1839.  
  1840. { Ink Targeting: }
  1841. function TargetPoints(p1: PTargInfo; p2: PPoint; p3: DWORD; p4: UINT; 
  1842.   p5: PStrokeInfo): Integer; stdcall;
  1843.  
  1844. { Virtual Event Layer: }
  1845. function AtomicVirtualEvent(p1: BOOL): Pointer; stdcall;
  1846.  
  1847. { Kanji }
  1848. function KKConvert(hwndConvert: HWND; hwndCaller: HWND; lpBuf: LPSTR; 
  1849.   cbBuf: UINT; lpPnt: PPoint): BOOL; stdcall;
  1850.  
  1851. implementation
  1852.  
  1853. const
  1854.   penwin32 = 'penwin32.dll';
  1855.   
  1856. function AddInksetInterval;             external penwin32 name 'AddInksetInterval';
  1857. function AddPenDataHRC;                 external penwin32 name 'AddPenDataHRC';
  1858. function AddPenInputHRC;                external penwin32 name 'AddPenInputHRC';
  1859. function AddPointsPenData;              external penwin32 name 'AddPointsPenData';
  1860. function AddWordsHWL;                   external penwin32 name 'AddWordsHWL';
  1861. function AtomicVirtualEvent;            external penwin32 name 'AtomicVirtualEvent';
  1862. function BoundingRectFromPoints;        external penwin32 name 'BoundingRectFromPoints';
  1863. function CharacterToSymbol;             external penwin32 name 'CharacterToSymbol';
  1864. function CompressPenData;               external penwin32 name 'CompressPenData';
  1865. function ConfigHREC;                    external penwin32 name 'ConfigHREC';
  1866. function CorrectWriting;                external penwin32 name 'CorrectWriting';
  1867. function CreateCompatibleHRC;           external penwin32 name 'CreateCompatibleHRC';
  1868. function CreateHWL;                     external penwin32 name 'CreateHWL';
  1869. function CreateInkset;                  external penwin32 name 'CreateInkset';
  1870. function CreateInksetHRCRESULT;         external penwin32 name 'CreateInksetHRCRESULT';
  1871. function CreatePenDataEx;               external penwin32 name 'CreatePenDataEx';
  1872. function CreatePenDataHRC;              external penwin32 name 'CreatePenDataHRC';
  1873. function CreatePenDataRegion;           external penwin32 name 'CreatePenDataRegion';
  1874. function DestroyHRC;                    external penwin32 name 'DestroyHRC';
  1875. function DestroyHRCRESULT;              external penwin32 name 'DestroyHRCRESULT';
  1876. function DestroyHWL;                    external penwin32 name 'DestroyHWL';
  1877. function DestroyInkset;                 external penwin32 name 'DestroyInkset';
  1878. function DestroyPenData;                external penwin32 name 'DestroyPenData';
  1879. function DictionarySearch;              external penwin32 name 'DictionarySearch';
  1880. function DoDefaultPenInput;             external penwin32 name 'DoDefaultPenInput';
  1881. function DPtoTP;                        external penwin32 name 'DPtoTP';
  1882. function DrawPenDataEx;                 external penwin32 name 'DrawPenDataEx';
  1883. function DuplicatePenData;              external penwin32 name 'DuplicatePenData';
  1884. function EnableGestureSetHRC;           external penwin32 name 'EnableGestureSetHRC';
  1885. function EnableSystemDictionaryHRC;     external penwin32 name 'EnableSystemDictionaryHRC';
  1886. function EndPenInputHRC;                external penwin32 name 'EndPenInputHRC';
  1887. function ExtractPenDataPoints;          external penwin32 name 'ExtractPenDataPoints';
  1888. function ExtractPenDataStrokes;         external penwin32 name 'ExtractPenDataStrokes';
  1889. function GetAlphabetHRC;                external penwin32 name 'GetAlphabetHRC';
  1890. function GetAlphabetPriorityHRC;        external penwin32 name 'GetAlphabetPriorityHRC';
  1891. function GetAlternateWordsHRCRESULT;    external penwin32 name 'GetAlternateWordsHRCRESULT';
  1892. function GetBoxMappingHRCRESULT;        external penwin32 name 'GetBoxMappingHRCRESULT';
  1893. function GetBoxResultsHRC;              external penwin32 name 'GetBoxResultsHRC';
  1894. function GetGuideHRC;                   external penwin32 name 'GetGuideHRC';
  1895. function GetHotspotsHRCRESULT;          external penwin32 name 'GetHotspotsHRCRESULT';
  1896. function GetHRECFromHRC;                external penwin32 name 'GetHRECFromHRC';
  1897. function GetInksetInterval;             external penwin32 name 'GetInksetInterval';
  1898. function GetInksetIntervalCount;        external penwin32 name 'GetInksetIntervalCount';
  1899. function GetInternationalHRC;           external penwin32 name 'GetInternationalHRC';
  1900. function GetMaxResultsHRC;              external penwin32 name 'GetMaxResultsHRC';
  1901. function GetPenAppFlags;                external penwin32 name 'GetPenAppFlags';
  1902. function GetPenAsyncState;              external penwin32 name 'GetPenAsyncState';
  1903. function GetPenDataAttributes;          external penwin32 name 'GetPenDataAttributes';
  1904. function GetPenDataInfo;                external penwin32 name 'GetPenDataInfo';
  1905. function GetPenInput;                   external penwin32 name 'GetPenInput';
  1906. function GetPenMiscInfo;                external penwin32 name 'GetPenMiscInfo';
  1907. function GetPointsFromPenData;          external penwin32 name 'GetPointsFromPenData';
  1908. function GetResultsHRC;                 external penwin32 name 'GetResultsHRC';
  1909. function GetStrokeAttributes;           external penwin32 name 'GetStrokeAttributes';
  1910. function GetStrokeTableAttributes;      external penwin32 name 'GetStrokeTableAttributes';
  1911. function GetSymbolCountHRCRESULT;       external penwin32 name 'GetSymbolCountHRCRESULT';
  1912. function GetSymbolsHRCRESULT;           external penwin32 name 'GetSymbolsHRCRESULT';
  1913. function GetVersionPenWin;              external penwin32 name 'GetVersionpenwin32';
  1914. function GetWordlistCoercionHRC;        external penwin32 name 'GetWordlistCoercionHRC';
  1915. function GetWordlistHRC;                external penwin32 name 'GetWordlistHRC';
  1916. function HitTestPenData;                external penwin32 name 'HitTestPenData';
  1917. function InsertPenData;                 external penwin32 name 'InsertPenData';
  1918. function InsertPenDataPoints;           external penwin32 name 'InsertPenDataPoints';
  1919. function InsertPenDataStroke;           external penwin32 name 'InsertPenDataStroke';
  1920. function InstallRecognizer;             external penwin32 name 'InstallRecognizer';
  1921. function IsPenEvent;                    external penwin32 name 'IsPenEvent';
  1922. function KKConvert;                     external penwin32 name 'KKConvert';
  1923. function MetricScalePenData;            external penwin32 name 'MetricScalePenData';
  1924. function OffsetPenData;                 external penwin32 name 'OffsetPenData';
  1925. function PeekPenInput;                  external penwin32 name 'PeekPenInput';
  1926. function PenDataFromBuffer;             external penwin32 name 'PenDataFromBuffer';
  1927. function PenDataToBuffer;               external penwin32 name 'PenDataToBuffer';
  1928. function ProcessHRC;                    external penwin32 name 'ProcessHRC';
  1929. function ReadHWL;                       external penwin32 name 'ReadHWL';
  1930. function RedisplayPenData;              external penwin32 name 'RedisplayPenData';
  1931. function RemovePenDataStrokes;          external penwin32 name 'RemovePenDataStrokes';
  1932. function ResizePenData;                 external penwin32 name 'ResizePenData';
  1933. function SetAlphabetHRC;                external penwin32 name 'SetAlphabetHRC';
  1934. function SetAlphabetPriorityHRC;        external penwin32 name 'SetAlphabetPriorityHRC';
  1935. function SetBoxAlphabetHRC;             external penwin32 name 'SetBoxAlphabetHRC';
  1936. function SetGuideHRC;                   external penwin32 name 'SetGuideHRC';
  1937. function SetInternationalHRC;           external penwin32 name 'SetInternationalHRC';
  1938. function SetMaxResultsHRC;              external penwin32 name 'SetMaxResultsHRC';
  1939. function SetPenAppFlags;                external penwin32 name 'SetPenAppFlags';
  1940. function SetPenMiscInfo;                external penwin32 name 'SetPenMiscInfo';
  1941. function SetResultsHookHREC;            external penwin32 name 'SetResultsHookHREC';
  1942. function SetStrokeAttributes;           external penwin32 name 'SetStrokeAttributes';
  1943. function SetStrokeTableAttributes;      external penwin32 name 'SetStrokeTableAttributes';
  1944. function SetWordlistCoercionHRC;        external penwin32 name 'SetWordlistCoercionHRC';
  1945. function SetWordlistHRC;                external penwin32 name 'SetWordlistHRC';
  1946. function StartInking;                   external penwin32 name 'StartInking';
  1947. function StartPenInput;                 external penwin32 name 'StartPenInput';
  1948. function StopInking;                    external penwin32 name 'StopInking';
  1949. function StopPenInput;                  external penwin32 name 'StopPenInput';
  1950. function SymbolToCharacter;             external penwin32 name 'SymbolToCharacter';
  1951. function TargetPoints;                  external penwin32 name 'TargetPoints';
  1952. function TPtoDP;                        external penwin32 name 'TPtoDP';
  1953. function TrainHREC;                     external penwin32 name 'TrainHREC';
  1954. function TrimPenData;                   external penwin32 name 'TrimPenData';
  1955. function UnhookResultsHookHREC;         external penwin32 name 'UnhookResultsHookHREC';
  1956. function UninstallRecognizer;           external penwin32 name 'UninstallRecognizer';
  1957. function WriteHWL;                      external penwin32 name 'WriteHWL';
  1958.  
  1959. function FPenUpX(X: Integer): BOOL;
  1960. begin
  1961.   Result := (X and BITPENUP) <> 0;
  1962. end;
  1963.  
  1964. function GetWEventRef: Word;
  1965. begin
  1966.   Result := Word(GetMessageExtraInfo);
  1967. end;
  1968.  
  1969. function MpAlcB(lprc: PRC; i: Word): PByte;
  1970. begin
  1971.   Result := @lprc^.rgbfAlc[ (i and $FF) shr 3 ];
  1972. end;
  1973.  
  1974. function MpIbf(i: Word): Byte;
  1975. begin
  1976.   Result := 1 shl (i and 7);
  1977. end;
  1978.  
  1979. procedure SetAlcBitAnsi(lprc: PRC; i: Word);
  1980. var
  1981.   P: PByte;
  1982. begin
  1983.   P := MpAlcB(lprc, i);
  1984.   P^ := P^ or MpIbf(i);
  1985. end;
  1986.  
  1987. procedure ResetAlcBitAnsi(lprc: PRC; i: Word);
  1988. var
  1989.   P: PByte;
  1990. begin
  1991.   P := MpAlcB(lprc, i);
  1992.   P^ := P^ and not MpIbf(i);
  1993. end;
  1994.  
  1995. function IsAlcBitAnsi(lprc: PRC; i: Word): Boolean;
  1996. begin
  1997.   Result := MpAlcB(lprc,i)^ and MpIbf(i) <> 0;
  1998. end;
  1999.  
  2000. function DrawPenDataFmt(hdc: HDC; lprect: PRect; hpndt: THandle): Integer;
  2001. begin
  2002.   Result := DrawPenDataEx(hdc, lprect, hpndt, 0, IX_END, 0, IX_END, nil, nil, 0);
  2003. end;
  2004.  
  2005. function dwDiffAT(at1, at2: TAbsTime): Integer;
  2006. begin
  2007.   Result := 1000 * (at2.sec - at1.sec) - (at1.ms + at2.ms);
  2008. end;
  2009.  
  2010. function FLTAbsTime(at1, at2: TAbsTime): Boolean;
  2011. begin
  2012.   Result := (at1.sec < at2.sec) or ((at1.sec = at2.sec) and (at1.ms < at2.ms));
  2013. end;
  2014.  
  2015. function FLTEAbsTime(at1, at2: TAbsTime): Boolean;
  2016. begin
  2017.   Result := (at1.sec < at2.sec) or ((at1.sec = at2.sec) and (at1.ms <= at2.ms));
  2018. end;
  2019.  
  2020. function FEQAbsTime(at1, at2: TAbsTime): Boolean;
  2021. begin
  2022.   Result := (at1.sec = at2.sec) and (at1.ms = at2.ms);
  2023. end;
  2024.  
  2025. function FAbsTimeInInterval(at: TAbsTime; lpi: PInterval): Boolean;
  2026. begin
  2027.   Result := FLTEAbsTime(lpi^.atBegin, at) and FLTEAbsTime(at, lpi^.atEnd);
  2028. end;
  2029.  
  2030. function FIntervalInInterval(lpiT, lpiS: PInterval): Boolean;
  2031. begin
  2032.   Result := FLTEAbsTime(lpiS^.atBegin, lpiT^.atBegin) and
  2033.     FLTEAbsTime(lpiT^.atEnd, lpiS^.atEnd);
  2034. end;
  2035.  
  2036. function FIntervalXInterval(lpiT, lpiS: PInterval): Boolean;
  2037. begin
  2038.   Result := (not FLTAbsTime(lpiT^.atEnd, lpiS^.atBegin)) or
  2039.      FLTAbsTime(lpiS^.atEnd, lpiT^.atBegin);
  2040. end;
  2041.  
  2042. function dwDurInterval(lpi: PInterval): Integer;
  2043. begin
  2044.   Result := dwDiffAT(lpi^.atBegin, lpi^.atEnd);
  2045. end;
  2046.  
  2047. procedure MakeAbsTime(var lpat: TAbsTime; sec, ms: Integer);
  2048. begin
  2049.   lpat.sec := sec + ms div 1000;
  2050.   lpat.ms := ms mod 1000;
  2051. end;
  2052.  
  2053. function FIsSpecial(syv: DWORD): Boolean;
  2054. begin
  2055.   Result := HiWord(syv) = SYVHI_SPECIAL;
  2056. end;
  2057.  
  2058. function FIsAnsi(syv: DWORD): Boolean;
  2059. begin
  2060.   Result := HiWord(syv) = SYVHI_ANSI;
  2061. end;
  2062.  
  2063. function FIsGesture(syv: DWORD): Boolean;
  2064. begin
  2065.   Result := HiWord(syv) = SYVHI_GESTURE;
  2066. end;
  2067.  
  2068. function FIsKanji(syv: DWORD): Boolean;
  2069. begin
  2070.   Result := HiWord(syv) = SYVHI_KANJI;
  2071. end;
  2072.  
  2073. function FIsShape(syv: DWORD): Boolean;
  2074. begin
  2075.   Result := HiWord(syv) = SYVHI_SHAPE;
  2076. end;
  2077.  
  2078. function FIsUniCode(syv: DWORD): Boolean;
  2079. begin
  2080.   Result := HiWord(syv) = SYVHI_UNICODE;
  2081. end;
  2082.  
  2083. function FIsVKey(syv: DWORD): Boolean;
  2084. begin
  2085.   Result := HiWord(syv) = SYVHI_VKEY;
  2086. end;
  2087.  
  2088. function ChSyvToAnsi(syv: DWORD): Byte;
  2089. begin
  2090.   Result := Byte(LOWORD(syv));
  2091. end;
  2092.  
  2093. function WSyvToKanji(syv: DWORD): Word;
  2094. begin
  2095.   Result := LOWORD(syv);
  2096. end;
  2097.  
  2098. function SyvCharacterToSymbol(c: Char): DWORD;
  2099. begin
  2100.   Result := Byte(c) or $10000;
  2101. end;
  2102.  
  2103. function SyvKanjiToSymbol(c: Char): DWORD;
  2104. begin
  2105.   Result := Byte(c) or $30000;
  2106. end;
  2107.  
  2108. function FIsSelectGesture(syv: DWORD): Boolean;
  2109. begin
  2110.   Result := (syv >= SYV_SELECTFIRST) and (syv <= SYV_SELECTLAST);
  2111. end;
  2112.  
  2113. function FIsStdGesture(syv: DWORD): Boolean;
  2114. begin
  2115.   Result := FIsSelectGesture(syv) or (syv = SYV_CLEAR) or (syv = SYV_HELP) or 
  2116.     (syv = SYV_EXTENDSELECT) or (syv = SYV_UNDO) or (syv = SYV_COPY) or 
  2117.     (syv = SYV_CUT) or (syv = SYV_PASTE) or (syv = SYV_CLEARWORD) or 
  2118.     (syv = SYV_KKCONVERT) or (syv = SYV_USER) or (syv = SYV_CORRECT);
  2119. end;
  2120.  
  2121. function FIsAnsiGesture(syv: DWORD): Boolean;
  2122. begin
  2123.   Result := (syv = SYV_BACKSPACE) or (syv = SYV_TAB) or 
  2124.     (syv = SYV_RETURN) or (syv = SYV_SPACE);
  2125. end;
  2126.  
  2127. function SubPenMsgFromWpLp(wp, lp: DWORD): Word;
  2128. begin
  2129.   Result := LOWORD(wp);
  2130. end;
  2131.  
  2132. function EventRefFromWpLp(wp, lp: DWORD): Word;
  2133. begin
  2134.   Result := HiWord(wp);
  2135. end;
  2136.  
  2137. function TerminationFromWpLp(wp, lp: DWORD): Integer;
  2138. begin
  2139.   Result := HiWord(wp);
  2140. end;
  2141.  
  2142. function HpcmFromWpLp(wp, lp: DWORD): Integer;
  2143. begin
  2144.   Result := HPCM(lp);
  2145. end;
  2146.  
  2147. function HwndFromHtrg(trg: HTRG): HWND;
  2148. begin
  2149.   Result := HWND(trg);
  2150. end;
  2151.  
  2152. function HtrgFromHwnd(hwnd: HWND): HTRG;
  2153. begin
  2154.   Result := HTRG(hwnd);
  2155. end;
  2156.  
  2157. end.
  2158.