Category : C Source Code
Archive   : JJBQC.ZIP
Filename : JJBREAD.ME

--------------------------------------------------------------------
JJBREAD.ME
--------------------------------------------------------------------


Anyone may use JJB without cost or obligation. It is a professional
product which places the 'C' programmer in a high-level coding
environment at the same time providing low-level control over your
program. Every two or three months, new software will become
available from JJB.

jjb



*****************************************************************************
* version 1.0 *
* *
* *
* JJB *
* *
* for Quick C and Turbo C programmers *
* *
* JJB is the first in a series of software which allow the C programmer *
* to write programs in minutes instead of taking days or even weeks. *
* *
* from *
* *
* JJB *
* 9236 Church Rd, Suite 1082 *
* Dallas, Tx 75231 *
* (214) 341-1635 *
* *
* *
* JJB may be freely copied, used and circulated without cost or obligation. *
* *
* Copyright (c) 1989, JJB Dallas, Tx. *
* Quick C is a trademark of Microsoft Corp. *
* Turbo C is a trademark of Borland. *
*****************************************************************************


What is JJB ?

JJB is an environment the C programmer can use to program any
application:


-JJB allows you to program fast.

-JJB handles routine tasks such option selection, input, etc.

-JJB gives your program a professional appearance.

-JJB provides you with both high-level and low-level control.

-JJB runs on all IBM PC, XT, AT 286, 386 and compatible computers,
on all MONOCHROME, CGA, EGA, and VGA controllers.





--------------------------------
first in a series
--------------------------------

JJB is the first in a series of software which enable the programmer
to become more efficient at the same time giving the programmer more
high-level and low-level control.


This version of JJB is for all Quick C programmers.



--------------------------------
JJB handles option selection
--------------------------------

The heart of JJB is its ability to monitor every keypress in your
program. No matter where you are in your program, you can press 'ALT'
and select any option. JJB handles changing options.

You can define options and assign function names to them.

Each option can be initalized and exited with a function.

Options can be grouped together.


JJB gives you more control over your program.


JJB provides you with necessary low-level functions you need to get
started. JJB also has high-level functions you can use so you do
not have to concern yourself with the details.



*******************************************************************
* *
* JJB runs on all IBM PC, XT, AT 286, 386 and compatible computers*
* and on all MONOCHROME, CGA, EGA, and VGA controllers. *
* *
*******************************************************************


The JJB functions run on all IBM PC, XT, AT 286, 386 and compatible
computers and on all video controllers. JJB is designed so that
the software you write today, will run on computers of the future
such as the 386 and etc.


JJB functions were written to conserve as much memory as possible.
Only the basic necessary functions are placed in JJB.OBJ. Other
optional functions are placed in object modules which can be linked.
Plus, these other functions are completely documented in the printed
documentation in case you need to change something.



--------------------------------
100% control over keyboard
--------------------------------

JJB gives you absolute 100% control over the keyboard. The header
file 'JJBKBD.H' provides you with definitions you can use to test
for any key on the keyboard.

The niece thing about JJB is that you do not have to use them.
JJB does all the low-level keyboard testing for you. There is even a
function which lets you simulate user keypresses from inside your
program.



--------------------------------
video fast 'vf'
--------------------------------

JJB gives you complete control over video. The 'vf' functions
are designed for speed, portability, flexiblity, and ease of use.

For example: vloc(4,10);
vfs("Video fast this string");

The above example places a string into direct memory access at row 4,
column 10. The 'vf' functions give you speed and control over what you
want videoed and how you want it to look on the monitor.


--------------------------------
input & enter
--------------------------------

The 'input' and 'enter' functions allow you to design input screens
which have a professional appearance. An entire input screen can be
programmed in less than 10 minutes, and these functions even have the
ability to edit for input ranges of numbers.


The 'input' and 'enter' functions have been designed so that you can
create you own 'enter' functions.



--------------------------------
printed documentation
--------------------------------

A printed manual is available from JJB for #35. Anyone may order it
and it will be shipped the next day.

The printed manual documents in detail over 80 hidden functions.
The hidden functions provide you with a very tight and powerful set
of routines.

The functions were written to be appreciated by the advanced programmer
who requires tight, fast and portable code. But they can also be used
by the beginning programmer who needs a simple and easy way to program.



--------------------------------
JJB hidden library
--------------------------------

The object file JJB.OBJ contains the hidden library. To conserve memory,
it was compiled using only two include files:

#include
#include

Any of the functions in the library can be used after you use the
function jjb_initalize() in your program . There are undoubtly some
very good programmers out there who will figure out how to look at the
file and get some of the function names without having the manual. A
hint is that all of the fast direct memory access functions begin
with 'v', and 'vf' stands for video fast.


------------------------ hidden library includes ---------------------

A comprehensive set of video fast functions which
runs on all IBM PC, XT, AT 286,386 and compatible computers
and on all MONOCHROME, CGA, EGA, and VGA controllers.
A complete set of keyboard, input, and enter functions including the
ability of simulate keypresses from inside your program.
Extremely high speed windowing ability and many more features which
every programmer needs in order to efficiently produce programs.

The printed documentation of the hidden library throughly explains what
each function does and gives you many examples of how to use them.

----------------------------------------------------------------------


--------------------------------
future JJB software
--------------------------------

JJB S&W (Strings & Windows) will be available in the spring of 1989.

JJB LA (Large Application) is the third in the JJB series and is
scheduled for release in the summer of 1989.

Also in 1989 will be released 'JJB IO' (input and output for DOS).
This software will allow you to easily create and update large data bases
and be able to access any record in a fraction of a second.




--------------------------------
GETTING STARTED WITH JJB
--------------------------------


If you have the JJB files on floppy diskette and you have
Quick C from Microsoft Corporation, you can begin using JJB.


Place the diskette with the JJB files in drive a: and:


enter 'JJBATOC' to copy all JJB files to c:\bin

enter 'JJBGO' to create the JJB.QLB (quick library)


In order to write programs, you need to create the JJB quick
library 'JJB.QLB'. The .bat file 'JJBGO.BAT' does this for you.
It requires you have QUICKLIB.OBJ on drive c:\lib. If so, it will
create the JJB quick library 'JJB.QLB'.


This version of JJB is for Quick C. Turbo C will soon be released.

Once you have created the JJB quick library, you can compile and
execute source files JJBSHOW1.C thru JJBSHOW5.C. These files are
examples of how to use JJB when you begin writing programs.


Remember, the concept of JJB is to provide you with an environment
in which you can write programs 'FAST'. Therefore, the JJB functions
are designed for high-level programming while at the same time giving
you low-level control over your program.


JJBSHOW5.C is a good example of this. This example shows you how you
can write an entire input screen. While entering data, the user of
your program can use the UP or DOWN ARROWS going to any input line on
the screen.


While entering any data, the user can also press 'ALT' and select
any option in your program. If another option is selected, JJB will
leave the current option and execute the new one.


Let's look at the first example of JJB 'JJBSHOW1.C'.


To begin, from DOS enter: 'JJBS1'.

You should now be in Quick C looking at 'JJBSHOW1.C'.

If you have any problems, see the 'problems' section below.



--------------------------------
JJB files
--------------------------------

JJBREAD.ME ( this file )
JJBATOC.BAT ( copies all JJB files from drive a: to c:\bin )
JJBGO.BAT ( creates the JJB quick library 'JJB.QLB' )

JJBGLOSS.DOC ( glossary of JJB functions )

JJB.EXE ( a JJB demo )

JJB.OBJ ( the JJB object file )
JJBINPUT.OBJ ( the object file for input & enter functions)
JJBDOLLR.OBJ ( the object file for input dollar functions )

JJB.QLB ( the JJB quick library created with JJBGO.BAT)

JJBKBD.H ( keyboard definitions plus documentation )
JJBSET.H ( get( & set( definitions and documentation)



JJBSHOW1.C ( examples of how to begin using JJB )
JJBSHOW2.C ( examples of how to begin using JJB )
JJBSHOW3.C ( examples of how to begin using JJB )
JJBSHOW4.C ( examples of how to begin using JJB )
JJBSHOW5.C ( examples of how to begin using JJB )

JJBS1.BAT ( use to enter Quick C and load JJBSHOW1.C )
JJBS2.BAT ( use to enter Quick C and load JJBSHOW2.C )
JJBS3.BAT ( use to enter Quick C and load JJBSHOW3.C )
JJBS4.BAT ( use to enter Quick C and load JJBSHOW4.C )
JJBS5.BAT ( use to enter Quick C and load JJBSHOW5.C )


--------------------------------
JJB demo
--------------------------------

The file JJB.EXE is a JJB demo. It is not really a demo because JJB
is an environment to use and is not an end product in itself.

From DOS enter 'JJB' and you will get some idea of how your pull-down
menus will look if you use JJB to write your program. The demo also
shows you its tremendous speed and powerful set of functions.



--------------------------------
problems
--------------------------------

This section trys to clear up problems you may have loading or executing
the JJBSHOW source files.


All the files in this version use Quick C from Microsoft Corp. If you
do not have Quick C, you can not complile and execute. You can, however,
run 'JJB.EXE' by entering 'JJB' from DOS.


The bat file JJBATOC.BAT assumes you have a hard disk in drive c:.
If not, move the JJB files to the Quick C subdirectory \bin.
For example: a:>copy jjb*.* b:\bin


The bat file JJBGO.BAT assumes the file QUICKLIB.OBJ is in the Quick C
subdirectory '\lib'. If not, change the bat file so that it is
referencing the proper subdirectory where it can find the Quick C
object library.


Entering 'qc jjbshow1.c' will not work.

You need to include the JJB quick library as follows from DOS:


QC /l JJB.QLB JJBSHOW1.C


The bat file 'JJBS1.BAT' does this. Enter 'JJBS1' from DOS.


--------------------------------------------------------------------
end of file: JJBREAD.ME
--------------------------------------------------------------------