Abstract for GDDM Base Application Programming Guide

Preface

• Latest GDDM information
• GDDM publications

Summary of changes

An introduction to programming with GDDM

• Supported languages
• The GDDM external application programming interfaces
• The nonreentrant programming interface
• The reentrant programming interface
• The system programmer interface
• Example programs
• Example: The HOUSE program
• Concepts introduced by the HOUSE program
• Initialization of GDDM
• Termination of GDDM
• Graphics primitives
• Graphics attributes
• The graphics segment
• The current position
• Graphics text
• The GDDM page
• Sending output from a GDDM program to a device
• Learning interactively to program with GDDM
• Error handling
• Entry points to GDDM
• Data types of GDDM call parameters
• Floating point
• Integers
• Character
• Arrays
• Structures
• How to compile and run a PL/I GDDM program
• How to compile and run the HOUSE program under VM/CMS
• How to compile, link-edit, and run the HOUSE program under TSO
• GDDM-REXX--the fast path to programming with GDDM
• Prototyping your solutions quickly
• An example of a REXX program using GDDM's functions
• Points to remember when using GDDM-REXX
• ERXTRY--the easiest way to write GDDM-REXX programs
• Unsure of the syntax of a GDDM call? -- ERXPROTO
• Converting PL/I examples to GDDM-REXX
• Specifying call parameters made easy by GDDM-REXX
• Omitting parameters
• Coding calls that take arrays as parameters
• Avoiding problems with GDDM-REXX parameters
• Finding errors in GDDM-REXX programs
• More complex programming with GDDM-REXX
• Multiple instances of GDDM and GDDM-REXX
• Terminating GDDM-REXX when your program is ended abnormally
• Invoking GDDM-REXX programs from other programs or from CMS subset
• Coding styles--strict or loose syntax

Drawing graphics pictures

• Example: Program that draws a street map
• Drawing graphics primitives
• Setting up a coordinate system for drawing graphics
• Moving the current position, using GSMOVE
• Drawing a line, using GSLINE
• Drawing a series of straight lines, using GSPLNE
• Drawing a circular arc, using GSARC
• Drawing an elliptic arc, using GSELPS
• Drawing a series of curved lines, using GSPFLT
• Drawing a graphics marker symbol, using GSMARK
• Drawing a shaded graphics area, using GSAREA and GSENDA
• Outline of a graphics area
• Closure of a graphics area
• The graphics area shading algorithm
• Drawing a multipart graphics area, using GSMOVE
• Querying the current position, using GSQPOS
• Drawing graphics image pictures, using GSIMG
• Drawing a scaled image picture, using GSIMGS
• Specifying graphics attributes for primitives
• Setting the current color, using GSCOL
• Setting a new current line type, using GSLT
• Setting a new current line width, using GSLW or GSFLW
• Setting the current marker symbol, using GSMS
• Changing the scale of a graphics marker symbol, using GSMB
• Setting the current shading pattern, using GSPAT
• Using shading patterns other than the GDDM system patterns
• Selecting from a wider range of colors, using GSPAT
• Setting the foreground color-mixing attribute, using GSMIX
• Special treatment of the background color, using call GSMIX
• Erasing graphics from part of the screen
• Producing a reverse-video effect
• Setting the background-mix attribute, using GSBMIX
• Specifying a transform for graphics primitives, using GSSCT
• Changing attributes inside an area
• Querying the attributes of graphics in a segment
• Storing and restoring graphics-attribute values, using GSAM and GSPOP
• Changing default attribute values
• Overriding the standard default of a graphics attribute
• Device variations with graphics pictures
• IBM 3279 terminals
• Workstations supported by GDDM-OS/2 Link or GDDM-PCLK
• IBM 3270-PC/G and /GX workstations
• IBM 5080 and 6090 Graphics Systems
• 5550-family Multistations
• Plotters
• Printers

Including text functions in your programs

• Graphics text
• Alphanumeric text
• Procedural alphanumerics
• Mapped alphanumerics
• High-performance alphanumerics (HPA)
• Comparison of the three methods of implementing alphanumeric functions

Creating graphics-text output in your application

• Drawing graphics text
• Affecting the appearance of graphics text
• Choosing a suitable mode of graphics text
• Mode-1: String-positioned graphics text
• Mode-2: Character-positioned graphics text
• Mode-3: Stroke-positioned graphics text
• Advantages and disadvantages of each character mode
• Mode-1: String-positioned graphics text
• Mode-2: Character-positioned graphics text
• Mode-3: Stroke-positioned graphics text
• Example: Subroutine to label the streets of the TOWN program
• Tasks illustrated by the LABELS subroutine
• Selecting the mode of graphics text to be used
• Ensuring that graphics text is readable
• Breaking lines of graphics text
• Changing the size and proportions of text characters
• Changing the space between characters of graphics text
• Concatenating graphics text
• Changing the slope of a graphics-text string
• Changing the direction of a graphics-text string
• Making graphics-text characters appear italic
• Outlining the text box around a graphics-text string
• Aligning text within the text box
• Using proportionally-spaced characters
• Device variations with graphics text
• On IBM 3279 color displays
• On the IBM 3270-PC/G and /GX workstations
• On the IBM 5080 and 6090 Graphics Systems
• On IBM 5550-family Multistations
• On advanced function printers and the IBM 4250
• On plotters

Basic procedural alphanumerics

• Defining an alphanumeric field, using call ASDFLD
• Sending and receiving alphanumeric data, using ASCPUT and ASCGET
• Breaking lines of alphanumeric text
• Clearing an alphanumeric field, using call ASFCLR
• Deleting an alphanumeric field, using call ASDFLD
• Positioning the alphanumeric cursor, using ASFCUR
• Querying the position of the alphanumeric cursor, using ASQCUR
• Attribute bytes on 3270 terminals
• Alphanumeric attributes
• Setting the attributes of alphanumeric fields
• Setting the attributes of alphanumeric characters
• Example: Program using procedural alphanumerics to display a bank balance
• Points illustrated by the Bank Account program
• Mixing alphanumeric and graphic functions
• Device variations with procedural alphanumerics
• 3179-G, 3192-G, 3472-G, 3270-PC/G and /GX, and IPDS printers
• IBM 5080 and 6090 graphics systems
• 5550-family multistations

Image basics

• Hardware required for image processing with GDDM
• How images are defined for processing by GDDM
• Transferring image data from one type of image to another
• How to scan, display, and save an image
• Scanner echoing
• Creating an image
• Loading the document into the scanner using call ISLDE
• Transferring images using call IMXFER
• Deleting images using call IMADEL
• Synchronizing output and input
• Saving images using call IMASAV
• Loading an image, using call IMARST
• Obtaining a new image identifier, using call IMAGID
• Querying image attributes
• Projections
• Example code to define and save a projection
• Creating a projection using call IMPCRT
• Extracting a rectangular sub-image using call IMREXR
• Changing the size of an extracted image using call IMRSCL
• Completing the image transform and positioning it in the target image
• Saving a projection using call IMPSAV
• Deleting a projection, using call IMPDEL
• How to apply a projection during a transfer operation
• The remaining transform elements
• Turning (reorienting) the image through multiples of 90 degrees
• Reflecting the image about a chosen axis, using call IMRREF
• Getting the negative of an image, using call IMRNEG
• Defining the resolution conversion algorithm, using call IMRRAL
• Putting transform calls in the right sequence
• Order of evaluation in projections
• Some other facilities
• Gray-scale image manipulation
• Applying a projection during image save and restore
• Getting a new projection identifier, using call IMPGID
• Changing the image resolution type, using call IMARF
• Editing images without a transfer operation
• Clearing a rectangle in an image, using call IMACLR
• Trimming an image, using call IMATRM
• Converting the resolution of an image, using call IMARES
• Using IMXFER with target image the same as source image

Hierarchy of GDDM concepts

• The device
• Virtual devices
• The partition set
• The partition
• The page and page window
• The graphics field and the image field
• The picture space
• The viewport
• The graphics window
• Uniform world coordinates
• How to avoid inverting the graphics window
• The graphics segment
• Redefining objects in the hierarchy
• Viewports and graphics windows
• Picture space and graphics field
• Other objects
• Example: Program using the GDDM hierarchy
• Concepts introduced by the TWOPAGE program
• A graphics hierarchy with two devices
• Graphics clipping
• Precise clipping at the data boundary
• Rough clipping at the data boundary
• Drawing graphics outside the segment viewing limits

Error handling and debugging

• The causes of errors in GDDM application programs
• GDDM error messages
• Identifying bugs in your program
• Querying the GDDM error record, using FSQERR
• Using GDDM trace to debug application programs
• Printing trace output
• Specifying when trace is to be invoked
• Format of the trace output file
• Error information returned in a control block
• Information returned in register 15
• Error information for the reentrant and system programmer interfaces
• Writing programs that can cope with error conditions
• Specifying an error exit and threshold, using call FSEXIT
• Using the default error-exit routine
• Language considerations for specifying error exit routines
• Example of an error exit routine, using FSEXIT
• Example of an error exit routine, without using FSEXIT
• Bypassing GDDM's parameter checking to improve the speed of applications

Manipulating graphics segments

• Creating segments, using GSSEG
• Deleting segments, using GSSDEL
• Segment attributes
• Unnamed segments
• Transforming segments, using GSSAGA or GSSTFM
• How and when transformations take effect
• Transforming text, markers, and graphics images
• Moving a segment and its origin using call GSSPOS
• Transforming segments using call GSSTFM
• Querying transforms
• Examples of transformations
• Moving the origin of a segment, using GSSORG
• Transforming primitives within a segment, using GSSCT
• Copying segments, using GSSCPY
• Including segments, using GSSINC
• Combining segments, using GSSINC and GSSDEL
• Drawing chain and segment priority
• Querying the order of all segments, using GSQPRI
• Calling segments from other segments, using GSCALL
• Graphics attribute handling with called segments
• Graphics not in named segments
• Primitives outside segments

Storing and retrieving graphics pictures

• The stored-graphics formats that GDDM supports
• Saving pictures in Graphics Data Format, using call GSSAVE
• Saving all graphics on the current page
• Selecting individual segments to be saved
• Naming the file or data set in which the GDF data is to be saved
• Specifying whether GDF files of the same name should be overwritten
• Choosing the type of GDF data for the graphics you want to save
• Inter-Release compatibility
• Saving pictures in Computer Graphics Metafile, using call CGSAVE
• Naming the file or data set in which the CGM data is to be saved
• Using a conversion profile to store CGM orders that suit another application
• Specifying a code page for saved CGM data
• Including descriptive text in the CGM data saved
• Retrieving graphics pictures from external storage
• Retrieving pictures stored in Graphics Data Format, using call GSLOAD
• Avoiding clashes between the identifiers of new and loaded segments
• Specifying whether saved segments be transformed when loaded
• Loading the drawing-default definitions of saved graphics
• Coping with GDF orders that call unsaved segments
• Loading a GDF file that refers to a symbol set
• Loading a GDF file that contains unnamed segments
• Loading a GDF with untagged primitives
• The three types of load
• Load type 1: Preserving the coordinates of the picture
• Load type 2: Maximizing the size of the picture
• Load type 3: Preserving the size of the picture
• Maintaining a library of segments
• Panning and zooming
• Retrieving pictures stored in CGM format, using call CGLOAD
• Retrieving pictures stored in PIF format, using call GSLOAD
• Modifying graphics pictures that have been loaded into your program
• Placing graphics data from the GDDM page in a program variable
• Device variations with GDF

Writing interactive graphics applications

• Overview of graphics input functions
• Simple interactive graphics program
• Locator input
• Choice input
• Enabling data keys for choice input in applications
• Effects of stroke and string devices
• Choice devices as triggers
• Processing choice input from the data keys
• String input
• Enabling end users to draw graphics with the puck, mouse, or stylus
• Querying stroke input
• Simple polyline program
• Enabling or disabling a logical input device, using call GSENAB
• Passing input to your program, using call GSREAD
• Checking for further graphics input records using call GSQSIM
• Handling the input queue
• Using ASREAD instead of GSREAD
• Initializing logical input devices
• Initializing a locator device, using call GSILOC
• Specifying locator-echo type and initial position, using call GSILOC
• Initializing a rubber-band locator
• Initializing a rubber-box locator
• Initializing a segment locator
• Initializing a segment-transform locator for applications running on GDDM-OS/2 Link
• Initializing a pick device, using calls GSIPIK and GSIDVF
• Specifying initial position of a pick device
• Setting the pick aperture
• Initializing a string device, using calls GSISTR and GSIDVI
• Initializing a stroke device, using call GSISTK
• Using a locator, pick, and stroke device together
• When to issue GSENAB calls
• Querying a logical input device
• Segment-picking example
• Simple free-hand drawing program
• Dragging segments
• How the 3270-PC/G and GX draw echoes
• Local origin when dragging a segment
• Local origin when transforming a segment
• Panning and zooming
• Retained and nonretained modes on the 3270-PC/G and GX
• Query primitives and segments in specified area using call GSCORR
• Querying segment structure in specified area using call GSCORS
• Interactive graphics with multiple partitions
• Device variations with interactive graphics
• On other terminals with vector graphics capabilities
• On terminals that use PS stores for graphics
• On the IBM 5080 and 6090 graphics systems
• 5550-family Multistation

Using symbol sets

• General information about symbol sets
• Loading symbol sets for graphics text
• Specifying a symbol set for graphics text
• Loading symbol sets for alphanumeric text
• Specifying a symbol set for use in an alphanumeric field
• Specifying a symbol set for individual characters in a field
• Input of character symbol-set attributes
• Multicolored image symbols
• Symbols for pounds, dollars, and cents
• Device-dependent symbol-set suffixes
• Manipulating symbol sets in a program
• Symbol sets and program variables
• Loading a symbol set from an application program
• Using double-byte characters for graphics text
• GDDM default required for Kanji and Simplified Chinese
• Using GDDM to convert character code pages for international applications
• General information on code pages and national characters
• Country-extended code pages
• CECPs supported by GDDM
• Code-page conversion
• Implicit conversion of code pages by GDDM
• Converting code pages using API calls in the program
• Translating user input on Japanese extended code pages using FSTRAN
• Translating Latin text input on Japanese (Katakana) Extended code page 290 to uppercase with ASFTRN
• Converting code pages for GDDM objects
• Compatibility with releases of GDDM before Version 2 Release 2
• GDDM code pages
• Inhibiting input of extended code points
• Code-page conversion for 4250 printers
• APL characters
• Device variations with symbol sets
• Transferring programs between different types of device
• Displays that use programmed symbols for graphics
• Querying PS stores
• Releasing a symbol set from a PS store
• Reserving or freeing a PS store
• IBM 3270-PC/G and GX workstations
• The PSLSS call
• The GSLSS call
• Graphics text:
• Printers managed by PSF and CDPF
• Graphics text:
• Plotters

Advanced procedural alphanumerics

• Example: Alphanumeric menu program
• Concepts introduced by the MENU program
• Defining multiple alphanumeric fields
• Setting the field attributes as you define the field
• Discovering how many fields on the current page were modified
• Identifying which fields have been modified
• Choosing advantageous field identifiers
• Redefining the attributes of existing fields
• Resetting the default value of an alphanumeric field attribute
• Processing an alphanumeric field with changed status
• Processing light-pen fields
• Using procedural alphanumerics for double-byte characters
• Example: Routine to fill an alphanumeric field with Kanji data
• Points illustrated by the example
• Performing output of strings mixing single- and double-byte characters
• Example: Routine to mix SBCS and DBCS data in an alphanumeric field
• Points illustrated by the example
• Returning the mixed-string contents of a user-input field to the application
• Cursor position with mixed-without-position fields
• Field outlining on the IBM 5550 Multistation
• Improving the performance of procedural alphanumerics applications

GDDM high-performance alphanumerics

• How to use high-performance alphanumerics
• Declaring and initializing the field list
• Declaring and initializing the bundle list
• Declaring and initializing the data buffer
• Mixing single-byte and double-byte character fields
• Example: Program displaying high-performance alphanumeric output
• Points illustrated by the EXHPA program
• Setting the status of field list
• Setting the depth, width, and cursor position of the field list
• Defining fields
• Setting the optional character attributes
• Specifying attributes for the alphanumeric fields
• Setting up the data buffer
• Defining a field list for the GDDM page
• Choosing modes of data transfer for HPA applications
• Changing the attributes of the alphanumeric field
• Returning HPA user input to the application
• Displaying alphanumeric fields again
• Field-list update rules
• Data buffer update rule
• Bundle list update rule
• Dynamic fields
• Programming HPA with interpreted languages
• Read-only storage
• Shared storage
• Choosing between validation and improved performance

Mapped alphanumerics

• Using predefined screen formats for alphanumeric applications
• A simple mapping application
• Tasks illustrated by the MAPEX01 program
• Compilation and execution of a mapping application program
• ADS conversion for mapping applications written in C/370
• A mapping application that sets up a dialog with the end user
• Why you do not always need to call MSPUT
• A typical mapping cycle
• Steps in creating a mapping application
• Changing existing maps
• Using more than one map to present and process alphanumeric information
• Using maps with positions fixed by GDDM-IMD
• Using several maps that position themselves relative to each other
• Example of a program that uses fixed and floating maps
• Points illustrated by the MAPEX04 programming example
• Querying changed maps
• Input from multiple copies of a map
• Device-independence for mapped-alphanumeric applications
• Attribute handling when mapgroup does not match device
• Output-only displays
• Mapping queries

Variations on a map

• Selecting fields from a map for use in complex dialogs
• Programming example using a selector adjunct to display a message
• Write, rewrite, and reject
• Selector adjuncts on input
• Effect of reject operation
• Uses of selector adjuncts
• Alarm and keyboard locking
• Effects of maps
• Other considerations
• Protecting fields from the end user
• The base attribute adjunct
• Defining the base attributes that are to apply to mapped fields
• The position of the cursor
• Positioning the cursor when your program sends output to the display
• Positioning the cursor dynamically
• Static positioning of the cursor
• Default positioning of the cursor
• Simple example using cursor adjuncts on output
• A typical cursor-positioning sequence
• Determining the cursor position following input by the end user
• Padding mapped fields with null characters
• Light pen and CURSR SEL key
• Example of selection with cursor, light pen, and PF key
• Specifying a PF key for alphanumeric input
• Changing the highlighting, color, and symbol sets of mapped fields
• Changing the attributes of individual characters in a mapped field
• Discovering which character attributes have been changed by the user
• Folding and justification of input
• Mapping and graphics
• Example of graphics in a mapped display

Using GDDM's advanced image functions

• Querying image devices
• Scanning gray-scale images
• Defining brightness conversion definition, using call IMRBRI
• Defining contrast conversion, using call IMRCON
• Defining the conversion algorithm, using call IMRCVB
• Ordering of brightness, contrast, and image type conversion calls
• Querying image-related device characteristics
• Querying formats supported by a device, using call ISQFOR
• Querying compressions supported by a device, using call ISQCOM
• Querying resolutions supported by a device, using call ISQRES
• Scaling an image to fit the display screen
• Interactive image manipulation, using image cursors
• Enabling or disabling device input, using call FSENAB
• Enabling or disabling an image cursor, using call ISENAB
• Querying the image locator cursor, using call ISQLOC
• Querying the image box cursor, using call ISQBOX
• Initializing the image cursors, using calls ISILOC and ISIBOX
• Local operations on the 3193 display station
• Interactive image manipulation example
• Transferring images into and out of your program
• Starting a PUT operation, using call IMAPTS
• PUTTING data into an image, using call IMAPT
• Ending a PUT operation, using call IMAPTE
• Starting a GET operation, using call IMAGTS
• GETTING data from an image, using call IMAGT
• Ending a GET operation, using call IMAGTE
• Controlling host offload by specifying image quality
• Image size rounding
• Scaling and resolution conversion
• Scaling algorithm (also used in resolution conversion)
• Multiple extraction and placing of rectangles
• Controlling image quality, using call ISCTL or ISXCTL
• Direct transmission
• Direct transmission from a scanner
• Direct echoing when scanning
• Combining an image with text or graphics
• Defining an image field, using call ISFLD
• Querying the attributes of an image field, using call ISQFLD
• Printing images
• Printing an image on an IPDS printer
• 4028 as the primary output device
• Printing an image on a printer as the alternate device
• Improving the performance of image programs
• Image processing on image devices
• Image processing on graphics devices
• Device variations for image
• Displays that support graphics
• Image input to GDDM

Device support in application programs

• Using DSOPEN to tell GDDM about a device you intend to use
• Coding a complete device definition on the DSOPEN call
• Coding a partial device definition for end users to change with nicknames
• How GDDM compounds device-definition information for a conceptual device
• Offering end users a menu of devices available for output
• Points illustrated by the DEVDISP program
• How a nickname can cause a device definition to be revised completely
• Rescanning nicknames when TONAME or TOFAM is specified
• Coding nickname statements within application programs
• Encoding nickname statements to improve application performance
• Syntax rules for coding source-format nickname statements
• Specifying device usage using the DSUSE call
• Discontinuing use of a device, using DSDROP
• Using the default primary device
• Sending output to a device other than the invoking device
• Using more than one primary device
• Example: Program using two primary devices
• Points illustrated by the SCREEN2 program
• Opening and using a dummy device
• Example: Program using a dummy device to create a stored picture
• Closing a device using the DSCLS call
• Reinitializing a device, using the DSRINIT call

Designing device-independent programs

• Device dependence in GDDM application programs
• Coping with device variation and dependence in your programs
• Avoiding dependencies when opening and using devices
• Querying the conceptual device, using the DSQDEV call
• Querying characteristics of the physical device, using the FSQURY call
• Setting up a GDDM hierarchy that suits most devices
• Device considerations for graphics functions
• Device considerations for graphics-text functions
• Device considerations for alphanumeric functions
• Device considerations for interactive-graphics functions
• Device considerations for partitioning functions
• Applications for devices that use programmed symbols
• Device considerations for image functions

Sending output from an application to a printer

• Overview of printing with GDDM
• Family-1 output: GDDM directly attached printers
• Family-2 output: Print files for GDDM queued printers
• Family-3 output: Print files for system printers
• Family-4 output: Print files for PostScript and PSF- and CDPF-attached printers
• Defining the area of the paper you want the printer to use
• Positioning graphics, image, and alphanumeric fields in the usable area
• Directing the program's output
• Specifying the format to be used for family-4 output
• Creating formatted output including GOCA, IOCA, and PTOCA objects
• Reducing program storage when generating rastered image output
• Specifying a data stream to suit the purposes of your family-4 output
• Creating an integral document
• Creating an encapsulated PostScript file, a page segment, or an overlay
• Retrieving family-4 output for the application
• Using a printer as an alternate device
• Copying a transformed picture to a printer, using call DSCOPY
• Copying a page to a printer using call FSCOPY
• Copying graphics to a printer using call GSCOPY
• Sending a character string to a printer using call FSLOG
• Sending a character string with control character to printer using call FSLOGC
• Example: Copying screen output to a printer
• Printing GDDM family-2 print files
• Printing composite documents
• Example: Program to print a composite document
• Controlling how end users browse composite documents
• Specifying the device for CDPU output
• Printing non-GDDM sequential files
• Re-rastering when copying
• Mixed graphics and alphanumerics
• Using loadable symbol sets on family-3 3800 printer
• Using typographic fonts on a family-4 4250 printer
• Code-page support for 4250 output
• Ordering of font and code page calls
• Example: Program using 4250 fonts
• Color masters for publications
• DSOPEN statement for color masters

Sending output from an application to a plotter

• DSOPEN for plotters
• Processing options for plotters
• Controlling the velocity of plotter pens
• Specifying the width of plotter pen used
• Controlling the pressure of plotter pens on paper
• Specifying the plotting area
• Selecting the size of paper for the plotter
• Picture orientation
• Saving plotted output in a file
• Setting up the plotter
• Terminating a plot
• Cells, pixels, and plotter units
• A simple plotting program
• Copying screen output to a plotter
• Plotting to scale
• Using nicknames to direct and control plotted output
• Diverting a program's output from a printer to a plotter
• Diverting a program's output from a plotter to a printer
• Diverting a program's output from a plotter to an IBM-GL file
• Supplying processing options
• Special considerations for graphics on plotters
• Colors
• Color mixing
• Graphics images and image symbols
• Line types and widths
• Shading patterns
• Symbol sets
• Optimum pen speed and pressure

Designing end-user interfaces for your applications

• Using partitions to divide up the screen
• A simple partitioning example
• Setting up a grid in which to define partitions
• Creating partitions
• Current partition sets, partitions, and pages
• Input/Output
• Active and current partitions
• Handling terminal-user errors
• Some other things you can do with partitions
• Visible and invisible partitions
• Overlapping partitions
• Prioritizing partitions
• Querying the priority of overlapping partitions
• Other calls that operate on partitions and partition sets
• Large and small pages
• Scrolling
• Variable character size
• Effects on graphics of scrolling and variable cell size
• Partitioning with scrolling and variable cell size
• Using operator windows to write task-manager programs
• Example: Program using one operator window
• Example: Program using two operator windows
• Modifying the attributes of an operator window, using call WSMOD
• Prioritizing operator windows
• Querying the priority of overlapping operator windows
• Querying operator window attributes, using WSQRY
• Task management
• Running existing GDDM applications under a task manager
• How FSSAVE and FSSHOW perform with operator windows
• Allocation of resources to operator windows
• How to free resources when a task terminates

Programming examples

• A System/370 Assembler programming example
• An APL2 programming example
• A BASIC programming example
• A C/370 programming example
• A REXX programming example
• A CICS pseudoconversational programming example

Appendix A. GDDM sample programs

• Sample program 1
• IMS version of sample program 1
• Sample program 2
• IMS version of sample program 2
• Sample program 3
• Sample program 4
• What sample program 4 does
• Invoking ADMUSP4
• Sample program 8
• Compiling and link-editing sample program 8 under TSO
• Running sample program 8 under TSO
• Compiling sample program 8 under VM/CMS
• Running sample program 8 under VM/CMS
• Using the sample task manager
• Compiling, link-editing, and running the sample programs
• Compiling the programs
• Link-editing the programs
• Running the sample programs
• REXX sample programs

Appendix B. Programming with GDDM under VM/CMS

• How to compile, load, and run a PL/I GDDM application program
• Running a GDDM utility program
• Considerations for running multiple instances of GDDM
• Native CMS files
• Native CMS spool files
• Display terminal conventions
• Asynchronous interrupts on VM/CMS
• Using the ENTER key
• Using other attention keys
• VM-initiated asynchronous interrupts
• Interactions with non-GDDM device interrupt handling
• Dialed devices
• Using APL terminals
• Using nonqueriable displays with the APL feature
• Using nonqueriable printers with the APL feature
• Batch processing
• GDDM application programs under VM/XA

Appendix C. Programming with GDDM under TSO

• Link-editing a GDDM application program
• Using the system programmer interface by means of dynamic load
• Data sets
• Partitioned data sets
• Sequential data sets
• Direct access data sets
• File-name usage
• Display terminal processing
• Using the CLEAR key in full-screen mode
• Entering attention interrupts in full-screen mode
• Reshow key processing in full-screen mode
• Device errors in full-screen mode
• Line-by-line input in full-screen mode
• NOEDIT mode under TSO
• Mixing GDDM I/O with nonGDDM I/O
• Using APL terminals
• Using GDDM under TSO batch
• Using GDDM under MVS batch
• Programming under TSO on extensions of MVS
• GDDM code above 16 megabytes
• Application code above 16 megabytes
• AMODE(31) applications and application parameters above 16 megabytes
• Application programming considerations
• User exits
• Example: JCL for link-editing GDDM applications under TSO

Appendix D. Programming with GDDM under IMS

• Restrictions on the use of GDDM under IMS
• The structure of GDDM application programs for use on IMS
• Programming under IMS on extensions of MVS
• GDDM code above 16 megabytes
• Application code above 16 megabytes
• AMODE(31) applications and application parameters above 16 megabytes
• Application programming considerations
• User exits
• Link-editing a GDDM application program
• Using the system programmer interface with dynamic load
• Program specification blocks for GDDM applications
• Data sets and file processing
• Specifying the default error exit under IMS
• GDDM and the Message Format Service
• GDDM DL/I interface
• Use of message queues
• 3270-family devices
• Queued printer devices
• System printer devices
• Use of databases
• IMS considerations for GDDM utilities
• GDDM object import/export utility
• Example: JCL to compile and link PL/I GDDM applications under IMS
• Example: JCL to compile and link COBOL GDDM applications under IMS

Appendix E. Programming GDDM applications for use with CICS

• Programming languages and restrictions
• CICS conversational applications
• CICS pseudoconversational applications
• Transaction-dependent pseudoconversations
• Typical call sequences for transaction-dependent pseudoconversations
• Transaction-independent pseudoconversations
• Typical call sequences for transaction-independent pseudoconversations
• Requesting transaction-independent services
• Using the resource audit trails
• Using GDDM with Basic Mapping Support
• Using GDDM and Basic Mapping Support consecutively
• Using GDDM and BMS concurrently without coordination mode
• Using GDDM and BMS concurrently with coordination mode
• CICS GDDM default error exit
• Display terminal conventions
• Using the GDDM nonreentrant interface
• Using the GDDM system programmer interface with dynamic load
• Data sets and file processing
• VSAM key-sequenced data sets
• Transient data queues
• Temporary storage data sets
• Programming under CICS on extensions of MVS
• GDDM code above 16 megabytes
• Application code above 16 megabytes
• AMODE(31) applications and application parameters above 16 megabytes
• Application programming considerations
• User exits
• Compiling and link-editing GDDM application programs
• Compiling a PL/I program
• Link-editing a GDDM application program under CICS
• Link-editing GDDM applications with CICS on MVS
• Link-editing a GDDM application with CICS on VSE
• Example of JCL for compiling and linking PL/I GDDM/CICS applications on MVS
• Example: JCL to compile and link COBOL GDDM/CICS applications on MVS
• Example of JCL for compiling and linking C/370 GDDM/CICS applications on MVS
• Example: JCL to assemble and link-edit Assembler GDDM/CICS applications on MVS
• Example: JCL to compile and link PL/I GDDM/CICS applications on VSE
• Example: JCL to compile and link COBOL GDDM/CICS applications on VSE
• Example: JCL to compile and link C/370 GDDM/CICS applications on VSE
• Example: JCL for GDDM under CICS/VSE using Assembler

Appendix F. Programming with GDDM using VSE batch mode

• Link-editing
• Using the system programmer interface with dynamic load
• Large 4250 page segments
• Spill files

Glossary

Index