./
scan.pro
Routines
result = sl_sysget(flg, val)
result = sl_cvsiz(vsiz)
result = sl_size(area)
result = sl_getsym(str)
result = sl_getlog(str, n)
result = sl_help(data)
result = sl_prompt(str)
result = sl_execute(n, i_rout, in_are, i_ps1, i_ps2, i_ps3, pcur, typ)
result = sl_run(cmd, str, ext, vers, flg)
result = sl_callt(rout, file, p1, p2)
result = sl_calll(rout, file, p1, p2, p3, p4, p5, p6)
result = sl_element(area)
result = sl_sarr(nd, d1, d2, d3, d4)
result = sl_barr(nd, d1, d2, d3, d4)
result = sl_iarr(nd, d1, d2, d3, d4)
result = sl_larr(nd, d1, d2, d3, d4)
result = sl_farr(nd, d1, d2, d3, d4)
result = sl_darr(nd, d1, d2, d3, d4)
result = sl_carr(nd, d1, d2, d3, d4)
result = sl_iotype(str, typ, np, v1, v2, v3, v4)
result = sl_iofind(specif, ext, vers, names)
result = sl_iolun(u)
result = sl_iofree(u)
result = sl_iopenw(u, desc, ext, rec, struc)
result = sl_iopenr(u, desc, struc, frm)
result = sl_iopoint(u, n, rec)
result = sl_iowrt(u, area, vsiz, flg)
result = sl_ioread(u, area, vsiz, flg)
result = sl_ioreads(str, typ, np, v1, v2, v3, v4)
result = sl_ioaccept(str, typ, np, v1, v2, v3, v4)
result = sl_ioclear(dum)
result = sl_iopage(cout, flg)
result = sl_swapint(area, d1, d2, d3, typ)
result = sl_swapvms(area, d1, d2, d3, typ, flag)
result = sl_sqrt(area, dm, sz)
result = sl_abs(are_in, are_out, nl, typ, sz)
result = sl_tang(x)
result = sl_atang(y, x)
result = sl_atangm(are_in, are_out, nl, typ, sz)
result = sl_pfix(x)
result = sl_maxf(area, vsiz, cm)
result = sl_minf(area, vsiz, cm)
result = sl_maxim(area, vsiz, cm, mv)
result = sl_correl(area1, area2, dx, dy, typ)
result = sl_deviat(area, y1, dx, dy, typ)
result = sl_logn(area, vsiz)
result = sl_log1(val, typ)
result = sl_expn(area, vsiz)
result = sl_cos(ah)
result = sl_acos(ah)
result = sl_sin(ah)
result = sl_asin(ah)
result = sl_gfit(x, y, vsiz, par)
result = sl_polycoef(x, y, vsiz, deg)
result = sl_polyval(x, vsiz, coef, deg)
result = sl_surfit(area, vsiz, deg)
result = sl_hist(area, dm, typ, his, mn, mx)
result = sl_redim(area, dx, dy, typ, nx, ny, flg)
result = sl_lis(area, dx, dy, typ, np, fl)
result = sl_media(area, dx, dy, typ, np, x1, y1)
result = sl_robt(area, dx, dy, typ)
result = sl_sobl(area, dx, dy, typ)
result = sl_fft(area, dir, dx, dy, fl)
result = sl_imaginary(are_in, are_out, nl, typ, sz)
result = sl_rotat(area, dx, dy, typ, ang, fl)
result = sl_rotscal(area, vsiz, nf, ang, mag, cx, cy)
result = sl_pogons(erey, vsiz, vl)
result = sl_shadoc(fl, area, xs, ys, ax, ay, az)
result = sl_revs(area, dx, dy, typ, flg)
result = sl_transp(area, dx, dy, typ)
result = sl_scale(area, dx, dy, typ, mn, mx)
result = sl_shift(area, dx, dy, typ, nx, ny)
result = sl_shiff(area, dx, dy, typ, nx, ny)
result = sl_totf(area, dx, dy, typ)
result = sl_fsum(area, dm, siz, areout)
result = sl_tsum(area, dm, s2, areout)
result = sl_index(dm, typ)
result = sl_wait(x)
result = sl_where(area, vsiz, opr, x, areout)
result = sl_str(v, fmat)
result = sl_strf(area, vsiz)
result = sl_sti(c_out, c_in, pos)
result = sl_stx(c_in, pos, len)
result = sl_stp(c_in, c_sub, pos)
result = sl_stbr(c_in, flg)
result = sl_stup(c_in)
result = sl_stdim(c_in, elm)
result = sl_stbyt(str, area)
result = sl_wggetuv(wg, uv)
result = sl_wgsens(wg, flg)
result = sl_wghourglass(dum)
result = sl_wgdel(wg)
result = sl_wgmotion(wd, fl)
sl_wgfocus, wn
result = sl_wgtimer(wd, fl)
result = sl_wgvalid(wg)
result = sl_wgjreg(wg)
scan_event, ev
result = sl_wglux(w, sx, sy, ttl, xp, yp, seq, t_sx, t_sy)
sl_poslider, base, w
result = sl_wghandy(flg)
result = sl_wgshow(wg, flg)
result = sl_wgclear(wg)
result = sl_wgevent(wg, flg)
result = sl_wgaccept(w, lab, typ, nb, m1, m2, m3, m4)
result = sl_tvlamp_base(flg, base_event)
result = sl_tvwmaj(w, vf, vm, rvl, rvm, f_fg, f_vu, spt, f_ax, f_az)
result = sl_tvset(flg, val, v2, v3, v4, v5, v6, v7)
result = sl_tvget(flg, val)
result = sl_x(str)
result = sl_tviokey(wt, nc)
result = sl_tvldcol(red, green, bleue)
result = sl_tvgtcol(red, green, bleue)
result = sl_tvloadct(id, red, green, bleue)
result = sl_tvcur_w(w, gh, inf, fs, sx, sy)
result = sl_tvwis(w, fl)
result = sl_tvshap(fl)
result = sl_tvclear(dummy)
result = sl_tvdelwn(wn)
result = sl_tvfreewn(wn)
result = sl_tvsel(w)
result = sl_tvsels(w)
result = sl_tvtidy(w, flg)
result = sl_tvwake(w)
result = sl_tvlux(w, sx, sy, ttl, op1, op2, op3, op4, op5, op6, op7, op8, x, y, seq)
result = sl_tvimag(area, vsiz, x, y)
result = sl_tvsimag(area, vsiz, x, y)
result = sl_tvmerr(dum)
result = sl_tvwinp(x, y)
result = sl_tvwait(tim, motion, button, wind, rflag, rw)
result = sl_tvgcur(x, y, button, wait)
result = sl_tvmcur(flg, x, y)
result = sl_tvread(x, y, dx, dy)
result = sl_tvpop(w, fl)
result = sl_tvdmenu(wm)
result = sl_tvs(x, y, text, siz, deg, col)
result = sl_tvt(x, y, text, siz, deg, col)
result = sl_tvxyz(xmin, xmax, ymin, ymax)
result = sl_tvscreen(xmin, xmax, ymin, ymax)
result = sl_tvaxis(mn, mx, flg, lab, sz, ttl)
result = sl_tvline(vx, vy, vs, mode, col)
result = sl_tvplt(flg, nx, x, ny, y)
result = sl_tvfill(x0, x, xn, y0, y, yn, col, inc, ang)
result = sl_tvpol(n, vx, vy, colpat, cp)
result = sl_tvdev(dev)
result = sl_tvfont(n)
result = sl_tvclass(n)
result = sl_tvsiz(v2)
result = sl_tvend(dum)
result = sl_tvmod(it, mode)
result = sl_tvmov(int7)
result = sl_tvhdfil(flg, fil, ext, fhd, nocol)
result = sl_tvhdlct(cr, cg, cb)
result = sl_tvhdimg(area, vsiz, fil, ext)
result = sl_tvpix(fx, fy)
result = sl_tvras(x, y, dx, dy, col, bx, by)
result = sl_tvnobut(dum)
result = sl_surfex(p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13)
result = sl_deepex(p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22, p23, p24, p25)
result = sl_surface(area, az, ax, asp, skirt)
result = sl_contour(area, start, endd, lev)
result = sl_tvhdout(fil, ext, fhd)
result = sl_tvscrl(txt, ms_ncol)
result = sl_tvmenub(wwm, flgg, txt, ttl, x, y, seq)
result = sl_tvmenu(wwm, flgg, txt, ttl, x, y)
result = sl_tvmenuc(wwm, flgg, txt, ttl, x, y)
result = sl_tvmenuh(wwm, flgg, txt, ttl, x, y)
result = sl_tvmenui(wwm, flgg, txt, ttl, x, y)
result = sl_tvmenul(wwm, flgg, txt, ttl, x, y)
result = sl_tvmenun(wwm, flgg, txt, ttl, x, y)
result = sl_tvmenunw(wwm, flgg, txt, ttl, x, y)
result = sl_tvdmenunw(wwm)
result = sl_tvgetwn(wn)
result = sl_tvfirst(devs, replic, tv_nc, tv_x, tv_y, tv_dx, tv_dy, tv_od, tv_rd, io_rec, io_dir, mo_tif, tv_vcol, tv_swap, tv_extso)
tvstop, dummy
sl_grafin, devs
sl_comi, dummy
sl_comi2, dummy
sl_comj, dummy
sl_inview, dummy
sl_inkeep1, dummy
sl_inkeep2, dummy
sl_inkeep3, dummy
invier, dum
sl_super, dummy
sl_super2, dummy
result = sl_handerr(n, str)
result = sl_tog(i)
result = sl_min2(x1, x2)
result = sl_max2(x1, x2)
result = sl_dd(j, erey, vsizy, area, vsiza)
result = sl_pp(j, erey, vsizy, area, vsiza)
result = sl_psiz(psiz, s0, s1, s2, s3, s4, s5)
result = sl_psiz0(psiz, s0, s1, s2, s3, s4, s5)
result = sl_psizm(area, psiz, s0, s1, s2, s3, s4, s5)
sl_stron, extab, j1, j2, plc, pll, char1, char2
result = sl_typb(typ)
result = sl_str_to_long(flg, str, areout, y, offset, maxl)
result = sl_put_strfile(n, win, dirc, dm1, dm2, dm3, recl, typ, form, posit, swap, start)
result = sl_get_strfile(n, win, dirc, dm1, dm2, dm3, recl, typ, form, posit, swap, start)
result = sl_cellget(u, dim, rl_ty, a, fl)
result = sl_stream(u, dim, rl_ty, a, fl)
result = sl_cellput(erey, u, vsiz)
result = sl_filr(diry, ext, vers, dirc, frm)
result = sl_filw(dim, extc, ext, name, typ, xsiz, ppf, nbf)
sl_colexp, x, y
sl_level, n
sl_kbcar, st
result = sl_kb(in_st)
sl_signal, x, y, fcx, fcy, rti, reg, ot
result = sl_glory(flin)
result = sl_vecfun(pw, pfl, pmen, pttl, px, py, erey, vsiz, c, l, f, bx, by)
result = sl_click(b1, b2, b3, ttl, flg)
sl_manycol, wcol
sl_dc, ci, li, xi, yi
sl_ellip, flg, erey, vsiz, nf, alph, cx, cy, ddx, ddy, itg, moy, nlz, sigma, sum
result = sl_radi_a(iy, ix, fang, lang)
result = sl_radies(erey, vsiz, nf, alph, cx, cy, ddx, ddy, sum, np, fang, lang)
sl_box, flg
sl_box_draw, dum
result = sl_settings(mfi, xu, yu, zerr, inc, flg)
result = sl_trsig(zerr, inc, vin, mfi, ot, rti)
result = sl_conv(erey, vsiz, typ)
result = sl_b_fix(erey, vsiz, typ)
result = sl_scalf(area, vsiz, mn, mx, mnx, flg, areout, sby)
result = sl_d_p1(j, erey, vsiz, dif, stc, x1, y1)
result = sl_d_p(j, erey, vsiz, dif, stc, x1, y1)
result = sl_gauss(x, siz, p)
result = sl_fit(erey, vsiz, f, f_ab, fct, sens, deg)
result = sl_prefit(erey, vsiz, f, f_ab, fct, sens, deg)
result = sl_opcheck(oprt)
result = sl_d_pm(are1, siz1, oprt, are2, siz2, are3, siz3)
result = sl_lstframe(erey, xsiz, flg, fout, areout, areout_z)
result = sl_getord(m_u, k, dm_ins, rl_ins, areins, zimg, m_sr, m_frm)
result = sl_getrflx(arel, arel_z, dm1, dirc)
result = sl_getccp4(m_u, idk, dm_ins, rl_ins, erey, zimg, m_sr, m_bo)
result = sl_tifb(idx)
result = sl_w(idx, flw)
sl_tiftag, idx
result = sl_tifcell(m_u, idk, dm_ins, rl_ins, erey, zimg, m_sr, m_bo, m_hyst)
result = sl_annot(win)
result = sl_matx(k, dirc, areins, dm_ins, zd, dy_ins, rl_ins, menfrm, z_pos, z_bo, z_sr, z_hyst)
result = sl_chk_win(w, xx, yy, fl, wex)
result = sl_purge(windn)
result = sl_cv(vl, vo, f, g, cpx)
result = sl_xred(erey, clf, siz, fct, cpx)
result = sl_spacial(erey, flg, clf, vsis, rot, sxy)
result = sl_savarea(cd, erey, fcg, xsiz, windn, icon, icon_z)
result = sl_resarea(cd, erey, xsiz, fdl, fl, filename)
result = sl_tty(flg)
result = sl_break(DATA, VSIZ, CURIJK, ARES, ARES_Z)
result = sl_insert(w, in_are, vsiz, pcur)
result = sl_gf(vl, f, g, fmt)
result = sl_dislog(are, are_z, vxl, vxm)
result = sl_surf(scl, erey, vsx, vsy, vsz, typ, plx, ply, miv, mxv, az, ax, lev, flg, bg, smo)
result = sl_rotfun(flg, w, flp, flpb, erey, vsx, vsy, vsz, typ, az, ax, smo, x1, x2, y1, y2)
result = sl_getentry(w, windn)
result = sl_views(erey, windn, ttl, c_c, l_c, sp_c, f_c, fcs, vsiz)
provw0, erey, kf, w_co, w_lt
provw1, erey, kf, w_co, windn, baseview
provw2, w_co
sl_region, c, l, a, b, d, e, ifu, jfu, vsiz
result = sl_slice(erey, vsiz, c, l, f1, f2, bxy6, bxy7, flg, f_sa)
result = sl_ellipos(erey, vsiz, cx, cy, cf, f_fg, f_el, rad, ccx, ccy)
result = sl_bgbox(erey, vsiz, f, f_ab)
provfu, erey, vsiz, c, l, f, bx
result = sl_funn(jf, erey, vsiz, c, l, f, k_bx, k_by, explv)
prov_fun2, jf, vsiz, c, l, f, bx, by
result = sl_raster(erey, windn)
result = sl_hardc(sx, sy, num, spt, spm, erey, vsiz, windn, fhd, nocol, lga)
result = sl_curset(exspc, exsi, exsj, fxy, nnz)
result = sl_working(inc, ttl, flg, exp)
result = sl_resize(dum)
result = sl_magang(b6, b7, c0, c1, rsm, rsl, vta, vtm)
sl_pan, px, py, pz, cc, lc, fcl, fcg, vsiz, flg
sl_pflex, arefl, k, ttp
provi, windn, erey
provc, windn, erey
provj, dum
provk, windn
provl, windn, erey, xsiz
provs, erey
provz, windn, erey, rvl, rvm
provit, erey, windn, xsiz
provit1, erey, windn
result = sl_rad_lu(area, vsiz, nf, cti, ctj, ry1, ry2, a1, a2, arel)
provit2, erey, windn
provit3, erey, windn, xsiz
provm, erey
result = sl_zoomi(x, y, xd, yd)
result = sl_viewr(erey, xsiz, windn, recurs)
result = sl_viewer(erey, windn, vsiz, flg)
result = sl_opview(erey, vsiz, w_1, w_2, oprt, flg)
result = sl_which(dummy)
result = sl_dtmp(dummy)
result = sl_menu_bg(w, fl, text, ttl, px, py, rfl)
sl_c_scan, dummy
xtrip
super, dummy
sl_lampscan, flg, p1, p2, p3, p4, fname
sl_main
scan, area, wentry, wother
Routine details
top sl_execute
result = sl_execute(n, i_rout, in_are, i_ps1, i_ps2, i_ps3, pcur, typ)
******* ********** **
Parameters
- n
- i_rout
- in_are
- i_ps1
- i_ps2
- i_ps3
- pcur
- typ
top sl_run
result = sl_run(cmd, str, ext, vers, flg)
******* ****** **
Parameters
- cmd
- str
- ext
- vers
- flg
top sl_calll
result = sl_calll(rout, file, p1, p2, p3, p4, p5, p6)
******* ******** **
Parameters
- rout
- file
- p1
- p2
- p3
- p4
- p5
- p6
top sl_sarr
result = sl_sarr(nd, d1, d2, d3, d4)
******* ****** ** on_error,2 %ow% if nd lt 0 then return, strarr(d1) else $ %ow% if nd eq 2 then return, strarr(d1,d2) else $ %ow% if nd eq 3 then return, strarr(d1,d2,d3) else $ %ow% if nd eq 4 then return, strarr(d1,d2,d3,d4)
Parameters
- nd
- d1
- d2
- d3
- d4
top sl_barr
result = sl_barr(nd, d1, d2, d3, d4)
******* ****** ** on_error,2 %ow% if nd lt 0 then return, bytarr(d1) else $ %ow% if nd eq 1 then return, bytarr(d1) else $ %ow% if nd eq 2 then return, bytarr(d1,d2) else $ %ow% if nd eq 3 then return, bytarr(d1,d2,d3) else $ %ow% if nd eq 4 then return, bytarr(d1,d2,d3,d4)
Parameters
- nd
- d1
- d2
- d3
- d4
top sl_iarr
result = sl_iarr(nd, d1, d2, d3, d4)
******* ****** ** on_error,2 %ow% if nd lt 0 then return, intarr(d1) else $ %ow% if nd eq 1 then return, intarr(d1) else $ %ow% if nd eq 2 then return, intarr(d1,d2) else $ %ow% if nd eq 3 then return, intarr(d1,d2,d3) else $ %ow% if nd eq 4 then return, intarr(d1,d2,d3,d4)
Parameters
- nd
- d1
- d2
- d3
- d4
top sl_larr
result = sl_larr(nd, d1, d2, d3, d4)
******* ****** ** on_error,2 %ow% if nd lt 0 then return, lonarr(d1) else $ %ow% if nd eq 1 then return, lonarr(d1) else $ %ow% if nd eq 2 then return, lonarr(d1,d2) else $ %ow% if nd eq 3 then return, lonarr(d1,d2,d3) else $ %ow% if nd eq 4 then return, lonarr(d1,d2,d3,d4)
Parameters
- nd
- d1
- d2
- d3
- d4
top sl_farr
result = sl_farr(nd, d1, d2, d3, d4)
******* ****** ** on_error,2 %ow% if nd lt 0 then return, fltarr(d1) else $ %ow% if nd eq 1 then return, fltarr(d1) else $ %ow% if nd eq 2 then return, fltarr(d1,d2) else $ %ow% if nd eq 3 then return, fltarr(d1,d2,d3) else $ %ow% if nd eq 4 then return, fltarr(d1,d2,d3,d4)
Parameters
- nd
- d1
- d2
- d3
- d4
top sl_darr
result = sl_darr(nd, d1, d2, d3, d4)
******* ****** ** on_error,2 %ow% if nd lt 0 then return, dblarr(d1) else $ %ow% if nd eq 1 then return, dblarr(d1) else $ %ow% if nd eq 2 then return, dblarr(d1,d2) else $ %ow% if nd eq 3 then return, dblarr(d1,d2,d3) else $ %ow% if nd eq 4 then return, dblarr(d1,d2,d3,d4)
Parameters
- nd
- d1
- d2
- d3
- d4
top sl_carr
result = sl_carr(nd, d1, d2, d3, d4)
******* ****** ** on_error,2 %ow% if nd lt 0 then return, complexarr(d1) else $ %ow% if nd eq 1 then return, complexarr(d1) else $ %ow% if nd eq 2 then return, complexarr(d1,d2) else $ %ow% if nd eq 3 then return, complexarr(d1,d2,d3) else $ %ow% if nd eq 4 then return, complexarr(d1,d2,d3,d4)
Parameters
- nd
- d1
- d2
- d3
- d4
top sl_iotype
result = sl_iotype(str, typ, np, v1, v2, v3, v4)
******* ********* **
Parameters
- str
- typ
- np
- v1
- v2
- v3
- v4
top sl_iofind
result = sl_iofind(specif, ext, vers, names)
******* ********* **
Parameters
- specif
- ext
- vers
- names
top sl_iopenw
result = sl_iopenw(u, desc, ext, rec, struc)
******* ********* ** struc= 0 for text , 1 for binary
Parameters
- u
- desc
- ext
- rec
- struc
top sl_iopenr
result = sl_iopenr(u, desc, struc, frm)
******* ********* ** Struc= 0 for edited text , 1 for binary ** Frm = 0 for fixed , 1 for text , 2 for tiff , 3 for stream ** 5 for segmented
Parameters
- u
- desc
- struc
- frm
top sl_ioread
result = sl_ioread(u, area, vsiz, flg)
******* ********* **
Parameters
- u
- area
- vsiz
- flg
top sl_ioreads
result = sl_ioreads(str, typ, np, v1, v2, v3, v4)
******* ********** **
Parameters
- str
- typ
- np
- v1
- v2
- v3
- v4
top sl_ioaccept
result = sl_ioaccept(str, typ, np, v1, v2, v3, v4)
******* *********** **
Parameters
- str
- typ
- np
- v1
- v2
- v3
- v4
top sl_swapint
result = sl_swapint(area, d1, d2, d3, typ)
******* ********** **
Parameters
- area
- d1
- d2
- d3
- typ
top sl_swapvms
result = sl_swapvms(area, d1, d2, d3, typ, flag)
******* ********** **
Parameters
- area
- d1
- d2
- d3
- typ
- flag
top sl_abs
result = sl_abs(are_in, are_out, nl, typ, sz)
******* ****** **
Parameters
- are_in
- are_out
- nl
- typ
- sz
top sl_atangm
result = sl_atangm(are_in, are_out, nl, typ, sz)
******* ********* **
Parameters
- are_in
- are_out
- nl
- typ
- sz
top sl_correl
result = sl_correl(area1, area2, dx, dy, typ)
******* ********* **
Parameters
- area1
- area2
- dx
- dy
- typ
top sl_deviat
result = sl_deviat(area, y1, dx, dy, typ)
******* ********* **
Parameters
- area
- y1
- dx
- dy
- typ
top sl_polycoef
result = sl_polycoef(x, y, vsiz, deg)
******* *********** **
Parameters
- x
- y
- vsiz
- deg
top sl_polyval
result = sl_polyval(x, vsiz, coef, deg)
******* ********** **
Parameters
- x
- vsiz
- coef
- deg
top sl_hist
result = sl_hist(area, dm, typ, his, mn, mx)
******* ******* **
Parameters
- area
- dm
- typ
- his
- mn
- mx
top sl_redim
result = sl_redim(area, dx, dy, typ, nx, ny, flg)
******* ******** **
Parameters
- area
- dx
- dy
- typ
- nx
- ny
- flg
top sl_lis
result = sl_lis(area, dx, dy, typ, np, fl)
******* ****** **
Parameters
- area
- dx
- dy
- typ
- np
- fl
top sl_media
result = sl_media(area, dx, dy, typ, np, x1, y1)
******* ******** **
Parameters
- area
- dx
- dy
- typ
- np
- x1
- y1
top sl_imaginary
result = sl_imaginary(are_in, are_out, nl, typ, sz)
******* ************ **
Parameters
- are_in
- are_out
- nl
- typ
- sz
top sl_rotat
result = sl_rotat(area, dx, dy, typ, ang, fl)
******* ******** **
Parameters
- area
- dx
- dy
- typ
- ang
- fl
top sl_rotscal
result = sl_rotscal(area, vsiz, nf, ang, mag, cx, cy)
******* ********** **
Parameters
- area
- vsiz
- nf
- ang
- mag
- cx
- cy
top sl_shadoc
result = sl_shadoc(fl, area, xs, ys, ax, ay, az)
******* ********* **
Parameters
- fl
- area
- xs
- ys
- ax
- ay
- az
top sl_revs
result = sl_revs(area, dx, dy, typ, flg)
******* ******* **
Parameters
- area
- dx
- dy
- typ
- flg
top sl_scale
result = sl_scale(area, dx, dy, typ, mn, mx)
******* ******** ** **Scale by tv_nc and return in byte. **
Parameters
- area
- dx
- dy
- typ
- mn
- mx
top sl_shift
result = sl_shift(area, dx, dy, typ, nx, ny)
******* ******** **
Parameters
- area
- dx
- dy
- typ
- nx
- ny
top sl_shiff
result = sl_shiff(area, dx, dy, typ, nx, ny)
******* ******** **
Parameters
- area
- dx
- dy
- typ
- nx
- ny
top sl_fsum
result = sl_fsum(area, dm, siz, areout)
******* ******* **
Parameters
- area
- dm
- siz
- areout
top sl_where
result = sl_where(area, vsiz, opr, x, areout)
******* ******** **
Parameters
- area
- vsiz
- opr
- x
- areout
top sl_wglux
result = sl_wglux(w, sx, sy, ttl, xp, yp, seq, t_sx, t_sy)
******* ******** ** w is the scan window number ** seq = 1 Starting and pixmap (not mapped) ** seq = 2 Menu + ok ** seq = 3 Menu + cancel (list) ** seq = 4 Menu + input buffer ** seq = 5 Menu ** seq = 6 Glory_Hole ** seq = 7 Scan ** seq = 8 View ** seq = 9 Info ** seq = 10 Scan or View to be resized ** seq < 0 Scan or View in base -seq **
Parameters
- w
- sx
- sy
- ttl
- xp
- yp
- seq
- t_sx
- t_sy
top sl_wghandy
result = sl_wghandy(flg)
******* ********** ** ** flg = 2 set new text value ** flg = 3 map widget **
Parameters
- flg
top sl_wgaccept
result = sl_wgaccept(w, lab, typ, nb, m1, m2, m3, m4)
******* *********** **
Parameters
- w
- lab
- typ
- nb
- m1
- m2
- m3
- m4
top sl_tvlamp_base
result = sl_tvlamp_base(flg, base_event)
******* ************** ** ** 1 = base ** 2 = event
Parameters
- flg
- base_event
top sl_tvwmaj
result = sl_tvwmaj(w, vf, vm, rvl, rvm, f_fg, f_vu, spt, f_ax, f_az)
******* ********* **
Parameters
- w
- vf
- vm
- rvl
- rvm
- f_fg
- f_vu
- spt
- f_ax
- f_az
top sl_tvset
result = sl_tvset(flg, val, v2, v3, v4, v5, v6, v7)
******* ** ** Set graphic's variables. ** --- --------- ---------
Parameters
- flg
- val
- v2
- v3
- v4
- v5
- v6
- v7
top sl_tvldcol
result = sl_tvldcol(red, green, bleue)
******* ********** ** ** Load color vectors. ** ---- ----- -------
Parameters
- red
- green
- bleue
top sl_tvgtcol
result = sl_tvgtcol(red, green, bleue)
******* ********** ** ** Load color vectors. ** ---- ----- -------
Parameters
- red
- green
- bleue
top sl_tvloadct
result = sl_tvloadct(id, red, green, bleue)
******* *********** ** ** Load color table. ** ---- ----- -----
Parameters
- id
- red
- green
- bleue
top sl_tvcur_w
result = sl_tvcur_w(w, gh, inf, fs, sx, sy)
******* **********
Parameters
- w
- gh
- inf
- fs
- sx
- sy
top sl_tvshap
result = sl_tvshap(fl)
******* ********* ** ** Cursor shape. ** ------ -----
Parameters
- fl
top sl_tvclear
result = sl_tvclear(dummy)
******* ********** ** ** Clear current window. ** ----- ------- ------
Parameters
- dummy
top sl_tvdelwn
result = sl_tvdelwn(wn)
******* ********** ** ** Suppress a window. ** -------- - ------
Parameters
- wn
top sl_tvfreewn
result = sl_tvfreewn(wn)
******* *********** ** ** Suppress a window. ** -------- - ------
Parameters
- wn
top sl_tvsel
result = sl_tvsel(w)
******* ******** ** ** Select a window. ** ------ - ------
Parameters
- w
top sl_tvsels
result = sl_tvsels(w)
******* ********* ** ** Select a window. ** ------ - ------
Parameters
- w
top sl_tvwake
result = sl_tvwake(w)
******* ********* ** ** Expand a window. ** ------ - ------
Parameters
- w
top sl_tvlux
result = sl_tvlux(w, sx, sy, ttl, op1, op2, op3, op4, op5, op6, op7, op8, x, y, seq)
******* ******** ** ** Create a window. ** ------ - ------
Parameters
- w
- sx
- sy
- ttl
- op1
- op2
- op3
- op4
- op5
- op6
- op7
- op8
- x
- y
- seq
top sl_tvimag
result = sl_tvimag(area, vsiz, x, y)
******* ********* ** ** Display image video. ** ------- ----- -----
Parameters
- area
- vsiz
- x
- y
top sl_tvsimag
result = sl_tvsimag(area, vsiz, x, y)
******* ********* ** ** Display image video. ** ------- ----- -----
Parameters
- area
- vsiz
- x
- y
top sl_tvmerr
result = sl_tvmerr(dum)
******* ********* ** ** Get the click button number. ** --- --- ----- ------ ------
Parameters
- dum
top sl_tvwinp
******* ********* ** ** Get window device position. ** --- ------ ------ --------
Parameters
- x
- y
top sl_tvwait
result = sl_tvwait(tim, motion, button, wind, rflag, rw)
******* ********* ** ** TIM to wait in seconds ** MOTION = 1 means wakup if cursor moved. ** BUTTON = 1 means wakup if button pressed. ** BUTTON = 2 means wakup if keyboard pressed. ** WIND =-1 if event from any window else = Window ID. ** RFLAG return type of event to be processed by nacs. ** RW return window of event ** in any case wakup if keyboard pressed is not faisable if MOTION=1. ** if tim = 0 motion may be important. **
Parameters
- tim
- motion
- wind
- rflag
- rw
top sl_tvgcur
result = sl_tvgcur(x, y, button, wait)
******* ********* ** ** Get cursor device position. ** --- ------ ------ --------
Parameters
- x
- y
- wait
top sl_tvmcur
******* ********* ** ** Manipulate the cursor. ** ---------- --- ------
Parameters
- flg
- x
- y
top sl_tvread
result = sl_tvread(x, y, dx, dy)
******* ********* ** ** Read pixels. ** ---- ------
Parameters
- x
- y
- dx
- dy
top sl_tvpop
******* ******** ** ** put window to the front or to the back. ** --- ------ -- --- ----- -- -- --- ----
Parameters
- w
- fl
top sl_tvs
result = sl_tvs(x, y, text, siz, deg, col)
******* ****** ** ** Output a text. ** ------ - ----
Parameters
- x
- y
- text
- siz
- deg
- col
top sl_tvt
result = sl_tvt(x, y, text, siz, deg, col)
******* ****** ** ** Output a text with special car. ** ------ - ---- ---- ------- ---
Parameters
- x
- y
- text
- siz
- deg
- col
top sl_tvxyz
result = sl_tvxyz(xmin, xmax, ymin, ymax)
******* ******** ** ** Scale into the window region.(Care parameters type) ** ----- ---- --- ------ ------
Parameters
- xmin
- xmax
- ymin
- ymax
top sl_tvscreen
result = sl_tvscreen(xmin, xmax, ymin, ymax)
******* *********** ** ** Map a window region. ** --- - ------ ------
Parameters
- xmin
- xmax
- ymin
- ymax
top sl_tvaxis
result = sl_tvaxis(mn, mx, flg, lab, sz, ttl)
******* ********* ** ** Draw axis. ** ---- ----
Parameters
- mn
- mx
- flg
- lab
- sz
- ttl
top sl_tvline
result = sl_tvline(vx, vy, vs, mode, col)
******* ********* ** ** Draw a vector. (vs=size) ** ---- - ------
Parameters
- vx
- vy
- vs
- mode
- col
top sl_tvplt
result = sl_tvplt(flg, nx, x, ny, y)
******* ******** ** ** Draw a vector. ** ---- - ------
Parameters
- flg
- nx
- x
- ny
- y
top sl_tvfill
result = sl_tvfill(x0, x, xn, y0, y, yn, col, inc, ang)
******* ********* ** ** Fill a region. ** ---- - ------
Parameters
- x0
- x
- xn
- y0
- y
- yn
- col
- inc
- ang
top sl_tvpol
result = sl_tvpol(n, vx, vy, colpat, cp)
******* ******** ** ** Fill a polygon ** ---- - -------
Parameters
- n
- vx
- vy
- colpat
- cp
top sl_tvdev
result = sl_tvdev(dev)
******* ******** ** ** Choice output device. ** ------ ------ ------
Parameters
- dev
top sl_tvmov
result = sl_tvmov(int7)
******* ******** ** ** Move a region in current window. ** ---- - ------ -- ------- ------
Parameters
- int7
top sl_tvhdfil
result = sl_tvhdfil(flg, fil, ext, fhd, nocol)
******* ********** ** ** Open or close a HD file ** ---- -- ----- - -- ----
Parameters
- flg
- fil
- ext
- fhd
- nocol
top sl_tvhdlct
result = sl_tvhdlct(cr, cg, cb)
******* ********** ** ** Put color in a HD file ** --- ----- -- - -- ----
Parameters
- cr
- cg
- cb
top sl_tvhdimg
result = sl_tvhdimg(area, vsiz, fil, ext)
******* ********** ** ** Put image in a HD file ** --- ----- -- - -- ----
Parameters
- area
- vsiz
- fil
- ext
top sl_tvpix
******* ******** ** ** Duplicate pixels. (tv_flg(0)=1) ** --------- ------ ******
Parameters
- fx
- fy
top sl_tvras
result = sl_tvras(x, y, dx, dy, col, bx, by)
******* ******** ** ** Fill a region with col. ** ---- - ------ ---- ---
Parameters
- x
- y
- dx
- dy
- col
- bx
- by
top sl_surfex
result = sl_surfex(p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13)
******* ********* **
Parameters
- p1
- p2
- p3
- p4
- p5
- p6
- p7
- p8
- p9
- p10
- p11
- p12
- p13
top sl_deepex
result = sl_deepex(p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22, p23, p24, p25)
******* ********* **
Parameters
- p1
- p2
- p3
- p4
- p5
- p6
- p7
- p8
- p9
- p10
- p11
- p12
- p13
- p14
- p15
- p16
- p17
- p18
- p19
- p20
- p21
- p22
- p23
- p24
- p25
top sl_surface
result = sl_surface(area, az, ax, asp, skirt)
******* ********** **
Parameters
- area
- az
- ax
- asp
- skirt
top sl_contour
result = sl_contour(area, start, endd, lev)
******* ********** **
Parameters
- area
- start
- endd
- lev
top sl_tvhdout
result = sl_tvhdout(fil, ext, fhd)
******* ********** ** ** Output a HD file ** ------ - -- ----
Parameters
- fil
- ext
- fhd
top sl_tvscrl
result = sl_tvscrl(txt, ms_ncol)
******* ********* ** ** Scroll menu text. ** ------ --- ---- **
Parameters
- txt
- ms_ncol
top sl_tvgetwn
result = sl_tvgetwn(wn)
******* ********** ** ** Get a free window number (or -1). ** --- - ---- ------ ------
Parameters
- wn
top sl_tvfirst
result = sl_tvfirst(devs, replic, tv_nc, tv_x, tv_y, tv_dx, tv_dy, tv_od, tv_rd, io_rec, io_dir, mo_tif, tv_vcol, tv_swap, tv_extso)
******* ********** ** ** Initialisations. ** ---------------
Parameters
- devs
- replic
- tv_nc
- tv_x
- tv_y
- tv_dx
- tv_dy
- tv_od
- tv_rd
- io_rec
- io_dir
- mo_tif
- tv_vcol
- tv_swap
- tv_extso
top sl_grafin
sl_grafin, devs
************ **Init station **---- ------- Care tv_nc=256 --> r,g,b,cr,cg,cb my_cl --> cl_i=tv_nc my_box --> bx_tb(*,*),bx_ty(*,*)=tv_nc-1 my_glor --> f_pl=sl_index(tv_nc,4)
Parameters
- devs
top sl_inview
sl_inview, dummy
** ********* ** Init viewer tables. ** ---- ------ ------ **
Parameters
- dummy
top sl_inkeep1
sl_inkeep1, dummy
** ********* ** Init viewer tables. ** ---- ------ ------ **
Parameters
- dummy
top sl_super
sl_super, dummy
** ******** ** Init Scan Desktop. ** ---- ---- ------- **
Parameters
- dummy
top sl_dd
result = sl_dd(j, erey, vsizy, area, vsiza)
******* ***** * **** ***** **** ***** ** ** Data dynamic. ** ---- -------
Parameters
- j
- erey
- vsizy
- area
- vsiza
top sl_pp
result = sl_pp(j, erey, vsizy, area, vsiza)
******* ***** * **** ***** **** ***** **
Parameters
- j
- erey
- vsizy
- area
- vsiza
top sl_psiz
result = sl_psiz(psiz, s0, s1, s2, s3, s4, s5)
******* ******* **
Parameters
- psiz
- s0
- s1
- s2
- s3
- s4
- s5
top sl_psiz0
result = sl_psiz0(psiz, s0, s1, s2, s3, s4, s5)
******* ******* **
Parameters
- psiz
- s0
- s1
- s2
- s3
- s4
- s5
top sl_psizm
result = sl_psizm(area, psiz, s0, s1, s2, s3, s4, s5)
******* ******** **
Parameters
- area
- psiz
- s0
- s1
- s2
- s3
- s4
- s5
top sl_stron
sl_stron, extab, j1, j2, plc, pll, char1, char2
** ******** **
Parameters
- extab
- j1
- j2
- plc
- pll
- char1
- char2
top sl_str_to_long
result = sl_str_to_long(flg, str, areout, y, offset, maxl)
******* ************** **
Parameters
- flg
- str
- areout
- y
- offset
- maxl
top sl_put_strfile
result = sl_put_strfile(n, win, dirc, dm1, dm2, dm3, recl, typ, form, posit, swap, start)
******* ************** **
Parameters
- n
- win
- dirc
- dm1
- dm2
- dm3
- recl
- typ
- form
- posit
- swap
- start
top sl_get_strfile
result = sl_get_strfile(n, win, dirc, dm1, dm2, dm3, recl, typ, form, posit, swap, start)
******* ************** **
Parameters
- n
- win
- dirc
- dm1
- dm2
- dm3
- recl
- typ
- form
- posit
- swap
- start
top sl_cellget
result = sl_cellget(u, dim, rl_ty, a, fl)
******* ********** * *** ***** * ** ** Read next block. fl > 0 then get memory ** ---- ---- ----- |fl| > 1 then skip records ** recl < 0 calculate max record size ** recl = 0 read(data) carez touti dim(3) rl_ty(2) a:area b:area **
Parameters
- u
- dim
- rl_ty
- a
- fl
top sl_stream
result = sl_stream(u, dim, rl_ty, a, fl)
******* ********** * *** ***** * ** ** Read stream matrix. fl > 0 then get memory ** ---- ------ ------ |fl| > 1 then skip bytes carez touti dim(3) rl_ty(2) a:area **
Parameters
- u
- dim
- rl_ty
- a
- fl
top sl_cellput
result = sl_cellput(erey, u, vsiz)
******* ********** **** * **** ** Write a scan block. ** ----- - ---- -----
Parameters
- erey
- u
- vsiz
top sl_filr
result = sl_filr(diry, ext, vers, dirc, frm)
******* ******* ************* **** *** ** Open a file. ** ---- - ---- **
Parameters
- diry
- ext
- vers
- dirc
- frm
top sl_filw
result = sl_filw(dim, extc, ext, name, typ, xsiz, ppf, nbf)
******* ******* *** ******** **** *** **** *** *** ** Open write a scan file. ** ---- ----- - ---- ----
Parameters
- dim
- extc
- ext
- name
- typ
- xsiz
- ppf
- nbf
top sl_level
sl_level, n
** ******** ** ** Edit color table to see levels. ** ---- ----- ----- -- --- ------
Parameters
- n
top sl_kb
result = sl_kb(in_st)
******* ***** ** get a user signal. ** *** * **** ******
Parameters
- in_st
top sl_signal
sl_signal, x, y, fcx, fcy, rti, reg, ot
** ********* **
Parameters
- x
- y
- fcx
- fcy
- rti
- reg
- ot
top sl_vecfun
result = sl_vecfun(pw, pfl, pmen, pttl, px, py, erey, vsiz, c, l, f, bx, by)
******* ********* **
Parameters
- pw
- pfl
- pmen
- pttl
- px
- py
- erey
- vsiz
- c
- l
- f
- bx
- by
top sl_click
result = sl_click(b1, b2, b3, ttl, flg)
******* ******** ** ** ** *** *** ** input a number using the smallest device. ** ----- - ------ ----- --- -------- ------
Parameters
- b1
- b2
- b3
- ttl
- flg
top sl_manycol
sl_manycol, wcol
** ********** ** Get a color table. ** *** * **** *****
Parameters
- wcol
top sl_ellip
sl_ellip, flg, erey, vsiz, nf, alph, cx, cy, ddx, ddy, itg, moy, nlz, sigma, sum
** ******** **
Parameters
- flg
- erey
- vsiz
- nf
- alph
- cx
- cy
- ddx
- ddy
- itg
- moy
- nlz
- sigma
- sum
top sl_radi_a
result = sl_radi_a(iy, ix, fang, lang)
******* ********* ** ** test point inside angle **
Parameters
- iy
- ix
- fang
- lang
top sl_radies
result = sl_radies(erey, vsiz, nf, alph, cx, cy, ddx, ddy, sum, np, fang, lang)
******* ********* **
Parameters
- erey
- vsiz
- nf
- alph
- cx
- cy
- ddx
- ddy
- sum
- np
- fang
- lang
top sl_settings
result = sl_settings(mfi, xu, yu, zerr, inc, flg)
******* *********** **
Parameters
- mfi
- xu
- yu
- zerr
- inc
- flg
top sl_trsig
result = sl_trsig(zerr, inc, vin, mfi, ot, rti)
******* ******** **** *** *** *** ** *** **
Parameters
- zerr
- inc
- vin
- mfi
- ot
- rti
top sl_conv
result = sl_conv(erey, vsiz, typ)
******* ******* **** **** *** ** ** Convert to byte fix float long double complex ** typ = 2 4 8 16 32 64
Parameters
- erey
- vsiz
- typ
top sl_b_fix
result = sl_b_fix(erey, vsiz, typ)
******* ******** **** **** *** ** ** Byte --> fix **
Parameters
- erey
- vsiz
- typ
top sl_scalf
result = sl_scalf(area, vsiz, mn, mx, mnx, flg, areout, sby)
******* ******** ** **Scale by sby. mnx= 1 means values already 0< >255 ** flg=-1 means return result ** flg= 0 means use areout ** flg= 1 means use area ** flg= 2 means use area + force byte **
Parameters
- area
- vsiz
- mn
- mx
- mnx
- flg
- areout
- sby
top sl_d_p1
result = sl_d_p1(j, erey, vsiz, dif, stc, x1, y1)
******* ****** * **** **** *** *** ** ** ** **
Parameters
- j
- erey
- vsiz
- dif
- stc
- x1
- y1
top sl_d_p
result = sl_d_p(j, erey, vsiz, dif, stc, x1, y1)
******* ****** * **** **** *** *** ***** ** ** Data Processing. ** ---- ---------- **
Parameters
- j
- erey
- vsiz
- dif
- stc
- x1
- y1
top sl_fit
result = sl_fit(erey, vsiz, f, f_ab, fct, sens, deg)
******* ****** ** fct: 0=gauss 1=poly 2=poly(null) 3=poly surface ** sens: 0=X 1=Y **
Parameters
- erey
- vsiz
- f
- f_ab
- fct
- sens
- deg
top sl_prefit
result = sl_prefit(erey, vsiz, f, f_ab, fct, sens, deg)
******* ********* ** fct: 0=gauss 1=poly 2=poly(null) 3=poly surface **
Parameters
- erey
- vsiz
- f
- f_ab
- fct
- sens
- deg
top sl_opcheck
result = sl_opcheck(oprt)
******* ********** ** Check concistancies for view operations. ** ----- ------------- --- ---- ---------- ** Matrix operations: are1 {oprt} are2 --> are3 2:+ 3:- 4:* 5:| 6:# 7:>- **
Parameters
- oprt
top sl_d_pm
result = sl_d_pm(are1, siz1, oprt, are2, siz2, are3, siz3)
******* ******** ** ** Matrix operations: are1 {oprt} are2 --> are3 2:+ 3:- 4:* 5:| 6:# 7:>- ** ------ ---------- ------------------------- - - - - - --
Parameters
- are1
- siz1
- oprt
- are2
- siz2
- are3
- siz3
top sl_lstframe
result = sl_lstframe(erey, xsiz, flg, fout, areout, areout_z)
******* *********** ** ** Matrix construction from vectors list. ni , cx , cy , radius ** ------ ------------ ---- ------- ---- val, rx , ry , rz ** " " " " ** ni = # of points ** flg = 0 to keep only sub_area ** fout= 1 use areout and areout_z=[0,typ,0,0,0,0..] ** fout= 0 use ares ** fout= 2 use ares and lisse
Parameters
- erey
- xsiz
- flg
- fout
- areout
- areout_z
top sl_getord
result = sl_getord(m_u, k, dm_ins, rl_ins, areins, zimg, m_sr, m_frm)
******* ********* ** ** Read (X , Y , values) and make image. --> m_frm=4 ** Read (value , X,Y,Z) and make image. --> m_frm=8 ** ---- --- ---- -----
Parameters
- m_u
- k
- dm_ins
- rl_ins
- areins
- zimg
- m_sr
- m_frm
top sl_getrflx
result = sl_getrflx(arel, arel_z, dm1, dirc)
******* ********** **
Parameters
- arel
- arel_z
- dm1
- dirc
top sl_getccp4
result = sl_getccp4(m_u, idk, dm_ins, rl_ins, erey, zimg, m_sr, m_bo)
******* ********** **
Parameters
- m_u
- idk
- dm_ins
- rl_ins
- erey
- zimg
- m_sr
- m_bo
top sl_tifcell
result = sl_tifcell(m_u, idk, dm_ins, rl_ins, erey, zimg, m_sr, m_bo, m_hyst)
******* ********** **
Parameters
- m_u
- idk
- dm_ins
- rl_ins
- erey
- zimg
- m_sr
- m_bo
- m_hyst
top sl_matx
result = sl_matx(k, dirc, areins, dm_ins, zd, dy_ins, rl_ins, menfrm, z_pos, z_bo, z_sr, z_hyst)
******* ******* ** k index ** dirc returned filename ** areins data buffer ** dm_ins [dim1,dim2] ** zd dim3 ** dy_ins ['filespec for input','returned filename'] ** rl_ins [recl , type] ** menfrm input format or -1 to get menu. ** z_pos integer positif ** z_bo byte order 1 to reverse ** z_sr byte offset or record offset
Parameters
- k
- dirc
- areins
- dm_ins
- zd
- dy_ins
- rl_ins
- menfrm
- z_pos
- z_bo
- z_sr
- z_hyst
top sl_chk_win
result = sl_chk_win(w, xx, yy, fl, wex)
******* ********** * ** ** ** *** ** ** Check where is the cursor. ** ----- ----- -- --- ------ **
Parameters
- w
- xx
- yy
- fl
- wex
top sl_purge
result = sl_purge(windn)
******* ******** ***** ** ** Delete some windows. ** ------ ---- ------- **
Parameters
- windn
top sl_xred
result = sl_xred(erey, clf, siz, fct, cpx)
******* ******* **** *** *** *** *** ** get indices from a max in a reduced sub_view. ** --- ------- ---- - --- -- - ------- -------- **
Parameters
- erey
- clf
- siz
- fct
- cpx
top sl_spacial
result = sl_spacial(erey, flg, clf, vsis, rot, sxy)
******* ********** **** *** *** **** *** *** ** spacial view for scan. ** ------- ---- --- ----
Parameters
- erey
- flg
- clf
- vsis
- rot
- sxy
top sl_savarea
result = sl_savarea(cd, erey, fcg, xsiz, windn, icon, icon_z)
******* ********** ** **** *** **** ***** **** ****** **
Parameters
- cd
- erey
- fcg
- xsiz
- windn
- icon
- icon_z
top sl_resarea
result = sl_resarea(cd, erey, xsiz, fdl, fl, filename)
******* ********** ** **** **** *** ** ******** **
Parameters
- cd
- erey
- xsiz
- fdl
- fl
- filename
top sl_break
result = sl_break(DATA, VSIZ, CURIJK, ARES, ARES_Z)
******* ******** **** **** ****** **** ****** ** ** on_error,0
Parameters
- DATA
- VSIZ
- CURIJK
- ARES
- ARES_Z
top sl_insert
result = sl_insert(w, in_are, vsiz, pcur)
******* ********* * ****** **** **** ** **Call an external function. **
Parameters
- w
- in_are
- vsiz
- pcur
top sl_dislog
result = sl_dislog(are, are_z, vxl, vxm)
******* ********* **
Parameters
- are
- are_z
- vxl
- vxm
top sl_surf
result = sl_surf(scl, erey, vsx, vsy, vsz, typ, plx, ply, miv, mxv, az, ax, lev, flg, bg, smo)
******* ******* *** **** *** *** *** *** *** *** *** *** ** ** *** *** ** *** ** ** Tranform an image to a surface video ** ******** ** ***** ** * ******* ***** **
Parameters
- scl
- erey
- vsx
- vsy
- vsz
- typ
- plx
- ply
- miv
- mxv
- az
- ax
- lev
- flg
- bg
- smo
top sl_rotfun
result = sl_rotfun(flg, w, flp, flpb, erey, vsx, vsy, vsz, typ, az, ax, smo, x1, x2, y1, y2)
******* ********* *** * *** **** **** *** *** *** *** ** ** *** ** ** ** ** **
Parameters
- flg
- w
- flp
- flpb
- erey
- vsx
- vsy
- vsz
- typ
- az
- ax
- smo
- x1
- x2
- y1
- y2
top sl_views
result = sl_views(erey, windn, ttl, c_c, l_c, sp_c, f_c, fcs, vsiz)
******* ******** **** ***** *** ******************** **** ** ** Or just an image for Loafers. ** -- ---- -- ----- --- ------- **
Parameters
- erey
- windn
- ttl
- c_c
- l_c
- sp_c
- f_c
- fcs
- vsiz
top provw1
provw1, erey, kf, w_co, windn, baseview
** ****** **
Parameters
- erey
- kf
- w_co
- windn
- baseview
top sl_region
sl_region, c, l, a, b, d, e, ifu, jfu, vsiz
** *********
Parameters
- c
- l
- a
- b
- d
- e
- ifu
- jfu
- vsiz
top sl_slice
result = sl_slice(erey, vsiz, c, l, f1, f2, bxy6, bxy7, flg, f_sa)
******* ********
Parameters
- erey
- vsiz
- c
- l
- f1
- f2
- bxy6
- bxy7
- flg
- f_sa
top sl_ellipos
result = sl_ellipos(erey, vsiz, cx, cy, cf, f_fg, f_el, rad, ccx, ccy)
******* ********** **
Parameters
- erey
- vsiz
- cx
- cy
- cf
- f_fg
- f_el
- rad
- ccx
- ccy
top sl_funn
result = sl_funn(jf, erey, vsiz, c, l, f, k_bx, k_by, explv)
******* ******* ** **** **** ***** **** **** ***** ** ** quick around representation. ** ----- ------ -------------- **
Parameters
- jf
- erey
- vsiz
- c
- l
- f
- k_bx
- k_by
- explv
top sl_hardc
result = sl_hardc(sx, sy, num, spt, spm, erey, vsiz, windn, fhd, nocol, lga)
******* ******** ** copy current view. (!!!! tvpix !!!!) ** **** ******* **** carez
Parameters
- sx
- sy
- num
- spt
- spm
- erey
- vsiz
- windn
- fhd
- nocol
- lga
top sl_curset
result = sl_curset(exspc, exsi, exsj, fxy, nnz)
******* ********* **
Parameters
- exspc
- exsi
- exsj
- fxy
- nnz
top sl_working
result = sl_working(inc, ttl, flg, exp)
******* ********** **
Parameters
- inc
- ttl
- flg
- exp
top sl_magang
result = sl_magang(b6, b7, c0, c1, rsm, rsl, vta, vtm)
******* ********* **
Parameters
- b6
- b7
- c0
- c1
- rsm
- rsl
- vta
- vtm
top sl_pan
sl_pan, px, py, pz, cc, lc, fcl, fcg, vsiz, flg
** ****** **
Parameters
- px
- py
- pz
- cc
- lc
- fcl
- fcg
- vsiz
- flg
top sl_rad_lu
result = sl_rad_lu(area, vsiz, nf, cti, ctj, ry1, ry2, a1, a2, arel)
******* ********* **
Parameters
- area
- vsiz
- nf
- cti
- ctj
- ry1
- ry2
- a1
- a2
- arel
top sl_viewr
result = sl_viewr(erey, xsiz, windn, recurs)
******* ******** **** **** ***** ****** ** ** Get more from the view. ** --- ---- ---- --- ---- **
Parameters
- erey
- xsiz
- windn
- recurs
top sl_viewer
result = sl_viewer(erey, windn, vsiz, flg)
******* ********* **** ***** **** *** ** ** Entry allowing context change. ** ----- -------- ------- ------ **
Parameters
- erey
- windn
- vsiz
- flg
top sl_opview
result = sl_opview(erey, vsiz, w_1, w_2, oprt, flg)
******* ********* ** ** Views operations. 2:+ 3:- 4:* 5:| 6:# ** ----- ---------- - - - - -
Parameters
- erey
- vsiz
- w_1
- w_2
- oprt
- flg
top sl_lampscan
sl_lampscan, flg, p1, p2, p3, p4, fname
** *********** ** ** tv_flg(8) = true tv_x ** tv_flg(9) = true tv_y ** tv_flg(10) = tv_w ** ** tv_flg(11) = new tv_x ** tv_flg(12) = new tv_y ** tv_flg(13) = new tv_w ** ** tv_flg(14) = base for views or 0 if root ** tv_flg(15) = base of Lamp **
Parameters
- flg
- p1
- p2
- p3
- p4
- fname
File attributes
Modification date: | Tue Oct 1 14:35:35 2013 |
Lines: | 22,844 |