home *** CD-ROM | disk | FTP | other *** search
/ PC World Komputer 2001 December / pcwk12201b.iso / Reklamy / CAD-Projekt / MegaCAD-4_5 / CC / MEGAIF.C_ / MEGAIF.C
C/C++ Source or Header  |  1996-09-27  |  31KB  |  998 lines
  1. /**********************************************************************/
  2.  
  3. #include "std.h"
  4. #include "megatyp.h"
  5. #include "megacad.h"
  6. #include "megapar.h"
  7.  
  8. /**********************************************************************/
  9. #if _MSC_VER == 700
  10. /**********************************************************************/
  11.  
  12. int FAR PASCAL WEP (
  13.         int nParameter)
  14. {
  15.     return (1);
  16. }   // C4100 (ignore warning 'unreferenced parameter')
  17.  
  18. /**********************************************************************/
  19.  
  20. int _far PASCAL LibMain (
  21.         HANDLE hInstance,
  22.         WORD   wDataSeg,
  23.         WORD   wHeapSize,
  24.         LPSTR  lpszCmdLine)
  25. {
  26.     return(1);
  27. }   // C4100 (ignore warning 'unreferenced parameter')
  28.  
  29. /**********************************************************************/
  30. #endif
  31. /**********************************************************************/
  32.  
  33. typedef ulong (_far _pascal _export *t_MegaCadIF)(t_MegaPars _far*,uint,uint);
  34.  
  35. typedef union
  36. {
  37.     struct
  38.     {
  39.         t_MegaCadIF fnIF;
  40.         uint        para;
  41.     } tp;
  42.     struct
  43.     {
  44.         char        _far *file;
  45.         char        _far *args;
  46.     } sm;
  47.     struct
  48.     {
  49.         tCallBack   func;
  50.         void        _far *data;
  51.     } cb;
  52. } t_para;
  53.  
  54. #define MI_CALLBACK   1
  55. #define MI_GETVERSION 2
  56. #define MI_TAKEPARA   3
  57. #define MI_STARTMAIN  4
  58.  
  59. /**********************************************************************/
  60.  
  61. static ulong _far _pascal IF_Dummy(
  62.         t_MegaPars _far *pars,
  63.         uint       megaptr,
  64.         uint       funcnum )
  65. {
  66.     return(0L);
  67. }   // C4100 (ignore warning 'unreferenced parameter')
  68.  
  69. /**********************************************************************/
  70.  
  71. static t_MegaCadIF MegaCAD_IF  = IF_Dummy;
  72. static uint        MegaCAD_ptr = 0;
  73.  
  74. extern short MegaMain(char*,char*);
  75.  
  76. #ifdef _WIN32
  77.     __declspec(dllexport) short __stdcall MegaCAD_Entry();
  78. #endif
  79.  
  80. /**********************************************************************/
  81. /* This function is the entry point that MegaCAD searches for, when   */
  82. /* having loaded the DLL.                                             */
  83. /**********************************************************************/
  84.  
  85. short _far _pascal _export MegaCAD_Entry(
  86.         uint   fCode,
  87.         t_para *par )
  88. {
  89.     switch ( fCode )
  90.     {
  91.         case MI_CALLBACK   :
  92.             // call the 'tCallBack' function with the given data pointer;
  93.             // this indirect way assures that only this function has to
  94.             // be '_export', not all the callback functions within the DLL.
  95.             return( par->cb.func(par->cb.data) );
  96.  
  97.         case MI_GETVERSION :
  98.             // return the version number of the MegaCAD interface
  99.             // the number must match the number of the MegaCAD .EXE
  100.             return( MI_VERSION );
  101.  
  102.         case MI_TAKEPARA   :
  103.             // save the MegaCAD entry function and parameter
  104.             MegaCAD_IF  = par->tp.fnIF;
  105.             MegaCAD_ptr = par->tp.para;
  106.             return(1);
  107.  
  108.         case MI_STARTMAIN  :
  109.             // call the 'MegaMain()' function of the DLL
  110.             return( MegaMain(par->sm.file,par->sm.args) );
  111.  
  112.     }
  113.     return(-1);
  114. }
  115.  
  116. /**********************************************************************/
  117. /* Local function, that calls the MegaCAD entry function.             */
  118. /**********************************************************************/
  119.  
  120. #if _MSC_VER >= 700 && _MSC_VER <= 800
  121.     #define _pSTACK _based(_segname("_STACK"))
  122. #else
  123.     #define _pSTACK
  124. #endif
  125.  
  126. static ulong _near _fastcall CallMegaCAD(
  127.         t_MegaPars _pSTACK *params,
  128.         uint       funcnum )
  129. {
  130.     return( MegaCAD_IF(params,MegaCAD_ptr,funcnum) );
  131. }
  132.  
  133. /**********************************************************************/
  134. #if defined ( _WIN32 )
  135. /**********************************************************************/
  136. /* In 32 bit DLL's there has to be an extra _matherr function!!!      */
  137. /* Especially 'atan2()' would produce floating point errors with two  */
  138. /* identical points.                                                  */
  139. /**********************************************************************/
  140.  
  141. int _matherr(
  142.         struct _exception *err )
  143. {
  144.     err->retval = 0.0;
  145.     return(1);
  146. }
  147.  
  148. /**********************************************************************/
  149. #endif   // _WIN32
  150. /**********************************************************************/
  151. /*--------------------------------------------------------------------*/
  152. /**********************************************************************/
  153. /* Function codes.                                                    */
  154. /**********************************************************************/
  155.  
  156. #define GET_PNT_INV            1
  157. #define DRAW_INV               2
  158. #define DLG_INPUT              3
  159. #define GET_FILENAME           4
  160. #define STORE_MULTIPLE         5
  161. #define MEGA_CMD               6
  162. #define MESSAGE                7
  163. #define MOUSE_HELP             8
  164. #define GET_PNT                9
  165. #define SAVECOUNT             10
  166. #define SET_FUNC_TEXT         11
  167. #define CREATE_ENTITY         12
  168. #define GET_TEXT_VAL          13
  169. #define READ_TXT_FILE         14
  170. #define ADD_POLYLN_PT         15
  171. #define ERASE_INV             16
  172. #define GET_DIM_VAL           17
  173. #define PRINT_DIM_VAL         18
  174. #define CLICK_ENTITY          19
  175. #define EX_CHANGE_ENTITY      20
  176. #define BLINK                 21
  177. #define ENTITY_LOOP           22
  178. #define DRAW_ENTITIES         23
  179. #define STRING_INPUT          24
  180. #define SELECT_INIT           25
  181. #define SELECT_LOOP           26
  182. #define INSERT_MACRO          27
  183. #define CALC_PATTERN          28
  184. #define DELETE_ENTITY         29
  185. #define GET_ENTITY            30
  186. #define SET_INC_PNT           31
  187. #define INFO_LOOP             32
  188. #define GET_INFO              33
  189. #define STORE_INFO            34
  190. #define EX_CHANGE_INFO        35
  191. #define GET_ATTRIBUTES        36
  192. #define GET_LAYER_BITS        37
  193. #define GET_GROUP_BITS        38
  194. #define GET_LAYER_NAMES       39
  195. #define GET_GROUP_NAMES       40
  196. #define GET_GRID_SETS         41
  197. #define SET_ATTRIBUTES        42
  198. #define SET_LAYER_BITS        43
  199. #define SET_GROUP_BITS        44
  200. #define SET_LAYER_NAMES       45
  201. #define SET_GROUP_NAMES       46
  202. #define SET_GRID_SETS         47
  203. #define GET_CURRENT_FILE      48
  204. #define CREATE_MACRO          49
  205. #define MACRO_LOOP            50
  206. #define CLICK_MACRO           51
  207. #define ENTITY_LEN            52
  208. #define PART_LIST             53
  209.  
  210. /**********************************************************************/
  211. /* The functions of the MegaCAD interface.                            */
  212. /**********************************************************************/
  213.  
  214. short GetPntInv(              // Get point and draw something with mouse move
  215.         double      *pkt,     // point to be filled in
  216.         short       setinc,   // incremental point to be set ?
  217.         tCallBack   func,     // callback function
  218.         void        *para)    // data pointer for callback function
  219. {
  220.     t_MegaPars params;
  221.  
  222.     params.m_GetPntInv.pkt    = pkt   ;
  223.     params.m_GetPntInv.setinc = setinc;
  224.     params.m_GetPntInv.func   = func  ;
  225.     params.m_GetPntInv.para   = para  ;
  226.  
  227.     return( (short) CallMegaCAD(¶ms,GET_PNT_INV) );
  228. }
  229.  
  230. /**********************************************************************/
  231.  
  232. void DrawInv(                 // draw and save a temporary object
  233.         ushort      type,     // type of entity to be drawn
  234.         void        *ptr,     // data of entity
  235.         ushort      lmode,    // line attributes (see LMODE)
  236.         ushort      atype)    // type to get attributes from
  237. {
  238.     t_MegaPars params;
  239.  
  240.     params.m_DrawInv.type  = type ;
  241.     params.m_DrawInv.ptr   = ptr  ;
  242.     params.m_DrawInv.lmode = lmode;
  243.     params.m_DrawInv.atype = atype;
  244.  
  245.     CallMegaCAD(¶ms,DRAW_INV);
  246. }
  247.  
  248. /**********************************************************************/
  249.  
  250. short DlgInput(               // input some values by dialog
  251.         ushort      num,      // number of fields (1 - 10)
  252.         char        *title,   // title string
  253.         t_dlgdta    *dta)     // array of field descriptors
  254. {
  255.     t_MegaPars params;
  256.  
  257.     params.m_DlgInput.num   = num  ;
  258.     params.m_DlgInput.title = title;
  259.     params.m_DlgInput.dta   = dta  ;
  260.  
  261.     return( (short) CallMegaCAD(¶ms,DLG_INPUT) );
  262. }
  263.  
  264. /**********************************************************************/
  265.  
  266. short GetFilename(            // let the user select a filename
  267.         char        *title,   // title string
  268.         char        *fname)   // filename; must be initialized with path
  269. {
  270.     t_MegaPars params;
  271.  
  272.     params.m_GetFilename.title = title;
  273.     params.m_GetFilename.fname = fname;
  274.  
  275.     return( (short) CallMegaCAD(¶ms,GET_FILENAME) );
  276. }
  277.  
  278. /**********************************************************************/
  279.  
  280. void StoreMultiple(           // store an entity (maybe multiple)
  281.         double      *data,    // entity data
  282.         ushort      type)     // entity type (may be or'ed with DO_SAVCNT)
  283. {
  284.     t_MegaPars params;
  285.  
  286.     params.m_StoreMultiple.data = data;
  287.     params.m_StoreMultiple.type = type;
  288.  
  289.     CallMegaCAD(¶ms,STORE_MULTIPLE);
  290. }
  291.  
  292. /**********************************************************************/
  293.  
  294. void MegaCMD(                 // call MegaCAD command
  295.         char        *cmd)     // command string (+ arguments)
  296. {
  297.     t_MegaPars params;
  298.  
  299.     params.m_MegaCMD.cmd = cmd;
  300.  
  301.     CallMegaCAD(¶ms,MEGA_CMD);
  302. }
  303.  
  304. /**********************************************************************/
  305.  
  306. short Message(                // message box
  307.         char        *str1,    // 1st line of text
  308.         char        *str2,    // 2nd line of text
  309.         char        *but1,    // 1st button (may be NULL)
  310.         char        *but2,    // 2nd button (may be NULL)
  311.         char        *but3,    // 3rd button
  312.         short       defbut)   // number of default button (1-3)
  313. {
  314.     t_MegaPars params;
  315.  
  316.     params.m_Message.str1   = str1  ;
  317.     params.m_Message.str2   = str2  ;
  318.     params.m_Message.but1   = but1  ;
  319.     params.m_Message.but2   = but2  ;
  320.     params.m_Message.but3   = but3  ;
  321.     params.m_Message.defbut = defbut;
  322.  
  323.     return( (short) CallMegaCAD(¶ms,MESSAGE) );
  324. }
  325.  
  326. /**********************************************************************/
  327.  
  328. void MouseHelp(               // help text for mouse buttons
  329.         char        *str1,    // help text for left mouse button
  330.         char        *str2,    // help text for right mouse button
  331.         ushort      inv)      // colour (beep) for 1st text (see HLP_INV)
  332. {
  333.     t_MegaPars params;
  334.  
  335.     params.m_MouseHelp.str1 = str1;
  336.     params.m_MouseHelp.str2 = str2;
  337.     params.m_MouseHelp.inv  = inv ;
  338.  
  339.     CallMegaCAD(¶ms,MOUSE_HELP);
  340. }
  341.  
  342. /**********************************************************************/
  343.  
  344. short GetPnt(                 // Get point
  345.         double      *pkt,     // point to be filled in
  346.         short       setinc)   // incremental point to be set ?
  347. {
  348.     t_MegaPars params;
  349.  
  350.     params.m_GetPnt.pkt    = pkt   ;
  351.     params.m_GetPnt.setinc = setinc;
  352.  
  353.     return( (short) CallMegaCAD(¶ms,GET_PNT) );
  354. }
  355.  
  356. /**********************************************************************/
  357.  
  358. void savecount(               // End of operation
  359.         void )                // must be called after creation of entities
  360. {
  361.     t_MegaPars params;
  362.  
  363.     CallMegaCAD(¶ms,SAVECOUNT);
  364. }
  365.  
  366. /**********************************************************************/
  367.  
  368. void SetFuncText(             // set name of current function
  369.         char        *text)    // function text
  370. {
  371.     t_MegaPars params;
  372.  
  373.     params.m_SetFuncText.text = text;
  374.  
  375.     CallMegaCAD(¶ms,SET_FUNC_TEXT);
  376. }
  377.  
  378. /**********************************************************************/
  379.  
  380. ulong CreateEntity(           // store an entity (not multiple), returns ID
  381.         ushort      type,     // entity type
  382.         t_attribs   *attr,    // entity attributes (may be NULL)
  383.         void        *data)    // entity data
  384. {
  385.     t_MegaPars params;
  386.  
  387.     params.m_CreateEntity.type = type;
  388.     params.m_CreateEntity.attr = attr;
  389.     params.m_CreateEntity.data = data;
  390.  
  391.     return( (ulong) CallMegaCAD(¶ms,CREATE_ENTITY) );
  392. }
  393.  
  394. /**********************************************************************/
  395.  
  396. void GetTextVal(              // retrieve text attributes
  397.         ushort      type,     // line or block
  398.         ushort      init,     // initialize (or just calculate box)
  399.         t_text      *txt)     // text data
  400. {
  401.     t_MegaPars params;
  402.  
  403.     params.m_GetTextVal.type = type;
  404.     params.m_GetTextVal.init = init;
  405.     params.m_GetTextVal.txt  = txt ;
  406.  
  407.     CallMegaCAD(¶ms,GET_TEXT_VAL);
  408. }
  409.  
  410. /**********************************************************************/
  411.  
  412. ushort ReadTxtFile(           // read in a text file
  413.         char        *fname,   // filename
  414.         char        *buf,     // buffer to be filled in
  415.         uint        bufsiz)   // size of buffer
  416. {
  417.     t_MegaPars params;
  418.  
  419.     params.m_ReadTxtFile.fname  = fname ;
  420.     params.m_ReadTxtFile.buf    = buf   ;
  421.     params.m_ReadTxtFile.bufsiz = bufsiz;
  422.  
  423.     return( (ushort) CallMegaCAD(¶ms,READ_TXT_FILE) );
  424. }
  425.  
  426. /**********************************************************************/
  427.  
  428. ushort AddPolylnPt(           // add a polyline point
  429.         t_polyln    *polyln,  // polyline structure
  430.         double      *mpd,     // may be NULL
  431.         double      px,       // x-coordinate of point
  432.         double      py)       // y-coordinate of point
  433. {
  434.     t_MegaPars params;
  435.  
  436.     params.m_AddPolylnPt.polyln = polyln;
  437.     params.m_AddPolylnPt.mpd    = mpd   ;
  438.     params.m_AddPolylnPt.px     = px    ;
  439.     params.m_AddPolylnPt.py     = py    ;
  440.  
  441.     return( (ushort) CallMegaCAD(¶ms,ADD_POLYLN_PT) );
  442. }
  443.  
  444. /**********************************************************************/
  445.  
  446. void EraseInv(                // delete temporary objects
  447.         void ) 
  448. {
  449.     t_MegaPars params;
  450.  
  451.     CallMegaCAD(¶ms,ERASE_INV);
  452. }
  453.  
  454. /**********************************************************************/
  455.  
  456. void GetDimVal(               // retrieve dimension attributes
  457.         ushort      type,     // type of dimension
  458.         ushort      init,     // initialize (or just calculate box)
  459.         t_dimension *dim)     // dimension data
  460. {
  461.     t_MegaPars params;
  462.  
  463.     params.m_GetDimVal.type = type;
  464.     params.m_GetDimVal.init = init;
  465.     params.m_GetDimVal.dim  = dim ;
  466.  
  467.     CallMegaCAD(¶ms,GET_DIM_VAL);
  468. }
  469.  
  470. /**********************************************************************/
  471.  
  472. void PrintDimVal(             // print dimension text
  473.         double      value,    // measured value
  474.         char        *str,     // string buffer to fill
  475.         char        *tol1,    // tolerance string 1
  476.         char        *tol2)    // tolerance string 2
  477. {
  478.     t_MegaPars params;
  479.  
  480.     params.m_PrintDimVal.value = value;
  481.     params.m_PrintDimVal.str   = str  ;
  482.     params.m_PrintDimVal.tol1  = tol1 ;
  483.     params.m_PrintDimVal.tol2  = tol2 ;
  484.  
  485.     CallMegaCAD(¶ms,PRINT_DIM_VAL);
  486. }
  487.  
  488. /**********************************************************************/
  489.  
  490. short ClickEntity(            // let the user click a single entity
  491.         ulong       filter,   // allowed entity types
  492.         double      *pnt,     // point where entity was clicked
  493.         t_entity    *ent,     // entity data to be filled in
  494.         void        *edta,    // data ptr of variable length entities
  495.         ushort      esiz)     // size of data buffer
  496. {
  497.     t_MegaPars params;
  498.  
  499.     params.m_ClickEntity.filter = filter;
  500.     params.m_ClickEntity.pnt    = pnt   ;
  501.     params.m_ClickEntity.ent    = ent   ;
  502.     params.m_ClickEntity.edta   = edta  ;
  503.     params.m_ClickEntity.esiz   = esiz  ;
  504.  
  505.     return( (short) CallMegaCAD(¶ms,CLICK_ENTITY) );
  506. }
  507.  
  508. /**********************************************************************/
  509.  
  510. ulong ExChangeEntity(         // exchange an entity, returns new ID
  511.         t_entity    *ent)     // new entity data, old id
  512. {
  513.     t_MegaPars params;
  514.  
  515.     params.m_ExChangeEntity.ent = ent;
  516.  
  517.     return( (ulong) CallMegaCAD(¶ms,EX_CHANGE_ENTITY) );
  518. }
  519.  
  520. /**********************************************************************/
  521.  
  522. short Blink(                  // draw something blinking
  523.         tCallBack   func,     // callback function
  524.         void        *para)    // data pointer for callback function
  525. {
  526.     t_MegaPars params;
  527.  
  528.     params.m_Blink.func = func;
  529.     params.m_Blink.para = para;
  530.  
  531.     return( (short) CallMegaCAD(¶ms,BLINK) );
  532. }
  533.  
  534. /**********************************************************************/
  535.  
  536. void EntityLoop(              // loop through all entities
  537.         ulong       filter,   // allowed entity types
  538.         tCallBack   func,     // callback function
  539.         void        *para,    // data pointer for callback function
  540.         void        *edta,    // data ptr of variable length entities
  541.         ushort      esiz)     // size of data buffer
  542. {
  543.     t_MegaPars params;
  544.  
  545.     params.m_EntityLoop.filter = filter;
  546.     params.m_EntityLoop.func   = func  ;
  547.     params.m_EntityLoop.para   = para  ;
  548.     params.m_EntityLoop.edta   = edta  ;
  549.     params.m_EntityLoop.esiz   = esiz  ;
  550.  
  551.     CallMegaCAD(¶ms,ENTITY_LOOP);
  552. }
  553.  
  554. /**********************************************************************/
  555.  
  556. void DrawEntities(            // draw array of entity-id's
  557.         ulong       *pid,     // array of entity-id's
  558.         ushort      num)      // number of id's
  559. {
  560.     t_MegaPars params;
  561.  
  562.     params.m_DrawEntities.pid = pid;
  563.     params.m_DrawEntities.num = num;
  564.  
  565.     CallMegaCAD(¶ms,DRAW_ENTITIES);
  566. }
  567.  
  568. /**********************************************************************/
  569.  
  570. short StringInput(            // input a line of text
  571.         char        *title,   // title string
  572.         char        *buf,     // string buffer to be filled in
  573.         ushort      buflen)   // size of buffer
  574. {
  575.     t_MegaPars params;
  576.  
  577.     params.m_StringInput.title  = title ;
  578.     params.m_StringInput.buf    = buf   ;
  579.     params.m_StringInput.buflen = buflen;
  580.  
  581.     return( (short) CallMegaCAD(¶ms,STRING_INPUT) );
  582. }
  583.  
  584. /**********************************************************************/
  585.  
  586. void SelectInit(              // set select filter
  587.         ulong       filter)   // allowed entity types
  588. {
  589.     t_MegaPars params;
  590.  
  591.     params.m_SelectInit.filter = filter;
  592.  
  593.     CallMegaCAD(¶ms,SELECT_INIT);
  594. }
  595.  
  596. /**********************************************************************/
  597.  
  598. void SelectLoop(              // select entities
  599.         tCallBack   func,     // callback function
  600.         void        *para,    // data pointer for callback function
  601.         void        *edta,    // data ptr of variable length entities
  602.         ushort      esiz)     // size of data buffer
  603. {
  604.     t_MegaPars params;
  605.  
  606.     params.m_SelectLoop.func = func;
  607.     params.m_SelectLoop.para = para;
  608.     params.m_SelectLoop.edta = edta;
  609.     params.m_SelectLoop.esiz = esiz;
  610.  
  611.     CallMegaCAD(¶ms,SELECT_LOOP);
  612. }
  613.  
  614. /**********************************************************************/
  615.  
  616. ushort InsertMacro(           // insert macro-file
  617.         char        *fname,   // macro filename
  618.         tCallBack   func,     // callback function
  619.         void        *para,    // data pointer for callback function
  620.         void        *edta,    // data ptr of variable length entities
  621.         ushort      esiz,     // size of data buffer
  622.         t_placemac  *pmac)    // how (and where) to place the macro
  623. {
  624.     t_MegaPars params;
  625.  
  626.     params.m_InsertMacro.fname = fname;
  627.     params.m_InsertMacro.func  = func ;
  628.     params.m_InsertMacro.para  = para ;
  629.     params.m_InsertMacro.edta  = edta ;
  630.     params.m_InsertMacro.esiz  = esiz ;
  631.     params.m_InsertMacro.pmac  = pmac ;
  632.  
  633.     return( (ushort) CallMegaCAD(¶ms,INSERT_MACRO) );
  634. }
  635.  
  636. /**********************************************************************/
  637.  
  638. ushort CalcPattern(           // calc perimeter, area, pt. of gravity
  639.         ushort      which,    // PERIM, AREA, GRAVITY
  640.         ushort      cnt,      // cnt of polyline points
  641.         t_polypt    *ppt,     // maybe NULL
  642.         double      *result)  // value vs. point
  643. {
  644.     t_MegaPars params;
  645.  
  646.     params.m_CalcPattern.which  = which ;
  647.     params.m_CalcPattern.cnt    = cnt   ;
  648.     params.m_CalcPattern.ppt    = ppt   ;
  649.     params.m_CalcPattern.result = result;
  650.  
  651.     return( (ushort) CallMegaCAD(¶ms,CALC_PATTERN) );
  652. }
  653.  
  654. /**********************************************************************/
  655.  
  656. ushort DeleteEntity(          // delete an entity
  657.         ulong       id)       // ID of entity
  658. {
  659.     t_MegaPars params;
  660.  
  661.     params.m_DeleteEntity.id = id;
  662.  
  663.     return( (ushort) CallMegaCAD(¶ms,DELETE_ENTITY) );
  664. }
  665.  
  666. /**********************************************************************/
  667.  
  668. ushort GetEntity(             // get entity data
  669.         ulong       id,       // ID of entity
  670.         t_entity    *ent,     // entity
  671.         void        *edta,    // data ptr of variable length entities
  672.         ushort      esiz)     // size of data buffer
  673. {
  674.     t_MegaPars params;
  675.  
  676.     params.m_GetEntity.id   = id  ;
  677.     params.m_GetEntity.ent  = ent ;
  678.     params.m_GetEntity.edta = edta;
  679.     params.m_GetEntity.esiz = esiz;
  680.  
  681.     return( (ushort) CallMegaCAD(¶ms,GET_ENTITY) );
  682. }
  683.  
  684. /**********************************************************************/
  685.  
  686. void SetIncPnt(               // set incremental point
  687.         double      *pnt)     // new incremental point
  688. {
  689.     t_MegaPars params;
  690.  
  691.     params.m_SetIncPnt.pnt = pnt;
  692.  
  693.     CallMegaCAD(¶ms,SET_INC_PNT);
  694. }
  695.  
  696. /**********************************************************************/
  697.  
  698. void InfoLoop(                // loop through all entity infos
  699.         tCallBack   func,     // callback function
  700.         t_entinfo   *inf )    // info buffer
  701. {
  702.     t_MegaPars params;
  703.  
  704.     params.m_InfoLoop.func = func;
  705.     params.m_InfoLoop.inf  = inf ;
  706.  
  707.     CallMegaCAD(¶ms,INFO_LOOP);
  708. }
  709.  
  710. /**********************************************************************/
  711.  
  712. ushort GetInfo(               // get entity info data
  713.         ushort      iID,      // info ID
  714.         t_entinfo   *inf )    // info buffer
  715. {
  716.     t_MegaPars params;
  717.  
  718.     params.m_GetInfo.iID  = iID ;
  719.     params.m_GetInfo.inf  = inf ;
  720.  
  721.     return( (ushort) CallMegaCAD(¶ms,GET_INFO) );
  722. }
  723.  
  724. /**********************************************************************/
  725.  
  726. ushort StoreInfo(             // store entity info
  727.         t_entinfo   *inf )    // info buffer
  728. {
  729.     t_MegaPars params;
  730.  
  731.     params.m_StoreInfo.inf  = inf ;
  732.  
  733.     return( (ushort) CallMegaCAD(¶ms,STORE_INFO) );
  734. }
  735.  
  736. /**********************************************************************/
  737.  
  738. ushort ExChangeInfo(          // exchange entity info data
  739.         t_entinfo   *inf )    // info buffer
  740. {
  741.     t_MegaPars params;
  742.  
  743.     params.m_ExChangeInfo.inf  = inf ;
  744.  
  745.     return( (ushort) CallMegaCAD(¶ms,EX_CHANGE_INFO) );
  746. }
  747.  
  748. /**********************************************************************/
  749.  
  750. void GetAttributes(           // get attributes (stl,col...)
  751.         ushort      type,     // entity type
  752.         t_attribs   *attr)    // buffer to be filled in
  753. {
  754.     t_MegaPars params;
  755.  
  756.     params.m_GetAttributes.type = type;
  757.     params.m_GetAttributes.attr = attr;
  758.  
  759.     CallMegaCAD(¶ms,GET_ATTRIBUTES);
  760. }
  761.  
  762. /**********************************************************************/
  763.  
  764. void GetLayerBits(            // retrieve active/inactive layers
  765.         uchar       *bits)    // buffer of 32 bytes (256 bits)
  766. {
  767.     t_MegaPars params;
  768.  
  769.     params.m_GetLayerBits.bits = bits;
  770.  
  771.     CallMegaCAD(¶ms,GET_LAYER_BITS);
  772. }
  773.  
  774. /**********************************************************************/
  775.  
  776. void GetGroupBits(            // retrieve active/inactive groups
  777.         uchar       *bits)    // buffer of 32 bytes (256 bits)
  778. {
  779.     t_MegaPars params;
  780.  
  781.     params.m_GetGroupBits.bits = bits;
  782.  
  783.     CallMegaCAD(¶ms,GET_GROUP_BITS);
  784. }
  785.  
  786. /**********************************************************************/
  787.  
  788. void GetLayerNames(           // retrieve layer names
  789.         t_laygrp    *lg)      // buffer of 256 * 64 bytes
  790. {
  791.     t_MegaPars params;
  792.  
  793.     params.m_GetLayerNames.lg = lg;
  794.  
  795.     CallMegaCAD(¶ms,GET_LAYER_NAMES);
  796. }
  797.  
  798. /**********************************************************************/
  799.  
  800. void GetGroupNames(           // retrieve group names
  801.         t_laygrp    *lg)      // buffer of 256 * 64 bytes
  802. {
  803.     t_MegaPars params;
  804.  
  805.     params.m_GetGroupNames.lg = lg;
  806.  
  807.     CallMegaCAD(¶ms,GET_GROUP_NAMES);
  808. }
  809.  
  810. /**********************************************************************/
  811.  
  812. void GetGridSets(             // retrieve grid settings
  813.         t_gridsets  *grid)    // buffer to be filled in
  814. {
  815.     t_MegaPars params;
  816.  
  817.     params.m_GetGridSets.grid = grid;
  818.  
  819.     CallMegaCAD(¶ms,GET_GRID_SETS);
  820. }
  821.  
  822. /**********************************************************************/
  823.  
  824. void SetAttributes(           // alter attributes (stl,col...)
  825.         ushort      type,     // entity type
  826.         t_attribs   *attr)    // new attributes
  827. {
  828.     t_MegaPars params;
  829.  
  830.     params.m_SetAttributes.type = type;
  831.     params.m_SetAttributes.attr = attr;
  832.  
  833.     CallMegaCAD(¶ms,SET_ATTRIBUTES);
  834. }
  835.  
  836. /**********************************************************************/
  837.  
  838. void SetLayerBits(            // set active/inactive layers
  839.         uchar       *bits)    // new bits (32 bytes/256 bits)
  840. {
  841.     t_MegaPars params;
  842.  
  843.     params.m_SetLayerBits.bits = bits;
  844.  
  845.     CallMegaCAD(¶ms,SET_LAYER_BITS);
  846. }
  847.  
  848. /**********************************************************************/
  849.  
  850. void SetGroupBits(            // set active/inactive groups
  851.         uchar       *bits)    // new bits (32 bytes/256 bits)
  852. {
  853.     t_MegaPars params;
  854.  
  855.     params.m_SetGroupBits.bits = bits;
  856.  
  857.     CallMegaCAD(¶ms,SET_GROUP_BITS);
  858. }
  859.  
  860. /**********************************************************************/
  861.  
  862. void SetLayerNames(           // set layer names
  863.         t_laygrp    *lg)      // buffer of 256 * 64 Bytes
  864. {
  865.     t_MegaPars params;
  866.  
  867.     params.m_SetLayerNames.lg = lg;
  868.  
  869.     CallMegaCAD(¶ms,SET_LAYER_NAMES);
  870. }
  871.  
  872. /**********************************************************************/
  873.  
  874. void SetGroupNames(           // set group names
  875.         t_laygrp    *lg)      // buffer of 256 * 64 Bytes
  876. {
  877.     t_MegaPars params;
  878.  
  879.     params.m_SetGroupNames.lg = lg;
  880.  
  881.     CallMegaCAD(¶ms,SET_GROUP_NAMES);
  882. }
  883.  
  884. /**********************************************************************/
  885.  
  886. void SetGridSets(             // alter grid settings
  887.         t_gridsets  *grid)    // new settings
  888. {
  889.     t_MegaPars params;
  890.  
  891.     params.m_SetGridSets.grid = grid;
  892.  
  893.     CallMegaCAD(¶ms,SET_GRID_SETS);
  894. }
  895.  
  896. /**********************************************************************/
  897.  
  898. short GetCurrentFile(         // get name of currently loaded file
  899.         uchar       *fname)   // name buffer to be filled in
  900. {
  901.     t_MegaPars params;
  902.  
  903.     params.m_GetCurrentFile.fname = fname;
  904.  
  905.     return( (short) CallMegaCAD(¶ms,GET_CURRENT_FILE) );
  906. }
  907.  
  908. /**********************************************************************/
  909.  
  910. ulong CreateMacro(            // create and insert a macro
  911.         t_macro     *mac,     // macro data
  912.         t_mkmacro   *mkm,     // entities to be created
  913.         ushort      cnt,      // number of entries
  914.         t_placemac  *pmac)    // how (and where) to place the macro
  915. {
  916.     t_MegaPars params;
  917.  
  918.     params.m_CreateMacro.mac  = mac ;
  919.     params.m_CreateMacro.mkm  = mkm ;
  920.     params.m_CreateMacro.cnt  = cnt ;
  921.     params.m_CreateMacro.pmac = pmac;
  922.  
  923.     return( (ulong) CallMegaCAD(¶ms,CREATE_MACRO) );
  924. }
  925.  
  926. /**********************************************************************/
  927.  
  928. void MacroLoop(               // loop through all macros
  929.         ulong       filter,   // allowed entity types
  930.         ulong       start,    // start ID (if 0L => all macros)
  931.         tCallBack   func,     // callback function
  932.         void        *para,    // data pointer for callback function
  933.         void        *edta,    // data ptr of variable length entities
  934.         ushort      esiz)     // size of data buffer
  935. {
  936.     t_MegaPars params;
  937.  
  938.     params.m_MacroLoop.filter = filter;
  939.     params.m_MacroLoop.start  = start ;
  940.     params.m_MacroLoop.func   = func  ;
  941.     params.m_MacroLoop.para   = para  ;
  942.     params.m_MacroLoop.edta   = edta  ;
  943.     params.m_MacroLoop.esiz   = esiz  ;
  944.  
  945.     CallMegaCAD(¶ms,MACRO_LOOP);
  946. }
  947.  
  948. /**********************************************************************/
  949.  
  950. short ClickMacro(             // let the user click a macro
  951.         double      *pnt,     // point where macro was clicked
  952.         t_entity    *ent,     // macro data to be filled in
  953.         void        *edta,    // data ptr of variable length entities
  954.         ushort      esiz)     // size of data buffer
  955. {
  956.     t_MegaPars params;
  957.  
  958.     params.m_ClickMacro.pnt  = pnt ;
  959.     params.m_ClickMacro.ent  = ent ;
  960.     params.m_ClickMacro.edta = edta;
  961.     params.m_ClickMacro.esiz = esiz;
  962.  
  963.     return( (short) CallMegaCAD(¶ms,CLICK_MACRO) );
  964. }
  965.  
  966. /**********************************************************************/
  967.  
  968. short EntityLen(              // retrieve the length of an entity
  969.         t_entity    *ent,     // entity to get length of
  970.         double      *len)     // resulting length
  971. {
  972.     t_MegaPars params;
  973.  
  974.     params.m_EntityLen.ent = ent;
  975.     params.m_EntityLen.len = len;
  976.  
  977.     return( (short) CallMegaCAD(¶ms,ENTITY_LEN) );
  978. }
  979.  
  980. /**********************************************************************/
  981.  
  982. short PartList(               // create a part list
  983.         uchar       *fmt,     // name of format file
  984.         uchar       *out,     // name of output file (maybe NULL)
  985.         uchar       flags)    // flags (PART_....)
  986. {
  987.     t_MegaPars params;
  988.  
  989.     params.m_PartList.fmt   = fmt  ;
  990.     params.m_PartList.out   = out  ;
  991.     params.m_PartList.flags = flags;
  992.  
  993.     return( (short) CallMegaCAD(¶ms,PART_LIST) );
  994. }
  995.  
  996. /**********************************************************************/
  997.  
  998.