home *** CD-ROM | disk | FTP | other *** search
/ Stars of Shareware: Programmierung / SOURCE.mdf / programm / msdos / c / txcl552 / inc / tcxlwin.h < prev   
Encoding:
C/C++ Source or Header  |  1991-03-15  |  19.6 KB  |  322 lines
  1. /*=====[ The TesSeRact(TM) CXL User Interface Development System ]======*
  2.  | Copyright (c) 1987-1991, Innovative Data Concepts, Inc.
  3.  | All Rights Reserved.
  4.  |
  5.  | This Library is part of IDC's TesSeRact Development Tools product
  6.  | line. For information about other IDC products, call  1-215-443-9705.
  7.  *-V--------------------------------------------------------------------*
  8.  | $Header:   tcxlwin.h     552.0   17 Mar 1991 18:27:00  $
  9.  |
  10.  | $Log:   tcxlwin.h    $
  11.  *-D--------------------------------------------------------------------*
  12.  | <TCXLwin.h> : Definitions and prototypes for TCXL window-system.
  13.  *-N-----------------------[ Notes and Caveats ]------------------------*
  14.  | 1) Included by: <TCXLent.h>, <TCXLhlp.h>, <TCXLmnu.h>, <TCXLsel.h>
  15.  | 2) To open an e*x*p*l*o*d*i*n*g window, OR the BOX_EXP bit with the
  16.  |    <bt> argument to Wopen() or WpopUp().
  17.  | 3) [A] indicates active window in function prototype comments.
  18.  | 4) Functions marked internal are not for public use!
  19.  *======================================================================*/
  20. #ifndef  _TCXLwin_
  21. #  define   _TCXLwin_ 1
  22. #  ifndef   _TCXLvid_
  23. #    include <TCXLvid.h>               /* video definitions             */
  24. #  endif
  25. #  ifndef   _TCXLerr_
  26. #    include <TCXLerr.h>               /* error definitions             */
  27. #  endif
  28.                                        /*- Frame (border) sides --------*/
  29. #define  BRD_TOP  0x00                 /* Top                           */
  30. #define  BRD_BOT  0x01                 /* Bottom                        */
  31. #define  BRD_LFT  0x02                 /* Left                          */
  32. #define  BRD_RGT  0x03                 /* Right                         */
  33.                                        /*- Wcenter(), WpopUp() flags ---*/
  34. #define  CNT_HOR  0x01                 /* Horizontal                    */
  35. #define  CNT_VER  0x02                 /* Vertical                      */
  36. #define  CNT_CNT  0x03                 /* Both                          */
  37.                                        /*- Direction codes -------------*/
  38. #define  DIR_DWN  0x00                 /* Down                          */
  39. #define  DIR_UP   0x01                 /* Up                            */
  40. #define  DIR_LFT  0x02                 /* Left                          */
  41. #define  DIR_RGT  0x03                 /* Right                         */
  42.                                        /*- Wtitle() positions ----------*/
  43. #define  TTL_LFT  0x01                 /* Left                          */
  44. #define  TTL_CNT  0x02                 /* Center                        */
  45. #define  TTL_RGT  0x03                 /* Right                         */
  46.                                        /*- error-return macros ---------*/
  47.  
  48. /*------------------[ Data objects and access macros ]------------------*/
  49.  
  50. TYP   struct   _Box  BoxT,  *BoxP;     /* Object and pointer types      */
  51. TYP   struct   _Ttl  TtlT,  *Ttlp;
  52. TYP   struct   _Wctl WctlT, *WctlP;
  53. TYP   struct   _Wdf  WdfT,  *WdfP;
  54.  
  55. struct   _Box                 /*-[ Window-frame object ]----------------*/
  56. {  BytT  btyp;                /* 00|00 : BoxTyp : Type                  */
  57.    BytT  batr;                /* 01|01 : BoxAtr : Attribute             */
  58. };                            /* 02|02 ]--------------------------------*/
  59. #define  BoxTyp(b)   ((b).btyp)
  60. #define  BoxAtr(b)   ((b).batr)
  61.  
  62. struct   _Ttl                 /*-[ Window-title object ]----------------*/
  63. {  ChrP  tstr;                /* 00|00 : TtlStr : String                */
  64.    BytT  tpos;                /* 02|04 : TtlPos : Position              */
  65.    AtrT  tatr;                /* 03|05 : TtlAtr : Attribute             */
  66. };                            /* 04|06 ]--------------------------------*/
  67. #define  TtlStr(t)   ((t).tstr)
  68. #define  TtlPos(t)   ((t).tpos)
  69. #define  TtlAtr(t)   ((t).tatr)
  70.  
  71. struct   _Wctl                /*-[ Window-control object ]--------------*/
  72. {  WdfP  wact;                /* 00|00 : WctlAct : Active window        */
  73.    WdfP  whid;                /* 02|04 : WctlHid : Top hidden window    */
  74.    VOID  (CTYP *wfun)         /* 04|08 : WctlFun : Fill-function        */
  75.       (WrdT, WrdT, ChrT, AtrT);
  76.    WndT  whdl;                /* 06|0C : WctlHdl : Last handle assigned */
  77.    TagT  whlp;                /* 08|0E : WctlHlp : Help category        */
  78.    IntT  wopn;                /* 0A|10 : WctlOpn : Total open windows   */
  79.    BytT  wesc;                /* 0C|12 : WctlEsc : [Esc] check ? 1 : 0  */
  80.    BytT  wtab;                /* 0D|13 : WctlTab : TTY output tab width */
  81.    BytT  wfil;                /* 0E|14 : WctlFil : Fill character       */
  82.    BytT  wflg;                /* 0F|15 : WctlFlg : Internal flag byte   */
  83. };                            /* 10|16 ]--------------------------------*/
  84.  
  85. GBL   WctlT CDC   _WinCtl;    /*- Global window-control object ---------*/
  86. #define  WctlAct  (_WinCtl.wact)                /* Active window        */
  87. #define  WctlHid  (_WinCtl.whid)                /* Top hidden window    */
  88. #define  WctlFun  (_WinCtl.wfun)                /* Fill function        */
  89. #define  WctlHdl  (_WinCtl.whdl)                /* Last handle          */
  90. #define  WctlHlp  (_WinCtl.whlp)                /* Help category        */
  91. #define  WctlOpn  (_WinCtl.wopn)                /* Total open           */
  92. #define  WctlEsc  (_WinCtl.wesc)                /* [Esc] check          */
  93. #define  WctlTab  (_WinCtl.wtab)                /* Tab width            */
  94. #define  WctlFil  (_WinCtl.wfil)                /* Fill char            */
  95. #define  WctlFlg  (_WinCtl.wflg)                /* Internal flag byte   */
  96.  
  97. struct   _Wdf                 /*-[ Window-definition object ]-----------*/
  98. {  WdfP  wprv;                /* 00|00 : WdfPrv : Previous window       */
  99.    WdfP  wnxt;                /* 02|04 : WdfNxt : Next window           */
  100.    VcelP wbfr;                /* 04|08 : WdfBfr : Buffer                */
  101.    VcelP wsbf;                /* 06|0C : WdfSbf : Shadow buffer         */
  102.    TtlT  wttl;                /* 08|10 : WdfTtl : Title                 */
  103.    WndT  whdl;                /* 0C|14 : WdfHdl : Handle                */
  104.    TagT  whlp;                /* 0E|16 : WdfHlp : Help category         */
  105.    VposT wbeg;                /* 10|18 : WdfBeg : Start position        */
  106.    VposT wend;                /* 12|1A : WdfEnd : End position          */
  107.    VposT wmin;                /* 14|1C : WdfMin : Minimum position      */
  108.    VposT wmax;                /* 16|1E : WdfMax : Maximum position      */
  109.    VposT wpos;                /* 18|20 : WdfPos : Cursor position       */
  110.    BoxT  wfrm;                /* 1A|22 : WdfFrm : Frame                 */
  111.    AtrT  wdat;                /* 1C|24 : WdfDat : Default attribute     */
  112.    AtrT  wcat;                /* 1D|25 : WdfCat : Current attribute     */
  113.    AtrT  wsat;                /* 1E|26 : WdfSat : Shadow attribute      */
  114.    BytT  wflg;                /* 1F|27 : WdfFlg : Internal flags        */
  115. };                            /* 20|28 ]--------------------------------*/
  116.  
  117. #define  WdfPrv(w)   ((w)->wprv)                /* Previous window      */
  118. #define  WdfNxt(w)   ((w)->wnxt)                /* Next window          */
  119. #define  WdfBfr(w)   ((w)->wbfr)                /* Buffer               */
  120. #define  WdfSbf(w)   ((w)->wsbf)                /* Shadow buffer        */
  121. #define  WdfTtl(w)   ((w)->wttl)                /* Title                */
  122. #define  WdfTtlS(w)  (TtlStr(WdfTtl(w)))           /* String            */
  123. #define  WdfTtlP(w)  (TtlPos(WdfTtl(w)))           /* Position          */
  124. #define  WdfTtlA(w)  (TtlAtr(WdfTtl(w)))           /* Attribute         */
  125. #define  WdfHdl(w)   ((w)->whdl)                /* Handle               */
  126. #define  WdfHlp(w)   ((w)->whlp)                /* Help category        */
  127. #define  WdfBeg(w)   ((w)->wbeg)                /* Start position       */
  128. #define  WdfBegW(w)  (VposW(WdfBeg(w)))            /* Word              */
  129. #define  WdfBegC(w)  (VposC(WdfBeg(w)))            /* Col               */
  130. #define  WdfBegR(w)  (VposR(WdfBeg(w)))            /* Row               */
  131. #define  WdfEnd(w)   ((w)->wend)                /* End position         */
  132. #define  WdfEndW(w)  (VposW(WdfEnd(w)))            /* Word              */
  133. #define  WdfEndC(w)  (VposC(WdfEnd(w)))            /* Col               */
  134. #define  WdfEndR(w)  (VposR(WdfEnd(w)))            /* Row               */
  135. #define  WdfMin(w)   ((w)->wmin)                /* Minimum position     */
  136. #define  WdfMinW(w)  (VposW(WdfMin(w)))            /* Word              */
  137. #define  WdfMinC(w)  (VposC(WdfMin(w)))            /* Col               */
  138. #define  WdfMinR(w)  (VposR(WdfMin(w)))            /* Row               */
  139. #define  WdfMax(w)   ((w)->wmax)                /* Maximum position     */
  140. #define  WdfMaxW(w)  (VposW(WdfMax(w)))            /*    Word           */
  141. #define  WdfMaxC(w)  (VposC(WdfMax(w)))            /*    Col            */
  142. #define  WdfMaxR(w)  (VposR(WdfMax(w)))            /*    Row            */
  143. #define  WdfPos(w)   ((w)->wpos)                /* Cursor position      */
  144. #define  WdfPosW(w)  (VposW(WdfPos(w)))            /*    Word           */
  145. #define  WdfPosC(w)  (VposC(WdfPos(w)))            /*    Col            */
  146. #define  WdfPosR(w)  (VposR(WdfPos(w)))            /*    Row            */
  147. #define  WdfFrm(w)   ((w)->wfrm)                /* Frame (border)       */
  148. #define  WdfFrmT(w)  (BoxTyp(WdfFrm(w)))           /* Type              */
  149. #define  WdfFrmA(w)  (BoxAtr(WdfFrm(w)))           /* Attribute         */
  150. #define  WdfDat(w)   ((w)->wdat)                /* Default attribute    */
  151. #define  WdfCat(w)   ((w)->wcat)                /* Current attribute    */
  152. #define  WdfSat(w)   ((w)->wsat)                /* Shadow attribute     */
  153. #define  WdfFlg(w)   ((w)->wflg)                /* Internal flag byte   */
  154. #define  WdfUse(w)   (WdfFlg(w) & 0x0F)            /* Window usage      */
  155. #define  WdfUwin(w)  (0x00 == WdfUse(w))              /* Vanilla        */
  156. #define  WdfUmnu(w)  (0x01 == (WdfUse(w))             /* Menu           */
  157. #define  WdfUent(w)  (0x02 == (WdfUse(w))             /* Entry-form     */
  158. #define  WdfUsel(w)  (0x04 == (WdfUse(w))             /* Selection-list */
  159. #define  WdfUhlp(w)  (0x08 == (WdfUse(w))             /* Help           */
  160. #define  WdfBrd(w)   (WdfBegW(w) != WdfMinW(w)) /* Border flag          */
  161.  
  162. /*------------------------[ Function prototypes ]-----------------------*/
  163.  
  164. #ifdef   __cplusplus                   /* No mangling, please           */
  165.    extern "C" {
  166. #endif
  167.                               /*- General window functions -------------*/
  168. IntT  CTYP  Wactiv(WndT wh);           /* Activate window <wh>          */
  169. IntT  CTYP  WcloseAll(NOARG);          /* Close all windows             */
  170. ChrP  CTYP  WerrMsg(NOARG);            /* get error-message text        */
  171. VOID  CTYP  Werror(NOARG);             /* exit with error-message       */
  172. WndT  CTYP  Windowat(IntT sr,          /* Handle of window at <sr,sc>   */
  173.    IntT sc);
  174. WdfP  CTYP  WinLoc(WndT wh);           /* Find window by handle <wh>    */
  175. IntT        Wisactiv(WndT a);          /* Test for active handle        */
  176. WndT  CTYP  Wopen(IntT sr, IntT sc,    /* Open window                   */
  177.    IntT er, IntT ec, BytT bt, AtrT ba, AtrT wa);
  178. IntT  CTYP  Wperror(ChrP mp);          /* Display error window          */
  179. WndT  CTYP  WpopUp(IntT cf, IntT sr,   /* Open centered window          */
  180.    IntT sc, IntT er, IntT ec, BytT bt, AtrT ba, AtrT wa);
  181. VOID  CTYP  Wrestore(VcelP wb);        /* Restore saved window          */
  182. VcelP CTYP  Wsave(IntT sr, IntT sc,    /* Save window                   */
  183.    IntT er, IntT ec);
  184. VOID  CTYP  Wpop(VcelP wb,             /* Restore saved window to new   */
  185.    IntT sr, IntT sc, IntT er, IntT ec);   /* screen position            */
  186. VcelP       Wpush(IntT sr, IntT sc,    /* Save window (alias)           */
  187.    IntT er, IntT ec);
  188. VOID  CTYP  WsetEsc(FlgT a);           /* Enable/Disable [Esc] key      */
  189. VOID        WsetFil(ChrT a);           /* Set fill char                 */
  190. VOID        WsetFun(                   /* Set fill function             */
  191.    VOID (CTYP *f)(WrdT, WrdT, ChrT, AtrT));
  192. VOID        WsetTab(BytT a);           /* Set tab-width                 */
  193. IntT  CTYP  WsetTxt(AtrT a);           /* Set text attr                 */
  194. IntT        Wunhide(WndT wh);          /* Unhide window <wh>            */
  195. IntT  CTYP  Wunlink(WndT wh);          /* Unlink window <wh>            */
  196. IntT  CTYP  Wwprints(WndT wh, BytT wr, /* Put string to window <wh>     */
  197.    BytT wc, AtrT at, ChrP ps);
  198.                               /*- Active window movement ---------------*/
  199. IntT  CTYP  Wcenter(BytT cf);          /* Center window on screen   [A] */
  200. IntT  CTYP  Wclose(NOARG);             /* Close window              [A] */
  201. WndT  CTYP  Wcopy(IntT nr, IntT nc);   /* Copy window               [A] */
  202. IntT  CTYP  Wdrag(BytT di);            /* Drag one row or col       [A] */
  203. IntT  CTYP  Wdump(NOARG);              /* Dump window to printer    [A] */
  204. WndT  CTYP  Whandle(NOARG);            /* Get active handle         [A] */
  205. IntT        Whide(NOARG);              /* Hide window               [A] */
  206. IntT  CTYP  Wmove(IntT sr, IntT sc);   /* Move window               [A] */
  207. IntT  CTYP  Wsize(IntT nr, IntT nc);   /* Resize window             [A] */
  208. IntT  CTYP  Wgrow(IntT nr, IntT nc);   /* Resize window             [A] */
  209. IntT  CTYP  Wslide(IntT sr, IntT sc);  /* Slide window              [A] */
  210. IntT  CTYP  Wstretch(IntT sr, IntT sc);/* Stretch window            [A] */
  211.                               /*- Active window-control ----------------*/
  212. IntT  CTYP  WchgAtr(AtrT ba, AtrT wa); /* Change window/border attr [A] */
  213. IntT        Wclear(NOARG);             /* Clear window to default   [A] */
  214. IntT  CTYP  WclrEol(NOARG);            /* Clear cursor to EOL       [A] */
  215. IntT  CTYP  WclrEos(NOARG);            /* Clear to end of window    [A] */
  216. IntT  CTYP  WclrWin(AtrT at);          /* Clear window              [A] */
  217. IntT        Wdepth(NOARG);             /* Depth of window           [A] */
  218. IntT  CTYP  WfilBox(BytT sr, BytT sc,  /* Fill region               [A] */
  219.    BytT er, BytT ec, ChrT ch, AtrT at);
  220. IntT        WlinDel(BytT wr, BytT di); /* Delete line               [A] */
  221. IntT        WlinIns(BytT wr, BytT di); /* Insert line               [A] */
  222. IntT  CTYP  WscrBox(BytT sr,           /* Scroll region             [A] */
  223.    BytT sc, BytT er, BytT ec, BytT nr, BytT di);
  224. IntT  CTYP  WscrWin(BytT nr, BytT di); /* Scroll window             [A] */
  225. IntT        Wwidth(NOARG);             /* Width of window           [A] */
  226.                               /*- Active border, box drawing -----------*/
  227. IntT  CTYP  Wborder(BytT bt);          /* Add border                [A] */
  228. IntT  CTYP  Wbprintc(BytT bd, BytT of, /* Put char/attr on border   [A] */
  229.    BytT at, ChrT ch);
  230. IntT  CTYP  WdrwBox(BytT sr, BytT sc,  /* Draw internal box         [A] */
  231.    BytT er, BytT ec, BytT bt, AtrT at);
  232. IntT  CTYP  WdrwHor(BytT sr, BytT sc,  /* Draw horizontal line      [A] */
  233.    BytT nc, BytT bt, AtrT at);
  234. IntT  CTYP  WdrwVer(BytT sr, BytT sc,  /* Draw vertical line        [A] */
  235.    BytT n, BytT bt, AtrT at);
  236. IntT  CTYP  Wmessage(ChrP ps, BytT bo, /* Put message on border     [A] */
  237.    BytT lo, AtrT at);
  238. IntT  CTYP  Wtitle(ChrP ps, BytT tp,   /* Put title on border       [A] */
  239.    AtrT ta);
  240.                               /*- Active window shadow -----------------*/
  241. IntT        Wshadoff(NOARG);           /* Remove shadow             [A] */
  242. IntT        Wshadow(AtrT at);          /* Add shadow                [A] */
  243.                               /*- Active window cursor -----------------*/
  244. VOID        WcurGet(VposT rc);         /* Get position              [A] */
  245. WrdT  CTYP  WcurGt_(NOARG);
  246. IntT        WcurPut(VposT rc);         /* Put cursor                [A] */
  247. IntT  CTYP  WcurPt_(WrdT rc);
  248. IntT  CTYP  Wgotoxy(BytT wr, BytT wc); /* Set position              [A] */
  249. IntT  CTYP  Wpgotoxy(BytT wr,          /* Provisional position      [A] */
  250.    BytT wc);
  251. VOID  CTYP  WposGet(IntP r, IntP c);   /* Get cursor position as <r,c>  */
  252.                               /*- Active Output / Current Cursor/Attrib */
  253. VOID  CTYP  WdupChr(ChrT ch, IntT nd); /* Put duplicated char       [A] */
  254. VOID  CTYP  WdupStr(ChrP ps, IntT nd); /* Put duplicated string     [A] */
  255. IntT  CTYP  WputCen(ChrP ps);          /* Put centered string       [A] */
  256. IntT  CTYP  WputFmt(ChrP fs, ChrP ps); /* Format-string output      [A] */
  257. VOID  CTYP  Wputc(ChrT ch);            /* Put char                  [A] */
  258. IntT  CDC   Wputf(ChrP fs, ...);       /* Put printf() string       [A] */
  259. VOID  CTYP  Wputs(ChrP ps);            /* Put string                [A] */
  260. VOID  CTYP  Wputns(ChrP ps, IntT wd);  /* Put limited string        [A] */
  261. IntT  CTYP  Wputrj(ChrP ps);           /* Right-justify string/attr [A] */
  262. IntT  CTYP  Wputsw(ChrP ps);           /* Put string with word-wrap [A] */
  263.                               /*- Active Output / Passed Cursor/Attrib -*/
  264. VOID  CTYP  WdupChrA(BytT wr, BytT wc, /* Put duplicated char/attr  [A] */
  265.    AtrT at, ChrT ch, IntT nd);
  266. VOID  CTYP  WdupStrA(BytT wr, BytT wc, /* Put duplicated str/attr   [A] */
  267.    AtrT at, ChrP ps, IntT nd);
  268. IntT  CTYP  WprtCen(BytT wr, AtrT at,  /* Put centered string/attr  [A] */
  269.    ChrP ps);
  270. IntT  CTYP  WprtFmt(BytT wr, BytT wc,  /* Format-string/attr output [A] */
  271.    AtrT at, ChrP fs, ChrP ps);
  272. IntT  CTYP  Wprtc(BytT wr, BytT wc,    /* Put char/attr             [A] */
  273.    AtrT at, ChrT ch);
  274. IntT  CDC   Wprtf(BytT wr, BytT wc,    /* Put printf() string/attr  [A] */
  275.    AtrT at, ChrP fs, ...);
  276. VOID  CTYP  Wprtns(BytT wr, BytT wc,   /* Put limited string/attr   [A] */
  277.    AtrT at, ChrP ps, IntT wd);
  278. IntT  CTYP  Wprtrj(BytT wr, BytT wc,   /* Right-justify string/attr [A] */
  279.    AtrT at, ChrP ps);
  280. IntT  CTYP  Wprts(BytT wr, BytT wc,    /* Put string/attr           [A] */
  281.    AtrT at, ChrP ps);
  282. IntT  CTYP  Wprtsw(BytT wr, BytT wc,   /* Put string/attr with wrap [A] */
  283.    AtrT at, ChrP ps);
  284.                               /*- Internals ----------------------------*/
  285. FlgT  CTYP  WchkBox(BytT sr, BytT sc, BytT er, BytT ec);
  286. FlgT  CTYP  WchkCol(BytT wc);
  287. FlgT  CTYP  WchkPos(BytT wr, BytT wc);
  288. FlgT  CTYP  WchkRow(BytT wr);
  289. VOID  CTYP  _WatrSet(WrdT p, AtrT at, IntT ln);
  290. IntT  CTYP  _Whide_(FlgT m, WndT h);
  291. VcelP CTYP  _WinBlk(WdfP w, WrdT c);
  292. VcelP CTYP  _WinPos(WdfP w, WrdT c);
  293. IntT  CTYP  _WlinDI_(BytT id, BytT wr, BytT di);
  294. VOID        _Woutp(VposT p, VcelP b, IntT l);
  295. VOID  CTYP  _Woutp_(WrdT p, VcelP b, IntT l);
  296. IntT  CTYP  _Wputl(ChrP tp);
  297. IntT  CTYP  _Wshadow_(FlgT m, AtrT at);
  298. VcelP CTYP  _WshBlk(WdfP w, WrdT c);
  299. VcelP CTYP  _WshPos(WdfP w, WrdT c, BytT s);
  300.                               /*- Implementation macros ----------------*/
  301. #define  Wclear()             (WclrWin(WdfDat(WctlAct)))
  302. #define  WcurGet(rc)          (VposW(rc)=WcurGt_())
  303. #define  WcurPut(rc)          (WcurPt_(VposW(rc)))
  304. #define  Wdepth()             MsInt(WdfMaxR(WctlAct)-WdfMinR(WctlAct))
  305. #define  Whide()              (_Whide_(1,0))
  306. #define  Wisactiv(a)          ((a)==WdfHdl(WctlAct))
  307. #define  WlinDel(wr,di)       (_WlinDI_(0,(wr),(di)))
  308. #define  WlinIns(wr,di)       (_WlinDI_(1,(wr),(di)))
  309. #define  Wpush(sr,sc,er,ec)   (Wsave((sr),(sc),(er),(ec))
  310. #define  WsetFil(a)           (WctlFil=(a))
  311. #define  WsetFun(f)           (WctlFun=(f))
  312. #define  WsetTab(a)           (WctlTab=(((a)==0)?1:(a)))
  313. #define  Wshadoff()           (_Wshadow_(0,0))
  314. #define  Wshadow(a)           (_Wshadow_(1,(a)))
  315. #define  Wunhide(h)           (_Whide_(0,(h)))
  316. #define  Wwidth()             MsInt(WdfMaxC(WctlAct)-WdfMinC(WctlAct))
  317. #define  _Woutp(p,b,l)        (_Woutp_(VposW(p),(b),(l)))
  318. #ifdef   __cplusplus
  319.    }
  320. #endif
  321. #endif   /*- _TCXLwin_ : End of TCXLwin.h ------------------------------*/
  322.