Conference iosg::all-in-1_v30

    The DECterm print graphics doesn't work too well (at all in fact!)
    
    The MOTIF Session Manager is far too slow - I would have thought that
    somewhere someone, could have written a ln03/vt100 > postscript
    converter.
    
    Winton

� I want to capture a load
� of screens for a spec direct from the forms library - all the 
� W/S based capture utilities are too clumsy and slow

	Winton,

	I've written several manuals that have required quite a number of screen
displays in them, and have tried several approaches (both w/s and non-w/s).
I have had no problems using the DECwindows Capture Portion of Screen; why is
this "clumsy" or "slow"?  I agree that there are some (such as UTOX) which are
not as intuitive, or take more effort -- yet the trade-off is that they can do
more things (e.g., clipping).

	What is the aversion to just using Capture Portion of Screen, and getting
a PostScript file from that?

	F

    I agree with Frank. The ALL-IN-1 screen captures in my books are taken
    with the DECwindows Print Screen program.  This doesn't take long to do
    and it's very effective.  I'm surprised GAP gave you so horrible advice
    earlier in this topic as I explained how to use Print Screen (for
    inserting graphics into a DECpresent slide) just last night.  He
    certainly forgets quickly...
    
    ;-)  Tony

    If you have an old VT240 or VT330, or something that DECslide can read
    the SIXEL map from, you can use DECslide to dump the image to SIXEL and
    use SIXTOPS to convert to PS.  I used to have some procedures that did
    this.  I'll look around if you want.  If you're in a hurry, send me
    mail at DAVID HUSSEY @ALF (MIMS::HUSSEY_D).
    
    G'luck,
    
    David

	A couple of years ago, before my days of X-Windows and screen captures,
I created a little utility to capture an FMS screen into a postscript file. You
simply called a command procedure (ALL-IN-1 subprocess) from the desired screen
(bound to a key, preferably),and a simple postscript file of about 10-20 blocks
was produced.

	A TPU procedure actually did most of the formatting. The form was
extracted from a form library (I actually passed the library name, didn't have
time to put in the smarts to search the standard libraries); the field names
and field attributes were determined from the description of the form; the field
values were then gleened from ALL-IN-1 (using GETs from the ALL-IN-1 subprocess)
and these passed to the TPU procedure to contruct the postscript.

	All field values and attributes were maintained, and, yes, scrolled
regions were handled (this was fairly tricky). The result was fairly nice, if
I do say so.

	

	Greg.

$! GEN_PSFORM.COM
$! find all .sls files in the directory and convert them to Postscript
$! graphics files.
$!
$ loop:
$ sls_file = f$search("*.SLS",1)
$ if sls_file .eqs. "" then goto fini
$ sls_file_name = f$parse(sls_file,,,"name")
$ sixtops/use=include/length=17/units=pica 'sls_file'
$ if f$type(gen_psform_loop) .nes "" then goto fini
$ goto loop
$!
$ fini:
$ exit
    

$! SIX_FRM.COM
$!
$! p1 = form to sixelize
$! p2 = output file
$!
$ if p1 .eqs. "" then exit
$ if p2 .eqs. "" then p2 = p1
$ fms/desc/display=escape/output='p2'.lis 'p1'.frm
$ if f$search("''p2'.lis") .eqs. "" then exit
$ assign/user sys$command sys$input
$ slide/nointeractive/sixel='p2' 'p2'.lis
$ purge 'p2'.*
$ exit

    $! DUMP_FLB.COM - Dump the forms in a FMS Library into the current directory
    $!  Will serve as an example jacket for the previous two procedures.
    $!
    $!	P1 - Form library
    $!	P2 - Data file containing forms to dump
    $!
    $ set noon
    $ say := write sys$output
    $ status = 1
    $ if p1 .eqs. "" then goto fini
    $ P1 = f$edit(p1,"upcase,trim")
    $ data_file = P2
    $ if P2 .nes. "" then goto got_list
    $   data_file := prtflb.dat
    $!
    $!  The following line generates a datafile containing just the form
    $!  names in the library.  Strips header and footer info from the file.
    $!  Unfortunately, don't have this procedure right now.
    $!
    $   @list_flb "''P1'" "''data_file'"
    $   if f$search("prtflb.dat") .eqs. "" then goto no_master_forms
    $ got_list:
    $!
    $ print := print
    $ delete := delete
    $ fms := fms
    $ edit := edit
    $!
    $!  For each form in the forms list, display the image.
    $! 
    $ on control_y then goto cleanup
    $ open/read/error=list_open_err list 'data_file'
    $!
    $ read_next:
    $!
    $!   Extract a form description for each form in the list and print the
    $!   result.
    $!
    $ read/error=no_more  list form_name
    $! Do whatever you will with the form.  This Example just extracts for
    $! comparison
    $ fms/library/extract 'P1'/form='form_name'
    $ if .not. $status then goto read_next
    $ goto read_next
    $!
    $!  Ran through the list.  Clean up and exit
    $!
    $ no_more:
    $       goto cleanup
    $!
    $!  Error processing.
    $!
    $ list_open_err:
    $	status = $status
    $	say "%DMPFLB-F-LSTOPN, Unable to open forms list"
    $	goto cleanup
    $ no_master_forms:
    $	say "%DMPFLB-I-NOFORM, No forms in master library"
    $!
    $! Cleanup and exit.
    $!
    $ cleanup:
    $ if f$logical("list") .nes. "" then close list
    $ if f$search("prtflb.dat") .nes. "" then delete/nolog prtflb.dat;
    $ exit status
    
    

   The attached comfile with turn a library of FMS forms into postscript
   files for DOCUMENT (or anything else). Hope it's useful. It requires
   PSART (see MLTVAX::DOCUMENT,NOTE 1162).

   It is FAR FASTER, CLEANER and device independant than the other FMS to SIXEL
   to POSTSCRIPT type stuff. It is real postscript not a dump of the sixel
   bitmap.

    (X-POSTED in FMSNOTES,DOCUMENT,DOC_GRAPHICS,ALL-IN-1)

    FMS_TO_PS.COM
----------------------------CUT HERE-------------------------------------------
$!+    
$!      � W. Davies 1992, IOSG
$!     	REQUIRES PSART - Available from MLTVAX::DOCUMENT,1126.0
$!      V1.1 to deal with SHORT SCREENS - bug in previous version
$!      meant screens less then 23 characters high were wrong.
$!-
$       ON WARNING THEN GOTO DONE
$	SET CONTROL=(T,Y)
$	FMS/DIRECT/OUT=FMS.ALL MM.FLB
$OPENDIR:
$	OPEN/READ/ERR=DONE FMS FMS.ALL
$	READ/END=DONE FMS REC
$	READ/END=DONE FMS REC
$	READ/END=DONE FMS REC
$	READ/END=DONE FMS REC
$	READ/END=DONE FMS REC
$	READ/END=DONE FMS REC
$	READ/END=DONE FMS REC
$	READ/END=DONE FMS REC
$	READ/END=DONE FMS REC
$	READ/END=DONE FMS REC
$LOOP:
$	READ/END=DONE FMS REC
$	FNAME=REC !F$PARSE(REC,,,"NAME")
$	SHOW SYMBOL FNAME
$	FMS/DESC/IMAGE  MM/FORM='FNAME /OUT='FNAME
$! BUNDLE OF NICE EDIT COMMAND
$	define/user sys$output nl: 
$	define/user sys$error  nl: 
$	Edit/Edt /Command 'FNAME'.LIS
SET NOKEYPAD
C;7(D+NL)ER2(-V)2(D+NL)BR
C;DEWI+ELI+ER(-V)DEWI+ELI+BR
C;BR+V23(D+CD+CD+CD+CD+CD+C+V)
C;BR+V23(ELBACK'|'SELADVELCUTSRI|)BR+V
C;ER-VD+NLI+80I-I+-V-V
S/|-/+-/WH
S/-|/-+/WH
EXIT
$PSART/NOALL  'fname'.LIS
$	GOTO LOOP
$DONE:
$	CLOSE FMS
$	EXIT

    I like it. The quick-and-dirty command procedure below gives users the
    possibility to print a PS dump of the current screen. The queue is
    hard-coded, a nicer way is to print via WPPRINT and eventually ask the
    user in an ARG screen for rotation and scaling parameters. When I have
    some time left I will program it.
    
    Invoke the procedure with <COMMAND DS. Ofcourse you need PSART on your
    system.
    
    Regards,
    Sjaak.
    ----------------------------------------------------------------------
$ msg=f$environment("message")
$ set message/nof/noi/nos/not
$ write oamailbox "oa print_screen screen.dmp"
$ write oamailbox "oa get oa$display = oa$_gbl_working"
$ write oamailbox "oa force"
$ @dclmailbox:
$ ff=""
$ ff[0,8]=12
$ prev_record=""
$ open /write out screen.lis
$ write out f$fao("+!80*-+")
$ open /read in screen.dmp.
$ read: read /end=read_all in record
$    tmp_record=f$edit(record,"collapse")
$    if tmp_record.nes.ff then write out f$fao("|!80AS|",record)
$    goto read
$ read_all:
$ close in
$ write out f$fao("+!80*-+")
$ close out
$ define /user sys$output nl:
$ psart screen.lis
$ define /user sys$output nl:
$ print/que=post/nonoti screen.ps /delete
$ write oamailbox "oa get oa$display = 'Screen will be printed.'"
$ @dclmailbox:
$ delete screen.dmp.,screen.lis.
$ set message 'msg'
$ exit