Now that we can change the number of rows supported in the emulator, is there a TCRT or ESC sequence to do it on the fly? (I might be inclined to support it within A-Shell via SET.LIT and/or TAB commands if so.)

Jack,

The AM65.M68 source code uses
-5, <42 or greater> to set 42 rows per screen
and -5, to reset back to 24 lines
per screen.

I.E. Print tab(-5,100); ! produces 42 lines per screen

Print tab(-5,24); ! produces 24 lines per screen.
Remember this is for the AM65 terminal
If there are true variable rows, then one could
do a -5,32 for 32 rows -5, 50 for 50 rows and
so on.

I have used this in many programs that support long screens.
Also be sure and set the TD$VCR flag for TRMCHR
to indicate that it supports variable row count.

Later
JAJIV

An existing standard is PRINT TAB(-5,rows). The terminal or terminal driver should select a number of rows equal to or larger than the number of requested rows, or set it as high as possible.

I have a WYSE60 TDV that selects between 24, 25, 42 and 43 rows.

I looked at the AM65 TDV and it has two escape sequences:

ESC e * for 42 line mode (actuallly 44 lines total)

and

ESC e ) for 24 line mode (actually 26 lines)

I'll implement these in the AM65/AM75 drivers for compatibility but will add a special escape to all the terminal drivers to set the actual number of rows since the ESC e stuff is pretty useless due to the stupid way Alpha Micro implemented it.

Rod

Thanks guys for all the feedback. I'm still a bit confused, though, over the following:

Which document or other reference should we all agree on as "the" standard for this kind of information? I'm looking at the AMOS Terminal Systems User Guide, for example, and there is no mention of TAB(-5,x) or TD$VCR.

What is the recommendation for a Basic programmer who wants to detect the extent of the variable row capability of the terminal? Is it a matter of first testing TD$VCR, and if set, then using TAB(-5,x) to attempt to set the screen height to x rows, and then using XCALL TRMCHR to see how many rows were actually set? That might not be so bad if the intent was simply to go for the maximum rows possible, but it could get rather messy if the goal is to go for some specific number, like 35 or 45, due to the trial and error involved.

Rod, do you have a suggestion for how one would access your new ESC sequence that allows setting a specific row count? As you suggest, we can't very well use the existing TAB(-5,x) because that would then be incompatible with real AM65's, AM75's, and other emulators thereof. I would be happy to add another XCALL MIAMEX function which could detect if ZTERM was running, set the desired number of rows, and return a status indicating if it succeeded, although besides being somewhat non-standard, it would also require that you return some kind of indicator (similar to the scheme with other "developer escape sequences") so we would know if the command succeeded, or alternately what the range of rows available was.

Jack,

TD$VRC is defined in MAC:SYSSYM.M68 as octal 400000000.

IMHO - I don't see any problem with using the PRINT TAB(-5,x). All AMOS terminal that support variable rows use it and in some cases is already programmed in some basic programs (mine).

If one was to do a ? TAB(-5,50); expecting 50 lines per screen, one would check XCALL TRMCHR after the PRINT TAB(-5,50); to see what the actual rows per screen were. That is how I program it. An Am65 supports 42 while the WYSE60 supports 42 and 43 rows.
Just check XCALL TRMCHR after the PRINT TAB(-5,ROWS); to see what the driver set the rows to.
Therefore depending on which OS you were using, the TI.ROW(OFFSET) in the driver impure area would have to be reset as it is on AMOS using drivers and terminals that support variable rows.
Properly written Basic programs (and or Assembly language programs on AMOS) would utilize this sequence to check for number of rows and columns a terminal supports and then utilize the area available.

This would work on all OS's and would work with
real terminals and terminal emulators.

Just a suggestion.

JAJIV

That's all fine, except I'm not sure how to update the A-Shell terminal drivers for the new variable row ESC sequence (yet to be implemented by Rod), since a single copy of a particular driver may be used by devices with ZTERM and also by real AM65 terminal (or other emulators).

I guess it's just a matter of A-Shell having to detect that the device is in fact ZTERM, in which case TD$VRC will be set and TAB(-5,x) will use the truly variable-row ESC sequence. If the device is not ZTERM, then TD$VRC would only be set for AM65/AM75 and TAB(-5,x) would use the existing ESC sequences.

On the AMOS side, I guess the requirement would be to use one of the drivers Rod supplies if one wanted to take advantage of the capability.

Jack,

Yes - Rod's ZTERM.M68 could be easily modified
to support the extended (-5,x). That is what I fully expect to do to the source when the new feature is available.

On a real AM65 terminal on AMOS, I would use the AM65.TDV
On a ZTERM emulated AM65 I would use an AM65ZT.TDV which would be modified to take advantage of the new fully variable row feature.
I would let the TDV take care of everything and
just check XCALL TRMCHR after the (-5,x);

SWB actually uses the AMOS Terminal.TDV on UNIX'es so I would just have to move the new .TDV to the Unix/Linux box.

I suppose on ASHELL, one could use MIAMI.INI to set the proper driver based on your selection.

Then Once again, I have a program that does
a ? TAB(-1,80) ! 132 column mode and then
a ? TAB(-1,44) ! 44 rows on an AM65.

With my eyesite and age I can't read the screen since the text is so small at that setting, so I actually never use that feature anymore.

Just a suggestion.
JAJIV

Any suggestion on how I should detect within A-Shell, on a job-by-job basis, whether the copy of ZTERM on the workstation supports variable rows? It's all very nice to use trial and error - attempting to set the desired number of rows and then call TRMCHR to find out what you got, but that depends on the driver knowing the capabilities of the particular release of the emulator.

I don't especially relish the prospect of making a separate "Z" version of every driver for the new capability, so I guess in the absence of any better suggestions, I'll plan on adding a SET TERM MAXROWS ## option to SET.LIT. That would allow each workstation to independently indicate not only whether they could support VRC, but whether and to what extent they wanted to.

Do the ESC ? four times trick and you'll get back the build number. If the build number is >= 143 then the terminal has variable row support.

That said, build 144 is the first version where you can set the row count from the host, so you probably want to look for that one.

Rod

I am using the esc ? sequence including a modified version if the trmdvr is WY works okay.

But am constatly checking the coolstf website for version 144 so I can get my hands on host changable screen length.

thanks

It'll be sometime next week when build 144 gets released. I'll post on this forum once it gets released.

Rod

I've just gotten another inquiry about this issue.

Did anyone ever generate a modified AM75 or ZTERM driver (for AMOS) that supports TAB(-5,rows) and the full range of rows? (It might have even been me, but if so, I can't remember it and can't find it.) If anyone has the TDV or M68 for such a driver, and would like to share it, it would definitely be worth a gold star.

Otherwise I may need to dust off my old assembler manual and engage a witch doctor to raise my decomposing AM2000 from the grave in order modify the driver myself.

Note that A-Shell has supported the feature via the embedded AM75Z terminal driver since at least 5.0. And ATE supports it in any of the "Z" or "G" emulations.

Enzo has been kind enough to make the necessary modification to the AM75 driver to support true variable rows using TAB(-5,rows) (where rows may range from 24 to 50).

The driver has been posted here: am75xz.tdv

The "x" is to indicate all the extensions, i.e. 8 bit and graphics, and the "z" is to indicate support for the ZTERM-specific "true" variable rows (as opposed to merely supporting 24 and 50 rows as the normal AM75 does).

Also note that A-Shell supports true variable rows (ranging from 1 to 50, or to the limit of the terminal device) in all of the following cases:

- A-Shell/Windows (local)

- A-Shell/UNIX or Windows/ATSD with a ZTERM (version 144+) client in AM75 emulation (provided the TERM environment variable is set to "AM75Z")

Note that in the case of Windows/ATSD, you may need to use SET TERMINAL DRIVER AM75Z (or XCALL MIAMEX, MX_SETENV , "TERM=AM75Z") after connecting in order to update the terminal setting, since there is no way to establish the TERM environment variable before launching A-Shell, as there is under UNIX.)

- A-Shell/UNIX or Windows/ATSD with an ATE client in AM75G, AM65G or AM62CG emulation.