home *** CD-ROM | disk | FTP | other *** search
/ Club Amiga de Montreal - CAM / CAM_CD_1.iso / files / 344b.lha / plplot_v2.6 / src / global.c < prev    next >
Encoding:
C/C++ Source or Header  |  1990-01-27  |  6.5 KB  |  474 lines
  1. /* Sets and gets global variables */
  2.  
  3. #include "plplot.h"
  4. #include "declare.h"
  5.  
  6. void glev(n)
  7. PLINT *n;
  8. {
  9.       *n = level;
  10. }
  11.  
  12. void slev(n)
  13. PLINT n;
  14. {
  15.       level = n;
  16. }
  17.  
  18. void gbase(x,y,xc,yc)
  19. PLFLT *x,*y,*xc,*yc;
  20. {
  21.       *x = base3x;
  22.       *y = base3y;
  23.       *xc = basecx;
  24.       *yc = basecy;
  25. }
  26.  
  27. void sbase(x,y,xc,yc)
  28. PLFLT x,y,xc,yc;
  29. {
  30.       base3x = x;
  31.       base3y = y;
  32.       basecx = xc;
  33.       basecy = yc;
  34. }
  35.  
  36. void gnms(n)
  37. PLINT *n;
  38. {
  39.       *n = nms;
  40. }
  41.  
  42. void snms(n)
  43. PLINT n;
  44. {
  45.       nms = n;
  46. }
  47.  
  48. void gdev(dev,term,gra)
  49. PLINT *dev,*term,*gra;
  50. {
  51.       *dev = device;
  52.       *term = termin;
  53.       *gra = graphx;
  54. }
  55.  
  56. void sdev(dev,term,gra)
  57. PLINT dev,term,gra;
  58. {
  59.       device = dev;
  60.       termin = term;
  61.       graphx = gra;
  62. }
  63.  
  64. void smod(term)
  65. PLINT term;
  66. {
  67.       termin = term;
  68. }
  69.  
  70. void gcurr(ix,iy)
  71. PLINT *ix,*iy;
  72. {
  73.       *ix = currx;
  74.       *iy = curry;
  75. }
  76.  
  77. void scurr(ix,iy)
  78. PLINT ix,iy;
  79. {
  80.       currx = ix;
  81.       curry = iy;
  82. }
  83.  
  84. void gdom(xmin,xmax,ymin,ymax)
  85. PLFLT *xmin,*xmax,*ymin,*ymax;
  86. {
  87.       *xmin = domxmi;
  88.       *xmax = domxma;
  89.       *ymin = domymi;
  90.       *ymax = domyma;
  91. }
  92.  
  93. void sdom(xmin,xmax,ymin,ymax)
  94. PLFLT xmin,xmax,ymin,ymax;
  95. {
  96.       domxmi = xmin;
  97.       domxma = xmax;
  98.       domymi = ymin;
  99.       domyma = ymax;
  100. }
  101.  
  102. void grange(zscl,zmin,zmax)
  103. PLFLT *zscl,*zmin,*zmax;
  104. {
  105.       *zscl = zzscl;
  106.       *zmin = ranmi;
  107.       *zmax = ranma;
  108. }
  109.  
  110. void srange(zscl,zmin,zmax)
  111. PLFLT zscl,zmin,zmax;
  112. {
  113.       zzscl = zscl;
  114.       ranmi = zmin;
  115.       ranma = zmax;
  116. }
  117.  
  118. void gw3wc(dxx,dxy,dyx,dyy,dyz)
  119. PLFLT *dxx,*dxy,*dyx,*dyy,*dyz;
  120. {
  121.       *dxx = cxx;
  122.       *dxy = cxy;
  123.       *dyx = cyx;
  124.       *dyy = cyy;
  125.       *dyz = cyz;
  126. }
  127.  
  128. void sw3wc(dxx,dxy,dyx,dyy,dyz)
  129. PLFLT dxx,dxy,dyx,dyy,dyz;
  130. {
  131.       cxx = dxx;
  132.       cxy = dxy;
  133.       cyx = dyx;
  134.       cyy = dyy;
  135.       cyz = dyz;
  136. }
  137.  
  138. void gvpp(ixmin,ixmax,iymin,iymax)
  139. PLINT *ixmin,*ixmax,*iymin,*iymax;
  140. {
  141.       *ixmin = vppxmi;
  142.       *ixmax = vppxma;
  143.       *iymin = vppymi;
  144.       *iymax = vppyma;
  145. }
  146.  
  147. void svpp(ixmin,ixmax,iymin,iymax)
  148. PLINT ixmin,ixmax,iymin,iymax;
  149. {
  150.       vppxmi = ixmin;
  151.       vppxma = ixmax;
  152.       vppymi = iymin;
  153.       vppyma = iymax;
  154. }
  155.  
  156. void gspp(ixmin,ixmax,iymin,iymax)
  157. PLINT *ixmin,*ixmax,*iymin,*iymax;
  158. {
  159.       *ixmin = sppxmi;
  160.       *ixmax = sppxma;
  161.       *iymin = sppymi;
  162.       *iymax = sppyma;
  163. }
  164.  
  165. void sspp(ixmin,ixmax,iymin,iymax)
  166. PLINT ixmin,ixmax,iymin,iymax;
  167. {
  168.       sppxmi = ixmin;
  169.       sppxma = ixmax;
  170.       sppymi = iymin;
  171.       sppyma = iymax;
  172. }
  173.  
  174. void gclp(ixmin,ixmax,iymin,iymax)
  175. PLINT *ixmin,*ixmax,*iymin,*iymax;
  176. {
  177.       *ixmin = clpxmi;
  178.       *ixmax = clpxma;
  179.       *iymin = clpymi;
  180.       *iymax = clpyma;
  181. }
  182.  
  183. void sclp(ixmin,ixmax,iymin,iymax)
  184. PLINT ixmin,ixmax,iymin,iymax;
  185. {
  186.       clpxmi = ixmin;
  187.       clpxma = ixmax;
  188.       clpymi = iymin;
  189.       clpyma = iymax;
  190. }
  191.  
  192. void gphy(ixmin,ixmax,iymin,iymax)
  193. PLINT *ixmin,*ixmax,*iymin,*iymax;
  194. {
  195.       *ixmin = phyxmi;
  196.       *ixmax = phyxma;
  197.       *iymin = phyymi;
  198.       *iymax = phyyma;
  199. }
  200.  
  201. void sphy(ixmin,ixmax,iymin,iymax)
  202. PLINT ixmin,ixmax,iymin,iymax;
  203. {
  204.       phyxmi = ixmin;
  205.       phyxma = ixmax;
  206.       phyymi = iymin;
  207.       phyyma = iymax;
  208. }
  209.  
  210. void gsub(nx,ny,cs)
  211. PLINT *nx,*ny,*cs;
  212. {
  213.       *nx = nsubx;
  214.       *ny = nsuby;
  215.       *cs = cursub;
  216. }
  217.  
  218. void ssub(nx,ny,cs)
  219. PLINT nx,ny,cs;
  220. {
  221.       nsubx = nx;
  222.       nsuby = ny;
  223.       cursub = cs;
  224. }
  225.  
  226. void gumpix(ix,iy)
  227. PLINT *ix,*iy;
  228. {
  229.       *ix = umx;
  230.       *iy = umy;
  231. }
  232.  
  233. void sumpix(ix,iy)
  234. PLINT ix,iy;
  235. {
  236.       umx = ix;
  237.       umy = iy;
  238. }
  239.  
  240. void gatt(ifnt,icol)
  241. PLINT *ifnt,*icol;
  242. {
  243.       *ifnt = font;
  244.       *icol = colour;
  245. }
  246.  
  247. void satt(ifnt,icol)
  248. PLINT ifnt,icol;
  249. {
  250.       font = ifnt;
  251.       colour = icol;
  252. }
  253.  
  254. void gcol(icol)
  255. PLINT *icol;
  256. {
  257.       *icol = colour;
  258. }
  259.  
  260. void scol(icol)
  261. PLINT icol;
  262. {
  263.       colour = icol;
  264. }
  265.  
  266. void gwid(pwid)
  267. PLINT *pwid;
  268. {
  269.       *pwid = width;
  270. }
  271.  
  272. void swid(pwid)
  273. PLINT pwid;
  274. {
  275.       width = pwid;
  276. }
  277.  
  278. void gspd(xmin,xmax,ymin,ymax)
  279. PLFLT *xmin,*xmax,*ymin,*ymax;
  280. {
  281.       *xmin = spdxmi;
  282.       *xmax = spdxma;
  283.       *ymin = spdymi;
  284.       *ymax = spdyma;
  285. }
  286.  
  287. void sspd(xmin,xmax,ymin,ymax)
  288. PLFLT xmin,xmax,ymin,ymax;
  289. {
  290.       spdxmi = xmin;
  291.       spdxma = xmax;
  292.       spdymi = ymin;
  293.       spdyma = ymax;
  294. }
  295.  
  296. void gvpd(xmin,xmax,ymin,ymax)
  297. PLFLT *xmin,*xmax,*ymin,*ymax;
  298. {
  299.       *xmin = vpdxmi;
  300.       *xmax = vpdxma;
  301.       *ymin = vpdymi;
  302.       *ymax = vpdyma;
  303. }
  304.  
  305. void svpd(xmin,xmax,ymin,ymax)
  306. PLFLT xmin,xmax,ymin,ymax;
  307. {
  308.       vpdxmi = xmin;
  309.       vpdxma = xmax;
  310.       vpdymi = ymin;
  311.       vpdyma = ymax;
  312. }
  313.  
  314. void gvpw(xmin,xmax,ymin,ymax)
  315. PLFLT *xmin,*xmax,*ymin,*ymax;
  316. {
  317.       *xmin = vpwxmi;
  318.       *xmax = vpwxma;
  319.       *ymin = vpwymi;
  320.       *ymax = vpwyma;
  321. }
  322.  
  323. void svpw(xmin,xmax,ymin,ymax)
  324. PLFLT xmin,xmax,ymin,ymax;
  325. {
  326.       vpwxmi = xmin;
  327.       vpwxma = xmax;
  328.       vpwymi = ymin;
  329.       vpwyma = ymax;
  330. }
  331.  
  332. void gpixmm(x,y)
  333. PLFLT *x,*y;
  334. {
  335.       *x = xpmm;
  336.       *y = ypmm;
  337. }
  338.  
  339. void spixmm(x,y)
  340. PLFLT x,y;
  341. {
  342.       xpmm = x;
  343.       ypmm = y;
  344. }
  345.  
  346. void gwp(xscl,xoff,yscl,yoff)
  347. PLFLT *xscl,*xoff,*yscl,*yoff;
  348. {
  349.       *xscl = wpxscl;
  350.       *xoff = wpxoff;
  351.       *yscl = wpyscl;
  352.       *yoff = wpyoff;
  353. }
  354.  
  355. void swp(xscl,xoff,yscl,yoff)
  356. PLFLT xscl,xoff,yscl,yoff;
  357. {
  358.       wpxscl = xscl;
  359.       wpxoff = xoff;
  360.       wpyscl = yscl;
  361.       wpyoff = yoff;
  362. }
  363.  
  364. void gwm(xscl,xoff,yscl,yoff)
  365. PLFLT *xscl,*xoff,*yscl,*yoff;
  366. {
  367.       *xscl = wmxscl;
  368.       *xoff = wmxoff;
  369.       *yscl = wmyscl;
  370.       *yoff = wmyoff;
  371. }
  372.  
  373. void swm(xscl,xoff,yscl,yoff)
  374. PLFLT xscl,xoff,yscl,yoff;
  375. {
  376.       wmxscl = xscl;
  377.       wmxoff = xoff;
  378.       wmyscl = yscl;
  379.       wmyoff = yoff;
  380. }
  381.  
  382. void gdp(xscl,xoff,yscl,yoff)
  383. PLFLT *xscl,*xoff,*yscl,*yoff;
  384. {
  385.       *xscl = dpxscl;
  386.       *xoff = dpxoff;
  387.       *yscl = dpyscl;
  388.       *yoff = dpyoff;
  389. }
  390.  
  391. void sdp(xscl,xoff,yscl,yoff)
  392. PLFLT xscl,xoff,yscl,yoff;
  393. {
  394.       dpxscl = xscl;
  395.       dpxoff = xoff;
  396.       dpyscl = yscl;
  397.       dpyoff = yoff;
  398. }
  399.  
  400. void gmp(xscl,xoff,yscl,yoff)
  401. PLFLT *xscl,*xoff,*yscl,*yoff;
  402. {
  403.       *xscl = mpxscl;
  404.       *xoff = mpxoff;
  405.       *yscl = mpyscl;
  406.       *yoff = mpyoff;
  407. }
  408.  
  409. void smp(xscl,xoff,yscl,yoff)
  410. PLFLT xscl,xoff,yscl,yoff;
  411. {
  412.       mpxscl = xscl;
  413.       mpxoff = xoff;
  414.       mpyscl = yscl;
  415.       mpyoff = yoff;
  416. }
  417.  
  418. void gchr(def,ht)
  419. PLFLT *def,*ht;
  420. {
  421.       *def = chrdef;
  422.       *ht = chrht;
  423. }
  424.  
  425. void schr(def,ht)
  426. PLFLT def,ht;
  427. {
  428.       chrdef = def;
  429.       chrht = ht;
  430. }
  431.  
  432. void gsym(def,ht)
  433. PLFLT *def,*ht;
  434. {
  435.       *def = symdef;
  436.       *ht = symht;
  437. }
  438.  
  439. void ssym(def,ht)
  440. PLFLT def,ht;
  441. {
  442.       symdef = def;
  443.       symht = ht;
  444. }
  445.  
  446. void gmaj(def,ht)
  447. PLFLT *def,*ht;
  448. {
  449.       *def = majdef;
  450.       *ht = majht;
  451. }
  452.  
  453. void smaj(def,ht)
  454. PLFLT def,ht;
  455. {
  456.       majdef = def;
  457.       majht = ht;
  458. }
  459.  
  460. void gmin(def,ht)
  461. PLFLT *def,*ht;
  462. {
  463.       *def = mindef;
  464.       *ht = minht;
  465. }
  466.  
  467. void smin(def,ht)
  468. PLFLT def,ht;
  469. {
  470.       mindef = def;
  471.       minht = ht;
  472. }
  473.  
  474.