Shareware Supreme Volume 6 #1/swsii.zip/swsii/163/QTEC9305.ZIP/APIBRO.TEC

Text File | 1992-03-09 | 48KB | 940 lines

ID:AB DESQview API General Information
Quarterdeck Technical Note #211
By Jim Susoy
last revision:  2 March 1992

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                  *$149.95*$      *
**************************************************************************
*   *     *     * DESQview API Panel Design Tool         *$149.95*$      *
**************************************************************************
*   *     *     * DESQview API Reference                 *$ 59.95*$      *
**************************************************************************
*   *     *     * DESQview API Libraries (C,Pascal,      *       *$      *
*   *     *     *          Basic,Clipper and dBase)      *$199.95*       *
*   *     *     *                                        *       *       *
*   *     *     * Check One:                             *       *       *
*   *     *     * C( )  Clipper( ) Pascal( ) dBase( )    *       *       *
*   *     *     * Basic( )                               *       *       *
**************************************************************************
*   *     *     * DESQview API Toolkit (API Reference,   *$500.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
                               [phone]
                             Fax [phone]

  ************************************************************************
  *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 *************************