/* Sets and gets global variables */

#include "plplot.h"
#include "declare.h"

void glev(n)
PLINT *n;
{
      *n = level;
}

void slev(n)
PLINT n;
{
      level = n;
}

void gbase(x,y,xc,yc)
PLFLT *x,*y,*xc,*yc;
{
      *x = base3x;
      *y = base3y;
      *xc = basecx;
      *yc = basecy;
}

void sbase(x,y,xc,yc)
PLFLT x,y,xc,yc;
{
      base3x = x;
      base3y = y;
      basecx = xc;
      basecy = yc;
}

void gnms(n)
PLINT *n;
{
      *n = nms;
}

void snms(n)
PLINT n;
{
      nms = n;
}

void gdev(dev,term,gra)
PLINT *dev,*term,*gra;
{
      *dev = device;
      *term = termin;
      *gra = graphx;
}

void sdev(dev,term,gra)
PLINT dev,term,gra;
{
      device = dev;
      termin = term;
      graphx = gra;
}

void smod(term)
PLINT term;
{
      termin = term;
}

void gcurr(ix,iy)
PLINT *ix,*iy;
{
      *ix = currx;
      *iy = curry;
}

void scurr(ix,iy)
PLINT ix,iy;
{
      currx = ix;
      curry = iy;
}

void gdom(xmin,xmax,ymin,ymax)
PLFLT *xmin,*xmax,*ymin,*ymax;
{
      *xmin = domxmi;
      *xmax = domxma;
      *ymin = domymi;
      *ymax = domyma;
}

void sdom(xmin,xmax,ymin,ymax)
PLFLT xmin,xmax,ymin,ymax;
{
      domxmi = xmin;
      domxma = xmax;
      domymi = ymin;
      domyma = ymax;
}

void grange(zscl,zmin,zmax)
PLFLT *zscl,*zmin,*zmax;
{
      *zscl = zzscl;
      *zmin = ranmi;
      *zmax = ranma;
}

void srange(zscl,zmin,zmax)
PLFLT zscl,zmin,zmax;
{
      zzscl = zscl;
      ranmi = zmin;
      ranma = zmax;
}

void gw3wc(dxx,dxy,dyx,dyy,dyz)
PLFLT *dxx,*dxy,*dyx,*dyy,*dyz;
{
      *dxx = cxx;
      *dxy = cxy;
      *dyx = cyx;
      *dyy = cyy;
      *dyz = cyz;
}

void sw3wc(dxx,dxy,dyx,dyy,dyz)
PLFLT dxx,dxy,dyx,dyy,dyz;
{
      cxx = dxx;
      cxy = dxy;
      cyx = dyx;
      cyy = dyy;
      cyz = dyz;
}

void gvpp(ixmin,ixmax,iymin,iymax)
PLINT *ixmin,*ixmax,*iymin,*iymax;
{
      *ixmin = vppxmi;
      *ixmax = vppxma;
      *iymin = vppymi;
      *iymax = vppyma;
}

void svpp(ixmin,ixmax,iymin,iymax)
PLINT ixmin,ixmax,iymin,iymax;
{
      vppxmi = ixmin;
      vppxma = ixmax;
      vppymi = iymin;
      vppyma = iymax;
}

void gspp(ixmin,ixmax,iymin,iymax)
PLINT *ixmin,*ixmax,*iymin,*iymax;
{
      *ixmin = sppxmi;
      *ixmax = sppxma;
      *iymin = sppymi;
      *iymax = sppyma;
}

void sspp(ixmin,ixmax,iymin,iymax)
PLINT ixmin,ixmax,iymin,iymax;
{
      sppxmi = ixmin;
      sppxma = ixmax;
      sppymi = iymin;
      sppyma = iymax;
}

void gclp(ixmin,ixmax,iymin,iymax)
PLINT *ixmin,*ixmax,*iymin,*iymax;
{
      *ixmin = clpxmi;
      *ixmax = clpxma;
      *iymin = clpymi;
      *iymax = clpyma;
}

void sclp(ixmin,ixmax,iymin,iymax)
PLINT ixmin,ixmax,iymin,iymax;
{
      clpxmi = ixmin;
      clpxma = ixmax;
      clpymi = iymin;
      clpyma = iymax;
}

void gphy(ixmin,ixmax,iymin,iymax)
PLINT *ixmin,*ixmax,*iymin,*iymax;
{
      *ixmin = phyxmi;
      *ixmax = phyxma;
      *iymin = phyymi;
      *iymax = phyyma;
}

void sphy(ixmin,ixmax,iymin,iymax)
PLINT ixmin,ixmax,iymin,iymax;
{
      phyxmi = ixmin;
      phyxma = ixmax;
      phyymi = iymin;
      phyyma = iymax;
}

void gsub(nx,ny,cs)
PLINT *nx,*ny,*cs;
{
      *nx = nsubx;
      *ny = nsuby;
      *cs = cursub;
}

void ssub(nx,ny,cs)
PLINT nx,ny,cs;
{
      nsubx = nx;
      nsuby = ny;
      cursub = cs;
}

void gumpix(ix,iy)
PLINT *ix,*iy;
{
      *ix = umx;
      *iy = umy;
}

void sumpix(ix,iy)
PLINT ix,iy;
{
      umx = ix;
      umy = iy;
}

void gatt(ifnt,icol)
PLINT *ifnt,*icol;
{
      *ifnt = font;
      *icol = colour;
}

void satt(ifnt,icol)
PLINT ifnt,icol;
{
      font = ifnt;
      colour = icol;
}

void gcol(icol)
PLINT *icol;
{
      *icol = colour;
}

void scol(icol)
PLINT icol;
{
      colour = icol;
}

void gwid(pwid)
PLINT *pwid;
{
      *pwid = width;
}

void swid(pwid)
PLINT pwid;
{
      width = pwid;
}

void gspd(xmin,xmax,ymin,ymax)
PLFLT *xmin,*xmax,*ymin,*ymax;
{
      *xmin = spdxmi;
      *xmax = spdxma;
      *ymin = spdymi;
      *ymax = spdyma;
}

void sspd(xmin,xmax,ymin,ymax)
PLFLT xmin,xmax,ymin,ymax;
{
      spdxmi = xmin;
      spdxma = xmax;
      spdymi = ymin;
      spdyma = ymax;
}

void gvpd(xmin,xmax,ymin,ymax)
PLFLT *xmin,*xmax,*ymin,*ymax;
{
      *xmin = vpdxmi;
      *xmax = vpdxma;
      *ymin = vpdymi;
      *ymax = vpdyma;
}

void svpd(xmin,xmax,ymin,ymax)
PLFLT xmin,xmax,ymin,ymax;
{
      vpdxmi = xmin;
      vpdxma = xmax;
      vpdymi = ymin;
      vpdyma = ymax;
}

void gvpw(xmin,xmax,ymin,ymax)
PLFLT *xmin,*xmax,*ymin,*ymax;
{
      *xmin = vpwxmi;
      *xmax = vpwxma;
      *ymin = vpwymi;
      *ymax = vpwyma;
}

void svpw(xmin,xmax,ymin,ymax)
PLFLT xmin,xmax,ymin,ymax;
{
      vpwxmi = xmin;
      vpwxma = xmax;
      vpwymi = ymin;
      vpwyma = ymax;
}

void gpixmm(x,y)
PLFLT *x,*y;
{
      *x = xpmm;
      *y = ypmm;
}

void spixmm(x,y)
PLFLT x,y;
{
      xpmm = x;
      ypmm = y;
}

void gwp(xscl,xoff,yscl,yoff)
PLFLT *xscl,*xoff,*yscl,*yoff;
{
      *xscl = wpxscl;
      *xoff = wpxoff;
      *yscl = wpyscl;
      *yoff = wpyoff;
}

void swp(xscl,xoff,yscl,yoff)
PLFLT xscl,xoff,yscl,yoff;
{
      wpxscl = xscl;
      wpxoff = xoff;
      wpyscl = yscl;
      wpyoff = yoff;
}

void gwm(xscl,xoff,yscl,yoff)
PLFLT *xscl,*xoff,*yscl,*yoff;
{
      *xscl = wmxscl;
      *xoff = wmxoff;
      *yscl = wmyscl;
      *yoff = wmyoff;
}

void swm(xscl,xoff,yscl,yoff)
PLFLT xscl,xoff,yscl,yoff;
{
      wmxscl = xscl;
      wmxoff = xoff;
      wmyscl = yscl;
      wmyoff = yoff;
}

void gdp(xscl,xoff,yscl,yoff)
PLFLT *xscl,*xoff,*yscl,*yoff;
{
      *xscl = dpxscl;
      *xoff = dpxoff;
      *yscl = dpyscl;
      *yoff = dpyoff;
}

void sdp(xscl,xoff,yscl,yoff)
PLFLT xscl,xoff,yscl,yoff;
{
      dpxscl = xscl;
      dpxoff = xoff;
      dpyscl = yscl;
      dpyoff = yoff;
}

void gmp(xscl,xoff,yscl,yoff)
PLFLT *xscl,*xoff,*yscl,*yoff;
{
      *xscl = mpxscl;
      *xoff = mpxoff;
      *yscl = mpyscl;
      *yoff = mpyoff;
}

void smp(xscl,xoff,yscl,yoff)
PLFLT xscl,xoff,yscl,yoff;
{
      mpxscl = xscl;
      mpxoff = xoff;
      mpyscl = yscl;
      mpyoff = yoff;
}

void gchr(def,ht)
PLFLT *def,*ht;
{
      *def = chrdef;
      *ht = chrht;
}

void schr(def,ht)
PLFLT def,ht;
{
      chrdef = def;
      chrht = ht;
}

void gsym(def,ht)
PLFLT *def,*ht;
{
      *def = symdef;
      *ht = symht;
}

void ssym(def,ht)
PLFLT def,ht;
{
      symdef = def;
      symht = ht;
}

void gmaj(def,ht)
PLFLT *def,*ht;
{
      *def = majdef;
      *ht = majht;
}

void smaj(def,ht)
PLFLT def,ht;
{
      majdef = def;
      majht = ht;
}

void gmin(def,ht)
PLFLT *def,*ht;
{
      *def = mindef;
      *ht = minht;
}

void smin(def,ht)
PLFLT def,ht;
{
      mindef = def;
      minht = ht;
}