home *** CD-ROM | disk | FTP | other *** search
/ Nebula 1 (1993) / nebula.bin / SourceCode / MiniExamples / PerformanceTuning / Winfo / wwrap.c < prev    next >
Encoding:
C/C++ Source or Header  |  1993-01-19  |  15.6 KB  |  510 lines
  1. /* wwrap.c generated from wwrap.psw
  2.    by unix pswrap V1.009  Wed Apr 19 17:50:24 PDT 1989
  3.  */
  4.  
  5. #include <dpsclient/dpsfriends.h>
  6. #include <string.h>
  7.  
  8. #line 1 "wwrap.psw"
  9. /*
  10.  * Winfo
  11.  * by Paul S. Kleppner
  12.  *
  13.  * This program may be freely distributed, but not sold.
  14.  * It is provided without warranty of any kind, expressed or
  15.  * implied, as to its fitness for any particular use.
  16.  */
  17.  
  18. /*
  19.  * This file contains DPS wrappers for a number of
  20.  * functions which deal with windows.  We have to write our
  21.  * own wrappers because we are dealing with true DPS window numbers
  22.  * as known by the window server.  The appkit, and the standard wrappers,
  23.  * seem to use "logical" window numbers which are local to each app.
  24.  */
  25.  
  26. // Look up the window at the given location; returns its
  27. // number, and whether or not one was found.
  28. #line 29 "wwrap.c"
  29. void myFindWindow(float x, float y, int where, int initWin, float *lx, float *ly, int *winFound, int *didFind)
  30. {
  31.   typedef struct {
  32.     unsigned char tokenType;
  33.     unsigned char topLevelCount;
  34.     unsigned short nBytes;
  35.  
  36.     DPSBinObjReal obj0;
  37.     DPSBinObjReal obj1;
  38.     DPSBinObjGeneric obj2;
  39.     DPSBinObjGeneric obj3;
  40.     DPSBinObjGeneric obj4;
  41.     DPSBinObjGeneric obj5;
  42.     DPSBinObjGeneric obj6;
  43.     DPSBinObjGeneric obj7;
  44.     DPSBinObjGeneric obj8;
  45.     DPSBinObjGeneric obj9;
  46.     DPSBinObjGeneric obj10;
  47.     DPSBinObjGeneric obj11;
  48.     DPSBinObjGeneric obj12;
  49.     DPSBinObjGeneric obj13;
  50.     DPSBinObjGeneric obj14;
  51.     DPSBinObjGeneric obj15;
  52.     DPSBinObjGeneric obj16;
  53.     char obj17[10];
  54.     } _dpsQ;
  55.   static const _dpsQ _dpsStat = {
  56.     DPS_DEF_TOKENTYPE, 17, 150,
  57.     {DPS_LITERAL|DPS_REAL, 0, 0, 0},    /* param: x */
  58.     {DPS_LITERAL|DPS_REAL, 0, 0, 0},    /* param: y */
  59.     {DPS_LITERAL|DPS_INT, 0, 0, 0},    /* param: where */
  60.     {DPS_LITERAL|DPS_INT, 0, 0, 0},    /* param: initWin */
  61.     {DPS_EXEC|DPS_NAME, 0, 10, 136},    /* findwindow */
  62.     {DPS_LITERAL|DPS_INT, 0, 0, 3},
  63.     {DPS_EXEC|DPS_NAME, 0, DPSSYSNAME, 119},    /* printobject */
  64.     {DPS_LITERAL|DPS_INT, 0, 0, 2},
  65.     {DPS_EXEC|DPS_NAME, 0, DPSSYSNAME, 119},    /* printobject */
  66.     {DPS_LITERAL|DPS_INT, 0, 0, 0},
  67.     {DPS_EXEC|DPS_NAME, 0, DPSSYSNAME, 119},    /* printobject */
  68.     {DPS_LITERAL|DPS_INT, 0, 0, 1},
  69.     {DPS_EXEC|DPS_NAME, 0, DPSSYSNAME, 119},    /* printobject */
  70.     {DPS_LITERAL|DPS_INT, 0, 0, 0},
  71.     {DPS_LITERAL|DPS_INT, 0, 0, 4},
  72.     {DPS_EXEC|DPS_NAME, 0, DPSSYSNAME, 119},    /* printobject */
  73.     {DPS_EXEC|DPS_NAME, 0, DPSSYSNAME, 70},    /* flush */
  74.     {'f','i','n','d','w','i','n','d','o','w'},
  75.     }; /* _dpsQ */
  76.   _dpsQ _dpsF;    /* local copy  */
  77.   register DPSContext _dpsCurCtxt = DPSPrivCurrentContext();
  78.   char pad[3];
  79.   register DPSBinObjRec *_dpsP = (DPSBinObjRec *)&_dpsF.obj0;
  80.   DPSResultsRec _dpsR[4];
  81.   static const DPSResultsRec _dpsRstat[] = {
  82.     { dps_tFloat, -1 },
  83.     { dps_tFloat, -1 },
  84.     { dps_tInt, -1 },
  85.     { dps_tBoolean, -1 },
  86.     };
  87.     _dpsR[0] = _dpsRstat[0];
  88.     _dpsR[0].value = (char *)lx;
  89.     _dpsR[1] = _dpsRstat[1];
  90.     _dpsR[1].value = (char *)ly;
  91.     _dpsR[2] = _dpsRstat[2];
  92.     _dpsR[2].value = (char *)winFound;
  93.     _dpsR[3] = _dpsRstat[3];
  94.     _dpsR[3].value = (char *)didFind;
  95.  
  96.   _dpsF = _dpsStat;    /* assign automatic variable */
  97.  
  98.   _dpsP[0].val.realVal = x;
  99.   _dpsP[1].val.realVal = y;
  100.   _dpsP[2].val.integerVal = where;
  101.   _dpsP[3].val.integerVal = initWin;
  102.   DPSSetResultTable(_dpsCurCtxt, _dpsR, 4);
  103.   DPSBinObjSeqWrite(_dpsCurCtxt,(char *) &_dpsF,150);
  104.   DPSAwaitReturnValues(_dpsCurCtxt);
  105.   if (0) *pad = 0;    /* quiets compiler warnings */
  106. }
  107. #line 25 "wwrap.psw"
  108.  
  109.  
  110. // Return alpha value for current window
  111. #line 112 "wwrap.c"
  112. void myCurrentWindowAlpha(int win, int *alpha)
  113. {
  114.   typedef struct {
  115.     unsigned char tokenType;
  116.     unsigned char topLevelCount;
  117.     unsigned short nBytes;
  118.  
  119.     DPSBinObjGeneric obj0;
  120.     DPSBinObjGeneric obj1;
  121.     DPSBinObjGeneric obj2;
  122.     DPSBinObjGeneric obj3;
  123.     DPSBinObjGeneric obj4;
  124.     DPSBinObjGeneric obj5;
  125.     DPSBinObjGeneric obj6;
  126.     DPSBinObjGeneric obj7;
  127.     char obj8[18];
  128.     } _dpsQ;
  129.   static const _dpsQ _dpsStat = {
  130.     DPS_DEF_TOKENTYPE, 8, 86,
  131.     {DPS_LITERAL|DPS_INT, 0, 0, 0},    /* param: win */
  132.     {DPS_EXEC|DPS_NAME, 0, 18, 64},    /* currentwindowalpha */
  133.     {DPS_LITERAL|DPS_INT, 0, 0, 0},
  134.     {DPS_EXEC|DPS_NAME, 0, DPSSYSNAME, 119},    /* printobject */
  135.     {DPS_LITERAL|DPS_INT, 0, 0, 0},
  136.     {DPS_LITERAL|DPS_INT, 0, 0, 1},
  137.     {DPS_EXEC|DPS_NAME, 0, DPSSYSNAME, 119},    /* printobject */
  138.     {DPS_EXEC|DPS_NAME, 0, DPSSYSNAME, 70},    /* flush */
  139.     {'c','u','r','r','e','n','t','w','i','n','d','o','w','a','l','p','h','a'},
  140.     }; /* _dpsQ */
  141.   _dpsQ _dpsF;    /* local copy  */
  142.   register DPSContext _dpsCurCtxt = DPSPrivCurrentContext();
  143.   char pad[3];
  144.   register DPSBinObjRec *_dpsP = (DPSBinObjRec *)&_dpsF.obj0;
  145.   DPSResultsRec _dpsR[1];
  146.   static const DPSResultsRec _dpsRstat[] = {
  147.     { dps_tInt, -1 },
  148.     };
  149.     _dpsR[0] = _dpsRstat[0];
  150.     _dpsR[0].value = (char *)alpha;
  151.  
  152.   _dpsF = _dpsStat;    /* assign automatic variable */
  153.  
  154.   _dpsP[0].val.integerVal = win;
  155.   DPSSetResultTable(_dpsCurCtxt, _dpsR, 1);
  156.   DPSBinObjSeqWrite(_dpsCurCtxt,(char *) &_dpsF,86);
  157.   DPSAwaitReturnValues(_dpsCurCtxt);
  158.   if (0) *pad = 0;    /* quiets compiler warnings */
  159. }
  160. #line 30 "wwrap.psw"
  161.  
  162.  
  163. // Return bounds of current window
  164. #line 165 "wwrap.c"
  165. void myCurrentWindowBounds(int win, float *x, float *y, float *w, float *h)
  166. {
  167.   typedef struct {
  168.     unsigned char tokenType;
  169.     unsigned char topLevelCount;
  170.     unsigned short nBytes;
  171.  
  172.     DPSBinObjGeneric obj0;
  173.     DPSBinObjGeneric obj1;
  174.     DPSBinObjGeneric obj2;
  175.     DPSBinObjGeneric obj3;
  176.     DPSBinObjGeneric obj4;
  177.     DPSBinObjGeneric obj5;
  178.     DPSBinObjGeneric obj6;
  179.     DPSBinObjGeneric obj7;
  180.     DPSBinObjGeneric obj8;
  181.     DPSBinObjGeneric obj9;
  182.     DPSBinObjGeneric obj10;
  183.     DPSBinObjGeneric obj11;
  184.     DPSBinObjGeneric obj12;
  185.     DPSBinObjGeneric obj13;
  186.     char obj14[19];
  187.     } _dpsQ;
  188.   static const _dpsQ _dpsStat = {
  189.     DPS_DEF_TOKENTYPE, 14, 135,
  190.     {DPS_LITERAL|DPS_INT, 0, 0, 0},    /* param: win */
  191.     {DPS_EXEC|DPS_NAME, 0, 19, 112},    /* currentwindowbounds */
  192.     {DPS_LITERAL|DPS_INT, 0, 0, 3},
  193.     {DPS_EXEC|DPS_NAME, 0, DPSSYSNAME, 119},    /* printobject */
  194.     {DPS_LITERAL|DPS_INT, 0, 0, 2},
  195.     {DPS_EXEC|DPS_NAME, 0, DPSSYSNAME, 119},    /* printobject */
  196.     {DPS_LITERAL|DPS_INT, 0, 0, 1},
  197.     {DPS_EXEC|DPS_NAME, 0, DPSSYSNAME, 119},    /* printobject */
  198.     {DPS_LITERAL|DPS_INT, 0, 0, 0},
  199.     {DPS_EXEC|DPS_NAME, 0, DPSSYSNAME, 119},    /* printobject */
  200.     {DPS_LITERAL|DPS_INT, 0, 0, 0},
  201.     {DPS_LITERAL|DPS_INT, 0, 0, 4},
  202.     {DPS_EXEC|DPS_NAME, 0, DPSSYSNAME, 119},    /* printobject */
  203.     {DPS_EXEC|DPS_NAME, 0, DPSSYSNAME, 70},    /* flush */
  204.     {'c','u','r','r','e','n','t','w','i','n','d','o','w','b','o','u','n','d','s'},
  205.     }; /* _dpsQ */
  206.   _dpsQ _dpsF;    /* local copy  */
  207.   register DPSContext _dpsCurCtxt = DPSPrivCurrentContext();
  208.   char pad[3];
  209.   register DPSBinObjRec *_dpsP = (DPSBinObjRec *)&_dpsF.obj0;
  210.   DPSResultsRec _dpsR[4];
  211.   static const DPSResultsRec _dpsRstat[] = {
  212.     { dps_tFloat, -1 },
  213.     { dps_tFloat, -1 },
  214.     { dps_tFloat, -1 },
  215.     { dps_tFloat, -1 },
  216.     };
  217.     _dpsR[0] = _dpsRstat[0];
  218.     _dpsR[0].value = (char *)x;
  219.     _dpsR[1] = _dpsRstat[1];
  220.     _dpsR[1].value = (char *)y;
  221.     _dpsR[2] = _dpsRstat[2];
  222.     _dpsR[2].value = (char *)w;
  223.     _dpsR[3] = _dpsRstat[3];
  224.     _dpsR[3].value = (char *)h;
  225.  
  226.   _dpsF = _dpsStat;    /* assign automatic variable */
  227.  
  228.   _dpsP[0].val.integerVal = win;
  229.   DPSSetResultTable(_dpsCurCtxt, _dpsR, 4);
  230.   DPSBinObjSeqWrite(_dpsCurCtxt,(char *) &_dpsF,135);
  231.   DPSAwaitReturnValues(_dpsCurCtxt);
  232.   if (0) *pad = 0;    /* quiets compiler warnings */
  233. }
  234. #line 36 "wwrap.psw"
  235.  
  236.  
  237.  
  238. // Return depth of current window
  239. #line 240 "wwrap.c"
  240. void myCurrentWindowDepth(int win, int *depth)
  241. {
  242.   typedef struct {
  243.     unsigned char tokenType;
  244.     unsigned char topLevelCount;
  245.     unsigned short nBytes;
  246.  
  247.     DPSBinObjGeneric obj0;
  248.     DPSBinObjGeneric obj1;
  249.     DPSBinObjGeneric obj2;
  250.     DPSBinObjGeneric obj3;
  251.     DPSBinObjGeneric obj4;
  252.     DPSBinObjGeneric obj5;
  253.     DPSBinObjGeneric obj6;
  254.     DPSBinObjGeneric obj7;
  255.     char obj8[18];
  256.     } _dpsQ;
  257.   static const _dpsQ _dpsStat = {
  258.     DPS_DEF_TOKENTYPE, 8, 86,
  259.     {DPS_LITERAL|DPS_INT, 0, 0, 0},    /* param: win */
  260.     {DPS_EXEC|DPS_NAME, 0, 18, 64},    /* currentwindowdepth */
  261.     {DPS_LITERAL|DPS_INT, 0, 0, 0},
  262.     {DPS_EXEC|DPS_NAME, 0, DPSSYSNAME, 119},    /* printobject */
  263.     {DPS_LITERAL|DPS_INT, 0, 0, 0},
  264.     {DPS_LITERAL|DPS_INT, 0, 0, 1},
  265.     {DPS_EXEC|DPS_NAME, 0, DPSSYSNAME, 119},    /* printobject */
  266.     {DPS_EXEC|DPS_NAME, 0, DPSSYSNAME, 70},    /* flush */
  267.     {'c','u','r','r','e','n','t','w','i','n','d','o','w','d','e','p','t','h'},
  268.     }; /* _dpsQ */
  269.   _dpsQ _dpsF;    /* local copy  */
  270.   register DPSContext _dpsCurCtxt = DPSPrivCurrentContext();
  271.   char pad[3];
  272.   register DPSBinObjRec *_dpsP = (DPSBinObjRec *)&_dpsF.obj0;
  273.   DPSResultsRec _dpsR[1];
  274.   static const DPSResultsRec _dpsRstat[] = {
  275.     { dps_tInt, -1 },
  276.     };
  277.     _dpsR[0] = _dpsRstat[0];
  278.     _dpsR[0].value = (char *)depth;
  279.  
  280.   _dpsF = _dpsStat;    /* assign automatic variable */
  281.  
  282.   _dpsP[0].val.integerVal = win;
  283.   DPSSetResultTable(_dpsCurCtxt, _dpsR, 1);
  284.   DPSBinObjSeqWrite(_dpsCurCtxt,(char *) &_dpsF,86);
  285.   DPSAwaitReturnValues(_dpsCurCtxt);
  286.   if (0) *pad = 0;    /* quiets compiler warnings */
  287. }
  288. #line 42 "wwrap.psw"
  289.  
  290.  
  291. // Returns owner (i.e. context value) for current window
  292. #line 293 "wwrap.c"
  293. void myCurrentOwner(int win, int *context)
  294. {
  295.   typedef struct {
  296.     unsigned char tokenType;
  297.     unsigned char topLevelCount;
  298.     unsigned short nBytes;
  299.  
  300.     DPSBinObjGeneric obj0;
  301.     DPSBinObjGeneric obj1;
  302.     DPSBinObjGeneric obj2;
  303.     DPSBinObjGeneric obj3;
  304.     DPSBinObjGeneric obj4;
  305.     DPSBinObjGeneric obj5;
  306.     DPSBinObjGeneric obj6;
  307.     DPSBinObjGeneric obj7;
  308.     char obj8[12];
  309.     } _dpsQ;
  310.   static const _dpsQ _dpsStat = {
  311.     DPS_DEF_TOKENTYPE, 8, 80,
  312.     {DPS_LITERAL|DPS_INT, 0, 0, 0},    /* param: win */
  313.     {DPS_EXEC|DPS_NAME, 0, 12, 64},    /* currentowner */
  314.     {DPS_LITERAL|DPS_INT, 0, 0, 0},
  315.     {DPS_EXEC|DPS_NAME, 0, DPSSYSNAME, 119},    /* printobject */
  316.     {DPS_LITERAL|DPS_INT, 0, 0, 0},
  317.     {DPS_LITERAL|DPS_INT, 0, 0, 1},
  318.     {DPS_EXEC|DPS_NAME, 0, DPSSYSNAME, 119},    /* printobject */
  319.     {DPS_EXEC|DPS_NAME, 0, DPSSYSNAME, 70},    /* flush */
  320.     {'c','u','r','r','e','n','t','o','w','n','e','r'},
  321.     }; /* _dpsQ */
  322.   _dpsQ _dpsF;    /* local copy  */
  323.   register DPSContext _dpsCurCtxt = DPSPrivCurrentContext();
  324.   char pad[3];
  325.   register DPSBinObjRec *_dpsP = (DPSBinObjRec *)&_dpsF.obj0;
  326.   DPSResultsRec _dpsR[1];
  327.   static const DPSResultsRec _dpsRstat[] = {
  328.     { dps_tInt, -1 },
  329.     };
  330.     _dpsR[0] = _dpsRstat[0];
  331.     _dpsR[0].value = (char *)context;
  332.  
  333.   _dpsF = _dpsStat;    /* assign automatic variable */
  334.  
  335.   _dpsP[0].val.integerVal = win;
  336.   DPSSetResultTable(_dpsCurCtxt, _dpsR, 1);
  337.   DPSBinObjSeqWrite(_dpsCurCtxt,(char *) &_dpsF,80);
  338.   DPSAwaitReturnValues(_dpsCurCtxt);
  339.   if (0) *pad = 0;    /* quiets compiler warnings */
  340. }
  341. #line 47 "wwrap.psw"
  342.  
  343.  
  344. // Sets level of current window
  345. #line 346 "wwrap.c"
  346. void mySetCurrentWindowLevel(int level)
  347. {
  348.   typedef struct {
  349.     unsigned char tokenType;
  350.     unsigned char topLevelCount;
  351.     unsigned short nBytes;
  352.  
  353.     DPSBinObjGeneric obj0;
  354.     DPSBinObjGeneric obj1;
  355.     DPSBinObjGeneric obj2;
  356.     char obj3[14];
  357.     char obj4[13];
  358.     } _dpsQ;
  359.   static const _dpsQ _dpsStat = {
  360.     DPS_DEF_TOKENTYPE, 3, 55,
  361.     {DPS_LITERAL|DPS_INT, 0, 0, 0},    /* param: level */
  362.     {DPS_EXEC|DPS_NAME, 0, 13, 38},    /* currentwindow */
  363.     {DPS_EXEC|DPS_NAME, 0, 14, 24},    /* setwindowlevel */
  364.     {'s','e','t','w','i','n','d','o','w','l','e','v','e','l'},
  365.     {'c','u','r','r','e','n','t','w','i','n','d','o','w'},
  366.     }; /* _dpsQ */
  367.   _dpsQ _dpsF;    /* local copy  */
  368.   register DPSContext _dpsCurCtxt = DPSPrivCurrentContext();
  369.   char pad[3];
  370.   register DPSBinObjRec *_dpsP = (DPSBinObjRec *)&_dpsF.obj0;
  371.   _dpsF = _dpsStat;    /* assign automatic variable */
  372.  
  373.   _dpsP[0].val.integerVal = level;
  374.   DPSBinObjSeqWrite(_dpsCurCtxt,(char *) &_dpsF,55);
  375.   if (0) *pad = 0;    /* quiets compiler warnings */
  376. }
  377. #line 52 "wwrap.psw"
  378.  
  379.  
  380. // Returns level of current window
  381. #line 382 "wwrap.c"
  382. void myCurrentWindowLevel(int win, int *level)
  383. {
  384.   typedef struct {
  385.     unsigned char tokenType;
  386.     unsigned char topLevelCount;
  387.     unsigned short nBytes;
  388.  
  389.     DPSBinObjGeneric obj0;
  390.     DPSBinObjGeneric obj1;
  391.     DPSBinObjGeneric obj2;
  392.     DPSBinObjGeneric obj3;
  393.     DPSBinObjGeneric obj4;
  394.     DPSBinObjGeneric obj5;
  395.     DPSBinObjGeneric obj6;
  396.     DPSBinObjGeneric obj7;
  397.     char obj8[12];
  398.     } _dpsQ;
  399.   static const _dpsQ _dpsStat = {
  400.     DPS_DEF_TOKENTYPE, 8, 80,
  401.     {DPS_LITERAL|DPS_INT, 0, 0, 0},    /* param: win */
  402.     {DPS_EXEC|DPS_NAME, 0, 12, 64},    /* currentowner */
  403.     {DPS_LITERAL|DPS_INT, 0, 0, 0},
  404.     {DPS_EXEC|DPS_NAME, 0, DPSSYSNAME, 119},    /* printobject */
  405.     {DPS_LITERAL|DPS_INT, 0, 0, 0},
  406.     {DPS_LITERAL|DPS_INT, 0, 0, 1},
  407.     {DPS_EXEC|DPS_NAME, 0, DPSSYSNAME, 119},    /* printobject */
  408.     {DPS_EXEC|DPS_NAME, 0, DPSSYSNAME, 70},    /* flush */
  409.     {'c','u','r','r','e','n','t','o','w','n','e','r'},
  410.     }; /* _dpsQ */
  411.   _dpsQ _dpsF;    /* local copy  */
  412.   register DPSContext _dpsCurCtxt = DPSPrivCurrentContext();
  413.   char pad[3];
  414.   register DPSBinObjRec *_dpsP = (DPSBinObjRec *)&_dpsF.obj0;
  415.   DPSResultsRec _dpsR[1];
  416.   static const DPSResultsRec _dpsRstat[] = {
  417.     { dps_tInt, -1 },
  418.     };
  419.     _dpsR[0] = _dpsRstat[0];
  420.     _dpsR[0].value = (char *)level;
  421.  
  422.   _dpsF = _dpsStat;    /* assign automatic variable */
  423.  
  424.   _dpsP[0].val.integerVal = win;
  425.   DPSSetResultTable(_dpsCurCtxt, _dpsR, 1);
  426.   DPSBinObjSeqWrite(_dpsCurCtxt,(char *) &_dpsF,80);
  427.   DPSAwaitReturnValues(_dpsCurCtxt);
  428.   if (0) *pad = 0;    /* quiets compiler warnings */
  429. }
  430. #line 57 "wwrap.psw"
  431.  
  432.  
  433. // Orders given window on the screen list
  434. #line 435 "wwrap.c"
  435. void myOrderWindow(int place, int otherwin, int win)
  436. {
  437.   typedef struct {
  438.     unsigned char tokenType;
  439.     unsigned char topLevelCount;
  440.     unsigned short nBytes;
  441.  
  442.     DPSBinObjGeneric obj0;
  443.     DPSBinObjGeneric obj1;
  444.     DPSBinObjGeneric obj2;
  445.     DPSBinObjGeneric obj3;
  446.     char obj4[11];
  447.     } _dpsQ;
  448.   static const _dpsQ _dpsStat = {
  449.     DPS_DEF_TOKENTYPE, 4, 47,
  450.     {DPS_LITERAL|DPS_INT, 0, 0, 0},    /* param: place */
  451.     {DPS_LITERAL|DPS_INT, 0, 0, 0},    /* param: otherwin */
  452.     {DPS_LITERAL|DPS_INT, 0, 0, 0},    /* param: win */
  453.     {DPS_EXEC|DPS_NAME, 0, 11, 32},    /* orderwindow */
  454.     {'o','r','d','e','r','w','i','n','d','o','w'},
  455.     }; /* _dpsQ */
  456.   _dpsQ _dpsF;    /* local copy  */
  457.   register DPSContext _dpsCurCtxt = DPSPrivCurrentContext();
  458.   char pad[3];
  459.   register DPSBinObjRec *_dpsP = (DPSBinObjRec *)&_dpsF.obj0;
  460.   _dpsF = _dpsStat;    /* assign automatic variable */
  461.  
  462.   _dpsP[0].val.integerVal = place;
  463.   _dpsP[1].val.integerVal = otherwin;
  464.   _dpsP[2].val.integerVal = win;
  465.   DPSBinObjSeqWrite(_dpsCurCtxt,(char *) &_dpsF,47);
  466.   if (0) *pad = 0;    /* quiets compiler warnings */
  467. }
  468. #line 62 "wwrap.psw"
  469.  
  470.  
  471.  
  472. // Fills window w2 with contents of all windows below level of w1
  473. #line 474 "wwrap.c"
  474. void fillBelowWin(int w1, int w2)
  475. {
  476.   typedef struct {
  477.     unsigned char tokenType;
  478.     unsigned char topLevelCount;
  479.     unsigned short nBytes;
  480.  
  481.     DPSBinObjGeneric obj0;
  482.     DPSBinObjGeneric obj1;
  483.     DPSBinObjGeneric obj2;
  484.     DPSBinObjGeneric obj3;
  485.     char obj4[10];
  486.     char obj5[5];
  487.     } _dpsQ;
  488.   static const _dpsQ _dpsStat = {
  489.     DPS_DEF_TOKENTYPE, 4, 51,
  490.     {DPS_EXEC|DPS_NAME, 0, 5, 42},    /* Below */
  491.     {DPS_LITERAL|DPS_INT, 0, 0, 0},    /* param: w1 */
  492.     {DPS_LITERAL|DPS_INT, 0, 0, 0},    /* param: w2 */
  493.     {DPS_EXEC|DPS_NAME, 0, 10, 32},    /* fillwindow */
  494.     {'f','i','l','l','w','i','n','d','o','w'},
  495.     {'B','e','l','o','w'},
  496.     }; /* _dpsQ */
  497.   _dpsQ _dpsF;    /* local copy  */
  498.   register DPSContext _dpsCurCtxt = DPSPrivCurrentContext();
  499.   char pad[3];
  500.   register DPSBinObjRec *_dpsP = (DPSBinObjRec *)&_dpsF.obj0;
  501.   _dpsF = _dpsStat;    /* assign automatic variable */
  502.  
  503.   _dpsP[1].val.integerVal = w1;
  504.   _dpsP[2].val.integerVal = w2;
  505.   DPSBinObjSeqWrite(_dpsCurCtxt,(char *) &_dpsF,51);
  506.   if (0) *pad = 0;    /* quiets compiler warnings */
  507. }
  508. #line 68 "wwrap.psw"
  509.  
  510.