home *** CD-ROM | disk | FTP | other *** search
/ PC World Plus! (NZ) 2001 June / HDC50.iso / Runimage / Delphi50 / Source / Rtl / Win / PENWIN.PAS < prev    next >
Pascal/Delphi Source File  |  1999-08-11  |  139KB  |  3,401 lines
  1.  
  2. {*******************************************************}
  3. {                                                       }
  4. {       Borland Delphi Run-time Library                 }
  5. {       Win32 Pen API Interface Unit                    }
  6. {                                                       }
  7. {       Copyright (c) 1985-1999, Microsoft Corporation  }
  8. {                                                       }
  9. {       Translator: Inprise Corporation                 }
  10. {                                                       }
  11. {*******************************************************}
  12.  
  13. unit PenWin;
  14.  
  15. {$WEAKPACKAGEUNIT}
  16.  
  17. { Pen Windows functions, types, and definitions  }
  18.  
  19. { "FBC" in the comments means that the feature exists only for
  20.   backward compatibility. It should not be used by new applications. }
  21.  
  22. interface
  23.  
  24. uses Windows, Messages, MMSystem;
  25.  
  26. { Enabled Alphabet: }
  27.  
  28. const
  29.   ALC_DEFAULT              = $00000000;  { nothing }
  30. {$EXTERNALSYM ALC_DEFAULT}
  31.   ALC_LCALPHA              = $00000001;  { a..z }
  32. {$EXTERNALSYM ALC_LCALPHA}
  33.   ALC_UCALPHA              = $00000002;  { A..Z }
  34. {$EXTERNALSYM ALC_UCALPHA}
  35.   ALC_NUMERIC              = $00000004;  { 0..9 }
  36. {$EXTERNALSYM ALC_NUMERIC}
  37.   ALC_PUNC                 = $00000008;  { !-;`"?()&.,; and backslash }
  38. {$EXTERNALSYM ALC_PUNC}
  39.   ALC_MATH                 = $00000010;  // %^*()-+={}<>,/.
  40. {$EXTERNALSYM ALC_MATH}
  41.   ALC_MONETARY             = $00000020;  { ,.$ or local }
  42. {$EXTERNALSYM ALC_MONETARY}
  43.   ALC_OTHER                = $00000040;  { @#|_~[] }
  44. {$EXTERNALSYM ALC_OTHER}
  45.   ALC_ASCII                = $00000080;  { restrict to 7-bit chars 20..7f }
  46. {$EXTERNALSYM ALC_ASCII}
  47.   ALC_WHITE                = $00000100;  { white space }
  48. {$EXTERNALSYM ALC_WHITE}
  49.   ALC_NONPRINT             = $00000200;  { sp tab ret ctrl glyphs }
  50. {$EXTERNALSYM ALC_NONPRINT}
  51.   ALC_DBCS                 = $00000400;  { allow DBCS variety of SBCS }
  52. {$EXTERNALSYM ALC_DBCS}
  53.   ALC_JIS1                 = $00000800;  { kanji JPN, ShiftJIS 1 only }
  54. {$EXTERNALSYM ALC_JIS1}
  55.   ALC_GESTURE              = $00004000;  { gestures }
  56. {$EXTERNALSYM ALC_GESTURE}
  57.   ALC_USEBITMAP            = $00008000;  { use rc.rgbfAlc to enable chars }
  58. {$EXTERNALSYM ALC_USEBITMAP}
  59.   ALC_HIRAGANA             = $00010000;  { hiragana JPN }
  60. {$EXTERNALSYM ALC_HIRAGANA}
  61.   ALC_KATAKANA             = $00020000;  { katakana JPN }
  62. {$EXTERNALSYM ALC_KATAKANA}
  63.   ALC_KANJI                = $00040000;  { kanji JPN, ShiftJIS 1+2+3 }
  64. {$EXTERNALSYM ALC_KANJI}
  65.   ALC_GLOBALPRIORITY       = $10000000;
  66. {$EXTERNALSYM ALC_GLOBALPRIORITY}
  67.   ALC_OEM                  = $0FF80000;  { OEM recognizer-specific }
  68. {$EXTERNALSYM ALC_OEM}
  69.   ALC_RESERVED             = $E0003000;  { avail for future use }
  70. {$EXTERNALSYM ALC_RESERVED}
  71.   ALC_NOPRIORITY           = $00000000;  { for alcPriority = none }
  72. {$EXTERNALSYM ALC_NOPRIORITY}
  73.   ALC_ALPHA                = ALC_LCALPHA or ALC_UCALPHA;
  74. {$EXTERNALSYM ALC_ALPHA}
  75.   ALC_ALPHANUMERIC         = ALC_ALPHA or ALC_NUMERIC;
  76. {$EXTERNALSYM ALC_ALPHANUMERIC}
  77.   ALC_SYSMINIMUM = ALC_ALPHANUMERIC or ALC_PUNC or ALC_WHITE or ALC_GESTURE;
  78. {$EXTERNALSYM ALC_SYSMINIMUM}
  79.   ALC_ALL = ALC_SYSMINIMUM or ALC_MATH or ALC_MONETARY or ALC_OTHER or ALC_NONPRINT;
  80. {$EXTERNALSYM ALC_ALL}
  81.   ALC_KANJISYSMINIMUM = ALC_SYSMINIMUM or ALC_HIRAGANA or ALC_KATAKANA or ALC_JIS1;
  82. {$EXTERNALSYM ALC_KANJISYSMINIMUM}
  83.   ALC_KANJIALL = ALC_ALL or ALC_HIRAGANA or ALC_KATAKANA or ALC_KANJI;
  84. {$EXTERNALSYM ALC_KANJIALL}
  85.  
  86. { box edit styles: }
  87.  
  88.   BXS_NONE                 = $0000;  { none }
  89. {$EXTERNALSYM BXS_NONE}
  90.   BXS_RECT                 = $0001;  { use rectangle instead of cusp }
  91. {$EXTERNALSYM BXS_RECT}
  92.   BXS_BOXCROSS             = $0004;  { use cross at box center }
  93. {$EXTERNALSYM BXS_BOXCROSS}
  94.   BXS_MASK                 = $0007;  { mask for above }
  95. {$EXTERNALSYM BXS_MASK}
  96.  
  97. { Public Bitmaps : }
  98.  
  99.   OBM_SKBBTNUP                = 32767;
  100. {$EXTERNALSYM OBM_SKBBTNUP}
  101.   OBM_SKBBTNDOWN              = 32766;
  102. {$EXTERNALSYM OBM_SKBBTNDOWN}
  103.   OBM_SKBBTNDISABLED          = 32765;
  104. {$EXTERNALSYM OBM_SKBBTNDISABLED}
  105.  
  106.   OBM_ZENBTNUP                = 32764;
  107. {$EXTERNALSYM OBM_ZENBTNUP}
  108.   OBM_ZENBTNDOWN              = 32763;
  109. {$EXTERNALSYM OBM_ZENBTNDOWN}
  110.   OBM_ZENBTNDISABLED          = 32762;
  111. {$EXTERNALSYM OBM_ZENBTNDISABLED}
  112.  
  113.   OBM_HANBTNUP                = 32761;
  114. {$EXTERNALSYM OBM_HANBTNUP}
  115.   OBM_HANBTNDOWN              = 32760;
  116. {$EXTERNALSYM OBM_HANBTNDOWN}
  117.   OBM_HANBTNDISABLED          = 32759;
  118. {$EXTERNALSYM OBM_HANBTNDISABLED}
  119.  
  120.   OBM_KKCBTNUP                = 32758;
  121. {$EXTERNALSYM OBM_KKCBTNUP}
  122.   OBM_KKCBTNDOWN              = 32757;
  123. {$EXTERNALSYM OBM_KKCBTNDOWN}
  124.   OBM_KKCBTNDISABLED          = 32756;
  125.  {$EXTERNALSYM OBM_KKCBTNDISABLED}
  126.  
  127.   OBM_SIPBTNUP                = 32755;
  128. {$EXTERNALSYM OBM_SIPBTNUP}
  129.   OBM_SIPBTNDOWN              = 32754;
  130. {$EXTERNALSYM OBM_SIPBTNDOWN}
  131.   OBM_SIPBTNDISABLED          = 32753;
  132. {$EXTERNALSYM OBM_SIPBTNDISABLED}
  133.  
  134.   OBM_PTYBTNUP                = 32752;
  135. {$EXTERNALSYM OBM_PTYBTNUP}
  136.   OBM_PTYBTNDOWN              = 32751;
  137. {$EXTERNALSYM OBM_PTYBTNDOWN}
  138.   OBM_PTYBTNDISABLED          = 32750;
  139. {$EXTERNALSYM OBM_PTYBTNDISABLED}
  140.  
  141. { Default pen cursor to indicate writing, points northwest }
  142.   IDC_PEN             = MAKEINTRESOURCE(32631);
  143. {$EXTERNALSYM IDC_PEN}
  144.  
  145. { alternate select cursor: upsidedown standard arrow, points southeast }
  146.   IDC_ALTSELECT       = MAKEINTRESOURCE(32501);
  147. {$EXTERNALSYM IDC_ALTSELECT}
  148.  
  149. { special SYV values: }
  150.   SYV_NULL                    = $00000000;
  151. {$EXTERNALSYM SYV_NULL}
  152.   SYV_UNKNOWN                 = $00000001;
  153. {$EXTERNALSYM SYV_UNKNOWN}
  154.   SYV_EMPTY                   = $00000003;
  155. {$EXTERNALSYM SYV_EMPTY}
  156.   SYV_BEGINOR                 = $00000010;
  157. {$EXTERNALSYM SYV_BEGINOR}
  158.   SYV_ENDOR                   = $00000011;
  159. {$EXTERNALSYM SYV_ENDOR}
  160.   SYV_OR                      = $00000012;
  161. {$EXTERNALSYM SYV_OR}
  162.   SYV_SOFTNEWLINE             = $00000020;
  163. {$EXTERNALSYM SYV_SOFTNEWLINE}
  164.   SYV_SPACENULL               = $00010000;    { SyvCharacterToSymbol('\0') }
  165. {$EXTERNALSYM SYV_SPACENULL}
  166.  
  167. { SYV values for gestures: }
  168.   SYV_SELECTFIRST             = $0002FFC0;    { . means circle in following }
  169. {$EXTERNALSYM SYV_SELECTFIRST}
  170.   SYV_LASSO                   = $0002FFC1;    { lasso o-tap }
  171. {$EXTERNALSYM SYV_LASSO}
  172.   SYV_SELECTLEFT              = $0002FFC2;    { no glyph }
  173. {$EXTERNALSYM SYV_SELECTLEFT}
  174.   SYV_SELECTRIGHT             = $0002FFC3;    { no glyph }
  175. {$EXTERNALSYM SYV_SELECTRIGHT}
  176.   SYV_SELECTLAST              = $0002FFCF;    { 16 SYVs reserved for selection }
  177. {$EXTERNALSYM SYV_SELECTLAST}
  178.  
  179.   SYV_CLEARCHAR               = $0002FFD2;    { d. }
  180. {$EXTERNALSYM SYV_CLEARCHAR}
  181.   SYV_HELP                    = $0002FFD3;    { no glyph }
  182. {$EXTERNALSYM SYV_HELP}
  183.   SYV_KKCONVERT               = $0002FFD4;    { k. }
  184. {$EXTERNALSYM SYV_KKCONVERT}
  185.   SYV_CLEAR                   = $0002FFD5;    { d. }
  186. {$EXTERNALSYM SYV_CLEAR}
  187.   SYV_INSERT                  = $0002FFD6;    { ^. }
  188. {$EXTERNALSYM SYV_INSERT}
  189.   SYV_CONTEXT                 = $0002FFD7;    { m. }
  190. {$EXTERNALSYM SYV_CONTEXT}
  191.   SYV_EXTENDSELECT            = $0002FFD8;    { no glyph }
  192. {$EXTERNALSYM SYV_EXTENDSELECT}
  193.   SYV_UNDO                    = $0002FFD9;    { u. }
  194. {$EXTERNALSYM SYV_UNDO}
  195.   SYV_COPY                    = $0002FFDA;    { c. }
  196. {$EXTERNALSYM SYV_COPY}
  197.   SYV_CUT                     = $0002FFDB;    { x. }
  198. {$EXTERNALSYM SYV_CUT}
  199.   SYV_PASTE                   = $0002FFDC;    { p. }
  200. {$EXTERNALSYM SYV_PASTE}
  201.   SYV_CLEARWORD               = $0002FFDD;    { no glyph }
  202. {$EXTERNALSYM SYV_CLEARWORD}
  203.   SYV_USER                    = $0002FFDE;    { reserved }
  204. {$EXTERNALSYM SYV_USER}
  205.   SYV_CORRECT                 = $0002FFDF;    { check. }
  206. {$EXTERNALSYM SYV_CORRECT}
  207.  
  208.   SYV_BACKSPACE               = $00020008;    { no glyph }
  209. {$EXTERNALSYM SYV_BACKSPACE}
  210.   SYV_TAB                     = $00020009;    { t. }
  211. {$EXTERNALSYM SYV_TAB}
  212.   SYV_RETURN                  = $0002000D;    { n. }
  213. {$EXTERNALSYM SYV_RETURN}
  214.   SYV_SPACE                   = $00020020;    { s. }
  215. {$EXTERNALSYM SYV_SPACE}
  216.  
  217. { Application specific gestures, Circle a-z and Circle A-Z: }
  218.   SYV_APPGESTUREMASK          = $00020000;
  219. {$EXTERNALSYM SYV_APPGESTUREMASK}
  220.   SYV_CIRCLEUPA               = $000224B6;    { map into Unicode space }
  221. {$EXTERNALSYM SYV_CIRCLEUPA}
  222.   SYV_CIRCLEUPZ               = $000224CF;    {  for circled letters }
  223. {$EXTERNALSYM SYV_CIRCLEUPZ}
  224.   SYV_CIRCLELOA               = $000224D0;
  225. {$EXTERNALSYM SYV_CIRCLELOA}
  226.   SYV_CIRCLELOZ               = $000224E9;
  227. {$EXTERNALSYM SYV_CIRCLELOZ}
  228.  
  229. { SYV definitions for shapes: }
  230.   SYV_SHAPELINE               = $00040001;
  231. {$EXTERNALSYM SYV_SHAPELINE}
  232.   SYV_SHAPEELLIPSE            = $00040002;
  233. {$EXTERNALSYM SYV_SHAPEELLIPSE}
  234.   SYV_SHAPERECT               = $00040003;
  235. {$EXTERNALSYM SYV_SHAPERECT}
  236.   SYV_SHAPEMIN                = SYV_SHAPELINE; { alias }
  237. {$EXTERNALSYM SYV_SHAPEMIN}
  238.   SYV_SHAPEMAX                = SYV_SHAPERECT; { alias }
  239. {$EXTERNALSYM SYV_SHAPEMAX}
  240.  
  241. { SYV classes: }
  242.   SYVHI_SPECIAL               = 0;
  243. {$EXTERNALSYM SYVHI_SPECIAL}
  244.   SYVHI_ANSI                  = 1;
  245. {$EXTERNALSYM SYVHI_ANSI}
  246.   SYVHI_GESTURE               = 2;
  247. {$EXTERNALSYM SYVHI_GESTURE}
  248.   SYVHI_KANJI                 = 3;
  249. {$EXTERNALSYM SYVHI_KANJI}
  250.   SYVHI_SHAPE                 = 4;
  251. {$EXTERNALSYM SYVHI_SHAPE}
  252.   SYVHI_UNICODE               = 5;
  253. {$EXTERNALSYM SYVHI_UNICODE}
  254.   SYVHI_VKEY                  = 6;
  255. {$EXTERNALSYM SYVHI_VKEY}
  256.  
  257.  
  258. { IEdit Pop-up Menu Command Items }
  259.  
  260.   IEM_UNDO                    = 1;         { Undo }
  261. {$EXTERNALSYM IEM_UNDO}
  262.   IEM_CUT                     = 2;         { Cut }
  263. {$EXTERNALSYM IEM_CUT}
  264.   IEM_COPY                    = 3;         { Copy }
  265. {$EXTERNALSYM IEM_COPY}
  266.   IEM_PASTE                   = 4;         { Paste }
  267. {$EXTERNALSYM IEM_PASTE}
  268.   IEM_CLEAR                   = 5;         { Clear }
  269. {$EXTERNALSYM IEM_CLEAR}
  270.   IEM_SELECTALL               = 6;         { Select All Strokes }
  271. {$EXTERNALSYM IEM_SELECTALL}
  272.   IEM_ERASE                   = 7;         { Use Eraser }
  273. {$EXTERNALSYM IEM_ERASE}
  274.   IEM_PROPERTIES              = 8;         { DoProperties }
  275. {$EXTERNALSYM IEM_PROPERTIES}
  276.   IEM_LASSO                   = 9;         { Use Lasso }
  277. {$EXTERNALSYM IEM_LASSO}
  278.   IEM_RESIZE                  = 10;        { Resize }
  279. {$EXTERNALSYM IEM_RESIZE}
  280.  
  281.   IEM_USER                        = 100;   { first menu item# available to app }
  282. {$EXTERNALSYM IEM_USER}
  283.  
  284. { IEdit Style Attributes }
  285.   IES_BORDER                  = $0001;   { ctl has a border }
  286. {$EXTERNALSYM IES_BORDER}
  287.   IES_HSCROLL                 = $0002;   { ctl is horizontally scrollable }
  288. {$EXTERNALSYM IES_HSCROLL}
  289.   IES_VSCROLL                 = $0004;   { ctl is vertically scrollable }
  290. {$EXTERNALSYM IES_VSCROLL}
  291.   IES_OWNERDRAW               = $0008;   { ctl will be drawn by parent window }
  292. {$EXTERNALSYM IES_OWNERDRAW}
  293.  
  294.  
  295. { PenData API constants: }
  296.  
  297. { ANIMATEINFO callback options: }
  298.   AI_CBSTROKE                 = $FFFF;  { Animate callback after every stroke }
  299. {$EXTERNALSYM AI_CBSTROKE}
  300.  
  301. { ANIMATEINFO options: }
  302.   AI_SKIPUPSTROKES            = $0001;  { ignore upstrokes in animation }
  303. {$EXTERNALSYM AI_SKIPUPSTROKES}
  304.  
  305. { CompressPenData() API options: }
  306.   CMPD_COMPRESS               = $0001;
  307. {$EXTERNALSYM CMPD_COMPRESS}
  308.   CMPD_DECOMPRESS             = $0002;
  309. {$EXTERNALSYM CMPD_DECOMPRESS}
  310.  
  311. { CreatePenDataRegion types: }
  312.   CPDR_BOX                    = 1;      { bounding box }
  313. {$EXTERNALSYM CPDR_BOX}
  314.   CPDR_LASSO                  = 2;      { lasso }
  315. {$EXTERNALSYM CPDR_LASSO}
  316.  
  317. { CreatePenData (CPD) and Pen Hardware (PHW) Flags; }
  318. { The order of PHW flags is important: }
  319.   CPD_DEFAULT                 = $047F;  { CPD_TIME | PHW_ALL }
  320. {$EXTERNALSYM CPD_DEFAULT}
  321.   CPD_USERBYTE                = $0100;  { alloc 8 bits/stroke }
  322. {$EXTERNALSYM CPD_USERBYTE}
  323.   CPD_USERWORD                = $0200;  { alloc 16 bits/stroke }
  324. {$EXTERNALSYM CPD_USERWORD}
  325.   CPD_USERDWORD               = $0300;  { alloc 32 bits/stroke }
  326. {$EXTERNALSYM CPD_USERDWORD}
  327.   CPD_TIME                    = $0400;  { maintain abs time info per stroke }
  328. {$EXTERNALSYM CPD_TIME}
  329.  
  330. { DrawPenDataEx() flags/options: }
  331.   DPD_HDCPEN                  = $0001;  { use pen selected in HDC }
  332. {$EXTERNALSYM DPD_HDCPEN}
  333.   DPD_DRAWSEL                 = $0002;  { draw the selection }
  334. {$EXTERNALSYM DPD_DRAWSEL}
  335.  
  336. { ExtractPenDataPoints options (EPDP_xx): }
  337.   EPDP_REMOVE                 = $0001;  { Remove points from the pendata }
  338. {$EXTERNALSYM EPDP_REMOVE}
  339.  
  340. { ExtractPenDataStrokes options and modifiers (EPDS_xx): }
  341.   EPDS_SELECT                 = 1;      { selected strokes }
  342. {$EXTERNALSYM EPDS_SELECT}
  343.   EPDS_STROKEINDEX            = 2;      { index }
  344. {$EXTERNALSYM EPDS_STROKEINDEX}
  345.   EPDS_USER                   = 3;      { user-specific value }
  346. {$EXTERNALSYM EPDS_USER}
  347.   EPDS_PENTIP                 = 4;      { complete pentip }
  348. {$EXTERNALSYM EPDS_PENTIP}
  349.   EPDS_TIPCOLOR               = 5;      { pentip color }
  350. {$EXTERNALSYM EPDS_TIPCOLOR}
  351.   EPDS_TIPWIDTH               = 6;      { pentip width }
  352. {$EXTERNALSYM EPDS_TIPWIDTH}
  353.   EPDS_TIPNIB                 = 7;      { pentip nib style }
  354. {$EXTERNALSYM EPDS_TIPNIB}
  355.   EPDS_INKSET                 = 8;      { inkset match }
  356. {$EXTERNALSYM EPDS_INKSET}
  357.  
  358.   EPDS_EQ                     = $0000;  { default: same as }
  359. {$EXTERNALSYM EPDS_EQ}
  360.   EPDS_LT                     = $0010;  { all strokes less than }
  361. {$EXTERNALSYM EPDS_LT}
  362.   EPDS_GT                     = $0020;  { all strokes greater than }
  363. {$EXTERNALSYM EPDS_GT}
  364.   EPDS_NOT                    = $0040;  { all strokes not matching }
  365. {$EXTERNALSYM EPDS_NOT}
  366.   EPDS_NE                     = $0040;  { alias }
  367. {$EXTERNALSYM EPDS_NE}
  368.   EPDS_GTE                    = $0050;  { alias for NOT LT }
  369. {$EXTERNALSYM EPDS_GTE}
  370.   EPDS_LTE                    = $0060;  { alias for NOT GT }
  371. {$EXTERNALSYM EPDS_LTE}
  372.   EPDS_REMOVE                 = $8000;  { remove matching strokes from source }
  373. {$EXTERNALSYM EPDS_REMOVE}
  374.  
  375. { GetPenDataAttributes options (GPA_xx): }
  376.   GPA_MAXLEN                  = 1;  { length of longest stroke }
  377. {$EXTERNALSYM GPA_MAXLEN}
  378.   GPA_POINTS                  = 2;  { total number of points }
  379. {$EXTERNALSYM GPA_POINTS}
  380.   GPA_PDTS                    = 3;  { PDTS_xx bits }
  381. {$EXTERNALSYM GPA_PDTS}
  382.   GPA_RATE                    = 4;  { get sampling rate }
  383. {$EXTERNALSYM GPA_RATE}
  384.   GPA_RECTBOUND               = 5;  { bounding rect of all points }
  385. {$EXTERNALSYM GPA_RECTBOUND}
  386.   GPA_RECTBOUNDINK            = 6;  { ditto, adj for fat ink }
  387. {$EXTERNALSYM GPA_RECTBOUNDINK}
  388.   GPA_SIZE                    = 7;  { size of pendata in bytes }
  389. {$EXTERNALSYM GPA_SIZE}
  390.   GPA_STROKES                 = 8;  { total number of strokes }
  391. {$EXTERNALSYM GPA_STROKES}
  392.   GPA_TIME                    = 9;  { absolute time at creation of pendata }
  393. {$EXTERNALSYM GPA_TIME}
  394.   GPA_USER                    = 10; { number of user bytes available: 0, 1, 2, 4 }
  395. {$EXTERNALSYM GPA_USER}
  396.   GPA_VERSION                 = 11; { version number of pendata }
  397. {$EXTERNALSYM GPA_VERSION}
  398.  
  399. { GetStrokeAttributes options (GSA_xx): }
  400.   GSA_PENTIP                  = 1;  { get stroke pentip (color, width, nib) }
  401. {$EXTERNALSYM GSA_PENTIP}
  402.   GSA_PENTIPCLASS             = 2;  { same as GSA_PENTIP }
  403. {$EXTERNALSYM GSA_PENTIPCLASS}
  404.   GSA_USER                    = 3;  { get stroke user value }
  405. {$EXTERNALSYM GSA_USER}
  406.   GSA_USERCLASS               = 4;  { get stroke's class user value }
  407. {$EXTERNALSYM GSA_USERCLASS}
  408.   GSA_TIME                    = 5;  { get time of stroke }
  409. {$EXTERNALSYM GSA_TIME}
  410.   GSA_SIZE                    = 6;  { get size of stroke in points and bytes }
  411. {$EXTERNALSYM GSA_SIZE}
  412.   GSA_SELECT                  = 7;  { get selection status of stroke }
  413. {$EXTERNALSYM GSA_SELECT}
  414.   GSA_DOWN                    = 8;  { get up/down state of stroke }
  415. {$EXTERNALSYM GSA_DOWN}
  416.   GSA_RECTBOUND               = 9;  { get the bounding rectangle of the stroke }
  417. {$EXTERNALSYM GSA_RECTBOUND}
  418.  
  419. { GetStrokeTableAttributes options (GSA_xx): }
  420.   GSA_PENTIPTABLE             = 10; { get table-indexed pentip }
  421. {$EXTERNALSYM GSA_PENTIPTABLE}
  422.   GSA_SIZETABLE               = 11; { get count of Stroke Class Table entries }
  423. {$EXTERNALSYM GSA_SIZETABLE}
  424.   GSA_USERTABLE               = 12; { get table-indexed user value }
  425. {$EXTERNALSYM GSA_USERTABLE}
  426.  
  427.   IX_END                      = $FFFF;  { to or past last available index }
  428. {$EXTERNALSYM IX_END}
  429.  
  430. { PenTip: }
  431.   PENTIP_NIBDEFAULT           = (0);            { default pen tip nib style }
  432. {$EXTERNALSYM PENTIP_NIBDEFAULT}
  433.   PENTIP_HEIGHTDEFAULT        = (0);            { default pen tip nib height }
  434. {$EXTERNALSYM PENTIP_HEIGHTDEFAULT}
  435.   PENTIP_OPAQUE               = $FF;            { default opaque ink }
  436. {$EXTERNALSYM PENTIP_OPAQUE}
  437.   PENTIP_HILITE               = $80;
  438. {$EXTERNALSYM PENTIP_HILITE}
  439.   PENTIP_TRANSPARENT          = (0);
  440. {$EXTERNALSYM PENTIP_TRANSPARENT}
  441.  
  442. { General PenData API return values (PDR_xx): }
  443.   PDR_NOHIT                   = 3;      { hit test failed }
  444. {$EXTERNALSYM PDR_NOHIT}
  445.   PDR_HIT                     = 2;      { hit test succeeded }
  446. {$EXTERNALSYM PDR_HIT}
  447.   PDR_OK                      = 1;      { success }
  448. {$EXTERNALSYM PDR_OK}
  449.   PDR_CANCEL                  = 0;      { callback cancel or impasse }
  450. {$EXTERNALSYM PDR_CANCEL}
  451.  
  452.   PDR_ERROR                   = -1;     { parameter or unspecified error }
  453. {$EXTERNALSYM PDR_ERROR}
  454.   PDR_PNDTERR                 = -2;     { bad pendata }
  455. {$EXTERNALSYM PDR_PNDTERR}
  456.   PDR_VERSIONERR              = -3;     { pendata version error }
  457. {$EXTERNALSYM PDR_VERSIONERR}
  458.   PDR_COMPRESSED              = -4;     { pendata is compressed }
  459. {$EXTERNALSYM PDR_COMPRESSED}
  460.   PDR_STRKINDEXERR            = -5;     { stroke index error }
  461. {$EXTERNALSYM PDR_STRKINDEXERR}
  462.   PDR_PNTINDEXERR             = -6;     { point index error }
  463. {$EXTERNALSYM PDR_PNTINDEXERR}
  464.   PDR_MEMERR                  = -7;     { memory error }
  465. {$EXTERNALSYM PDR_MEMERR}
  466.   PDR_INKSETERR               = -8;     { bad inkset }
  467. {$EXTERNALSYM PDR_INKSETERR}
  468.   PDR_ABORT                   = -9;     { pendata has become invalid, e.g. }
  469. {$EXTERNALSYM PDR_ABORT}
  470.   PDR_NA                      = -10;    { option not available (pw kernel) }
  471. {$EXTERNALSYM PDR_NA}
  472.   PDR_USERDATAERR             = -16;    { user data error }
  473. {$EXTERNALSYM PDR_USERDATAERR}
  474.   PDR_SCALINGERR              = -17;    { scale error }
  475. {$EXTERNALSYM PDR_SCALINGERR}
  476.   PDR_TIMESTAMPERR            = -18;    { timestamp error }
  477. {$EXTERNALSYM PDR_TIMESTAMPERR}
  478.   PDR_OEMDATAERR              = -19;    { OEM data error }
  479. {$EXTERNALSYM PDR_OEMDATAERR}
  480.   PDR_SCTERR                  = -20;    { SCT error (full) }
  481. {$EXTERNALSYM PDR_SCTERR}
  482.  
  483. { PenData Scaling (PDTS): }
  484.   PDTS_LOMETRIC               = 0;      { 0.01mm }
  485. {$EXTERNALSYM PDTS_LOMETRIC}
  486.   PDTS_HIMETRIC               = 1;      { 0.001mm }
  487. {$EXTERNALSYM PDTS_HIMETRIC}
  488.   PDTS_HIENGLISH              = 2;      { 0.001" }
  489. {$EXTERNALSYM PDTS_HIENGLISH}
  490.   PDTS_STANDARDSCALE          = 2;      { PDTS_HIENGLISH   alias }
  491. {$EXTERNALSYM PDTS_STANDARDSCALE}
  492.   PDTS_DISPLAY                = 3;      { display pixel }
  493. {$EXTERNALSYM PDTS_DISPLAY}
  494.   PDTS_ARBITRARY              = 4;      { app-specific scaling }
  495. {$EXTERNALSYM PDTS_ARBITRARY}
  496.   PDTS_SCALEMASK              = $000F;  { scaling values in low nibble }
  497. {$EXTERNALSYM PDTS_SCALEMASK}
  498.  
  499. { CompactPenData API trim options: }
  500.   PDTT_DEFAULT                = $0000;
  501. {$EXTERNALSYM PDTT_DEFAULT}
  502.   PDTT_PENINFO                = $0100;
  503. {$EXTERNALSYM PDTT_PENINFO}
  504.   PDTT_UPPOINTS               = $0200;
  505. {$EXTERNALSYM PDTT_UPPOINTS}
  506.   PDTT_OEMDATA                = $0400;
  507. {$EXTERNALSYM PDTT_OEMDATA}
  508.   PDTT_COLLINEAR              = $0800;
  509. {$EXTERNALSYM PDTT_COLLINEAR}
  510.   PDTT_COLINEAR               = $0800;  { alt sp alias }
  511. {$EXTERNALSYM PDTT_COLINEAR}
  512.   PDTT_DECOMPRESS             = $4000;  { decompress the data }
  513. {$EXTERNALSYM PDTT_DECOMPRESS}
  514.   PDTT_COMPRESS               = $8000;
  515. {$EXTERNALSYM PDTT_COMPRESS}
  516.   PDTT_ALL                    = $0F00;  { PENINFO|UPPOINTS|OEMDATA|COLLINEAR }
  517. {$EXTERNALSYM PDTT_ALL}
  518.  
  519.   PHW_NONE                    = $0000;  { no OEMdata }
  520. {$EXTERNALSYM PHW_NONE}
  521.   PHW_PRESSURE                = $0001;  { report pressure in OEMdata if avail }
  522. {$EXTERNALSYM PHW_PRESSURE}
  523.   PHW_HEIGHT                  = $0002;  { ditto height }
  524. {$EXTERNALSYM PHW_HEIGHT}
  525.   PHW_ANGLEXY                 = $0004;  { ditto xy angle }
  526. {$EXTERNALSYM PHW_ANGLEXY}
  527.   PHW_ANGLEZ                  = $0008;  { ditto z angle }
  528. {$EXTERNALSYM PHW_ANGLEZ}
  529.   PHW_BARRELROTATION          = $0010;  { ditto barrel rotation }
  530. {$EXTERNALSYM PHW_BARRELROTATION}
  531.   PHW_OEMSPECIFIC             = $0020;  { ditto OEM-specific value }
  532. {$EXTERNALSYM PHW_OEMSPECIFIC}
  533.   PHW_PDK                     = $0040;  { report per-point PDK_xx in OEM data }
  534. {$EXTERNALSYM PHW_PDK}
  535.   PHW_ALL                     = $007F;  { report everything }
  536. {$EXTERNALSYM PHW_ALL}
  537.  
  538. { compact pen data trim options: matches PDTT_values (see above) }
  539.   PDTS_COMPRESS2NDDERIV       = $0010;  { compress using 2nd deriv }
  540. {$EXTERNALSYM PDTS_COMPRESS2NDDERIV}
  541.   PDTS_COMPRESSMETHOD         = $00F0;  { sum of compress method flags }
  542. {$EXTERNALSYM PDTS_COMPRESSMETHOD}
  543.   PDTS_NOPENINFO              = $0100;  { removes PENINFO struct from header }
  544. {$EXTERNALSYM PDTS_NOPENINFO}
  545.   PDTS_NOUPPOINTS             = $0200;  { remove up pts }
  546. {$EXTERNALSYM PDTS_NOUPPOINTS}
  547.   PDTS_NOOEMDATA              = $0400;  { remove OEM data }
  548. {$EXTERNALSYM PDTS_NOOEMDATA}
  549.   PDTS_NOCOLLINEAR            = $0800;  { remove successive identical pts }
  550. {$EXTERNALSYM PDTS_NOCOLLINEAR}
  551.   PDTS_NOCOLINEAR             = $0800;  { alt sp alias }
  552. {$EXTERNALSYM PDTS_NOCOLINEAR}
  553.   PDTS_NOTICK                 = $1000;  { remove timing info (2.0) }
  554. {$EXTERNALSYM PDTS_NOTICK}
  555.   PDTS_NOUSER                 = $2000;  { remove user info (2.0) }
  556. {$EXTERNALSYM PDTS_NOUSER}
  557.   PDTS_NOEMPTYSTROKES         = $4000;  { remove empty strokes (2.0) }
  558. {$EXTERNALSYM PDTS_NOEMPTYSTROKES}
  559.   PDTS_COMPRESSED             = $8000;  { perform lossless compression }
  560. {$EXTERNALSYM PDTS_COMPRESSED}
  561.  
  562. { SetStrokeAttributes options (SSA_xx): }
  563.   SSA_PENTIP                  = 1;      { set stroke tip (color, width, nib) }
  564. {$EXTERNALSYM SSA_PENTIP}
  565.   SSA_PENTIPCLASS             = 2;      { set stroke's class pentip }
  566. {$EXTERNALSYM SSA_PENTIPCLASS}
  567.   SSA_USER                    = 3;      { set stroke user value }
  568. {$EXTERNALSYM SSA_USER}
  569.   SSA_USERCLASS               = 4;      { set stroke's class user value }
  570. {$EXTERNALSYM SSA_USERCLASS}
  571.   SSA_TIME                    = 5;      { set time of stroke }
  572. {$EXTERNALSYM SSA_TIME}
  573.   SSA_SELECT                  = 6;      { set selection status of stroke }
  574. {$EXTERNALSYM SSA_SELECT}
  575.   SSA_DOWN                    = 7;      { set up/down state of stroke }
  576. {$EXTERNALSYM SSA_DOWN}
  577.  
  578. { SetStrokeTableAttributes options (SSA_xx): }
  579.   SSA_PENTIPTABLE             = 8;      { set table-indexed pentip }
  580. {$EXTERNALSYM SSA_PENTIPTABLE}
  581.   SSA_USERTABLE               = 9;      { set table-indexed user value }
  582. {$EXTERNALSYM SSA_USERTABLE}
  583.  
  584. { PenTip flag bits: }
  585.   TIP_ERASECOLOR              = 1;      { erase specific color pentip.rgb }
  586. {$EXTERNALSYM TIP_ERASECOLOR}
  587.  
  588. { TrimPenData() API options: }
  589.   TPD_RECALCSIZE              = $0000;  { no trim, used for resize calc }
  590. {$EXTERNALSYM TPD_RECALCSIZE}
  591.   TPD_USER                    = $0080;  { per-stroke user info }
  592. {$EXTERNALSYM TPD_USER}
  593.   TPD_TIME                    = $0100;  { per-stroke timing info }
  594. {$EXTERNALSYM TPD_TIME}
  595.   TPD_UPPOINTS                = $0200;  { x-y data up points }
  596. {$EXTERNALSYM TPD_UPPOINTS}
  597.   TPD_COLLINEAR               = $0400;  { colinear and coincident points }
  598. {$EXTERNALSYM TPD_COLLINEAR}
  599.   TPD_COLINEAR                = $0400;  { alt sp alias }
  600. {$EXTERNALSYM TPD_COLINEAR}
  601.   TPD_PENINFO                 = $0800;  { PenInfo struct and all OEM }
  602. {$EXTERNALSYM TPD_PENINFO}
  603.   TPD_PHW                     = $1000;  { OEM & pdk except stroke tick or user }
  604. {$EXTERNALSYM TPD_PHW}
  605.   TPD_OEMDATA                 = $1000;  { ditto }
  606. {$EXTERNALSYM TPD_OEMDATA}
  607.   TPD_EMPTYSTROKES            = $2000;  { strokes with zero points }
  608. {$EXTERNALSYM TPD_EMPTYSTROKES}
  609.   TPD_EVERYTHING              = $3FFF;  { everything (incl PHW_xx) except down pts }
  610. {$EXTERNALSYM TPD_EVERYTHING}
  611.  
  612. { Dictionary: }
  613.  
  614.   cbDictPathMax               = 255;
  615. {$EXTERNALSYM cbDictPathMax}
  616.   DIRQ_QUERY                  = 1;
  617. {$EXTERNALSYM DIRQ_QUERY}
  618.   DIRQ_DESCRIPTION            = 2;
  619. {$EXTERNALSYM DIRQ_DESCRIPTION}
  620.   DIRQ_CONFIGURE              = 3;
  621. {$EXTERNALSYM DIRQ_CONFIGURE}
  622.   DIRQ_OPEN                   = 4;
  623. {$EXTERNALSYM DIRQ_OPEN}
  624.   DIRQ_CLOSE                  = 5;
  625. {$EXTERNALSYM DIRQ_CLOSE}
  626.   DIRQ_SETWORDLISTS           = 6;
  627. {$EXTERNALSYM DIRQ_SETWORDLISTS}
  628.   DIRQ_STRING                 = 7;
  629. {$EXTERNALSYM DIRQ_STRING}
  630.   DIRQ_SUGGEST                = 8;
  631. {$EXTERNALSYM DIRQ_SUGGEST}
  632.   DIRQ_ADD                    = 9;
  633. {$EXTERNALSYM DIRQ_ADD}
  634.   DIRQ_DELETE                 = 10;
  635. {$EXTERNALSYM DIRQ_DELETE}
  636.   DIRQ_FLUSH                  = 11;
  637. {$EXTERNALSYM DIRQ_FLUSH}
  638.   DIRQ_RCCHANGE               = 12;
  639. {$EXTERNALSYM DIRQ_RCCHANGE}
  640.   DIRQ_SYMBOLGRAPH            = 13;
  641. {$EXTERNALSYM DIRQ_SYMBOLGRAPH}
  642.   DIRQ_INIT                   = 14;
  643. {$EXTERNALSYM DIRQ_INIT}
  644.   DIRQ_CLEANUP                = 15;
  645. {$EXTERNALSYM DIRQ_CLEANUP}
  646.   DIRQ_COPYRIGHT              = 16;
  647. {$EXTERNALSYM DIRQ_COPYRIGHT}
  648.   DIRQ_USER                   = 4096;
  649. {$EXTERNALSYM DIRQ_USER}
  650.  
  651. { Pen driver: }
  652.  
  653.   BITPENUP                    = $8000;
  654. {$EXTERNALSYM BITPENUP}
  655.  
  656. { Pen Driver messages: }
  657.   DRV_SetPenDriverEntryPoints         = DRV_RESERVED+1;
  658. {$EXTERNALSYM DRV_SetPenDriverEntryPoints}
  659.   DRV_SetEntryPoints                  = DRV_RESERVED+1; { alias }
  660. {$EXTERNALSYM DRV_SetEntryPoints}
  661.   DRV_RemovePenDriverEntryPoints      = DRV_RESERVED+2;
  662. {$EXTERNALSYM DRV_RemovePenDriverEntryPoints}
  663.   DRV_RemoveEntryPoints               = DRV_RESERVED+2; { alias }
  664. {$EXTERNALSYM DRV_RemoveEntryPoints}
  665.   DRV_SetPenSamplingRate              = DRV_RESERVED+3;
  666. {$EXTERNALSYM DRV_SetPenSamplingRate}
  667.   DRV_SetPenSamplingDist              = DRV_RESERVED+4;
  668. {$EXTERNALSYM DRV_SetPenSamplingDist}
  669.   DRV_GetName                         = DRV_RESERVED+5;
  670. {$EXTERNALSYM DRV_GetName}
  671.   DRV_GetVersion                      = DRV_RESERVED+6;
  672. {$EXTERNALSYM DRV_GetVersion}
  673.   DRV_GetPenInfo                      = DRV_RESERVED+7;
  674. {$EXTERNALSYM DRV_GetPenInfo}
  675.   DRV_PenPlayStart                    = DRV_RESERVED+8;
  676. {$EXTERNALSYM DRV_PenPlayStart}
  677.   DRV_PenPlayBack                     = DRV_RESERVED+9;
  678. {$EXTERNALSYM DRV_PenPlayBack}
  679.   DRV_PenPlayStop                     = DRV_RESERVED+10;
  680. {$EXTERNALSYM DRV_PenPlayStop}
  681.   DRV_GetCalibration                  = DRV_RESERVED+11;
  682. {$EXTERNALSYM DRV_GetCalibration}
  683.   DRV_SetCalibration                  = DRV_RESERVED+12;
  684. {$EXTERNALSYM DRV_SetCalibration}
  685.   DRV_Reserved1                       = DRV_RESERVED+13;
  686. {$EXTERNALSYM DRV_Reserved1}
  687.   DRV_Reserved2                       = DRV_RESERVED+14;
  688. {$EXTERNALSYM DRV_Reserved2}
  689.   DRV_Query                           = DRV_RESERVED+15;
  690. {$EXTERNALSYM DRV_Query}
  691.   DRV_GetPenSamplingRate              = DRV_RESERVED+16;
  692. {$EXTERNALSYM DRV_GetPenSamplingRate}
  693.   DRV_Calibrate                       = DRV_RESERVED+17;
  694. {$EXTERNALSYM DRV_Calibrate}
  695.  
  696. { Pen Driver Playback constants: }
  697.   PLAY_VERSION_10_DATA     = 0;
  698. {$EXTERNALSYM PLAY_VERSION_10_DATA}
  699.   PLAY_VERSION_20_DATA     = 1;
  700. {$EXTERNALSYM PLAY_VERSION_20_DATA}
  701.  
  702. { Pen Driver return values: }
  703.   DRV_FAILURE                 = $00000000;
  704. {$EXTERNALSYM DRV_FAILURE}
  705.   DRV_SUCCESS                 = $00000001;
  706. {$EXTERNALSYM DRV_SUCCESS}
  707.   DRV_BADPARAM1               = $FFFFFFFF;
  708. {$EXTERNALSYM DRV_BADPARAM1}
  709.   DRV_BADPARAM2               = $FFFFFFFE;
  710. {$EXTERNALSYM DRV_BADPARAM2}
  711.   DRV_BADSTRUCT               = $FFFFFFFD;
  712. {$EXTERNALSYM DRV_BADSTRUCT}
  713.  
  714. { Pen Driver register messages flags: }
  715.   PENREG_DEFAULT              = $00000002;
  716. {$EXTERNALSYM PENREG_DEFAULT}
  717.   PENREG_WILLHANDLEMOUSE      = $00000001;
  718. {$EXTERNALSYM PENREG_WILLHANDLEMOUSE}
  719.  
  720.   MAXOEMDATAWORDS             = 6;            { rgwOemData[MAXOEMDATAWORDS] }
  721. {$EXTERNALSYM MAXOEMDATAWORDS}
  722.  
  723.   RC_LDEFAULTFLAGS            = $80000000;
  724. {$EXTERNALSYM RC_LDEFAULTFLAGS}
  725.  
  726. { Pen Collection Mode termination conditions: }
  727. { (note update doc for PCMINFO struct if change these) }
  728.   PCM_PENUP                   = $00000001;    { stop on penup }
  729. {$EXTERNALSYM PCM_PENUP}
  730.   PCM_RANGE                   = $00000002;    { stop on leaving range }
  731. {$EXTERNALSYM PCM_RANGE}
  732.   PCM_INVERT                  = $00000020;    { stop on tap of opposite end }
  733. {$EXTERNALSYM PCM_INVERT}
  734.   PCM_RECTEXCLUDE             = $00002000;    { click in exclude rect }
  735. {$EXTERNALSYM PCM_RECTEXCLUDE}
  736.   PCM_RECTBOUND               = $00004000;    { click outside bounds rect }
  737. {$EXTERNALSYM PCM_RECTBOUND}
  738.   PCM_TIMEOUT                 = $00008000;    { no activity for timeout ms }
  739. {$EXTERNALSYM PCM_TIMEOUT}
  740. { new for 2.0: }
  741.   PCM_RGNBOUND                = $00010000;    { click outside bounding region }
  742. {$EXTERNALSYM PCM_RGNBOUND}
  743.   PCM_RGNEXCLUDE              = $00020000;    { click in exclude region }
  744. {$EXTERNALSYM PCM_RGNEXCLUDE}
  745.   PCM_DOPOLLING               = $00040000;    { polling mode }
  746. {$EXTERNALSYM PCM_DOPOLLING}
  747.   PCM_TAPNHOLD                = $00080000;    { check for Tap And Hold }
  748. {$EXTERNALSYM PCM_TAPNHOLD}
  749.   PCM_ADDDEFAULTS             = RC_LDEFAULTFLAGS; { $80000000 }
  750. {$EXTERNALSYM PCM_ADDDEFAULTS}
  751.  
  752. { Pen Device Capabilities: }
  753.   PDC_INTEGRATED              = $00000001;    { display=digitizer }
  754. {$EXTERNALSYM PDC_INTEGRATED}
  755.   PDC_PROXIMITY               = $00000002;    { detect non-contacting pen }
  756. {$EXTERNALSYM PDC_PROXIMITY}
  757.   PDC_RANGE                   = $00000004;    { event on out-of-range }
  758. {$EXTERNALSYM PDC_RANGE}
  759.   PDC_INVERT                  = $00000008;    { pen opposite end detect }
  760. {$EXTERNALSYM PDC_INVERT}
  761.   PDC_RELATIVE                = $00000010;    { pen driver coords }
  762. {$EXTERNALSYM PDC_RELATIVE}
  763.   PDC_BARREL1                 = $00000020;    { barrel button 1 present }
  764. {$EXTERNALSYM PDC_BARREL1}
  765.   PDC_BARREL2                 = $00000040;    { ditto 2 }
  766. {$EXTERNALSYM PDC_BARREL2}
  767.   PDC_BARREL3                 = $00000080;    { ditto 3 }
  768. {$EXTERNALSYM PDC_BARREL3}
  769.  
  770. { Pen Driver Kit states: }
  771.   PDK_NULL                    = $0000;  { default to no flags set }
  772. {$EXTERNALSYM PDK_NULL}
  773.   PDK_UP                      = $0000;  { PDK_NULL alias }
  774. {$EXTERNALSYM PDK_UP}
  775.   PDK_DOWN                    = $0001;  { pentip switch ON due to contact }
  776. {$EXTERNALSYM PDK_DOWN}
  777.   PDK_BARREL1                 = $0002;  { barrel1 switch depressed }
  778. {$EXTERNALSYM PDK_BARREL1}
  779.   PDK_BARREL2                 = $0004;  { ditto 2 }
  780. {$EXTERNALSYM PDK_BARREL2}
  781.   PDK_BARREL3                 = $0008;  { ditto 3 }
  782. {$EXTERNALSYM PDK_BARREL3}
  783.   PDK_SWITCHES                = $000F;  { sum of down + barrels 1,2,3 }
  784. {$EXTERNALSYM PDK_SWITCHES}
  785.   PDK_UNUSED10                = $0020;
  786. {$EXTERNALSYM PDK_UNUSED10}
  787.   PDK_UNUSED20                = $0040;
  788. {$EXTERNALSYM PDK_UNUSED20}
  789.   PDK_INVERTED                = $0080;  { other end of pen used as tip }
  790. {$EXTERNALSYM PDK_INVERTED}
  791.   PDK_PENIDMASK               = $0F00;  { bits 8..11 physical pen id (0..15) }
  792. {$EXTERNALSYM PDK_PENIDMASK}
  793.   PDK_UNUSED1000              = $1000;
  794. {$EXTERNALSYM PDK_UNUSED1000}
  795.   PDK_INKSTOPPED              = $2000;  { Inking stopped }
  796. {$EXTERNALSYM PDK_INKSTOPPED}
  797.   PDK_OUTOFRANGE              = $4000;  { pen left range (OEM data invalid) }
  798. {$EXTERNALSYM PDK_OUTOFRANGE}
  799.   PDK_DRIVER                  = $8000;  { pen (not mouse) event }
  800. {$EXTERNALSYM PDK_DRIVER}
  801.   PDK_TIPMASK                 = $0001;  { mask for testing PDK_DOWN }
  802. {$EXTERNALSYM PDK_TIPMASK}
  803.  
  804. { OEM-specific values for Pen Driver: }
  805.   PDT_NULL                    = 0;
  806. {$EXTERNALSYM PDT_NULL}
  807.   PDT_PRESSURE                = 1;      { pressure supported }
  808. {$EXTERNALSYM PDT_PRESSURE}
  809.   PDT_HEIGHT                  = 2;      { height above tablet }
  810. {$EXTERNALSYM PDT_HEIGHT}
  811.   PDT_ANGLEXY                 = 3;      { xy (horiz) angle supported }
  812. {$EXTERNALSYM PDT_ANGLEXY}
  813.   PDT_ANGLEZ                  = 4;      { z (vert) angle supported }
  814. {$EXTERNALSYM PDT_ANGLEZ}
  815.   PDT_BARRELROTATION          = 5;      { barrel is rotated }
  816. {$EXTERNALSYM PDT_BARRELROTATION}
  817.   PDT_OEMSPECIFIC             = 16;     { max }
  818. {$EXTERNALSYM PDT_OEMSPECIFIC}
  819.  
  820. { Denotes the ID of the current packet }
  821.   PID_CURRENT                 = -1;
  822. {$EXTERNALSYM PID_CURRENT}
  823.  
  824. { Handwriting Recognizer: }
  825.  
  826. { GetResultsHRC options: }
  827.   GRH_ALL                     = 0;      { get all results }
  828. {$EXTERNALSYM GRH_ALL}
  829.   GRH_GESTURE                 = 1;      { get only gesture results }
  830. {$EXTERNALSYM GRH_GESTURE}
  831.   GRH_NONGESTURE              = 2;      { get all but gesture results }
  832. {$EXTERNALSYM GRH_NONGESTURE}
  833.  
  834. { Gesture sets for EnableGestureSetHRC (bit flags): }
  835.   GST_SEL                     = $00000001;    { sel & lasso }
  836. {$EXTERNALSYM GST_SEL}
  837.   GST_CLIP                    = $00000002;    { cut copy paste }
  838. {$EXTERNALSYM GST_CLIP}
  839.   GST_WHITE                   = $00000004;    { sp tab ret }
  840. {$EXTERNALSYM GST_WHITE}
  841.   GST_KKCONVERT               = $00000008;    { kkconvert }
  842. {$EXTERNALSYM GST_KKCONVERT}
  843.   GST_EDIT                    = $00000010;    { insert correct undo clear }
  844. {$EXTERNALSYM GST_EDIT}
  845.   GST_SYS                     = $00000017;    { all of the above }
  846. {$EXTERNALSYM GST_SYS}
  847.   GST_CIRCLELO                = $00000100;    { lowercase circle }
  848. {$EXTERNALSYM GST_CIRCLELO}
  849.   GST_CIRCLEUP                = $00000200;    { uppercase circle }
  850. {$EXTERNALSYM GST_CIRCLEUP}
  851.   GST_CIRCLE                  = $00000300;    { all circle }
  852. {$EXTERNALSYM GST_CIRCLE}
  853.   GST_ALL                     = $00000317;    { all of the above }
  854. {$EXTERNALSYM GST_ALL}
  855.  
  856. { General HRC API return values (HRCR_xx): }
  857.   HRCR_NORESULTS              = 4;      { No possible results  to be found }
  858. {$EXTERNALSYM HRCR_NORESULTS}
  859.   HRCR_COMPLETE               = 3;      { finished recognition }
  860. {$EXTERNALSYM HRCR_COMPLETE}
  861.   HRCR_GESTURE                = 2;      { recognized gesture }
  862. {$EXTERNALSYM HRCR_GESTURE}
  863.   HRCR_OK                     = 1;      { success }
  864. {$EXTERNALSYM HRCR_OK}
  865.   HRCR_INCOMPLETE             = 0;      { recognizer is processing input }
  866. {$EXTERNALSYM HRCR_INCOMPLETE}
  867.   HRCR_ERROR                  = -1;     { invalid param or unspecified error }
  868. {$EXTERNALSYM HRCR_ERROR}
  869.   HRCR_MEMERR                 = -2;     { memory error }
  870. {$EXTERNALSYM HRCR_MEMERR}
  871.   HRCR_INVALIDGUIDE           = -3;     { invalid GUIDE struct }
  872. {$EXTERNALSYM HRCR_INVALIDGUIDE}
  873.   HRCR_INVALIDPNDT            = -4;     { invalid pendata }
  874. {$EXTERNALSYM HRCR_INVALIDPNDT}
  875.   HRCR_UNSUPPORTED            = -5;     { recognizer does not support feature }
  876. {$EXTERNALSYM HRCR_UNSUPPORTED}
  877.   HRCR_CONFLICT               = -6;     { training conflict }
  878. {$EXTERNALSYM HRCR_CONFLICT}
  879.   HRCR_HOOKED                 = -8;     { hookasaurus ate the result }
  880. {$EXTERNALSYM HRCR_HOOKED}
  881.  
  882. { system wordlist for AddWordsHWL: }
  883.   HWL_SYSTEM                  = (1);       { magic value means system wordlist }
  884. {$EXTERNALSYM HWL_SYSTEM}
  885.  
  886. { inkset returns: }
  887.   ISR_ERROR                   = -1;     { Memory or other error }
  888. {$EXTERNALSYM ISR_ERROR}
  889.   ISR_BADINKSET               = -2;     { bad source inkset }
  890. {$EXTERNALSYM ISR_BADINKSET}
  891.   ISR_BADINDEX                = -3;     { bad inkset index }
  892. {$EXTERNALSYM ISR_BADINDEX}
  893.   MAXHOTSPOT                  = 8;      { max number of hotspots possible }
  894. {$EXTERNALSYM MAXHOTSPOT}
  895.  
  896. { ProcessHRC time constants: }
  897.   PH_MAX                      = $FFFFFFFF;    { recognize rest of ink }
  898. {$EXTERNALSYM PH_MAX}
  899.   PH_DEFAULT                  = $FFFFFFFE;    { reasonable time }
  900. {$EXTERNALSYM PH_DEFAULT}
  901.   PH_MIN                      = $FFFFFFFD;    { minimum time }
  902. {$EXTERNALSYM PH_MIN}
  903.  
  904. { ResultsHookHRC options: }
  905.   RHH_STD                     = 0;      { GetResultsHRC }
  906. {$EXTERNALSYM RHH_STD}
  907.   RHH_BOX                     = 1;      { GetBoxResultsHRC }
  908. {$EXTERNALSYM RHH_BOX}
  909.  
  910. { SetWordlistCoercionHRC options: }
  911.   SCH_NONE                    = 0;      { turn off coercion }
  912. {$EXTERNALSYM SCH_NONE}
  913.   SCH_ADVISE                  = 1;      { macro is hint only }
  914. {$EXTERNALSYM SCH_ADVISE}
  915.   SCH_FORCE                   = 2;      { some result is forced from macro }
  916. {$EXTERNALSYM SCH_FORCE}
  917.  
  918. { Symbol Context Insert Modes }
  919.   SCIM_INSERT                 = 0;      { insert }
  920. {$EXTERNALSYM SCIM_INSERT}
  921.   SCIM_OVERWRITE              = 1;      { overwrite }
  922. {$EXTERNALSYM SCIM_OVERWRITE}
  923.  
  924. { SetResultsHookHREC options: }
  925.   SRH_HOOKALL                 = 1;      { hook all recognizers }
  926. {$EXTERNALSYM SRH_HOOKALL}
  927.  
  928. { SetInternationalHRC options: }
  929.   SSH_RD                      = 1;      { to right and down (English) }
  930. {$EXTERNALSYM SSH_RD}
  931.   SSH_RU                      = 2;      { to right and up }
  932. {$EXTERNALSYM SSH_RU}
  933.   SSH_LD                      = 3;      { to left and down (Hebrew) }
  934. {$EXTERNALSYM SSH_LD}
  935.   SSH_LU                      = 4;      { to left and up }
  936. {$EXTERNALSYM SSH_LU}
  937.   SSH_DL                      = 5;      { down and to the left (Chinese) }
  938. {$EXTERNALSYM SSH_DL}
  939.   SSH_DR                      = 6;      { down and to the right (Chinese) }
  940. {$EXTERNALSYM SSH_DR}
  941.   SSH_UL                      = 7;      { up and to the left }
  942. {$EXTERNALSYM SSH_UL}
  943.   SSH_UR                      = 8;      { up and to the right }
  944. {$EXTERNALSYM SSH_UR}
  945.  
  946.   SIH_ALLANSICHAR             = 1;      { use all ANSI }
  947. {$EXTERNALSYM SIH_ALLANSICHAR}
  948.  
  949. { TrainHREC options: }
  950.   TH_QUERY                    = 0;      { query the user if conflict }
  951. {$EXTERNALSYM TH_QUERY}
  952.   TH_FORCE                    = 1;      { ditto no query }
  953. {$EXTERNALSYM TH_FORCE}
  954.   TH_SUGGEST                  = 2;      { abandon training if conflict }
  955. {$EXTERNALSYM TH_SUGGEST}
  956.  
  957. { Return values for WCR_TRAIN Function }
  958.   TRAIN_NONE                  = $0000;
  959. {$EXTERNALSYM TRAIN_NONE}
  960.   TRAIN_DEFAULT               = $0001;
  961. {$EXTERNALSYM TRAIN_DEFAULT}
  962.   TRAIN_CUSTOM                = $0002;
  963. {$EXTERNALSYM TRAIN_CUSTOM}
  964.   TRAIN_BOTH                  = TRAIN_DEFAULT or TRAIN_CUSTOM;
  965. {$EXTERNALSYM TRAIN_BOTH}
  966.  
  967. { Control values for TRAINSAVE }
  968.   TRAIN_SAVE                  = 0;      { save changes that have been made }
  969. {$EXTERNALSYM TRAIN_SAVE}
  970.   TRAIN_REVERT                = 1;      { discard changes that have been made }
  971. {$EXTERNALSYM TRAIN_REVERT}
  972.   TRAIN_RESET                 = 2;      { use factory settings }
  973. {$EXTERNALSYM TRAIN_RESET}
  974.  
  975. { ConfigRecognizer and ConfigHREC options: }
  976.   WCR_RECOGNAME               = 0;      { ConfigRecognizer 1.0 }
  977. {$EXTERNALSYM WCR_RECOGNAME}
  978.   WCR_QUERY                   = 1;
  979. {$EXTERNALSYM WCR_QUERY}
  980.   WCR_CONFIGDIALOG            = 2;
  981. {$EXTERNALSYM WCR_CONFIGDIALOG}
  982.   WCR_DEFAULT                 = 3;
  983. {$EXTERNALSYM WCR_DEFAULT}
  984.   WCR_RCCHANGE                = 4;
  985. {$EXTERNALSYM WCR_RCCHANGE}
  986.   WCR_VERSION                 = 5;
  987. {$EXTERNALSYM WCR_VERSION}
  988.   WCR_TRAIN                   = 6;
  989. {$EXTERNALSYM WCR_TRAIN}
  990.   WCR_TRAINSAVE               = 7;
  991. {$EXTERNALSYM WCR_TRAINSAVE}
  992.   WCR_TRAINMAX                = 8;
  993. {$EXTERNALSYM WCR_TRAINMAX}
  994.   WCR_TRAINDIRTY              = 9;
  995. {$EXTERNALSYM WCR_TRAINDIRTY}
  996.   WCR_TRAINCUSTOM             = 10;
  997. {$EXTERNALSYM WCR_TRAINCUSTOM}
  998.   WCR_QUERYLANGUAGE           = 11;
  999. {$EXTERNALSYM WCR_QUERYLANGUAGE}
  1000.   WCR_USERCHANGE              = 12;
  1001. {$EXTERNALSYM WCR_USERCHANGE}
  1002.  
  1003. { ConfigHREC options: }
  1004.   WCR_PWVERSION               = 13;     { ver of PenWin recognizer supports }
  1005. {$EXTERNALSYM WCR_PWVERSION}
  1006.   WCR_GETALCPRIORITY          = 14;     { get recognizer's ALC priority }
  1007. {$EXTERNALSYM WCR_GETALCPRIORITY}
  1008.   WCR_SETALCPRIORITY          = 15;     { set recognizer's ALC priority }
  1009. {$EXTERNALSYM WCR_SETALCPRIORITY}
  1010.   WCR_GETANSISTATE            = 16;     { get ALLANSICHAR state }
  1011. {$EXTERNALSYM WCR_GETANSISTATE}
  1012.   WCR_SETANSISTATE            = 17;     { set ALLANSICHAR if T }
  1013. {$EXTERNALSYM WCR_SETANSISTATE}
  1014.   WCR_GETHAND                 = 18;     { get writing hand }
  1015. {$EXTERNALSYM WCR_GETHAND}
  1016.   WCR_SETHAND                 = 19;     { set writing hand }
  1017. {$EXTERNALSYM WCR_SETHAND}
  1018.   WCR_GETDIRECTION            = 20;     { get writing direction }
  1019. {$EXTERNALSYM WCR_GETDIRECTION}
  1020.   WCR_SETDIRECTION            = 21;     { set writing direction }
  1021. {$EXTERNALSYM WCR_SETDIRECTION}
  1022.   WCR_INITRECOGNIZER          = 22;     { init recognizer and set user name }
  1023. {$EXTERNALSYM WCR_INITRECOGNIZER}
  1024.   WCR_CLOSERECOGNIZER         = 23;     { close recognizer }
  1025. {$EXTERNALSYM WCR_CLOSERECOGNIZER}
  1026.   WCR_PRIVATE                 = 1024;
  1027. {$EXTERNALSYM WCR_PRIVATE}
  1028.  
  1029. { sub-functions of WCR_USERCHANGE }
  1030.   CRUC_NOTIFY                 = 0;      { user name change }
  1031. {$EXTERNALSYM CRUC_NOTIFY}
  1032.   CRUC_REMOVE                 = 1;      { user name deleted }
  1033. {$EXTERNALSYM CRUC_REMOVE}
  1034.  
  1035. { Word List Types: }
  1036.   WLT_STRING                  = 0;      { one string }
  1037. {$EXTERNALSYM WLT_STRING}
  1038.   WLT_STRINGTABLE             = 1;      { array of strings }
  1039. {$EXTERNALSYM WLT_STRINGTABLE}
  1040.   WLT_EMPTY                   = 2;      { empty wordlist }
  1041. {$EXTERNALSYM WLT_EMPTY}
  1042.   WLT_WORDLIST                = 3;      { handle to a wordlist }
  1043. {$EXTERNALSYM WLT_WORDLIST}
  1044.  
  1045.  
  1046. { IEdit Background Options }
  1047.  
  1048.   IEB_DEFAULT                 = 0;      { default (use COLOR_WINDOW) }
  1049. {$EXTERNALSYM IEB_DEFAULT}
  1050.   IEB_BRUSH                   = 1;      { paint background with brush }
  1051. {$EXTERNALSYM IEB_BRUSH}
  1052.   IEB_BIT_UL                  = 2;      { bitmap, upper-left aligned }
  1053. {$EXTERNALSYM IEB_BIT_UL}
  1054.   IEB_BIT_CENTER              = 3;      { bitmap, centered in control }
  1055. {$EXTERNALSYM IEB_BIT_CENTER}
  1056.   IEB_BIT_TILE                = 4;      { bitmap, tiled repeatedly in ctl }
  1057. {$EXTERNALSYM IEB_BIT_TILE}
  1058.   IEB_BIT_STRETCH             = 5;      { bitmap, stretched to fit ctl }
  1059. {$EXTERNALSYM IEB_BIT_STRETCH}
  1060.   IEB_OWNERDRAW               = 6;      { parent window will draw background }
  1061. {$EXTERNALSYM IEB_OWNERDRAW}
  1062.  
  1063. { IEdit Drawing Options }
  1064.   IEDO_NONE                   = $0000;  { no drawing }
  1065. {$EXTERNALSYM IEDO_NONE}
  1066.   IEDO_FAST                   = $0001;  { ink drawn as fast as possible (def) }
  1067. {$EXTERNALSYM IEDO_FAST}
  1068.   IEDO_SAVEUPSTROKES          = $0002;  { save upstrokes }
  1069. {$EXTERNALSYM IEDO_SAVEUPSTROKES}
  1070.   IEDO_RESERVED               = $FFFC;  { reserved bits }
  1071. {$EXTERNALSYM IEDO_RESERVED}
  1072.  
  1073. { IEdit Input Options }
  1074.   IEI_MOVE                    = $0001;  { move ink into ctl }
  1075. {$EXTERNALSYM IEI_MOVE}
  1076.   IEI_RESIZE                  = $0002;  { resize ink to fit within ctl }
  1077. {$EXTERNALSYM IEI_RESIZE}
  1078.   IEI_CROP                    = $0004;  { discard ink outside of ctl }
  1079. {$EXTERNALSYM IEI_CROP}
  1080.   IEI_DISCARD                 = $0008;  { discard all ink if any outside ctl }
  1081. {$EXTERNALSYM IEI_DISCARD}
  1082.   IEI_RESERVED                = $FFF0;  { reserved }
  1083. {$EXTERNALSYM IEI_RESERVED}
  1084.  
  1085. { IEdit IE_GETINK options }
  1086.   IEGI_ALL                    = $0000;  { get all ink from control }
  1087. {$EXTERNALSYM IEGI_ALL}
  1088.   IEGI_SELECTION              = $0001;  { get selected ink from control }
  1089. {$EXTERNALSYM IEGI_SELECTION}
  1090.  
  1091. { IEdit IE_SETMODE/IE_GETMODE (mode) options }
  1092.   IEMODE_READY                = 0;      { default inking, moving, sizing mode }
  1093. {$EXTERNALSYM IEMODE_READY}
  1094.   IEMODE_ERASE                = 1;      { erasing Mode }
  1095. {$EXTERNALSYM IEMODE_ERASE}
  1096.   IEMODE_LASSO                = 2;      { lasso selection mode }
  1097. {$EXTERNALSYM IEMODE_LASSO}
  1098.  
  1099. { IEdit    Notification Bits }
  1100.   IEN_NULL                    = $0000;  { null notification }
  1101. {$EXTERNALSYM IEN_NULL}
  1102.   IEN_PDEVENT                 = $0001;  { notify about pointing device events }
  1103. {$EXTERNALSYM IEN_PDEVENT}
  1104.   IEN_PAINT                   = $0002;  { send painting-related notifications }
  1105. {$EXTERNALSYM IEN_PAINT}
  1106.   IEN_FOCUS                   = $0004;  { send focus-related notifications }
  1107. {$EXTERNALSYM IEN_FOCUS}
  1108.   IEN_SCROLL                  = $0008;  { send scrolling notifications }
  1109. {$EXTERNALSYM IEN_SCROLL}
  1110.   IEN_EDIT                    = $0010;  { send editing/change notifications }
  1111. {$EXTERNALSYM IEN_EDIT}
  1112.   IEN_PROPERTIES              = $0020;  { send properties dialog notification }
  1113. {$EXTERNALSYM IEN_PROPERTIES}
  1114.   IEN_RESERVED                = $FF80;  { reserved }
  1115. {$EXTERNALSYM IEN_RESERVED}
  1116.  
  1117. { IEdit Return Values }
  1118.   IER_OK                      = 0;      { success }
  1119. {$EXTERNALSYM IER_OK}
  1120.   IER_NO                      = 0;      { ctl cannot do request }
  1121. {$EXTERNALSYM IER_NO}
  1122.   IER_YES                     = 1;      { ctl can do request }
  1123. {$EXTERNALSYM IER_YES}
  1124.   IER_ERROR                   = -1;     { unspecified error; operation failed }
  1125. {$EXTERNALSYM IER_ERROR}
  1126.   IER_PARAMERR                = -2;     { bogus lParam value, bad handle, etc }
  1127. {$EXTERNALSYM IER_PARAMERR}
  1128.   IER_OWNERDRAW               = -3;     { can't set drawopts in ownerdraw ctl }
  1129. {$EXTERNALSYM IER_OWNERDRAW}
  1130.   IER_SECURITY                = -4;     { security protection disallows action }
  1131. {$EXTERNALSYM IER_SECURITY}
  1132.   IER_SELECTION               = -5;     { nothing selected in control }
  1133. {$EXTERNALSYM IER_SELECTION}
  1134.   IER_SCALE                   = -6;     { merge:  incompatible scaling factors }
  1135. {$EXTERNALSYM IER_SCALE}
  1136.   IER_MEMERR                  = -7;     { memory error }
  1137. {$EXTERNALSYM IER_MEMERR}
  1138.   IER_NOCOMMAND               = -8;     { tried IE_GETCOMMAND w/no command }
  1139. {$EXTERNALSYM IER_NOCOMMAND}
  1140.   IER_NOGESTURE               = -9;     { tried IE_GETGESTURE w/no gesture }
  1141. {$EXTERNALSYM IER_NOGESTURE}
  1142.   IER_NOPDEVENT               = -10;    { tried IE_GETPDEVENT but no event }
  1143. {$EXTERNALSYM IER_NOPDEVENT}
  1144.   IER_NOTINPAINT              = -11;    { tried IE_GETPAINTSTRUCT but no paint }
  1145. {$EXTERNALSYM IER_NOTINPAINT}
  1146.   IER_PENDATA                 = -12;    { can't do request with NULL hpd in ctl }
  1147. {$EXTERNALSYM IER_PENDATA}
  1148.  
  1149. { IEdit Recognition Options }
  1150.   IEREC_NONE                  = $0000;  { No recognition }
  1151. {$EXTERNALSYM IEREC_NONE}
  1152.   IEREC_GESTURE               = $0001;  { Gesture recognition }
  1153. {$EXTERNALSYM IEREC_GESTURE}
  1154. {$DEFINE IEREC_ALL}
  1155.   IEREC_RESERVED              = $FFFE;  { Reserved }
  1156. {$EXTERNALSYM IEREC_RESERVED}
  1157.  
  1158. { IEdit Security Options }
  1159.   IESEC_NOCOPY                = $0001;  { copying disallowed }
  1160. {$EXTERNALSYM IESEC_NOCOPY}
  1161.   IESEC_NOCUT                 = $0002;  { cutting disallowed }
  1162. {$EXTERNALSYM IESEC_NOCUT}
  1163.   IESEC_NOPASTE               = $0004;  { pasting disallowed }
  1164. {$EXTERNALSYM IESEC_NOPASTE}
  1165.   IESEC_NOUNDO                = $0008;  { undoing disallowed }
  1166. {$EXTERNALSYM IESEC_NOUNDO}
  1167.   IESEC_NOINK                 = $0010;  { inking  disallowed }
  1168. {$EXTERNALSYM IESEC_NOINK}
  1169.   IESEC_NOERASE               = $0020;  { erasing disallowed }
  1170. {$EXTERNALSYM IESEC_NOERASE}
  1171.   IESEC_NOGET                 = $0040;  { IE_GETINK message verboten }
  1172. {$EXTERNALSYM IESEC_NOGET}
  1173.   IESEC_NOSET                 = $0080;  { IE_SETINK message verboten }
  1174. {$EXTERNALSYM IESEC_NOSET}
  1175.   IESEC_RESERVED              = $FF00;  { reserved }
  1176. {$EXTERNALSYM IESEC_RESERVED}
  1177.  
  1178. { IEdit IE_SETFORMAT/IE_GETFORMAT options }
  1179.   IESF_ALL                    = $0001;  { set/get stk fmt of all ink }
  1180. {$EXTERNALSYM IESF_ALL}
  1181.   IESF_SELECTION              = $0002;  { set/get stk fmt of selected ink }
  1182. {$EXTERNALSYM IESF_SELECTION}
  1183.   IESF_STROKE                 = $0004;  { set/get stk fmt of specified stroke }
  1184. {$EXTERNALSYM IESF_STROKE}
  1185.  
  1186.   IESF_TIPCOLOR               = $0008;  { set color }
  1187. {$EXTERNALSYM IESF_TIPCOLOR}
  1188.   IESF_TIPWIDTH               = $0010;  { set width }
  1189. {$EXTERNALSYM IESF_TIPWIDTH}
  1190.   IESF_PENTIP                 = IESF_TIPCOLOR or IESF_TIPWIDTH;
  1191. {$EXTERNALSYM IESF_PENTIP}
  1192.  
  1193.  
  1194. { IEdit IE_SETINK options }
  1195.   IESI_REPLACE                = $0000;  { replace ink in control }
  1196. {$EXTERNALSYM IESI_REPLACE}
  1197.   IESI_APPEND                 = $0001;  { append ink to existing control ink }
  1198. {$EXTERNALSYM IESI_APPEND}
  1199.  
  1200. { Ink Edit Control (IEdit) definitions }
  1201. { IEdit Notifications }
  1202.   IN_PDEVENT          = (IEN_PDEVENT shl 8) or 0; { pointing device event occurred }
  1203. {$EXTERNALSYM IN_PDEVENT}
  1204.   IN_ERASEBKGND       = (IEN_NULL shl 8) or 1; { control needs bkgnd erased }
  1205. {$EXTERNALSYM IN_ERASEBKGND}
  1206.   IN_PREPAINT         = (IEN_PAINT shl 8) or 2; { before control paints its ink }
  1207. {$EXTERNALSYM IN_PREPAINT}
  1208.   IN_PAINT            = (IEN_NULL shl 8) or 3; { control needs to be painted }
  1209. {$EXTERNALSYM IN_PAINT}
  1210.   IN_POSTPAINT        = (IEN_PAINT shl 8) or 4; { after control has painted }
  1211. {$EXTERNALSYM IN_POSTPAINT}
  1212.   IN_MODECHANGED      = (IEN_EDIT shl 8) or 5; { mode changed }
  1213. {$EXTERNALSYM IN_MODECHANGED}
  1214.   IN_CHANGE           = (IEN_EDIT shl 8) or 6; { contents changed & painted }
  1215. {$EXTERNALSYM IN_CHANGE}
  1216.   IN_UPDATE           = (IEN_EDIT shl 8) or 7; { contents changed & !painted }
  1217. {$EXTERNALSYM IN_UPDATE}
  1218.   IN_SETFOCUS         = (IEN_FOCUS shl 8) or 8; { IEdit is getting focus }
  1219. {$EXTERNALSYM IN_SETFOCUS}
  1220.   IN_KILLFOCUS        = (IEN_FOCUS shl 8) or 9; { IEdit is losing focus }
  1221. {$EXTERNALSYM IN_KILLFOCUS}
  1222.   IN_MEMERR           = (IEN_NULL shl 8) or 10; { memory error }
  1223. {$EXTERNALSYM IN_MEMERR}
  1224.   IN_HSCROLL          = (IEN_SCROLL shl 8) or 11; { horz scrolled, not painted }
  1225. {$EXTERNALSYM IN_HSCROLL}
  1226.   IN_VSCROLL          = (IEN_SCROLL shl 8) or 12; { vert scrolled, not painted }
  1227. {$EXTERNALSYM IN_VSCROLL}
  1228.   IN_GESTURE          = (IEN_EDIT shl 8) or 13; { user has gestured on control }
  1229. {$EXTERNALSYM IN_GESTURE}
  1230.   IN_COMMAND          = (IEN_EDIT shl 8) or 14; { command selected from menu }
  1231. {$EXTERNALSYM IN_COMMAND}
  1232.   IN_CLOSE            = (IEN_NULL shl 8) or 15; { I-Edit is being closed }
  1233. {$EXTERNALSYM IN_CLOSE}
  1234.   IN_PROPERTIES       = (IEN_PROPERTIES shl 8) or 16; { properties dialog }
  1235. {$EXTERNALSYM IN_PROPERTIES}
  1236.  
  1237. { PenIn[k]put API constants }
  1238.  
  1239. { Default Processing }
  1240.   LRET_DONE                   = 1;
  1241. {$EXTERNALSYM LRET_DONE}
  1242.   LRET_ABORT                  = -1;
  1243. {$EXTERNALSYM LRET_ABORT}
  1244.   LRET_HRC                    = -2;
  1245. {$EXTERNALSYM LRET_HRC}
  1246.   LRET_HPENDATA               = -3;
  1247. {$EXTERNALSYM LRET_HPENDATA}
  1248.   LRET_PRIVATE                = -4;
  1249. {$EXTERNALSYM LRET_PRIVATE}
  1250.  
  1251. { Inkput: }
  1252.   PCMR_OK                     = 0;
  1253. {$EXTERNALSYM PCMR_OK}
  1254.   PCMR_ALREADYCOLLECTING      = -1;
  1255. {$EXTERNALSYM PCMR_ALREADYCOLLECTING}
  1256.   PCMR_INVALIDCOLLECTION      = -2;
  1257. {$EXTERNALSYM PCMR_INVALIDCOLLECTION}
  1258.   PCMR_EVENTLOCK              = -3;
  1259. {$EXTERNALSYM PCMR_EVENTLOCK}
  1260.   PCMR_INVALID_PACKETID       = -4;
  1261. {$EXTERNALSYM PCMR_INVALID_PACKETID}
  1262.   PCMR_TERMTIMEOUT            = -5;
  1263. {$EXTERNALSYM PCMR_TERMTIMEOUT}
  1264.   PCMR_TERMRANGE              = -6;
  1265. {$EXTERNALSYM PCMR_TERMRANGE}
  1266.   PCMR_TERMPENUP              = -7;
  1267. {$EXTERNALSYM PCMR_TERMPENUP}
  1268.   PCMR_TERMEX                 = -8;
  1269. {$EXTERNALSYM PCMR_TERMEX}
  1270.   PCMR_TERMBOUND              = -9;
  1271. {$EXTERNALSYM PCMR_TERMBOUND}
  1272.   PCMR_APPTERMINATED          = -10;
  1273. {$EXTERNALSYM PCMR_APPTERMINATED}
  1274.   PCMR_TAP                    = -11;    { alias PCMR_TAPNHOLD_LAST }
  1275. {$EXTERNALSYM PCMR_TAP}
  1276.   PCMR_SELECT                 = -12;    { ret because of tap & hold }
  1277. {$EXTERNALSYM PCMR_SELECT}
  1278.   PCMR_OVERFLOW               = -13;
  1279. {$EXTERNALSYM PCMR_OVERFLOW}
  1280.   PCMR_ERROR                  = -14;    { parameter or unspecified error }
  1281. {$EXTERNALSYM PCMR_ERROR}
  1282.   PCMR_DISPLAYERR             = -15;    { inking only }
  1283. {$EXTERNALSYM PCMR_DISPLAYERR}
  1284.   PCMR_TERMINVERT             = -16;    { termination due to tapping opposite end of pen }
  1285. {$EXTERNALSYM PCMR_TERMINVERT}
  1286.  
  1287.   PII_INKCLIPRECT             = $0001;
  1288. {$EXTERNALSYM PII_INKCLIPRECT}
  1289.   PII_INKSTOPRECT             = $0002;
  1290. {$EXTERNALSYM PII_INKSTOPRECT}
  1291.   PII_INKCLIPRGN              = $0004;
  1292. {$EXTERNALSYM PII_INKCLIPRGN}
  1293.   PII_INKSTOPRGN              = $0008;
  1294. {$EXTERNALSYM PII_INKSTOPRGN}
  1295.   PII_INKPENTIP               = $0010;
  1296. {$EXTERNALSYM PII_INKPENTIP}
  1297.   PII_SAVEBACKGROUND          = $0020;
  1298. {$EXTERNALSYM PII_SAVEBACKGROUND}
  1299.   PII_CLIPSTOP                = $0040;
  1300. {$EXTERNALSYM PII_CLIPSTOP}
  1301.  
  1302.   PIT_RGNBOUND                = $0001;
  1303. {$EXTERNALSYM PIT_RGNBOUND}
  1304.   PIT_RGNEXCLUDE              = $0002;
  1305. {$EXTERNALSYM PIT_RGNEXCLUDE}
  1306.   PIT_TIMEOUT                 = $0004;
  1307. {$EXTERNALSYM PIT_TIMEOUT}
  1308.   PIT_TAPNHOLD                = $0008;
  1309. {$EXTERNALSYM PIT_TAPNHOLD}
  1310.  
  1311.  
  1312. { Misc RC Definitions: }
  1313.  
  1314.   CL_NULL                     = 0;
  1315. {$EXTERNALSYM CL_NULL}
  1316.   CL_MINIMUM                  = 1;      { minimum confidence level }
  1317. {$EXTERNALSYM CL_MINIMUM}
  1318.   CL_MAXIMUM                  = 100;    { max (require perfect recog) }
  1319. {$EXTERNALSYM CL_MAXIMUM}
  1320.   cwRcReservedMax             = 8;      { rc.rgwReserved[cwRcReservedMax] }
  1321. {$EXTERNALSYM cwRcReservedMax}
  1322.   ENUM_MINIMUM                = 1;
  1323. {$EXTERNALSYM ENUM_MINIMUM}
  1324.   ENUM_MAXIMUM                = 4096;
  1325. {$EXTERNALSYM ENUM_MAXIMUM}
  1326.  
  1327.   HKP_SETHOOK                 = 0;      { SetRecogHook() }
  1328. {$EXTERNALSYM HKP_SETHOOK}
  1329.   HKP_UNHOOK                  = $FFFF;
  1330. {$EXTERNALSYM HKP_UNHOOK}
  1331.  
  1332.   HWR_RESULTS                 = 0;
  1333. {$EXTERNALSYM HWR_RESULTS}
  1334.   HWR_APPWIDE                 = 1;
  1335. {$EXTERNALSYM HWR_APPWIDE}
  1336.  
  1337.   iSycNull                    = -1;
  1338. {$EXTERNALSYM iSycNull}
  1339.   LPDFNULL                    = 0;      { nil }
  1340. {$EXTERNALSYM LPDFNULL}
  1341.   MAXDICTIONARIES             = 16;     { rc.rglpdf[MAXDICTIONARIES] }
  1342. {$EXTERNALSYM MAXDICTIONARIES}
  1343.   wPntAll                     = $FFFF;
  1344. {$EXTERNALSYM wPntAll}
  1345.   cbRcLanguageMax             = 44;     { rc.lpLanguage[cbRcLanguageMax] }
  1346. {$EXTERNALSYM cbRcLanguageMax}
  1347.   cbRcUserMax                 = 32;     { rc.lpUser[cbRcUserMax] }
  1348. {$EXTERNALSYM cbRcUserMax}
  1349.   cbRcrgbfAlcMax              = 32;     { rc.rgbfAlc[cbRcrgbfAlcMax] }
  1350. {$EXTERNALSYM cbRcrgbfAlcMax}
  1351.   RC_WDEFAULT                 = $FFFF;
  1352. {$EXTERNALSYM RC_WDEFAULT}
  1353.   RC_LDEFAULT                 = $FFFFFFFF;
  1354. {$EXTERNALSYM RC_LDEFAULT}
  1355.   RC_WDEFAULTFLAGS            = $8000;
  1356. {$EXTERNALSYM RC_WDEFAULTFLAGS}
  1357. //  RC_LDEFAULTFLAGS            = $80000000; defined above
  1358.  
  1359. { CorrectWriting() API constants: }
  1360. { LOWORD values: }
  1361.   CWR_REPLACECR               = $0001;  { replace carriage ret (\r) with space }
  1362. {$EXTERNALSYM CWR_REPLACECR}
  1363.   CWR_STRIPCR                 = CWR_REPLACECR; { alias for backward compatibility }
  1364. {$EXTERNALSYM CWR_STRIPCR}
  1365.   CWR_STRIPLF                 = $0002;  { strip linefeed (\n) }
  1366. {$EXTERNALSYM CWR_STRIPLF}
  1367.   CWR_REPLACETAB              = $0004;  { replace tab with space (\t) }
  1368. {$EXTERNALSYM CWR_REPLACETAB}
  1369.   CWR_STRIPTAB                = CWR_REPLACETAB; { alias for backward compatibility }
  1370. {$EXTERNALSYM CWR_STRIPTAB}
  1371.   CWR_SINGLELINEEDIT          = CWR_REPLACECR or CWR_STRIPLF or CWR_REPLACETAB; { all of the above }
  1372. {$EXTERNALSYM CWR_SINGLELINEEDIT}
  1373.   CWR_INSERT                  = $0008;  { use "Insert Text" instead of "Edit Text" in the title }
  1374. {$EXTERNALSYM CWR_INSERT}
  1375.   CWR_TITLE                   = $0010;  { interpret dwParam as title string }
  1376. {$EXTERNALSYM CWR_TITLE}
  1377.   CWR_KKCONVERT               = $0020;  { JPN initiate IME }
  1378. {$EXTERNALSYM CWR_KKCONVERT}
  1379.   CWR_SIMPLE                  = $0040;  { simple dialog (lens) }
  1380. {$EXTERNALSYM CWR_SIMPLE}
  1381.   CWR_HEDIT                   = $0080;  { HEDIT CorrectWriting }
  1382. {$EXTERNALSYM CWR_HEDIT}
  1383.   CWR_KEYBOARD                = $0100;  { keyboard lens }
  1384. {$EXTERNALSYM CWR_KEYBOARD}
  1385.   CWR_BOXES                   = $0200;  { bedit lens }
  1386. {$EXTERNALSYM CWR_BOXES}
  1387.  
  1388. { HIWORD values: keyboard types }
  1389.   CWRK_DEFAULT                = 0;      { default keyboard type }
  1390. {$EXTERNALSYM CWRK_DEFAULT}
  1391.   CWRK_BASIC                  = 1;      { basic keyboard }
  1392. {$EXTERNALSYM CWRK_BASIC}
  1393.   CWRK_FULL                   = 2;      { full keyboard }
  1394. {$EXTERNALSYM CWRK_FULL}
  1395.   CWRK_NUMPAD                 = 3;      { numeric keyboard }
  1396. {$EXTERNALSYM CWRK_NUMPAD}
  1397.   CWRK_TELPAD                 = 4;      { Telephone type keyboard }
  1398. {$EXTERNALSYM CWRK_TELPAD}
  1399.  
  1400.   GPMI_OK                     = 0;
  1401. {$EXTERNALSYM GPMI_OK}
  1402.   GPMI_INVALIDPMI             = $8000;
  1403. {$EXTERNALSYM GPMI_INVALIDPMI}
  1404.  
  1405. { inkwidth limits }
  1406.   INKWIDTH_MINIMUM            = 0;          { 0 invisible, 1..15 pixel widths }
  1407. {$EXTERNALSYM INKWIDTH_MINIMUM}
  1408.   INKWIDTH_MAXIMUM            = 15;         { max width in pixels }
  1409. {$EXTERNALSYM INKWIDTH_MAXIMUM}
  1410.  
  1411. { Get/SetPenMiscInfo: }
  1412. { PMI_RCCHANGE is for WM_GLOBALRCCHANGE compatability only: }
  1413.   PMI_RCCHANGE                = 0;      { invalid for Get/SetPenMiscInfo }
  1414. {$EXTERNALSYM PMI_RCCHANGE}
  1415.   PMI_BEDIT                   = 1;      { boxed edit info }
  1416. {$EXTERNALSYM PMI_BEDIT}
  1417.   PMI_IMECOLOR                = 2;      { input method editor color }
  1418. {$EXTERNALSYM PMI_IMECOLOR}
  1419.   PMI_CXTABLET                = 3;      { tablet width }
  1420. {$EXTERNALSYM PMI_CXTABLET}
  1421.   PMI_CYTABLET                = 4;      { tablet height }
  1422. {$EXTERNALSYM PMI_CYTABLET}
  1423.   PMI_PENTIP                  = 6;      { pen tip: color, width, nib }
  1424. {$EXTERNALSYM PMI_PENTIP}
  1425.   PMI_ENABLEFLAGS             = 7;      { PWE_xx enablements }
  1426. {$EXTERNALSYM PMI_ENABLEFLAGS}
  1427.   PMI_TIMEOUT                 = 8;      { handwriting timeout }
  1428. {$EXTERNALSYM PMI_TIMEOUT}
  1429.   PMI_TIMEOUTGEST             = 9;      { gesture timeout }
  1430. {$EXTERNALSYM PMI_TIMEOUTGEST}
  1431.   PMI_TIMEOUTSEL              = 10;     { select (press&hold) timeout }
  1432. {$EXTERNALSYM PMI_TIMEOUTSEL}
  1433.   PMI_SYSFLAGS                = 11;     { component load configuration }
  1434. {$EXTERNALSYM PMI_SYSFLAGS}
  1435.   PMI_INDEXFROMRGB            = 12;     { color table index from RGB }
  1436. {$EXTERNALSYM PMI_INDEXFROMRGB}
  1437.   PMI_RGBFROMINDEX            = 13;     { RGB from color table index }
  1438. {$EXTERNALSYM PMI_RGBFROMINDEX}
  1439.   PMI_SYSREC                  = 14;     { handle to system recognizer }
  1440. {$EXTERNALSYM PMI_SYSREC}
  1441.   PMI_TICKREF                 = 15;     { reference absolute time }
  1442. {$EXTERNALSYM PMI_TICKREF}
  1443.   PMI_SAVE                    = $1000;  { save setting to file }
  1444. {$EXTERNALSYM PMI_SAVE}
  1445.  
  1446. { Set/GetPenMiscInfo/PMI_ENABLEFLAGS flags: }
  1447.   PWE_AUTOWRITE               = $0001;  { pen functionality where IBeam }
  1448. {$EXTERNALSYM PWE_AUTOWRITE}
  1449.   PWE_ACTIONHANDLES           = $0002;  { action handles in controls }
  1450. {$EXTERNALSYM PWE_ACTIONHANDLES}
  1451.   PWE_INPUTCURSOR             = $0004;  { show cursor while writing }
  1452. {$EXTERNALSYM PWE_INPUTCURSOR}
  1453.   PWE_LENS                    = $0008;  { allow lens popup }
  1454. {$EXTERNALSYM PWE_LENS}
  1455.  
  1456. { GetPenMiscInfo/PMI_SYSFLAGS flags: }
  1457.   PWF_RC1                     = $0001;  { Windows for Pen 1.0 RC support }
  1458. {$EXTERNALSYM PWF_RC1}
  1459.   PWF_PEN                     = $0004;  { pen drv loaded & hdwe init'd }
  1460. {$EXTERNALSYM PWF_PEN}
  1461.   PWF_INKDISPLAY              = $0008;  { ink-compatible display drv loaded }
  1462. {$EXTERNALSYM PWF_INKDISPLAY}
  1463.   PWF_RECOGNIZER              = $0010;  { system recognizer installed }
  1464. {$EXTERNALSYM PWF_RECOGNIZER}
  1465.   PWF_BEDIT                   = $0100;  { boxed edit support }
  1466. {$EXTERNALSYM PWF_BEDIT}
  1467.   PWF_HEDIT                   = $0200;  { free input edit support }
  1468. {$EXTERNALSYM PWF_HEDIT}
  1469.   PWF_IEDIT                   = $0400;  { ink edit support }
  1470. {$EXTERNALSYM PWF_IEDIT}
  1471.   PWF_ENHANCED                = $1000;  { enh features (gest, 1ms timing) }
  1472. {$EXTERNALSYM PWF_ENHANCED}
  1473.   PWF_FULL    = PWF_RC1 or PWF_PEN or PWF_INKDISPLAY or PWF_RECOGNIZER or
  1474.                 PWF_BEDIT or PWF_HEDIT or PWF_IEDIT or PWF_ENHANCED;
  1475. {$EXTERNALSYM PWF_FULL}
  1476.  
  1477. { SetPenAppFlags API constants: }
  1478.   RPA_DEFAULT                 = $0001;  { = RPA_HEDIT }
  1479. {$EXTERNALSYM RPA_DEFAULT}
  1480.   RPA_HEDIT                   = $0001;  { convert EDIT to HEDIT }
  1481. {$EXTERNALSYM RPA_HEDIT}
  1482.   RPA_KANJIFIXEDBEDIT         = $0002;
  1483. {$EXTERNALSYM RPA_KANJIFIXEDBEDIT}
  1484.   RPA_DBCSPRIORITY            = $0004;  { assume DBCS has priority (Japan) }
  1485. {$EXTERNALSYM RPA_DBCSPRIORITY}
  1486.  
  1487.   PMIR_OK                     = 0;
  1488. {$EXTERNALSYM PMIR_OK}
  1489.   PMIR_INDEX                  = -1;
  1490. {$EXTERNALSYM PMIR_INDEX}
  1491.   PMIR_VALUE                  = -2;
  1492. {$EXTERNALSYM PMIR_VALUE}
  1493.   PMIR_INVALIDBOXEDITINFO     = -3;
  1494. {$EXTERNALSYM PMIR_INVALIDBOXEDITINFO}
  1495.   PMIR_INIERROR               = -4;
  1496. {$EXTERNALSYM PMIR_INIERROR}
  1497.   PMIR_ERROR                  = -5;
  1498. {$EXTERNALSYM PMIR_ERROR}
  1499.   PMIR_NA                     = -6;
  1500. {$EXTERNALSYM PMIR_NA}
  1501.  
  1502.   SPMI_OK                     = 0;
  1503. {$EXTERNALSYM SPMI_OK}
  1504.   SPMI_INVALIDBOXEDITINFO     = 1;
  1505. {$EXTERNALSYM SPMI_INVALIDBOXEDITINFO}
  1506.   SPMI_INIERROR               = 2;
  1507. {$EXTERNALSYM SPMI_INIERROR}
  1508.   SPMI_INVALIDPMI             = $8000;
  1509. {$EXTERNALSYM SPMI_INVALIDPMI}
  1510.  
  1511. { RC Options and Flags: }
  1512.  
  1513. { RC Direction: }
  1514.   RCD_DEFAULT                 = 0;      { def none }
  1515. {$EXTERNALSYM RCD_DEFAULT}
  1516.   RCD_LR                      = 1;      { left to right like English }
  1517. {$EXTERNALSYM RCD_LR}
  1518.   RCD_RL                      = 2;      { right to left like Arabic }
  1519. {$EXTERNALSYM RCD_RL}
  1520.   RCD_TB                      = 3;      { top to bottom like Japanese }
  1521. {$EXTERNALSYM RCD_TB}
  1522.   RCD_BT                      = 4;      { bottom to top like some Chinese }
  1523. {$EXTERNALSYM RCD_BT}
  1524.  
  1525. { RC International Preferences: }
  1526.   RCIP_ALLANSICHAR            = $0001;  { all ANSI chars }
  1527. {$EXTERNALSYM RCIP_ALLANSICHAR}
  1528.   RCIP_MASK                   = $0001;
  1529. {$EXTERNALSYM RCIP_MASK}
  1530.  
  1531. { RC Options: }
  1532.   RCO_NOPOINTEREVENT          = $00000001;    { no recog tap, tap/hold }
  1533. {$EXTERNALSYM RCO_NOPOINTEREVENT}
  1534.   RCO_SAVEALLDATA             = $00000002;    { save pen data like upstrokes }
  1535. {$EXTERNALSYM RCO_SAVEALLDATA}
  1536.   RCO_SAVEHPENDATA            = $00000004;    { save pen data for app }
  1537. {$EXTERNALSYM RCO_SAVEHPENDATA}
  1538.   RCO_NOFLASHUNKNOWN          = $00000008;    { no ? cursor on unknown }
  1539. {$EXTERNALSYM RCO_NOFLASHUNKNOWN}
  1540.   RCO_TABLETCOORD             = $00000010;    { tablet coords used in RC }
  1541. {$EXTERNALSYM RCO_TABLETCOORD}
  1542.   RCO_NOSPACEBREAK            = $00000020;    { no space break recog -> dict }
  1543. {$EXTERNALSYM RCO_NOSPACEBREAK}
  1544.   RCO_NOHIDECURSOR            = $00000040;    { display cursor during inking }
  1545. {$EXTERNALSYM RCO_NOHIDECURSOR}
  1546.   RCO_NOHOOK                  = $00000080;    { disallow ink hook (passwords) }
  1547. {$EXTERNALSYM RCO_NOHOOK}
  1548.   RCO_BOXED                   = $00000100;    { valid rc.guide provided }
  1549. {$EXTERNALSYM RCO_BOXED}
  1550.   RCO_SUGGEST                 = $00000200;    { for dict suggest }
  1551. {$EXTERNALSYM RCO_SUGGEST}
  1552.   RCO_DISABLEGESMAP           = $00000400;    { disable gesture mapping }
  1553. {$EXTERNALSYM RCO_DISABLEGESMAP}
  1554.   RCO_NOFLASHCURSOR           = $00000800;    { no cursor feedback }
  1555. {$EXTERNALSYM RCO_NOFLASHCURSOR}
  1556.   RCO_BOXCROSS                = $00001000;    { show + at boxedit center }
  1557. {$EXTERNALSYM RCO_BOXCROSS}
  1558.   RCO_COLDRECOG               = $00008000;    { result is from cold recog }
  1559. {$EXTERNALSYM RCO_COLDRECOG}
  1560.   RCO_SAVEBACKGROUND          = $00010000;    { Save background from ink }
  1561. {$EXTERNALSYM RCO_SAVEBACKGROUND}
  1562.   RCO_DODEFAULT               = $00020000;    { do default gesture processing }
  1563. {$EXTERNALSYM RCO_DODEFAULT}
  1564.  
  1565. { RC Orientation of Tablet: }
  1566.   RCOR_NORMAL                 = 1;      { tablet not rotated }
  1567. {$EXTERNALSYM RCOR_NORMAL}
  1568.   RCOR_RIGHT                  = 2;      { rotated 90 deg anticlockwise }
  1569. {$EXTERNALSYM RCOR_RIGHT}
  1570.   RCOR_UPSIDEDOWN             = 3;      { rotated 180 deg }
  1571. {$EXTERNALSYM RCOR_UPSIDEDOWN}
  1572.   RCOR_LEFT                   = 4;      { rotated 90 deg clockwise }
  1573. {$EXTERNALSYM RCOR_LEFT}
  1574.  
  1575. { RC Preferences: }
  1576.   RCP_LEFTHAND                = $0001;  { left handed input }
  1577. {$EXTERNALSYM RCP_LEFTHAND}
  1578.   RCP_MAPCHAR                 = $0004;  { fill in syg.lpsyc (ink) for training }
  1579. {$EXTERNALSYM RCP_MAPCHAR}
  1580.  
  1581. { RCRESULT wResultsType values: }
  1582.   RCRT_DEFAULT                = $0000;  { normal ret }
  1583. {$EXTERNALSYM RCRT_DEFAULT}
  1584.   RCRT_UNIDENTIFIED           = $0001;  { result contains unidentified results }
  1585. {$EXTERNALSYM RCRT_UNIDENTIFIED}
  1586.   RCRT_GESTURE                = $0002;  { result is a gesture }
  1587. {$EXTERNALSYM RCRT_GESTURE}
  1588.   RCRT_NOSYMBOLMATCH          = $0004;  { nothing recognized (no ink match) }
  1589. {$EXTERNALSYM RCRT_NOSYMBOLMATCH}
  1590.   RCRT_PRIVATE                = $4000;  { recognizer-specific symbol }
  1591. {$EXTERNALSYM RCRT_PRIVATE}
  1592.   RCRT_NORECOG                = $8000;  { no recog attempted, only data ret }
  1593. {$EXTERNALSYM RCRT_NORECOG}
  1594.   RCRT_ALREADYPROCESSED       = $0008;  { GestMgr hooked it }
  1595. {$EXTERNALSYM RCRT_ALREADYPROCESSED}
  1596.   RCRT_GESTURETRANSLATED      = $0010;  { GestMgr translated it to ANSI value }
  1597. {$EXTERNALSYM RCRT_GESTURETRANSLATED}
  1598.   RCRT_GESTURETOKEYS          = $0020;  { ditto to set of virtual keys }
  1599. {$EXTERNALSYM RCRT_GESTURETOKEYS}
  1600.  
  1601. { RC Result Return Mode specification: }
  1602.   RRM_STROKE                  = 0;      { return results after each stroke }
  1603. {$EXTERNALSYM RRM_STROKE}
  1604.   RRM_SYMBOL                  = 1;      { per symbol (e.g. boxed edits) }
  1605. {$EXTERNALSYM RRM_SYMBOL}
  1606.   RRM_WORD                    = 2;      { on recog of a word }
  1607. {$EXTERNALSYM RRM_WORD}
  1608.   RRM_NEWLINE                 = 3;      { on recog of a line break }
  1609. {$EXTERNALSYM RRM_NEWLINE}
  1610.   RRM_COMPLETE                = 16;     { on PCM_xx specified completion }
  1611. {$EXTERNALSYM RRM_COMPLETE}
  1612.  
  1613.   TPT_CLOSEST                 = $0001;   { Assign to the closest target }
  1614. {$EXTERNALSYM TPT_CLOSEST}
  1615.   TPT_INTERSECTINK            = $0002;   { target with intersecting ink }
  1616. {$EXTERNALSYM TPT_INTERSECTINK}
  1617.   TPT_TEXTUAL                 = $0004;   { apply textual heuristics }
  1618. {$EXTERNALSYM TPT_TEXTUAL}
  1619.   TPT_DEFAULT                 = TPT_TEXTUAL or TPT_INTERSECTINK or TPT_CLOSEST;
  1620. {$EXTERNALSYM TPT_DEFAULT}
  1621.  
  1622. { Virtual Event Layer: }
  1623.   VWM_MOUSEMOVE               = $0001;
  1624. {$EXTERNALSYM VWM_MOUSEMOVE}
  1625.   VWM_MOUSELEFTDOWN           = $0002;
  1626. {$EXTERNALSYM VWM_MOUSELEFTDOWN}
  1627.   VWM_MOUSELEFTUP             = $0004;
  1628. {$EXTERNALSYM VWM_MOUSELEFTUP}
  1629.   VWM_MOUSERIGHTDOWN          = $0008;
  1630. {$EXTERNALSYM VWM_MOUSERIGHTDOWN}
  1631.   VWM_MOUSERIGHTUP            = $0010;
  1632. {$EXTERNALSYM VWM_MOUSERIGHTUP}
  1633.  
  1634. { Messages and Defines }
  1635.  
  1636.   WM_RCRESULT                 = WM_PENWINFIRST+1;   { $381 }
  1637. {$EXTERNALSYM WM_RCRESULT}
  1638.   WM_HOOKRCRESULT             = WM_PENWINFIRST+2;   { $382 }
  1639. {$EXTERNALSYM WM_HOOKRCRESULT}
  1640.   WM_PENMISCINFO              = WM_PENWINFIRST+3;   { $383 }
  1641. {$EXTERNALSYM WM_PENMISCINFO}
  1642.   WM_GLOBALRCCHANGE           = WM_PENWINFIRST+3;   { alias }
  1643. {$EXTERNALSYM WM_GLOBALRCCHANGE}
  1644.   WM_SKB                      = WM_PENWINFIRST+4;   { $384 }
  1645. {$EXTERNALSYM WM_SKB}
  1646.   WM_PENCTL                   = WM_PENWINFIRST+5;   { $385 }
  1647. {$EXTERNALSYM WM_PENCTL}
  1648.   WM_HEDITCTL                 = WM_PENWINFIRST+5;   { FBC: alias }
  1649. {$EXTERNALSYM WM_HEDITCTL}
  1650.  
  1651. { WM_HEDITCTL (WM_PENCTL) wParam options: }
  1652.   HE_GETRC                    = 3;      { FBC: get RC from HEDIT/BEDIT control }
  1653. {$EXTERNALSYM HE_GETRC}
  1654.   HE_SETRC                    = 4;      { FBC: ditto set }
  1655. {$EXTERNALSYM HE_SETRC}
  1656.   HE_GETINFLATE               = 5;      { FBC: get inflate rect }
  1657. {$EXTERNALSYM HE_GETINFLATE}
  1658.   HE_SETINFLATE               = 6;      { FBC: ditto set }
  1659. {$EXTERNALSYM HE_SETINFLATE}
  1660.   HE_GETUNDERLINE             = 7;      { get underline mode }
  1661. {$EXTERNALSYM HE_GETUNDERLINE}
  1662.   HE_SETUNDERLINE             = 8;      { ditto set }
  1663. {$EXTERNALSYM HE_SETUNDERLINE}
  1664.   HE_GETINKHANDLE             = 9;      { get handle to captured ink }
  1665. {$EXTERNALSYM HE_GETINKHANDLE}
  1666.   HE_SETINKMODE               = 10;     { begin HEDIT cold recog mode }
  1667. {$EXTERNALSYM HE_SETINKMODE}
  1668.   HE_STOPINKMODE              = 11;     { end cold recog mode }
  1669. {$EXTERNALSYM HE_STOPINKMODE}
  1670.   HE_GETRCRESULTCODE          = 12;     { FBC: result of recog after HN_ENDREC }
  1671. {$EXTERNALSYM HE_GETRCRESULTCODE}
  1672.   HE_DEFAULTFONT              = 13;     { switch BEDIT to def font }
  1673. {$EXTERNALSYM HE_DEFAULTFONT}
  1674.   HE_CHARPOSITION             = 14;     { BEDIT byte offset -> char position }
  1675. {$EXTERNALSYM HE_CHARPOSITION}
  1676.   HE_CHAROFFSET               = 15;     { BEDIT char position -> byte offset }
  1677. {$EXTERNALSYM HE_CHAROFFSET}
  1678.   HE_GETBOXLAYOUT             = 20;     { get BEDIT layout }
  1679. {$EXTERNALSYM HE_GETBOXLAYOUT}
  1680.   HE_SETBOXLAYOUT             = 21;     { ditto set }
  1681. {$EXTERNALSYM HE_SETBOXLAYOUT}
  1682.   HE_GETRCRESULT              = 22;     { FBC: get RCRESULT after HN_RCRESULT }
  1683. {$EXTERNALSYM HE_GETRCRESULT}
  1684.   HE_KKCONVERT                = 30;     { JPN start kana-kanji conversion }
  1685. {$EXTERNALSYM HE_KKCONVERT}
  1686.   HE_GETKKCONVERT             = 31;     { JPN get KK state }
  1687. {$EXTERNALSYM HE_GETKKCONVERT}
  1688.   HE_CANCELKKCONVERT          = 32;     { JPN cancel KK conversion }
  1689. {$EXTERNALSYM HE_CANCELKKCONVERT}
  1690.   HE_FIXKKCONVERT             = 33;     { JPN force KK result }
  1691. {$EXTERNALSYM HE_FIXKKCONVERT}
  1692.   HE_GETKKSTATUS              = 34;     { JPN get KK UI state }
  1693. {$EXTERNALSYM HE_GETKKSTATUS}
  1694.   HE_KKNOCONVERT              = 35;     { JPN revert conversion }
  1695. {$EXTERNALSYM HE_KKNOCONVERT}
  1696.   HE_SETIMEDEFAULT            = 36;     { JPN set a range of DCS }
  1697. {$EXTERNALSYM HE_SETIMEDEFAULT}
  1698.   HE_GETIMEDEFAULT            = 37;     { JPN get a range of DCS }
  1699. {$EXTERNALSYM HE_GETIMEDEFAULT}
  1700.   HE_ENABLEALTLIST            = 40;     { en/disable dropdown recog alt's }
  1701. {$EXTERNALSYM HE_ENABLEALTLIST}
  1702.   HE_SHOWALTLIST              = 41;     { show dropdown (assume enabled) }
  1703. {$EXTERNALSYM HE_SHOWALTLIST}
  1704.   HE_HIDEALTLIST              = 42;     { hide dropdown alternatives }
  1705. {$EXTERNALSYM HE_HIDEALTLIST}
  1706.   HE_GETLENSTYPE              = 43;     { get lens type: CWR_ and CWRK_ flags }
  1707. {$EXTERNALSYM HE_GETLENSTYPE}
  1708.   HE_SETLENSTYPE              = 44;     { set lens type: CWR_ and CWRK_ flags }
  1709. {$EXTERNALSYM HE_SETLENSTYPE}
  1710.  
  1711. { JPN Kana-to-Kanji conversion subfunctions: }
  1712.   HEKK_DEFAULT                = 0;      { def }
  1713. {$EXTERNALSYM HEKK_DEFAULT}
  1714.   HEKK_CONVERT                = 1;      { convert in place }
  1715. {$EXTERNALSYM HEKK_CONVERT}
  1716.   HEKK_CANDIDATE              = 2;      { start conversion dialog }
  1717. {$EXTERNALSYM HEKK_CANDIDATE}
  1718.   HEKK_DBCSCHAR               = 3;      { convert to DBCS }
  1719. {$EXTERNALSYM HEKK_DBCSCHAR}
  1720.   HEKK_SBCSCHAR               = 4;      { convert to SBCS }
  1721. {$EXTERNALSYM HEKK_SBCSCHAR}
  1722.   HEKK_HIRAGANA               = 5;      { convert to hiragana }
  1723. {$EXTERNALSYM HEKK_HIRAGANA}
  1724.   HEKK_KATAKANA               = 6;      { convert to katakana }
  1725. {$EXTERNALSYM HEKK_KATAKANA}
  1726.  
  1727. { JPN Return value of HE_GETKKSTATUS }
  1728.   HEKKR_PRECONVERT            = 1;      { in pre conversion mode }
  1729. {$EXTERNALSYM HEKKR_PRECONVERT}
  1730.   HEKKR_CONVERT               = 2;      { in mid conversion mode }
  1731. {$EXTERNALSYM HEKKR_CONVERT}
  1732.   HEKKR_TEMPCONFIRM           = 3;      { in post conversion mode }
  1733. {$EXTERNALSYM HEKKR_TEMPCONFIRM}
  1734.  
  1735. { HE_STOPINKMODE (stop cold recog) options: }
  1736.   HEP_NORECOG                 = 0;      { don't recog ink }
  1737. {$EXTERNALSYM HEP_NORECOG}
  1738.   HEP_RECOG                   = 1;      { recog ink }
  1739. {$EXTERNALSYM HEP_RECOG}
  1740.   HEP_WAITFORTAP              = 2;      { recog after tap in window }
  1741. {$EXTERNALSYM HEP_WAITFORTAP}
  1742.  
  1743. { WM_PENCTL notifications: }
  1744.   HN_ENDREC                   = 4;      { recog complete }
  1745. {$EXTERNALSYM HN_ENDREC}
  1746.   HN_DELAYEDRECOGFAIL         = 5;      { HE_STOPINKMODE (cold recog) failed }
  1747. {$EXTERNALSYM HN_DELAYEDRECOGFAIL}
  1748.   HN_RESULT                   = 20;     { HEDIT/BEDIT has received new ink/recognition result }
  1749. {$EXTERNALSYM HN_RESULT}
  1750.   HN_RCRESULT                 = HN_RESULT;
  1751. {$EXTERNALSYM HN_RCRESULT}
  1752.   HN_ENDKKCONVERT             = 30;     { JPN KK conversion complete }
  1753. {$EXTERNALSYM HN_ENDKKCONVERT}
  1754.   HN_BEGINDIALOG              = 40;     { Lens/EditText/garbage detection dialog }
  1755. {$EXTERNALSYM HN_BEGINDIALOG}
  1756. {  is about to come up on this hedit/bedit }
  1757.   HN_ENDDIALOG                = 41;     { Lens/EditText/garbage detection dialog }
  1758. {$EXTERNALSYM HN_ENDDIALOG}
  1759. {  has just been destroyed }
  1760.  
  1761. { Messages common with other controls: }
  1762.  
  1763.   IE_GETMODIFY          = EM_GETMODIFY;        { gets the mod'n (dirty) bit }
  1764. {$EXTERNALSYM IE_GETMODIFY}
  1765.   IE_SETMODIFY          = EM_SETMODIFY;        { sets the mod'n (dirty) bit }
  1766. {$EXTERNALSYM IE_SETMODIFY}
  1767.   IE_CANUNDO            = EM_CANUNDO;          { queries whether can undo }
  1768. {$EXTERNALSYM IE_CANUNDO}
  1769.   IE_UNDO               = EM_UNDO;             { undo }
  1770. {$EXTERNALSYM IE_UNDO}
  1771.   IE_EMPTYUNDOBUFFER    = EM_EMPTYUNDOBUFFER;  { clears IEDIT undo buffer }
  1772. {$EXTERNALSYM IE_EMPTYUNDOBUFFER}
  1773.   IE_MSGFIRST           = WM_USER+150;         { $496 = 1174 }
  1774. {$EXTERNALSYM IE_MSGFIRST}
  1775.  
  1776. { IEdit common messages: }
  1777.   IE_GETINK                 = IE_MSGFIRST+0;    { gets ink from the control }
  1778. {$EXTERNALSYM IE_GETINK}
  1779.   IE_SETINK                 = IE_MSGFIRST+1;    { sets ink into the control }
  1780. {$EXTERNALSYM IE_SETINK}
  1781.   IE_GETPENTIP              = IE_MSGFIRST+2;    { gets the cur def ink pentip }
  1782. {$EXTERNALSYM IE_GETPENTIP}
  1783.   IE_SETPENTIP              = IE_MSGFIRST+3;    { sets the cur def ink pentip }
  1784. {$EXTERNALSYM IE_SETPENTIP}
  1785.   IE_GETERASERTIP           = IE_MSGFIRST+4;    { gets the cur eraser pentip }
  1786. {$EXTERNALSYM IE_GETERASERTIP}
  1787.   IE_SETERASERTIP           = IE_MSGFIRST+5;    { sets the cur eraser pentip }
  1788. {$EXTERNALSYM IE_SETERASERTIP}
  1789.   IE_GETBKGND               = IE_MSGFIRST+6;    { gets the bkgnd options }
  1790. {$EXTERNALSYM IE_GETBKGND}
  1791.   IE_SETBKGND               = IE_MSGFIRST+7;    { sets the bkgnd options }
  1792. {$EXTERNALSYM IE_SETBKGND}
  1793.   IE_GETGRIDORIGIN          = IE_MSGFIRST+8;    { gets the bkgnd grid origin }
  1794. {$EXTERNALSYM IE_GETGRIDORIGIN}
  1795.   IE_SETGRIDORIGIN          = IE_MSGFIRST+9;    { sets the bkgnd grid origin }
  1796. {$EXTERNALSYM IE_SETGRIDORIGIN}
  1797.   IE_GETGRIDPEN             = IE_MSGFIRST+10;   { gets the bkgnd grid pen }
  1798. {$EXTERNALSYM IE_GETGRIDPEN}
  1799.   IE_SETGRIDPEN             = IE_MSGFIRST+11;   { sets the bkgnd grid pen }
  1800. {$EXTERNALSYM IE_SETGRIDPEN}
  1801.   IE_GETGRIDSIZE            = IE_MSGFIRST+12;   { gets the bkgnd grid size }
  1802. {$EXTERNALSYM IE_GETGRIDSIZE}
  1803.   IE_SETGRIDSIZE            = IE_MSGFIRST+13;   { sets the bkgnd grid size }
  1804. {$EXTERNALSYM IE_SETGRIDSIZE}
  1805.   IE_GETMODE                = IE_MSGFIRST+14;   { gets the current pen mode }
  1806. {$EXTERNALSYM IE_GETMODE}
  1807.   IE_SETMODE                = IE_MSGFIRST+15;   { sets the current pen mode }
  1808. {$EXTERNALSYM IE_SETMODE}
  1809.   IE_GETINKRECT             = IE_MSGFIRST+16;   { gets the rectbound of the ink }
  1810. {$EXTERNALSYM IE_GETINKRECT}
  1811.  
  1812. { IEdit-specific messages: }
  1813.   IE_GETAPPDATA             = IE_MSGFIRST+34;   { gets the user-defined datum }
  1814. {$EXTERNALSYM IE_GETAPPDATA}
  1815.   IE_SETAPPDATA             = IE_MSGFIRST+35;   { sets the user-defined data }
  1816. {$EXTERNALSYM IE_SETAPPDATA}
  1817.   IE_GETDRAWOPTS            = IE_MSGFIRST+36;   { gets the ink draw options }
  1818. {$EXTERNALSYM IE_GETDRAWOPTS}
  1819.   IE_SETDRAWOPTS            = IE_MSGFIRST+37;   { sets the ink options }
  1820. {$EXTERNALSYM IE_SETDRAWOPTS}
  1821.   IE_GETFORMAT              = IE_MSGFIRST+38;   { gets format of stroke(s) }
  1822. {$EXTERNALSYM IE_GETFORMAT}
  1823.   IE_SETFORMAT              = IE_MSGFIRST+39;   { sets format of stroke(s) }
  1824. {$EXTERNALSYM IE_SETFORMAT}
  1825.   IE_GETINKINPUT            = IE_MSGFIRST+40;   { gets the ink input option }
  1826. {$EXTERNALSYM IE_GETINKINPUT}
  1827.   IE_SETINKINPUT            = IE_MSGFIRST+41;   { sets the ink input option }
  1828. {$EXTERNALSYM IE_SETINKINPUT}
  1829.   IE_GETNOTIFY              = IE_MSGFIRST+42;   { gets the notification bits }
  1830. {$EXTERNALSYM IE_GETNOTIFY}
  1831.   IE_SETNOTIFY              = IE_MSGFIRST+43;   { sets the notification bits }
  1832. {$EXTERNALSYM IE_SETNOTIFY}
  1833.   IE_GETRECOG               = IE_MSGFIRST+44;   { gets recognition options }
  1834. {$EXTERNALSYM IE_GETRECOG}
  1835.   IE_SETRECOG               = IE_MSGFIRST+45;   { sets recognition options }
  1836. {$EXTERNALSYM IE_SETRECOG}
  1837.   IE_GETSECURITY            = IE_MSGFIRST+46;   { gets the security options }
  1838. {$EXTERNALSYM IE_GETSECURITY}
  1839.   IE_SETSECURITY            = IE_MSGFIRST+47;   { sets the security options }
  1840. {$EXTERNALSYM IE_SETSECURITY}
  1841.   IE_GETSEL                 = IE_MSGFIRST+48;   { gets sel status of a stroke }
  1842. {$EXTERNALSYM IE_GETSEL}
  1843.   IE_SETSEL                 = IE_MSGFIRST+49;   { sets sel status of a stroke }
  1844. {$EXTERNALSYM IE_SETSEL}
  1845.   IE_DOCOMMAND              = IE_MSGFIRST+50;   { send command to IEdit }
  1846. {$EXTERNALSYM IE_DOCOMMAND}
  1847.   IE_GETCOMMAND             = IE_MSGFIRST+51;   { gets user command }
  1848. {$EXTERNALSYM IE_GETCOMMAND}
  1849.   IE_GETCOUNT               = IE_MSGFIRST+52;   { gets count of strks in I-Edit }
  1850. {$EXTERNALSYM IE_GETCOUNT}
  1851.   IE_GETGESTURE             = IE_MSGFIRST+53;   { gets details on user gesture }
  1852. {$EXTERNALSYM IE_GETGESTURE}
  1853.   IE_GETMENU                = IE_MSGFIRST+54;   { gets handle to pop-up menu }
  1854. {$EXTERNALSYM IE_GETMENU}
  1855.   IE_GETPAINTDC             = IE_MSGFIRST+55;   { gets the HDC for painting }
  1856. {$EXTERNALSYM IE_GETPAINTDC}
  1857.   IE_GETPDEVENT             = IE_MSGFIRST+56;   { gets details of last pd event }
  1858. {$EXTERNALSYM IE_GETPDEVENT}
  1859.   IE_GETSELCOUNT            = IE_MSGFIRST+57;   { gets count of selected strks }
  1860. {$EXTERNALSYM IE_GETSELCOUNT}
  1861.   IE_GETSELITEMS            = IE_MSGFIRST+58;   { gets indices of all sel strks }
  1862. {$EXTERNALSYM IE_GETSELITEMS}
  1863.   IE_GETSTYLE               = IE_MSGFIRST+59;   { gets IEdit control styles }
  1864. {$EXTERNALSYM IE_GETSTYLE}
  1865.  
  1866. { (H)Edit Control: }
  1867.  
  1868. { CTLINITHEDIT.dwFlags values }
  1869.   CIH_NOGDMSG               = $0001;  { disable garbage detection message box for this edit }
  1870. {$EXTERNALSYM CIH_NOGDMSG}
  1871.   CIH_NOACTIONHANDLE        = $0002;  { disable action handles for this edit }
  1872. {$EXTERNALSYM CIH_NOACTIONHANDLE}
  1873.   CIH_NOEDITTEXT            = $0004;  { disable Lens/Edit/Insert text for this edit }
  1874. {$EXTERNALSYM CIH_NOEDITTEXT}
  1875.   CIH_NOFLASHCURSOR         = $0008;  { don't flash cursor on tap-n-hold in this (h)edit }
  1876. {$EXTERNALSYM CIH_NOFLASHCURSOR}
  1877.  
  1878. { Boxed Edit Control: }
  1879.  
  1880. { box edit alternative list: }
  1881.   HEAL_DEFAULT                = -1;     { AltList def value for lParam }
  1882. {$EXTERNALSYM HEAL_DEFAULT}
  1883.  
  1884. { box edit Info: }
  1885.   BEI_FACESIZE                = 32;     { max size of font name, = LF_FACESIZE }
  1886. {$EXTERNALSYM BEI_FACESIZE}
  1887.   BEIF_BOXCROSS               = $0001;
  1888. {$EXTERNALSYM BEIF_BOXCROSS}
  1889.  
  1890. { box edit size: }
  1891.   BESC_DEFAULT                = 0;
  1892. {$EXTERNALSYM BESC_DEFAULT}
  1893.   BESC_ROMANFIXED             = 1;
  1894. {$EXTERNALSYM BESC_ROMANFIXED}
  1895.   BESC_KANJIFIXED             = 2;
  1896. {$EXTERNALSYM BESC_KANJIFIXED}
  1897.   BESC_USERDEFINED            = 3;
  1898. {$EXTERNALSYM BESC_USERDEFINED}
  1899.  
  1900. { CTLINITBEDIT.wFlags values }
  1901.   CIB_NOGDMSG               = $0001;  { disable garbage detection message box for this bedit }
  1902. {$EXTERNALSYM CIB_NOGDMSG}
  1903.   CIB_NOACTIONHANDLE        = $0002;  { disable action handles for this bedit }
  1904. {$EXTERNALSYM CIB_NOACTIONHANDLE}
  1905.   CIB_NOFLASHCURSOR         = $0004;  { don't flash cursor on tap-n-hold in this bedit }
  1906.  {$EXTERNALSYM CIB_NOFLASHCURSOR}
  1907.   CIB_NOWRITING             = $0010;  { disallow pen input into control }
  1908. {$EXTERNALSYM CIB_NOWRITING}
  1909.  
  1910.   BXD_CELLWIDTH               = 12;
  1911. {$EXTERNALSYM BXD_CELLWIDTH}
  1912.   BXD_CELLHEIGHT              = 16;
  1913. {$EXTERNALSYM BXD_CELLHEIGHT}
  1914.   BXD_BASEHEIGHT              = 13;
  1915. {$EXTERNALSYM BXD_BASEHEIGHT}
  1916.   BXD_BASEHORZ                = 0;
  1917. {$EXTERNALSYM BXD_BASEHORZ}
  1918.   BXD_MIDFROMBASE             = 0;
  1919. {$EXTERNALSYM BXD_MIDFROMBASE}
  1920.   BXD_CUSPHEIGHT              = 2;
  1921. {$EXTERNALSYM BXD_CUSPHEIGHT}
  1922.   BXD_ENDCUSPHEIGHT           = 4;
  1923. {$EXTERNALSYM BXD_ENDCUSPHEIGHT}
  1924.  
  1925.   BXDK_CELLWIDTH              = 32;
  1926. {$EXTERNALSYM BXDK_CELLWIDTH}
  1927.   BXDK_CELLHEIGHT             = 32;
  1928. {$EXTERNALSYM BXDK_CELLHEIGHT}
  1929.   BXDK_BASEHEIGHT             = 28;
  1930. {$EXTERNALSYM BXDK_BASEHEIGHT}
  1931.   BXDK_BASEHORZ               = 0;
  1932. {$EXTERNALSYM BXDK_BASEHORZ}
  1933.   BXDK_MIDFROMBASE            = 0;
  1934. {$EXTERNALSYM BXDK_MIDFROMBASE}
  1935.   BXDK_CUSPHEIGHT             = 28;
  1936. {$EXTERNALSYM BXDK_CUSPHEIGHT}
  1937.   BXDK_ENDCUSPHEIGHT          = 10;
  1938. {$EXTERNALSYM BXDK_ENDCUSPHEIGHT}
  1939.  
  1940. { IME colors for bedit }
  1941.   COLOR_BE_INPUT                 = 0;
  1942. {$EXTERNALSYM COLOR_BE_INPUT}
  1943.   COLOR_BE_INPUT_TEXT            = 1;
  1944. {$EXTERNALSYM COLOR_BE_INPUT_TEXT}
  1945.   COLOR_BE_CONVERT               = 2;
  1946. {$EXTERNALSYM COLOR_BE_CONVERT}
  1947.   COLOR_BE_CONVERT_TEXT          = 3;
  1948. {$EXTERNALSYM COLOR_BE_CONVERT_TEXT}
  1949.   COLOR_BE_CONVERTED             = 4;
  1950. {$EXTERNALSYM COLOR_BE_CONVERTED}
  1951.   COLOR_BE_CONVERTED_TEXT        = 5;
  1952. {$EXTERNALSYM COLOR_BE_CONVERTED_TEXT}
  1953.   COLOR_BE_UNCONVERT             = 6;
  1954. {$EXTERNALSYM COLOR_BE_UNCONVERT}
  1955.   COLOR_BE_UNCONVERT_TEXT        = 7;
  1956. {$EXTERNALSYM COLOR_BE_UNCONVERT_TEXT}
  1957.   COLOR_BE_CURSOR                = 8;
  1958. {$EXTERNALSYM COLOR_BE_CURSOR}
  1959.   COLOR_BE_CURSOR_TEXT           = 9;
  1960. {$EXTERNALSYM COLOR_BE_CURSOR_TEXT}
  1961.   COLOR_BE_PRECONVERT            = 10;
  1962. {$EXTERNALSYM COLOR_BE_PRECONVERT}
  1963.   COLOR_BE_PRECONVERT_TEXT       = 11;
  1964. {$EXTERNALSYM COLOR_BE_PRECONVERT_TEXT}
  1965.   MAXIMECOLORS                   = 12;
  1966. {$EXTERNALSYM MAXIMECOLORS}
  1967.  
  1968.   WM_PENMISC                  = WM_PENWINFIRST+6;   { $386 }
  1969. {$EXTERNALSYM WM_PENMISC}
  1970.  
  1971. { WM_PENMISC message constants: }
  1972.   PMSC_BEDITCHANGE            = 1;      { broadcast when BEDIT changes }
  1973. {$EXTERNALSYM PMSC_BEDITCHANGE}
  1974.   PMSC_PENUICHANGE            = 2;      { JPN broadcast when PENUI changes }
  1975. {$EXTERNALSYM PMSC_PENUICHANGE}
  1976.   PMSC_SUBINPCHANGE           = 3;      { JPN broadcast when SUBINPUT changes }
  1977. {$EXTERNALSYM PMSC_SUBINPCHANGE}
  1978.   PMSC_KKCTLENABLE            = 4;      { JPN }
  1979. {$EXTERNALSYM PMSC_KKCTLENABLE}
  1980.   PMSC_GETPCMINFO             = 5;      { query the window's PCMINFO }
  1981. {$EXTERNALSYM PMSC_GETPCMINFO}
  1982.   PMSC_SETPCMINFO             = 6;      { set the window's PCMINFO }
  1983. {$EXTERNALSYM PMSC_SETPCMINFO}
  1984.   PMSC_GETINKINGINFO          = 7;      { query the window's INKINGINFO }
  1985. {$EXTERNALSYM PMSC_GETINKINGINFO}
  1986.   PMSC_SETINKINGINFO          = 8;      { set the window's INKINGINFO }
  1987. {$EXTERNALSYM PMSC_SETINKINGINFO}
  1988.   PMSC_GETHRC                 = 9;      { query the window's HRC }
  1989. {$EXTERNALSYM PMSC_GETHRC}
  1990.   PMSC_SETHRC                 = 10;     { set the window's HRC }
  1991. {$EXTERNALSYM PMSC_SETHRC}
  1992.   PMSC_GETSYMBOLCOUNT         = 11;     { count of symbols in result recd by window }
  1993. {$EXTERNALSYM PMSC_GETSYMBOLCOUNT}
  1994.   PMSC_GETSYMBOLS             = 12;     { ditto symbols }
  1995. {$EXTERNALSYM PMSC_GETSYMBOLS}
  1996.   PMSC_SETSYMBOLS             = 13;     { ditto set symbols }
  1997. {$EXTERNALSYM PMSC_SETSYMBOLS}
  1998.   PMSC_LOADPW                 = 15;     { broadcast load state on penwin }
  1999. {$EXTERNALSYM PMSC_LOADPW}
  2000.   PMSC_INKSTOP                = 16;
  2001. {$EXTERNALSYM PMSC_INKSTOP}
  2002.  
  2003. { PMSCL_xx lParam values for PMSC_xx: }
  2004.   PMSCL_UNLOADED              = 0;      { penwin just unloaded }
  2005. {$EXTERNALSYM PMSCL_UNLOADED}
  2006.   PMSCL_LOADED                = 1;      { penwin just loaded }
  2007. {$EXTERNALSYM PMSCL_LOADED}
  2008.   PMSCL_UNLOADING             = 2;      { penwin about to unload }
  2009. {$EXTERNALSYM PMSCL_UNLOADING}
  2010.  
  2011.   WM_CTLINIT                  = WM_PENWINFIRST+7;   { $387 }
  2012. {$EXTERNALSYM WM_CTLINIT}
  2013.  
  2014. { WM_CTLINIT message constants: }
  2015.   CTLINIT_HEDIT               = 1;
  2016. {$EXTERNALSYM CTLINIT_HEDIT}
  2017.   CTLINIT_BEDIT               = 7;
  2018. {$EXTERNALSYM CTLINIT_BEDIT}
  2019.   CTLINIT_IEDIT               = 9;
  2020. {$EXTERNALSYM CTLINIT_IEDIT}
  2021.   CTLINIT_MAX                 = 10;
  2022. {$EXTERNALSYM CTLINIT_MAX}
  2023.  
  2024.   WM_PENEVENT                 = WM_PENWINFIRST+8;   { $388 }
  2025. {$EXTERNALSYM WM_PENEVENT}
  2026.  
  2027. { WM_PENEVENT message values for wParam: }
  2028.   PE_PENDOWN                  = 1;      { pen tip down }
  2029. {$EXTERNALSYM PE_PENDOWN}
  2030.   PE_PENUP                    = 2;      { pen tip went from down to up }
  2031. {$EXTERNALSYM PE_PENUP}
  2032.   PE_PENMOVE                  = 3;      { pen moved without a tip transition }
  2033. {$EXTERNALSYM PE_PENMOVE}
  2034.   PE_TERMINATING              = 4;      { Peninput about to terminate }
  2035. {$EXTERNALSYM PE_TERMINATING}
  2036.   PE_TERMINATED               = 5;      { Peninput terminated }
  2037. {$EXTERNALSYM PE_TERMINATED}
  2038.   PE_BUFFERWARNING            = 6;      { Buffer half full. }
  2039. {$EXTERNALSYM PE_BUFFERWARNING}
  2040.   PE_BEGININPUT               = 7;      { begin default input }
  2041. {$EXTERNALSYM PE_BEGININPUT}
  2042.   PE_SETTARGETS               = 8;      { set target data structure (TARGINFO) }
  2043. {$EXTERNALSYM PE_SETTARGETS}
  2044.   PE_BEGINDATA                = 9;      { init message to all targets }
  2045. {$EXTERNALSYM PE_BEGINDATA}
  2046.   PE_MOREDATA                 = 10;     { target gets more data }
  2047. {$EXTERNALSYM PE_MOREDATA}
  2048.   PE_ENDDATA                  = 11;     { termination message to all targets }
  2049. {$EXTERNALSYM PE_ENDDATA}
  2050.   PE_GETPCMINFO               = 12;     { get input collection info }
  2051. {$EXTERNALSYM PE_GETPCMINFO}
  2052.   PE_GETINKINGINFO            = 13;     { get inking info }
  2053. {$EXTERNALSYM PE_GETINKINGINFO}
  2054.   PE_ENDINPUT                 = 14;     { Input termination message to window }
  2055. {$EXTERNALSYM PE_ENDINPUT}
  2056. { starting default input }
  2057.   PE_RESULT                   = 15;     { sent after ProcessHRC but before GetResultsHRC }
  2058. {$EXTERNALSYM PE_RESULT}
  2059.  
  2060. type
  2061.   HTRG = Integer;
  2062. {$EXTERNALSYM HTRG}
  2063.   HPCM = Integer;
  2064. {$EXTERNALSYM HPCM}
  2065.   HPENDATA = Integer;
  2066. {$EXTERNALSYM HPENDATA}
  2067.   HREC = Integer;
  2068. {$EXTERNALSYM HREC}
  2069.  
  2070.  
  2071. { Types }
  2072.  
  2073. { Simple: }
  2074. type
  2075.   ALC = Longint;                                { Enabled Alphabet }
  2076. {$EXTERNALSYM ALC}
  2077.   CL = Integer;                              { Confidence Level }
  2078. {$EXTERNALSYM CL}
  2079.   HKP = UINT;                                { Hook Parameter }
  2080. {$EXTERNALSYM HKP}
  2081.   REC = Integer;                             { recognition result }
  2082. {$EXTERNALSYM REC}
  2083.   SYV = Longint;                                { Symbol Value }
  2084. {$EXTERNALSYM SYV}
  2085.  
  2086. { Pointer Types: }
  2087. type
  2088.   PALC = ^ALC;                                      { ptr to ALC }
  2089.   LPALC = PALC;
  2090. {$EXTERNALSYM LPALC}
  2091.   POEM = Pointer;                                   { alias }
  2092.   LPOEM = POEM;
  2093. {$EXTERNALSYM LPOEM}
  2094.   PSYV = ^SYV;                                      { ptr to SYV }
  2095.   LPSYV = PSYV;
  2096. {$EXTERNALSYM LPSYV}
  2097.   PHPENDATA = ^HPENDATA;                            { ptr to HPENDATA }
  2098.   LPHPENDATA = PHPENDATA;
  2099. {$EXTERNALSYM LPHPENDATA}
  2100.  
  2101. { Function Prototypes: }
  2102.   ENUMPROC = function(p1: PSYV; p2: Integer; p3: Integer): Integer stdcall;
  2103.   TFNEnumProc = ENUMPROC;
  2104. {$EXTERNALSYM ENUMPROC}
  2105.   PFNLPDF = ^TFNLPDF;
  2106.   LPDF = function(p1: Integer; p2, p3: Pointer; p4: Integer;
  2107.     p5, p6: DWORD): Integer stdcall;
  2108.   TFNLPDF = LPDF;
  2109.   {$EXTERNALSYM LPDF}
  2110.   RCYIELDPROC = function: BOOL stdcall;
  2111.   TFNRCYieldProc = RCYIELDPROC;
  2112.   {$EXTERNALSYM RCYIELDPROC}
  2113.  
  2114. { Structures: }
  2115.  
  2116.   PAbsTime = ^TAbsTime;
  2117.   tagABSTIME = packed record    { 2.0 absolute date/time }
  2118.     sec: DWORD;    { number of seconds since 1/1/1970, ret by CRTlib time() fn }
  2119.     ms: UINT;      { additional offset in ms, 0..999 }
  2120.   end;
  2121. {$EXTERNALSYM tagABSTIME}
  2122.   TAbsTime = tagABSTIME;
  2123.   ABSTIME = tagABSTIME;
  2124. {$EXTERNALSYM ABSTIME}
  2125.   LPABSTIME = PAbsTime;
  2126. {$EXTERNALSYM LPABSTIME}
  2127.  
  2128.   PCtlInitHEdit = ^TCtlInitHEdit;
  2129.   tagCTLINITHEDIT = packed record { 2.0 init struct for (h)edit }
  2130.     cbSize: DWORD;              { sizeof(CTLINITHEDIT) }
  2131.     hwnd: HWND;                 { (h)edit window handle }
  2132.     id: Integer;                    { its id }
  2133.     dwFlags: DWORD;             { CIE_xx }
  2134.     dwReserved: DWORD;          { for future use }
  2135.   end;
  2136. {$EXTERNALSYM tagCTLINITHEDIT}
  2137.   TCtlInitHEdit = tagCTLINITHEDIT;
  2138.   CTLINITHEDIT = tagCTLINITHEDIT;
  2139. {$EXTERNALSYM CTLINITHEDIT}
  2140.   LPCTLINITHEDIT = PCtlInitHEdit;
  2141. {$EXTERNALSYM LPCTLINITHEDIT}
  2142.  
  2143.   PBoxLayout = ^TBoxLayout;
  2144.   tagBOXLAYOUT = packed record  { 1.0 box edit layout }
  2145.     cyCusp: Integer;                { pixel height of box (BXS_RECT) or cusp }
  2146.     cyEndCusp: Integer;             { pixel height of cusps at extreme ends }
  2147.     style: UINT;                { BXS_xx style }
  2148.     dwReserved1: DWORD;         { reserved }
  2149.     dwReserved2: DWORD;         { reserved }
  2150.     dwReserved3: DWORD;         { reserved }
  2151.   end;
  2152. {$EXTERNALSYM tagBOXLAYOUT}
  2153.   TBoxLayout = tagBOXLAYOUT;
  2154.   BOXLAYOUT = TBoxLayout;
  2155. {$EXTERNALSYM BOXLAYOUT}
  2156.   LPBOXLAYOUT = PBoxLayout;
  2157. {$EXTERNALSYM LPBOXLAYOUT}
  2158.  
  2159.   PIMEColors = ^TIMEColors;
  2160.   tagIMECOLORS = packed record  { 2.0 IME undetermined string color info. }
  2161.     cColors: Integer;               { count of colors to be set/get }
  2162.     lpnElem: PINT;             { address of array of elements }
  2163.     lprgbIme: ^COLORREF;        { address of array of RGB values }
  2164.   end;
  2165. {$EXTERNALSYM tagIMECOLORS}
  2166.   TIMEColors = tagIMECOLORS;
  2167.   IMECOLORS = tagIMECOLORS;
  2168. {$EXTERNALSYM IMECOLORS}
  2169.   LPIMECOLORS = PIMEColors;
  2170. {$EXTERNALSYM LPIMECOLORS}
  2171.  
  2172.   PCtlInitBEdit = ^TCtlInitBEdit;
  2173.   tagCTLINITBEDIT = packed record { 2.0 init struct for box edit }
  2174.     cbSize: DWORD;              { sizeof(CTLINITBEDIT) }
  2175.     hwnd: HWND;                 { box edit window handle }
  2176.     id: Integer;                    { its id }
  2177.     wSizeCategory: WORD;        { BESC_xx }
  2178.     wFlags: WORD;               { CIB_xx }
  2179.     dwReserved: DWORD;          { for future use }
  2180.   end;
  2181. {$EXTERNALSYM tagCTLINITBEDIT}
  2182.   TCtlInitBEdit = tagCTLINITBEDIT;
  2183.   CTLINITBEDIT = tagCTLINITBEDIT;
  2184. {$EXTERNALSYM CTLINITBEDIT}
  2185.   LPCTLINITBEDIT = PCtlInitBEdit;
  2186. {$EXTERNALSYM LPCTLINITBEDIT}
  2187.  
  2188.   PBoxEditInfo = ^TBoxEditInfo;
  2189.   tagBOXEDITINFO = packed record { 1.1 box edit Size Info }
  2190.     cxBox: Integer;                 { width of a single box }
  2191.     cyBox: Integer;                 { ditto height }
  2192.     cxBase: Integer;                { in-box x-margin to guideline }
  2193.     cyBase: Integer;                { in-box y offset from top to baseline }
  2194.     cyMid: Integer;                 { 0 or distance from baseline to midline }
  2195.     boxlayout: TBoxLayout;       { embedded BOXLAYOUT structure }
  2196.     wFlags: UINT;               { BEIF_xx }
  2197.     szFaceName: packed array[0..BEI_FACESIZE-1] of BYTE;{ font face name }
  2198.     wFontHeight: UINT;          { font height }
  2199.     rgwReserved: packed array[0..7] of UINT;{ for future use }
  2200.   end;
  2201. {$EXTERNALSYM tagBOXEDITINFO}
  2202.   TBoxEditInfo = tagBOXEDITINFO;
  2203.   BOXEDITINFO = tagBOXEDITINFO;
  2204. {$EXTERNALSYM BOXEDITINFO}
  2205.   LPBOXEDITINFO = PBoxEditInfo;
  2206. {$EXTERNALSYM LPBOXEDITINFO}
  2207.  
  2208.   PRectOfs = ^TRectOfs;
  2209.   tagRECTOFS = packed record    { 1.0 rectangle offset for nonisometric inflation }
  2210.     dLeft: Integer;                 { inflation leftwards from left side }
  2211.     dTop: Integer;                  { ditto upwards from top }
  2212.     dRight: Integer;                { ditto rightwards from right }
  2213.     dBottom: Integer;               { ditto downwards from bottom }
  2214.   end;
  2215. {$EXTERNALSYM tagRECTOFS}
  2216.   TRectOfs = tagRECTOFS;
  2217.   RECTOFS = tagRECTOFS;
  2218. {$EXTERNALSYM RECTOFS}
  2219.   LPRECTOFS = PRectOfs;
  2220. {$EXTERNALSYM LPRECTOFS}
  2221.  
  2222.   PPenDataHeader = ^TPenDataHeader;
  2223.   tagPENDATAHEADER = packed record { 1.0 main pen data header }
  2224.     wVersion: UINT;             { pen data format version }
  2225.     cbSizeUsed: UINT;           { size of pendata mem block in bytes }
  2226.     cStrokes: UINT;             { number of strokes (incl up-strokes) }
  2227.     cPnt: UINT;                 { count of all points }
  2228.     cPntStrokeMax: UINT;        { length (in points) of longest stroke }
  2229.     rectBound: TRect;            { bounding rect of all down points }
  2230.     wPndts: UINT;               { PDTS_xx bits }
  2231.     nInkWidth: Integer;             { ink width in pixels }
  2232.     rgbInk: DWORD;              { ink color }
  2233.   end;
  2234. {$EXTERNALSYM tagPENDATAHEADER}
  2235.   TPenDataHeader = tagPENDATAHEADER;
  2236.   PENDATAHEADER = tagPENDATAHEADER;
  2237. {$EXTERNALSYM PENDATAHEADER}
  2238.   LPPENDATAHEADER = PPenDataHeader;
  2239. {$EXTERNALSYM LPPENDATAHEADER}
  2240.  
  2241.   PStrokeInfo = ^TStrokeInfo;
  2242.   tagSTROKEINFO = packed record { 1.0 stroke header }
  2243.     cPnt: UINT;                 { count of points in stroke }
  2244.     cbPnts: UINT;               { size of stroke in bytes }
  2245.     wPdk: UINT;                 { state of stroke }
  2246.     dwTick: DWORD;              { time at beginning of stroke }
  2247.   end;
  2248. {$EXTERNALSYM tagSTROKEINFO}
  2249.   TStrokeInfo = tagSTROKEINFO;
  2250.   STROKEINFO = tagSTROKEINFO;
  2251. {$EXTERNALSYM STROKEINFO}
  2252.   LPSTROKEINFO = PStrokeInfo;
  2253. {$EXTERNALSYM LPSTROKEINFO}
  2254.  
  2255.   PPenTip = ^TPenTip;
  2256.   tagPENTIP = packed record     { 2.0 Pen Tip characteristics }
  2257.     cbSize: DWORD;              { sizeof(PENTIP) }
  2258.     btype: BYTE;                { pen type/nib (calligraphic nib, etc.) }
  2259.     bwidth: BYTE;               { width of Nib (typically = nInkWidth) }
  2260.     bheight: BYTE;              { height of Nib }
  2261.     bOpacity: BYTE;             { 0=transparent, $80=hilite, $FF=opaque }
  2262.     rgb: COLORREF;              { pen color }
  2263.     dwFlags: DWORD;             { TIP_xx flags }
  2264.     dwReserved: DWORD;          { for future expansion }
  2265.   end;
  2266. {$EXTERNALSYM tagPENTIP}
  2267.   TPenTip = tagPENTIP;
  2268.   PENTIP = tagPENTIP;
  2269. {$EXTERNALSYM PENTIP}
  2270.   LPPENTIP = PPenTip;
  2271. {$EXTERNALSYM LPPENTIP}
  2272.  
  2273.   ANIMATEPROC = function(p1: HPENDATA; p2, p3: UINT; p4: PUINT;
  2274.     p5: LPARAM): BOOL stdcall;
  2275. {$EXTERNALSYM ANIMATEPROC}
  2276.   TFNAnimateProc = ANIMATEPROC;
  2277.  
  2278.   PAnimateInfo = ^TAnimateInfo;
  2279.   tagANIMATEINFO = packed record { 2.0 Animation parameters }
  2280.     cbSize: DWORD;              { sizeof(ANIMATEINFO) }
  2281.     uSpeedPct: UINT;            { speed percent to animate at }
  2282.     uPeriodCB: UINT;            { time between calls to callback in ms }
  2283.     fuFlags: UINT;              { animation flags }
  2284.     lParam: LPARAM;             { value to pass to callback }
  2285.     dwReserved: DWORD;          { reserved }
  2286.   end;
  2287. {$EXTERNALSYM tagANIMATEINFO}
  2288.   TAnimateInfo = tagANIMATEINFO;
  2289.   ANIMATEINFO = tagANIMATEINFO;
  2290. {$EXTERNALSYM ANIMATEINFO}
  2291.   LPANIMATEINFO = PAnimateInfo;
  2292. {$EXTERNALSYM LPANIMATEINFO}
  2293.  
  2294.   POEMPenInfo = ^TOEMPenInfo;
  2295.   tagOEMPENINFO = packed record { 1.0 OEM pen/tablet hdwe info }
  2296.     wPdt: UINT;                 { pen data type }
  2297.     wValueMax: UINT;            { largest val ret by device }
  2298.     wDistinct: UINT;            { number of distinct readings possible }
  2299.   end;
  2300. {$EXTERNALSYM tagOEMPENINFO}
  2301.   TOEMPenInfo = tagOEMPENINFO;
  2302.   OEMPENINFO = tagOEMPENINFO;
  2303. {$EXTERNALSYM OEMPENINFO}
  2304.   LPOEMPENINFO = POEMPenInfo;
  2305. {$EXTERNALSYM LPOEMPENINFO}
  2306.  
  2307.   PPenPacket = ^TPenPacket;
  2308.   tagPENPACKET = packed record
  2309.     wTabletX: UINT;             { x in raw coords }
  2310.     wTabletY: UINT;             { ditto y }
  2311.     wPDK: UINT;                 { state bits }
  2312.     rgwOemData: packed array[0..MAXOEMDATAWORDS-1] of UINT;{ OEM-specific data }
  2313.   end;
  2314. {$EXTERNALSYM tagPENPACKET}
  2315.   TPenPacket = tagPENPACKET;
  2316.   PENPACKET = tagPENPACKET;
  2317. {$EXTERNALSYM PENPACKET}
  2318.   LPPENPACKET = PPenPacket;
  2319. {$EXTERNALSYM LPPENPACKET}
  2320.  
  2321.   POEMPenPacket = ^TOEMPenPacket;
  2322.   tagOEMPENPACKET = packed record
  2323.     wTabletX: UINT;             { x in raw coords }
  2324.     wTabletY: UINT;             { ditto y }
  2325.     wPDK: UINT;                 { state bits }
  2326.     rgwOemData: packed array[0..MAXOEMDATAWORDS-1] of UINT;{ OEM-specific data }
  2327.     dwTime: DWORD;
  2328.   end;
  2329. {$EXTERNALSYM tagOEMPENPACKET}
  2330.   TOEMPenPacket = tagOEMPENPACKET;
  2331.   OEMPENPACKET = tagOEMPENPACKET;
  2332. {$EXTERNALSYM OEMPENPACKET}
  2333.   LPOEMPENPACKET = POEMPenPacket;
  2334. {$EXTERNALSYM LPOEMPENPACKET}
  2335.  
  2336.   PPenInfo = ^TPenInfo;
  2337.   tagPENINFO = packed record    { 1.0 pen/tablet hdwe info }
  2338.     cxRawWidth: UINT;           { max x coord and tablet width in 0.001" }
  2339.     cyRawHeight: UINT;          { ditto y, height }
  2340.     wDistinctWidth: UINT;       { number of distinct x values tablet ret }
  2341.     wDistinctHeight: UINT;      { ditto y }
  2342.     nSamplingRate: Integer;         { samples / second }
  2343.     nSamplingDist: Integer;         { min distance to move before generating event }
  2344.     lPdc: Longint;                 { Pen Device Capabilities }
  2345.     cPens: Integer;                 { number of pens supported }
  2346.     cbOemData: Integer;             { width of OEM data packet }
  2347.     rgoempeninfo: packed array[0..MAXOEMDATAWORDS-1] of TOEMPenInfo;{ supported OEM data types }
  2348.     rgwReserved: packed array[0..6] of UINT;{ for internal use }
  2349.     fuOEM: UINT;                { which OEM data, timing, PDK_xx to report }
  2350.   end;
  2351. {$EXTERNALSYM tagPENINFO}
  2352.   TPenInfo = tagPENINFO;
  2353.   PENINFO = tagPENINFO;
  2354. {$EXTERNALSYM PENINFO}
  2355.   LPPENINFO = PPenInfo;
  2356. {$EXTERNALSYM LPPENINFO}
  2357.  
  2358.   PCalbStruct = ^TCalbStruct;
  2359.   tagCALBSTRUCT = packed record { 1.0 pen calibration }
  2360.     wOffsetX: Integer;
  2361.     wOffsetY: Integer;
  2362.     wDistinctWidth: Integer;
  2363.     wDistinctHeight: Integer;
  2364.   end;
  2365. {$EXTERNALSYM tagCALBSTRUCT}
  2366.   TCalbStruct = tagCALBSTRUCT;
  2367.   CALBSTRUCT = tagCALBSTRUCT;
  2368. {$EXTERNALSYM CALBSTRUCT}
  2369.   LPCALBSTRUCT = PCalbStruct;
  2370. {$EXTERNALSYM LPCALBSTRUCT}
  2371.  
  2372.   LPFNRAWHOOK = function(PenPacket: PPenPacket): BOOL stdcall;
  2373. {$EXTERNALSYM LPFNRAWHOOK}
  2374.   TFNRawHook = LPFNRAWHOOK;
  2375.  
  2376. { Handwriting Recognizer: }
  2377.  
  2378. type
  2379.   HRC = Integer;
  2380. {$EXTERNALSYM HRC}
  2381.   HRCRESULT = Integer;
  2382. {$EXTERNALSYM HRCRESULT}
  2383.   HWL = Integer;
  2384. {$EXTERNALSYM HWL}
  2385.   HRECHOOK = Integer;
  2386. {$EXTERNALSYM HRECHOOK}
  2387.   HINKSET = Integer;
  2388. {$EXTERNALSYM HINKSET}
  2389.  
  2390.   PHRC = ^HRC;
  2391.   LPHRC = PHRC;
  2392. {$EXTERNALSYM LPHRC}
  2393.   PHRCRESULT = ^HRCRESULT;
  2394.   LPHRCRESULT = PHRCRESULT;
  2395. {$EXTERNALSYM LPHRCRESULT}
  2396.   PHWL = ^HWL;
  2397.   LPHWL = PHWL;
  2398. {$EXTERNALSYM LPHWL}
  2399.  
  2400.   HRCRESULTHOOKPROC = function(p1: HREC; p2: HRC; p3, p4, p5: UINT;
  2401.     p6: Pointer): BOOL stdcall;
  2402. {$EXTERNALSYM HRCRESULTHOOKPROC}
  2403.   TFNHRCResultHookProc = HRCRESULTHOOKPROC;
  2404.  
  2405. { Inksets: }
  2406.  
  2407.   LPHINKSET = ^HINKSET;                                    { ptr to HINKSET }
  2408. {$EXTERNALSYM LPHINKSET}
  2409.  
  2410.   PInterval = ^TInterval;
  2411.   tagINTERVAL = packed record   { 2.0 interval structure for inksets }
  2412.     atBegin: TAbsTime;           { begining of 1-ms granularity interval }
  2413.     atEnd: TAbsTime;             { 1 ms past end of interval }
  2414.   end;
  2415. {$EXTERNALSYM tagINTERVAL}
  2416.   TInterval = tagINTERVAL;
  2417.   INTERVAL = tagINTERVAL;
  2418. {$EXTERNALSYM INTERVAL}
  2419.   LPINTERVAL = PInterval;
  2420. {$EXTERNALSYM LPINTERVAL}
  2421.  
  2422.   PBoxResults = ^TBoxResults;
  2423.   tagBOXRESULTS = packed record { 2.0 }
  2424.     indxBox: UINT;
  2425.     hinksetBox: HINKSET;
  2426.     rgSyv: packed array[0..0] of SYV;
  2427.   end;
  2428. {$EXTERNALSYM tagBOXRESULTS}
  2429.   TBoxResults = tagBOXRESULTS;
  2430.   BOXRESULTS = tagBOXRESULTS;
  2431. {$EXTERNALSYM BOXRESULTS}
  2432.   LPBOXRESULTS = PBoxResults;
  2433. {$EXTERNALSYM LPBOXRESULTS}
  2434.  
  2435.   PGuide = ^TGuide;
  2436.   tagGUIDE = packed record      { 1.0 guide structure }
  2437.     xOrigin: Integer;               { left edge of first box (screen coord)) }
  2438.     yOrigin: Integer;               { ditto top edge }
  2439.     cxBox: Integer;                 { width of a single box }
  2440.     cyBox: Integer;                 { ditto height }
  2441.     cxBase: Integer;                { in-box x-margin to guideline }
  2442.     cyBase: Integer;                { in-box y offset from top to baseline }
  2443.     cHorzBox: Integer;              { count of boxed columns }
  2444.     cVertBox: Integer;              { ditto rows }
  2445.     cyMid: Integer;                 { 0 or distance from baseline to midline }
  2446.   end;
  2447. {$EXTERNALSYM tagGUIDE}
  2448.   TGuide = tagGUIDE;
  2449.   GUIDE = tagGUIDE;
  2450. {$EXTERNALSYM GUIDE}
  2451.   LPGUIDE = PGuide;
  2452. {$EXTERNALSYM LPGUIDE}
  2453.  
  2454.   PCtlInitIEdit = ^TCtlInitIEdit;
  2455.   tagCTLINITIEDIT = packed record { 2.0 init struct for Ink Edit }
  2456.     cbSize: DWORD;              { sizeof(CTLINITIEDIT) }
  2457.     hwnd: HWND;                 { IEdit window handle }
  2458.     id: Integer;                    { its ID }
  2459.     ieb: WORD;                  { IEB_* (background) bits }
  2460.     iedo: WORD;                 { IEDO_* (draw options) bits }
  2461.     iei: WORD;                  { IEI_* (ink input) bits }
  2462.     ien: WORD;                  { IEN_* (notification) bits }
  2463.     ierec: WORD;                { IEREC_* (recognition) bits }
  2464.     ies: WORD;                  { IES_* (style) bits }
  2465.     iesec: WORD;                { IESEC_* (security) bits }
  2466.     pdts: WORD;                 { initial pendata scale factor (PDTS_*) }
  2467.     hpndt: HPENDATA;            { initial pendata (or NULL if none) }
  2468.     hgdiobj: HGDIOBJ;           { background brush or bitmap handle }
  2469.     hpenGrid: HPEN;             { pen to use in drawing grid }
  2470.     ptOrgGrid: TPoint;          { grid lines point of origin }
  2471.     wVGrid: WORD;               { vertical gridline spacing }
  2472.     wHGrid: WORD;               { horizontal gridline spacing }
  2473.     dwApp: DWORD;               { application-defined data }
  2474.     dwReserved: DWORD;          { reserved for future use }
  2475.   end;
  2476. {$EXTERNALSYM tagCTLINITIEDIT}
  2477.   TCtlInitIEdit = tagCTLINITIEDIT;
  2478.   CTLINITIEDIT = tagCTLINITIEDIT;
  2479. {$EXTERNALSYM CTLINITIEDIT}
  2480.   LPCTLINITIEDIT = PCtlInitIEdit;
  2481. {$EXTERNALSYM LPCTLINITIEDIT}
  2482.  
  2483.   PPDEvent = ^TPDEvent;
  2484.   tagPDEVENT = packed record    { 2.0 }
  2485.     cbSize: DWORD;              { sizeof(PDEVENT) }
  2486.     hwnd: HWND;                 { window handle of I-Edit }
  2487.     wm: UINT;                   { WM_* (window message) of event }
  2488.     wParam: WPARAM;             { wParam of message }
  2489.     lParam: LPARAM;             { lParam of message }
  2490.     pt: TPoint;                  { event pt in I-Edit client co-ords }
  2491.     fPen: BOOL;                 { TRUE if pen (or other inking device) }
  2492.     lExInfo: Longint;              { GetMessageExtraInfo() return value }
  2493.     dwReserved: DWORD;          { for future use }
  2494.   end;
  2495. {$EXTERNALSYM tagPDEVENT}
  2496.   TPDEvent = tagPDEVENT;
  2497.   PDEVENT = tagPDEVENT;
  2498. {$EXTERNALSYM PDEVENT}
  2499.   LPPDEVENT = PPDEvent;
  2500. {$EXTERNALSYM LPPDEVENT}
  2501.  
  2502.   PStrkFmt = ^TStrkFmt;
  2503.   tagSTRKFMT = packed record    { 2.0 }
  2504.     cbSize: DWORD;              { sizeof(STRKFMT) }
  2505.     iesf: UINT;                 { stroke format flags and return bits }
  2506.     iStrk: UINT;                { stroke index if IESF_STROKE }
  2507.     tip: TPenTip;                { ink tip attributes }
  2508.     dwUser: DWORD;              { user data for strokes }
  2509.     dwReserved: DWORD;          { for future use }
  2510.   end;
  2511. {$EXTERNALSYM tagSTRKFMT}
  2512.   TStrkFmt = tagSTRKFMT;
  2513.   STRKFMT = tagSTRKFMT;
  2514. {$EXTERNALSYM STRKFMT}
  2515.   LPSTRKFMT = PStrkFmt;
  2516. {$EXTERNALSYM LPSTRKFMT}
  2517.  
  2518.   PPCMInfo = ^TPCMInfo;
  2519.   tagPCMINFO = packed record    { 2.0 Pen Collection Mode Information }
  2520.     cbSize: DWORD;              { sizeof(PCMINFO) }
  2521.     dwPcm: DWORD;               { PCM_xxx flags }
  2522.     rectBound: TRect;            { if finish on pendown outside this rect }
  2523.     rectExclude: TRect;          { if finish on pendown inside this rect }
  2524.     hrgnBound: HRGN;            { if finish on pendown outside this region }
  2525.     hrgnExclude: HRGN;          { if finish on pendown inside this region }
  2526.     dwTimeout: DWORD;           { if finish after timeout, this many ms }
  2527.   end;
  2528. {$EXTERNALSYM tagPCMINFO}
  2529.   TPCMInfo = tagPCMINFO;
  2530.   PCMINFO = tagPCMINFO;
  2531. {$EXTERNALSYM PCMINFO}
  2532.   LPPCMINFO = PPCMInfo;
  2533. {$EXTERNALSYM LPPCMINFO}
  2534.  
  2535.   PInkingInfo = ^TInkingInfo;
  2536.   tagINKINGINFO = packed record { 2.0 Pen Inking Information }
  2537.     cbSize: DWORD;              { sizeof(INKINGINFO) }
  2538.     wFlags: UINT;               { One of the PII_xx flags }
  2539.     tip: TPenTip;                { Pen type, size and color }
  2540.     rectClip: TRect;             { Clipping rect for the ink }
  2541.     rectInkStop: TRect;          { Rect in which a pen down stops inking }
  2542.     hrgnClip: HRGN;             { Clipping region for the ink }
  2543.     hrgnInkStop: HRGN;          { Region in which a pen down stops inking }
  2544.   end;
  2545. {$EXTERNALSYM tagINKINGINFO}
  2546.   TInkingInfo = tagINKINGINFO;
  2547.   INKINGINFO = tagINKINGINFO;
  2548. {$EXTERNALSYM INKINGINFO}
  2549.   LPINKINGINFO = PInkingInfo;
  2550. {$EXTERNALSYM LPINKINGINFO}
  2551.  
  2552.   PSYC = ^TSYC;
  2553.   tagSYC = packed record        { 1.0 Symbol Correspondence for Ink }
  2554.     wStrokeFirst: UINT;         { first stroke, inclusive }
  2555.     wPntFirst: UINT;            { first point in first stroke, inclusive }
  2556.     wStrokeLast: UINT;          { last stroke, inclusive }
  2557.     wPntLast: UINT;             { last point in last stroke, inclusive }
  2558.     fLastSyc: BOOL;             { T: no more SYCs follow for current SYE }
  2559.   end;
  2560. {$EXTERNALSYM tagSYC}
  2561.   TSYC = tagSYC;
  2562.   SYC = tagSYC;
  2563. {$EXTERNALSYM SYC}
  2564.   LPSYC = PSYC;
  2565. {$EXTERNALSYM LPSYC}
  2566.  
  2567.   PSYE = ^TSYE;
  2568.   tagSYE = packed record        { 1.0 Symbol Element }
  2569.     syv: SYV;                   { symbol value }
  2570.     lRecogVal: Longint;            { for internal use by recognizer }
  2571.     cl: CL;                     { confidence level }
  2572.     iSyc: Integer;                  { SYC index }
  2573.   end;
  2574. {$EXTERNALSYM tagSYE}
  2575.   TSYE = tagSYE;
  2576.   SYE = tagSYE;
  2577. {$EXTERNALSYM SYE}
  2578.   LPSYE = PSYE;
  2579. {$EXTERNALSYM LPSYE}
  2580.  
  2581.   PSYG = ^TSYG;
  2582.   tagSYG = packed record        { 1.0 Symbol Graph }
  2583.     rgpntHotSpots: packed array[0..MAXHOTSPOT-1] of TPoint;{ hot spots (max 8) }
  2584.     cHotSpot: Integer;              { number of valid hot spots in rgpntHotSpots }
  2585.     nFirstBox: Integer;             { row-major index to box of 1st char in result }
  2586.     lRecogVal: Longint;            { reserved for use by recoognizer }
  2587.     lpsye: PSYE;               { nodes of symbol graph }
  2588.     cSye: Integer;                  { number of SYEs in symbol graph }
  2589.     lpsyc: PSYC;               { ptr to corresp symbol ink }
  2590.     cSyc: Integer;                  { ditto count }
  2591.   end;
  2592. {$EXTERNALSYM tagSYG}
  2593.   TSYG = tagSYG;
  2594.   SYG = tagSYG;
  2595. {$EXTERNALSYM SYG}
  2596.   LPSYG = PSYG;
  2597. {$EXTERNALSYM LPSYG}
  2598.  
  2599.   PRC = ^TRC;
  2600.   tagRC = packed record         { 1.0 Recognition Context (RC) }
  2601.     hrec: HREC;                 { handle of recognizer to use }
  2602.     hwnd: HWND;                 { window to send results to }
  2603.     wEventRef: UINT;            { index into ink buffer }
  2604.     wRcPreferences: UINT;       { flags: RCP_xx Preferences }
  2605.     lRcOptions: Longint;           { RCO_xx options }
  2606.     lpfnYield: TFNRCYieldProc;     { procedure called during Yield() }
  2607.     lpUser: packed array[0..cbRcUserMax-1] of BYTE;{ current writer }
  2608.     wCountry: UINT;             { country code }
  2609.     wIntlPreferences: UINT;     { flags: RCIP_xx }
  2610.     lpLanguage: packed array[0..cbRcLanguageMax-1] of Char;{ language strings }
  2611.     rglpdf: packed array[0..MAXDICTIONARIES-1] of PFNLPDF;{ list of dictionary functions }
  2612.     wTryDictionary: UINT;       { max enumerations to search }
  2613.     clErrorLevel: CL;           { level where recognizer should reject input }
  2614.     alc: ALC;                   { enabled alphabet }
  2615.     alcPriority: ALC;           { prioritizes the ALC_ codes }
  2616.     rgbfAlc: packed array[0..cbRcrgbfAlcMax-1] of BYTE;{ bit field for enabled characters }
  2617.     wResultMode: UINT;          { RRM_xx when to send (asap or when complete) }
  2618.     wTimeOut: UINT;             { recognition timeout in ms }
  2619.     lPcm: Longint;                 { flags: PCM_xx for ending recognition }
  2620.     rectBound: TRect;            { bounding rect for inking (def:screen coords) }
  2621.     rectExclude: TRect;          { pen down inside this terminates recognition }
  2622.     guide: TGuide;               { struct: defines guidelines for recognizer }
  2623.     wRcOrient: UINT;            { RCOR_xx orientation of writing wrt tablet }
  2624.     wRcDirect: UINT;            { RCD_xx direction of writing }
  2625.     nInkWidth: Integer;             { ink width 0 (none) or 1..15 pixels }
  2626.     rgbInk: COLORREF;           { ink color }
  2627.     dwAppParam: DWORD;          { for application use }
  2628.     dwDictParam: DWORD;         { for app use to be passed on to dictionaries }
  2629.     dwRecognizer: DWORD;        { for app use to be passed on to recognizer }
  2630.     rgwReserved: packed array[0..cwRcReservedMax-1] of UINT;{ reserved for future use by Windows }
  2631.   end;
  2632. {$EXTERNALSYM tagRC}
  2633.   TRC = tagRC;
  2634.   RC = tagRC;
  2635. {$EXTERNALSYM RC}
  2636.   LPRC = PRC;
  2637. {$EXTERNALSYM LPRC}
  2638.  
  2639.   PRCResult = ^TRCResult;
  2640.   tagRCRESULT = packed record   { 1.0 Recognition Result }
  2641.     syg: TSYG;                   { symbol graph }
  2642.     wResultsType: UINT;         { see RCRT_xx }
  2643.     cSyv: Integer;                  { count of symbol values }
  2644.     lpsyv: PSYV;               { NULL-term ptr to recog's best guess }
  2645.     hSyv: THandle;               { globally-shared handle to lpsyv mem }
  2646.     nBaseLine: Integer;             { 0 or baseline of input writing }
  2647.     nMidLine: Integer;              { ditto midline }
  2648.     hpendata: HPENDATA;         { pen data mem }
  2649.     rectBoundInk: TRect;         { ink data bounds }
  2650.     pntEnd: TPoint;              { pt that terminated recog }
  2651.     lprc: PRC;                 { recog context used }
  2652.   end;
  2653. {$EXTERNALSYM tagRCRESULT}
  2654.   TRCResult = tagRCRESULT;
  2655.   RCRESULT = tagRCRESULT;
  2656. {$EXTERNALSYM RCRESULT}
  2657.   LPRCRESULT = PRCResult;
  2658. {$EXTERNALSYM LPRCRESULT}
  2659.  
  2660.   LPFUNCRESULTS = function(p1: PRCResult; p2: REC): Integer stdcall;
  2661. {$EXTERNALSYM LPFUNCRESULTS}
  2662.   TFNFuncResults = LPFUNCRESULTS;
  2663.  
  2664.   PTarget = ^TTarget;
  2665.   tagTARGET = packed record     { 2.0 Geometry for a single target. }
  2666.     dwFlags: DWORD;             { individual target flags }
  2667.     idTarget: DWORD;            { TARGINFO.rgTarget[] index }
  2668.     htrgTarget: HTRG;           { HANDLE32 equiv }
  2669.     rectBound: TRect;           { Bounding rect of the target }
  2670.     dwData: DWORD;              { data collection info per target }
  2671.     rectBoundInk: TRect;        { Reserved for internal use, must be zero }
  2672.     rectBoundLastInk: TRect;    { Reserved for internal use, must be zero }
  2673.   end;
  2674. {$EXTERNALSYM tagTARGET}
  2675.   TTarget = tagTARGET;
  2676.   TARGET = tagTARGET;
  2677. {$EXTERNALSYM TARGET}
  2678.   LPTARGET = PTarget;
  2679. {$EXTERNALSYM LPTARGET}
  2680.  
  2681.   PTargInfo = ^TTargInfo;
  2682.   tagTARGINFO = packed record   { 2.0 A set of targets }
  2683.     cbSize: DWORD;              { sizeof(TARGINFO) }
  2684.     dwFlags: DWORD;             { flags }
  2685.     htrgOwner: HTRG;            { HANDLE32 equiv }
  2686.     cTargets: WORD;             { count of targets }
  2687.     iTargetLast: WORD;          { last target, used by TargetPoints API }
  2688. { if TPT_TEXTUAL flag is set }
  2689.     rgTarget: packed array[0..0] of TTarget;{ variable-length array of targets }
  2690.   end;
  2691. {$EXTERNALSYM tagTARGINFO}
  2692.   TTargInfo = tagTARGINFO;
  2693.   TARGINFO = tagTARGINFO;
  2694. {$EXTERNALSYM TARGINFO}
  2695.   LPTARGINFO = PTargInfo;
  2696. {$EXTERNALSYM LPTARGINFO}
  2697.  
  2698.   PInpParams = ^TInpParams;
  2699.   tagINPPARAMS = packed record  { 2.0 }
  2700.     cbSize: DWORD;              { sizeof(INPPARAMS) }
  2701.     dwFlags: DWORD;
  2702.     hpndt: HPENDATA;
  2703.     target: TTarget;             { target structure }
  2704.   end;
  2705. {$EXTERNALSYM tagINPPARAMS}
  2706.   TInpParams = tagINPPARAMS;
  2707.   INPPARAMS = tagINPPARAMS;
  2708. {$EXTERNALSYM INPPARAMS}
  2709.   LPINPPARAMS = PInpParams;
  2710. {$EXTERNALSYM LPINPPARAMS}
  2711.  
  2712.   PSKBInfo = ^TSKBInfo;
  2713.   tagSKBINFO = packed record
  2714.     handle: HWnd;
  2715.     nPad: Word;
  2716.     fVisible: Bool;
  2717.     fMinimized: Bool;
  2718.     hect: TRect;
  2719.     dwReserved: Longint;
  2720.   end;
  2721. {$EXTERNALSYM tagSKBINFO}
  2722.   TSKBInfo = tagSKBINFO;
  2723.   SKBINFO = tagSKBINFO;
  2724. {$EXTERNALSYM SKBINFO}
  2725.   LPSKBINFO = PSKBInfo;
  2726. {$EXTERNALSYM LPSKBINFO}
  2727.  
  2728. { Utility Functions }
  2729.  
  2730. { Misc }
  2731. function FPenUpX(X: Integer): BOOL;
  2732. {$EXTERNALSYM FPenUpX}
  2733. function GetWEventRef: Word;
  2734. {$EXTERNALSYM GetWEventRef}
  2735.  
  2736. { ALC: }
  2737. function MpAlcB(lprc: PRC; i: Word): PByte;
  2738. {$EXTERNALSYM MpAlcB}
  2739. function MpIbf(i: Word): Byte;
  2740. {$EXTERNALSYM MpIbf}
  2741. procedure SetAlcBitAnsi(lprc: PRC; i: Word);
  2742. {$EXTERNALSYM SetAlcBitAnsi}
  2743. procedure ResetAlcBitAnsi(lprc: PRC; i: Word);
  2744. {$EXTERNALSYM ResetAlcBitAnsi}
  2745. function IsAlcBitAnsi(lprc: PRC; i: Word): Boolean;
  2746. {$EXTERNALSYM IsAlcBitAnsi}
  2747.  
  2748. { draw 2.0 pendata using internal stroke formats: }
  2749. function DrawPenDataFmt(hdc: HDC; lprect: PRect; hpndt: THandle): Integer;
  2750. {$EXTERNALSYM DrawPenDataFmt}
  2751.  
  2752. { Handwriting Recognizer: }
  2753.  
  2754. { Intervals: }
  2755.  
  2756. { difference of two absolute times (at2 > at1 for positive result): }
  2757. function dwDiffAT(at1, at2: TAbsTime): Integer;
  2758. {$EXTERNALSYM dwDiffAT}
  2759.  
  2760. { comparison of two absolute times (TRUE if at1 < at2): }
  2761. function FLTAbsTime(at1, at2: TAbsTime): Boolean;
  2762. {$EXTERNALSYM FLTAbsTime}
  2763.  
  2764. function FLTEAbsTime(at1, at2: TAbsTime): Boolean;
  2765. {$EXTERNALSYM FLTEAbsTime}
  2766.  
  2767. function FEQAbsTime(at1, at2: TAbsTime): Boolean;
  2768. {$EXTERNALSYM FEQAbsTime}
  2769.  
  2770. { test if abstime is within an interval: }
  2771. function FAbsTimeInInterval(at: TAbsTime; lpi: PInterval): Boolean;
  2772. {$EXTERNALSYM FAbsTimeInInterval}
  2773.  
  2774. { test if interval (lpiT) is within an another interval (lpiS): }
  2775. function FIntervalInInterval(lpiT, lpiS: PInterval): Boolean;
  2776. {$EXTERNALSYM FIntervalInInterval}
  2777.  
  2778. { test if interval (lpiT) intersects another interval (lpiS): }
  2779. function FIntervalXInterval(lpiT, lpiS: PInterval): Boolean;
  2780. {$EXTERNALSYM FIntervalXInterval}
  2781.  
  2782. { duration of an PInterval in ms: }
  2783. function dwDurInterval(lpi: PInterval): Integer;
  2784. {$EXTERNALSYM dwDurInterval}
  2785.  
  2786. { fill a pointer to an ABSTIME structure from a count of seconds and ms: }
  2787. procedure MakeAbsTime(var lpat: TAbsTime; sec, ms: Integer);
  2788. {$EXTERNALSYM MakeAbsTime}
  2789.  
  2790. { SYV functions: }
  2791.  
  2792. function FIsSpecial(syv: DWORD): Boolean;
  2793. {$EXTERNALSYM FIsSpecial}
  2794. function FIsAnsi(syv: DWORD): Boolean;
  2795. {$EXTERNALSYM FIsAnsi}
  2796. function FIsGesture(syv: DWORD): Boolean;
  2797. {$EXTERNALSYM FIsGesture}
  2798. function FIsKanji(syv: DWORD): Boolean;
  2799. {$EXTERNALSYM FIsKanji}
  2800. function FIsShape(syv: DWORD): Boolean;
  2801. {$EXTERNALSYM FIsShape}
  2802. function FIsUniCode(syv: DWORD): Boolean;
  2803. {$EXTERNALSYM FIsUniCode}
  2804. function FIsVKey(syv: DWORD): Boolean;
  2805. {$EXTERNALSYM FIsVKey}
  2806.  
  2807. function ChSyvToAnsi(syv: DWORD): Byte;
  2808. {$EXTERNALSYM ChSyvToAnsi}
  2809. function WSyvToKanji(syv: DWORD): Word;
  2810. {$EXTERNALSYM WSyvToKanji}
  2811. function SyvCharacterToSymbol(c: Char): DWORD;
  2812. {$EXTERNALSYM SyvCharacterToSymbol}
  2813. function SyvKanjiToSymbol(c: Char): DWORD;
  2814. {$EXTERNALSYM SyvKanjiToSymbol}
  2815.  
  2816. function FIsSelectGesture(syv: DWORD): Boolean;
  2817. {$EXTERNALSYM FIsSelectGesture}
  2818. function FIsStdGesture(syv: DWORD): Boolean;
  2819. {$EXTERNALSYM FIsStdGesture}
  2820. function FIsAnsiGesture(syv: DWORD): Boolean;
  2821. {$EXTERNALSYM FIsAnsiGesture}
  2822.  
  2823. function SubPenMsgFromWpLp(wp, lp: DWORD): Word;
  2824. {$EXTERNALSYM SubPenMsgFromWpLp}
  2825. function EventRefFromWpLp(wp, lp: DWORD): Word;
  2826. {$EXTERNALSYM EventRefFromWpLp}
  2827. function TerminationFromWpLp(wp, lp: DWORD): Integer;
  2828. {$EXTERNALSYM TerminationFromWpLp}
  2829.  
  2830. function HwndFromHtrg(trg: HTRG): HWND;
  2831. {$EXTERNALSYM HwndFromHtrg}
  2832. function HpcmFromWpLp(wp, lp: DWORD): Integer;
  2833. {$EXTERNALSYM HpcmFromWpLp}
  2834. function HtrgFromHwnd(hwnd: HWND): HTRG;
  2835. {$EXTERNALSYM HtrgFromHwnd}
  2836.  
  2837. { APIs and Prototypes }
  2838.  
  2839. { PenData: }
  2840. function AddPointsPenData(p1: HPENDATA; p2: PPoint; p3: Pointer;
  2841.   p4: PStrokeInfo): HPENDATA; stdcall;
  2842. {$EXTERNALSYM AddPointsPenData}
  2843. function CompressPenData(p1: HPENDATA; p2: UINT; p3: DWORD): Integer; stdcall;
  2844. {$EXTERNALSYM CompressPenData}
  2845. function CreatePenDataEx(p1: PPenInfo; p2: UINT; p3: UINT;
  2846.   p4: UINT): HPENDATA; stdcall;
  2847. {$EXTERNALSYM CreatePenDataEx}
  2848. function CreatePenDataRegion(p1: HPENDATA; p2: UINT): HRGN; stdcall;
  2849. {$EXTERNALSYM CreatePenDataRegion}
  2850. function DestroyPenData(p1: HPENDATA): BOOL; stdcall;
  2851. {$EXTERNALSYM DestroyPenData}
  2852. function DrawPenDataEx(p1: HDC; p2: PRect; p3: HPENDATA; p4: UINT; p5: UINT;
  2853.   p6: UINT; p7: UINT; p8: TFNAnimateProc; p9: PAnimateInfo;
  2854.   p10: UINT): Integer; stdcall;
  2855. {$EXTERNALSYM DrawPenDataEx}
  2856. function DuplicatePenData(p1: HPENDATA; p2: UINT): HPENDATA; stdcall;
  2857. {$EXTERNALSYM DuplicatePenData}
  2858. function ExtractPenDataPoints(p1: HPENDATA; p2: UINT; p3: UINT; p4: UINT;
  2859.   p5: PPoint; p6: Pointer; p7: UINT): Integer; stdcall;
  2860. {$EXTERNALSYM ExtractPenDataPoints}
  2861. function ExtractPenDataStrokes(p1: HPENDATA; p2: UINT; p3: LPARAM;
  2862.   p4: PHPENDATA; p5: UINT): Integer; stdcall;
  2863. {$EXTERNALSYM ExtractPenDataStrokes}
  2864. function GetPenDataAttributes(p1: HPENDATA; p2: Pointer; p3: UINT): Integer; stdcall;
  2865. {$EXTERNALSYM GetPenDataAttributes}
  2866. function GetPenDataInfo(p1: HPENDATA; p2: PPENDATAHEADER; p3: PPenInfo;
  2867.   p4: DWORD): BOOL; stdcall;
  2868. {$EXTERNALSYM GetPenDataInfo}
  2869. function GetPointsFromPenData(p1: HPENDATA; p2: UINT; p3: UINT; p4: UINT;
  2870.   p5: PPoint): BOOL; stdcall;
  2871. {$EXTERNALSYM GetPointsFromPenData}
  2872. function GetStrokeAttributes(p1: HPENDATA; p2: UINT; p3: Pointer;
  2873.   p4: UINT): Integer; stdcall;
  2874. {$EXTERNALSYM GetStrokeAttributes}
  2875. function GetStrokeTableAttributes(p1: HPENDATA; p2: UINT; p3: Pointer;
  2876.   p4: UINT): Integer; stdcall;
  2877. {$EXTERNALSYM GetStrokeTableAttributes}
  2878. function HitTestPenData(p1: HPENDATA; p2: PPoint; p3: UINT; p4: PUINT;
  2879.   p5: PUINT): Integer; stdcall;
  2880. {$EXTERNALSYM HitTestPenData}
  2881. function InsertPenData(p1: HPENDATA; p2: HPENDATA; p3: UINT): Integer; stdcall;
  2882. {$EXTERNALSYM InsertPenData}
  2883. function InsertPenDataPoints(p1: HPENDATA; p2: UINT; p3: UINT; p4: UINT;
  2884.   p5: PPoint; p6: Pointer): Integer; stdcall;
  2885. {$EXTERNALSYM InsertPenDataPoints}
  2886. function InsertPenDataStroke(p1: HPENDATA; p2: UINT; p3: PPoint; p4: Pointer;
  2887.   p5: PStrokeInfo): Integer; stdcall;
  2888. {$EXTERNALSYM InsertPenDataStroke}
  2889. function MetricScalePenData(p1: HPENDATA; p2: UINT): BOOL; stdcall;
  2890. {$EXTERNALSYM MetricScalePenData}
  2891. function OffsetPenData(p1: HPENDATA; p2: Integer; p3: Integer): BOOL; stdcall;
  2892. {$EXTERNALSYM OffsetPenData}
  2893. function PenDataFromBuffer(p1: PHPENDATA; p2: UINT; p3: PByte; p4: Longint;
  2894.   p5: PDWORD): Longint; stdcall;
  2895. {$EXTERNALSYM PenDataFromBuffer}
  2896. function PenDataToBuffer(p1: HPENDATA; p2: PByte; p3: Longint;
  2897.   p4: PDWORD): Longint; stdcall;
  2898. {$EXTERNALSYM PenDataToBuffer}
  2899. function RedisplayPenData(p1: HDC; p2: HPENDATA; p3: PPoint; p4: PPoint;
  2900.   p5: Integer; p6: DWORD): BOOL; stdcall;
  2901. {$EXTERNALSYM RedisplayPenData}
  2902. function RemovePenDataStrokes(p1: HPENDATA; p2: UINT; p3: UINT): Integer; stdcall;
  2903. {$EXTERNALSYM RemovePenDataStrokes}
  2904. function ResizePenData(p1: HPENDATA; p2: PRect): BOOL; stdcall;
  2905. {$EXTERNALSYM ResizePenData}
  2906. function SetStrokeAttributes(p1: HPENDATA; p2: UINT; p3: LPARAM;
  2907.   p4: UINT): Integer; stdcall;
  2908. {$EXTERNALSYM SetStrokeAttributes}
  2909. function SetStrokeTableAttributes(p1: HPENDATA; p2: UINT; p3: LPARAM;
  2910.   p4: UINT): Integer; stdcall;
  2911. {$EXTERNALSYM SetStrokeTableAttributes}
  2912. function TrimPenData(p1: HPENDATA; p2: DWORD; p3: DWORD): Integer; stdcall;
  2913. {$EXTERNALSYM TrimPenData}
  2914.  
  2915. { Pen Hardware/Driver: }
  2916. function GetPenAsyncState(p1: UINT): BOOL; stdcall;
  2917. {$EXTERNALSYM GetPenAsyncState}
  2918. function IsPenEvent(p1: UINT; p2: Longint): BOOL; stdcall;
  2919. {$EXTERNALSYM IsPenEvent}
  2920.  
  2921. { Handwriting Recognizer: }
  2922. function AddPenDataHRC(p1: HRC; p2: HPENDATA): Integer; stdcall;
  2923. {$EXTERNALSYM AddPenDataHRC}
  2924. function AddPenInputHRC(p1: HRC; p2: PPoint; p3: Pointer; p4: UINT;
  2925.   p5: PStrokeInfo): Integer; stdcall;
  2926. {$EXTERNALSYM AddPenInputHRC}
  2927. function AddWordsHWL(p1: HWL; p2: LPSTR; p3: UINT): Integer; stdcall;
  2928. {$EXTERNALSYM AddWordsHWL}
  2929. function ConfigHREC(p1: HREC; p2: UINT; p3: WPARAM; p4: LPARAM): Integer; stdcall;
  2930. {$EXTERNALSYM ConfigHREC}
  2931. function CreateCompatibleHRC(p1: HRC; p2: HREC): HRC; stdcall;
  2932. {$EXTERNALSYM CreateCompatibleHRC}
  2933. function CreateHWL(p1: HREC; p2: LPSTR; p3: UINT; p4: DWORD): HWL; stdcall;
  2934. {$EXTERNALSYM CreateHWL}
  2935. function CreateInksetHRCRESULT(p1: HRCRESULT; p2: UINT;
  2936.   p3: UINT): HINKSET; stdcall;
  2937. {$EXTERNALSYM CreateInksetHRCRESULT}
  2938. function CreatePenDataHRC(p1: HRC): HPENDATA; stdcall;
  2939. {$EXTERNALSYM CreatePenDataHRC}
  2940. function DestroyHRC(p1: HRC): Integer; stdcall;
  2941. {$EXTERNALSYM DestroyHRC}
  2942. function DestroyHRCRESULT(p1: HRCRESULT): Integer; stdcall;
  2943. {$EXTERNALSYM DestroyHRCRESULT}
  2944. function DestroyHWL(p1: HWL): Integer; stdcall;
  2945. {$EXTERNALSYM DestroyHWL}
  2946. function EnableGestureSetHRC(p1: HRC; p2: SYV; p3: BOOL): Integer; stdcall;
  2947. {$EXTERNALSYM EnableGestureSetHRC}
  2948. function EnableSystemDictionaryHRC(p1: HRC; p2: BOOL): Integer; stdcall;
  2949. {$EXTERNALSYM EnableSystemDictionaryHRC}
  2950. function EndPenInputHRC(p1: HRC): Integer; stdcall;
  2951. {$EXTERNALSYM EndPenInputHRC}
  2952. function GetAlphabetHRC(p1: HRC; p2: PALC; p3: PByte): Integer; stdcall;
  2953. {$EXTERNALSYM GetAlphabetHRC}
  2954. function GetAlphabetPriorityHRC(p1: HRC; p2: PALC; p3: PByte): Integer; stdcall;
  2955. {$EXTERNALSYM GetAlphabetPriorityHRC}
  2956. function GetAlternateWordsHRCRESULT(p1: HRCRESULT; p2: UINT; p3: UINT;
  2957.   p4: PHRCRESULT; p5: UINT): Integer; stdcall;
  2958. {$EXTERNALSYM GetAlternateWordsHRCRESULT}
  2959. function GetBoxMappingHRCRESULT(p1: HRCRESULT; p2, p3: UINT;
  2960.   p4: PUINT): Integer; stdcall;
  2961. {$EXTERNALSYM GetBoxMappingHRCRESULT}
  2962. function GetBoxResultsHRC(p1: HRC; p2, p3, p4: UINT;
  2963.   p5: PBoxResults; p6: BOOL): Integer; stdcall;
  2964. {$EXTERNALSYM GetBoxResultsHRC}
  2965. function GetGuideHRC(p1: HRC; p2: PGuide; p3: PUINT): Integer; stdcall;
  2966. {$EXTERNALSYM GetGuideHRC}
  2967. function GetHotspotsHRCRESULT(p1: HRCRESULT; p2: UINT; p3: PPoint;
  2968.   p4: UINT): Integer; stdcall;
  2969. {$EXTERNALSYM GetHotspotsHRCRESULT}
  2970. function GetHRECFromHRC(p1: HRC): HREC; stdcall;
  2971. {$EXTERNALSYM GetHRECFromHRC}
  2972. function GetInternationalHRC(p1: HRC; p2: PUINT; p3: LPSTR; p4: PUINT;
  2973.   p5: PUINT): Integer; stdcall;
  2974. {$EXTERNALSYM GetInternationalHRC}
  2975. function GetMaxResultsHRC(p1: HRC): Integer; stdcall;
  2976. {$EXTERNALSYM GetMaxResultsHRC}
  2977. function GetResultsHRC(p1: HRC; p2: UINT; p3: PHRCRESULT;
  2978.   p4: UINT): Integer; stdcall;
  2979. {$EXTERNALSYM GetResultsHRC}
  2980. function GetSymbolCountHRCRESULT(p1: HRCRESULT): Integer; stdcall;
  2981. {$EXTERNALSYM GetSymbolCountHRCRESULT}
  2982. function GetSymbolsHRCRESULT(p1: HRCRESULT; p2: UINT; p3: PSYV;
  2983.   p4: UINT): Integer; stdcall;
  2984. {$EXTERNALSYM GetSymbolsHRCRESULT}
  2985. function GetWordlistHRC(p1: HRC; p2: PHWL): Integer; stdcall;
  2986. {$EXTERNALSYM GetWordlistHRC}
  2987. function GetWordlistCoercionHRC(p1: HRC): Integer; stdcall;
  2988. {$EXTERNALSYM GetWordlistCoercionHRC}
  2989. function ProcessHRC(p1: HRC; p2: DWORD): Integer; stdcall;
  2990. {$EXTERNALSYM ProcessHRC}
  2991. function ReadHWL(p1: HWL; p2: HFILE): Integer; stdcall;
  2992. {$EXTERNALSYM ReadHWL}
  2993. function SetAlphabetHRC(p1: HRC; p2: ALC; p3: PByte): Integer; stdcall;
  2994. {$EXTERNALSYM SetAlphabetHRC}
  2995. function SetAlphabetPriorityHRC(p1: HRC; p2: ALC; p3: PByte): Integer; stdcall;
  2996. {$EXTERNALSYM SetAlphabetPriorityHRC}
  2997. function SetBoxAlphabetHRC(p1: HRC; p2: PALC; p3: UINT): Integer; stdcall;
  2998. {$EXTERNALSYM SetBoxAlphabetHRC}
  2999. function SetGuideHRC(p1: HRC; p2: PGuide; p3: UINT): Integer; stdcall;
  3000. {$EXTERNALSYM SetGuideHRC}
  3001. function SetInternationalHRC(p1: HRC; p2: UINT; p3: LPCSTR; p4: UINT;
  3002.   p5: UINT): Integer; stdcall;
  3003. {$EXTERNALSYM SetInternationalHRC}
  3004. function SetMaxResultsHRC(p1: HRC; p2: UINT): Integer; stdcall;
  3005. {$EXTERNALSYM SetMaxResultsHRC}
  3006. function SetResultsHookHREC(p1: HREC; var p2: TFNHRCResultHookProc): HRECHOOK; stdcall;
  3007. {$EXTERNALSYM SetResultsHookHREC}
  3008. function SetWordlistCoercionHRC(p1: HRC; p2: UINT): Integer; stdcall;
  3009. {$EXTERNALSYM SetWordlistCoercionHRC}
  3010. function SetWordlistHRC(p1: HRC; p2: HWL): Integer; stdcall;
  3011. {$EXTERNALSYM SetWordlistHRC}
  3012. function TrainHREC(p1: HREC; p2: PSYV; p3: UINT; p4: HPENDATA;
  3013.   p5: UINT): Integer; stdcall;
  3014. {$EXTERNALSYM TrainHREC}
  3015. function UnhookResultsHookHREC(p1: HREC; p2: HRECHOOK): Integer; stdcall;
  3016. {$EXTERNALSYM UnhookResultsHookHREC}
  3017. function WriteHWL(p1: HWL; p2: HFILE): Integer; stdcall;
  3018. {$EXTERNALSYM WriteHWL}
  3019.  
  3020. { Recognizer Installation: }
  3021. function InstallRecognizer(p1: LPSTR): HREC; stdcall;
  3022. {$EXTERNALSYM InstallRecognizer}
  3023. function UninstallRecognizer(p1: HREC): Pointer; stdcall;
  3024. {$EXTERNALSYM UninstallRecognizer}
  3025.  
  3026. { Inksets: }
  3027. function AddInksetInterval(p1: HINKSET; p2: PInterval): BOOL; stdcall;
  3028. {$EXTERNALSYM AddInksetInterval}
  3029. function CreateInkset(p1: UINT): HINKSET; stdcall;
  3030. {$EXTERNALSYM CreateInkset}
  3031. function DestroyInkset(p1: HINKSET): BOOL; stdcall;
  3032. {$EXTERNALSYM DestroyInkset}
  3033. function GetInksetInterval(p1: HINKSET; p2: UINT; p3: PInterval): Integer; stdcall;
  3034. {$EXTERNALSYM GetInksetInterval}
  3035. function GetInksetIntervalCount(p1: HINKSET): Integer; stdcall;
  3036. {$EXTERNALSYM GetInksetIntervalCount}
  3037.  
  3038. { Symbol Values: }
  3039. function CharacterToSymbol(p1: LPSTR; p2: Integer; p3: PSYV): Integer; stdcall;
  3040. {$EXTERNALSYM CharacterToSymbol}
  3041. function SymbolToCharacter(p1: PSYV; p2: Integer; p3: LPSTR;
  3042.   p4: PINT): BOOL; stdcall;
  3043. {$EXTERNALSYM SymbolToCharacter}
  3044.  
  3045. { Pen Input/Inking: }
  3046. function DoDefaultPenInput(p1: HWND; p2: UINT): Integer; stdcall;
  3047. {$EXTERNALSYM DoDefaultPenInput}
  3048. function GetPenInput(p1: HPCM; p2: PPoint; p3: Pointer; p4: UINT; p5: UINT;
  3049.   p6: PStrokeInfo): Integer; stdcall;
  3050. {$EXTERNALSYM GetPenInput}
  3051. function PeekPenInput(p1: HPCM; p2: UINT; p3: PPoint; p4: Pointer;
  3052.   p5: UINT): Integer; stdcall;
  3053. {$EXTERNALSYM PeekPenInput}
  3054. function StartInking(p1: HPCM; p2: UINT; p3: PInkingInfo): Integer; stdcall;
  3055. {$EXTERNALSYM StartInking}
  3056. function StartPenInput(p1: HWND; p2: UINT; p3: PPCMInfo;
  3057.   p4: PINT): HPCM; stdcall;
  3058. {$EXTERNALSYM StartPenInput}
  3059. function StopInking(p1: HPCM): Integer; stdcall;
  3060. {$EXTERNALSYM StopInking}
  3061. function StopPenInput(p1: HPCM; p2: UINT; p3: Integer): Integer; stdcall;
  3062. {$EXTERNALSYM StopPenInput}
  3063.  
  3064. { Miscellaneous/Utilities: }
  3065. function BoundingRectFromPoints(p1: PPoint; p2: UINT;
  3066.   p3: PRect): Pointer; stdcall;
  3067. {$EXTERNALSYM BoundingRectFromPoints}
  3068. function DPtoTP(p1: PPoint; p2: Integer): BOOL; stdcall;
  3069. {$EXTERNALSYM DPtoTP}
  3070. function GetPenAppFlags: UINT; stdcall;
  3071. {$EXTERNALSYM GetPenAppFlags}
  3072. function SetPenAppFlags(p1: UINT; p2: UINT): Pointer; stdcall;
  3073. {$EXTERNALSYM SetPenAppFlags}
  3074. function GetPenMiscInfo(p1: WPARAM; p2: LPARAM): Longint; stdcall;
  3075. {$EXTERNALSYM GetPenMiscInfo}
  3076. function GetVersionPenWin: UINT; stdcall;
  3077. {$EXTERNALSYM GetVersionPenWin}
  3078. function SetPenMiscInfo(p1: WPARAM; p2: LPARAM): Longint; stdcall;
  3079. {$EXTERNALSYM SetPenMiscInfo}
  3080. function TPtoDP(p1: PPoint; p2: Integer): BOOL; stdcall;
  3081. {$EXTERNALSYM TPtoDP}
  3082. function CorrectWriting(p1: HWND; p2: LPSTR; p3: UINT; p4: Pointer; p5: DWORD;
  3083.   p6: DWORD): BOOL; stdcall;
  3084. {$EXTERNALSYM CorrectWriting}
  3085.  
  3086. { Ink Targeting: }
  3087. function TargetPoints(p1: PTargInfo; p2: PPoint; p3: DWORD; p4: UINT;
  3088.   p5: PStrokeInfo): Integer; stdcall;
  3089. {$EXTERNALSYM TargetPoints}
  3090.  
  3091. { Kanji }
  3092. function KKConvert(hwndConvert: HWND; hwndCaller: HWND; lpBuf: LPSTR;
  3093.   cbBuf: UINT; lpPnt: PPoint): BOOL; stdcall;
  3094. {$EXTERNALSYM KKConvert}
  3095.  
  3096. implementation
  3097.  
  3098. const
  3099.   penwin32 = 'penwin32.dll';
  3100.  
  3101. function AddInksetInterval;             external penwin32 name 'AddInksetInterval';
  3102. function AddPenDataHRC;                 external penwin32 name 'AddPenDataHRC';
  3103. function AddPenInputHRC;                external penwin32 name 'AddPenInputHRC';
  3104. function AddPointsPenData;              external penwin32 name 'AddPointsPenData';
  3105. function AddWordsHWL;                   external penwin32 name 'AddWordsHWL';
  3106. function BoundingRectFromPoints;        external penwin32 name 'BoundingRectFromPoints';
  3107. function CharacterToSymbol;             external penwin32 name 'CharacterToSymbol';
  3108. function CompressPenData;               external penwin32 name 'CompressPenData';
  3109. function ConfigHREC;                    external penwin32 name 'ConfigHREC';
  3110. function CorrectWriting;                external penwin32 name 'CorrectWriting';
  3111. function CreateCompatibleHRC;           external penwin32 name 'CreateCompatibleHRC';
  3112. function CreateHWL;                     external penwin32 name 'CreateHWL';
  3113. function CreateInkset;                  external penwin32 name 'CreateInkset';
  3114. function CreateInksetHRCRESULT;         external penwin32 name 'CreateInksetHRCRESULT';
  3115. function CreatePenDataEx;               external penwin32 name 'CreatePenDataEx';
  3116. function CreatePenDataHRC;              external penwin32 name 'CreatePenDataHRC';
  3117. function CreatePenDataRegion;           external penwin32 name 'CreatePenDataRegion';
  3118. function DestroyHRC;                    external penwin32 name 'DestroyHRC';
  3119. function DestroyHRCRESULT;              external penwin32 name 'DestroyHRCRESULT';
  3120. function DestroyHWL;                    external penwin32 name 'DestroyHWL';
  3121. function DestroyInkset;                 external penwin32 name 'DestroyInkset';
  3122. function DestroyPenData;                external penwin32 name 'DestroyPenData';
  3123. function DoDefaultPenInput;             external penwin32 name 'DoDefaultPenInput';
  3124. function DPtoTP;                        external penwin32 name 'DPtoTP';
  3125. function DrawPenDataEx;                 external penwin32 name 'DrawPenDataEx';
  3126. function DuplicatePenData;              external penwin32 name 'DuplicatePenData';
  3127. function EnableGestureSetHRC;           external penwin32 name 'EnableGestureSetHRC';
  3128. function EnableSystemDictionaryHRC;     external penwin32 name 'EnableSystemDictionaryHRC';
  3129. function EndPenInputHRC;                external penwin32 name 'EndPenInputHRC';
  3130. function ExtractPenDataPoints;          external penwin32 name 'ExtractPenDataPoints';
  3131. function ExtractPenDataStrokes;         external penwin32 name 'ExtractPenDataStrokes';
  3132. function GetAlphabetHRC;                external penwin32 name 'GetAlphabetHRC';
  3133. function GetAlphabetPriorityHRC;        external penwin32 name 'GetAlphabetPriorityHRC';
  3134. function GetAlternateWordsHRCRESULT;    external penwin32 name 'GetAlternateWordsHRCRESULT';
  3135. function GetBoxMappingHRCRESULT;        external penwin32 name 'GetBoxMappingHRCRESULT';
  3136. function GetBoxResultsHRC;              external penwin32 name 'GetBoxResultsHRC';
  3137. function GetGuideHRC;                   external penwin32 name 'GetGuideHRC';
  3138. function GetHotspotsHRCRESULT;          external penwin32 name 'GetHotspotsHRCRESULT';
  3139. function GetHRECFromHRC;                external penwin32 name 'GetHRECFromHRC';
  3140. function GetInksetInterval;             external penwin32 name 'GetInksetInterval';
  3141. function GetInksetIntervalCount;        external penwin32 name 'GetInksetIntervalCount';
  3142. function GetInternationalHRC;           external penwin32 name 'GetInternationalHRC';
  3143. function GetMaxResultsHRC;              external penwin32 name 'GetMaxResultsHRC';
  3144. function GetPenAppFlags;                external penwin32 name 'GetPenAppFlags';
  3145. function GetPenAsyncState;              external penwin32 name 'GetPenAsyncState';
  3146. function GetPenDataAttributes;          external penwin32 name 'GetPenDataAttributes';
  3147. function GetPenDataInfo;                external penwin32 name 'GetPenDataInfo';
  3148. function GetPenInput;                   external penwin32 name 'GetPenInput';
  3149. function GetPenMiscInfo;                external penwin32 name 'GetPenMiscInfo';
  3150. function GetPointsFromPenData;          external penwin32 name 'GetPointsFromPenData';
  3151. function GetResultsHRC;                 external penwin32 name 'GetResultsHRC';
  3152. function GetStrokeAttributes;           external penwin32 name 'GetStrokeAttributes';
  3153. function GetStrokeTableAttributes;      external penwin32 name 'GetStrokeTableAttributes';
  3154. function GetSymbolCountHRCRESULT;       external penwin32 name 'GetSymbolCountHRCRESULT';
  3155. function GetSymbolsHRCRESULT;           external penwin32 name 'GetSymbolsHRCRESULT';
  3156. function GetVersionPenWin;              external penwin32 name 'GetVersionPenWin';
  3157. function GetWordlistCoercionHRC;        external penwin32 name 'GetWordlistCoercionHRC';
  3158. function GetWordlistHRC;                external penwin32 name 'GetWordlistHRC';
  3159. function HitTestPenData;                external penwin32 name 'HitTestPenData';
  3160. function InsertPenData;                 external penwin32 name 'InsertPenData';
  3161. function InsertPenDataPoints;           external penwin32 name 'InsertPenDataPoints';
  3162. function InsertPenDataStroke;           external penwin32 name 'InsertPenDataStroke';
  3163. function InstallRecognizer;             external penwin32 name 'InstallRecognizer';
  3164. function IsPenEvent;                    external penwin32 name 'IsPenEvent';
  3165. function KKConvert;                     external penwin32 name 'KKConvert';
  3166. function MetricScalePenData;            external penwin32 name 'MetricScalePenData';
  3167. function OffsetPenData;                 external penwin32 name 'OffsetPenData';
  3168. function PeekPenInput;                  external penwin32 name 'PeekPenInput';
  3169. function PenDataFromBuffer;             external penwin32 name 'PenDataFromBuffer';
  3170. function PenDataToBuffer;               external penwin32 name 'PenDataToBuffer';
  3171. function ProcessHRC;                    external penwin32 name 'ProcessHRC';
  3172. function ReadHWL;                       external penwin32 name 'ReadHWL';
  3173. function RedisplayPenData;              external penwin32 name 'RedisplayPenData';
  3174. function RemovePenDataStrokes;          external penwin32 name 'RemovePenDataStrokes';
  3175. function ResizePenData;                 external penwin32 name 'ResizePenData';
  3176. function SetAlphabetHRC;                external penwin32 name 'SetAlphabetHRC';
  3177. function SetAlphabetPriorityHRC;        external penwin32 name 'SetAlphabetPriorityHRC';
  3178. function SetBoxAlphabetHRC;             external penwin32 name 'SetBoxAlphabetHRC';
  3179. function SetGuideHRC;                   external penwin32 name 'SetGuideHRC';
  3180. function SetInternationalHRC;           external penwin32 name 'SetInternationalHRC';
  3181. function SetMaxResultsHRC;              external penwin32 name 'SetMaxResultsHRC';
  3182. function SetPenAppFlags;                external penwin32 name 'SetPenAppFlags';
  3183. function SetPenMiscInfo;                external penwin32 name 'SetPenMiscInfo';
  3184. function SetResultsHookHREC;            external penwin32 name 'SetResultsHookHREC';
  3185. function SetStrokeAttributes;           external penwin32 name 'SetStrokeAttributes';
  3186. function SetStrokeTableAttributes;      external penwin32 name 'SetStrokeTableAttributes';
  3187. function SetWordlistCoercionHRC;        external penwin32 name 'SetWordlistCoercionHRC';
  3188. function SetWordlistHRC;                external penwin32 name 'SetWordlistHRC';
  3189. function StartInking;                   external penwin32 name 'StartInking';
  3190. function StartPenInput;                 external penwin32 name 'StartPenInput';
  3191. function StopInking;                    external penwin32 name 'StopInking';
  3192. function StopPenInput;                  external penwin32 name 'StopPenInput';
  3193. function SymbolToCharacter;             external penwin32 name 'SymbolToCharacter';
  3194. function TargetPoints;                  external penwin32 name 'TargetPoints';
  3195. function TPtoDP;                        external penwin32 name 'TPtoDP';
  3196. function TrainHREC;                     external penwin32 name 'TrainHREC';
  3197. function TrimPenData;                   external penwin32 name 'TrimPenData';
  3198. function UnhookResultsHookHREC;         external penwin32 name 'UnhookResultsHookHREC';
  3199. function UninstallRecognizer;           external penwin32 name 'UninstallRecognizer';
  3200. function WriteHWL;                      external penwin32 name 'WriteHWL';
  3201.  
  3202. function FPenUpX(X: Integer): BOOL;
  3203. begin
  3204.   Result := (X and BITPENUP) <> 0;
  3205. end;
  3206.  
  3207. function GetWEventRef: Word;
  3208. begin
  3209.   Result := Word(GetMessageExtraInfo);
  3210. end;
  3211.  
  3212. function MpAlcB(lprc: PRC; i: Word): PByte;
  3213. begin
  3214.   Result := @lprc^.rgbfAlc[ (i and $FF) shr 3 ];
  3215. end;
  3216.  
  3217. function MpIbf(i: Word): Byte;
  3218. begin
  3219.   Result := 1 shl (i and 7);
  3220. end;
  3221.  
  3222. procedure SetAlcBitAnsi(lprc: PRC; i: Word);
  3223. var
  3224.   P: PByte;
  3225. begin
  3226.   P := MpAlcB(lprc, i);
  3227.   P^ := P^ or MpIbf(i);
  3228. end;
  3229.  
  3230. procedure ResetAlcBitAnsi(lprc: PRC; i: Word);
  3231. var
  3232.   P: PByte;
  3233. begin
  3234.   P := MpAlcB(lprc, i);
  3235.   P^ := P^ and not MpIbf(i);
  3236. end;
  3237.  
  3238. function IsAlcBitAnsi(lprc: PRC; i: Word): Boolean;
  3239. begin
  3240.   Result := MpAlcB(lprc,i)^ and MpIbf(i) <> 0;
  3241. end;
  3242.  
  3243. function DrawPenDataFmt(hdc: HDC; lprect: PRect; hpndt: THandle): Integer;
  3244. begin
  3245.   Result := DrawPenDataEx(hdc, lprect, hpndt, 0, IX_END, 0, IX_END, nil, nil, 0);
  3246. end;
  3247.  
  3248. function dwDiffAT(at1, at2: TAbsTime): Integer;
  3249. begin
  3250.   Result := 1000 * (at2.sec - at1.sec) - (at1.ms + at2.ms);
  3251. end;
  3252.  
  3253. function FLTAbsTime(at1, at2: TAbsTime): Boolean;
  3254. begin
  3255.   Result := (at1.sec < at2.sec) or ((at1.sec = at2.sec) and (at1.ms < at2.ms));
  3256. end;
  3257.  
  3258. function FLTEAbsTime(at1, at2: TAbsTime): Boolean;
  3259. begin
  3260.   Result := (at1.sec < at2.sec) or ((at1.sec = at2.sec) and (at1.ms <= at2.ms));
  3261. end;
  3262.  
  3263. function FEQAbsTime(at1, at2: TAbsTime): Boolean;
  3264. begin
  3265.   Result := (at1.sec = at2.sec) and (at1.ms = at2.ms);
  3266. end;
  3267.  
  3268. function FAbsTimeInInterval(at: TAbsTime; lpi: PInterval): Boolean;
  3269. begin
  3270.   Result := FLTEAbsTime(lpi^.atBegin, at) and FLTEAbsTime(at, lpi^.atEnd);
  3271. end;
  3272.  
  3273. function FIntervalInInterval(lpiT, lpiS: PInterval): Boolean;
  3274. begin
  3275.   Result := FLTEAbsTime(lpiS^.atBegin, lpiT^.atBegin) and
  3276.     FLTEAbsTime(lpiT^.atEnd, lpiS^.atEnd);
  3277. end;
  3278.  
  3279. function FIntervalXInterval(lpiT, lpiS: PInterval): Boolean;
  3280. begin
  3281.   Result := (not FLTAbsTime(lpiT^.atEnd, lpiS^.atBegin)) or
  3282.      FLTAbsTime(lpiS^.atEnd, lpiT^.atBegin);
  3283. end;
  3284.  
  3285. function dwDurInterval(lpi: PInterval): Integer;
  3286. begin
  3287.   Result := dwDiffAT(lpi^.atBegin, lpi^.atEnd);
  3288. end;
  3289.  
  3290. procedure MakeAbsTime(var lpat: TAbsTime; sec, ms: Integer);
  3291. begin
  3292.   lpat.sec := sec + ms div 1000;
  3293.   lpat.ms := ms mod 1000;
  3294. end;
  3295.  
  3296. function FIsSpecial(syv: DWORD): Boolean;
  3297. begin
  3298.   Result := HiWord(syv) = SYVHI_SPECIAL;
  3299. end;
  3300.  
  3301. function FIsAnsi(syv: DWORD): Boolean;
  3302. begin
  3303.   Result := HiWord(syv) = SYVHI_ANSI;
  3304. end;
  3305.  
  3306. function FIsGesture(syv: DWORD): Boolean;
  3307. begin
  3308.   Result := HiWord(syv) = SYVHI_GESTURE;
  3309. end;
  3310.  
  3311. function FIsKanji(syv: DWORD): Boolean;
  3312. begin
  3313.   Result := HiWord(syv) = SYVHI_KANJI;
  3314. end;
  3315.  
  3316. function FIsShape(syv: DWORD): Boolean;
  3317. begin
  3318.   Result := HiWord(syv) = SYVHI_SHAPE;
  3319. end;
  3320.  
  3321. function FIsUniCode(syv: DWORD): Boolean;
  3322. begin
  3323.   Result := HiWord(syv) = SYVHI_UNICODE;
  3324. end;
  3325.  
  3326. function FIsVKey(syv: DWORD): Boolean;
  3327. begin
  3328.   Result := HiWord(syv) = SYVHI_VKEY;
  3329. end;
  3330.  
  3331. function ChSyvToAnsi(syv: DWORD): Byte;
  3332. begin
  3333.   Result := Byte(LOWORD(syv));
  3334. end;
  3335.  
  3336. function WSyvToKanji(syv: DWORD): Word;
  3337. begin
  3338.   Result := LOWORD(syv);
  3339. end;
  3340.  
  3341. function SyvCharacterToSymbol(c: Char): DWORD;
  3342. begin
  3343.   Result := Byte(c) or $10000;
  3344. end;
  3345.  
  3346. function SyvKanjiToSymbol(c: Char): DWORD;
  3347. begin
  3348.   Result := Byte(c) or $30000;
  3349. end;
  3350.  
  3351. function FIsSelectGesture(syv: DWORD): Boolean;
  3352. begin
  3353.   Result := (syv >= SYV_SELECTFIRST) and (syv <= SYV_SELECTLAST);
  3354. end;
  3355.  
  3356. function FIsStdGesture(syv: DWORD): Boolean;
  3357. begin
  3358.   Result := FIsSelectGesture(syv) or (syv = SYV_CLEAR) or (syv = SYV_HELP) or
  3359.     (syv = SYV_EXTENDSELECT) or (syv = SYV_UNDO) or (syv = SYV_COPY) or
  3360.     (syv = SYV_CUT) or (syv = SYV_PASTE) or (syv = SYV_CLEARWORD) or
  3361.     (syv = SYV_KKCONVERT) or (syv = SYV_USER) or (syv = SYV_CORRECT);
  3362. end;
  3363.  
  3364. function FIsAnsiGesture(syv: DWORD): Boolean;
  3365. begin
  3366.   Result := (syv = SYV_BACKSPACE) or (syv = SYV_TAB) or
  3367.     (syv = SYV_RETURN) or (syv = SYV_SPACE);
  3368. end;
  3369.  
  3370. function SubPenMsgFromWpLp(wp, lp: DWORD): Word;
  3371. begin
  3372.   Result := LOWORD(wp);
  3373. end;
  3374.  
  3375. function EventRefFromWpLp(wp, lp: DWORD): Word;
  3376. begin
  3377.   Result := HiWord(wp);
  3378. end;
  3379.  
  3380. function TerminationFromWpLp(wp, lp: DWORD): Integer;
  3381. begin
  3382.   Result := HiWord(wp);
  3383. end;
  3384.  
  3385. function HpcmFromWpLp(wp, lp: DWORD): Integer;
  3386. begin
  3387.   Result := HPCM(lp);
  3388. end;
  3389.  
  3390. function HwndFromHtrg(trg: HTRG): HWND;
  3391. begin
  3392.   Result := HWND(trg);
  3393. end;
  3394.  
  3395. function HtrgFromHwnd(hwnd: HWND): HTRG;
  3396. begin
  3397.   Result := HTRG(hwnd);
  3398. end;
  3399.  
  3400. end.
  3401.