Media Share 9/MEDIASHARE_09.ISO/os2/row2r01.zip/USER.DOC

Text File | 1993-06-27 | 18KB | 399 lines

Documentation for Row.Exe. Last revision is 06-24-1993 for version 2.x.
Produced by Patrick T. Wolfert, (c) Copyright 1993. All Rights Reserved.




What is Row?

Row.Exe is a program which may be executed from the DOS Config.Sys file as
a device driver or from the DOS Command prompt or from the OS/2 Cmd prompt or
from an OS/2 Config.Sys Call statement as a standard executable file to
change the number of rows currently being displayed by either a text mode
display adapter or a graphics mode windowed session on either a color or
monochrome monitor. The operating system, presence of a presentation manager,
and the display adapter define the various possibilities with respect to the
number of rows that can be displayed by a particular system or session.



Why use Row?

Use Row when you want to change the number of text rows being displayed on
your computer's monitor if it's in text mode or the number of rows which can
be displayed by a OS/2 virtual DOS session or Cmd session. For DOS you may
set the rows to either 50, 43, 28, 25, 21, 14, or 12 rows with or without
clearing the screen. OS/2 will accept a number from between 1 and 255 rows
inclusive but the valid mode settings vary with the presence of the
presentation manager as the protected mode shell and if a full-screen session
is being used and the graphics adapter in use.

You may want to change the rows being displayed for a whole host of reasons:
        1. Reduce eye strain.
        2. Prevent DOS Config.sys initialization messages from scrolling off
           of the screen before they can be read; This is the reason why
           I wrote the device driver part of the program which came first.
        3. Confuse network snooper programs which transmit an image of the
           screen back to another node on the network, with or without the
           knowledge of the person whose screen is being viewed. The NetBIOS
           snooper program at an office where I have worked tosses cookies
           to the viewer for any number of rows other than 25.
        4. Setting up nice looking small OS/2 2.x virtual DOS windowed
           sessions without having any scroll bars around to muck them up.
        5. Setting up nice looking large OS/2 2.x Cmd windowed sessions
           without having any scroll bars around to muck them up.
        6. You want to see more of that spreadsheet you have been working
           on but even just the thought of that 132 column mode and it's
           tiny characters makes your eyes cross and the slow performance
           of the WYSIWYG mode just plain makes you cross.
        7. Same as 6 but the 132 column mode is not supported or does not
           look nice in some graphical environment you are working in.
        ...




What is Row compatible with?

Row for DOS requires that the host computer have a VGA adapter and a BIOS
which supports the basic VGA functions of setting the scan lines, mode,
and font. Row has an option which disables VGA detection for those video
adapters such as the EGA which are capable of some of the modes and which
should be able to run the screen in 43 or 21 rows just fine.

Row for OS/2 only requires that the operating system be present. The OS and
the underlying hardware determine how many rows from 1 through 255 can be
displayed in the current context of the request.

Row has been tested with MS DOS 3.2, IBM DOS 3.3, IBM DOS 4.01, IBM DOS 5.0,
IBM OS/2 2.0 GA using a DOS Window or a Virtual DOS Machine, and IBM OS/2
2.0 GA Cmd.Exe sessions and has been found to work in all cases either when
loaded as a device driver or when invoked from the Command or Cmd prompt
except for MS DOS 3.2 in which Row does not work as a device driver. For OS/2
Row may also be executed from Config.Sys through a Call statement but since
programs invoked in this way execute after all other Config.Sys processing is
complete chances are that putting Row in the OS/2 Config.Sys will be useless.

Row has been tested on both ISA and EISA based PCs having either a Diamond
Stealth VRAM, or an Orchid ProDesigner VGA graphics adapter.

Row for DOS has been tested (and developed) under QuarterDeck's DesqView
which does not toss any cookies but which may or may not change the mode
depending on how DV and it's windows are set up and the position of the sun.

It has not been tested under MicroSoft Windows at all.

Row's machine code is compiled for the 8086 meaning that it will run on any
80x86 processor based computer (running DOS or OS/2).




DOS compatibility notes:

Versions of DOS previous to version 5 do not detect the number of rows on the
screen dynamically when programs such as Dir /p or More need to know when to
pause. DOS 3.3 for example seems to always think that there are only 25 rows
no matter how many or few there really are on the screen. IBM DOS 5 processes
Dir /p and More correctly no matter how many rows are set.

The device driver and executable format should be good for DOS 2 and up but
I have read that some versions of DOS 2 do not have the executable file loader
present at the time Config.Sys is processed so .EXE files cannot be in
Config.Sys. My program will not work under those conditions.

For the MS DOS 3.2 version I have been testing with the protocol described
by the IBM DOS 3.3 Technical Reference to indicate that a device driver
should terminate without staying resident does not seem to work so for that
version of DOS Row may not operate as a device driver properly. Specifically,
it will not unload properly. I do not know if this is because of the specific
buggy DOS 3.2 I have or if it's a general property for DOS versions below 3.3.

Do not exepack Row.Exe and expect for it to still function as a device driver;
The OS/2 part of Row will probably stop working correctly also.




OS/2 2.x virtual DOS compatibility notes:

Row.Exe works in any regular OS/2 DOS Command windowed or full screen
session or any windowed or full screen session of a Virtual DOS Machine. I
have tested only VDM's booted from image files but have tested images of
DOS 3.2 through DOS 5.0. All DOS versions from 3.3+ allow Row to be used in
any command invocation. Row makes nice 14 row DOS windows which can be
maximized and then have a small font applied to them yielding a scroll bar
free window of a small height stretching across the screen. I find it quite
useful for those commands which might require it.




OS/2 2.x protected mode compatibility notes:

Row.Exe operates in any OS/2 2.x windowed or full screen Cmd session; The
programming API used is for OS/2 1.2 so this program may also work for OS/2
1.2+ windowed and full screen Cmd sessions but has not been tested as to
whether it will work or as to which row settings will be available.

For a VGA OS/2 2.0 GA presentation manager windowed session the row settings
OS/2 does not balk at are from 1 through 102 inclusive. For a full screen
session under presentation manager the following settings were possible: 24,
25, 27, 28, 45, 46, 47, 48, 49, and 50 rows. A full screen session of Cmd.Exe
running directly as the protected mode shell was only capable of setting 25
rows on the display at a time. When called through the Config.Sys Call
statement Row was capable of setting the text mode screen to both 25 and 50
rows which is all that was tested.




The Disclaimer:

This software carries absolutely no warranty whatsoever, this program
works on the author's system and is not guaranteed to work on anyone
else's system. The owner/author, Patrick T. Wolfert, will not be held
liable for any damages caused by this program to any system.  If you are
in doubt as to this program's suitability for your computer system then
simply do not run it!




The License:

This program is not free, it is distributed as shareware, meaning that
you are encouraged to try it out on your own system and to pass it along
to as many others as you would like to, but that after a reasonable trial
period, not to exceed one month of use you are required to pay for it's
continued use.

Payment is ten dollars ($10) per computer which will have it's screen rows
modified by Row payable in United States currency/check/MO, etc...

Please remit to:
        Patrick T. Wolfert
        580 Main Street, Suite 1320
        New York, N.Y., 10044

Multiple computer licensing information is available upon request.

Registered users of Row will recieve the latest edition of the program and
documentation files on diskette as well as a laser printed typeset edition
of the user documentation if desired and your address is supplied; Registered

Any license granted applies to all past, present, and future editions of Row.




Instructions:

Row for DOS (Row/D) may be loaded from either the Config.Sys file or from the
Command prompt. Row requires no resident memory; Loading as a device driver
is simply a convenience to prevent messages from scrolling off of the screens
of those computer systems which process many programs within their Config.Sys
and Autoexec.Bat files.

Row for OS/2 (Row/2) is executable from either a Config.Sys Call statement at
system startup time or from the Cmd prompt at any time.

Row may also be executed from other programs; LoadHi /GS for DOS indicates
that 9K run-time bytes of memory are used by Row/D 2.01.

Row will always display a message indicating it's processing status.

The version numbers displayed by Row/D and Row/2 may be different since
Row.Exe is really two separate executable programs combined into one; The
operating system loads Row.Exe and executes the appropriate part of it.

To invoke Row from your DOS or OS/2 Config.Sys file add a line consisting of
the following anywhere in the file where you want the screen rows to change:
(Note:OS/2 executes Call statements after all other Config processing is done)

        DEVICE=[d:][path]Row.Exe [options]          <== Use this for DOS

                      -or-

        CALL=[d:][path]Row.Exe [options]            <== Use this for OS/2

Replace the [d:] with an optional drive specification, the [path] with an
optional path specification and [options] with any options you may wish to
pass to Row to modify it's execution. Do not place the Row invocation in
between any device commands or call statments which must load consecutively.

To invoke Row from the DOS Command or OS/2 Cmd prompt type the following:

        [d:][path]Row [options]

Replace the [d:] with an optional drive specification, the [path] with
an optional path specification and [options] with any options you may
wish to pass to Row to modify it's execution.




Options available to modify the operation of Row/D for DOS:

Options to Row/D are typed after it's invocation. Options are not case
sensitive and consist of a row count or short word or abbreviation.
Options may be typed in any order; If multiple conflicting options are
present then only the last applicable one is used since it's values
will overwrite any set by previous options.

Option          Function
?               Row does nothing but display a quick syntax message.
50              Row will set the adapter to display 50 rows.
                This is the default number of screen rows.
43              Row will set the adapter to display 43 rows.
28              Row will set the adapter to display 28 rows.
25              Row will set the adapter to display 25 VGA rows.
25V             Row will set the adapter to display 25 VGA rows.
25E             Row will set the adapter to display 25 EGA rows.
25C             Row will set the adapter to display 25 CGA rows.
21              Row will set the adapter to display 21 rows.
14              Row will set the adapter to display 14 rows.
12              Row will set the adapter to display 12 rows.
NoCls           Row will not clear the screen.
                This is the default for screen clearing.
Cls             Row will clear the screen and 'home' the cursor.
+               Enable VGA detect. This is the default.
-               Disable VGA detect.
               *Results are undefined for non-VGA adapters.

N and C may be used in place of NoCls and Cls respectively.




Options available to modify the operation of Row/2 for OS/2:

Options to Row/2 are typed after it's invocation. Options are not case
sensitive and consist of a row count or short word or abbreviation.
Options may be typed in any order; If multiple conflicting options are
present then only the last applicable one is used since it's values
will overwrite any set by previous options.

Option          Function
?               Row does nothing but display a quick syntax message.
[rows]          Place the number of rows you wish for the session to have
                here. The default is 50 rows. OS/2 allows 1<=rows<=255.
NoCls           Row will not clear the screen.
                This is the default for screen clearing.
Cls             Row will clear the screen and 'home' the cursor.

N and C may be used in place of NoCls and Cls respectively.




Examples for DOS and OS/2 follow:

Device=c:\util\Row.exe              Change rows to 50 without clearing.
Device=c:\util\Row.exe Cls 28       Change rows to 28, clear screen.
Row ?                               Display a help message only.
Row n 21                            Change to 21 rows, no screen clear.
Row 43 -                            Display 43 rows, no screen clear,
                                    disable VGA detection. For DOS only.




Usage notes:

Since I do not have a monochrome VGA monitor to test this program with the
monochrome code for Row/D is untested at this time. If you use this program
with a monochrome VGA please let me know how it turns out. The differences
for monochrome are that screen mode 7 is used instead of mode 3 and the
program message colors are plain white. No video card I tested this with was
capable of emulating monochrome so that my program (or any other for that
matter) could detect it properly.

If you are using a display page other than page zero as the active page
the Row/D will probably reset the screen to page zero as the active
page. I do not know this for sure and have not tested it under this
condition.

Row/D may be invoked from the DOS_DEVICE DOS setting of an OS/2 DOS session.
Do not place the DEVICE= statement in the DOS_DEVICE setting, just use the
Row.Exe invocation.

The difference between the Row/D CGA, EGA, and VGA 25 row modes is the number
of scan lines put on the screen. Each is visibly different in VGA text mode.




Author's notes:

The Row/D program is written in 8086 Assembler. It was assembled using
XASM, The Brand X Assembler by Access, a very good assembler compatible
with MASM, so compatible it probably could never be released.
Thank-you to whoever wrote it!

The Row/2 program is written in C for the Microsoft C Compiler version 6.00AX
using OS/2 as the target operating system.

The program requires about 9K of memory and switches to an internal stack
for both DOS device driver and DOS EXEC execution. For OS/2 the C startup
code handles the program's stack. Row/D is the stub of Row/2.

In May of 1991 I typed in a debug script from what I think was PC Magazine.
In a letter to the editor there was a small 21 byte COM file (in a debug
script) which set the screen to 28 rows. I thought that it was pretty cool
and learned more about the video services by using Debug to unassemble the
bytes in the script. While learning about the video services I saw that other
row counts were possible. In December 1992 after getting a new video adapter
I made a 50 row version of the 21 byte file which got me wondering if the
mode switch could be done in Config.Sys so that I would not miss any messages
output by programs starting up there or in Autoexec. Recently I had some time
to do this and so VgaRow was born. It was started on May 15, 1993, some hours
later the first device driver version gave my screen 50 rows. Quarterdeck's
Device program was very useful since I could test my program in a Desqview
window without having to reboot my computer every time the program freaked
out (developing device drivers tend to do that). After the program was stable
I decided to make an .EXE out of the .SYS version which would load both ways
and operate using the same syntax. The program grew to many times the size of
the original .SYS version but added many features such as picking the rows
and screen clearing options. Now it probably takes less space than two separate
executable files would take.

After writing a new program like VgaRow but in C and targeted for OS/2 I
wanted to combine the two into one executable program if possible and also
fix the lack of screen scrolling in certain conditions in the DOS version
which is handled more pleasently in the OS/2 version. More specifically the
screen is scrolled up an appropriate number of rows if the new screen will
have less rows displayed on it. The new, combined executable file for DOS and
OS/2 is called Row.Exe.

The first edition to be released is VgaRow.Exe version 1.21 of May 21, 1993.
The second edition to be released is Row.Exe version 2.01 for DOS and 2.10
for OS/2 of June 23, 1993.




Questions, Comments, Suggestions, or Criticisms?

They are all welcome, send them to me at:
        Patrick T. Wolfert
        580 Main Street, Suite 1320
        New York, N.Y., 10044

Hopefully VgaRow and now Row can help to make using your computer more
efficient and enjoyable than it otherwise would have been.




Copyrights, Trademarks, and other protections:

        Desqview is property of Quarterdeck Office Systems.
        IBM DOS is property of IBM Corporation.
        LoadHi is property of Quarterdeck Office Systems.
        MS DOS is property of MicroSoft Corporation.
        OS/2 is property of IBM Corporation.
        The VgaRow and Row programs are property of Patrick T. Wolfert.

                                   - Fini -