Category : Alternate Operating Systems - Quarterdeck DesqView, CP/M, etc
Archive   : QWHITE13.ZIP
Filename : APIBRO.TEC

 
Output of file : APIBRO.TEC contained in archive : QWHITE13.ZIP

ID:AI DESQview API General Information
Quarterdeck Technical Note #211 Filename: APIBRO.TEC
by Jim Susoy CompuServe: APIBRO.ZIP
Last revised: 9/14/92 Category: API

Subject: The text of our brochure describing the DESQview Application
Program Interface, used to create DESQview-aware or
DESQview-specific programs. A full description of the API,
including all available calls.


In the Quarterdeck view of the world there are three kinds of DOS programs:

There's the DESQview-oblivious program, such as 1-2-3 or AutoCAD, written with
no consideration of DESQview, but still compatible with DESQview.

There's the DESQview-aware program. It has been modified slightly so that it
runs efficiently in DESQview and concurrently with other programs. Paradox,
DBASE III, DBASE IV, FoxPro, and WordPerfect are DESQview-aware.

Then there's the DESQview-specific program, like the DESQview Datebook. It's
written to take advantage of DESQview's power. If you look closely, you'll
discover DESQview behind both the ICL North America and IBM/Tridata point of
sale systems, US Data's factory control systems, TRW's title insurance system,
Moody's Investor's Services' bond rating system, FNN's NewsReal and Novell's
Remote Access Server, to name only a few.

Hidden deep inside DESQview 2 is a powerful API (Application Program
Interface) that lets programs control and interact with DESQview and with
other programs running in DESQview. For MIS and DP departments building
workstation solutions, the DESQview API provides enormous benefits, for it
brings OS/2 capabilities (and even OS/2 look and feel if desired) to DOS.
Using the DESQview API, a program can use all the DESQview menu functions
available to the user as well as the power-packed capabilities built into
DESQview: multitasking, windowing, intertask communications, mailboxes,
shared programs, memory management, mousing, data transfer, menu-building, and
help.

So, DOS programs can now act alone or together. Either within a window or
hidden behind one, they can do chores in silence or in chorus, all the while
utilizing the full power of DESQview, all the while bringing you treasures you
only dreamed 'til now were possible.

A program taking advantage of the DESQview API can display information in
windows and control the color, dimensions, position, and ordering of windows
on the screen. It can disable, limit or enhance the standard DESQview user
interface, which means that you can have DESQview-like menus in your program,
or menu bars and pull-down menus, or IBM SAA-like menus. It can let DESQview
handle all keyboard and mouse input to menus and forms yet still process
keyboard and mouse input directly when necessary. It can schedule processing
after a certain time interval or at a certain time. It can spawn subtasks for
performing background operations such as printing, recalculating, and
communicating. It can communicate between the various tasks in the system.

MULTITASKING

DESQview supports true multitasking of existing DOS programs in addition to
programs written specifically for DESQview. So a user can run multiple
programs (Lotus 1-2-3, DBASE IV and others) and DESQview-specific programs
(DESQview Datebook, Calculator, your own program) concurrently. So a user can
switch to whichever program needs input and switch away while the program
recalculates or sorts in background.

Under DESQview, each program runs in its own "virtual machine", thinking it
has exclusive access to DOS, the keyboard, etc. DESQview calls these virtual
machines "processes". DESQview calls the portion of a process that keeps
track of which instruction to execute next and what the register contents are
a "task" (or "thread"). Every program running under DESQview consists,
initially, of a single process running a single task.

DESQview-specific programs may create additional tasks within their own
processes and additional processes. Additional tasks allow a portion of your
program, the part that controls the printer for example, to be run in
background. Additional processes allow whole new programs to be loaded and
run concurrently.

PRESENTATION MANAGEMENT

Because DESQview lets you run more than one program at a time, DESQview
provides a way to view more than one program at a time on the screen. DESQview
does this by mapping each program into its own "window" and by managing the
display of multiple windows on the screen. To DESQview, windows are
rectangular areas of displayable information. They may be moved, resized,
colored, and reordered by either the user or by your program. Everything that
is displayed on the screen under DESQview is displayed in a window.

Multiple windows are not only useful for displaying several programs
simultaneously, but may also be used within a single program to display menus,
help screens, error messages. DESQview provides facilities for storing
complete descriptions of such windows, (known by DESQview as "panels"), on
disk or in your program and displaying them with a single call to the API.
These panels may be as simple as one-line error messages or as complex as data
entry forms with multiple-choice and data entry fields.

Once a panel has been displayed, your program can ask DESQview's "field
manager" to process all user input to the panel including mousing and data
entry editing. The field manager returns the results to your program in a
simple, field-oriented format, independent of the appearance of the panel.

The use of panels and the field manager not only simplifies the job of
programming an application, but gives a consistency to the user interface
that makes the learning of new applications easier.

INTERTASK COMMUNICATIONS

So that DESQview-specific programs can rapidly exchange information, DESQview
provides a wide range of intertask communications facilities. These
facilities allow several concurrently-running tasks to exchange information or
signals, to lock access to common resources, to share common code and data,
and to interrupt each other to handle critical events. These tasks can be in
either the same or different processes.

Intertask communication is the key to building complex applications in a
multitasking environment. Let's say, for example, you are building a point of
sale system, that handles a dozen cash registers for a department store. Using
DESQview you could break your application up into fourteen tasks: one for
each of the cash registers, one to handle access to the pricing data-base and
one to track sales and generate management reports. The cash register tasks
would process keystrokes from the clerk until an item price is needed, they
would then send a message to the database task requesting the price. The
database task would log the sale and return the price to the sender of the
request. Meanwhile, the store manager could interact with the reporting task
to monitor sales, clerk performance, etc.


DATA TRANSFER

DESQview supports two types of user-initiated data transfer. The first, called
Mark & Transfer, lets a user mark text in any window and transfer that text to
any other application. The application receiving the data can be DESQview-
oblivious, seeing the data as normal keyboard input.

More sophisticated transfers are possible between DESQview-specific
applications that support the DESQview Scissors command. When the user marks
data in such an application, DESQview notifies the application that data has
been requested and lets the application determine exactly what data to supply.
The application may supply anything including text, formulas, or even graphics
images. When the user instructs DESQview to Paste the data into another
application, that application is also notified so that the data can be handled
appropriately.

The applications involved in a Scissors transfer can even use DESQview's
intertask communication facilities to setup a "hot-link" between themselves so
that subsequent changes to the data are automatically reflected in both
applications.

MEMORY MANAGEMENT

Programs running under DOS are typically given all of a PC's memory to do with
as they please. In a multitasking environment, memory must be managed so that
more than one program can be loaded at a time and so that no single program is
given more memory than it needs. DESQview provides this management in a way
that adapts to the type of memory hardware available on your PC.

If your PC has 640K of conventional memory, DESQview is able to multitask as
many programs as will fit in memory at the same time. Additional programs can
be loaded but will cause the least recently used programs to be suspended and
swapped to disk to make room in memory for the new ones.

If your PC is a 286-based system with extended memory only, DESQview can still
only multitask the programs that fit in 640K. Additional programs open can be
swapped either to RAM disk, as well as to the user's local disk or network
disk. DESQview is also capable of running 60K of itself in extended memory
thus reducing its DOS conventional memory overhead. If you have EMS 3.2 (Lotus-
Intel-Microsoft Expanded Memory), DESQview will swap programs to expanded
memory instead of to disk. This is so much faster than swapping to disk that
the swap time is almost not noticeable.

If your PC has EMS 4.0 or EEMS (AST-Quadram-Ashton Tate Enhanced Expanded
Memory) or a 386-based PC with an EMS 4.0 driver, DESQview can actually
multitask as many programs as will fit in conventional and expanded memory.
This can be as high as 32-megabytes worth of programs. DESQview can also run
a large part of itself in expanded memory, giving a much larger maximum
program size.

Furthermore, DESQview can actually run both 286 or 386 DOS Extended programs
simultaneously with your other DOS programs. DOS Extended programs are
programs, such as Lotus 1-2-3 Release 3, IBM Interleaf, AutoCAD 386, Paradox
386, which have been written to take advantage of either the 16-bit protected
mode of the 80286 processor or the 32-bit protected mode of the 80386
processor. It is important to note that for DESQview to be able to run DOS
Extended programs, the DOS Extender must conform to the VCPI (Virtual Control
Program Interface) specification which specifies how protected mode programs
and 80386 control programs can work together. With most DOS Extenders, you
also get the added benefit of virtual memory support automatically built into
the program a significant benefit if your users have limited memory.

CUSTOMIZATION

Although DESQview is best known for its ability to run off-the-shelf software
concurrently, DESQview is an ideal platform for developing customized vertical
market applications and workstations.

DESQview's intertask communications and shared program and data capabilities,
coupled with its support of expanded memory, give developers efficient and
cost-effective techniques for developing large programs that can still run on
DOS and thus on the large installed base of DOS PCs.

In addition to providing multitasking and windowing services, DESQview can be
customized to provide the user interface appropriate to a particular
application. This customization can take the form of restricting access to
certain DESQview menus, taking special action when certain menu items are
selected, or, in the extreme, disabling all access to DESQview menus and
providing the entire user interface as part of the application.

In this latter case, the only part of DESQview that the user sees is a
copyright screen during start-up. DESQview also includes a keystroke macro
capability enabling you to create built-in macros for each application running
as well as global macros which combine actions from several programs.


PORTABILITY

DESQview with its entire API runs on 8088, 8086, 80286, 80386 and 80486i PCs
as well as the IBM Personal System/2s with monochrome, CGA, EGA, VGA or
Hercules display adapters. Additionally, Wyse 700 and Micro Display System
Genius adapters are available from Quarterdeck. This means that an
application that you write to be DESQview-specific can run on any PC from a
laptop dual-floppy PC to the very latest 486-based PC. It can even run over a
network on a diskless PC. Thus, the market for your DESQview-specific
application extends to the entire base of existing and future DOS PCs.


API DETAILS

In order for you to get a feel for the power built-in to each and every
DESQview, we've included a short description about each API command.

The DESQview API is an object-oriented interface. The data structures
DESQview uses to represent windows, mailboxes, etc. are called "objects". A
call to the API involves "sending a message" to an object, indicating which of
several operations you want performed on that data structure. This is referred
to as the "send interface." Almost the entire API consists of sending one of
25 messages to one of 7 different object types.

The DESQview API also has a non-object-oriented interface called the "direct
call interface." This is the small subset of API functions that are not, by
nature, object-oriented, or that are convenient alternatives to the send
interface.

The DESQview API has a concise way of encoding a complete description of a
window so that a single call to the API can create the window, fill it with
the desired information, size and position it on the display, and define
fields that interact with the user. All this is done using "Window Streams".

So that you can interrogate a window for its current contents, position, etc.,
the DESQview 2 API also has "Query Streams." In fact, any window parameter
that can be set by a Window Stream can be read by a Query Stream.

DESQview calls the portion of itself that interfaces with the user
the "Window Manager." Every time a user presses the DESQ key (normally the
Alt key) and makes a menu selection, it is the Window Manager that opens,
switches, rearranges and closes windows, transfers data, displays help, or
quits DESQview. In order for an application to have the same power as the
user, the DESQview API has "Manager Streams." Manager Streams enable an
application to interact with the Window Manager.

Using Manager Streams an application can, for example, ask the Window Manager
to make one of its windows the topmost window in the system, disallow any
resizing of the window by the user, and even notify the application if the
user tries to close the window. Using Manager Streams an application can
disallow use of the DESQview menu and DESQview sub-menus.

But, there's still even more to the DESQview API. DESQview provides a
comprehensive set of functions for simplifying the job of interfacing with the
user. Instead of dealing with user input a single character at a time, your
application can present entire menus, dialogue boxes, or help screens to
DESQview and get back the resulting user input. Common functions such as
cursor control, insertion and deletion of characters, tracking the mouse, and
selection from option lists are performed by DESQview. DESQview performs
these functions under control of a data structure called the "Field Table."
Information about a window's size, position, contents and Field Table can be
combined together into "Panels." Panels can be stored on disk or in memory
for later display. Panels can be constructed manually or via the DESQview API
Panel Design Tool.


DESQVIEW 2 API COMMANDS:

Send Interface Commands

WINDOW Objects

ADDTO write characters & attributes to a window
AT position the logical cursor
CONNECT connect one window to another window
EOF return TRUE if cursor is past end window
ERASE clear a window
FREE close and free a window or a task
HANDLE return handle of current task's window
LEN return # characters/line in logical window
NEW create a new window or task
OPEN fill a window with a given character
READ read the next logical line from a window
READN read the next n characters/attributes
REDRAW redraw a window
SIZEOF return total # characters/logical window
SUBFROM write attributes to a window
WRITE write characters and/or command streams

KEYBOARD Objects

ADDTO set individual keyboard control flags
CLOSE close a keyboard object
ERASE discard all input queued to keyboard
FREE free a keyboard object
GETFLAGS get keyboard control flags
GETPRI get objectq priority level of keyboard
HANDLE return handle of task's default keyboard
NEW create a new keyboard object
OPEN attach a keyboard to a window
READ get the next input from the keyboard
SETESC intercept keystrokes to input fields
SETFLAGS set/clear all keyboard control flags
SETPRI set objectq priority level of keyboard
SIZEOF return # of input buffers queued
STATUS get the scan code for the last key read
SUBFROM clear individual keyboard control flags
WRITE add input buffer to keyboard queue

MAILBOX Objects

ADDR return sender of the last message READ
ADDTO send a message and status by value
CLOSE close a mailbox
ERASE discard all queued messages
FREE free a mailbox
GETFLAGS get mailbox control flags
GETPRI get objectq priority level of mailbox
HANDLE return handle of task's default mailbox
LOCK request exclusive access to a resource
NEW create a new mailbox
OPEN open a mailbox for input
READ get the next message from the queue
SETFLAGS set/clear all mailbox control flags
SETNAME assign a name to a mailbox
SETPRI set objectq priority level of mailbox
SIZEOF return the # of messages in the queue
STATUS return status of the last message READ
SUBFROM send a message & status by reference
WRITE send a message by value with status=0

OBJECTQ Objects

CLOSE close an objectq
ERASE remove all objects from the queue
HANDLE return the handle of a task's objectq
OPEN open the objectq
READ wait for input from any open object
SIZEOF return the number of objects queued
STATUS return whether or not objectq is open
SUBFROM remove specific object from queue
WRITE add an object to the objectq

PANEL Objects

APPLY display a particular panel
CLOSE close a panel object
DIR return a pointer to the panel directory
FREE free a panel object
NEW create a panel object
OPEN associate panel object with a panel file
SIZEOF return the # of panels in a panel file
STATUS verify success of an OPEN or APPLY

POINTER Objects

ADDTO set pointer control flags
CLOSE stop taking pointer input
ERASE discard all pointer messages
FREE free a pointer object
GETFLAGS get pointer control flags
GETPRI get objectq priority level of pointer
GETSCALE return the current scaling factors
NEW create a new pointer object
OPEN start taking pointer input for window
READ wait for the next pointer message
SETFLAGS replace pointer control flags
SETPRI set objectq priority level of pointer
SETSCALE set the current scaling factors
SIZEOF return the number of messages queued
STATUS return the status of the last message
SUBFROM reset pointer control flags
WRITE move the pointer to a specified position

TIMER Objects

ADDTO start a timer for a specified interval
CLOSE close a timer object
ERASE cancel the current timer interval
FREE free a timer object
GETPRI get objectq priority level of timer
LEN return time remaining before expiration
NEW create a new timer object
OPEN open a timer object
READ wait for the current timer to expire
SETPRI set objectq priority level of timer
SIZEOF return elapsed time since timer started
STATUS return the status of the timer object
WRITE start a timer to end at a specified time

Direct Call Interface Commands

APILEVEL define minimum API level required
APPNUM get the current application's number
ASSERTMAP get current mapping context & set new
BEGINC begin critical region
CSTYLE use C language style control codes
DBGPOKE poke debug information onto display
DISPEROR display an error message window
DVPRESENT determine if DESQview is present
ENDC end critical region
FINDMAIL find a mailbox by name
FREEBIT undefine second-level interrupt handler
GETBIT define a second-level interrupt handler
GETBUF get address of a Logical Window Buffer
GETCRIT get critical region nesting level
GETERROR get error handling level of current task
GETMEM allocate buffer from System Memory
ISOBJ determine if a handle is valid
JUSTIFY turn off/on automatic justification
KMOUSE control the keyboard mouse
LOCATE find window at given screen location
NEWPROC start a new process
OBJTYPE determine object type of a given handle
OSTACK switch to task's internal stack
PAUSE relinquish control to other tasks
PGMINT interrupt another task
POSTTASK awaken task by posting its Objectq
POSWIN position a window on the display
PRINTC display a character in a window
PUSHKEY push key into keyboard input stream
PUTMEM free a buffer allocated by GETMEM
SETBIT schedule a second-level interrupt handler
SETERROR set error handling level of current task
SHADOW get window buffer and start shadowing
SOUND make a sound
START start a task that was previously stopped
STOP stop a task until START is called
UPDATE update a portion of a window
USTACK switch off task's internal stack


Window Stream & Query Stream Commands

00 to 9F print strings (attrib,char,blanks) to window

A0 to CF change size/ position of a window

D0 to DF set options for appearance of window: frames,color,
show/hide window, display of control characters

E0 to EF perform immediate actions: clearing,scrolling recoloring,
redrawing window; create new windows & repeat command sequences

F0 to FF define, read, write fields within window.


Manager Streams

00 to 3F Allows specific DESQview commands:
move & resize window, scroll data, hide
rearrange program, suspend application,
display DESQview menu

40 to 71 notify application on specific DV commands.

84 to 8B specify environment of window: suspend
application when it is in background, set
application's asynchronous notification.

AE to BF enable/disable DESQview extensions.

C0 to FF reorder, hide, unhide, suspend resume
applications.


C, Pascal, BASIC, Clipper & dBASE
Listed below are API Interfaces available with each DESQview API library.


C - C
P - Pascal
B - Basic
R - Clipper
D - dBase

General Functions
CPBRD
-----
YYYYY api_beginc begin critical region
YYYYY api_cancel cancel current Window Mgr operation
YYYY api_commonmem get status of Common Memory
YYYY api_convenmem get status of Conventional Memory
Y api_curdrive get the current default drive
Y api_dec convert hex string to unsigned decimal #
YY Y api_dvpresent determine if DESQview is present
YYYYY api_endc end critical region
YYYY api_enterc begin critical region w/o waiting for DOS
YYYYY api_exit exit API interface
YYYY api_expandmem get status of Expanded Memory
YY Y api_freebit disconnect 2nd level interrupt handler
YY Y api_getbit define 2nd level interrupt handler
YYYYY api_getcommon get Common Memory buffer
YYYYY api_getcrit get critical region nesting level
YYYYY api_getmem get System Memory buffer
Y api_hex convert decimal # to hexadecimal string
Y api_hexaddr convert addr to string in seg:off hex form
YYYYY api_init initialize API interface & return version of DESQview
Y api_interactive determine if in BASIC interactive environment
YYYYY api_isobj determine if a given handle is valid
Y api_isset determine if given bit is set within a specified byte
YYYYY api_justify enable/disable automatic justification of task window
YYYYY api_kmouse turn keyboard mouse on and off
YYYYY api_level define API revision level that application requires
YYYYY api_objtype determine object type of a given handle
YYYYY api_pause give other tasks a chance to run
YYYYY api_poke display debug info on bottom line of screen
YYYY api_processmem get status of app's Process Memory
YYYYY api_pushkey push key into input stream
YYYY api_putcommon return Common Memory buffer
YYYY api_putkey put key into an application's input stream
YYYY api_putmem return System Memory buffer
Y api_read read from DV-owned memory buffer
YY Y api_setbit schedule a 2nd level interrupt handler
YY Y api_shadow get task's logical window buffer & start shadowing
YYYYY api_sound make a sound
YY Y api_update redraw portion of a task's logical window
Y api_write write to DESQview-owned memory buffer


Application Management Functions
CPBRD
-----
YYYYY app_foreonly indicate whether app can run in background
YYYYY app_free free an application and its window
YYYYY app_goback force an application into background
YYYYY app_gofore force an application into foreground
YYYYY app_hide hide all windows of an application
YYYY app_new start a new app in the current process
YYYYY app_number get the current app's Switch number
Y app_run execute DOS command in new process
YYYYY app_show display all windows of an application
YYYYY app_start start a new application in a new process
YYYYY app_suspend suspend and hide all tasks in an app


Field Management Functions
CPBRD
-----
YYYYY fld_altmode set Alternate Field Processing mode
Y fld_atget input data at specified field position
Y fld_atprompt paint menu prompts & define msg at fld
Y fld_atsay display data at specified field
YYYYY fld_attr fill a field with a given attribute
YYYYY fld_char fill a field with a given character
YYYYY fld_clear clear a field
YYYYY fld_cursor move cursor to a field
YYYYY fld_entry change field table entry
YYYYY fld_header change field table header
YYY fld_lentry load field table entry of field table window stream
YYY fld_lheader load field table header of field table window stream
YYYYY fld_marker define selected-field marker character
YYYYY fld_point move pointer to a given position in a field
YYYYY fld_protattr set Protected Attrib field processing mode
YYYYY fld_reset reset selected and modified bits
YYYYY fld_scroll scroll a field
YYY fld_stream allocate string space for field table window stream
YYYYY fld_type change the type of a field
YYYYY fld_write write a string into a field


Keyboard Management Functions
CPBRD
-----
Y key_accept enter a string into a memory variable
YYYYY key_addto set keyboard control flags
Y key_clear empty keyboard type ahead buffer
Y key_clkey convert DV key code to Clipper key code
YYYYY key_close disconnect keyboard from its window
Y key_dvkey convert Clipper key code to DV key code
YYYYY key_erase discard pending keyboard input
YYYYY key_free free a keyboard object
YYYYY key_getc wait for next key (keystroke mode)
YYYYY key_getflags get keyboard control flags
YYYYY key_getpri get priority level of keyboard in objectq
YY key_inkey read a character from keyboard
Y key_input enter an expression into a memory variable
Y key_keyboard stuff keyboard buffer with a string
Y key_lastkey determine last key fetched from keybd
YYYYY key_me get current task's keyboard handle
Y key_nextkey read the next key from keyboard
YYYYY key_new create a new keyboard object
YYYYY key_of get handle of a given task's keyboard
YYYYY key_open attach keyboard to a given window
YYYY key_owner get owner of a given keyboard
YYYYY key_read read input from keyboard
Y key_readinsert return the current insert mode setting
Y key_readlast read DV key code in key_lastkey buffer
Y key_setcursor determine if hardware cursor displayed
YYYY key_setesc define function to filter keys in fld mode
YYYYY key_setflags replace keyboard control flags
YYYYY key_setpri set priority level of kbd in task's objectq
YYYYY key_sizeof get # keyboard messages pending
YYYYY key_status get status of last keyboard message
YYYYY key_subfrom clear keyboard control flags
Y key_wait suspend task until a key is pressed
YYYYY key_write write string to keyboard
Y key_writelast write DV key code into


Mailbox Management Functions
CPBRD
-----
YYYYY mal_addr return sender of last message
YYYYY mal_addto send a message by value with given status
YYYYY mal_close close a mailbox
YYYYY mal_erase erase all pending messages
YYYYY mal_find find a mailbox by name
YYYYY mal_free free a mailbox object
YYYY mal_getflags get mailbox control flags
YYYY mal_getpri get priority level of mailbox in objectq
YYYYY mal_lock lock access to a resource
YYYYY mal_me get handle of current task's mailbox
YYYYY mal_name assign a global name to a mailbox
YYYYY mal_new create a new mailbox
YYYYY mal_of get handle of a given task's mailbox
YYYYY mal_open open a mailbox
YYYY mal_ownerget owner of a given mailbox
YYYYY mal_read wait for next message
YYYY mal_setflags replace mailbox control flags
YYYY mal_setpriset priority level of mailbox in task's objectq
YYYYY mal_sizeof get # messages pending
YYYYY mal_status get status of last message received
YYYY mal_subfrom send msg by reference w given status
YYYYY mal_unlock unlock access to a resource
YYYYY mal_write send a message by value with status zero


Objectq Management Functions
CPBRD
-----
YYYYY obq_close close the task's objectq
YYYYY obq_erase erase contents of the task's objectq
YYYYY obq_open open the task's objectq
YYYYY obq_read wait for any object to have input
YYYYY obq_sizeof get # of objectq entries pending
YYYYY obq_status determine if the task's objectq is open
YYYYY obq_subfrom remove copies of object handle from task's objectq
YYYYY obq_write add an object handle to task's objectq


Panel Management Functions
CPBRD
-----
YYYYY pan_apply display a named panel & prepare for input
YYYYY pan_close close a panel file
YYYY pan_dir get list of panels in the panel file
YYYYY pan_free free a panel object
YYYYY pan_new create a panel object
YYYYY pan_open open a panel file
YYYY pan_owner get owner of a given panel
YYYY pan_sizeof get # panels in the panel file
YYYYY pan_status get status of last pan_open or pan_apply


Pointer Management Functions
CPBRD
-----
YYYYY ptr_addto set pointer control flags
YYYYY ptr_close close a pointer object
YYYYY ptr_erase erase pending pointer messages
YYYYY ptr_free free a pointer object
YYYYY ptr_getflags get pointer control flags
YYYYY ptr_getpri get priority level of pointer in objectq
YYYYY ptr_getscale get current scaling factors
YYYYY ptr_new create a new pointer object
YYYYY ptr_open open pointer and assign to a window
YYYY ptr_owner get owner of a given pointer
YYYYY ptr_read wait for next pointer message
YYYYY ptr_setflags replace pointer control flags
YYYYY ptr_setpri set priority level of ptr in task's objectq
YYYYY ptr_setscale set current scaling factors
YYYYY ptr_sizeof get # messages pending
YYYYY ptr_status get button status from last message received
YYYYY ptr_subfrom clear pointer control flags
YYYYY ptr_write move the pointer to a given position


Query Functions
CPBRD
-----
YYYYY qry_atread TRUE if win_read and win_readn will read attributes
YYYYY qry_attrget current output attribute
YY Y qry_col get current cursor column position
YYYYY qry_color get physical attribute for given logical attribute
YYYYY qry_ctrl TRUE if processing control codes
YYYYY qry_cursor get current cursor position
YYYY qry_dosuser get handle of task currently using DOS
YYYYY qry_entry get field table entry
YYYYY qry_field get contents of a field
YYYY qry_flength get length of a field
YYYYY qry_frame TRUE if the window has a frame
YYYYY qry_frattr get current frame attribute
Y qry_ftable get field table window stream
YYYYY qry_header get field table header
YYYYY qry_hidden TRUE if the window is hidden
YYYYY qry_kmouse TRUE if using a keyboard mouse
YYYYY qry_leave TRUE if leaving attributes untouched when writing to
window
YYYYY qry_logattr TRUE if using logical attributes
YYYYY qry_lsize get size of logical window buffer
YYYYY qry_origin get origin of physical relative to logical window
YYYYY qry_position get position of physical window
YY Y qry_row get current cursor row position
YYYY qry_scrninfo get current size & video mode of screen
YYYYY qry_size get size of physical window
YYYYY qry_title get window's title
YYYYY qry_type get type of field


Text File Device Driver Functions
CPBRD
-----
Y tfd_attach attach a given window to TFDD
Y tfd_close close TFDD
Y tfd_lock lock access to TFDD
Y tfd_open open TFDD and attach given window
Y tfd_unlock unlock access to TFDD


Timer Management Functions
CPBRD
-----
YYYYY tim_addto start a timer for a given interval
YYYYY tim_close close a timer object
YYYYY tim_erase stop a running timer
YYYYY tim_freefree a timer object
YYYYY tim_getpriget priority level of timer in objectq
YYYYY tim_len get time remaining until timer expires
YYYYY tim_newcreate a new timer object
YYYYY tim_openopen a timer object
YYYY tim_owner get owner of a given timer
YYYYY tim_read wait for timer to expire
YYYYY tim_setpri set priority level of timer in task's objectq
YYYYY tim_sizeofget time since a timer started running
YYYYY tim_status determine if a timer is running
YYYYY tim_write start a timer for a given time of day


Task Management Functions
CPBRD
-----
YY Y tsk_dispatchint software interrupt another task at a "safer" time
YYYYY tsk_free free a task and its window
YYYYY tsk_geterrorget error handling level of current task
YYYY tsk_me get handle of current task
YY Y tsk_new create a new task
YY Y tsk_pgmint software interrupt another task
YYYY tsk_owner get owner of a given task
YYYYY tsk_post restart a task waiting on its objectq
YYYYY tsk_seterror set error handling level of current task
YYYYY tsk_start restart a stopped task
YYYYY tsk_stop temporarily stop a task


Window Management Functions
CPBRD
-----
Y win_achoice execute a pop-up menu in a window
YYYYY win_addto write characters & attributes to a window
YYYYY win_adopt adopt a window
YYYYY win_allow specify which DV commands are allowed
YY Y win_async define asynchronous notify function
Y win_atbox draw a box in a window
Y win_atclear clear rectangular region of window
Y win_atget input data at specified window position
Y win_atprompt paint menu prompts & define messages of window
YYYYY win_atread set read mode to read either character or attribute
Y win_atsay display data at specified window position
YYYY win_attach attach/detach window to parent task window
Y win_atto draw single or double line box in window
YYYYY win_attr set current output attribute
YYYYY win_blanks write blanks to a window
YYYYY win_bottom make window bottommost in its application
Y win_browse browse & edit records within a window
YYYY win_buffer get address of logical window buffer
YYYYY win_cancel cancel notification on a given event
Y win_clear clear a window and home the cursor
Y win_clcolor convert DESQview physical attribute to Clipper color
code
Y win_cleargets release all of window's pending gets
Y win_clscroll scroll window region up, down or blank out
YYYYY win_color change logical attribute mapping
YYYY win_connect attach window to another window
YYYYY win_ctrl enable/disable interpretation of control characters
YYYYY win_cursor move window's logical cursor
Y win_dbedit browse records in a table layout
YYYYY win_dflt change default notify window
YYYYY win_disallow specify which DV commands are not allowed
YYYYY win_disperor display an error message window
Y win_dvattr convert Clipper color code to DESQview physical
attribute
YYYYY win_eof TRUE if logical cursor is beyond end of window
YYYYY win_erase clear a window
YYYYY win_frame enable/disable display of a window's frame
YYYYY win_frattr define window frame attribute
YYYYY win_free remove a window from screen and free its handle
YYYYY win_hcur display hardware cursor at logical cursor position
YYYYY win_hide mark a window as hidden
YYYYY win_leave leave existing attribute when writing to window
YYYYY win_len return width of logical window
YYYYY win_locate return which window is visible at given screen
position
YYYYY win_logattr use logical/physical attributes
YYYYY win_lsize set window's logical dimensions
Y win_mark1/2 display result of an expression in specified window
YYYYY win_maxsize set window's max physical dimensions
YYYYY win_me get current task's window handle
Y win_menuto execute light-bar menu for defined prompts in a window
YYYYY win_minsize set window's min physical dimensions
YYYYY win_move move physical window
YYYYY win_new create a new window
YYYYY win_notify enable notification on a given event
YYYYY win_nread read n characters from a window
YYYYY win_open fill a window with a given character
YYYYY win_origin define portion of logical window viewed in physical
window
YYYYY win_orphan orphan a window
YYYY win_owner get owner of a given window
YYYYY win_paste define window as current clipboard window
YYYYY win_point jump mouse to logical cursor position
YYYYY win_poswin position window relative to another window
YYYYY win_putc write a character/attribute pair to a window
YYYYY win_printf write formatted data to a window
YYYYY win_read read rest of current line from window
Y win_readexit determine whether Up/Down keys exit
Y win_readgets enter editing mode using pending gets in a window
YYYYY win_redraw redraw a window
YYYY win_reorder reorder an application's windows
YYYYY win_repattr write an attribute to a window n times
YYYYY win_repchar write a character to a window n times
YYYYY win_resize set physical dimensions of a window
Y win_restore display a saved window to a specified window area
Y win_save save window region to memory variable
YYYYY win_scroll scroll all or part of a window
Y win_setbell determine sounding of bell during win_readgets
Y win_setcenter determine centering of win_atprompt messages
Y win_setcolor determine color attributes of window
Y win_setconfirm determine required win_atget termination with Enter
key
Y win_setescape determine whether Esc key terminates win_readgets
Y win_setintensity toggle display intensity of win_atget and win_atprompt
Y win_setmessage determine row and centering of win_atprompt messages
Y win_setwrap determine wrapping in win_menuto
YYYYY win_sizeof get # character positions in the logical window
YYYYY win_stream write a stream to a window
YYYYY win_subfrom write attributes to a window
YYYYY win_title change a window's title
YYYYY win_top make window topmost in its application
YYYYY win_topsys make window topmost in the system
YYYYY win_unhide mark a window as not hidden
Y win_updated determine if pending gets changed during last
win_readgets
YYYYY win_write write characters to a window


YES! I'm Interested In System Development/Performance
**************************************************************************
*QTY*5-1/4*3-1/2* Product * Price * Total *
**************************************************************************

* * * * DESQview *$129.95*$ *
**************************************************************************
* * * * DESQview386 (DESQview & QEMM) *$219.95*$ *
**************************************************************************
* * * * Quarterdeck Manifest *$ 59.95*$ *
**************************************************************************
* * * * QRAM *$ 79.95*$ *
**************************************************************************
* * * * QEMM 50/60 *$ 99.95*$ *
**************************************************************************
* * * * QEMM 386 *$ 99.95*$ *
**************************************************************************
* * * * DESQview API Debugger *$ 50.00*$ *
**************************************************************************
* * * * DESQview API Panel Design Tool *$ 50.00*$ *
**************************************************************************
* * * * DESQview API Reference *$ 25.00*$ *
**************************************************************************
* * * * DESQview API Libraries (C,Pascal, * *$ *
* * * * Basic,Clipper and dBase) *$ 50.00* *
* * * * * * *
* * * * Check One: * * *
* * * * C( ) Clipper( ) Pascal( ) dBase( ) * * *
* * * * Basic( ) * * *
**************************************************************************
* * * * DESQview API Toolkit (API Reference, *$100.00*$ *
* * * * Library,Panel Design Tool, * * *
* * * * Debugger, DESQview) * * *
* * * * * * *
* * * * Check One: * * *
* * * * C( ) Clipper( ) Pascal( ) dBase( ) * * *
* * * * Basic( ) * * *
**************************************************************************
* * * * DESQview by S.R. Davis (book) *$ 29.95*$ *
**************************************************************************
***************** Shipping & Handling ********* *
***************** USA: $5 ********* *
***************** Outside USA: $10 *********$ *
**************************************************************************
***************** Sales Tax (CA Only @ %8.25) *********$ *
**************************************************************************
***************** Amount *$ *
**************************************************************************


**************************************************************************
* Payment: M/C VISA AMEX Discover *
**************************************************************************
* Expiration: *
**************************************************************************
* Card Number: *
**************************************************************************
* Name on credit card: *
**************************************************************************
* Shipping Address: *
* *
* *
**************************************************************************
* Telephone: *
**************************************************************************
* Signature: *
**************************************************************************


Quarterdeck Office Systems
150 Pico Blvd., Santa Monica, CA 90405
(310) 314-3222
Fax (310) 314-3217

************************************************************************
*This technical note may be copied and distributed freely as long as it*
*is distributed in its entirety and it is not distributed for profit. *
* Copyright (C) 1990-2 by Quarterdeck Office Systems *
************************ E N D O F F I L E *************************