                     fv OtBNXECu

                              Version  0.99.9b




              Copyright (C) 1998 - 2003  Tamaribuchi, Tsuguhiro

                       tamari@spdg1.sci.shizuoka.ac.jp

                  http://spdg1.sci.shizuoka.ac.jp/grwinlib/



Tu[`Ɗ֐̈ꗗ
#   Fortran     C           @ \ n 
 1. gwinit      GWinit      0 
 1. gwinitx     GWinitx     0 
 2. gwopen      GWopen      EBhẼI[v1 
 2. gwopenx     GWopenx     EBhẼI[v1 
 3. gwquit      GWquit      I0 
 3. gwquitx     GWquitx     I0 
 4. gwleave     GWleave     EBhEȂŏI0 
 5. gwjoin      GWjoin      WCiǉ`̊Jnj0,2 
 6. gwreset     GWreset     p[^̍ď1 
 7. gwclose     GWclose     EBhẼN[Y0 
 8. gwindow     GWindow     [hWn̐ݒ0 
 9. gwgetwn     GWgetwn     [hWn̎擾0 
10. gwvport     GWvport     r[|[g̐ݒ0 
11. gwport      GWport      r[|[g̐ݒ([hWn)0 
12. gwgetvp     GWgetvp     r[|[g̎擾0 
13. gwsavevp    GWsavevp    r[|[g̕ۑ0 
14. gwselvp     GWselvp     r[|[g̑I0 
15. gwfirst     GWfirst     ŏ̃EBhE0 
16. gwnext      GWnext      ̃EBhE0 
17. gwselect    GWselect    EBhEI0 
18. gwshowwn    GWshowwn    EBhE̕\Ԃݒ0 
19. gwshowfr    GWshowfr    t[̕\Ԃݒ0 
20. gwarrange   GWarrange   EBhE̔zu0 
21. gwldcpos    GWldcpos    _foCXWnł̈ʒuW̎擾0 
22. gwldcsiz    GWldcsiz    _foCXWnł̃TCY̎擾0 
23. gwpxlsiz    GWpxlsiz    sNZETCY̎擾0 
24. gwsetpen    GWsetpen    y̎w1 
25. gwgetpen    GWgetpen    y̎擾0 
26. gwsetbrs    GWsetbrs    uV̎w1 
27. gwgetbrs    GWgetbrs    uV̎擾0 
28. gwsettxt    GWsettxt    eLXgptHg̐ݒ1 
29. gwgettxt    GWgettxt    TCY̎擾0 
30. gwputtxt    GWputtxt    (eLXg)̕`1 
31. gwsetsym    GWsetsym    LtHg̐ݒ1 
32. gwgetsym    GWgetsym    L̃TCY擾0 
33. gwputsym    GWputsym    L̏o1 
34. gwsetmsg    GWsetmsg    bZ[W̕\0 
35. msgbox*     GWmsgbox    bZ[W{bNX0 
36. gwgetpos    GWgetpos    yʒu0 
37. gwmove2     GWmove2     ÿړ1 
38. gwline2     GWline2     w肵_܂ł̒1 
39. gwline      GWline      Q_Ԓ2 
40. gwrect      GWrect      lp`̕`1 
41. gwsrect     GWsrect     hԂꂽlp`̕`1 
42. gwrrect     GWrrect     p̊ۂlp`̕`1 
43. gwellipse   GWellipse   ȉ~̕`1 
44. gwarc       GWarc       ʂ̕`1 
45. gwchord     GWchord     ʂ̕`1 
46. gwpie       GWpie       `̕`1 
47. gwplot1     GWplot1     1z̃vbgx 
48. gwpolygon   GWpolygon   p`̕`1 
49. gwpolylin   GWpolylin   ܂̕`1 
50. gwbezier    GWbezier    xWG XvC̕`1 
51. gwflood     GWflood     ̈̓hԂ1 
52. gwclear     GWclear     EBhEʂ̏1 
53. gwsetmrk    GWsetmrk    }[N̎w1 
54. gwputmrk    GWputmrk    }[N`1 
55. gwgetmrk    GWgetmrk    }[N̎擾0 
56. gwsetxfrm   GWsetxfrm   ϊs̐ݒ1 
57. gwgetxfrm   GWgetxfrm   ϊs̎擾0 
58. gwsetrgn    GWsetrgn    NbsÖ̐ݒ1 
59. gwsetpxl    GWsetpxl    sNZ̐ݒ1 
60. gwgetpxl    GWgetpxl    sNZ̘_Fԍ̎擾0 
61. gwcolor     GWcolor     F̐ݒ1 
62. gwgetrgb    GWgetrgb    _FԍRGB(OF)ɕϊ0 
63. krgb*       GWkrgb      RGB(OF)_Fԍւ̕ϊ0 
64. kcolor*     GWkcolor     COLORREF l_Fԍւ̕ϊ0 
65. ipalette*   GWipalette  Windows pbgԍ_Fԍւ̕ϊ0 
66. gwncolor    GWncolor    p\ȐFpbg̎擾0 
67. gwsavecc    GWsavecc    JX^J[̕ۑ0 
68. gwloadcc    GWloadcc    JX^J[̕0 
69. gwsysclr    GWsysclr    VXeɐݒ肳ĂF̎擾0 
70. gwcappnt    GWcappnt    }EXɂ_W̎擾0 
71. gwcapvec    GWcapvec    }EXɂxNg̎擾0 
72. gwcaplin    GWcaplin    }EXɂW̎擾0 
73. gwcaprect   GWcaprect   }EXɂ`W̎擾0 
74. gwloadbmp   GWloadbmp   rbg}bvt@C̓ǂݍ0 
75. gwsavebmp   GWsavebmp   rbg}bvt@C̕ۑ0 
76. gwmakebmp   GWmakebmp   rbg}bv̍쐬0 
77. gwfnt2bmp   GWfnt2bmp   tHgrbg}bvւ̕ϊ0 
78. gwsetbmp    GWsetbmp    rbg}bv̑ݒ0 
79. gwgetbmp    GWgetbmp    rbg}bv̑擾0 
80. gwputbmp    GWputbmp    rbg}bv̕`1 
81. gwcopybmp   GWcopybmp   ۑrbg}bṽRs[o^0 
82. gwdelbmp    GWdelbmp    rbg}bv̓o^폜0 
83. gwcapimg    GWcapimg    `̈̎荞0 
84. gwclipimg   GWclipimg   `̈̃Nbv{[hւ̃Rs[0 
85. gwloadcmb   GWloadcmb   R{Et@C̓ǂݍ0 
86. gwsavecmb   GWsavecmb   R{tBɕۑ0 
87. gwcmbmrk    GWcmbmrk    }[NR{Ƃč쐬0 
88. gwbegincmb  GWbegincmb  R{̍쐬Jn0 
89. gwendcmb    GWendcmb    R{̍쐬I0 
90. gwputcmb    GWputcmb    R{̕`1 
91. gwgetcmb    GWgetcmb    R{̑擾0 
92. gwcopycmb   GWcopycmb   ۑR{̃Rs[o^0 
93. gwdelcmb    GWdelcmb    R{̓o^폜0 
94. gwinput     GWinput     ̓0 
95. gwfiledlg   GWfiledlg   _CAO{bNXɂt@C̎擾0 
96. gwload      GWload      f[^̓ǂݍ0 
97. gwsaveas    GWsaveas    f[^̕ۑ0 
98. gwprint     GWprint     0 
99. gwsetogn    GWsetogn    IuWFNgEO[vԍ̐ݒ0 
100. gwanchor    GWanchor    AJ[1,-x 
101. gwsetbk     GWsetbk     wi̐ݒx 
102. gwerase     GWerase     }`̏-x 
103. gwflush     GWflush     tbV`-x 
104. gwrefresh   GWrefresh   ʂ̍ĕ`0 
105. gwvwmod     GWvwmod     r[[h0 
106. gwmode      GWmode      [hݒƖ₢킹0 
107. gwkybrd     GWkybrd     L[{[hEXe[^X0 
108. gwmouse     GWmouse     }EX0 
109. gwtimer     GWtimer     C^[oE^C}[0 
110. gwevent     GWevent     CxgԂ̎擾0 
111. gwidle      GWidle      AChO0 
112. gwidle2     GWidle2     AChO 20 
113. gwsleep     GWsleep     X[v1 
114. gwsleep2    GWsleep2    X[v 21 
115. gwctime     GWctime     ݎ̎擾0 
116. gwpause     GWpause     |[Y0 
117. gwsize      GWsize      eTCY̎擾/ݒ0 
118. gwaspect*   GWaspect    AXyNg̎擾0 
119. gwfmax*     GWfmax      _̍ől0 
120. gwversion   GWversion   o[Wԍ̎擾0 
121. kbhit*      kbhit       R\[EL[{[h0 
122. kbgetch*    kbgetch     R\[ł̃L[ER[h̎擾0 
123. gwtspawn    GWTspawn    ^[gF0 
124. gwdtturn    GWTturn     ^[gFis̕ύX1 
124. gwdtturn    GWDTturn    ^[gFis̕ύX1 
125. gwdtforward GWTforward  ^[gFOi1 
125. gwdtforward GWDTforward ^[gFOi1 
126. gwdtshift   GWTshift    ^[gFΈړ1 
126. gwdtshift   GWDTshift   ^[gFΈړ1 
127. gwdtmove2   GWTmove2    ^[gFw_ւ̈ړ1 
127. gwdtmove2   GWDTmove2   ^[gFw_ւ̈ړ1 
128. gwtclone    GWTclone    ^[g𕡐0 
129. gwtremove   GWTremove   ^[g菜0 
130. gwdtsetpos  GWTsetpos   ^[gʒuݒ1 
130. gwdtsetpos  GWDTsetpos  ^[gʒuݒ1 
131. gwdtgetpos  GWTgetpos   ^[gʒu̎擾0 
131. gwdtgetpos  GWDTgetpos  ^[gʒu̎擾0 
132. gwdtsetdir  GWTsetdir   ^[gFis̐ݒ1 
132. gwdtsetdir  GWDTsetdir  ^[gFis̐ݒ1 
133. gwdtgetdir  GWTgetdir   ^[gFis̎擾0 
133. gwdtgetdir  GWDTgetdir  ^[gFis̎擾0 
134. gwtsetcol   GWTsetcol   ^[gFF̐ݒ1 
135. gwtgetcol   GWTgetcol   ^[gFF̎擾1 
136. gwtsetpen   GWTsetpen   ^[gFy̐ݒ1 
137. gwdtsetmrk  GWTsetmrk   ^[gF}[Nݒ1 
137. gwdtsetmrk  GWDTsetmrk  ^[gF}[Nݒ1 
138. plots       Ȃ        (Calcomp nR}h)0 
139. plote       Ȃ        I(Calcomp nR}h)0 
140. plot        Ȃ        ÿړ/̕`(Calcomp nR}h)1 
141. window      Ȃ        [hWn̐ݒ(Calcomp nR}h)0 
142. newpen      Ȃ        y̐F(Calcomp nR}h)1 
143. symbol      Ȃ        ̕\(Calcomp nR}h)1 
144. number      Ȃ        l̕\(Calcomp nR}h)2 
145. gcls        Ȃ        OtBNXʏ(Calcomp nR}h)0 



{Cuł́CEBhEI[vƉzIȒ`́upv[
ɗpӂāCKȃ[`R[邱ƂɂāC}`IuWFNg
upvɕ`悳܂Bupv ̃TCY͌ƂăI[vɌ肳C 
ʂɂ́Cۂɏo͂fXvBʂ̕\ "vgp" ̃TCYƂ͖
֌WłDupvfXvBʂv^ɏo͂ۂɂ́Cr[(\)
[hɉāĆupv ꂼ̃foCXɃ}bsO܂DpŎ
ۂɕ`s`̗̈ur[|[gvƌĂт܂B[U[̓r[|[g
̍ƉE̓_̍W^邱ƂŔCӂ̍Wn`邱ƂłC̍W
nu[hWnvƌĂт܂B{CûقƂǂ̃[`ł͂́u
[hWnvp܂DupvɃr[|[gݒ肷ɂ́uKi_
Wnvg܂BKi_WńC`}`̏cɂ܂܁Cp
Z̕ӂ̒1ɋKiWnŁC_́upv̍Ƃ܂BK
i_Wnł́Cupv ̏ꍇ̉E̍W (W/H, 1.0) ɂȂ
BŁCW  H ́upv̕ƍ(sNZP)łBupvɌŒ肳
Cupv̍_Cu  v ꂼEƉɂƂWn
u_foCXWnv(LDC) ƌĂсCŗp܂Bu_foCXWn
v̒Pʂ̓v^ɏo͂Ƃ1sNZɑΉĂ܂D

̐ Fortran Ɋւ镔ɂĂ͑Sđ啶gĂ܂C
Fortran ł͎ʎq(ϐTu[`Ȃ)̑啶Ə͋ʂ܂
̂ŁCR̈ꗗ̂悤ɏgƂł܂BɂāCC 
͋ʂ܂̂ŒӂĂB̈ꗗĂ킩悤Fortran p
Tu[`(yъ֐) C p̊֐ 1:1 ɑΉĂ܂Bڍׂ͊eTu
[`֐ɂẲ̋LqQƂĎgpĂB

GWT Ŏn܂郋[`Q̓^[gEOtBNX̂߂̂̂łBꂼɑΉ
āCGWDT Ŏn܂郋[`Qp\ŁCGWDTxxxxx  GWTxxxxx ̔{xł
B܂CGWDTxxxxx gꍇɂ́C{}jȂΉ GWTxxxxx ̋LqŁC
REAL  REAL*8 ܂ DOUBLE PRECISION iFORTRAN ̏ꍇjɁC܂Cfloat 
ׂ double iC ܂ C++ ̏ꍇjɓǂ݂Kv܂B̃[`
Q͍ĕ`̂߂̍WiȉQƁj[hWƂāC 
(GWTxxxxx) ܂͔{x (GWDTxxxxx) ŕێ̂ŁC΍Wɂ`ł
덷̒~ςقƂǐ܂B

Ō 8 ̃Tu[`(#138`#145) Calcomp ñTu[`gpv
OpɁCŒ̌݊mۂ̂߂ɗpӂꂽR}hQłBC
ɂĂ͑Ή C ̊֐͂܂B

^[gEOtBNX Calcomp ñ[`QׂāCIɂ GW***** 
R}hQƓȂ̂ŁC݂ėpĂ肠܂BȂC
'n' ̐͊e[`̋@\ɑΉIuWFNg(}`f[^)̐܂
DۑꂽIuWFNg͍ĕ`ɎgpC gwsaveas/GWsaveas  
gwload/GWload Ńt@Cɕۑt@C畜邱Ƃł܂D

ȉł́C[F]  Fortarn ł̒`C[C]  C ł̒`\Ă܂B
Fortran Tu[`ɂ IRTN ̓^[ER[hŁCƂɒf
ȂCŝƂ 0C 0 łȂlԂ܂B܂CC ̊e
̖߂l IRTN ƓłDC ̏ꍇɂ́CGWsize āCo͕ϐɎw肳
Ă|C^^̈́Csv̏ꍇ NULL Ƃ邱Ƃł܂B
֐̌ɂ́uvpł܂B



GrWin CuE[`

1. 
-----------------------------------------------------------------------------
[F] SUBROUTINE GWINIT(IRTN)
    INTEGER IRTN

[C] int GWinit(void);
-----------------------------------------------------------------------------
()
    CȕsB̍ہCC(t[)EEBhEJĂ
    Ȃ΁Cgrwnd.exe IvVȂŎsCJBAvP[V2x
    ȏ̌ĂяosĂ邾ŎQ͂ȂB
     GWinitx(-1,-1,-1,-1,-1,-1,-1,-1,-1) ƓB
    GWopen ̌ĂяoɁCKvȂ玩IɌĂяôŒʏ͏ȗB
-----------------------------------------------------------------------------
[F] SUBROUTINE GWINITX(IRTN, IRB, IX, IY, IW, IH, MA, MM, MZ, ND)
    INTEGER IRTN, IRB, IX, IY, IW, IH, MA, MM, MZ, ND

[C] int GWinitx(int IRB, int IX, int IY, int IW, int IH, int MA, int MM, 
		int MZ, int ND);
-----------------------------------------------------------------------------
()
    CȕsCC(t[)EEBhEJĂȂ
    grwnd.exe Xg̕тɑΉIvVŎsCJBAvP[
    V2xȏ̌ĂяosĂ邾ŎQ͂ȂB̒l
    ̏ꍇɂ͑ΉR}hCEIvV͐ȂB
    GWopen ̌ĂяoɁCKvȂ GWinitx(-1,-1,-1,-1,-1,-1,-1,-1) I
    ĂяôŁCIvVwsꍇďȗB
(͕ϐ)
    IRB = O*32 + L*16 + I*8 + R*4 + B*2 + T*1 
            + 65536*(o*32 + l*16 + i*8 + r*4 + b*2 + t*1)
          O = 1[0] IɃEBhE [Ȃ]
          L = 1[0] v^̃hXP[vipujE[h ON [OFF]
          I = 1[0] mF[h ON [OFF]
          R = 1[0] Xe[^Xo[\ ON [OFF]
          B = 1[0] obt@OE[h ON [OFF]
          T = 1[0] ۑ[h ON [OFF]
       [l, i,... ́Cꂼ L, I,... ̐ݒ荀ڂɑΉ}XNrbg
       i0 ܂ 1jŁC}XNrbg 1 ̐ݒ荀ڂ͖]
 IX, IY = t[̍̃XN[W (sNZl)
 IW, IH = t[̕ƍ (sNZl)
     MA = EBhE̔zu[hԍ (MA = 1..4)B GWarrange(MA) ƓB
     MM = t[̕\[hԍ (MM = 0..14)B GWshowfr(MM) ƓB
     MZ = t[̕\[hԍ (MZ = 1..4)B GWshowfr(MZ+10) ƓB
     ND = Ȃǂɉ肳𑜓xidpi lj
(o͕ϐ)
  IRTN = ^[ER[h

[TOC] [INDEX]

2. EBhẼI[v
-----------------------------------------------------------------------------
[F] SUBROUTINE GWOPEN(IRTN, NW)
    INTEGER IRTN, NW

[C] int GWopen(int NW);
-----------------------------------------------------------------------------
()
    GWopenx  IW = 0, IH = 0, IFC = -1, IBC = -1, M = -1, FN = ''(NULL) 
   w肵̂ƓB

-----------------------------------------------------------------------------
[F] SUBROUTINE GWOPENX(IRTN, NW, IW, IH, IFC, IBC, M, FN)
    INTEGER IRTN, NW, IW, IH, IFC, IBC, M
    CHARACTER FN*(*)

[C] int GWopenx(int NW, int IW, int IH, int IFC, int IBC, int M, char *FN);
-----------------------------------------------------------------------------
()
   NW > 0 ̏ꍇɂ́Cw肳ꂽԍ NWAt@C FN ̃EBhEJB
   NW = 0 ̏ꍇ͎gĂȂEBhEԍgpB̍ہCgp̃
   C(t[)EEBhEȂ΁CGWINIT Ăяoďs
   Bł 'WC' (GWJOIN Q) ɐĂꍇɂ NW  FN ̎w
   BIW  IH ɂ͗p̕ƍ 0.1mm PʂŎw肷BIɂ́C
   w肳ꂽi邢͏ȗĺjƍCшȂǂɉ肳𑜓xi
   GWinitx QƁjƂɃobt@prbg}bvETCY肳BIFC  
   IBC ͑OiFƔwiF̏l_FԍŎw肷BǂC̒lݒ肳
   ꂽꍇɂ͏ȗlpB ȂCwiF IBC ̎wɂ Windows Wp
   bgƑ COLORREF lwłȂ(GWcolor Q)B M (0..10) ̓I[v
   ̃EBhE̕\ (GWshowwn Q)B
(͕ϐ)
   NW = EBhEԍ (0,1,2,3,...)
   IW = p̕ (0 ̏ꍇAv^[̏ȗlgp)
   IH = p̍ (0 ̏ꍇAv^[̏ȗlgp)
  IFC = OiF̏l(_Fԍ: GWCOLOR Q)Bȗl 0  ()
  IBC = wiF̏l(_Fԍ: GWCOLOR Q)Bȗl 19 ()
    M = I[ṽEBhE̕\ (< 0 ̏ꍇ͏ȗl)
   FN = OtBNXEf[^ۑꍇ̃ftHg̃t@C
(o͕ϐ)
 IRTN = ۂɊJꂽEBhEԍ ( > 0 ), ŝƂ 0

[TOC] [INDEX]

3. I
-----------------------------------------------------------------------------
[F] SUBROUTINE GWQUIT(IRTN)
    INTEGER IRTN

[C] int GWquit(void);
-----------------------------------------------------------------------------
()
   I_CAO\C҂ĂCAvP[VJׂĂ
   EBhEāAIsBɊJĂEBhEꍇɂ
   C(t[)EEBhEB GWquitx(1) ƓB

-----------------------------------------------------------------------------
[F] SUBROUTINE GWQUITX(IRTN, MQ)
    INTEGER IRTN, MQ

[C] int GWquitx(int MQ);
-----------------------------------------------------------------------------
()
   AvP[VJׂẴEBhEAIsB̒l
   ďI_CAO̐sB
(͕ϐ)
   MQ = 0 :   I_CAOoɒɏIsB
        :   I_CAO\ĂC͂҂ďIsB
(o͕ϐ)
  IRTN = ^[ER[h

[TOC] [INDEX]

4. EBhEȂŏI
-----------------------------------------------------------------------------
[F] SUBROUTINE GWLEAVE(IRTN)
    INTEGER IRTN

[C] int GWleave(void);
-----------------------------------------------------------------------------
()
   EBhEȂŁAIsB
(͕ϐ)
   Ȃ

(o͕ϐ)
  IRTN = ^[ER[h

[TOC] [INDEX]

5. WCiǉ`̊Jnj
-----------------------------------------------------------------------------
[F] SUBROUTINE GWJOIN(IRTN, NW, IN, IS, JND)
    INTEGER IRTN, NW, IN, IS
    CHARACTER JND*(*)

[C] int GWjoin(int NW, int IN, int IS, char *JND);
-----------------------------------------------------------------------------
()
   ̓p[^ (NW, IN) Ŏw肳ꂽEBhEɐڑĒǉ`s߂
   iWCjsB̓p[^ IN ŃCEEBhEiGrWndj
   CNW ŃEBhEԍiGWopen QƁjw肷B{[` GWinit[x] 
    GWopen[x] ɌĂяoȂ΂ȂȂB GWinit[x]  GWopen[x] 
   Ăяoꂽ_Ŗ{ݒ肪LƂȂCNW, IN ̂ǂ̓̓p[^ɂ
   Ă 0 w肳ꂽꍇɂ́CΉEBhEōŏɂ݂̂g
   C݂Ȃꍇ͐VɊJB'WC'̃EBhȄ͕ϐ JND 
   Ŏ󂯎邱ƂłB'WC'\ǂm邾̏ꍇ IS  0 
   ݒ肷΂悢B̏ꍇCo͕ϐ̐ݒ肾'WC'͍sȂ
   ŁC'WC'ꍇɂ IS  0 łȂlݒ肵Ė{[`x
   ĂяoKvB

   ӁFP̃EBhEɕ̃AvP[V'WC'ꍇ̌ʂɂ
   Ă͕ۏ؂ȂB
(͕ϐ)
   NW = EBhEԍ (0,1,2,3,...)
   IN = CEEBhEiGrWndjԍ (0,1,2,3,...)
(o͕ϐ)
  JND = 'WC'ɐꍇ́CCEEBhEԍCEBhEԍCA
        vP[VJ}ŋ؂Bsꍇ͋̕B
 IRTN = ۂɊJꂽEBhEԍ ( > 0 ), ŝƂ 0

[TOC] [INDEX]

6. p[^̍ď
-----------------------------------------------------------------------------
[F] SUBROUTINE GWRESET(IRTN)
    INTEGER IRTN

[C] int GWreset(void);
-----------------------------------------------------------------------------
()
   ݂̃EBhE̊ep[^ftHglɖ߂B
(͕ϐ)
   Ȃ

(o͕ϐ)
  IRTN = ^[ER[h

[TOC] [INDEX]

7. EBhẼN[Y
-----------------------------------------------------------------------------
[F] SUBROUTINE GWCLOSE(IRTN, NW)
    INTEGER IRTN, NW

[C] int GWclose(int NW);
-----------------------------------------------------------------------------
()
   w肵OtBNXEEBhEB
(͕ϐ)
   NW > 0: w肵ԍ̃EBhEN[Y
      = 0: JgEEBhEN[Y
      < 0: AvP[VJׂẴEBhE
(o͕ϐ)
 IRTN = JgEEBhEԍCJĂEBhE 0

[TOC] [INDEX]

8. [hWn̐ݒ
-----------------------------------------------------------------------------
[F] SUBROUTINE GWINDOW(IRTN, X1,Y1,X2,Y2)
    INTEGER IRTN
    REAL X1,Y1,X2,Y2

[C] int GWindow(float X1, float Y1, float X2, float Y2);
-----------------------------------------------------------------------------
()
   r[|[g̓_ƉE̓_̍W[hWŗ^邱Ƃɂ胏[
   hWnݒ肷BftHgł͗p̃TCY͍_ɁC 
       (X1, Y1, X2, Y2) = (0.0, 0.0, 640.0, 640.0/U2*V2)
   ɐݒ肳ĂD(U2,V2) ́DKi_Wnɂr[|[g̉E̓_
   ̍WBX1 = X2  Y1 != Y2 ̏ꍇɂ́C r[|[gӒ̓_̃[
   hW (X1, Y1)Cr[|[g̃[hWnł̍ | Y2 - Y1 | ́CA
   XyNgic̃XP[j 1:1 ̍Wnݒ肳BlɁCX1 != X2 
    Y1 = Y2 ̏ꍇɂ́Cɍ킹AXyNg䂪 1:1 ̍Wnݒ肳
   B X1 = X2  Y1 = Y2 ̏ꍇɂ́C[hWn͘_foCXWnƓ
   ɂȂB
(͕ϐ)
   X1 = r[|[g X W([hWn)
   Y1 = r[|[g Y W([hWn)
   X2 = r[|[gE X W([hWn)
   Y2 = r[|[gE Y W([hWn)
(o͕ϐ)
  IRTN = ^[ER[h

[TOC] [INDEX]

9. [hWn̎擾
-----------------------------------------------------------------------------
[F] SUBROUTINE GWGETWN(IRTN, X1,Y1,X2,Y2)
    INTEGER IRTN
    REAL X1,Y1,X2,Y2

[C] int GWgetwn(float *X1, float *Y1, float *X2, float *Y2);
-----------------------------------------------------------------------------
()
  ݂̃[hWn擾(GWINDOW Q)B
(͕ϐ)
   Ȃ
(o͕ϐ)
   X1 = r[|[g X W([hWn)
   Y1 = r[|[g Y W([hWn)
   X2 = r[|[gE X W([hWn)
   Y2 = r[|[gE Y W([hWn)
 IRTN = ^[ER[h

[TOC] [INDEX]

10. r[|[g̐ݒ
-----------------------------------------------------------------------------
[F] SUBROUTINE GWVPORT(IRTN, U1,V1,U2,V2)
    INTEGER IRTN
    REAL U1,V1,U2,V2

[C] int GWvport(float U1, float V1, float U2, float V2);
-----------------------------------------------------------------------------
()
   Ki_WnŃr[|[gݒ肷BKi_WnƂ́Cp̃AX
   yNg(c)ۂ܂܁Cp̕(W)ƍ(H)̒Z 1 ɋKi
   Wn̂ƁBU1 = U2C܂́CV1 = V2 w肵ꍇɂ͗pŜɃr[
   |[gݒ肳B
(͕ϐ)
   U1 = r[|[g X W (Ki_Wn)
   V1 = r[|[g Y W (Ki_Wn)
   U2 = r[|[gE X W (Ki_Wn)
   V2 = r[|[gE Y W (Ki_Wn)
(o͕ϐ)
  IRTN = ^[ER[h

[TOC] [INDEX]

11. r[|[g̐ݒ([hWn)
-----------------------------------------------------------------------------
[F] SUBROUTINE GWPORT(IRTN, X1,Y1,X2,Y2)
    INTEGER IRTN
    REAL X1,Y1,X2,Y2

[C] int GWport(float X1, float Y1, float X2, float Y2);
-----------------------------------------------------------------------------
()
   [hWnŃr[|[gݒ肷BX1 = X2C܂́CY1 = Y2 w肵
   ꍇɂ͗pŜɃr[|[gݒ肳B[hWnωȂ
   ɂ́C GWINDOW(IRTN, X1,Y1,X2,Y2) ĂяoKvB
(͕ϐ)
   X1 = r[|[g X W ([hWn)
   Y1 = r[|[g Y W ([hWn)
   X2 = r[|[gE X W ([hWn)
   Y2 = r[|[gE Y W ([hWn)
(o͕ϐ)
  IRTN = ^[ER[h

[TOC] [INDEX]

12. r[|[g̎擾
-----------------------------------------------------------------------------
[F] SUBROUTINE GWGETVP(IRTN, U1,V1,U2,V2)
    INTEGER IRTN
    REAL U1,V1,U2,V2

[C] int GWgetvp(float *U1, float *V1, float *U2, float *V2);
-----------------------------------------------------------------------------
()
  ݂̃r[|[g擾(GWVPORT Q)B
(͕ϐ)
   Ȃ
(o͕ϐ)
   U1 = r[|[g X W (Ki_Wn)
   V1 = r[|[g Y W (Ki_Wn)
   U2 = r[|[gE X W (Ki_Wn)
   V2 = r[|[gE Y W (Ki_Wn)
 IRTN = ^[ER[h

[TOC] [INDEX]

13. r[|[g̕ۑ
-----------------------------------------------------------------------------
[F] SUBROUTINE GWSAVEVP(IRTN, IVP)
    INTEGER IRTN, IVP

[C] int GWsavevp(int IVP);
-----------------------------------------------------------------------------
()
  ݂̃r[|[gw肵r[|[gԍŕۑBۑꂽr[
  |[g GWselvp ŌĂяoƂłB
(͕ϐ)
  IVP = r[|[gԍ ( > 0 )
(o͕ϐ)
  IRTN = ^[ER[h

[TOC] [INDEX]

14. r[|[g̑I
-----------------------------------------------------------------------------
[F] SUBROUTINE GWSELVP(IRTN, IVP)
    INTEGER IRTN, IVP

[C] int GWselvp(int IVP);
-----------------------------------------------------------------------------
()
  r[|[gIBw肳ꂽr[|[gԍ IVP `̏ꍇ͉
  ȂB  ƁCr[|[gƑΉ郏[hWnB
  r[|[gԍ IVP = 0 ɂ̓ftHg̐ݒ肪ۑĂB
(͕ϐ)
  IVP = r[|[gԍ
(o͕ϐ)
  IRTN = ^[ER[h

[TOC] [INDEX]

15. ŏ̃EBhE
-----------------------------------------------------------------------------
[F] SUBROUTINE GWFIRST(IRTN)
    INTEGER IRTN

[C] int GWfirst(void);
-----------------------------------------------------------------------------
()
   ̃AvP[VI[vŏ̃EBhE̔ԍ擾B

(͕ϐ)
   Ȃ
(o͕ϐ)
 IRTN = ŏ̃EBhẼEBhEԍ, ŝƂ 0

[TOC] [INDEX]

16. ̃EBhE
-----------------------------------------------------------------------------
[F] SUBROUTINE GWNEXT(IRTN, NW)
    INTEGER IRTN, NW

[C] int GWnext(int NW);
-----------------------------------------------------------------------------
()
   w肵EBhE̎ɃI[vEBhE̔ԍ擾B
   I[vĂ邷ׂẴEBhE̔ԍ擾ɂ́Aŏ GWfirst 
   ĂłA0 Ԃ܂ GWnext JԂĂׂ΂悢BC ̏ꍇɃEB
   hEԍ NW XVɂ
      NW = GWnext(NW);
   ƂāC֐̖߂l𖾎I NW ɑȂĂ͂ȂȂB
(͕ϐ)
   EBhEԍ
(o͕ϐ)
 IRTN = ̃EBhẼEBhEԍCsƂ 0

[TOC] [INDEX]

17. EBhEI
-----------------------------------------------------------------------------
[F] SUBROUTINE GWSELECT(IRTN, NW)
    INTEGER IRTN, NW

[C] int GWselect(int NW);
-----------------------------------------------------------------------------
()
   w肳ꂽEBhEԍ̃EBhEJgEEBhEɐݒ肷B
(͕ϐ)
   NW = EBhEԍ (1,2,3,...)
(o͕ϐ)
 IRTN = JgEEBhEԍ

[TOC] [INDEX]

18. EBhE̕\Ԃݒ
-----------------------------------------------------------------------------
[F] SUBROUTINE GWSHOWWN(IRTN, NW, IS)
    INTEGER IRTN, NW, IS

[C] int GWshowwn(int NW, int IS);
-----------------------------------------------------------------------------
()
   w肳ꂽEBhEԍ̃EBhE̕\Ԃݒ肷BJgEEBh
   E͕ύXȂBNW = 0 ̏ꍇ̓JgEEBhEw肳B
(͕ϐ)
   NW = EBhEԍ (0,1,2,3,...)
   IS = 0: EBhE\ɂÃEBhEANeBuɂ܂B 
        1: EBhEő剻܂B 
        2: EBhEŏAZ ʂ̃gbvxEBhEANeBu
           ɂ܂B 
        3: EBhEANeBuɂA\܂BEBhEŏĂ
           ő剻Ă肷ƁÄʒuƃTCYɖ߂܂B 
        4: EBhEANeBuɂāÄ݂ʒuƃTCYŕ\܂B 
        5: EBhEANeBuɂāAő剻܂B 
        6: EBhEANeBuɂāAŏ܂B 
        7: EBhEŏ܂BANeBuȃEBhÉAANeBuȏ
           ێ܂BANeBuȃEBhÉAANeBuȂ܂܂łB 
        8: EBhȄ݂Ԃŕ\܂BANeBuȃEBhE̓ANeB
           uȏԂێ܂B 
        9: EBhE𒼑ÖʒuƃTCYŕ\܂BANeBuȃEBhE
           ANeBuȏԂێ܂B 
       10: EBhEANeBuɂāA\܂BEBhEŏ܂͍
           剻ĂƂ́AʒuƃTCYɖ߂܂B 

(o͕ϐ)
  IRTN = ^[ER[h

[TOC] [INDEX]

19. t[̕\Ԃݒ
-----------------------------------------------------------------------------
[F] SUBROUTINE GWSHOWFR(IRTN, IS)
    INTEGER IRTN, IS

[C] int GWshowfr(int IS);
-----------------------------------------------------------------------------
()
   t[(g)̕\Ԃݒ肷B
(͕ϐ)
   IS = 0: t[\ɂÃt[ANeBuɂ܂(HIDE)
        1: t[ő剻܂(MAXIMIZE)
        2: t[ŏAZ ʂ̃gbvxt[ANeBu
           ɂ܂(MINIMIZE)
        3: t[ANeBuɂA\܂Bt[ŏĂ
           ő剻Ă肷ƁÄʒuƃTCYɖ߂܂(RESTORE)
        4: t[ANeBuɂāÄ݂ʒuƃTCYŕ\܂(SHOW)
        5: t[ANeBuɂāAő剻܂(SHOWMAXIMIZED)
        6: t[ANeBuɂāAŏ܂(SHOWMINIMIZED)
        7: t[ŏ܂BANeBuȃt[́AANeBuȏ
           ێ܂BANeBuȃt[́AANeBuȂ܂܂ł
           (SHOWMINNOACTIVE)
        8: t[݂̏Ԃŕ\܂BANeBuȃt[̓ANeB
           uȏԂێ܂(SHOWNA)
        9: t[𒼑ÖʒuƃTCYŕ\܂BANeBuȃt[
           ANeBuȏԂێ܂(SHOWNOACTIVATE)
       10: t[ANeBuɂāA\܂Bt[ŏ܂͍
           剻ĂƂ́AʒuƃTCYɖ߂܂(SHOWNORMAL)
       11: t[őOʂɒu(TOPMOST)
       12: t[őOʂ̎ɒu(NOTOPMOST)
       13: t[ԏɒu(TOP)
       14: t[ԉɒu(BOTTOM)

(o͕ϐ)
  IRTN = ^[ER[h

[TOC] [INDEX]

20. EBhE̔zu
-----------------------------------------------------------------------------
[F] SUBROUTINE GWARRANGE(IRTN, M)
    INTEGER IRTN, M

[C] int GWarrange(int M);
-----------------------------------------------------------------------------
()
   C(t[)EEBhẼNCAgEEBhEĔzuB
   j[Eo[[EBhE] w肷̂Ɠ (M < 5 ̏ꍇ)B
(͕ϐ)
    M = 1: d˂ĕ\
        2: cɕׂĕ\
        3: ɕׂĕ\
        4: ACR̐
        5: JgEEBhEANeBuɂ
        6: JgEEBhEő剻
        7: JgEEBhẼTCYɖ߂
        8: JgEEBhEj
(o͕ϐ)
  IRTN = ^[ER[h

[TOC] [INDEX]

21. _foCXWnł̈ʒuW̎擾
-----------------------------------------------------------------------------
[F] SUBROUTINE GWLDCPOS(IRTN, X, Y, IU, IV)
    REAL X, Y
    INTEGER IRTN, IU, IV

[C] int GWldcpos(float X, float Y, int *IU, int *IV);
-----------------------------------------------------------------------------
()
    [hW (X, Y) _foCXW [IU, IV] ֕ϊB_foCX
    WńupvɌŒ肳ꂽWnŁCupv̍_ [0,0]CE
    [W-1,H-1] ƂWnB W  H ́upv̕ƍiv^̃sN
    ZPʁjB
(͕ϐ)
    X = X W([hWn)
    Y = Y W([hWn)
(o͕ϐ)
   IU = U W(_foCXWn)
   IV = V W(_foCXWn)
 IRTN = ^[ER[h

[TOC] [INDEX]

22. _foCXWnł̃TCY̎擾
-----------------------------------------------------------------------------
[F] SUBROUTINE GWLDCSIZ(IRTN, W, H, IU, IV)
    REAL X, Y
    INTEGER IRTN, IU, IV

[C] int GWldcsiz(float W, float H, int *IU, int *IV);
-----------------------------------------------------------------------------
()
    [hWnł̕ W ƍ H _foCXWn֕ϊB
(͕ϐ)
    X = [hWnł̕
    Y = [hWnł̍
(o͕ϐ)
   IU = _foCXWnł̕
   IV = _foCXWnł̍
 IRTN = ^[ER[h

[TOC] [INDEX]

23. sNZETCY̎擾
-----------------------------------------------------------------------------
[F] SUBROUTINE GWPXLSIZ(IRTN, W, H)
    REAL X, Y

[C] int GWpxlsiz(float *W, float *H);
-----------------------------------------------------------------------------
()
    gp̃fBXvC1sNZɑΉ郏[hWnł̕ W ƍ H 
    ̌ݒl擾Bl݂͌̕\EBhẼTCY\[h
    ˑB
(͕ϐ)
    Ȃ
(o͕ϐ)
    X = [hWnł̕
    Y = [hWnł̍
 IRTN = ^[ER[h

[TOC] [INDEX]

24. y̎w
-----------------------------------------------------------------------------
[F] SUBROUTINE GWSETPEN(IRTN, IPC, IPS, IPW, MX)
    INTEGER IRTN, IPC, IPS, IPW, MX

[C] int GWsetpen(int IPC, int IPS, int IPW, int MX);
-----------------------------------------------------------------------------
()
   JgEEBhEŎgpy̐FCCC[hw肷B
   (IPS=1)ȊO̐gpꍇ͐͂Pɐݒ肳B[hɂ
   CyuV̐FƁAłɕ`ĂȂǂƂ̐F̍@߂B
   MX > 15 ̏ꍇ MX-16 ̒l̂܂ "Q ROP R[h[W]" ƂĎgpB
   ƂāAlł΂̍ڂ͕ύXȂCIPC ɂĂ -1 ȊO
   ̒lɂ͓ʂ̈Ӗ̂ŒӁBׂĂ͕̓ϐ -1 ̏ꍇɂ̓yʒu
   (GWLINE2 Q)B
(͕ϐ)
  IPC = _Fԍ
         -1 ̏ꍇ͕ύXȂ
         ̑̏ꍇɂĂ GWCOLOR ̍QƁB

  IPS = 
        0: (NULL)
        1: (SOLID)
        2: j(DASH)
        3: _(DOT)
        4: P_(DASHDOT)
        5: Q_(DASHDOTDOT)

  IPW = _foCXWnŎw肷B0 w肷ƃfoCXɂ炸
        1 sNZɂȂB

   MX = [h
        0:	NOP
        1:	BLACK
        2:	WHITE
        3:	NOT
        4:	COPYPEN
        5:	MASKPEN
        6:	MERGEPEN
        7:	XORPEN
        8:	NOTCOPYPEN
        9:	NOTMASKPEN
       10:	NOTMERGEPEN
       11:	NOTXORPEN
       12:	MASKNOTPEN
       13:	MASKPENNOT
       14:	MERGENOTPEN
       15:	MERGEPENNOT
(o͕ϐ)
  IRTN = ^[ER[h

[TOC] [INDEX]

25. y̎擾
-----------------------------------------------------------------------------
[F] SUBROUTINE GWGETPEN(IRTN, IPC, IPS, IPW, MX)
    INTEGER IRTN, IPC, IPS, IPW, MX

[C] int GWgetpen(int *IPC, int *IPS, int *IPW, int *MX);
-----------------------------------------------------------------------------
()
   JgEEBhEŎgpĂy̘_FԍCCC[h
   擾B
(͕ϐ)
   Ȃ
(o͕ϐ)
  IPC = _Fԍ
  IPS = 
  IPW = 
   MX = [h
 IRTN = ^[ER[h

[TOC] [INDEX]

26. uV̎w
-----------------------------------------------------------------------------
[F] SUBROUTINE GWSETBRS(IRTN, IBC, IBS, IBH)
    INTEGER IRTN, IBC, IBS, IBH

[C] int GWsetbrs(int IBC, int IBS, int IBH);
-----------------------------------------------------------------------------
()
   JgEEBhEŎgpuV̐FCށCnb`p^[w肷B
   ݒlł΂̍ڂ͕ύXȂBIBC ̏ꍇɂ -1 ȊO̐̕l
   ͕ʂ̈Ӗ̂ŒӁB
(͕ϐ)
  IBC = _Fԍ
         -1 ̏ꍇ͕ύXȂ
         ̑̏ꍇɂĂ GWCOLOR ̍QƁB

  IBS = 0: NULLBRUSH      ̃uV
        1: SOLIDBRUSH     F̃uV
        2: HATCHED        nb` uV
        3: BSPATTERN      p^[ uV(\)
        4: DIBPATTERN     p^[ uV(\)
        5: DIBPATTERNPT   p^[ uV(\)

  IBH = 1: HORIZONTAL     ̃nb`
        2: VERTICAL       ̃nb`
        3: FDIAGONAL      ォEւ 45 x̃nb`
        4: BDIAGONAL      Eւ 45 x̃nb`
        5: CROSS          Åiq̃nb`
        6: DIAGCROSS      45 x̊iq̃nb`
(o͕ϐ)
  IRTN = ^[ER[h

[TOC] [INDEX]

27. uV̎擾
-----------------------------------------------------------------------------
[F] SUBROUTINE GWGETBRS(IRTN, IBC, IBS, IBH)
    INTEGER IRTN, IBC, IBS, IBH

[C] int GWgetbrs(int *IBC, int *IBS, int *IBH);
-----------------------------------------------------------------------------
()
   JgEEBhEŎgpĂuV̐FCށCnb`p^[擾B
   p^[̈Ӗ GWSETBRS QƁB
(͕ϐ)
   Ȃ
(o͕ϐ)
  IBC = _Fԍ
  IBS = uV̎
  IPW = nb`p^[
 IRTN = ^[ER[h

[TOC] [INDEX]

28. eLXgptHg̐ݒ
-----------------------------------------------------------------------------
[F] SUBROUTINE GWSETTXT(IRTN, H, A, IO, K, KB, FACE)
    INTEGER IRTN, IO, K, KB
    REAL H, A
    CHARACTER FACE*(*)

[C] int GWsettxt(float H, float A, int IO, int K, int KB, char *FACE);
-----------------------------------------------------------------------------
()
   eLXgptHg̑ݒ肷Bgp\ȃtHg TrueType tHg
   ݁BtHg󔒂̏ꍇ̓ftH[g܂͑OgpꂽtHgg
   BtHg '*' ̏ꍇAݒ肵ŃtHg̐Ɏsꍇ
   ɂ́CtHgE_CAOĂяoB
(͕ϐ)
      H = tHg̍([hWn)
          0 ̏ꍇ̓ftH[glg
          ̏ꍇ݂͌̒lg
      A = tHǧXp(deg/360Cv; |A| < 1.0)
          |A| >= 1.0 ̏ꍇ݂͌̒lg
     IO = _̈ʒuw肷
        = 0: 
        = 1:  (ftHg)
        = 2: E
        = 3: E
        = 4: 
        = 5: 
        = 6: 
        = 7: E
        = 8: 
      K = ̘_Fԍ(GWCOLOR ̍Q)
          -1 ̏ꍇ͌ݒlg
     KB = ̔wiF̘_Fԍ(GWCOLOR ̍Q)
          -1 ̏ꍇ͌ݒlg
        = -100: (default)
   FACE = TrueType tHg
(o͕ϐ)
  IRTN = ^[ER[h

[TOC] [INDEX]

29. TCY̎擾
-----------------------------------------------------------------------------
[F] SUBROUTINE GWGETTXT(IRTN, W, H, X, Y, TXT)
    INTEGER IRTN
    REAL W, H, X, Y
    CHARACTER TXT*(*)

[C] int GWgettxt(float *W, float *H, float *X, float *Y, char *TXT);
-----------------------------------------------------------------------------
()
    ̃[hWnł̕ƍ擾B
(͕ϐ)
     W = ̕([hWn)
     H = ̍([hWn)
     X = _̃ItZbgXW([hWn)
     Y = _̃ItZbgYW([hWn)
   TXT = 
(o͕ϐ)
  IRTN = ^[ER[h

[TOC] [INDEX]

30. (eLXg)̕`
-----------------------------------------------------------------------------
[F] SUBROUTINE GWPUTTXT(IRTN, X, Y, TXT)
    INTEGER IRTN
    REAL X, Y
    CHARACTER TXT*(*)

[C] int GWputtxt(float X, float Y, char *TXT);
-----------------------------------------------------------------------------
()
    OtBNXEEBhEɕo͂BtHg̎ނ GWSETTXT 
    ܂́Cj[o[ [Options] => [Font] ŕύXB͓̕eƃtH
    g̎ނɈˑ邽ߐݒłȂBႦ GWFMAX() gȂǂāC
    ̍̓_̍WɁCp (GWINDOW Q) ͈̔͂傫Oꂽ_w肷
    ƁC͂̑Ȍo͕̒ɏo͂B
(͕ϐ)
     X = _ X W([hWn)
     Y = _ Y W([hWn)
   TXT = o͕
(o͕ϐ)
  IRTN = ^[ER[h

[TOC] [INDEX]

31. LtHg̐ݒ
-----------------------------------------------------------------------------
[F] SUBROUTINE GWSETSYM(IRTN, H, A, IO, K, KB, FACE)
    INTEGER IRTN, IO, K, KB
    REAL H, A
    CHARACTER FACE*(*)

[C] int GWsetsym(float H, float A, int IO, int K, int KB, char *FACE);
-----------------------------------------------------------------------------
()
   LtHg̑ݒ肷Bgp\ȃtHg TrueType tHĝ݁B
   tHg󔒂̏ꍇ̓ftH[g܂͑OgpꂽtHgg
   Bݒ肵ŃtHg̐Ɏsꍇɂ́CtHgE_CAO
   ĂяoB
(͕ϐ)
    H = tHg̍([hWn)
        0 ̏ꍇ̓ftH[glg
        ̏ꍇ݂͌̒lg
    A = tHǧXp(deg/360Cv; |A| < 1.0)
        |A| >= 1.0 ̏ꍇ݂͌̒lg
   IO = _̈ʒuw肷
      = 0:  (ftHg)
      = 1: 
      = 2: E
      = 3: E
      = 4: 
      = 5: 
      = 6: 
      = 7: E
      = 8: 
    K = ̘_Fԍ(GWCOLOR ̍Q)
        -1 ̏ꍇ͌ݒlg
   KB = ̔wiF̘_Fԍ(GWCOLOR ̍Q)
        -1 ̏ꍇ͌ݒlg
      = -100: (default)
 FACE = TrueType tHg
(o͕ϐ)
  IRTN = ^[ER[h

[TOC] [INDEX]

32. L̃TCY擾
-----------------------------------------------------------------------------
[F] SUBROUTINE GWGETSYM(IRTN, W, H, IC)
    INTEGER IRTN, IC
    REAL W, H

[C] int GWgetsym(float *W, float *H, int IC);
-----------------------------------------------------------------------------
()
    L̃[hWnł̕ƍ擾B
(͕ϐ)
     W = L̕([hWn)
     H = L̍([hWn)
    IC = LR[h(0`255)
(o͕ϐ)
  IRTN = ^[ER[h

[TOC] [INDEX]

33. L̏o
-----------------------------------------------------------------------------
[F] SUBROUTINE GWPUTSYM(IRTN, X, Y, IC)
    INTEGER IRTN, IC
    REAL X, Y

[C] int GWputsym(float X, float Y, int IC);
-----------------------------------------------------------------------------
()
    OtBNXEEBhEɋLo͂BL̑ GWSETSYM ܂́C
    j[o[ [Options] => [Symbol] ŕύXBftHg̋LtHgƂ
    Ă Windows TrueType tHg "WingDings" gpB
(͕ϐ)
    X = L̒S_ X W([hWn)
    Y = L̒S_ Y W([hWn)
   IC = LR[h(0`255)
(o͕ϐ)
  IRTN = ^[ER[h

[TOC] [INDEX]

34. bZ[W̕\
-----------------------------------------------------------------------------
[F] SUBROUTINE GWSETMSG(IRTN, TXT)
    INTEGER IRTN
    CHARACTER TXT*(*)

[C] int GWsetmsg(char *TXT);
-----------------------------------------------------------------------------
()
    Xe[^Xo[ɃbZ[W\B
(͕ϐ)
   TXT = bZ[W̕
(o͕ϐ)
  IRTN = ^[ER[h

[TOC] [INDEX]

35. bZ[W{bNX
-----------------------------------------------------------------------------
[F] INTEGER FUNCTION MSGBOX(TXT)
    CHARACTER TXT*(*)

[C] int GWmsgbox(char *TXT);
-----------------------------------------------------------------------------
()
    bZ[W{bNX\Cǂ̃{^ꂽ̒l𓾂B
(͕ϐ)
   TXT = bZ[W̕
(o͕ϐ)
   Ȃ
(Ԃl)
    1: YES {^ꂽꍇ
   -1: NO {^ꂽꍇ
    0: ̑

[TOC] [INDEX]

36. yʒu
-----------------------------------------------------------------------------
[F] SUBROUTINE GWGETPOS(IRTN, X, Y)
    INTEGER IRTN
    REAL X, Y

[C] int GWgetpos(float *X, float *Y);
-----------------------------------------------------------------------------
()
   ݂̃yʒu (X, Y) [hWnŕԂB
(͕ϐ)
   Ȃ
(o͕ϐ)
    X = _ X W([hWn)
    Y = _ Y W([hWn)
 IRTN = ^[ER[h

[TOC] [INDEX]

37. ÿړ
-----------------------------------------------------------------------------
[F] SUBROUTINE GWMOVE2(IRTN, X, Y)
    INTEGER IRTN
    REAL X, Y

[C] int GWmove2(float X, float Y);
-----------------------------------------------------------------------------
()
   [hWn (X, Y) ɃyړB`ȂB
(͕ϐ)
    X = _ X W([hWn)
    Y = _ Y W([hWn)
(o͕ϐ)
  IRTN = ^[ER[h

[TOC] [INDEX]

38. w肵_܂ł̒
-----------------------------------------------------------------------------
[F] SUBROUTINE GWLINE2(IRTN, X, Y)
    INTEGER IRTN
    REAL X, Y

[C] int GWline2(float X, float Y);
-----------------------------------------------------------------------------
()
   ݂̃y (GWSETPEN Q) gāC݂̃yʒuƎw肳ꂽ[hW
   n̓_ (X, Y) Ԓ`CyʒuXVByʒu`(
   )̏ꍇ́CyʒuXV邾Œ͕`ȂByʒu GWSETPEN 
   ŏłB
(͕ϐ)
    X = _ X W([hWn)
    Y = _ Y W([hWn)
(o͕ϐ)
  IRTN = ^[ER[h

[TOC] [INDEX]

39. Q_Ԓ
-----------------------------------------------------------------------------
[F] SUBROUTINE GWLINE(IRTN, X1, Y1, X2, Y2)
    INTEGER IRTN
    REAL X1, Y1, X2, Y2

[C] int GWline(float X1, float Y1, float X2, float Y2);
-----------------------------------------------------------------------------
()
   ݂̃y (GWSETPEN Q) gāC[hWn (X1, Y1)  (X2, Y2) 
   𒼐ŌԁB
(͕ϐ)
   X1 = n_ X W([hWn)
   Y1 = n_ Y W([hWn)
   X2 = I_ X W([hWn)
   Y2 = I_ Y W([hWn)
(o͕ϐ)
 IRTN = ^[ER[h

[TOC] [INDEX]

40. lp`̕`
-----------------------------------------------------------------------------
[F] SUBROUTINE GWRECT(IRTN, X1, Y1, X2, Y2)
    INTEGER IRTN
    REAL X1, Y1, X2, Y2

[C] int GWrect(float X1, float Y1, float X2, float Y2);
-----------------------------------------------------------------------------
()
   ݂̃y (GWSETPEN Q) gāC[hWn̓_P (X1, Y1) Ɠ_Q 
   (X2, Y2) ΊpƂlp``B̂Ƃ݂̃uV (GWSETBRS Q) 
   hB
(͕ϐ)
   X1 = _P X W([hWn)
   Y1 = _P Y W([hWn)
   X2 = _Q X W([hWn)
   Y2 = _Q Y W([hWn)
(o͕ϐ)
 IRTN = ^[ER[h

[TOC] [INDEX]

41. hԂꂽlp`̕`
-----------------------------------------------------------------------------
[F] SUBROUTINE GWSRECT(IRTN, X1, Y1, X2, Y2, K)
    INTEGER IRTN, K
    REAL X1, Y1, X2, Y2

[C] int GWsrect(float X1, float Y1, float X2, float Y2, int K);
-----------------------------------------------------------------------------
()
   [hWn̓_P (X1, Y1) Ɠ_Q (X2, Y2) ΊpƂlp`̓
   _Fԍ K œhԂB
(͕ϐ)
   X1 = _P X W([hWn)
   Y1 = _P Y W([hWn)
   X2 = _Q X W([hWn)
   Y2 = _Q Y W([hWn)
    K = _Fԍ
(o͕ϐ)
 IRTN = ^[ER[h

[TOC] [INDEX]

42. p̊ۂlp`̕`
-----------------------------------------------------------------------------
[F] SUBROUTINE GWRRECT(IRTN, X1, Y1, X2, Y2, W, H)
    INTEGER IRTN
    REAL X1, Y1, X2, Y2, W, H

[C] int GWrrect(float X1, float Y1, float X2, float Y2, float W, float H);
-----------------------------------------------------------------------------
()
   ݂̃y (GWSETPEN Q) gāC[hWn̓_P (X1, Y1) Ɠ_Q 
   (X2, Y2) ΊpƂlp`ɓڂp̊ۂlp``B ̂Ƃ݂
   uV (GWSETBRS Q) œhBۂp`߂̑ȉ~̕ƍ 
   (W, H) Ŏw肷B
(͕ϐ)
   X1 = _P X W([hWn)
   Y1 = _P Y W([hWn)
   X2 = _Q X W([hWn)
   Y2 = _Q Y W([hWn)
    W = p̑ȉ~̕([hWn)
    H = p̑ȉ~̍([hWn)
(o͕ϐ)
 IRTN = ^[ER[h

[TOC] [INDEX]

43. ȉ~̕`
-----------------------------------------------------------------------------
[F] SUBROUTINE GWELLIPSE(IRTN, X1, Y1, X2, Y2)
    INTEGER IRTN
    REAL X1, Y1, X2, Y2

[C] int GWellipse(float X1, float Y1, float X2, float Y2);
-----------------------------------------------------------------------------
()
   ݂̃y (GWSETPEN Q) gāC[hWn̓_P (X1, Y1) Ɠ_Q 
   (X2, Y2) ΊpƂlp`ɓڂȉ~`B̂Ƃ݂̃uV 
   (GWSETBRS Q) œhB
(͕ϐ)
   X1 = _P X W([hWn)
   Y1 = _P Y W([hWn)
   X2 = _Q X W([hWn)
   Y2 = _Q Y W([hWn)
(o͕ϐ)
 IRTN = ^[ER[h

[TOC] [INDEX]

44. ʂ̕`
-----------------------------------------------------------------------------
[F] SUBROUTINE GWARC(IRTN, X1, Y1, X2, Y2, A, AW)
    INTEGER IRTN
    REAL X1, Y1, X2, Y2, A, AW

[C] int GWarc(float X1, float Y1, float X2, float Y2, float A, float AW);
-----------------------------------------------------------------------------
()
   ݂̃y (GWSETPEN Q) gāC[hWn̓_P (X1, Y1) Ɠ_Q 
   (X2, Y2) ΊpƂlp`ɓڂȉ~̌ʂ`BhԂ͍s
   Bʂ́Cpx̒Pʂ "x/360" ƂCv𐳂ɂƂāC
   px A ̓_Cpx A + AW ̓_܂ŕ`悳BA  AW ɂ
   ́Cl -1.0 ȉ̏ꍇɂ̓ftHglpB
(͕ϐ)
   X1 = _P X W([hWn)
   Y1 = _P Y W([hWn)
   X2 = _Q X W([hWn)
   Y2 = _Q Y W([hWn)
    A = ʂ̕`Jnp(deg/360; ftHgl 0.0)
   AW = ʂ̊px(deg/360; ftHgl 1.0)
(o͕ϐ)
 IRTN = ^[ER[h

[TOC] [INDEX]

45. ʂ̕`
-----------------------------------------------------------------------------
[F] SUBROUTINE GWCHORD(IRTN, X1, Y1, X2, Y2, A, AW)
    INTEGER IRTN
    REAL X1, Y1, X2, Y2, A, AW

[C] int GWchord(float X1, float Y1, float X2, float Y2, float A, float AW);
-----------------------------------------------------------------------------
()
   ݂̃y (GWSETPEN Q) gāC[hWn̓_P (X1, Y1) Ɠ_Q 
   (X2, Y2) ΊpƂlp`ɓڂȉ~̌ʂƂ̗[Ԍ`B
   ̂Ƃ݂̃uV (GWSETBRS Q) œhBʂ́Cpx̒Pʂ 
   "x/360" ƂCv𐳂ɂƂāC瑪px A ̓_C
   px A + AW ̓_܂ŕ`悳BA  AW ɂẮCl -1.0 ȉ̏ꍇ
   ̓ftHglpB
(͕ϐ)
   X1 = _P X W([hWn)
   Y1 = _P Y W([hWn)
   X2 = _Q X W([hWn)
   Y2 = _Q Y W([hWn)
    A = ʂ̕`Jnp(deg/360; ftHgl 0.0)
   AW = ʂ̊px(deg/360; ftHgl 1.0)
(o͕ϐ)
 IRTN = ^[ER[h

[TOC] [INDEX]

46. `̕`
-----------------------------------------------------------------------------
[F] SUBROUTINE GWPIE(IRTN, X1, Y1, X2, Y2, A, AW)
    INTEGER IRTN
    REAL X1, Y1, X2, Y2, A, AW

[C] int GWpie(float X1, float Y1, float X2, float Y2, float A, float AW);
-----------------------------------------------------------------------------
()
   ݂̃y (GWSETPEN Q) gāC[hWn̓_P (X1, Y1) Ɠ_Q 
   (X2, Y2) ΊpƂlp`ɓڂ`𔽎vɕ`B̂Ƃ
   ̃uV (GWSETBRS Q) œhB`́Aȉ~̌ʂƁA2 ̒[_
   ꂼꂩȉ~̒SɈ\}`Bʂ́Cpx̒Pʂ 
   "x/360" ƂCv𐳂ɂƂāC瑪px A ̓_C
   px A + AW ̓_܂ŕ`悳BA  AW ɂẮCl -1.0 ȉ̏ꍇ
   ̓ftHglpB
(͕ϐ)
   X1 = _P X W([hWn)
   Y1 = _P Y W([hWn)
   X2 = _Q X W([hWn)
   Y2 = _Q Y W([hWn)
    A = ʂ̕`Jnp(deg/360; ftHgl 0.0)
   AW = ʂ̊px(deg/360; ftHgl 1.0)
(o͕ϐ)
 IRTN = ^[ER[h

[TOC] [INDEX]

47. 1z̃vbg
-----------------------------------------------------------------------------
[F] SUBROUTINE GWPLOT1(IRTN, M, N, P1, PN, S, O, A, B, ARRY)
    INTEGER IRTN, M, N
    REAL P1, PN, S, O, A, B, ARRY(N)

[C] int GWplot1(int M, int N, float P1, float PN, float S, float O, 
                float A, float B, float *ARRY);
-----------------------------------------------------------------------------
()
   1z ARRY ̐擪 |N| ̃f[^ɂĐ`ϊŝ M 
   w肳ꂽ`œԊuɃvbgBvbg i Ԗ (i = 1..|N|) 
   _ (x,y) W([hW) FORTRAN ̏ꍇC
       (P1 + (i - 1)*(PN - P1)/(N - 1), A*ARRY(i)+B)     (N > 0)
   邢
       (A*ARRY(i)+B, P1 + (i - 1)*(PN - P1)/(- N - 1))   (N < 0)
   ƂȂBC ̏ꍇ ARRY(i)  ARRY[i-1] ɓǂݑւKvB
(͕ϐ)
     M = vbg`
       = -1: ݂̃yg܂Ot
       = -2(-3): ݂̃yg󐂒()_Ot
       = -4(-5): ݂̃uVg()_Ot( S)
       = -6(-7): ݂̃yƌ݂̃uVg()_Ot( S)  
       =  0: ݂̃}[Ng'}[N'( S)
       >  0: R{ԍ M ̃R{i쐬̑傫jg'R{'
   |N| = vbgzvf ( > 1: ܂Ot̏ꍇ)BN > 0 ̏ꍇɂ 
         A*ARRY(i)+B  y WƂĈCN < 0 ̏ꍇɂ x WƂĈB
    P1 = ŏ̓_ x ܂ y W([hW)
    PN = Ō̓_ x ܂ y W([hW)
     S = _Ot̖_̕邢̓}[N̑傫([hW)
     O = M < -1 ̏ꍇF_Ot̏ꍇ̊̍W([hW)
         M >  0 ̏ꍇFR{ IOF (GWPUTCMB Q) p[^
     A = `ϊ̌W
     B = `ϊ̕t萔
  ARRY = vbg1z
(o͕ϐ)
 IRTN = ^[ER[h

[TOC] [INDEX]

48. p`̕`
-----------------------------------------------------------------------------
[F] SUBROUTINE GWPOLYGON(IRTN, POINTS, N, MF)
    INTEGER IRTN, N, MF
    REAL POINTS(2,N)

[C] int GWpolygon(float *POINTS, int N, int MF);
-----------------------------------------------------------------------------
()
   ݂̃y (GWSETPEN Q) gāCN ̒_Ȃ鑽p`Ci (= 1..N) 
   Ԗڂ̒_̍W (POINTS(1,i), POINTS(2,i)) ŗ^ĕ`([F])B̂Ƃ
   ݂̃uV (GWSETBRS Q) pCw肳ꂽhԂ[hœh
   B[C] ̏ꍇɂ́C|C^ POINTS w[̈͘AIŁC 
   *(POINTS + 2*i - 2)  *(POINTS + 2*i - 1) ̂ꂼɁCi (= 1..N) Ԗڂ̒
   _ x, y Wi[ĂȂ΂ȂȂB
(͕ϐ)
    POINTS(1,i)   = i Ԗڂ̒_ x W (i = 1..N)
    POINTS(2,i)   = i Ԗڂ̒_ y W (i = 1..N)
                N = _
               MF = hԂ[h
                    0: Alternate (default)
                    1: Winding
                   : ύXȂ
(o͕ϐ)
 IRTN = ^[ER[h

[TOC] [INDEX]

49. ܂̕`
-----------------------------------------------------------------------------
[F] SUBROUTINE GWPOLYLIN(IRTN, POINTS, N)
    INTEGER IRTN, N
    REAL POINTS(2,N)

[C] int GWpolylin(float *POINTS, int N);
-----------------------------------------------------------------------------
()
   ݂̃y (GWSETPEN Q) gāCN ̓_Ԑ܂Ci (= 1..N) Ԗ
   ̒_̍W (POINTS(1,i), POINTS(2,i)) ŗ^ĕ`([F])B}`Ă
   ĂhԂ͍sȂBC ̏ꍇ̓_̍W̗^ɂĂ 
   GWPOLYGON QƁB
(͕ϐ)
    POINTS(1,i) = i Ԗڂ̓_ x W (i = 1..N)
    POINTS(2,i) = i Ԗڂ̓_ y W (i = 1..N)
              N = _̐ ( > 1 )
(o͕ϐ)
 IRTN = ^[ER[h

[TOC] [INDEX]

50. xWG XvC̕`
-----------------------------------------------------------------------------
[F] SUBROUTINE GWBEZIER(IRTN, POINTS, N)
    INTEGER IRTN, N
    REAL POINTS(2,N)

[C] int GWbezier(float *POINTS, int N);
-----------------------------------------------------------------------------
()
   ݂̃y (GWSETPEN Q) gāCxWG XvC`悷Bh
   ͍sȂB POINTS Ɏw肳ꂽI_Ɛ_g 3 xWGX
   vC`悷Bŏ̃XvĆAŏ̓_ 4 Ԗڂ̓_܂ŕ`悳
   B2 Ԗڂ̓_ 3 Ԗڂ̓_́A_ƂĎgB̌ɑÃXv
   C͂ꂼ 3 ̓_KvƂBÕXvC̏I_Jn_Ƃ
   gCA 2 _𐧌_C3 Ԗڂ̓_I_ƂĎgBāC
   XvCEZOg n ̏ꍇCN = 3*n+1 ̃f[^_^Ȃ΂
   ȂBC ̏ꍇ̓_̍W̗^ɂĂ GWPOLYGON QƁB
(͕ϐ)
    POINTS(1,i) = i Ԗڂ̓_ x W (i = 1..N)
    POINTS(2,i) = i Ԗڂ̓_ y W (i = 1..N)
              N = _̐ ( 3 ̔{ + 1 )
(o͕ϐ)
 IRTN = ^[ER[h

[TOC] [INDEX]

51. ̈̓hԂ
-----------------------------------------------------------------------------
[F] SUBROUTINE GWFLOOD(IRTN, X, Y)
    INTEGER IRTN
    REAL X, Y

[C] int GWflood(float X, float Y);
-----------------------------------------------------------------------------
()
   (X,Y) Ŏw肳ꂽhԂJn_CJn_܂݁CJn_ƈقȂFE
   Ƃ݂̈̃uVœhԂ [̃[`͔ɒᑬŁC
   v^͂̋@\T|[gĂȂ̂ŁCł邾gȂ悢]B
(͕ϐ)
   X = hԂJn_ X W([hWn)
   Y = hԂJn_ Y W([hWn)
(o͕ϐ)
 IRTN = ^[ER[h

[TOC] [INDEX]

52. EBhEʂ̏
-----------------------------------------------------------------------------
[F] SUBROUTINE GWCLEAR(IRTN, K)
    INTEGER IRTN, K

[C] int GWclear(int K);
-----------------------------------------------------------------------------
()
   w肳ꂽFŌ݂̃r[|[ghԂB
(͕ϐ)
    K = _Fԍ(GWCOLOR ̍Q)
        -1 ̏ꍇ͉ʏƂƂɂׂẴIuWFNg
(o͕ϐ)
 IRTN = ^[ER[h

[TOC] [INDEX]

53. }[N̎w
-----------------------------------------------------------------------------
[F] SUBROUTINE GWSETMRK(IRTN, MT, S, K, KB, MX)
    INTEGER IRTN, MT, K, KB, MX
    REAL S

[C] int GWsetmrk(int MT, float S, int K, int KB, int MX);
-----------------------------------------------------------------------------
()
   }[Nԍ MT(0-6)C傫 S([hWn)C}[N̘_Fԍ KC}[N
   wiF̘_Fԍ KBC[h MX w肷B MX > 15 ̏ꍇ (MX-16) 
   ̒l̂܂ "binary raster-operation code[W]" ƂĎgpBK, KB 
   āC̓p[^̒lłΑΉ鑮͕ύXȂBMT  0 
   ꍇ́C傫 SisNZj̓_w肳C̏ꍇC`悳}[N
   傫̓r[i\j[hɉeȂB
(͕ϐ)
   MT = 0: _
        1: 
        2: {
        3: ~
        4: {Ɓ~d˂킹
        5: 
        6: 
        ̑:  ύXȂ
    S = hbg̑傫(sNZl)
      = }[N̍([hWn) > 0.0
    K = }[N̘_Fԍ(GWCOLOR ̍Q)
        -1 ̏ꍇ͌ݒlg
   KB = }[N̔wiF̘_Fԍ(GWCOLOR ̍Q)
        -1 ̏ꍇ͌ݒlg
      = -100: (default)
   MX = }[N̍[h( GWSETPEN ̍Q)
(o͕ϐ)
 IRTN = ^[ER[h

[TOC] [INDEX]

54. }[N`
-----------------------------------------------------------------------------
[F] SUBROUTINE GWPUTMRK(IRTN, X, Y)
    INTEGER IRTN
    REAL X, Y

[C] int GWputmrk(float X, float Y);
-----------------------------------------------------------------------------
()
    GWSETMRK Őݒ肳ꂽ}[Nʒu (X,Y) ɕ`悷B}[N\̕`
    ɂ݂͌̃y (GWSETPEN Q) gB
(͕ϐ)
    X = }[NS_ X W([hWn)
    Y = }[NS_ Y W([hWn)
(o͕ϐ)
  IRTN = ^[ER[h

[TOC] [INDEX]

55. }[N̎擾
-----------------------------------------------------------------------------
[F] SUBROUTINE GWGETMRK(IRTN, MT, S, K, KB, MX)
    INTEGER IRTN, MT, K, KB, MX
    REAL S

[C] int GWgetmrk(int *MT, float *S, int *K, int *KB, int *MX);
-----------------------------------------------------------------------------
()
   ݂̃}[NԍC}[NTCYC}[Nƃ}[NwiF̘_FԍC[h
   擾B
(͕ϐ)
   Ȃ
(o͕ϐ)
   MT = }[Nԍ
    S = }[NTCY([hWnŎw肷)
    K = }[N̘_Fԍ(GWCOLOR ̍Q)
   KB = }[N̔wiF̘_Fԍ(GWCOLOR ̍Q)
   MX = }[N̍[h( GWSETPEN ̍Q)
 IRTN = ^[ER[h

[TOC] [INDEX]

56. ϊs̐ݒ
-----------------------------------------------------------------------------
[F] SUBROUTINE GWSETXFRM(IRTN, XFRM)
    INTEGER IRTN
    REAL XFRM(6)

[C] int GWsetxfrm(float *XFRM);
-----------------------------------------------------------------------------
()
   ϊsݒ肷Bϊs̓rbg}bv}[N̉]ό`ɎgpC
   ϊÕ[hW̓_ (x, y) 
      x' = XFRM(1) + XFRM(2) * x + XFRM(3) * y
      y' = XFRM(4) + XFRM(5) * x + XFRM(6) * y
   ɂ (x', y') ɕϊB̋@\ Windows 9x/Me ł͐ɓ삵ȂB
(͕ϐ)
   XFRM = ϊs̊e
(o͕ϐ)
   IRTN = ^[ER[h

[TOC] [INDEX]

57. ϊs̎擾
-----------------------------------------------------------------------------
[F] SUBROUTINE GWGETXFRM(IRTN, XFRM)
    INTEGER IRTN
    REAL XFRM(6)

[C] int GWgetxfrm(float *XFRM);
-----------------------------------------------------------------------------
()
   ݂̕ϊs̐擾Bϊs̓rbg}bv}[N̉]ό`
   Ɏgp(GWGETXFRM Q)B
(͕ϐ)
   Ȃ
(o͕ϐ)
   XFRM = ϊs̊e(GWGETXFRM Q)
   IRTN = ^[ER[h

[TOC] [INDEX]

58. NbsÖ̐ݒ
-----------------------------------------------------------------------------
[F] SUBROUTINE GWSETRGN(IRTN, X1, Y1, X2, Y2, M)
    INTEGER IRTN, M
    REAL X1, Y1, X2, Y2

[C] int GWsetrgn(float X1, float Y1, float X2, float Y2, int M);
-----------------------------------------------------------------------------
()
   ݂̃NbsÖƃ[hWn̓_P (X1, Y1) Ɠ_Q (X2, Y2) Ίp
   Ƃlp` M Ŏw肳郂[hŌCVȃNbsÖƂB
   M < 0 ܂ M > 4 ŁCX1 = X2 ܂ Y1 = Y2 ̏ꍇɂ́CNbsO͉
   B
(͕ϐ)
   X1 = _P X W([hWn)
   Y1 = _P Y W([hWn)
   X2 = _Q X W([hWn)
   Y2 = _Q Y W([hWn)
    M = 1: AND
        2: OR
        3: DIFF
        4: XOR
       : COPY

(o͕ϐ)
 IRTN = ^[ER[h

[TOC] [INDEX]

59. sNZ̐ݒ
-----------------------------------------------------------------------------
[F] SUBROUTINE GWSETPXL(IRTN, X, Y, K)
    INTEGER IRTN, K
    REAL X, Y

[C] int GWsetpxl(float X, float Y, int K);
-----------------------------------------------------------------------------
()
    (X,Y) Ŏw肳ꂽ_̃sNZɘ_Fԍ (GWCOLOR Q) ݒ肷B
(͕ϐ)
   X = _ X W([hWn)
   Y = _ Y W([hWn)
   K = _Fԍ
(o͕ϐ)
  IRTN = ^[ER[h

[TOC] [INDEX]

60. sNZ̘_Fԍ̎擾
-----------------------------------------------------------------------------
[F] SUBROUTINE GWGETPXL(IRTN, X, Y)
    INTEGER IRTN
    REAL X, Y

[C] int GWgetpxl(float X, float Y);
-----------------------------------------------------------------------------
()
    (X,Y) Ŏw肳ꂽ_̘_Fԍ (GWCOLOR Q) 擾B
(͕ϐ)
   X = _ X W([hWn)
   Y = _ Y W([hWn)
(o͕ϐ)
 IRTN = _Fԍ (ꍇ)
      = -1 (s̏ꍇ)

[TOC] [INDEX]

61. F̐ݒ
-----------------------------------------------------------------------------
[F] SUBROUTINE GWCOLOR(IRTN, K, IDST)
    INTEGER IRTN, K, IDST

[C] int GWcolor(int K, int IDST);
-----------------------------------------------------------------------------
()
   _Fԍ K Ŏw肳ꂽF IDST ɐݒ肷BK = -1 ̏ꍇ́uF̐ݒv_
   CAO{bNXőI΂ꂽFݒ肳B_FԍƂ́Cȉɒ`Ă
   eFɑΉÂꂽԍ̂ƁB

    m_Fԍn: Ӗ
            0..19 : Windows Wpbg
                0 : 
                1 : IF
                2 : Â
                3 : I[u
                4 : Z
                5 : 
                6 : ΐ
                7 : DF
                8 : 邢
                9 : F
               10 : DF
               11 : DF
               12 : ZDF
               13 : 
               14 : 
               15 : 
               16 : 
               17 : Ԏ
               18 : F
               19 : 
           20..35 : uF̐ݒv_CAO{bNX́u쐬Fv(0..15)
    0x02000000
     ..0x02ffffff :   COLORREF l
               -1 : uF̐ݒv_CAO{bNXőIꂽF
               -2 : ݂̑OiF
               -3 : ݂̔wiF
               -4 : ݂̃y̐F
               -5 : ݂̃uV̐F
               -6 : ݂̃}[N̐F
               -7 : ݂̃}[N̔wiF
               -8 : ݂̃eLXg̐F
               -9 : ݂̃eLXg̔wiF
              -10 : ݂̋L̐F
              -11 : ݂̋L̔wiF
              -12 : ݂̃sNZF
             -100 :  (wiFp)
           ̑ : uF̐ݒv_CAO{bNXőIꂽF
(͕ϐ)
       K = _Fԍ
    IDST = ݒ
           1: OiF
           2: wiF
           3: y̐F
           4: uV̐F
           5: }[N̐F
           6: }[N̔wiF
           7: eLXg̐F
           8: eLXg̔wiF
           9: L̐F
          10: L̔wiF
          11: sNZF
      20..35: uF̐ݒv_CAO{bNX́u쐬Fv(0..15)
      ̑: ݒ肵Ȃ
(o͕ϐ)
  IRTN = ^[ER[h

[TOC] [INDEX]

62. _FԍRGB(OF)ɕϊ
-----------------------------------------------------------------------------
[F] SUBROUTINE GWGETRGB(IRTN, K, IR, IG, IB)
    INTEGER IRTN, K, IR, IG, IB

[C] int GWgetrgb(int K, int *IR, int *IG, int *IB);
-----------------------------------------------------------------------------
()
    _Fԍ K OF (IR,IG,IB) ɕϊB
(͕ϐ)
    K = _Fԍ
(o͕ϐ)
   IR = F RED   (0-255)
   IG = F GREEN (0-255)
   IB = F BLUE  (0-255)
 IRTN = ^[ER[h

[TOC] [INDEX]

63. RGB(OF)_Fԍւ̕ϊ
-----------------------------------------------------------------------------
[F] INTEGER FUNCTION KRGB(IR, IG, IB)
    INTEGER IR, IG, IB

[C] int GWkrgb(int IR, int IG, int IB);
-----------------------------------------------------------------------------
()
   GWSETPEN  GWSETBRS ȂǁC_Fԍ̎w肪KvȏꍇɁCOF(IR,IG,IB)
   疾IɐFꍇɗpBIR,IG,IB ׂ̂Ă 0 ` 255 ͈̔
   ɂꍇɂ͑Ή_FԍԂ,ȊȌꍇɂ́uF̐ݒv_CA
   O{bNXJ߂̔ԍԂB_Fԍɂďڂ GWCOLOR ̍Q
   ƁB
(͕ϐ)
  IR = F RED   (0-255)
  IG = F GREEN (0-255)
  IB = F BLUE  (0-255)
(o͕ϐ)
   Ȃ
(Ԃl)
    _Fԍ( GWCOLOR Q)

[TOC] [INDEX]

64.  COLORREF l_Fԍւ̕ϊ
-----------------------------------------------------------------------------
[F] INTEGER FUNCTION KCOLOR(IC)
    INTEGER IC

[C] int GWkcolor(int IC);
-----------------------------------------------------------------------------
()
   COLORREF l_Fԍɕϊ邽߂ɎgpBCOLORREF lƂ Windows 
   gpĂCF̓\̂ƁBڂ́CWindows ֌W̎QƁB
(͕ϐ)
  IC = F COLORREF l
(o͕ϐ)
   Ȃ
(Ԃl)
    _Fԍ( GWCOLOR Q)

[TOC] [INDEX]

65. Windows pbgԍ_Fԍւ̕ϊ
-----------------------------------------------------------------------------
[F] INTEGER FUNCTION IPALETTE(IP)
    INTEGER IP

[C] int GWipalette(int IP);
-----------------------------------------------------------------------------
()
   GWSETPEN  GWSETBRS ȂǁC_Fԍ̎w肪KvȏꍇɁCWindows pbg
   ԍ_Fԍɕϊ邽߂ɎgpBIɂ PALETTEINDEX }N [W] 
    call ĂDCfbNXl IP > 19  Windows pbgpł邩
   ǂ͎gpĂfBXvCJ[hȂǃVXeɈˑ̂ŒӁB
(͕ϐ)
  IP = FWindows pbgԍ (0..255)
(o͕ϐ)
   Ȃ
(Ԃl)
    _Fԍ( GWCOLOR Q)

[TOC] [INDEX]

66. p\ȐFpbg̎擾
-----------------------------------------------------------------------------
[F] SUBROUTINE GWNCOLOR(IRTN)
    INTEGER IRTN

[C] int GWncolor(void);
-----------------------------------------------------------------------------
()
   p\ȐFpbg = (ŏIpbgԍ{P) 擾B̃o[W
   ͗p\ȐFpbg 36 ŌŒBpbgԍ 0..19  Windows ̕WF
   pbgŁCݒl͕ύXłȂ(0 = , 19 = )Bpbgԍ 20..35 ͐F
   ̐ݒv_CAO{bNXŕύX(GWCOLOR ̍Q)B
(͕ϐ)
   Ȃ
(o͕ϐ)
   IRTN = 36 = (ŏIpbgԍ{P)

[TOC] [INDEX]

67. JX^J[̕ۑ
-----------------------------------------------------------------------------
[F] SUBROUTINE GWSAVECC(IRTN, FN)
    INTEGER IRTN
    CHARACTER FN*(*)

[C] int GWsavecc(char *FN);
-----------------------------------------------------------------------------
()
   JX^J[t@CɕۑB
(͕ϐ)
  FN = t@C
(o͕ϐ)
  IRTN = ^[ER[h

[TOC] [INDEX]

68. JX^J[̕
-----------------------------------------------------------------------------
[F] SUBROUTINE GWLOADCC(IRTN, FN)
    INTEGER IRTN
    CHARACTER FN*(*)

[C] int GWloadcc(char *FN);
-----------------------------------------------------------------------------
()
   JX^J[t@C畜BJX^J[i[Ăt@C
   ̏́Cesɂ COLORREF l 0x02XXXXXX ̌`Ŏw肵 16 s
   Ȃ(XXXXXX  16 i 6 )BGWSAVECC ō쐬̂͂̂܂ܓǂނƂ
   B
(͕ϐ)
  FN = t@C
(o͕ϐ)
  IRTN = ^[ER[h

[TOC] [INDEX]

69. VXeɐݒ肳ĂF̎擾
-----------------------------------------------------------------------------
[F] SUBROUTINE GWSYSCLR(IRTN, IDX)
    INTEGER IRTN, IDX

[C] int GWsysclr(int IDX);
-----------------------------------------------------------------------------
()
   IDX Ŏw肳ꂽF (CORORREF l) 擾Bڂ Win32 API ɂ
   ̐鎑ŁC GetSysColor() ̍ڂQƂĂB
(͕ϐ)
  IDX = 0: SCROLLBAR
        1: BACKGROUND
        2: ACTIVECAPTION
        3: INACTIVECAPTION
        4: MENU
        5: WINDOW
        6: WINDOWFRAME
        7: MENUTEXT
        8: WINDOWTEXT
        9: CAPTIONTEXT
       10: ACTIVEBORDER
       11: INACTIVEBORDER
       12: APPWORKSPACE
       13: HIGHLIGHT
       14: HIGHLIGHTTEXT
       15: BTNFACE
       16: BTNSHADOW
       17: GRAYTEXT
       18: BTNTEXT
       19: INACTIVECAPTIONTEXT
       20: BTNHIGHLIGHT

(o͕ϐ)
  IRTN = CORORREF l (Windows ֌W̎Q)

[TOC] [INDEX]

70. }EXɂ_W̎擾
-----------------------------------------------------------------------------
[F] SUBROUTINE GWCAPPNT(IRTN, X, Y, TEXT)
    INTEGER IRTN
    REAL X, Y
    CHARACTER TEXT*(*)

[C] int GWcappnt(float *X, float *Y, char *TEXT);
-----------------------------------------------------------------------------
()
   }EX̍{^܂ő҂C̓_̍WƘ_Fԍ ( GWCOLOR Q) 
   ԂB
(͕ϐ)
   TEXT = Xe[^Xo[ɕ\镶
(o͕ϐ)
 IRTN = _Fԍ (-1: s̏ꍇ)
    X = }EX̍{^ꂽ_ X W([hWn)
    Y = }EX̍{^ꂽ_ Y W([hWn)

[TOC] [INDEX]

71. }EXɂxNg̎擾
-----------------------------------------------------------------------------
[F] SUBROUTINE GWCAPVEC(IRTN, X1, Y1, X2, Y2, TEXT)
    INTEGER IRTN
    REAL X1, Y1, X2, Y2
    CHARACTER TEXT*(*)

[C] int GWcapvec(float X1, float Y1, float *X2, float *Y2, char *TEXT);
-----------------------------------------------------------------------------
()
   xNg̎n_^āC}EX̃{^܂ő҂C̓_̍W
   BI_m肷܂ŁCn_ƌ݂̃}EX|C^Ԑ\B
(͕ϐ)
   TEXT = Xe[^Xo[ɕ\镶
   X1 = n_ X W([hWn)
   Y1 = n_ Y W([hWn)
(o͕ϐ)
 IRTN  = 1: }EX̍{^ꂽꍇ
       = 2: }EX̉E{^ꂽꍇ
      <= 0: ̑
    X2 = I_ X W([hWn)
    Y2 = I_ Y W([hWn)
  IRTN = ^[ER[h

[TOC] [INDEX]

72. }EXɂW̎擾
-----------------------------------------------------------------------------
[F] SUBROUTINE GWCAPLIN(IRTN, X1, Y1, X2, Y2, TEXT)
    INTEGER IRTN
    REAL X1, Y1, X2, Y2
    CHARACTER TEXT*(*)

[C] int GWcaplin(float *X1, float *Y1, float *X2, float *Y2, char *TEXT);
-----------------------------------------------------------------------------
()
   }EXhbO܂ő҂ChbOJn_ƏI_̍WԂBhbO
   ̓hbOJn_ƌ݂̃}EX|C^Ԑ\B܂Chb
   OɉE{^΃hbÔ蒼łB
(͕ϐ)
   TEXT = Xe[^Xo[ɕ\镶
(o͕ϐ)
 IRTN > 0: I
     <= 0: LZC
   X1 = hbOJn_ X W([hWn)
   Y1 = hbOJn_ Y W([hWn)
   X2 = hbOI_ X W([hWn)
   Y2 = hbOI_ Y W([hWn)
 IRTN = ^[ER[h

[TOC] [INDEX]

73. }EXɂ`W̎擾
-----------------------------------------------------------------------------
[F] SUBROUTINE GWCAPRECT(IRTN, X1, Y1, X2, Y2, TEXT)
    INTEGER IRTN
    REAL X1, Y1, X2, Y2
    CHARACTER TEXT*(*)

[C] int GWcaprect(float *X1, float *Y1, float *X2, float *Y2, char *TEXT);
-----------------------------------------------------------------------------
()
   }EXhbOCE{^܂ő҂ChbOJn_ƏI_
   WԂB}EXhbOƋ`̈悪邪CE{^
   ܂ł͊m肵Ȃ̂ŁC`̋hbO邱ƂőÏύXłB
   ܂ChbOɉE{^΃hbÔ蒼łB
(͕ϐ)
   TEXT = Xe[^Xo[ɕ\镶
(o͕ϐ)
 IRTN != 0: I
       = 0: LZC
    X1 = hbOJn_ X W([hWn)
    Y1 = hbOJn_ Y W([hWn)
    X2 = hbOI_ X W([hWn)
    Y2 = hbOI_ Y W([hWn)
  IRTN = ^[ER[h

[TOC] [INDEX]

74. rbg}bvt@C̓ǂݍ
-----------------------------------------------------------------------------
[F] SUBROUTINE GWLOADBMP(IRTN, NB, FN)
    INTEGER IRTN, NB
    CHARACTER FN*(*)

[C] int GWloadbmp(int NB, char *FN);
-----------------------------------------------------------------------------
()
    rbg}bvt@C(*.bmp)ǂݍ݁Crbg}bvԍ NB ɓo^BU
    o^ꂽrbg}bv̓rbg}bvԍɂ艽xłp邱ƂłB
    rbg}bv̓o^ɏ݂͐ĂȂȂ,̓[CVXeE
    [\[X̗ʂɈˑBVXeE[\[Xg؂Ƃ̓ɂ
    Ă͂قƂǃ`FbNsĂȂ̂ŗvӁB
(͕ϐ)
    NB = rbg}bvԍ(1`): ǂݍ񂾃rbg}bvۑz̗vfԍB
         NB = 0 ƂƖgp̔zvfgB
    FN = rbg}bvt@C(rbg}bvt@C͎st@CƓfB
         NgɒuCtpXŎw肵Ȃ΂ȂȂ)
(o͕ϐ)
  IRTN = ۂɃrbg}bvۑzvfԍBsƂ 0 ԂB

[TOC] [INDEX]

75. rbg}bvt@C̕ۑ
-----------------------------------------------------------------------------
[F] SUBROUTINE GWSAVEBMP(IRTN, NB, FN)
    INTEGER IRTN, NB
    CHARACTER FN*(*)

[C] int GWsavebmp(int NB, char *FN);
-----------------------------------------------------------------------------
()
    ԍ NB ̃rbg}bvt@CɕۑB
(͕ϐ)
    NB = rbg}bvԍ
    FN = rbg}bvt@C
(o͕ϐ)
  IRTN = ^[ER[h

[TOC] [INDEX]

76. rbg}bv̍쐬
-----------------------------------------------------------------------------
[F] SUBROUTINE GWMAKEBMP(IRTN, NB, IW, IH, IBC, IBITS)
    INTEGER IRTN, NB, IW, IH, IBITS(*)

[C] int GWmakebmp(int NB, int IW, int IH, int IBC, int *IBITS);
-----------------------------------------------------------------------------
()
    z IBITS Ɋi[Ărbg}bvEf[^ɂrbg}bv쐬C
    rbg}bvԍNB ɓo^BIBC ɕsȒlݒ肵ꍇɂ̓ftHgl
    gpD
(͕ϐ)
    NB = rbg}bvԍ(1`): 쐬rbg}bvۑz̗vfԍB
         NB = 0 ƂƖgp̔zvfgB
    IW = rbg}bv̕(sNZ)
    IH = rbg}bv̍(sNZ)
   IBC = sNZ̍ő̐F(rbg)
       = 1: mN(1rbg)
       = 4: 16F(4rbg)
       = 8: 256F(8rbgFftHg)
       = 16: 2^16F(16rbg)
       = 24: 2^24F(24rbg)
       = 32: 2^32F(32rbg)
 IBITS = rbg}bvEf[^
         rbg}bv̍_[0,0]ƂāCʒu[i,j]̃sNZ̘_Fԍ
             IBITS(i+IW*j+1)    : [F}
             IBITS[i+IW*j]      : [C]
         ɐݒ肷ii = 0 ` IW-1Cj = 0 ` IH-1j.
(o͕ϐ)
  IRTN = ۂɃrbg}bvۑzvfԍBsƂ 0 ԂB

[TOC] [INDEX]

77. tHgrbg}bvւ̕ϊ
-----------------------------------------------------------------------------
[F] SUBROUTINE GWFNT2BMP(IRTN, NB, IW, IH, IU, IV, TEXT)
    INTEGER IRTN, NB, IW, IH, IC, IU, IV
    CHARACTER TEXT*(*)

[C] int GWfnt2bmp(int NB, int IW, int IH, int IU, int IV, char *TEXT);
-----------------------------------------------------------------------------
()
   ݂̃tHggĕ񂩂烂mNErbg}bv쐬B쐬ꂽ
   rbg}bv̓rbg}bvԍNB ɓo^B
(͕ϐ)
    NB = rbg}bvԍ(1`): 쐬rbg}bvۑz̗vfԍB
         NB = 0 ƂƖgp̔zvfgB
    IW = rbg}bv̕(sNZ)
    IH = rbg}bv̍(sNZ)
    IU = _̃ItZbguW(sNZ)
    IV = _̃ItZbgvW(sNZ)
  TEXT = 
(o͕ϐ)
  IRTN = ۂɃrbg}bvۑzvfԍBsƂ 0 ԂB

[TOC] [INDEX]

78. rbg}bv̑ݒ
-----------------------------------------------------------------------------
[F] SUBROUTINE GWSETBMP(IRTN, NB, W, H, MX, ITR, IOF)
    INTEGER IRTN, NB, MX, ITR, IOF
    REAL W, H

[C] int GWsetbmp(int NB, float W, float H, int MX, int ITR, int IOF);
-----------------------------------------------------------------------------
()
    NB Ŏw肳ꂽo^ς݃rbg}bv̕`掞̑ݒ肷Bj[o[
     [Edit] -> [Import Clipboard] Ŏ荞񂾃rbg}bv 0 Ԃɓo^
    ĂBW = H = 0 ̏ꍇ͓o^̃TCY_foCXWnŉ肳B
    rbg}bv[h MX ݂͌̃uVA]̃rbg}bvA]
    rbg}bvgݍ킹ďo͑̐F𐶐@`BMX > 15 
    ꍇ MX - 16 ̒l "ternary raster-operation code" ƂĎgpB
    ITR > 0 ̏ꍇɂ ITR Ŏw肳ꂽFɂȂBIOF ł͊_ǂ
    uw肷Bp^̒l̏ꍇ́CΉ鑮͕ύXȂB
(͕ϐ)
    NB = gprbg}bvԍB
     W = ʏ̃rbg}bv̕([hWn)B
     H = ʏ̃rbg}bv̍([hWn)B
    MX = 0 ... 15 : rbg}bv[h(ȉQ)B
       > 15 :  (MX - 16) = "ternary raster-operation code[W]"
   ITR = [htO
       = 0: s[h(rbg}bv͋`ŕ\)
       = 1: 𓧖FƂ(ftHg)
       > 1: F̘_Fԍl + 2 (. 2 => )
   IOF = _̈ʒuw肷
       = 0:  (ftHg)
       = 1: 
       = 2: E
       = 3: E
       = 4: 
       = 5: 
       = 6: 
       = 7: E
       = 8: 

    (rbg}bv[h)
        0: INVERTNOT = source XOR (NOT dest)
            ]rbg}bv𔽓]ǍʂƓ]rbg}bv_ XOR 
            ZqŌ܂B
        1: SRCCOPY = source
            
        2: SRCPAINT = source OR dest
            ]rbg}bṽsNZƓ]rbg}bv_ OR Zq
            ܂B
        3: SRCAND = source AND dest
            ]̃rbg}bvƓ]rbg}bṽsNZ_ AND Zq
            Ō܂B
        4: SRCINVERT= source XOR dest
            ]rbg}bṽsNZƓ]rbg}bv_ XOR Zq
            ܂B
        5: SRCERASE = source AND (NOT dest )
            ]rbg}bv𔽓]ǍʂƓ]rbg}bv_ AND 
            ZqŌ܂B
        6: NOTSRCCOPY = (NOT source)
            ]]rbg}bv]rbg}bvɃRs[܂B
        7: NOTSRCERASE = (NOT src) AND (NOT dest)
            ]rbg}bvƓ]rbg}bv_ OR ZqŌ
            ʂ𔽓]܂B
        8: MERGECOPY = (source AND pattern)
            p^[ rbg}bvƓ]rbg}bv_ AND ZqŌ
            ܂B
        9: MERGEPAINT = (NOT source) OR dest
            ]]rbg}bvƓ]rbg}bv_ OR ZqŌ
            ܂B
       10: PATCOPY = pattern
           p^[ rbg}bv]rbg}bvɃRs[܂B
       11: PATPAINT = DPSnoo
           ]]rbg}bvƃp^[ rbg}bv_ OR Zq
           ܂BɁȂœ̂Ɠ]rbg}bv_ OR 
           ZqŌ܂B
       12: PATINVERT = pattern XOR dest
           p^[ rbg}bvƓ]rbg}bv_ XOR ZqŌ
           B
       13: DSTINVERT = (NOT dest)
           ]̃rbg}bv𔽓]܂B
       14: BLACKNESS = BLACK
           ׂĂ̏o͂ɂ܂B
       15: WHITENESS = WHITE
           ׂĂ̏o͂𔒂ɂ܂B
(o͕ϐ)
   IRTN = ^[ER[h

[TOC] [INDEX]

79. rbg}bv̑擾
-----------------------------------------------------------------------------
[F] SUBROUTINE GWGETBMP(IRTN, NB, W, H, IW, IH, IB, MAXNB, FN)
    INTEGER IRTN, NB, IW, IH, NC, MAXNB
    CHARACTER FN*(*)
    REAL W, H

[C] int GWgetbmp(int NB, float *W, float *H, int *IW, int *IH, 
		int *NC, int *MAXNB, char *FN, int l);
-----------------------------------------------------------------------------
()
    o^ς݃rbg}bv̑擾B
(͕ϐ)
    NB = 擾rbg}bvԍB0 ̓Nbv{[hC|[g
         ([Edit] => [Import Clipboard])Ƀrbg}bvۑԍB
     l = char ϐ FN ̒ ([C])
(o͕ϐ)
     W = rbg}bv̕[hWɊŹB
     H = rbg}bv̍[hWɊŹB
    IW = rbg}bv̕(rbg)B
    IH = rbg}bv̍(rbg)B
    IB = rbg}bv̊esNZ`rbgBsꍇ 0B
 MAXNB = o^ς݃rbg}bvԍ̍őlB
    FN = rbg}bvt@CB FN == NULL ([C]) ܂ FN ̒\łȂ
         ꍇ͖B
  IRTN = ^[ER[h

[TOC] [INDEX]

80. rbg}bv̕`
-----------------------------------------------------------------------------
[F] SUBROUTINE GWPUTBMP(IRTN, NB, X, Y, IBK)
    INTEGER IRTN, NB, IBK
    REAL X, Y

[C] int GWputbmp(int NB, float X, float Y, int IBK);
-----------------------------------------------------------------------------
()
    w肳ꂽo^ς݃rbg}bv NB ʒu (X, Y) ɕ`悷Brbg}bv
     GWSETBMP Őݒ肷BIBK ͔wiǂ̂悤Ɉw肷B
    `̑OɔwiۑC̕`̑OɕۑĂwi𕜌C܂C
    `悳Ărbg}bvΊȒPȃAj[V邱Ƃ
    łBIBK ̃ftHgl 1 ŁC`݂̂sB
(͕ϐ)
    NB = gprbg}bvԍB
     X = rbg}bv_ X W([hWn)B
     Y = rbg}bv_ Y W([hWn)B
   IBK = R*4 + S*2 + D*1
         R = 1(0): `̑Oɔwi̕sisȂj
         S = 1(0): `̑Oɔwi̕ۑsisȂj
         D = 1(0): `sisȂj

   ) IBK = 7: () > ۑ > `s
       IBK = 4: ()݂̂s

(o͕ϐ)
   IRTN = ^[ER[h

[TOC] [INDEX]

81. ۑrbg}bṽRs[o^
-----------------------------------------------------------------------------
[F] SUBROUTINE GWCOPYBMP(IRTN, NB1, NB2)
    INTEGER IRTN, NB1, NB2

[C] int GWcopybmp(int NB1, int NB2);
-----------------------------------------------------------------------------
()
    rbg}bvԍ NB1 (0 ` MAXNB)ɓo^Ărbg}bvrbg}bv
    ԍ NB2 ɍēo^B
(͕ϐ)
  NB1 = o^̃rbg}bvԍ
  NB2 = o^̃rbg}bvԍBNB = 0 ƂƖgp̔zvfgB
(o͕ϐ)
 IRTN = ۂɓo^ꂽrbg}bvԍB

[TOC] [INDEX]

82. rbg}bv̓o^폜
-----------------------------------------------------------------------------
[F] SUBROUTINE GWDELBMP(IRTN, NM)
    INTEGER IRTN, NM

[C] int GWdelbmp(int NM);
-----------------------------------------------------------------------------
()
    rbg}bvԍ NM (1 ` MAXNM) ̃rbg}bv̓o^폜Bw肳ꂽ
    rbg}bvԍgp̏ꍇ͉ȂB
(͕ϐ)
  NM = 폜rbg}bv̔ԍ
(o͕ϐ)
 IRTN = ۂɍ폜ꂽrbg}bv̔ԍ (>0)B폜Ȃꍇ 0B

[TOC] [INDEX]

83. `̈̎荞
-----------------------------------------------------------------------------
[F] SUBROUTINE GWCAPIMG(IRTN, NB, X1, Y1, X2, Y2)
    INTEGER IRTN, NB
    REAL X1, Y1, X2, Y2

[C] int GWcapimg(int NB, float X1, float Y1, float X2, float Y2);
-----------------------------------------------------------------------------
()
    (X1,Y1)-(X2,Y2) Ŏw肳ꂽ`̈rbg}bvƂāCrbg}bvԍ
    NB ɓo^Bw肳ꂽ`̖̈ʐς 0 ̏ꍇɂ́C݂̃EBhES
    ̂肳B
(͕ϐ)
    NB = rbg}bvԍ(1`): ǂݍ񂾃rbg}bvۑz̗vfԍB
         NB = 0 ƂƖgp̔zvfgB
   X1 = `̊p̓_ X W([hWn)
   Y1 = `̊p̓_ Y W([hWn)
   X2 = _(X1, Y1)ƑΊpƂȂ_ X W([hWn)
   Y2 = _(X1, Y1)ƑΊpƂȂ_ Y W([hWn)
(o͕ϐ)
  IRTN = ۂɃrbg}bvۑzvfԍBsƂ 0 ԂB

[TOC] [INDEX]

84. `̈̃Nbv{[hւ̃Rs[
-----------------------------------------------------------------------------
[F] SUBROUTINE GWCLIPIMG(IRTN, X1, Y1, X2, Y2)
    INTEGER IRTN
    REAL X1, Y1, X2, Y2

[C] int GWclipimg(float X1, float Y1, float X2, float Y2);
-----------------------------------------------------------------------------
()
    (X1,Y1)-(X2,Y2) Ŏw肳ꂽ`̈Nbv{[hփRs[BNbv
    {[hփRs[ꂽ}`̓rbg}bvԍ 0 ɂۑBw肳ꂽ`
    ̖̈ʐς 0 ̏ꍇɂ́C݂̃EBhEŜ肳B
(͕ϐ)
   X1 = `̊p̓_ X W([hWn)
   Y1 = `̊p̓_ Y W([hWn)
   X2 = _(X1, Y1)ƑΊpƂȂ_ X W([hWn)
   Y2 = _(X1, Y1)ƑΊpƂȂ_ Y W([hWn)
(o͕ϐ)
  IRTN = ^[ER[h

[TOC] [INDEX]

85. R{Et@C̓ǂݍ
-----------------------------------------------------------------------------
[F] SUBROUTINE GWLOADCMB(IRTN, NM, FN)
    INTEGER IRTN, NM
    CHARACTER FN*(*)

[C] int GWloadcmb(int NM, char *FN);
-----------------------------------------------------------------------------
()
    R{Et@CR{ǂݍŁCR{ԍ NM ɓo^BR{Ƃ
	g̕`IuWFNĝƂŁC쐬ꂽR{͑傫ςĉʂɉx
	`悵Ct@Cɕۑ邱ƂłBR{Et@C̓R{\
	`IuWFNgg^t@CƓt@C`ŕۑ̂ŁCf
	tHg̊gqɂ͊g^t@CƓ .emf pBUo^ꂽ
	R{͂̃R{ԍw肷邱Ƃɂ艽xłp邱ƂłBR
	{̓o^ɏ݂͐ĂȂȂC̓[CVXeE[\[X
	̗ʂɈˑBVXeE[\[Xg؂Ƃ̓ɂĂ͂قƂ
	`FbNsĂȂ̂ŗvӁB
(͕ϐ)
    NM = R{ԍ(1`): ǂݍ񂾃R{ۑz̗vfԍB
         NM = 0 ƂƖgp̔zvfgB
    FN = R{Et@C(R{Et@C͎st@CƓfBNgɒu
         CtpXŎw肵Ȃ΂ȂȂ)
(o͕ϐ)
  IRTN = R{o^ꂽzvf̔ԍBsƂ 0 ԂB

[TOC] [INDEX]

86. R{tBɕۑ
-----------------------------------------------------------------------------
[F] SUBROUTINE GWSAVECMB(IRTN, NM, FN)
    INTEGER IRTN, NM
    CHARACTER FN*(*)

[C] int GWsavecmb(int NM, char *FN);
-----------------------------------------------------------------------------
()
    ԍ NM ̃R{R{Et@CɕۑB
(͕ϐ)
    NM = R{ԍ
    FN = R{Et@C
(o͕ϐ)
  IRTN = ^[ER[h

[TOC] [INDEX]

87. }[NR{Ƃč쐬
-----------------------------------------------------------------------------
[F] SUBROUTINE GWCMBMRK(IRTN, NM, MT, S, K, KB, MX)
    INTEGER IRTN, NM, MT, K, KB, MX
    REAL S

[C] int GWcmbmrk(int NM, int MT, float S, int K, int KB, int MX);
-----------------------------------------------------------------------------
()
   }[Nԍ MT(0-6)C傫 S([hWn)C}[N̘_Fԍ KC}[N
   wiF̘_Fԍ KBC[h MX Ŏw肳ꂽ}[N (GWSETMRK ̍Q) 
   R{ƂăR{ԍ NM ɓo^B}[N (GWSETMRK ̍Q) ͕
   ȂBMT, S, K, KB, MX ɕsȒlw肳ꂽꍇɂ̓}[Ňݒlg
   DNM = 0 ܂́Cw肵R{ԍ NM ̃R{gĂƂɂ́C
   gp̔ԍgB
(͕ϐ)
   NM = o^]R{ԍ
   MT = 0: _
        1: 
        2: {
        3: ~
        4: {Ɓ~d˂킹
        5: 
        6: 
    S = }[N̍([hWn) >= 0.0
    K = }[N̘_Fԍ(GWCOLOR ̍Q)
        -1 ̏ꍇ̓}[Ňݒl
   KB = }[N̔wiF̘_Fԍ(GWCOLOR ̍Q)
        -1 ̏ꍇ̓}[Ňݒl
   MX = }[N̍[h(GWSETPEN ̍Q)
(o͕ϐ)
 IRTN = ۂɓo^ꂽR{ԍBsƂ 0 Ԃ

[TOC] [INDEX]

88. R{̍쐬Jn
-----------------------------------------------------------------------------
[F] SUBROUTINE GWBEGINCMB(IRTN, NM, W, H)
    INTEGER IRTN, NM
    REAL W, H

[C] int GWbegincmb(int NM, float W, float H);
-----------------------------------------------------------------------------
()
    R{̍쐬JnCR{ԍ NM \񂷂BR{Ƃ͈g̕`Iu
    WFNĝƂŁC쐬ꂽR{͑傫ςĉʂɉxł`悵C
    t@Cɕۑ邱ƂłB\񂵂R{ GWENDCMB ō쐬I
    ܂ł͎gpłȂBGWBEGINCMB  GWENDCMB ̌Ăяo̊ԂɎsꂽ`施
    ߂ׂăR{֑gݍ܂C̊ԉʂɂ͉`悳ȂB
(͕ϐ)
    NM = R{ԍ(1`): R{ۑz̗vfԍB
         NM = 0 ƂƖgp̔zvfgB
     W = R{̕( > 0: [hW)
     H = R{̍( > 0: [hW)
(o͕ϐ)
  IRTN = \񂵂R{̔zvfԍBsƂ 0 ԂB

[TOC] [INDEX]

89. R{̍쐬I
-----------------------------------------------------------------------------
[F] SUBROUTINE GWENDCMB(IRTN)
    INTEGER IRTN

[C] int GWendcmb(void);
-----------------------------------------------------------------------------
()
    R{ւ̕`ICR{gp\ɂB
(͕ϐ)
    Ȃ
(o͕ϐ)
  IRTN = 쐬R{̔zvfԍ (>0)BsƂ 0 ԂB

[TOC] [INDEX]

90. R{̕`
-----------------------------------------------------------------------------
[F] SUBROUTINE GWPUTCMB(IRTN, NM, X, Y, W, H, IOF)
    INTEGER IRTN, NM, IOF
    REAL X, Y, W, H

[C] int GWputcmb(int NM, float X, float Y, float W, float H, int IOF);
-----------------------------------------------------------------------------
()
    w肳ꂽo^ς݃R{ NM ʒu (X, Y) ɁC WC H ŕ`悷
    BW = 0.0 ܂ H = 0.0 ̏ꍇɂ͍쐬̑傫ŕ`悳BIOF ɂ 
    (X, Y) Ŏw肷_ǂɒuw肷B
(͕ϐ)
    NM = R{ԍB
     X = _ X W([hWn)B
     Y = _ Y W([hWn)B
     W = ʏ̕([hWn)B
     H = ʏ̍([hWn)B
   IOF = _̈ʒuw肷
       = 0:  (ftHg)
       = 1: 
       = 2: E
       = 3: E
       = 4: 
       = 5: 
       = 6: 
       = 7: E
       = 8: 

(o͕ϐ)
   IRTN = ^[ER[h

[TOC] [INDEX]

91. R{̑擾
-----------------------------------------------------------------------------
[F] SUBROUTINE GWGETCMB(IRTN, NM, W, H, W0, H0, MAXNM, FN)
    INTEGER IRTN, NM, MAXNM
    CHARACTER FN*(*)
    REAL W, H, W0, H0

[C] int GWgetcmb(int NM, float *W, float *H, float *W0, float *H0, 
		int *MAXNM, char *FN, int l);
-----------------------------------------------------------------------------
()
    o^ς݃R{̑擾BNM ɖo^C邢͕sȃR{ԍw
    ꂽꍇɂ MAXNM ɗLȒlԂB
(͕ϐ)
    NM = 擾R{̔ԍ (>0)B
     l = char ϐ FN ̒ ([C])
(o͕ϐ)
     W = `掞̃R{̕([hW)B
     H = `掞̃R{̍([hW)B
    W0 = ^t@CƂĂ̕(mm)B
    H0 = ^t@CƂĂ̍(mm)B
 MAXNM = o^ς݃R{ԍ̍őlB
    FN = ^t@CB FN == NULL ([C]) ܂ FN ̒\łȂꍇ
    B
  IRTN = ^[ER[h

[TOC] [INDEX]

92. ۑR{̃Rs[o^
-----------------------------------------------------------------------------
[F] SUBROUTINE GWCOPYCMB(IRTN, NM1, NM2)
    INTEGER IRTN, NM1, NM2

[C] int GWcopycmb(int NM1, int NM2);
-----------------------------------------------------------------------------
()
    R{ԍ NM1 (0 ` MAXNM)ɓo^ĂR{R{ԍ NM2 ɍēo^
    B
(͕ϐ)
  NM1 = o^̃R{ԍ
  NM2 = o^̃R{ԍBNM = 0 ƂƖgp̔zvfgB
(o͕ϐ)
 IRTN = ۂɓo^ꂽR{ԍB

[TOC] [INDEX]

93. R{̓o^폜
-----------------------------------------------------------------------------
[F] SUBROUTINE GWDELCMB(IRTN, NM)
    INTEGER IRTN, NM

[C] int GWdelcmb(int NM);
-----------------------------------------------------------------------------
()
    R{ԍ NM (0 ` MAXNM) ̃R{̓o^폜Bw肳ꂽR{ԍ
    gp̏ꍇ͉ȂB
(͕ϐ)
  NM = 폜R{̔ԍ
(o͕ϐ)
 IRTN = ۂɍ폜ꂽR{̔ԍB

[TOC] [INDEX]

94. ̓
-----------------------------------------------------------------------------
[F] SUBROUTINE GWINPUT(IRTN, TITLE, TXT)
    INTEGER IRTN
    CHARACTER TITLE*(*), TXT*(*)

[C] int GWinput(char *TITLE, char *TXT, int l);
-----------------------------------------------------------------------------
()
   L[{[h當͂邽߂̃_CAOJB
(͕ϐ)
 TITLE = ^Cgo[ɕ\镶
     l = ϐ TXT ̒ ([C])
(o͕ϐ)
  IRTN = ̒(oCg)
   TXT = (͂̏I̓^[L[)

[TOC] [INDEX]

95. _CAO{bNXɂt@C̎擾
-----------------------------------------------------------------------------
[F] SUBROUTINE GWFILEDLG(IRTN, FN)
    INTEGER IRTN
    CHARACTER FN*(*)

[C] int GWfiledlg(char *FN, int l);
-----------------------------------------------------------------------------
()
    ut@C̎擾v_CAO{bNXJăt@C擾B_CA
    O{bNXŎw肵t@Ci`͏nɈˑj̒()
    ϐ FN ̒𒴂ꍇɂ͎sCFN ͕ωȂB
(͕ϐ)
  FN = lƂėpt@C
   l = ϐ FN ̒ ([C])
(o͕ϐ)
 IRTN > 0: 擾t@C̒
      < 0: -(_CAO{bNXŎw肵t@C̒ > l)
      = 0: ̎s
   FN = 擾t@C (ꍇ)

[TOC] [INDEX]

96. f[^̓ǂݍ
-----------------------------------------------------------------------------
[F] SUBROUTINE GWLOAD(IRTN, IC, FN)
    INTEGER IRTN
    CHARACTER FN*(*)

[C] int GWload(int IC, char *FN);
-----------------------------------------------------------------------------
()
    ۑt@C(*.gwd)ǂݍ݁C`悷Bt@C FN Ŏw肳ꂽt@C
    Ȃꍇ̓t@C擾̃_CAO{bNXJBp[^ IC
    ̒lɂ蓮삪قȂBkڂ𒲐ȂƂɂ́Cۑ(foCXɈˑ
    ) kڂŌEBhEɒǉ̂ŁCۑƈقȂœǂݍޏ
    Ȃǂɂ͒ӂKvB
(͕ϐ)
    IC = 0: kڂ𒲐ȂŒǉBp^͕ȂB
       = 1: kڂ𒲐Ēǉ(p^͕Ȃ)
       = 2: kڂ𒲐ȂŒǉCp^𕜌
        : kڂ𒲐ĒǉCp^𕜌
    FN = ۑt@C(t@C͎st@CƓfBNgɒuCt
         pXŎw肵Ȃ΂ȂȂ)
(o͕ϐ)
  IRTN = ^[ER[h

[TOC] [INDEX]

97. f[^̕ۑ
-----------------------------------------------------------------------------
[F] SUBROUTINE GWSAVEAS(IRTN, MF, MV, IW, IH, FN)
    INTEGER IRTN, MF, MV, IW, IH
    CHARACTER FN*(*)

[C] int GWsaveas(int MF, int MV, int IW, int IH, char *FN);
-----------------------------------------------------------------------------
()
    }`f[^C̓p[^ MF Ŏw肵t@C`Ńt@CɕۑB
    t@Cw肷̓p[^ FN ̒ 0 ( FN == NULL [C]) ̏ꍇ
    ́Ct@C擾̃_CAO{bNXJBMF  0 ܂ C邢͑
    ̖Ȓlݒ肳ꂽꍇɂ́Ct@C̊gqɂt@C`
    Bt@C̊gqt@C`łȂꍇɂ GrWin 
    L̃t@C`iGWD t@C`j肳CKvȂΊgq '.gwd' t
    Br[(\)[hw肷̓p[^ MV ƁCۑt@C
    ƍ^̓p[^ IWCIH ̒lɂ\͈͂AXyNg䂪
    ̂ŒӁB^̓̓p[^̒l 0 ̏ꍇɂ̓ftHglg
    BIW ܂ IH ɕ̒lݒ肳ꂽꍇɂ͂ꂼ̌]B
    ̃[`͕ۑ[hiGWMODE QƁj on ̏ꍇɐɓ삷B
(͕ϐ)
    MF = t@C` (gq, ƍ̒P)
       = 1: GWD t@C ('.gwd', Ȃ) 
       = 2: g^t@C ('.emf', 0.01 mm)
       = 3: rbg}bv ('.bmp', sNZ)
    MV = r[[h
         1: rbg}bv
         2: I
         3: tBbg
         4: S
         5: ݂̃r[|[g
    IW =  (Pʂ MF ̍QƁj
    IH = iPʂ MF ̍QƁj
    FN = t@C
(o͕ϐ)
  IRTN = ^[ER[h

[TOC] [INDEX]

98. 
-----------------------------------------------------------------------------
[F] SUBROUTINE GWPRINT(IRTN, IW, MV)
    INTEGER IRTN, IW, MV

[C] int GWprint(int IW, int MV);
-----------------------------------------------------------------------------
()
    IW Ŏw肳ꂽEBhEBIW = 0 ̏ꍇ̓JgEEBhE
    BIW < 0 ̏ꍇɂ̓AvP[VJׂẴEBhE
    BMV ɂ͈̃r[(\)[hw肷BIW < 0 ̏ꍇɂ̓J
    gEEBhĚ݂̃r[(\)[hiGWVWMOD QƁj肳B
    [`͕ۑ[hiGWMODE QƁj on ̏ꍇɐɓ삷B
(͕ϐ)
    IW = EBhẼEBhEԍB
    MV = r[[h
         1: rbg}bv
         2: I
         3: tBbg
         4: S
         5: ݂̃EBhES
(o͕ϐ)
  IRTN = ^[ER[h

[TOC] [INDEX]

99. IuWFNgEO[vԍ̐ݒ
-----------------------------------------------------------------------------
[F] SUBROUTINE GWSETOGN(IRTN, ISRC, IDST)
    INTEGER IRTN, ISRC, IDST

[C] int GWsetogn(int ISRC, int IDST);
-----------------------------------------------------------------------------
(IuWFNgEO[vԍɂ)
   IuWFNgEO[vԍ (OGN) Ƃ͊e`IuWFNg(}`vf)𕪗ނ
   ߂ɗpӂꂽIuWFNg̑̈ŁCOGN ̃IuWFNg͕`悪
   Cobt@iFBFtbVEobt@jɕۑBvZԂ̂
   镡GȐ}`̍\zȂǕ`ۗĂCOGN ̕𐳂ɕύX邱Ƃɂ
   `ۗ̕CɉāCȕ`sƂłBtbV
   `ƌĂԁB܂Cۑ[hiGWMODE QƁjȈꍇɂ́CIuWFNg
   `ɃɕۑiVACYjCOGN ͂ۑIuWFNg̑I
   Iȏ (GWERASE Q) Ȃǂ̂߂ɂQƂBftHg OGN  1 
   ZbgĂ(OGN = 0 ̓VXeŎgp)BȂCۑ[hiGWMODE 
   QƁjIt̏ꍇɂ́C`ɃIuWFNg͏̂ŁCOGN  FB 
   ۑIuWFNgɑ΂ĂLB|OGN|  32767 ȉłȂ΂ȂȂB
()
   ISRC != 0 ̏ꍇɂ OGN  ISRC ɓۑIuWFNg OGN  IDST ɕ
   XCOGN ̒l ISRC ɓۑIuWFNg̐ IRTN ɕԂB
   ƂCOGN 畉ɕύXƑΉIuWFNg͕ۗԂɖ߂ĉ
   ʂB΂ɁC琳ɕύXƕۗԂCtbV`
   悪sBOGN  0 ɕύXƂ̓VXeݒpIuWFNgƂāC
   ȌłȂȂBISRC = 0CIDST != 0 ̏ꍇɂ́Cȍ~ɕ`悳I
   uWFNg OGN  IDST Ŏw肳ꂽlɐݒ肳C݂̃IuWFNg̑
    IRTN ɕԂBISRC = IDST = 0 ̏ꍇɂ OGN ͕ύXꂸC݂ OGN 
    IRTN ɕԂB

   ISRC  IDST :                       : o͒l
  ------------+---------------------------+--------------------------
     +  !  0  : ی                      : ی삳ꂽIuWFNg
     +  =  +  : Ȃ                : ۑIuWFNg OGN  ISRC 
                                            ̂̑
     +  !  +  : ۑIuWFNgOGNύX : OGNύXꂽIuWFNg
     +  =  -  : ISRCB                : BꂽIuWFNg
     +  !  -  : ISRCIDSTɕύXCB  : BꂽIuWFNg
     -  !  0  : tbV`ɕی    : ی삳ꂽIuWFNg
     -  =  +  : tbV`            : tbV`悳ꂽIuWFNg
     -  !  +  : tbV`OGNύX : tbV`悳ꂽIuWFNg
     -  =  -  : Ȃ                : FB  OGN  -ISRC ɓIu
                                            WFNg̐
     -  !  -  : FBISRCIDSTɌ: ꂽIuWFNg
     0  =  0  : Ȃ                : ݂ OGN
     0  ! +/- : ݂OGNύX       : ۑIuWFNg
  
   [ L '='C'!'  ISRC  IDST ̐ΒlłȂ\B] 
(͕ϐ)
  ISRC != 0: IuWFNg OGN (= ISRC)  IDST ɕύX
        = 0: ȍ~ OGN  IDST (!= 0) Ƃ
  IDST  = Zbg OGN
(o͕ϐ)
   IRTN = OGN ̒l ISRC ɓIuWFNg̐ (ISRC != 0 ̏ꍇ)
        = ݂̃IuWFNg̑ (ISRC = 0, IDST != 0 ̏ꍇ)
        = ݂ OGN  (ISRC = IDST = 0 ̏ꍇ)
      < 0 s̏ꍇ

[TOC] [INDEX]

100. AJ[
-----------------------------------------------------------------------------
[F] SUBROUTINE GWANCHOR(IRTN, N)
    INTEGER IRTN, N

[C] int GWanchor(int N);
-----------------------------------------------------------------------------
()
   AJ[̐ݒƏsBAJ[Ƃ̓IuWFNgEO[vԍ (OGN) 
   0 ̉ȂIuWFNgłCɁCGWFLUSH  GWERASE Ƒgݍ킹āC
   ܂łɕ`悵IuWFNg̕یɗpBftHgł́Cی삳ꂽIu
   WFNg͔wiƂčĕ`ɎgpBeAJ[̓IuWFNg̐擪
   牽Ԗڂ̃AJ[ɂAJ[ԍŎʂBۑ[hiGWMODE QƁj
    off ̏ꍇCAJ[̓IuWFNgƂĂ̈ӖCwi̕ۑ̂߂
   ɎgB
(͕ϐ)
     N > 0: IuWFNg̍ŌɃAJ[BN ̒l݂̃AJ[ɓ
            ꍇɂ́CÕAJ[菜āCAJ[͕ωȂB
       < 0: IuWFNg̍Ō |N| ̃AJ[菜B
       = 0: ׂẴAJ[菜B
(o͕ϐ)
 IRTN >  0: ݂̃AJ[
      == 0: AJ[̒ǉɎs
      <  0: -(菜Ƃ̂łȂAJ[)

[TOC] [INDEX]

101. wi̐ݒ
-----------------------------------------------------------------------------
[F] SUBROUTINE GWSETBK(IRTN, N)
    INTEGER IRTN, N

[C] int GWsetbk(int N);
-----------------------------------------------------------------------------
()
    AJ[ԍ N ( > 0 ) ̃AJ[wiAJ[ɐݒ肷BN = 0 ̏ꍇɂ
    wi[h (AJ[͍폜Ȃ)BN < 0 w肵ꍇɂ́C
    ݂̔wiAJ[ԍAJ[̖₢킹sB
(͕ϐ)
    N >  0: AJ[ԍ N ̃AJ[wiAJ[ɐݒ肷Bw肵ԍ
            AJ[݂Ȃꍇɂ͉ȂB
      =  0: wigpȂ
      = -1: wiAJ[ԍ̖₢킹
      < -1: AJ[̖₢킹
(o͕ϐ)
 IRTN >= 0: ݂̔wĩAJ[ԍ (N >= -1) ܂̓AJ[̑ (N < -1)
      <  0: G[

[TOC] [INDEX]

102. }`̏
-----------------------------------------------------------------------------
[F] SUBROUTINE GWERASE(IRTN, N, LRF)
    INTEGER IRTN, N, LRF

[C] int GWerase(int N, int LRF);
-----------------------------------------------------------------------------
()
   N > 0 ̏ꍇɂ́CIuWFNgEO[vԍ (GWSETOGN Q) ̐Βl N 
   ׂẴIuWFNg(}`vf)[BN = 0 ̏ꍇ̓J
   gEEBhÊׂẴIuWFNgC܂CN < 0 ̏ꍇɂ͍Ō
    abs(N) ȉ̃IuWFNgBLRF  0 łȂꍇɂ́C
   ꂽIuWFNgɑΉ}`ʏォɏ邪CLRF = 0 ̏
   ɂ͌Ăяoʂ͕ωCĕ`̍ۂɌʂfBȂC
   Ō̃IuWFNg珇ɍsCOGN  0 ̃IuWFNgɒBꍇɂ͂
   ŏIB̃[`͕ۑ[hiGWMODE QƁj on ̏ꍇɐɓ
   삷B
(͕ϐ)
    N > 0: IuWFNg OGN ̐Βl
      = 0: JgEEBhȄ
      < 0: Ō abs(N) ̃IuWFNg̏
  LRF = ĕ`tO(0 ̂Ƃĕ`sȂ)
(o͕ϐ)
  IRTN = ۂɏꂽIuWFNg̑

[TOC] [INDEX]

103. tbV`
-----------------------------------------------------------------------------
[F] SUBROUTINE GWFLUSH(IRTN, N)
    INTEGER IRTN, N

[C] int GWflush(int N);
-----------------------------------------------------------------------------
()
   N > 0 ̏ꍇ́COGN (GWSETOGN Q)  -N ɓׂẴIuWFNg(}`
   vf)  OGN ̕𐳂ɕύXătbV`sBN < 0 ̏ꍇɂ
   OGN ̐Βl N ɓIuWFNg OGN ׂ̕Ĕ]COGN 
   ȂIuWFNg菜BɂCΒlŕقȂIuWF
   Ng̕\̐؂ւsBN = 0 ̏ꍇ̓IuWFNgEO[vԍ
   ̃IuWFNg̕𔽓]CtbV`sBIRTN ɂ͕`悳ꂽ
   IuWFNg̑ԂB̃[`gpꍇ͕ۑ[hiGWMODE Q
   Ɓj on ɃZbgĂȂ΂ȂȂB
(͕ϐ)
     N > 0: OGN = -N ̃IuWFNgtbV`
       < 0: iOGN = -Nj{tbV`iOGN = Nj
       = 0: `ۗĂׂẴIuWFNg̃tbV`
(o͕ϐ)
  IRTN = `悳ꂽIuWFNg̑

[TOC] [INDEX]

104. ʂ̍ĕ`
-----------------------------------------------------------------------------
[F] SUBROUTINE GWREFRESH(IRTN)
    INTEGER IRTN

[C] int GWrefresh(void);
-----------------------------------------------------------------------------
()
   JgEEBhEĕ`悷Bj[o[  [r[] -> [ĕ`] 
   B̃[`͕ۑ[hiGWMODE QƁj on ̏ꍇɐɓ삷B
(͕ϐ)
    Ȃ
(o͕ϐ)
  IRTN = ^[ER[h

[TOC] [INDEX]

105. r[[h
-----------------------------------------------------------------------------
[F] SUBROUTINE GWVWMOD(IRTN, M)
    INTEGER IRTN, M

[C] int GWvwmod(int M);
-----------------------------------------------------------------------------
()
   JgEEBhẼr[(\)[h̐ݒ/₢킹sB EBhE
   JĂȂꍇɂ̓ftHg̃r[[h̐ݒ/₢킹sBf
   tHg̃r[[h̓EBhẼI[viGWopen QƁjɎQƂB
(͕ϐ)
    M = 1:    rbg}bv
        2:    I
        3:    tBbg
        4:    S
        5:    gĩ݂r[|[gցFݒ莞j
       :    ₢킹
(o͕ϐ)
 IRTN = JgEEBhẼr[(\)[h(͕ϐ̍ڎQ, 0: s)

[TOC] [INDEX]

106. [hݒƖ₢킹
-----------------------------------------------------------------------------
[F] SUBROUTINE GWMODE(IRTN, MD, M)
    INTEGER IRTN, MD, M

[C] int GWmode(int MD, int M);
-----------------------------------------------------------------------------
()
   e탂[hiȉQƁj̐ݒ//₢킹sB[h̎ʂƐݒ胂[h
    MD  M Ŏw肷D

   1. ۑF ۑ[h on ̏ꍇɂ͐}`IuWFNg͕`Ƀɕۑ
      iVACYjCĕ`t@Cւ̕ۑCɍėpB
      ۑ[h off ̏ꍇC}`IuWFNg͕`ɍ폜Bۑ[h
      ̉ɂ胁[gpʂ}邪ĈƂɕ`悳ꂽIuWFN
      g̃t@Cւ̕ۑ͐̂ŒӁBftHgł onB

   2. obt@OF obt@OsƁC݂̉ʂƓ\́upv
      IɃrbg}bvƂėpӂCʂւ̍ĕ`悪B
      ̏kڂɂĂ͑ʂ̃[BftH[gł on B   

   3. Xe[^XEo[̕\F Xe[^XEo[Ƃ̓C(t[)EEBhE
      ŉ̃o[̂ƂŁCeԂ\B`ɍsꍇ̓X
      e[^XEo[\\Ȃق悢BftHgł onB

   4. mFF ܂܂ȏʂŁCx⒍ӂ𑣂_CAO{bNX\B
      ftHgł offB

   5. hXP[vF ɗpuihXP[vjɐݒ肷B
      ftHgł onB

   6. EBhEJ܂܏IF GWQUIT ̌ĂяoƂCEBhEJ
      ܂܏IBftHgł offB

   7. rbg}bv̖ߍ݁F gwd t@CɃrbg}bv𖄂ߍށB̃[h off ɂ΃rbg}bvEt@CoƂłBftHgł onB
(͕ϐ)
   MD = 1 :  ۑ
        2 :  obt@O
        3 :  Xe[^Xo[̕\
        4 :  mF
        5 :  hXP[v
        6 :  EBhEJ܂܏I
        7 :  rbg}bv̖ߍ
        :  
    M = 0 :   (off) 
      > 0 :  ݒ (on) 
      < 0 :  ₢킹̂
(o͕ϐ)
 IRTN = 0 :   (off) Ă
        1 :  ݒ (on) Ă
       -1 :  G[

[TOC] [INDEX]

107. L[{[hEXe[^X
-----------------------------------------------------------------------------
[F] SUBROUTINE GWKYBRD(IRTN, ICH, NCNT, IFLG, M)
    INTEGER IRTN, ICH, NCNT, IFLG, M

[C] int GWkybrd(int *ICH, int *NCNT, int *IFLG, int M);
-----------------------------------------------------------------------------
()
   ANeBuȃEBhEł̃L[{[h擾Bďo M ̒lɂ蓮
   삪قȂ(ȉQ)BωȂ(IRTN = 0)ƂCICH, NCNT, IFLG ̊e
   ̒l͕ωȂB
(͕ϐ)
   M = 0   L[{[h擾Ēɐ߂
       1   VXeL[(L[Ȃ)C̃R[h ASCII R[hւ
           ϊI܂ő҂D
       2   ǂꂩL[܂ő҂
       3   ǂꂩL[܂ő҂
   ̑  L[ĂƂ͂̃L[܂ő҂CĂяoꂽƂ
           ̃L[{[hԂDL[ĂȂƂ͒ɐ߂
(o͕ϐ)
 IRTN = L[Ă΂̃L[̉zR[h(ĂȂƂ 0)
  ICH = ŌɉꂽVXeL[(L[Ȃ)̕R[h
 NCNT = L[Ƃ̃L[̉
 IFLG = tOBӖ̂rbg͈ȉ̒ʂF

          0-7  XL R[h (OEM ˑ̒l)
            8  t@NV L[␔L[pbh̃L[ȂǁCgL[̏
                1
        11-12  Windows Ŏgp
           13  Alt L[Ԃłق̃L[ꍇ 1CȊO 0
           14  OɃL[Ăꍇ 1CĂꍇ 0
           15  ϊ (L[𗣂Ăꍇ 1CĂꍇ 0)

[TOC] [INDEX]

108. }EX
-----------------------------------------------------------------------------
[F] SUBROUTINE GWMOUSE(IRTN, IRB, X, Y)
    INTEGER IRTN, IRB
    REAL X, Y

[C] int GWmouse(int *IRB, float *X, float *Y);
-----------------------------------------------------------------------------
()
   JgEEBhEł̃}EX擾B
(͕ϐ)
   Ȃ
(o͕ϐ)
 IRTN = {^̏ (ĂȂƂ 0)
  IRB = E{^̏ (ĂȂƂ 0)
    X = }EXE|C^ X W([hWn)
    Y = }EXE|C^ Y W([hWn)

[TOC] [INDEX]

109. C^[oE^C}[
-----------------------------------------------------------------------------
[F] SUBROUTINE GWTIMER(IRTN, MS, N)
    INTEGER IRTN, MS, N

[C] int GWtimer(int MS, int N);
-----------------------------------------------------------------------------
()
   N != 0 ̏ꍇ̓C^[o^C}[NBN == 0 ̏ꍇɂ̓C^[o
   ^C}[~BC^[o^C}[Nƈ̎ԊԊu MS (~
   bP) Ń^C}[ECxgB^C}[ECxgǂ
    GWEVENT Ŏ擾BN > 0 ̏ꍇɂ N ̃^C}[ECxg𔭐
   C^C}[͒~B
(͕ϐ)
    MS = ^C}[ECxg𔭐鎞ԊԊu(~bP)
     N  > 0: C^[o^C}[NC^C}[ECxg N 񔭐
        < 0: C^[o^C}[̋N
       == 0: C^[o^C}[̒~
(o͕ϐ)
  IRTN = ^[ER[h

[TOC] [INDEX]

110. CxgԂ̎擾
-----------------------------------------------------------------------------
[F] SUBROUTINE GWEVENT(IRTN, X, Y)
    INTEGER IRTN
    REAL X, Y

[C] int GWevent(float *X, float *Y);
-----------------------------------------------------------------------------
()
   JgEEBhẼCxgԂ擾BCxgԂ́CC^[o^
   C}[̐ݒ莞Ԃo߂CL[{[h̃{^}EX{^ƁC
   ̎_̃}EXJ[\̈ʒuƂƂɃZbgC{[`̌Ăяo
   ܂ŕێB{[`̌ĂяoCCxgԂ̓ZbgB
(͕ϐ)
   Ȃ
(o͕ϐ)
  IRTN: Cxg
       >  0: ꂽL[̉zR[h
       = -1: }EX̍{^ꂽ
       = -2: }EX̉E{^ꂽ
       = -3: ^C}[ECxgiGWTIMER QƁj
     X = }EXE|C^ X W([hWn)
     Y = }EXE|C^ Y W([hWn)

[TOC] [INDEX]

111. AChO
-----------------------------------------------------------------------------
[F] SUBROUTINE GWIDLE(IRTN, ICH, X, Y, MSEC)
    INTEGER IRTN, ICH, MSEC
    REAL X, Y

[C] int GWidle(int *ICH, float *X, float *y, int MSEC);
-----------------------------------------------------------------------------
()
   L[{[h當͂邩}EX{^܂ŁC邢͎w肵
   Ԃo߂܂ŃAChOԂɂBAChO̓AvP[V
   䂪߂Ȃ̂ŁC̊ԁCAvP[V͒~B}EXɂW
   L[{[h͂҂ꍇC邢́CAvP[V̎s𒆒fĈ
   ʃ[h̕ύXȂǁCj[sꍇɗpłBIRTN ɂ̓ACh
   OԂ̌oߎԂԂBAChOԂł̓J[\L[Ń}EX|C^
   邱ƂłB
(͕ϐ)
 MSEC = AChOԂ̏i~bPʁjB0 ܂͕̒lw肷 5 
        ɐݒ肳B
(o͕ϐ)
  IRTN  = AChOoߎԁi~bPʁj
  ICH > 0: ꂽL[̕R[h(ASCII)
      = 0: AChOԂ̏ɒBꍇ
       -1: }EX̍{^ꂽꍇ
       -2: }EX̉E{^ꂽꍇ
    X = }EXE|C^ X W([hWn)
    Y = }EXE|C^ Y W([hWn)

[TOC] [INDEX]

112. AChO 2
-----------------------------------------------------------------------------
[F] SUBROUTINE GWIDLE2(IRTN, ICH, X, Y, MSEC)
    INTEGER IRTN, ICH, MSEC
    REAL X, Y

[C] int GWidle2(int *ICH, float *X, float *y, int MSEC);
-----------------------------------------------------------------------------
()
   ̓p[^ MSEC ɂCAChOԂ̏vɂ鎞
   (GWSLEEP2 Q) Ŏw肷_ƁCIRTN ɕԂloߎԂł͂ȂC[^[
   ̓v̎ł_ GWIDLE ƓBv̏ 
   GWSLEEP2 ōsƂłB

[TOC] [INDEX]

113. X[v
-----------------------------------------------------------------------------
[F] SUBROUTINE GWSLEEP(IRTN, MS)
    INTEGER IRTN, MS

[C] int GWsleep(int MS);
-----------------------------------------------------------------------------
()
    ~ (1/1000) bPʂŎs~B
(͕ϐ)
   MS = s~鎞(~bP)
(o͕ϐ)
  IRTN = ^[ER[h

[TOC] [INDEX]

114. X[v 2
-----------------------------------------------------------------------------
[F] SUBROUTINE GWSLEEP2(IRTN, MS)
    INTEGER IRTN, MS

[C] int GWsleep2(int MS);
-----------------------------------------------------------------------------
()
    w肵ɒB܂Ŏs~B ( > 0, ~bP) ̌v͊e
    EBhEƂɗpӂꂽvɂčsB͕ϐ MS  0 ܂
    ̐lw肵ꍇɂ́Cv̎ |MS| ɏCɐ
    ߂ (s~Ȃ)B܂CMS Ɍ݂̓v̎O̎ 
    ( > 0) w肳ꂽꍇɂɐ䂪߂Bv̓EBhẼI[
    v 0 ɏBv̎ GWCTIME Ŏ擾łB
(͕ϐ)
     MS > 0: sĊJ̗\莞 (~bP)
       <= 0: v |MS| ̒lɏ
(o͕ϐ)
  IRTN = Ăяo̓v̎ (~bP)

[TOC] [INDEX]

115. ݎ̎擾
-----------------------------------------------------------------------------
[F] SUBROUTINE GWCTIME(IRTN)
    INTEGER IRTN

[C] int GWctime(void);
-----------------------------------------------------------------------------
()
    EBhEƂɗpӂꂽv̌ݎ (~bP) 擾B
(͕ϐ)
     Ȃ
(o͕ϐ)
  IRTN = ݎ (~bP)

[TOC] [INDEX]

116. |[Y
-----------------------------------------------------------------------------
[F] SUBROUTINE GWPAUSE(IRTN, TXT)
    INTEGER IRTN
    CHARACTER TXT*(*)

[C] int GWpause(char *TXT);
-----------------------------------------------------------------------------
()
    bZ[W{bNX\C{^܂ő҂B
(͕ϐ)
   TXT = bZ[W̕
(o͕ϐ)
  IRTN = ^[ER[h

[TOC] [INDEX]

117. eTCY̎擾/ݒ
-----------------------------------------------------------------------------
[F] SUBROUTINE GWSIZE(IRTN, N, IW, IH)
    INTEGER IRTN, N, IX, IY

[C] int GWsize(int N, int *IW, int *IH);
-----------------------------------------------------------------------------
()
    eTCYʒu̎擾^ݒsBCN > 0 ̏ꍇ͎擾CN < 0 ̏
    ͐ݒsBĈڂ͕ύXłȂBt[ETCY
    ݒ莞 IW = IH = 0 w肷ƌ݂̃EBhEɃt[tBbg
    Beʒu͎w肵EBhE̍́CΉeEBhE̍
    ΍WBʃTCŶ݂́CGWOPEN(X)  GWINIT(X) ̌Ăяoɂ
    {CȕOɂ擾łB
(͕ϐ)
  |N| = 1: upvTCY (sNZ)
       *2:  ʃTCY (sNZ)
        3:  t[(g)ETCY (sNZ)
        4:  t[(g)ʒu (sNZ) / ʓ
        5:  EBhEir[jETCY (sNZ)
        6:  EBhEir[jʒu (sNZ) / t[
        7:  r[|[gETCY (sNZ)
        8:  r[|[gʒu (sNZ) / r[
        9:  ftHǵupvTCY (sNZ)
       10:  Ȃǂɉ肳𑜓x (DPI)
       11:  ̃}[W (0.1 mm P)
      *12:  v^̗pTCY (0.1 mm P)
      *13:  v^̉𑜓x (DPI)
     > 13:  `
(͕ϐ: N < 0 ̏ꍇ)
    IW = 
    IH = 
(o͕ϐ: N > 0 ̏ꍇ)
    IW = 
    IH = 
  IRTN = ^[ER[h

[TOC] [INDEX]

118. AXyNg̎擾
-----------------------------------------------------------------------------
[F] REAL FUNCTION GWASPECT(N)

[C] float GWaspect(int N);
-----------------------------------------------------------------------------
()
   eAXyNg擾BႦ, [rbg}bv] ܂ [I]̃r[E
   [hŐ^~`ɂ́C, AR = GWASPECT(-1) ƂƁCc([h
   Wn) 1:AR ̑ȉ~`ΗǂB
(͕ϐ)
    N = AXyNg̎
(o͕ϐ)
  Ȃ
(Ԃl)
    N = 1:  ݒ肳ĂupvTCỸAXyNg
        2:  EBhEETCỸAXyNg
        3:  t[(g)ETCỸAXyNg
        4:  ʃTCỸAXyNg
        5:  v^̉𑜓x(DPI)̃AXyNg
        6:  v^̗pTCỸAXyNg
        7:  ݂̃r[|[gETCY(sNZl)̃AXyNg
   ̑:  ^~(␳`)`߂̃AXyNg
   ܂́CG[ER[h ( <= 0 )

[TOC] [INDEX]

119. _̍ől
-----------------------------------------------------------------------------
[F] REAL FUNCTION GWFMAX()

[C] float GWfmax(void);
-----------------------------------------------------------------------------
()
   _̍őlԂB
(͕ϐ)
    Ȃ
(o͕ϐ)
    Ȃ
(Ԃl)
    _̍ől

[TOC] [INDEX]

120. o[Wԍ̎擾
-----------------------------------------------------------------------------
[F] SUBROUTINE GWVERSION(IRTN,IS,STR)
    INTEGER IRTN, IS
    CHARACTER STR*(*)

[C] int GWversion(int IS, char *STR, int l);
-----------------------------------------------------------------------------
()
   CuEt@Cɖߍ܂Ăo[WԍȂǂ̕擾B
   ̃[`͖{CȕOɂĂяoD
(͕ϐ)
   IS = ̎
        0: 擾\ȕ̌𕶎 STR ɕԂD
        1: J}(',')ŋ؂ꂽo[WԍDꂼꐔl傫قǁC
           o[WVƂ\D
        2: K grwnd.exe ̃o[Wԍ
        3: 쐬
        4: 쌠\
        5: rhԍ
     l = ()ϐ STR ̒
(o͕ϐ)
  IRTN > 擾\ȕ̌i݂̔łł 5 j
       = 0: Ȕԍw肳ꂽƂ
       = - (擾悤Ƃ̒) < 0: ŝƂ
   STR = 擾

[TOC] [INDEX]

121. R\[EL[{[h
-----------------------------------------------------------------------------
[F] INTEGER FUNCTION KBHIT()

[C] int kbhit(void);
-----------------------------------------------------------------------------
()
   R\[ʂŉĂL[̃R[hԂBĂȂ 0 
   ԂBgwkybrd QƁB
(͕ϐ)
   Ȃ
(o͕ϐ)
   Ȃ
(߂l)
   L[ER[hiL[ĂȂ 0j

[TOC] [INDEX]

122. R\[ł̃L[ER[h̎擾
-----------------------------------------------------------------------------
[F] INTEGER FUNCTION KBGETCH(N)
    INTEGER N

[C] int kbgetch(int N);
-----------------------------------------------------------------------------
()
   R\[1oCg̃L[ER[h擾BL[ĂȂΉ
   ܂ő҂B Iɂ C  getch() ܂ getche() ĂяoĂB
(͕ϐ)
   N  = 0: GR[Ȃ
     <> 0: GR[
(o͕ϐ)
   Ȃ
(߂l)
   擾L[ER[h

[TOC] [INDEX]

123. ^[gF
-----------------------------------------------------------------------------
[F] SUBROUTINE GWTSPAWN(IRTN, IT, IS, M)
    INTEGER IRTN, IT, IS, M

[C] int GWTspawn(int IT, int IS, int M);
-----------------------------------------------------------------------------
()
   ^[gEOtBNX̂߂̃^[g(T)𐶐B^[gƂ̋O
   Ղ`悳B`IuWFNgƂẮCyC}[NCLCrbg}bvC
   R{̉ꂩgpłB^[g͉Cł邱ƂłCe^[g
   ͂̔ԍ (IT)C`IuWFNg̎ (IS)CсC݂̈ʒuƐis
   ƂĎBIT > 0 ̏ꍇɂ́Cw肳ꂽԍ IT ̃^[g𐶐B
   łɎw肳ꂽԍ̃^[g݂ꍇɂ͉ȂBIT = 0 ̏ꍇ
   gĂȂ^[gԍgpB`IuWFNg̎ʂ͓͕ϐ IS 
   w肷B͕ϐ M ̈Ӗ IS ɂقȂB`IuWFNgyC}[
   NCL̉ꂩ̏ꍇɂ́CftHgł̘_FԍC'(^[gԍ) 
   mod 18 + 1'ɐݒ肳BɐꍇCIRTN ɂ͎ۂɐ^[g
   ̔ԍԂC݂̃^[gԍɎۂɐ^[g̔ԍݒ肷B
   IS < 0 ̏ꍇ͕`IuWFNgƂČ݂̃y (GWSETPEN Q) ݒ肳
   Bɂ́C݂̈ʒuƂČ݂̃yʒu (GWLINE2 Q) ݒ肳C
   is͉Eɐݒ肳B
(͕ϐ)
   IT = ^[gԍ
   IS = `IuWFNg̎ (M ̈Ӗ)
      = 1: y (y̘_Fԍ)
      = 2: }[N (}[N̘_Fԍ)
      = 3:* L (L̘_Fԍ)
      = 4:* rbg}bv (rbg}bvԍ)
      = 5:* R{ (R{ԍ)

     iF* ͖T|[gj
(o͕ϐ)
 IRTN = ۂɐ^[g̔ԍ ( > 0 ), ŝƂ 0

[TOC] [INDEX]

124. ^[gFis̕ύX
-----------------------------------------------------------------------------
[F] SUBROUTINE GWTTURN(IRTN, IT, DA)
    INTEGER IRTN, IT
    REAL DA

[F] SUBROUTINE GWDTTURN(IRTN, IT, DA)
    INTEGER IRTN, IT
    REAL*8 DA

[C] int GWTturn(int IT, float DA);

[C] int GWDTturn(int IT, double DA);
-----------------------------------------------------------------------------
()
   ^[gԍ IT > 0 ̃^[ǧ݂̐is DA ωB
(͕ϐ)
   IT = ^[gԍ ( > 0 )
   DA = ^[ǧ̕ω (x 甽vɑpx()/360)
(o͕ϐ)
 IRTN > 0F ύXꂽꍇ ( ^[gԍ )
      = 0F sC܂͑ύXȂꍇ

[TOC] [INDEX]

125. ^[gFOi
-----------------------------------------------------------------------------
[F] SUBROUTINE GWTFORWARD(IRTN, IT, D)
    INTEGER IRTN, IT
    REAL D

[F] SUBROUTINE GWDTFORWARD(IRTN, IT, D)
    INTEGER IRTN, IT
    REAL*8 D

[C] int GWTforward(int IT, float D);

[C] int GWDTforward(int IT, double D);
-----------------------------------------------------------------------------
()
   ^[gԍ |IT| ̃^[g݈ʒu猻݂̐is֋ |D|i[h
   WnjړCIT > 0 ̏ꍇ͒`悷BD < 0 ̏ꍇɂ݂͌̐is
   ƋtɐiށB݈ʒu (x, y)Cis A (px/360) ƂƂCI_
   ̍W
 
     (x + D*cos(2*pi*A), y + D*sin(2*pi*A)) 
 
   ŎZo ( pi ͉~ )BāC[hWn ( GWINDOW Q ) 
   Iɐݒ肳ĂȂꍇɂ́Cʏ̐is̊px A Ŏw肵̂
   قȂĂ܂̂ŗvӁB
(͕ϐ)
 |IT| = ^[gԍ
  |D| = ^[g̈ړ ( [hWn ) 
(o͕ϐ)
 IRTN > 0F  ( ^[gԍ )
      = 0F s

[TOC] [INDEX]

126. ^[gFΈړ
-----------------------------------------------------------------------------
[F] SUBROUTINE GWTSHIFT(IRTN, IT, DX, DY)
    INTEGER IRTN, IT
    REAL DX, DY

[F] SUBROUTINE GWDTSHIFT(IRTN, IT, DX, DY)
    INTEGER IRTN, IT
    REAL*8 DX, DY

[C] int GWTshift(int IT, float DX, float DY);

[C] int GWDTshift(int IT, double DX, double DY);
-----------------------------------------------------------------------------
()
   ^[gԍ |IT| ̃^[g݈ʒu x  DXCy  DY ړ
   iψʁjCIT > 0 ̏ꍇ͒`悷B
(͕ϐ)
 |IT| = ^[gԍ
   DX = ψʂ X ([hWn)
   DY = ψʂ Y ([hWn)
(o͕ϐ)
 IRTN > 0F  ( ^[gԍ )
      = 0F s

[TOC] [INDEX]

127. ^[gFw_ւ̈ړ
-----------------------------------------------------------------------------
[F] SUBROUTINE GWTMOVE2(IRTN, IT, X, Y)
    INTEGER IRTN, IT
    REAL X, Y

[F] SUBROUTINE GWDTMOVE2(IRTN, IT, X, Y)
    INTEGER IRTN, IT
    REAL*8 X, Y

[C] int GWTmove2(int IT, float X, float Y);

[C] int GWDTmove2(int IT, double X, double Y);
-----------------------------------------------------------------------------
()
   ^[gԍ |IT| ̃^[g݈ʒu_ (X, Y) ֈړCIT > 0 ̏ꍇ
   ͒`悷B
(͕ϐ)
 |IT| = ^[gԍ
    X = I_ X W([hWn)
    Y = I_ Y W([hWn)
(o͕ϐ)
 IRTN > 0F  ( ^[gԍ )
      = 0F s

[TOC] [INDEX]

128. ^[g𕡐
-----------------------------------------------------------------------------
[F] SUBROUTINE GWTCLONE(IRTN, IT1, IT2)
    INTEGER IRTN, IT1, IT2

[C] int GWTclone(int IT1, int IT2);
-----------------------------------------------------------------------------
()
   ^[gԍ IT1 > 0 ̃^[g^[gԍ IT2 ɃRs[()B
   ԍ IT1 ̃^[g݂ȂCԍ IT2 ̃^[gɑ݂ꍇɂ
   sCȂBIT2 = 0 w肵ꍇɂ͋󂢂Ă^[gԍgB
   ꍇɂ́C݂̃^[gԍRs[̃^[gԍɐݒ肷B
(͕ϐ)
   IT1 = Rs[̃^[gԍ ( > 0 )
   IT2 = Rs[̃^[gԍ ( >= 0 ) 
(o͕ϐ)
 IRTN = ꂽ^[g̔ԍ ( > 0 ), ŝƂ 0

[TOC] [INDEX]

129. ^[g菜
-----------------------------------------------------------------------------
[F] SUBROUTINE GWTREMOVE(IRTN, IT)
    INTEGER IRTN, IT

[C] int GWTremove(int IT);
-----------------------------------------------------------------------------
()
   ^[gԍ IT > 0 ̃^[g菜Bw肳ꂽԍ̃^[g݂
   ꍇɂ͉ȂB
(͕ϐ)
   IT = ^[gԍ
(o͕ϐ)
 IRTN = 菜^[g̔ԍ ( > 0 ), ŝƂ 0

[TOC] [INDEX]

130. ^[gʒuݒ
-----------------------------------------------------------------------------
[F] SUBROUTINE GWTSETPOS(IRTN, IT, X, Y)
    INTEGER IRTN, IT
    REAL X, Y

[F] SUBROUTINE GWDTSETPOS(IRTN, IT, X, Y)
    INTEGER IRTN, IT
    REAL*8 X, Y

[C] int GWTsetpos(int IT, float X, float Y);

[C] int GWDTsetpos(int IT, double X, double Y);
-----------------------------------------------------------------------------
()
   ^[gԍ IT > 0 ̃^[g̈ʒuݒ肷B̂Ƃ`͍sȂB
(͕ϐ)
   IT = ^[gԍ ( > 0 )
    X = ^[gʒu X W([hWn)
    Y = ^[gʒu Y W([hWn)
(o͕ϐ)
 IRTN > 0F i ^[gԍ )
      = 0F s

[TOC] [INDEX]

131. ^[gʒu̎擾
-----------------------------------------------------------------------------
[F] SUBROUTINE GWTGETPOS(IRTN, IT, X, Y)
    INTEGER IRTN, IT
    REAL X, Y

[F] SUBROUTINE GWDTGETPOS(IRTN, IT, X, Y)
    INTEGER IRTN, IT
    REAL*8 X, Y

[C] int GWTgetpos(int IT, float *X, float *Y);

[C] int GWDTgetpos(int IT, double *X, double *Y);
-----------------------------------------------------------------------------
()
   ^[gԍ IT > 0 ̃^[ǧ݂̈ʒu[hWnŕԂB
(͕ϐ)
   IT = ^[gԍ ( > 0 )
(o͕ϐ)
    X = ^[gʒu X W([hWn)
    Y = ^[gʒu Y W([hWn)
 IRTN > 0F i ^[gԍ )
      = 0F s

[TOC] [INDEX]

132. ^[gFis̐ݒ
-----------------------------------------------------------------------------
[F] SUBROUTINE GWTSETDIR(IRTN, IT, A)
    INTEGER IRTN, IT
    REAL A

[F] SUBROUTINE GWDTSETDIR(IRTN, IT, A)
    INTEGER IRTN, IT
    REAL*8 A

[C] int GWTsetdir(int IT, float A);

[C] int GWDTsetdir(int IT, double A);
-----------------------------------------------------------------------------
()
   ^[gԍ IT > 0 ̃^[g̐isݒ肷B
(͕ϐ)
   IT = ^[gԍ ( > 0 )
    A = ^[g̐is (x 甽vɑp/360)
        |A| >= 1.0 ̏ꍇ݂͌̒lg
(o͕ϐ)
 IRTN > 0F ύXꂽꍇ ( ^[gԍ )
      = 0F sC܂͑ύXȂꍇ

[TOC] [INDEX]

133. ^[gFis̎擾
-----------------------------------------------------------------------------
[F] SUBROUTINE GWTGETDIR(IRTN, IT, A)
    INTEGER IRTN, IT
    REAL A

[F] SUBROUTINE GWDTGETDIR(IRTN, IT, A)
    INTEGER IRTN, IT
    REAL*8 A

[C] int GWTgetdir(int IT, float *A);

[C] int GWDTgetdir(int IT, double *A);
-----------------------------------------------------------------------------
()
   ^[gԍ IT > 0 ̃^[ǧ݂̐is擾B
(͕ϐ)
   IT = ^[gԍ ( > 0 )
(o͕ϐ)
    A = ^[ǧ (x 甽vɑp/360)
 IRTN > 0F ύXꂽꍇ ( ^[gԍ )
      = 0F sC܂͑ύXȂꍇ

[TOC] [INDEX]

134. ^[gFF̐ݒ
-----------------------------------------------------------------------------
[F] SUBROUTINE GWTSETCOL(IRTN, IT, IPC)
    INTEGER IRTN, IT, IPC

[C] int GWTsetcol(int IT, int IPC);
-----------------------------------------------------------------------------
()
   ^[gԍ IT > 0 ̃^[g̐Fݒ肷B
(͕ϐ)
   IT = ^[gԍ ( > 0 )
  IPC = _Fԍ (GWCOLOR Q)
(o͕ϐ)
 IRTN > 0F ύXꂽꍇ ( ^[gԍ )
      = 0F sC܂͑ύXȂꍇ

[TOC] [INDEX]

135. ^[gFF̎擾
-----------------------------------------------------------------------------
[F] SUBROUTINE GWTGETCOL(IPC, IT)
    INTEGER IPC, IT

[C] int GWTgetcol(int IT);
-----------------------------------------------------------------------------
()
   ^[gԍ IT > 0 ̃^[g̐F擾B
(͕ϐ)
   IT = ^[gԍ ( > 0 )
(o͕ϐ)
  IPC <> -1F _Fԍ (GWCOLOR Q)
       = -1F s

[TOC] [INDEX]

136. ^[gFy̐ݒ
-----------------------------------------------------------------------------
[F] SUBROUTINE GWTSETPEN(IRTN, IT, IPC, IPS, IPW)
    INTEGER IRTN, IT, IPC, IPS, IPW

[C] int GWTsetpen(int IT, int IPC, int IPS, int IPW);
-----------------------------------------------------------------------------
()
   ^[gԍ IT > 0 ̃^[g̃yݒ肷B
(͕ϐ)
   IT = ^[gԍ ( > 0 )
  IPC = _Fԍ (GWCOLOR Q)
  IPS =  (GWCOLOR Q)
  IPW =  (GWCOLOR Q)
(o͕ϐ)
 IRTN > 0F ύXꂽꍇ ( ^[gԍ )
      = 0F sC܂͑ύXȂꍇ

[TOC] [INDEX]

137. ^[gF}[Nݒ
-----------------------------------------------------------------------------
[F] SUBROUTINE GWTSETMRK(IRTN, IT, MT, S, K, KS, KB, MX)
    INTEGER IRTN, IT, MT, K, KS, KB, MX
    REAL S

[F] SUBROUTINE GWDTSETMRK(IRTN, IT, MT, S, K, KS, KB, MX)
    INTEGER IRTN, IT, MT, K, KS, KB, MX
    REAL*8 S

[C] int GWTsetmrk(int IT, int MT, float S, int K, int KS, int KB, int MX);

[C] int GWDTsetmrk(int IT, int MT, double S, int K, int KS, int KB, int MX);
-----------------------------------------------------------------------------
()
   }[Nԍ MT(0-6)C傫 S([hWn)C}[N̘_Fԍ KC}[N
   wiF̘_Fԍ KBC[h MX w肷B MX > 15 ̏ꍇ (MX-16) 
   ̒l̂܂ "binary raster-operation code[W]" ƂĎgpBK, KB 
   āC̓p[^̒lłΑΉ鑮͕ύXȂBMT  0 
   ꍇ́C傫 SisNZj̓_w肳C̏ꍇC`悳}[N
   傫̓r[i\j[hɉeȂB
(͕ϐ)
   IT = ^[gԍ ( > 0 )
   MT = 0: _
        1: 
        2: {
        3: ~
        4: {Ɓ~d˂킹
        5: 
        6: 
        ̑:  ύXȂ
    S = hbg̑傫(sNZl)
      = }[N̍([hWn) > 0.0
    K = }[Niyj̘_Fԍ(GWCOLOR ̍Q)
        -1 ̏ꍇ͌ݒlg
   KS = }[NiuVj̘_Fԍ(GWCOLOR ̍Q)
        -1 ̏ꍇ͌ݒlg
   KB = }[N̔wiF̘_Fԍ(GWCOLOR ̍Q)
        -1 ̏ꍇ͌ݒlg
      = -100: (default)
   MX = }[N̍[h( GWSETPEN ̍Q)
(o͕ϐ)
 IRTN = ^[ER[h

[TOC] [INDEX]

138. (Calcomp nR}h)
-----------------------------------------------------------------------------
[F] SUBROUTINE PLOTS(X, Y, LD)

[C] Ȃ
-----------------------------------------------------------------------------
()
   GrWin Cȕ̌COtBNXEEBhEI[vB

      mQln CALL GWOPEN(NW,0)
(͕ϐ)
    X = y̏ʒu X W([hWn)
    Y = y̏ʒu Y W([hWn)
   LD = ݊̂߂̃_~[
(o͕ϐ)
  Ȃ

[TOC] [INDEX]

139. I(Calcomp nR}h)
-----------------------------------------------------------------------------
[F] SUBROUTINE PLOTE(MQ)

[C] Ȃ
-----------------------------------------------------------------------------
()
      JĂSẴEBhECGrWin CȕIsB

      mQln CALL GWQUIT
(͕ϐ)
   MQ = 0 :   R\[EEBhEɏIvvg '>' \B
        1 :   I_CAO\B
        :   IvvgoɒɏIsB
(o͕ϐ)
  Ȃ

[TOC] [INDEX]

140. ÿړ/̕`(Calcomp nR}h)
-----------------------------------------------------------------------------
[F] SUBROUTINE PLOT(X, Y, IP)
    REAL X, Y
    INTEGER IP

[C] Ȃ
-----------------------------------------------------------------------------
()
    [hWnŎw肳ꂽ_ (X, Y) ܂ŃyړB

    mQln CALL GWLINE2(X, Y)
             CALL GWMOVE2(X, Y)
(͕ϐ)
    X = ړ̃yʒu X W([hWn)
    Y = ړ̃yʒu Y W([hWn)
   IP = }2: y܂܈ړB܂蒼`B
        }3: yグ܂܈ړB܂艽`ȂB
        999: Is(PLOTE Ɠ)B
      <   0: [hWn𕽍sړāCړ̓_VɍW_ɂB
(o͕ϐ)
  Ȃ

[TOC] [INDEX]

141. [hWn̐ݒ(Calcomp nR}h)
-----------------------------------------------------------------------------
[F] SUBROUTINE WINDOW(XL, YT, XR, YB)
    REAL XL, YT, XR, YB

[C] Ȃ
-----------------------------------------------------------------------------
()
   ʂ̍ӂ x WCӂ y WCEӂ x WCӂ y W[h
   Wŗ^邱Ƃɂ胏[hWnݒ肷B GWINDOW Ƃ͈̕т̏
   Ⴄ̂ŒӁB

    mQln CALL GWINDOW(XL, YB, XR, YT)
(͕ϐ)
    XL = ӂ x W([hWn)
    YT = ӂ y W([hWn)
    XR = Eӂ x W([hWn)
    YB = ӂ y W([hWn)
(o͕ϐ)
  Ȃ

[TOC] [INDEX]

142. y̐F(Calcomp nR}h)
-----------------------------------------------------------------------------
[F] SUBROUTINE NEWPEN(IPC)
    INTEGER IPC

[C] Ȃ
-----------------------------------------------------------------------------
()
    y̘_Fԍݒ肷B

    mQln GWSETPEN(IPC, -1, -1, -1)
(͕ϐ)
  IPC = _Fԍ
         -1 ̏ꍇ͕ύXȂ
         ̑̏ꍇɂĂ GWCOLOR ̍QƁB
(o͕ϐ)
  Ȃ

[TOC] [INDEX]

143. ̕\(Calcomp nR}h)
-----------------------------------------------------------------------------
[F] SUBROUTINE SYMBOL(X, Y, H, TXT, A, NC)
    REAL X, Y, H, A
    CHARACTER TXT*(*)
    INTEGER NC

[C] Ȃ
-----------------------------------------------------------------------------
()
    [hWnŎw肳ꂽ_ (X, Y) ɕ\B

    mQln CALL GWSETTXT(H, A, -1, -1, -1, ' ')
             CALL GWPUTTXT(X, Y, TXT)
(͕ϐ)
    X = ŏ̍̓̕_ X W([hWn)
    Y = ŏ̍̓̕_ Y W([hWn)
    H = tHg̍([hWn)
         0 ̏ꍇ̓ftH[glg
         ̏ꍇ݂͌̒lg
  TXT = \镶
    A = tHǧXp(degCv)
   NC = ̒B 0 ܂͕̏ꍇ TXT ׂ̂Ă̕\B
(o͕ϐ)
  Ȃ

[TOC] [INDEX]

144. l̕\(Calcomp nR}h)
-----------------------------------------------------------------------------
[F] SUBROUTINE NUMBER(X, Y, H, D, A, ND)
    REAL X, Y, H, D, A
    INTEGER ND

[C] Ȃ
-----------------------------------------------------------------------------
()
    [hWnŎw肳ꂽ_ (X, Y) ɐ\Bϊ@włB

    mQln WRITE(TXT, *) N
             CALL GWSETTXT(H, A, -1, -1, -1, ' ')
             CALL GWPUTTXT(X, Y, TXT)
(͕ϐ)
    X = ŏ̍̓̕_ X W([hWn)
    Y = ŏ̍̓̕_ Y W([hWn)
    H = tHg̍([hWn)
         0 ̏ꍇ̓ftH[glg
         ̏ꍇ݂͌̒lg
    D = \鐔l
    A = tHǧXp(degCv)
   ND >  0: _̌
      =  0: Ə_\
      = -1: ̂ݕ\
      < -1: ̏ |ND| ̂ݕ\
(o͕ϐ)
  Ȃ

[TOC] [INDEX]

145. OtBNXʏ(Calcomp nR}h)
-----------------------------------------------------------------------------
[F] SUBROUTINE GCLS(IDMY)

[C] Ȃ
-----------------------------------------------------------------------------
()
   OtBNXʂB
(͕ϐ)
   IDMY ͌݊̂߂̃_~[ϐB
(o͕ϐ)
  Ȃ

[TOC] [INDEX]



Fortran     C           @ \                                           #
gcls        Ȃ        OtBNXʏ(Calcomp nR}h)        145.  
gwanchor    GWanchor    AJ[                                        100.  
gwarc       GWarc       ʂ̕`                                        44.  
gwarrange   GWarrange   EBhE̔zu                                20.  
gwaspect*   GWaspect    AXyNg̎擾                              118.  
gwbegincmb  GWbegincmb  R{̍쐬Jn                                88.  
gwbezier    GWbezier    xWG XvC̕`                         50.  
gwcapimg    GWcapimg    `̈̎荞                              83.  
gwcaplin    GWcaplin    }EXɂW̎擾                      72.  
gwcappnt    GWcappnt    }EXɂ_W̎擾                        70.  
gwcaprect   GWcaprect   }EXɂ`W̎擾                      73.  
gwcapvec    GWcapvec    }EXɂxNg̎擾                      71.  
gwchord     GWchord     ʂ̕`                                  45.  
gwclear     GWclear     EBhEʂ̏                            52.  
gwclipimg   GWclipimg   `̈̃Nbv{[hւ̃Rs[              84.  
gwclose     GWclose     EBhẼN[Y                             7.  
gwcmbmrk    GWcmbmrk    }[NR{Ƃč쐬                        87.  
gwcolor     GWcolor     F̐ݒ                                        61.  
gwcopybmp   GWcopybmp   ۑrbg}bṽRs[o^                    81.  
gwcopycmb   GWcopycmb   ۑR{̃Rs[o^                          92.  
gwctime     GWctime     ݎ̎擾                                  115.  
gwdelbmp    GWdelbmp    rbg}bv̓o^폜                          82.  
gwdelcmb    GWdelcmb    R{̓o^폜                                93.  
gwdtforward GWDTforward ^[gFOi                                  125.  
gwdtforward GWTforward  ^[gFOi                                  125.  
gwdtgetdir  GWDTgetdir  ^[gFis̎擾                        133.  
gwdtgetdir  GWTgetdir   ^[gFis̎擾                        133.  
gwdtgetpos  GWDTgetpos  ^[gʒu̎擾                              131.  
gwdtgetpos  GWTgetpos   ^[gʒu̎擾                              131.  
gwdtmove2   GWDTmove2   ^[gFw_ւ̈ړ                        127.  
gwdtmove2   GWTmove2    ^[gFw_ւ̈ړ                        127.  
gwdtsetdir  GWDTsetdir  ^[gFis̐ݒ                        132.  
gwdtsetdir  GWTsetdir   ^[gFis̐ݒ                        132.  
gwdtsetmrk  GWDTsetmrk  ^[gF}[Nݒ                            137.  
gwdtsetmrk  GWTsetmrk   ^[gF}[Nݒ                            137.  
gwdtsetpos  GWDTsetpos  ^[gʒuݒ                                130.  
gwdtsetpos  GWTsetpos   ^[gʒuݒ                                130.  
gwdtshift   GWDTshift   ^[gFΈړ                              126.  
gwdtshift   GWTshift    ^[gFΈړ                              126.  
gwdtturn    GWDTturn    ^[gFis̕ύX                        124.  
gwdtturn    GWTturn     ^[gFis̕ύX                        124.  
gwellipse   GWellipse   ȉ~̕`                                      43.  
gwendcmb    GWendcmb    R{̍쐬I                                89.  
gwerase     GWerase     }`̏                                      102.  
gwevent     GWevent     CxgԂ̎擾                              110.  
gwfiledlg   GWfiledlg   _CAO{bNXɂt@C̎擾        95.  
gwfirst     GWfirst     ŏ̃EBhE                                15.  
gwflood     GWflood     ̈̓hԂ                              51.  
gwflush     GWflush     tbV`                                  103.  
gwfmax*     GWfmax      _̍ől                            119.  
gwfnt2bmp   GWfnt2bmp   tHgrbg}bvւ̕ϊ                77.  
gwgetbmp    GWgetbmp    rbg}bv̑擾                          79.  
gwgetbrs    GWgetbrs    uV̎擾                                27.  
gwgetcmb    GWgetcmb    R{̑擾                                91.  
gwgetmrk    GWgetmrk    }[N̎擾                                55.  
gwgetpen    GWgetpen    y̎擾                                  25.  
gwgetpos    GWgetpos    yʒu                                        36.  
gwgetpxl    GWgetpxl    sNZ̘_Fԍ̎擾                      60.  
gwgetrgb    GWgetrgb    _FԍRGB(OF)ɕϊ                   62.  
gwgetsym    GWgetsym    L̃TCY擾                                32.  
gwgettxt    GWgettxt    TCY̎擾                              29.  
gwgetvp     GWgetvp     r[|[g̎擾                              12.  
gwgetwn     GWgetwn     [hWn̎擾                             9.  
gwgetxfrm   GWgetxfrm   ϊs̎擾                                  57.  
gwidle2     GWidle2     AChO 2                                  112.  
gwidle      GWidle      AChO                                    111.  
gwindow     GWindow     [hWn̐ݒ                             8.  
gwinit      GWinit                                                 1.  
gwinitx     GWinitx                                                1.  
gwinput     GWinput     ̓                                    94.  
gwjoin      GWjoin      WCiǉ`̊Jnj                       5.  
gwkybrd     GWkybrd     L[{[hEXe[^X                          107.  
gwldcpos    GWldcpos    _foCXWnł̈ʒuW̎擾            21.  
gwldcsiz    GWldcsiz    _foCXWnł̃TCY̎擾              22.  
gwleave     GWleave     EBhEȂŏI                       4.  
gwline2     GWline2     w肵_܂ł̒                            38.  
gwline      GWline      Q_Ԓ                                  39.  
gwload      GWload      f[^̓ǂݍ                                96.  
gwloadbmp   GWloadbmp   rbg}bvt@C̓ǂݍ                  74.  
gwloadcc    GWloadcc    JX^J[̕                            68.  
gwloadcmb   GWloadcmb   R{Et@C̓ǂݍ                      85.  
gwmakebmp   GWmakebmp   rbg}bv̍쐬                              76.  
gwmode      GWmode      [hݒƖ₢킹                          106.  
gwmouse     GWmouse     }EX                                          108.  
gwmove2     GWmove2     ÿړ                                      37.  
gwncolor    GWncolor    p\ȐFpbg̎擾                    66.  
gwnext      GWnext      ̃EBhE                                  16.  
gwopen      GWopen      EBhẼI[v                             2.  
gwopenx     GWopenx     EBhẼI[v                             2.  
gwpause     GWpause     |[Y                                          116.  
gwpie       GWpie       `̕`                                      46.  
gwplot1     GWplot1     1z̃vbg                             47.  
gwpolygon   GWpolygon   p`̕`                                    48.  
gwpolylin   GWpolylin   ܂̕`                                    49.  
gwport      GWport      r[|[g̐ݒ([hWn)              11.  
gwprint     GWprint                                                 98.  
gwputbmp    GWputbmp    rbg}bv̕`                              80.  
gwputcmb    GWputcmb    R{̕`                                    90.  
gwputmrk    GWputmrk    }[N`                                      54.  
gwputsym    GWputsym    L̏o                                      33.  
gwputtxt    GWputtxt    (eLXg)̕`                          30.  
gwpxlsiz    GWpxlsiz    sNZETCY̎擾                          23.  
gwquit      GWquit      I                                             3.  
gwquitx     GWquitx     I                                             3.  
gwrect      GWrect      lp`̕`                                    40.  
gwrefresh   GWrefresh   ʂ̍ĕ`                                    104.  
gwreset     GWreset     p[^̍ď                             6.  
gwrrect     GWrrect     p̊ۂlp`̕`                            42.  
gwsaveas    GWsaveas    f[^̕ۑ                                    97.  
gwsavebmp   GWsavebmp   rbg}bvt@C̕ۑ                      75.  
gwsavecc    GWsavecc    JX^J[̕ۑ                            67.  
gwsavecmb   GWsavecmb   R{tBɕۑ                            86.  
gwsavevp    GWsavevp    r[|[g̕ۑ                          13.  
gwselect    GWselect    EBhEI                                17.  
gwselvp     GWselvp     r[|[g̑I                              14.  
gwsetbk     GWsetbk     wi̐ݒ                                      101.  
gwsetbmp    GWsetbmp    rbg}bv̑ݒ                          78.  
gwsetbrs    GWsetbrs    uV̎w                                    26.  
gwsetmrk    GWsetmrk    }[N̎w                                    53.  
gwsetmsg    GWsetmsg    bZ[W̕\                                34.  
gwsetogn    GWsetogn    IuWFNgEO[vԍ̐ݒ                99.  
gwsetpen    GWsetpen    y̎w                                      24.  
gwsetpxl    GWsetpxl    sNZ̐ݒ                                  59.  
gwsetrgn    GWsetrgn    NbsÖ̐ݒ                          58.  
gwsetsym    GWsetsym    LtHg̐ݒ                              31.  
gwsettxt    GWsettxt    eLXgptHg̐ݒ                        28.  
gwsetxfrm   GWsetxfrm   ϊs̐ݒ                                  56.  
gwshowfr    GWshowfr    t[̕\Ԃݒ                        19.  
gwshowwn    GWshowwn    EBhE̕\Ԃݒ                      18.  
gwsize      GWsize      eTCY̎擾/ݒ                           117.  
gwsleep2    GWsleep2    X[v 2                                      114.  
gwsleep     GWsleep     X[v                                        113.  
gwsrect     GWsrect     hԂꂽlp`̕`                      41.  
gwsysclr    GWsysclr    VXeɐݒ肳ĂF̎擾            69.  
gwtclone    GWTclone    ^[g𕡐                              128.  
gwtgetcol   GWTgetcol   ^[gFF̎擾                              135.  
gwtimer     GWtimer     C^[oE^C}[                          109.  
gwtremove   GWTremove   ^[g菜                              129.  
gwtsetcol   GWTsetcol   ^[gFF̐ݒ                              134.  
gwtsetpen   GWTsetpen   ^[gFy̐ݒ                            136.  
gwtspawn    GWTspawn    ^[gF                                  123.  
gwversion   GWversion   o[Wԍ̎擾                            120.  
gwvport     GWvport     r[|[g̐ݒ                              10.  
gwvwmod     GWvwmod     r[[h                                    105.  
ipalette*   GWipalette  Windows pbgԍ_Fԍւ̕ϊ      65.  
kbgetch*    kbgetch     R\[ł̃L[ER[h̎擾                122.  
kbhit*      kbhit       R\[EL[{[h                          121.  
kcolor*     GWkcolor     COLORREF l_Fԍւ̕ϊ          64.  
krgb*       GWkrgb      RGB(OF)_Fԍւ̕ϊ               63.  
msgbox*     GWmsgbox    bZ[W{bNX                              35.  
newpen      Ȃ        y̐F(Calcomp nR}h)                    142.  
number      Ȃ        l̕\(Calcomp nR}h)                  144.  
plot        Ȃ        ÿړ/̕`(Calcomp nR}h)       140.  
plote       Ȃ        I(Calcomp nR}h)                        139.  
plots       Ȃ        (Calcomp nR}h)                      138.  
symbol      Ȃ        ̕\(Calcomp nR}h)                143.  
window      Ȃ        [hWn̐ݒ(Calcomp nR}h)        141.  
-----------------------------------------------------------------------------
ŏIXV 2003/6/28
