/*
 * grph1_swpack.fp
 *
 * $Id: grph1_swpack.fp,v 1.1 2000/11/23 08:15:25 keiko Exp $
 */

/*****************************************************
 * grph1/swpack/swpack.f
 ****************************************************/
/* 
 *      SUBROUTINE SWDOPN
 */
      SUBROUTINE SWDOPN(
      )

/* 
 *      ENTRY SWDCLS
 */
      SUBROUTINE SWDCLS(
      )

/* 
 *      ENTRY SWPOPN
 */
      SUBROUTINE SWPOPN(
      )

/* 
 *      ENTRY SWPCLS
 */
      SUBROUTINE SWPCLS(
      )

/* 
 *      ENTRY SWOOPN(COBJ, COMM)
 *      CHARACTER COBJ*(*), COMM*(*)
 */
      SUBROUTINE SWOOPN(
          CHARACTER*(*) COBJ
          CHARACTER*(*) COMM
      )

/* 
 *      ENTRY SWOCLS(COBJ)
 *      CHARACTER COBJ*(*), COMM*(*)
 */
      SUBROUTINE SWOCLS(
          CHARACTER*(*) COBJ
      )

/* 
 *      ENTRY SWSWDI(IWDIDX)
 */
      SUBROUTINE SWSWDI(
          INTEGER IWDIDX
      )

/* 
 *      ENTRY SWSCLI(ICLIDX)
 */
      SUBROUTINE SWSCLI(
          INTEGER ICLIDX
      )

/* 
 *      ENTRY SWGOPN
 */
      SUBROUTINE SWGOPN(
      )

/* 
 *      ENTRY SWGMOV(WX,WY)
 */
      SUBROUTINE SWGMOV(
          REAL WX
          REAL WY
      )

/* 
 *      ENTRY SWGPLT(WX,WY)
 */
      SUBROUTINE SWGPLT(
          REAL WX
          REAL WY
      )

/* 
 *      ENTRY SWGCLS
 */
      SUBROUTINE SWGCLS(
      )

/* 
 *      ENTRY SWGTON(NP,WPX,WPY,ITPAT)
 *      REAL      WPX(*), WPY(*)
 */
      SUBROUTINE SWGTON(
          INTEGER NP
          REAL (NP) WPX
          REAL (NP) WPY
          INTEGER ITPAT
      )

/* 
 *      ENTRY SWIOPN(IWX,IWY,IMW,IMH)
 */
      SUBROUTINE SWIOPN(
          INTEGER IWX
          INTEGER IWY
          INTEGER IMW
          INTEGER IMH
      )

/* 
 *      ENTRY SWIDAT(IMAGE, NLEN)
 *      INTEGER   IMAGE(*)
 */
      SUBROUTINE SWIDAT(
          INTEGER (NLEN) IMAGE
          INTEGER NLEN
      )

/* 
 *      ENTRY SWICLS
 */
      SUBROUTINE SWICLS(
      )

/* 
 *      ENTRY SWQPNT(WX,WY,MB)
 */
      SUBROUTINE SWQPNT(
          REAL o WX
          REAL o WY
          INTEGER o MB
      )

/* 
 *      ENTRY SWFINT(WX, WY, IWX, IWY)
 */
      SUBROUTINE SWFINT(
          REAL WX
          REAL WY
          INTEGER o IWX
          INTEGER o IWY
      )

/* 
 *      ENTRY SWIINT(IWX, IWY, WX, WY)
 */
      SUBROUTINE SWIINT(
          INTEGER IWX
          INTEGER IWY
          REAL o WX
          REAL o WY
      )

/* 
 *      ENTRY SWQWDC(LWDATR)
 *      LOGICAL   LWDATR, LCLATR, LTNATR, LIMATR, LPTATR
 */
      SUBROUTINE SWQWDC(
          LOGICAL o LWDATR
      )

/* 
 *      ENTRY SWQCLC(LCLATR)
 *      LOGICAL   LWDATR, LCLATR, LTNATR, LIMATR, LPTATR
 */
      SUBROUTINE SWQCLC(
          LOGICAL o LCLATR
      )

/* 
 *      ENTRY SWQTNC(LTNATR)
 *      LOGICAL   LWDATR, LCLATR, LTNATR, LIMATR, LPTATR
 */
      SUBROUTINE SWQTNC(
          LOGICAL o LTNATR
      )

/* 
 *      ENTRY SWQIMC(LIMATR)
 *      LOGICAL   LWDATR, LCLATR, LTNATR, LIMATR, LPTATR
 */
      SUBROUTINE SWQIMC(
          LOGICAL o LIMATR
      )

/* 
 *      ENTRY SWQPTC(LPTATR)
 *      LOGICAL   LWDATR, LCLATR, LTNATR, LIMATR, LPTATR
 */
      SUBROUTINE SWQPTC(
          LOGICAL o LPTATR
      )

/* 
 *      ENTRY SWQRCT(WSXMN,WSXMX,WSYMN,WSYMX,FACT)
 */
      SUBROUTINE SWQRCT(
          REAL o WSXMN
          REAL o WSXMX
          REAL o WSYMN
          REAL o WSYMX
          REAL o FACT
      )

/* 
 *      ENTRY SWSROT(IWTROT)
 */
      SUBROUTINE SWSROT(
          INTEGER IWTROT
      )

/*****************************************************
 * grph1/swpack/swpqnp.f
 ****************************************************/
/* 
 *      SUBROUTINE SWPQNP(NCP)
 */
      SUBROUTINE SWPQNP(
          INTEGER o NCP
      )

/* 
 *      ENTRY SWPQID(CP, IDX)
 *      CHARACTER CP*(*)
 */
      SUBROUTINE SWPQID(
          CHARACTER*(*) CP
          INTEGER o IDX
      )

/* 
 *      ENTRY SWPQCP(IDX, CP)
 *      CHARACTER CP*(*)
 */
      SUBROUTINE SWPQCP(
          INTEGER IDX
          CHARACTER*(*) o CP
      )

/* 
 *      ENTRY SWPQCL(IDX, CP)
 *      CHARACTER CP*(*)
 */
      SUBROUTINE SWPQCL(
          INTEGER IDX
          CHARACTER*(*) o CP
      )

/* 
 *      ENTRY SWPQIT(IDX, ITP)
 */
      SUBROUTINE SWPQIT(
          INTEGER IDX
          INTEGER o ITP
      )

/* 
 *      ENTRY SWPQVL(IDX, IPARA)
 */
      SUBROUTINE SWPQVL(
          INTEGER IDX
          INTEGER o IPARA
      )

/* 
 *      ENTRY SWPSVL(IDX, IPARA)
 */
      SUBROUTINE SWPSVL(
          INTEGER IDX
          INTEGER IPARA
      )

/* 
 *      ENTRY SWPQIN(CP, IN)
 *      CHARACTER CP*(*)
 */
      SUBROUTINE SWPQIN(
          CHARACTER*(*) CP
          INTEGER o IN
      )

/*****************************************************
 * grph1/swpack/swpget.f
 ****************************************************/
/* 
 *      SUBROUTINE SWPGET(CP, IPARA)
 *      CHARACTER CP*(*)
 */
/*      SUBROUTINE SWPGET(
 *          CHARACTER*(*) CP
 *          INTEGER o IPARA
 *      )
 */

/* 
 *      ENTRY SWPSET(CP, IPARA)
 *      CHARACTER CP*(*)
 */
/*      SUBROUTINE SWPSET(
 *          CHARACTER*(*) CP
 *          INTEGER IPARA
 *      )
 */

/* 
 *      ENTRY SWPSTX(CP, IPARA)
 *      CHARACTER CP*(*)
 */
/*      SUBROUTINE SWPSTX(
 *          CHARACTER*(*) CP
 *          INTEGER IPARA
 *      )
 */

/*****************************************************
 * grph1/swpack/swcget.f
 ****************************************************/
/* 
 *      SUBROUTINE SWCGET(CP, CPARA)
 *      CHARACTER CP*(*), CPARA*(*)
 */
      SUBROUTINE SWCGET(
          CHARACTER*(*) CP
          CHARACTER*(*) o CPARA
      )

/* 
 *      ENTRY SWCSET(CP, CPARA)
 *      CHARACTER CP*(*), CPARA*(*)
 */
      SUBROUTINE SWCSET(
          CHARACTER*(*) CP
          CHARACTER*(*) CPARA
      )

/* 
 *      ENTRY SWCSTX(CP, CPARA)
 *      CHARACTER CP*(*), CPARA*(*)
 */
      SUBROUTINE SWCSTX(
          CHARACTER*(*) CP
          CHARACTER*(*) CPARA
      )

/*****************************************************
 * grph1/swpack/swqfnm.f
 ****************************************************/
/* 
 *      SUBROUTINE SWQFNM(CPARA,CFNAME)
 *      CHARACTER CPARA*(*),CFNAME*(*)
 */
      SUBROUTINE SWQFNM(
          CHARACTER*(*) CPARA
          CHARACTER*(*) o CFNAME
      )

/*****************************************************
 * grph1/swpack/swcqnp.f
 ****************************************************/
/* 
 *      SUBROUTINE SWCQNP(NCP)
 */
      SUBROUTINE SWCQNP(
          INTEGER o NCP
      )

/* 
 *      ENTRY SWCQID(CP, IDX)
 *      CHARACTER CP*(*), CVAL*(*)
 */
      SUBROUTINE SWCQID(
          CHARACTER*(*) CP
          INTEGER o IDX
      )

/* 
 *      ENTRY SWCQCP(IDX, CP)
 *      CHARACTER CP*(*), CVAL*(*)
 */
      SUBROUTINE SWCQCP(
          INTEGER IDX
          CHARACTER*(*) o CP
      )

/* 
 *      ENTRY SWCQCL(IDX, CP)
 *      CHARACTER CP*(*), CVAL*(*)
 */
      SUBROUTINE SWCQCL(
          INTEGER IDX
          CHARACTER*(*) o CP
      )

/* 
 *      ENTRY SWCQVL(IDX, CVAL)
 *      CHARACTER CP*(*), CVAL*(*)
 */
      SUBROUTINE SWCQVL(
          INTEGER IDX
          CHARACTER*(*) o CVAL
      )

/* 
 *      ENTRY SWCSVL(IDX, CVAL)
 *      CHARACTER CP*(*), CVAL*(*)
 */
      SUBROUTINE SWCSVL(
          INTEGER IDX
          CHARACTER*(*) CVAL
      )

/* 
 *      ENTRY SWCQIN(CP, IN)
 *      CHARACTER CP*(*), CVAL*(*)
 */
      SUBROUTINE SWCQIN(
          CHARACTER*(*) CP
          INTEGER o IN
      )

/*****************************************************
 * grph1/swpack/swiget.f
 ****************************************************/
/* 
 *      SUBROUTINE SWIGET(CP, IPARA)
 *      CHARACTER CP*(*)
 */
      SUBROUTINE SWIGET(
          CHARACTER*(*) CP
          INTEGER o IPARA
      )

/* 
 *      ENTRY SWISET(CP, IPARA)
 *      CHARACTER CP*(*)
 */
      SUBROUTINE SWISET(
          CHARACTER*(*) CP
          INTEGER IPARA
      )

/* 
 *      ENTRY SWISTX(CP, IPARA)
 *      CHARACTER CP*(*)
 */
      SUBROUTINE SWISTX(
          CHARACTER*(*) CP
          INTEGER IPARA
      )

/*****************************************************
 * grph1/swpack/swiqnp.f
 ****************************************************/
/* 
 *      SUBROUTINE SWIQNP(NCP)
 */
      SUBROUTINE SWIQNP(
          INTEGER o NCP
      )

/* 
 *      ENTRY SWIQID(CP, IDX)
 *      CHARACTER CP*(*)
 */
      SUBROUTINE SWIQID(
          CHARACTER*(*) CP
          INTEGER o IDX
      )

/* 
 *      ENTRY SWIQCP(IDX, CP)
 *      CHARACTER CP*(*)
 */
      SUBROUTINE SWIQCP(
          INTEGER IDX
          CHARACTER*(*) o CP
      )

/* 
 *      ENTRY SWIQCL(IDX, CP)
 *      CHARACTER CP*(*)
 */
      SUBROUTINE SWIQCL(
          INTEGER IDX
          CHARACTER*(*) o CP
      )

/* 
 *      ENTRY SWIQVL(IDX, IPARA)
 */
      SUBROUTINE SWIQVL(
          INTEGER IDX
          INTEGER o IPARA
      )

/* 
 *      ENTRY SWISVL(IDX, IPARA)
 */
      SUBROUTINE SWISVL(
          INTEGER IDX
          INTEGER IPARA
      )

/* 
 *      ENTRY SWIQIN(CP, IN)
 *      CHARACTER CP*(*)
 */
      SUBROUTINE SWIQIN(
          CHARACTER*(*) CP
          INTEGER o IN
      )

/*****************************************************
 * grph1/swpack/swlget.f
 ****************************************************/
/* 
 *      SUBROUTINE SWLGET(CP, LPARA)
 *      CHARACTER CP*(*)
 *      LOGICAL   LPARA
 */
      SUBROUTINE SWLGET(
          CHARACTER*(*) CP
          LOGICAL o LPARA
      )

/* 
 *      ENTRY SWLSET(CP, LPARA)
 *      CHARACTER CP*(*)
 *      LOGICAL   LPARA
 */
      SUBROUTINE SWLSET(
          CHARACTER*(*) CP
          LOGICAL LPARA
      )

/* 
 *      ENTRY SWLSTX(CP, LPARA)
 *      CHARACTER CP*(*)
 *      LOGICAL   LPARA
 */
      SUBROUTINE SWLSTX(
          CHARACTER*(*) CP
          LOGICAL LPARA
      )

/*****************************************************
 * grph1/swpack/swlqnp.f
 ****************************************************/
/* 
 *      SUBROUTINE SWLQNP(NCP)
 */
      SUBROUTINE SWLQNP(
          INTEGER o NCP
      )

/* 
 *      ENTRY SWLQID(CP, IDX)
 *      CHARACTER CP*(*)
 */
      SUBROUTINE SWLQID(
          CHARACTER*(*) CP
          INTEGER o IDX
      )

/* 
 *      ENTRY SWLQCP(IDX, CP)
 *      CHARACTER CP*(*)
 */
      SUBROUTINE SWLQCP(
          INTEGER IDX
          CHARACTER*(*) o CP
      )

/* 
 *      ENTRY SWLQCL(IDX, CP)
 *      CHARACTER CP*(*)
 */
      SUBROUTINE SWLQCL(
          INTEGER IDX
          CHARACTER*(*) o CP
      )

/* 
 *      ENTRY SWLQVL(IDX, LPARA)
 *      LOGICAL   LPARA
 */
      SUBROUTINE SWLQVL(
          INTEGER IDX
          LOGICAL o LPARA
      )

/* 
 *      ENTRY SWLSVL(IDX, LPARA)
 *      LOGICAL   LPARA
 */
      SUBROUTINE SWLSVL(
          INTEGER IDX
          LOGICAL LPARA
      )

/* 
 *      ENTRY SWLQIN(CP, IN)
 *      CHARACTER CP*(*)
 */
      SUBROUTINE SWLQIN(
          CHARACTER*(*) CP
          INTEGER o IN
      )

/*****************************************************
 * grph1/swpack/swrget.f
 ****************************************************/
/* 
 *      SUBROUTINE SWRGET(CP, RPARA)
 *      CHARACTER CP*(*)
 */
      SUBROUTINE SWRGET(
          CHARACTER*(*) CP
          REAL o RPARA
      )

/* 
 *      ENTRY SWRSET(CP, RPARA)
 *      CHARACTER CP*(*)
 */
      SUBROUTINE SWRSET(
          CHARACTER*(*) CP
          REAL RPARA
      )

/* 
 *      ENTRY SWRSTX(CP, RPARA)
 *      CHARACTER CP*(*)
 */
      SUBROUTINE SWRSTX(
          CHARACTER*(*) CP
          REAL RPARA
      )

/*****************************************************
 * grph1/swpack/swrqnp.f
 ****************************************************/
/* 
 *      SUBROUTINE SWRQNP(NCP)
 */
      SUBROUTINE SWRQNP(
          INTEGER o NCP
      )

/* 
 *      ENTRY SWRQID(CP, IDX)
 *      CHARACTER CP*(*)
 */
      SUBROUTINE SWRQID(
          CHARACTER*(*) CP
          INTEGER o IDX
      )

/* 
 *      ENTRY SWRQCP(IDX, CP)
 *      CHARACTER CP*(*)
 */
      SUBROUTINE SWRQCP(
          INTEGER IDX
          CHARACTER*(*) o CP
      )

/* 
 *      ENTRY SWRQCL(IDX, CP)
 *      CHARACTER CP*(*)
 */
      SUBROUTINE SWRQCL(
          INTEGER IDX
          CHARACTER*(*) o CP
      )

/* 
 *      ENTRY SWRQVL(IDX, RPARA)
 */
      SUBROUTINE SWRQVL(
          INTEGER IDX
          REAL o RPARA
      )

/* 
 *      ENTRY SWRSVL(IDX, RPARA)
 */
      SUBROUTINE SWRSVL(
          INTEGER IDX
          REAL RPARA
      )

/* 
 *      ENTRY SWRQIN(CP, IN)
 *      CHARACTER CP*(*)
 */
      SUBROUTINE SWRQIN(
          CHARACTER*(*) CP
          INTEGER o IN
      )

