Dec 132017
 
New version of Winobj interface library for Borland C++. Windows, menus, formatted data entry, now supports Paradox objects with C++ classes for use with the Paradox engine.
File WINOBJ16.ZIP from The Programmer’s Corner in
Category C Source Code
New version of Winobj interface library for Borland C++. Windows, menus, formatted data entry, now supports Paradox objects with C++ classes for use with the Paradox engine.
File Name File Size Zip Size Zip Type
DEMO.CPP 20003 6061 deflated
DEMO.EXE 59736 35018 deflated
DEMO.MAK 466 283 deflated
SCR.DOC 12171 3172 deflated
SCR.EXE 58038 33438 deflated
WIN.H 6505 1665 deflated
WINCALC.HPP 589 332 deflated
WINMENU.HPP 1177 481 deflated
WINOBJ.DOC 64774 16118 deflated
WINOBJ.HPP 9807 2689 deflated
WINOBJ_S.LIB 50688 20332 deflated
WINPICK.HPP 630 326 deflated
WINTOOLS.HPP 833 374 deflated
WIN_HARD.HPP 447 266 deflated
WIN_PRN.HPP 2602 1079 deflated

Download File WINOBJ16.ZIP Here

Contents of the SCR.DOC file



LVS Windows Screen Painter

Version 1.5

May 31, 1991

by Lake View Software

Copyright (c) 1991 All Rights Reserved

Reference Manual




****************************************************************************
Purpose of the Screen Painter
****************************************************************************

The screen painter can be used to reduce the amount of coding needed
to produce professional looking data entry screens.

The screen painter was written using the LVS Windows library.

The screen painter allows you to:

- Position text and data fields any where on a 50 x 100
virtual window.

- Easily move text and fields anywhere on the window.

- Save the painted screen.

- Produce the coded to duplicate your screen in your programs.

- Produce a header file declaring the functions defined by your
screen. The header file also defines a structure for the data
in your entry fields.

- Produce additional code for users of CodeBase IV. This can
be turned on or off.

******************************************************************************
Files
******************************************************************************

SCR.EXE The main Screen Painter executable.
SCR.DOC This file.

******************************************************************************
Using the LVS Windows Screen Painter
******************************************************************************

Using the screen painter is simple and straight forward.

Designing and generating a screen requires 4 steps.

1.) Place all desired screen text in the screen painters main
window. You have a 50 row X 100 column area to work in.
You can place text by moving the cursor with the arrow
keys then typing.

2.) Place all desired input fields in the main screen painter
window. You must create fields using the Field Menu. Alt-F.
This allows you to specify the size and type of field to place
on the screen. You can also specify the name of a valid
function to be called for the field.

3.) Generate the code. In normal operation the code generated
will appear as in the example below. Additional code can
be generated for CodeBase users by turning the codebase switch
on. Ctrl-F4.

4.) Create a main function to call your generated functions.
See the example below.


******************************************************************************
Example code produced by the screen painter
******************************************************************************

Screen: painted in SCR.EXE
--------------------- TEST.SCR ----------------------------------------------

Name: [ ]

Address: [ ]

City: [ ]

State: []

Zip: [ ]

-----------------------------------------------------------------------------
Header: produced by the screen painter.
--------------------- TEST.HPP ----------------------------------------------
#include

struct TEST_data {
char Name [31];
char Address [31];
char City [16];
char State [3];
char Zip [11];
};

// Function prototypes
void TEST_screen (WinObj &w);
int TEST_get (struct TEST_data &d,WinObj &w);
void TEST_clear (struct TEST_data &d);

-----------------------------------------------------------------------------
Code: produced by the screen painter.
------------------------ TEST.CPP -------------------------------------------
#include "TEST.HPP"

void TEST_screen (WinObj &w)
{
w.printf(2,0," Name:");
w.printf(4,0," Address:");
w.printf(6,0," City:");
w.printf(8,0," State:");
w.printf(10,0," Zip:");
}

int TEST_get (struct TEST_data &d,WinObj &w)
{
w.get (2,14,d.Name,'F');
w.get (4,14,d.Address,'F');
w.get (6,14,d.City,'F');
w.get (8,14,d.State,'U');
w.get (10,14,d.Zip,'Z');
return (W_OK);
}

void TEST_clear (struct TEST_data &d)
{
str_clear (d.Name,30);
str_clear (d.Address,30);
str_clear (d.City,15);
str_clear (d.State,2);
str_clear (d.Zip,10);
}

-----------------------------------------------------------------------------
Main: produced by you the programmer.
---------------------- MAIN.CPP ---------------------------------------------

#include "TEST.HPP"

void main()
{
WinObj w;
w.open (2,0,23,79,W_SINGLE,_BLACK|WHITE,_LGREY|RED);
struct TEST_data d;
TEST_screen (w); // display screen
TEST_clear (d); // clear the data
TEST_get (d,w); // perform the gets
w.read(); // perform read
}
-----------------------------------------------------------------------------


*****************************************************************************
Functions & Data Types Created with the Screen Painter
*****************************************************************************

All functions created start with the name of the generated file,
Followed by an underscore then the function name.

Ex. If the generated code is named TEST.CPP the resultant functions
will have the name TEST_function

Each function created by the generator will be defined in the generated
header file. (filename.HPP)

--------------------------------
_data
A structure representing the data in your defined gets. This
is just the structure definition, you must declare your own
data. This structure is used by the screen painter get function.
The structure is defined int ?????.HPP.

USAGE: struct ?????_data d;
--------------------------------
_screen
Paint the screen text in the given window object. You must open
the window your self. The screen painter does not make an attempt
to guess the size & position of the window you wish to use.

USAGE: void ?????_screen (WinObj &w);
--------------------------------
_get
Call all the needed gets and valid statements. The read function
is not called. This is to allow you to call clear_gets. Calling
clear_gets will cause the data to be displayed but not read from
the user.

USAGE: int ?????_get (struct ?????_data &d,WinObj &w);
---------------------------------
_clear
Clear all data to blanks or 0 in the data struct. This can be
used to initialize the data structure.

USAGE: void ?????_clear (struct ?????_data &d);
---------------------------------


Additional functions create for use with CodeBase.
---------------------------------
_def[]
A Field definition array in codebase formate. This structure can
be used to create your codebase data file.

Definition: FIELD ?????_def[] = { fields };
----------------------------------
_replace
Used to replace the data fields in your codebase field with
the data in your _data structure. It assumes the file you
wish to replace is the currently selected file, also that the
fields in the file match the order of _def[].

USAGE: ?????_replace (?????_data &d);
----------------------------------
_load
Used to load the structure _data variables with the values
from the current database record. It assumes the file you
wish to load from is the currently selected file, and that
the fields are in the same order as _def[].
----------------------------------

*****************************************************************************
Screen Paint Keys and Menus
*****************************************************************************

Arrow keys = Move the cursor one character.
PgUp & PgDn = Move the cursor to the first/last rows.
Home & End = Move the cursor to the first/last column.
Delete = Delete the character under the cursor.
Insert = Toggle the insert/overtype mode. See bottom right
of the screen.
Backspace = Delete the character to the left of the cursor.

Ctrl-F4 = Toggle the codebase code generation mode. See
upper right corner of the screen.

Alt-M = Display the main menu. This is a slide bar menu
or F10 which can be used to select any of the other menus.

Alt-S = Display the Screen menu. Options:
Save = Save the current screen in a .SCR file.
Retrieve = Retrieve a previous created screen.
Clear = Clear the work area.

Alt-F = Display the Field menu. Options:
Add = Add a new field.
Change = Change the currently selected field.
Delete = Delete the currently selected field.
Move = Move the currently selected field.
See the field definitions below.

Alt-C = Code generator. You will be prompted for a file
name.

Alt-Q = Quit the Screen Painter.



Field Definition Values.
Name = Name used for field in programs. This will be used in
the structure definition and the codebase file definition.

Order = The order the fields get is called. This is the order
the user will be prompted in. Leave space for additional
fields. The generator will start with 100,200... by default.

Type = The type of variable to be used.
C = Character
L = Long
D = Double

Style = The picture style to use for the field. This is valid
in Character fields only.
L convert field to 'L'owercase.
U convert field to 'U'ppercase.
F convert 'F'irst character to uppercase.
D MM/DD/YY date field.
S 999-99-9999 Social Security number field
P (999) 999-9999 phone number.
Z 99999-9999 zip code.

Length = The length of the field. This is automatic in the case
of some style. D,S,P and Z

Decimals= The number of decimals in a Double field.

Valid Function = The name of the function to be called as a valid
for the field. You must supply this function in
your share of the code. A declaration for the
function will be provided in ?????.HPP.



*****************************************************************************
Copyright Notices
*****************************************************************************

CodeBase 4 is a dBASE compatible function library by Sequitur.



 December 13, 2017  Add comments

Leave a Reply