home *** CD-ROM | disk | FTP | other *** search
/ OS/2 Shareware BBS: 10 Tools / 10-Tools.zip / mesaaiok.zip / source / model.cpp < prev    next >
C/C++ Source or Header  |  1995-11-28  |  13KB  |  523 lines
  1. #include <string.h>
  2. #include <stdio.h>                 // added for printf
  3.  
  4. #include "model.h"
  5. #include "extaddin.h"
  6.  
  7. Model :: Model()
  8. {
  9.     _model = (int)performAddInFunction(newModelMesaAddIn);
  10.     _redisplay = 0;
  11. }
  12.  
  13. Model ::Model(int m)
  14. {
  15.     switch (m) {
  16.     case -1:
  17.        _model = (int)performAddInFunction(getActiveModelMesaAddIn);
  18.        break;
  19.     case 0:
  20.        _model = (int)performAddInFunction(newModelMesaAddIn);
  21.        break;
  22.     default:
  23.        _model = m;
  24.       break;
  25.     } /* endswitch */
  26.     _redisplay = 0;
  27. }
  28.  
  29. Model :: Model(char *name)
  30. {
  31.     _model = (int)performAddInFunction(openModelMesaAddIn,name);
  32.     _redisplay = 0;
  33. }
  34.  
  35. Model & Model ::  getName(char * buf,int max)
  36. {
  37.     char * b2;
  38.     b2 = (char *)performAddInFunction(getModelNameMesaAddIn,_model);
  39.     if (!b2) {
  40.        buf[0] = 0;
  41.        return *this;
  42.     } /* endif */
  43.     if ((strlen(b2)+1) > max) {
  44.         b2[max-1] = 0;
  45.     } /* endif */
  46.     strcpy(buf,b2);
  47.     MFree(b2);
  48.     return *this;
  49. }
  50.  
  51. Model & Model :: setName(char *name)
  52. {
  53.     performAddInFunction(setModelNameMesaAddIn,_model,name,_redisplay);
  54.     return *this;
  55. }
  56.  
  57. Model & Model :: save()
  58. {
  59.     performAddInFunction(saveModelAddIn, _model);
  60.     return *this;
  61. }
  62.  
  63. Model & Model :: saveAs(char * name)
  64. {
  65.     setName(name);
  66.     save();
  67.     return *this;
  68. }
  69.  
  70. int Model :: load(char * name)   // returns true if successfull
  71. {
  72.     _model = (int)performAddInFunction(openModelMesaAddIn,name);
  73.     return _model != 0;
  74. }
  75.  
  76. Model & Model :: addressToString(Address &a,char * buf,int max)
  77. {
  78.     char * b2;
  79.     b2 = (char *)performAddInFunction(addressToStringMesaAddIn,_model,
  80.              a.row(),a.col(),a.layer());
  81.  
  82.     if ((strlen(b2)+1) > max) {
  83.         b2[max-1] = 0;
  84.     } /* endif */
  85.     strcpy(buf,b2);
  86.     MFree(b2);
  87.     return *this;
  88. }
  89.  
  90. Address Model :: stringToAddress(char * buf)
  91. {
  92.     int r,c,l;
  93.     int rc = (int) performAddInFunction(stringToAddressMesaAddIn, _model,buf,&r, &c, &l);
  94.     if (rc) {
  95.        return Address(r,c,l);
  96.     }
  97.     return Address(-1,-1,-1);
  98. }
  99.  
  100. Model & Model :: selectNamedRange(char *buf)
  101. {
  102.     performAddInFunction(selectMesaAddIn, buf);
  103.     return *this;
  104. }
  105.  
  106. int Model :: setCellValue(const Address &ad,double db)
  107. {
  108.     MesaAddInValue aiv;
  109.     int rc;
  110.  
  111.     performAddInFunction(initValueMesaAddIn, &aiv);
  112.     aiv.row = ad.row();
  113.     aiv.column = ad.col();
  114.     aiv.layer = ad.layer();
  115.  
  116.     aiv.number = db;
  117.     aiv.type = numberValueMesaAddInType;
  118.     rc = (int) performAddInFunction(setCellValueMesaAddIn, _model,&aiv, _redisplay);
  119.     performAddInFunction(freeValueMesaAddIn, &aiv);
  120.     return rc;
  121. }
  122.  
  123. int Model :: setCellValue(const Address &ad,char * str)
  124. {
  125.     MesaAddInValue aiv;
  126.     int rc;
  127.  
  128.     performAddInFunction(initValueMesaAddIn, &aiv);
  129.     aiv.row = ad.row();
  130.     aiv.column = ad.col();
  131.     aiv.layer = ad.layer();
  132.  
  133.     aiv.string = MMalloc(strlen(str)+1);
  134.     strcpy(aiv.string,str);
  135.     aiv.type = stringValueMesaAddInType;
  136.     rc = (int) performAddInFunction(setCellValueMesaAddIn, _model,&aiv, _redisplay);
  137.     performAddInFunction(freeValueMesaAddIn, &aiv);
  138.     return rc;
  139. }
  140.  
  141. int Model :: setCellError(const Address &ad,int error)
  142. {
  143.     MesaAddInValue aiv;
  144.     int rc;
  145.  
  146.     performAddInFunction(initValueMesaAddIn, &aiv);
  147.     aiv.row = ad.row();
  148.     aiv.column = ad.col();
  149.     aiv.layer = ad.layer();
  150.  
  151.     aiv.error = error;
  152.     aiv.type = errorValueMesaAddInType;
  153.     rc = (int) performAddInFunction(setCellValueMesaAddIn, _model,&aiv, _redisplay);
  154.     performAddInFunction(freeValueMesaAddIn, &aiv);
  155.     return rc;
  156. }
  157.  
  158. int Model :: getCellValue(const Address &ad,double &db)
  159. {
  160.     MesaAddInValue aiv;
  161.     int rc;
  162.  
  163.     performAddInFunction(initValueMesaAddIn, &aiv);
  164.     aiv.row = ad.row();
  165.     aiv.column = ad.col();
  166.     aiv.layer = ad.layer();
  167.  
  168.     rc = (int) performAddInFunction(getCellValueMesaAddIn, _model,&aiv);
  169.     if (aiv.type != numberValueMesaAddInType) {
  170.        rc = 1;
  171.     } /* endif */
  172.  
  173.     db = aiv.number;
  174.     performAddInFunction(freeValueMesaAddIn, &aiv);
  175.     return rc;
  176. }
  177.  
  178. int Model :: getCellValue(const Address &ad,char * &str, int max)
  179. {
  180.     MesaAddInValue aiv;
  181.     int rc;
  182.  
  183.     performAddInFunction(initValueMesaAddIn, &aiv);
  184.     aiv.row = ad.row();
  185.     aiv.column = ad.col();
  186.     aiv.layer = ad.layer();
  187.  
  188.     rc = (int) performAddInFunction(getCellValueMesaAddIn, _model,&aiv);
  189.     if (aiv.type != stringValueMesaAddInType) {
  190.        rc = 1;
  191.     } /* endif */
  192.  
  193.     if ((strlen(aiv.string)+1) > max) {
  194.         aiv.string[max-1] = 0;
  195.     } /* endif */
  196.     strcpy(str,aiv.string);
  197.  
  198.     performAddInFunction(freeValueMesaAddIn, &aiv);
  199.     return rc;
  200. }
  201.  
  202. int Model :: getCellError(const Address &ad,int &error)
  203. {
  204.     MesaAddInValue aiv;
  205.     int rc;
  206.  
  207.     performAddInFunction(initValueMesaAddIn, &aiv);
  208.     aiv.row = ad.row();
  209.     aiv.column = ad.col();
  210.     aiv.layer = ad.layer();
  211.  
  212.     rc = (int) performAddInFunction(getCellValueMesaAddIn, _model,&aiv);
  213.     if (aiv.type != errorValueMesaAddInType) {
  214.        rc = 1;
  215.     } /* endif */
  216.  
  217.     error = aiv.error;
  218.     performAddInFunction(freeValueMesaAddIn, &aiv);
  219.     return rc;
  220. }
  221.  
  222. int Model :: setCellString(const Address &ad,char * str)
  223. {
  224.     return (int)performAddInFunction(setCellStringMesaAddIn, _model,str,
  225.                   ad.layer(),ad.row(), ad.col(),_redisplay);
  226. }
  227.  
  228. Model & Model :: getCellString(const Address &ad,char * &str, int max)
  229. {
  230.    char * b2 = (char *)performAddInFunction(getCellOutputMesaAddIn,
  231.            _model,ad.layer(), ad.row(),ad.col());
  232.     if ((strlen(b2)+1) > max) {
  233.         b2[max-1] = 0;
  234.     } /* endif */
  235.     strcpy(str,b2);
  236.     MFree(b2);
  237.     return *this;
  238. }
  239.  
  240. Model & Model :: getCellOutput(const Address &ad,char * &str, int max)
  241. {
  242.    char * b2 = (char *)performAddInFunction(getCellStringMesaAddIn,
  243.            _model,ad.layer(), ad.row(),ad.col());
  244.     if ((strlen(b2)+1) > max) {
  245.         b2[max-1] = 0;
  246.     } /* endif */
  247.     strcpy(str,b2);
  248.     MFree(b2);
  249.     return *this;
  250. }
  251.  
  252. int Model :: setExtentsForLayer(int layer,int rows,int columns)
  253. {
  254.     return (int)performAddInFunction(setExtentsMesaAddIn, _model, layer,rows,
  255.         columns, _redisplay);
  256. }
  257.  
  258. int Model :: getExtentsForLayer(int layer,int &rows,int &columns)
  259. {
  260.     return (int)performAddInFunction(getExtentsMesaAddIn, _model,layer, &rows,
  261.         &columns);
  262. }
  263.  
  264. int Model :: getNumberOfLayers()
  265. {
  266.     return (int) performAddInFunction(getNumberOfLayersMesaAddIn,_model);
  267. }
  268.  
  269. Model & Model :: addLayer()
  270. {
  271.     performAddInFunction(addALayerMesaAddIn,_model,_redisplay);
  272.     return *this;
  273. }
  274.  
  275. int Model :: setRowSize(int layer,int row, int size)
  276. {
  277.     return (int)performAddInFunction(setRowSizeMesaAddIn,_model,layer,row,
  278.                     size,_redisplay);
  279. }
  280.  
  281. int Model :: getRowSize(int layer,int row)
  282. {
  283.     return (int)performAddInFunction(getRowSizeMesaAddIn,_model,layer,row);
  284. }
  285.  
  286. int Model :: setColSize(int layer,int col, int size)
  287. {
  288.     return (int)performAddInFunction(setColumnSizeMesaAddIn,_model,layer,col,
  289.                     size,_redisplay);
  290. }
  291.  
  292. int Model :: getColSize(int layer,int col)
  293. {
  294.     return (int)performAddInFunction(getColumnSizeMesaAddIn,_model,layer,col);
  295. }
  296.  
  297.  
  298. Model & Model :: recalc()
  299. {
  300.     performAddInFunction(recalcMesaAddIn, _model);
  301.     return *this;
  302. }
  303. Model & Model :: redisplay()
  304. {
  305.     performAddInFunction(redisplayMesaAddIn, _model);
  306.     return *this;
  307. }
  308.  
  309. Model & Model :: setBlob(char * name, int len, void * data)
  310. {
  311.     if ((int)performAddInFunction(getVersionNumberMesaAddIn) > 102) {
  312.         performAddInFunction(setBlobMesaAddIn,(void *)_model,(const char *)name,(int)len,(const void *)data);
  313.     } // endif
  314.     return *this;
  315. }
  316.  
  317. int Model :: getBlob(char * name,int max, void * data)
  318. {
  319.     int len=0;
  320.     void *dt=NULL;
  321.     int rc = performAddInFunction(getBlobMesaAddIn,_model,name,&len,&dt);
  322.  
  323.     if (!rc) {   // blob wasn't found
  324.         return 0;
  325.     } /* endif */
  326.  
  327.     if (len <= max) {
  328.        memcpy(data,dt,len);
  329.        MFree(dt);
  330.        return len;
  331.     } else {
  332.        memcpy(data,dt,max);
  333.        MFree(dt);
  334.        return max;
  335.     } /* endif */
  336.     MFree(dt);
  337.     return 0;
  338. }
  339.  
  340.  
  341. Model & Model :: rangeToString(Range &r,char * buf, int max)
  342. {
  343.     char * b2;
  344.     int x,y;
  345.     Address a,b;
  346.     int lensofar = 0;
  347.     buf[0] = NULL;
  348.  
  349.     for (x = 0 ; x < r.getCount() ; x++) {
  350.         r.getItem(x,a,b);
  351.         b2 = (char *)performAddInFunction(rangeToStringMesaAddIn,_model,
  352.              a.row(),a.col(),a.layer(),b.row(),b.col(),b.layer());
  353.  
  354.         if (lensofar) {                    // if it has a range, add a ,
  355.             strcpy(&buf[lensofar],",");
  356.             lensofar++;
  357.         } /* endif */
  358.  
  359.         y = strlen(b2);
  360.         if ((lensofar + y + 1) > max); {
  361.            b2[max - lensofar - 1] = 0;
  362.         } /* endif */
  363.  
  364.         strcpy(&buf[lensofar],b2);
  365.         lensofar += strlen(b2);
  366.         MFree(b2);
  367.     } /* endfor */
  368.  
  369.     return *this;
  370. }
  371.  
  372.  
  373. Range Model :: stringToRange(char * buf)
  374. {
  375.     int r,c,l;
  376.     int r2,c2,l2;
  377.     int x;
  378.     Range ra;
  379.     Address a,b;
  380.     int rc = (int) performAddInFunction(stringToRangeMesaAddIn, _model,buf,0,&r, &c, &l, &r2,&c2,&l2);
  381.  
  382.     for (x = 0; x < rc ; x++ ) {
  383.         performAddInFunction(stringToRangeMesaAddIn, _model,buf,x,&r, &c, &l, &r2,&c2,&l2);
  384.         a.set(r,c,l);
  385.         b.set(r2,c2,l2);
  386.         ra.add(a,b);
  387.     } /* endfor */
  388.  
  389.     return ra;
  390. }
  391.  
  392. int Model :: pushValue(void * stack,double db)
  393. {
  394.     MesaAddInValue aiv;
  395.     int rc;
  396.  
  397.     performAddInFunction(initValueMesaAddIn, &aiv);
  398.  
  399.     aiv.number = db;
  400.     aiv.type = numberValueMesaAddInType;
  401.     rc = (int) performAddInFunction(pushValueMesaAddIn,stack, _model,&aiv);
  402.     performAddInFunction(freeValueMesaAddIn, &aiv);
  403.     return rc;
  404. }
  405.  
  406. int Model :: pushValue(void * stack,char * str)
  407. {
  408.     MesaAddInValue aiv;
  409.     int rc;
  410.  
  411.     performAddInFunction(initValueMesaAddIn, &aiv);
  412.  
  413.     aiv.string = MMalloc(strlen(str)+1);
  414.     strcpy(aiv.string,str);
  415.     aiv.type = stringValueMesaAddInType;
  416.     rc = (int) performAddInFunction(pushValueMesaAddIn,stack, _model,&aiv);
  417.     performAddInFunction(freeValueMesaAddIn, &aiv);
  418.     return rc;
  419. }
  420.  
  421. int Model :: pushError(void * stack,int error)
  422. {
  423.     MesaAddInValue aiv;
  424.     int rc = 0;
  425.  
  426.     performAddInFunction(initValueMesaAddIn, &aiv);
  427.  
  428.     aiv.error = error;
  429.     aiv.type = errorValueMesaAddInType;
  430.     rc = (int) performAddInFunction(pushValueMesaAddIn,stack, _model,&aiv);
  431.     performAddInFunction(freeValueMesaAddIn, &aiv);
  432.     return rc;
  433. }
  434.  
  435. int Model :: popValue(void * stack,double &db)
  436. {
  437.     MesaAddInValue aiv;
  438.     int rc = 0;
  439.  
  440.     performAddInFunction(initValueMesaAddIn, &aiv);
  441.  
  442.     rc = (int) performAddInFunction(popElementMesaAddIn,stack, _model,&aiv);
  443.     if (aiv.type != numberValueMesaAddInType) {
  444.        rc = 1;
  445.        performAddInFunction(pushValueMesaAddIn,stack, _model,&aiv);
  446.     } /* endif */
  447.  
  448.     db = aiv.number;
  449.     performAddInFunction(freeValueMesaAddIn, &aiv);
  450.     return rc;
  451. }
  452.  
  453. int Model :: popValue(void * stack,char * &str, int max)
  454. {
  455.     MesaAddInValue aiv;
  456.     int rc = 0;
  457.  
  458.     performAddInFunction(initValueMesaAddIn, &aiv);
  459.  
  460.     rc = (int) performAddInFunction(popElementMesaAddIn,stack, _model,&aiv);
  461.     if (aiv.type != stringValueMesaAddInType) {
  462.        rc = 1;
  463.        performAddInFunction(pushValueMesaAddIn,stack, _model,&aiv);
  464.     } /* endif */
  465.  
  466.     if ((strlen(aiv.string)+1) > max) {
  467.         aiv.string[max-1] = 0;
  468.     } /* endif */
  469.     strcpy(str,aiv.string);
  470.  
  471.     performAddInFunction(freeValueMesaAddIn, &aiv);
  472.     return rc;
  473. }
  474.  
  475. int Model :: popError(void * stack,int &error)
  476. {
  477.     MesaAddInValue aiv;
  478.     int rc = 0;
  479.  
  480.     performAddInFunction(initValueMesaAddIn, &aiv);
  481.  
  482.     rc = (int) performAddInFunction(popElementMesaAddIn,stack, _model,&aiv);
  483.     if (aiv.type != errorValueMesaAddInType) {
  484.        rc = 1;
  485.        performAddInFunction(pushValueMesaAddIn,stack, _model,&aiv);
  486.     } /* endif */
  487.  
  488.     error = aiv.error;
  489.     performAddInFunction(freeValueMesaAddIn, &aiv);
  490.     return rc;
  491. }
  492.  
  493. void Model :: initAddInValue(MesaAddInValue &aiv)
  494. {
  495.     performAddInFunction(initValueMesaAddIn, &aiv);
  496. }
  497.  
  498. void Model :: freeAddInValue(MesaAddInValue &aiv)
  499. {
  500.     performAddInFunction(freeValueMesaAddIn, &aiv);
  501. }
  502.  
  503. void Model :: pushValue( void * stack, MesaAddInValue &aiv)
  504. {
  505.     performAddInFunction(pushValueMesaAddIn,stack, _model,&aiv);
  506. }
  507.  
  508. void Model :: popValue( void * stack, MesaAddInValue &aiv)
  509. {
  510.     performAddInFunction(popElementMesaAddIn,stack, _model,&aiv);
  511. }
  512.  
  513. void Model :: getCellValue( Address & ad, MesaAddInValue &aiv)
  514. {
  515.     performAddInFunction(getCellValueMesaAddIn, _model,&aiv);
  516. }
  517.  
  518. void Model :: setCellValue( Address & ad, MesaAddInValue &aiv)
  519. {
  520.     performAddInFunction(setCellValueMesaAddIn, _model,&aiv, _redisplay);
  521. }
  522.  
  523.