|
|
|
|
(* *HTMLGEN InsertUnitDocStart SGK_UnitDoc* *)
(**
SGK - SageST main graphics module.
This unit contains the main routines that support doing graphics operations
in SageST. There are constants and types declared in this module that are
used throughout all the graphics units.
Copyright (C) Idaho National Laboratory (INL) All Rights Reserved
*)
(* *HTMLGEN InsertUnitDocEnd* *)
PROCEDURE ClearDevice
(CONST deviceHandle : GPDevice);
(* *HTMLGEN InsertProcDocStart SGK_ClearDevice* *)
(**
ClearDevice - Paint device with device's color one.
The display area of the device defined by 'deviceHandle' is
painted with solid fill in color table entry one.
CALLING SEQUENCE -
ClearDevice (deviceHandle)
ENTRY -
deviceHandle : GPDevice
A handle to an open device.
*)
(* *HTMLGEN InsertProcDocEnd* *)
PROCEDURE CloseDevice
(CONST deviceHandle : GPDevice;
CONST done : BOOLEAN);
(* *HTMLGEN InsertProcDocStart SGK_CloseDevice* *)
(**
CloseDevice - Close a device in use.
Close a currently open device and deallocate any memory used for
that device.
The device is no longer available unless it is opened again.
Upon return deviceHandle is undefined.
CALLING SEQUENCE -
CloseDevice (deviceHandle)
ENTRY -
deviceHandle : GPDevice
A handle to an open device.
done : BOOLEAN
(Windows only, printing only)
False will send the output produced so far to the printer,
but will not actually close the device, so that you may
pass the device handle back into OpenDevice with the printer
information intact (a printer prompt will not reoccur)
You must call CloseDevice with continue set to True
when you are really finished. For example
OpenDevice (dH .. .
REPEAT
DrawStuff (dH, done)
CloseDevice (dH, True);
UNTIL done;
CloseDevice (dH);
*)
(* *HTMLGEN InsertProcDocEnd* *)
PROCEDURE GetActiveState
(CONST deviceHandle : GPDevice;
VAR IsOn : BOOLEAN);
(* *HTMLGEN InsertProcDocStart SGK_GetActiveState* *)
(**
GetActiveState - Get the active state of a device.
Gets the active state of a device.
If on is True the drawing of output primitives to the device is
enabled, otherwise drawing is disabled. This state is initially set by
'OpenDevice'.
CALLING SEQUENCE -
GetActiveState (deviceHandle, IsOn)
ENTRY -
deviceHandle : GPDevice
A handle to an open device.
EXIT -
IsOn : BOOLEAN
If True then output primitives are drawn, else they are not.
*)
(* *HTMLGEN InsertProcDocEnd* *)
PROCEDURE GetColorTable
(CONST deviceHandle : GPDevice;
VAR redArray : GARGB;
VAR greenArray : GARGB;
VAR blueArray : GARGB);
(* *HTMLGEN InsertProcDocStart SGK_GetColorTable* *)
(**
GetColorTable - Get a device's color table.
Each device has associated with it a color table comprised of
1 .. MAXCOLORINDEX entries which define the color palette for the
device.
Entries in a color table are defined by giving the red, green and
blue color components, and the entry number.
The color components are defined in terms of [0 .. 255] levels of
intensity. 0 = lowest intensity (usually lack of color).
The entire color table entries may be read by using the 'redArray',
'greenArray', and 'blueArray' color component arrays.
CALLING SEQUENCE -
GetColorTable (deviceHandle, redArray, greenArray, blueArray)
ENTRY -
deviceHandle : GPDevice
A handle to an open device.
EXIT -
redArray : GARGB
The desired color component intensity arrays.
greenArray : GARGB
The desired color component intensity arrays.
blueArray : GARGB
The desired color component intensity arrays.
*)
(* *HTMLGEN InsertProcDocEnd* *)
PROCEDURE GetColorTableEntry
(CONST deviceHandle : GPDevice;
CONST EntryValue : GTColorTableEntry;
VAR Red : GTRGB;
VAR Green : GTRGB;
VAR Blue : GTRGB);
(* *HTMLGEN InsertProcDocStart SGK_GetColorTableEntry* *)
(**
GetColorTableEntry - Get an entry in a device's color table.
Each device has associated with it a color table comprised of
1 .. MAXCOLORINDEX entries which define the color palette for the
device.
Entries in a color table are defined by giving the red, green and
blue color components, and the entry number.
The color components are defined in terms of [0 .. 255] levels of
intensity. 0 = lowest intensity (usually lack of color).
CALLING SEQUENCE -
GetColorTableEntry (deviceHandle, EntryValue, red, green, blue)
ENTRY -
deviceHandle : GPDevice
A handle to an open device.
EntryValue : GTColorTableEntry
The color table entry to be modified.
EXIT -
red : GTRGB
The desired color component intensities.
green : GTRGB
The desired color component intensities.
blue : GTRGB
The desired color component intensities.
*)
(* *HTMLGEN InsertProcDocEnd* *)
PROCEDURE SGKIsOpen
() : BOOLEAN;
(* *HTMLGEN InsertProcDocStart SGK_SGKIsOpen* *)
(**
SGKIsOpen - Check if SGK is still open.
Check if SGK is still open and return a boolean indicating
the results.
CALLING SEQUENCE -
SGKOpen := SGKIsOpen ()
EXIT -
SGKIsOpen : BOOLEAN
True - SGK is still open and active.
False - SGK is currently in a closed state.
*)
(* *HTMLGEN InsertProcDocEnd* *)
PROCEDURE ADeviceIsOpen
() : BOOLEAN;
(* *HTMLGEN InsertProcDocStart SGK_ADeviceIsOpen* *)
(**
ADeviceIsOpen - Check if there are any open devices.
Check if there are any open devices and return a boolean indicating
the results.
CALLING SEQUENCE -
DevOpen := ADeviceIsOpen ()
EXIT -
ADeviceIsOpen : BOOLEAN
True - There is at least one device still open.
False - There are zero devices open.
*)
(* *HTMLGEN InsertProcDocEnd* *)
PROCEDURE GetDevice
(CONST deviceHandle : GPDevice;
VAR Device : GAName;
VAR port : ARRAY OF CHAR;
VAR FileName : ARRAY OF CHAR);
(* *HTMLGEN InsertProcDocStart SGK_GetDevice* *)
(**
GetDevice - Get information about a device.
Get the device name, port, and possibly file name associated with
'deviceHandle'.
CALLING SEQUENCE -
GetDevice (deviceHandle, device, port, fileName)
ENTRY -
deviceHandle : GPDevice
A handle to an open device.
EXIT -
device : ARRAY OF CHAR
The name of the device associated with 'deviceHandle'.
port : ARRAY OF CHAR
The name of the port associated with 'deviceHandle'.
fileName : ARRAY OF CHAR
If port is 'FILE' then this parameter contains the file's
path and name.
*)
(* *HTMLGEN InsertProcDocEnd* *)
PROCEDURE GetDeviceLocation
(CONST deviceHandle : GPDevice;
VAR minX : ModSys.S_Integer;
VAR minY : ModSys.S_Integer;
VAR maxX : ModSys.S_Integer;
VAR maxY : ModSys.S_Integer);
(* *HTMLGEN InsertProcDocStart SGK_GetDeviceLocation* *)
(**
GetDeviceLocation - Get the min and max for a device.
Get the rectangle in device coordinates where all device output
will be rendered.
CALLING SEQUENCE -
GetDeviceLocation (deviceHandle, minX, minY, maxX, maxY)
ENTRY -
deviceHandle : GPDevice
A handle to an open device.
EXIT -
minX, minY : ModSys.S_Natural
The lower left corner of the device rendering rectangle.
maxX, maxY : ModSys.S_Natural
The upper right corner of the device rendering rectangle.
*)
(* *HTMLGEN InsertProcDocEnd* *)
PROCEDURE GetMaxAllocation
() : ModSys.S_Natural;
(* *HTMLGEN InsertProcDocStart SGK_GetMaxAllocation* *)
(**
GetMaxAllocation - Get the maximum allowed memory allocation size.
Get the maximum allowed memory allocation size used by fonts and
devices.
CALLING SEQUENCE -
maxAlloc := GetMaxAllocation ()
EXIT -
maxAlloc : ModSys.S_Natural
The maximum allocation size.
*)
(* *HTMLGEN InsertProcDocEnd* *)
PROCEDURE GetMaxColors
(CONST deviceHandle : GPDevice;
VAR numberOfColors : ModSys.S_Natural;
VAR colorAvailable : GEColor);
(* *HTMLGEN InsertProcDocStart SGK_GetMaxColors* *)
(**
GetMaxColors - Get the maximum displayable colors for a device.
Get the maximum number of concurrent colors available for a given
device, and if the device is color or monochrome.
CALLING SEQUENCE -
GetMaxColors (deviceHandle, numberOfColors, colorAvailable)
ENTRY -
deviceHandle : GPDevice
A handle to an open device.
EXIT -
numberOfColors : ModSys.S_Natural
The number of displayable colors.
colorAvailable : GEColor
The monochrome/color characteristics of the device.
(color, mono)
*)
(* *HTMLGEN InsertProcDocEnd* *)
PROCEDURE GetPixelHeight
(CONST Pixels : ModSys.S_Natural;
VAR height : GTCoordinate);
(* *HTMLGEN InsertProcDocStart SGK_GetPixelHeight* *)
(**
GetPixelHeight - The height of pixels in window coordinates.
Get the height of 'pixels' in terms of the active window.
'pixels' is in terms of the console device only.
CALLING SEQUENCE -
GetPixelHeight (pixels, height)
ENTRY -
pixels : ModSys.S_Natural
Height in pixels.
EXIT -
height : GTCoordinate
The height of pixels in window coordinates.
*)
(* *HTMLGEN InsertProcDocEnd* *)
PROCEDURE GetPixelWidth
(CONST Pixels : ModSys.S_Natural;
VAR width : GTCoordinate);
(* *HTMLGEN InsertProcDocStart SGK_GetPixelWidth* *)
(**
GetPixelWidth - The width of pixels in window coordinates.
Get the width of 'pixels' in terms of the active window.
'pixels' is in terms of the console device only.
CALLING SEQUENCE -
GetPixelWidth (pixels, width)
ENTRY -
pixels : ModSys.S_Natural
Width in pixels.
EXIT -
width : GTCoordinate
The width of pixels in window coordinates.
*)
(* *HTMLGEN InsertProcDocEnd* *)
PROCEDURE GetTempPath
(VAR Path : ARRAY OF CHAR);
(* *HTMLGEN InsertProcDocStart SGK_GetTempPath* *)
(**
GetTempPath - Get the temporary file path set with a SetTempPath command.
CALLING SEQUENCE -
GetTempPath (path)
EXIT -
path : ARRAY OF CHAR
The path used to store temporary files in.
*)
(* *HTMLGEN InsertProcDocEnd* *)
PROCEDURE OpenDevice
(VAR deviceHandle : GPDevice;
VAR Device : GAName;
CONST parentWindow : WIN32.HWND;
CONST PortName : ARRAY OF CHAR;
CONST FileName : ARRAY OF CHAR);
(* *HTMLGEN InsertProcDocStart SGK_OpenDevice* *)
(**
OpenDevice - Add a device to the open list.
Specifies to the graphics system that the available device, given
by 'device', should be put into the open device list and
activated.
If 'device' is set to 'MAXRES' and 'port' is 'CON' the value
returned in 'device' will be set to the available device with the
maximum resolution that matches the video hardware of the sytem.
For a list of valid port names for a device see the documentation
of the particular device.
For Windows, the only valid devices are 'WINCON' and 'WINPRN'. To
output to an EMF file, use 'EMF' for the port and supply a file name.
Windows extra parameter is the hwnd to draw on, if provided.
CALLING SEQUENCE -
OpenDevice (deviceHandle, device, PortName, fileName)
ENTRY -
device : ARRAY OF CHAR
The name of the device to open.
PortName : ARRAY OF CHAR
The name of the port to which the device will be attached.
fileName : ARRAY OF CHAR
If port is 'FILE' this parameter defines the file's path
and name.
EXIT -
deviceHandle : GPDevice
A handle to the opened device.
device : ARRAY OF CHAR
The name of the device opened.
*)
(* *HTMLGEN InsertProcDocEnd* *)
PROCEDURE PaintDevice
(CONST deviceHandle : GPDevice);
(* *HTMLGEN InsertProcDocStart SGK_PaintDevice* *)
(**
PaintDevice - Paint device with base window's fill style.
The display area of the device defined by 'deviceHandle' is
painted in the base window's fill style.
CALLING SEQUENCE -
PaintDevice (deviceHandle)
ENTRY -
deviceHandle : GPDevice
A handle to an open device.
*)
(* *HTMLGEN InsertProcDocEnd* *)
PROCEDURE SetActiveState
(CONST deviceHandle : GPDevice;
CONST IsOn : BOOLEAN);
(* *HTMLGEN InsertProcDocStart SGK_SetActiveState* *)
(**
SetActiveState - Enable/disable primitives on device.
Enable/disable the drawing of output primitives to an open device. This
state is initially set by 'OpenDevice'.
CALLING SEQUENCE -
SetActiveState (deviceHandle, IsOn)
ENTRY -
deviceHandle : GPDevice
A handle to an open device.
IsOn : BOOLEAN
If True then output primitives are drawn, else they are not.
*)
(* *HTMLGEN InsertProcDocEnd* *)
PROCEDURE SetColorTable
(CONST deviceHandle : GPDevice;
CONST redArray : GARGB;
CONST greenArray : GARGB;
CONST blueArray : GARGB);
(* *HTMLGEN InsertProcDocStart SGK_SetColorTable* *)
(**
SetColorTable - Set a device's color table.
Each device has associated with it a color table comprised of
1 .. MAXCOLORINDEX entries which define the color palette for the
device.
Entries in a color table are defined by giving the red, green and
blue color components, and the entry number.
The color components are defined in terms of [0 .. 255] levels of
intensity. 0 = lowest intensity (usually lack of color).
The entire color table may be set by defining all entries in
the color table using the 'redArray', 'greenArray', and 'blueArray'
color component arrays.
CALLING SEQUENCE -
SetColorTable (deviceHandle, redArray, greenArray, blueArray)
ENTRY -
deviceHandle : GPDevice
A handle to an open device.
redArray : GARGB
The desired color component intensity arrays.
greenArray : GARGB
The desired color component intensity arrays.
blueArray : GARGB
The desired color component intensity arrays.
*)
(* *HTMLGEN InsertProcDocEnd* *)
PROCEDURE SetColorTableEntry
(CONST deviceHandle : GPDevice;
CONST EntryValue : GTColorTableEntry;
CONST Red : GTRGB;
CONST Green : GTRGB;
CONST Blue : GTRGB);
(* *HTMLGEN InsertProcDocStart SGK_SetColorTableEntry* *)
(**
SetColorTableEntry - Define an entry in a device's color table.
Each device has associated with it a color table comprised of
1 .. MAXCOLORINDEX entries which define the color palette for the device.
Entries in a color table are defined by giving the red, green and
blue color components, and the entry number.
The color components are defined in terms of [0 .. 255] levels of
intensity. 0 = lowest intensity (usually lack of color).
CALLING SEQUENCE -
SetColorTableEntry (deviceHandle, EntryValue, red, green, blue)
ENTRY -
deviceHandle : GPDevice
A handle to an open device.
EntryValue : GTColorTableEntry
The color table entry to be modified.
red : GTRGB
The desired color component intensities.
green : GTRGB
The desired color component intensities.
blue : GTRGB
The desired color component intensities.
*)
(* *HTMLGEN InsertProcDocEnd* *)
PROCEDURE SetDeviceLocation
(CONST deviceHandle : GPDevice;
CONST minX : ModSys.S_Integer;
CONST minY : ModSys.S_Integer;
CONST maxX : ModSys.S_Integer;
CONST maxY : ModSys.S_Integer);
(* *HTMLGEN InsertProcDocStart SGK_SetDeviceLocation* *)
(**
SetDeviceLocation - Set the min and max for a device.
Set the rectangle in device coordinates where all device output
will be rendered.
CALLING SEQUENCE -
SetDeviceLocation (deviceHandle, minX, minY, maxX, maxY)
ENTRY -
deviceHandle : GPDevice
A handle to an open device.
EXIT -
minX, minY : ModSys.S_Natural
The lower left corner of the device rendering rectangle.
maxX, maxY : ModSys.S_Natural
The upper right corner of the device rendering rectangle.
*)
(* *HTMLGEN InsertProcDocEnd* *)
PROCEDURE SetMaxAllocation
(CONST maxAllocation : ModSys.S_Natural);
(* *HTMLGEN InsertProcDocStart SGK_SetMaxAllocation* *)
(**
SetMaxAllocation - Set the maximum allowed memory allocation size.
Set the maximum allowed memory allocation size used by fonts and
devices.
CALLING SEQUENCE -
SetMaxAllocation (maxAllocation)
ENTRY -
maxAllocation : ModSys.S_Natural
The maximum allocation size.
*)
(* *HTMLGEN InsertProcDocEnd* *)
PROCEDURE SetTempPath
(CONST Path : ARRAY OF CHAR);
(* *HTMLGEN InsertProcDocStart SGK_SetTempPath* *)
(**
SetTempPath - Set path for temporary files.
Set the path that SGK uses to store its temporary files. The path
must be such that a filename directly appended onto the end of
'path' is a valid DOS filename.
CALLING SEQUENCE -
SetTempPath (path)
ENTRY -
path : ARRAY OF CHAR
The path to store temporary files in.
EXAMPLE -
SetTempPath ('C:\TEMP\');
*)
(* *HTMLGEN InsertProcDocEnd* *)
PROCEDURE CloseFont
(CONST FontHandle : GPFont);
(* *HTMLGEN InsertProcDocStart SGK_CloseFont* *)
(**
CloseFont - Close a font in use.
Close a currently open font and deallocate any memory used for
that font.
The font is no longer available unless it is opened again.
Upon return fontHandle is undefined.
CALLING SEQUENCE -
CloseFont (fontHandle)
ENTRY -
fontHandle : GPFont
A handle to an open font.
*)
(* *HTMLGEN InsertProcDocEnd* *)
PROCEDURE GetTextMetrics
(CONST FontHandle : GPFont;
VAR metrics : GRTextMetrics);
(* *HTMLGEN InsertProcDocStart SGK_GetTextMetrics* *)
(**
GetTextMetrics - Get text metric information.
Returns information about the font 'fontHandle'.
The metrics includes the following attributes:
maxHeight : GTCoordinate; -- The maximum height of all characters
maxWidth : GTCoordinate; -- The maximum width of all characters
maxDescender : GTCoordinate; -- The maximum descender of all characters
avgHeight : GTCoordinate; -- The average height of all characters
avgWidth : GTCoordinate; -- The average width of all characters
avgDescender : GTCoordinate; -- The average descender of all characters
CALLING SEQUENCE -
GetTextMetrics (fontHandle, metrics)
ENTRY -
fontHandle : GPFont
The handle to the font.
EXIT -
metrics : GRTextMetrics
The text metrics.
*)
(* *HTMLGEN InsertProcDocEnd* *)
PROCEDURE OpenFont
(VAR FontHandle : GPFont;
CONST FontName : ARRAY OF CHAR;
CONST FileName : ARRAY OF CHAR);
(* *HTMLGEN InsertProcDocStart SGK_OpenFont* *)
(**
OpenFont - Add a font to the open list.
Specifies to the graphics system that the available font, given
by 'fontName' and 'fileName', should be put into the open
font list.
'fontName' is the name of a particular font and 'fileName' the
name of the DOS file containing the font definitions.
For a list of valid 'fontName's see the documentation.
CALLING SEQUENCE -
OpenFont (fontHandle, fontName, fileName)
ENTRY -
fontName : ARRAY OF CHAR
The name of the font to open.
fileName : ARRAY OF CHAR
The name of the DOS file containing the font.
EXIT -
fontHandle : GPFont
A handle to the opened font.
*)
(* *HTMLGEN InsertProcDocEnd* *)
PROCEDURE GetLimitingWindow
(VAR WindowHandle : GPWindow);
(* *HTMLGEN InsertProcDocStart SGK_GetLimitingWindow* *)
(**
GetLimitingWindow - Get the handle of locator limiting window.
CALLING SEQUENCE -
GetLimitingWindow (windowHandle)
EXIT -
windowHandle : GPWindow
The handle of the window to which the locator is limited.
*)
(* *HTMLGEN InsertProcDocEnd* *)
PROCEDURE GetLocatorSettings
(VAR Settings : GRLocatorSettings);
(* *HTMLGEN InsertProcDocStart SGK_GetLocatorSettings* *)
(**
GetLocatorSettings - Get the settings for the locator.
The settings for the locator are as follows:
pattern : GRLocator; -- Desired locator style
color0 : GTColorTableEntry; -- Locator's color 0
color1 : GTColorTableEntry; -- Locator's color 1
kbdArrowsEnabled : boolean; -- Allow kbd arrows to move locator
kbdButtonsEnabled : boolean; -- Allow kbd buttons to be used
mouseButtonsEnabled : boolean; -- Allow mouse buttons to be used
mouseMovementEnabled : boolean; -- Allow mouse movement to be used
mouseHorzSensitivity : ModSys.S_Natural; -- Mouse units per horizontal movement
mouseVertSensitivity : ModSys.S_Natural; -- Mouse units per vertical movement
kbdSnapX : GTCoordinate; -- X snap grid for keyboard
kbdSnapY : GTCoordinate; -- Y snap grid for keyboard
mouseSnapX : GTCoordinate; -- X snap grid for mouse
mouseSnapY : GTCoordinate; -- Y snap grid for mouse
CALLING SEQUENCE -
GetLocatorSettings (settings)
EXIT -
settings : GRLocatorSettings
The settings for the locator.
*)
(* *HTMLGEN InsertProcDocEnd* *)
PROCEDURE GetVisibilityStatus
(VAR IsOn : BOOLEAN);
(* *HTMLGEN InsertProcDocStart SGK_GetVisibilityStatus* *)
(**
GetVisibilityStatus - Get visibility status of locator.
CALLING SEQUENCE -
GetVisibilityStatus (IsOn)
EXIT -
IsOn : BOOLEAN
True means the locator is visible and False means it is not.
*)
(* *HTMLGEN InsertProcDocEnd* *)
PROCEDURE PositionLocator
(CONST XVal : GTCoordinate;
CONST YVal : GTCoordinate);
(* *HTMLGEN InsertProcDocStart SGK_PositionLocator* *)
(**
PositionLocator - Position locator in active window.
Positions the locator in the active window at 'x, y'.
CALLING SEQUENCE -
PositionLocator (x, y)
ENTRY -
XVal, YVal : GTCoordinate
The coordinates for the position of the locator in the
current window. These are window coordinates.
*)
(* *HTMLGEN InsertProcDocEnd* *)
PROCEDURE ReadLocator
(VAR Window : GPWindow;
VAR XVal : GTCoordinate;
VAR YVal : GTCoordinate);
(* *HTMLGEN InsertProcDocStart SGK_ReadLocator* *)
(**
ReadLocator - Read the locator position.
Get the window and the window coordinates of the locator's
position. The window returned will be the highest (closest to zero)
priority window.
CALLING SEQUENCE -
ReadLocator (window, XVal, YVal)
EXIT -
window : GPWindow
The window in which the locator is located.
XVal, YVal : GTCoordinate
The coordinates in 'window' at which the locator is
located.
input : InputType
The input read from the keyboard or mouse, or INONE if none.
*)
(* *HTMLGEN InsertProcDocEnd* *)
PROCEDURE SetLimitingWindow
(CONST WindowHandle : GPWindow);
(* *HTMLGEN InsertProcDocStart SGK_SetLimitingWindow* *)
(**
SetLimitingWindow - Set the handle of locator limiting window.
CALLING SEQUENCE -
SetLimitingWindow (windowHandle)
ENTRY -
windowHandle : GPWindow
The handle of the window to which the locator is limited.
*)
(* *HTMLGEN InsertProcDocEnd* *)
PROCEDURE SetLocatorSettings
(CONST Settings : GRLocatorSettings);
(* *HTMLGEN InsertProcDocStart SGK_SetLocatorSettings* *)
(**
SetLocatorSettings - Set the settings for the locator.
The settings for the locator are as follows:
pattern : GRLocator; -- Desired locator style
color0 : GTColorTableEntry; -- Locator's color 0
color1 : GTColorTableEntry; -- Locator's color 1
kbdArrowsEnabled : boolean; -- Allow kbd arrows to move locator
kbdButtonsEnabled : boolean; -- Allow kbd buttons to be used
mouseButtonsEnabled : boolean; -- Allow mouse buttons to be used
mouseMovementEnabled : boolean; -- Allow mouse movement to be used
mouseHorzSensitivity : ModSys.S_Natural; -- Mouse units per horizontal movement
mouseVertSensitivity : ModSys.S_Natural; -- Mouse units per vertical movement
kbdSnapX : GTCoordinate; -- X snap grid for keyboard
kbdSnapY : GTCoordinate; -- Y snap grid for keyboard
mouseSnapX : GTCoordinate; -- X snap grid for mouse
mouseSnapY : GTCoordinate; -- Y snap grid for mouse
CALLING SEQUENCE -
SetLocatorSettings (settings)
ENTRY -
settings : GRLocatorSettings
The settings for the locator.
*)
(* *HTMLGEN InsertProcDocEnd* *)
PROCEDURE SetVisibilityStatus
(CONST IsOn : BOOLEAN);
(* *HTMLGEN InsertProcDocStart SGK_SetVisibilityStatus* *)
(**
SetVisibilityStatus - Set visibility status of locator.
CALLING SEQUENCE -
SetVisibilityStatus (IsOn)
ENTRY -
IsOn : BOOLEAN
True means the locator is visible and False means it is not.
*)
(* *HTMLGEN InsertProcDocEnd* *)
PROCEDURE WaitForAndCopyInput
() : SGKInputs.InputType;
(* *HTMLGEN InsertProcDocStart SGK_WaitForAndCopyInput* *)
(**
WaitForAndCopyInput - Waits for then copies the current input.
This routine waits for then copies the current input value.
Locator position will be updated while waiting.
CALLING SEQUENCE -
input := WaitForAndCopyInput ()
EXIT -
input : InputType
The current input value.
*)
(* *HTMLGEN InsertProcDocEnd* *)
PROCEDURE WaitForAndReadInput
() : SGKInputs.InputType;
(* *HTMLGEN InsertProcDocStart SGK_WaitForAndReadInput* *)
(**
WaitForAndReadInput - Waits for then reads the current input.
This routine waits for then reads the current input value.
Locator position will be updated while waiting.
CALLING SEQUENCE -
input := WaitForAndReadInput ()
EXIT -
input : InputType
The current input value.
*)
(* *HTMLGEN InsertProcDocEnd* *)
PROCEDURE WaitForNoInput;
(* *HTMLGEN InsertProcDocStart SGK_WaitForNoInput* *)
(**
WaitForNoInput - Waits until no input read.
This routine waits until the current input value is
equal to SGK.INONE.
CALLING SEQUENCE -
WaitForNoInput
*)
(* *HTMLGEN InsertProcDocEnd* *)
PROCEDURE Arc
(CONST xCenter : GTCoordinate;
CONST yCenter : GTCoordinate;
CONST xRadius : GTCoordinate;
CONST yRadius : GTCoordinate;
CONST RotationAngle : GTDegree;
CONST startAngle : GTDegree;
CONST sweepAngle : GTDegree;
CONST arcType : GEArcTypes;
CONST numberOfSegments : ModSys.S_Natural);
(* *HTMLGEN InsertProcDocStart SGK_Arc* *)
(**
Arc - Draw an arc locused at xCenter, yCenter.
Draw an arc for 'sweepAngle' degrees from 'startAngle' whose
center is 'xCenter, yCenter', X radius is 'xRadius' and Y radius is
'yRadius', and is rotated off the X axis by 'rotationAngle'
degrees.
The arc is drawn in the active window using the active window's
line style.
To fill an arc, the active window's fill style is set to a value
other than HOLLOWSTYLE.
If 'sweepAngle' is less than 360 degrees the ends of the arc are
connected with an invisible line for filling purposes.
The available arc types are as follows:
closedChordArc -- Draw the arc as a closed chord
closedPieArc -- Draw the arc as a closed pie wedge
chordArc -- Draw the arc as a chord
pieArc -- Draw the arc as a pie wedge
CALLING SEQUENCE -
Arc (xCenter, yCenter, xRadius, yRadius,
rotationAngle, startAngle, sweepAngle,
SGK.closedPieArc, numberOfSegments)
ENTRY -
xCenter : GTCoordinate
The locus of the arc.
yCenter : GTCoordinate
The locus of the arc.
xRadius : GTCoordinate
The X radius of the arc.
yRadius : GTCoordinate
The Y radius of the arc.
rotationAngle : GTDegree
The angle off of horizontal at which the arc is rotated.
startAngle : GTDegree
The angle off of horizontal at which the arc starts.
sweepAngle : GTDegree
The total degrees of the arc.
arcType : GEArcTypes
The type of arc to be drawn.
numberOfSegments : ModSys.S_Natural
The number of line segments used to approximate the arc.
*)
(* *HTMLGEN InsertProcDocEnd* *)
PROCEDURE ArcRelative
(CONST xRadius : GTCoordinate;
CONST yRadius : GTCoordinate;
CONST RotationAngle : GTDegree;
CONST startAngle : GTDegree;
CONST sweepAngle : GTDegree;
CONST arcType : GEArcTypes;
CONST numberOfSegments : ModSys.S_Natural);
(* *HTMLGEN InsertProcDocStart SGK_ArcRelative* *)
(**
ArcRelative - Draw an arc locused at the active window's CP.
Draw an arc for 'sweepAngle' degrees from 'startAngle' whose
center is at the active window's CP, X radius is 'xRadius' and Y
radius is 'yRadius', and is rotated off the X axis by
'rotationAngle' degrees.
The arc is drawn in the active window using the active window's
line style.
To fill an arc, the active window's fill style is set to a value
other than HOLLOWSTYLE.
If 'sweepAngle' is less than 360 degrees the ends of the arc are
connected with an invisible line for filling purposes.
The available arc types are as follows:
closedChordArc -- Draw the arc as a closed chord
closedPieArc -- Draw the arc as a closed pie wedge
chordArc -- Draw the arc as a chord
pieArc -- Draw the arc as a pie wedge
CALLING SEQUENCE -
ArcRelative (xRadius, yRadius,
rotationAngle, startAngle, sweepAngle,
SGK.closedPieArc, numberOfSegments)
ENTRY -
xRadius : GTCoordinate
The X radius of the arc.
yRadius : GTCoordinate
The Y radius of the arc.
rotationAngle : GTDegree
The angle off of horizontal at which the arc is rotated.
startAngle : GTDegree
The angle off of horizontal at which the arc starts.
sweepAngle : GTDegree
The total degrees of the arc.
arcType : GEArcTypes
The type of arc to be drawn.
numberOfSegments : ModSys.S_Natural
The number of line segments used to approximate the arc.
*)
(* *HTMLGEN InsertProcDocEnd* *)
PROCEDURE DrawTwoColorBitMap
(CONST XVal : GTCoordinate;
CONST YVal : GTCoordinate;
CONST ForegroundColor : ModSys.S_Natural;
CONST BackgroundColor : ModSys.S_Natural;
CONST numberOfRows : ModSys.S_Natural;
CONST numberOfColumns : ModSys.S_Natural;
CONST bitmap : ARRAY OF ModSys.S_Natural16);
(* *HTMLGEN InsertProcDocStart SGK_DrawTwoColorBitMap* *)
(**
DrawTwoColorBitMap - Draw a bitmap in the active window.
Draw a two color device independent bitmap on all active devices
in the active window.
Bits set to 1 in the mask are drawn in the 'foregroundColor'.
Bits set to 0 in the mask are drawn in the 'backgroundColor'.
'bitMap' is defined as an array [0 .. n] of ModSys.S_Natural in row/column order.
'numberOfRows' corresponds to the number lines in the mask,
'numberOfColumns' corresponds to the number of ModSys.S_Naturals in each
row.
NOTE : The bit map's orientation is lower left corner.
CALLING SEQUENCE -
DrawTwoColorBitMap (XVal, YVal, foregroundColor, backgroundColor,
numberOfRows, numberOfColumns, bitMap)
ENTRY -
XVal, YVal : GTCoordinate
location to place the bitmap.
foregroundColor : ModSys.S_Natural
Color index for the foreground.
backgroundColor : ModSys.S_Natural
Color index for the background.
numberOfRows : ModSys.S_Natural
The number of rows or lines in the bitmap.
numberOfColumns : ModSys.S_Natural
The number of ModSys.S_Natural16's per each row.
bitMap : array of ModSys.S_Natural16
The bit map data.
*)
(* *HTMLGEN InsertProcDocEnd* *)
PROCEDURE GetTextBoxExtent
(CONST XVal : GTCoordinate;
CONST YVal : GTCoordinate;
CONST width : GTCoordinate;
CONST height : GTCoordinate;
CONST theText : ARRAY OF CHAR;
CONST concatChar : CHAR;
VAR extent : GRTextExtent);
(* *HTMLGEN InsertProcDocStart SGK_GetTextBoxExtent* *)
(**
GetTextBoxExtent - Get the extent of the given text box.
Using the active window's text style, calculate the coordinates of
the rectangle that encompasses 'text' using 'x, y' as the locus.
CALLING SEQUENCE -
GetTextBoxExtent (XVal, YVal, width, height, theText,
concatChar, extent)
ENTRY -
XVal : GTCoordinate
The locus of the extent calculation.
YVal : GTCoordinate
The locus of the extent calculation.
width : GTCoordinate
The width of the extent calculation.
height : GTCoordinate
The height of the extent calculation.
TheText : ARRAY OF CHAR
The text whose extent is desired.
concatChar : CHAR
The character to use in the concatenation point
calculation.
EXIT -
extent : GRTextExtent
The calculated extent.
*)
(* *HTMLGEN InsertProcDocEnd* *)
PROCEDURE GetTextExtent
(CONST XVal : GTCoordinate;
CONST YVal : GTCoordinate;
CONST theText : ARRAY OF CHAR;
CONST concatChar : CHAR;
VAR extent : GRTextExtent);
(* *HTMLGEN InsertProcDocStart SGK_GetTextExtent* *)
(**
GetTextExtent - Get the extent of the given text.
Using the active window's text style, calculate the coordinates of
the rectangle that encompasses 'text' using 'x, y' as the locus.
The extent includes the following attributes:
lowerLeftX : GTCoordinate; -- ³1 Upper
lowerLeftY : GTCoordinate; -- þ10 ³ Right
lowerRightX : GTCoordinate; -- ³2 Upper
lowerRightY : GTCoordinate; -- 1þÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄþ2 ³ Left
upperRightX : GTCoordinate; -- ³ º º º º³ ³3 Lower
upperRightY : GTCoordinate; -- ³ÉÍÍ» º º ÉÍÍ» º º³ ³ Left
upperLeftX : GTCoordinate; -- ³º º ÌÍ͹ º º ÌÍ͹³ ³4 Lower
upperLeftY : GTCoordinate; -- ³º º º º º º º º³ ³ Right
baseLeftX : GTCoordinate; -- ³ÈÍ͹ º º ÈÍ͹ º º³ ³5 Base
baseLeftY : GTCoordinate; -- 5þÄÄÄ×ÄÄÄÄÄÄÄÄÄÄÄ×ÄÄÄÄÄÄþ6 ³ Left
baseRightX : GTCoordinate; -- ³ÍÍͼ ÍÍͼ ³ ³6 Base
baseRightY : GTCoordinate; --þ9 4þÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄþ3þ7³ Right
concatLeftX : GTCoordinate; -- ³7 Concat
concatLeftY : GTCoordinate; -- ³ Right
concatBottomX : GTCoordinate; -- ³8 Concat
concatBottomY : GTCoordinate; -- ³ Bottom
concatRightX : GTCoordinate; -- ³9 Concat
concatRightY : GTCoordinate; -- ³ Left
concatTopX : GTCoordinate; -- ³10Concat
concatTopY : GTCoordinate; -- þ8 ³ Top
Height is calculated by the distance between lowerLeftY and
upperLeftY, or lowerRightY and upperRightY.
Width is calculated by the distance between lowerLeftX and
lowerRightX, or upperLeftX and upperRightX.
The concatenation point (concatX, concatY) is the point at which
the character 'concatChar' should be drawn to appended it to
'text' at the left, bottom, right, or top.
CALLING SEQUENCE -
GetTextExtent (XVal, YVal, TheText, concatChar, extent)
ENTRY -
XVal, YVal : GTCoordinate
The locus of the extent calculation.
TheText : ARRAY OF CHAR
The text whose extent is desired.
concatChar : CHAR
The character to use in the concatenation point
calculation.
EXIT -
extent : GRTextExtent
The calculated extent.
*)
(* *HTMLGEN InsertProcDocEnd* *)
PROCEDURE PolyLine
(CONST numberOfPoints : ModSys.S_Natural;
CONST XVal : ARRAY OF GTCoordinate;
CONST YVal : ARRAY OF GTCoordinate);
(* *HTMLGEN InsertProcDocStart SGK_PolyLine* *)
(**
PolyLine - Draw a set of lines defined by a set of points.
Draw a set of lines by drawing a line between 'x (0), y (0)' and
'x (1), y (1)' followed by drawing a line between 'x (1), y (1)' and
'x (2), y (2)', etc.
The line is drawn in the active window's line style.
To fill the polygon defined by the set of points 'x' and 'y', the
fill style is set to a value other than HOLLOWSTYLE.
If the 'x, y' pairs do not define a closed polygon a transparent line
will be added to close the polygon for the fill operation.
CALLING SEQUENCE -
PolyLine (numberOfPoints, XVal, YVal)
ENTRY -
numberOfPoints : ModSys.S_Natural
The number of valid points in the 'x' and 'y' arrays.
XVal, YVal : array of GTCoordinate
The coordinate pairs defining the set of lines (polygon) to
be drawn.
*)
(* *HTMLGEN InsertProcDocEnd* *)
PROCEDURE PolyLineRelative
(CONST numberOfPoints : ModSys.S_Natural;
CONST XVal : ARRAY OF GTCoordinate;
CONST YVal : ARRAY OF GTCoordinate);
(* *HTMLGEN InsertProcDocStart SGK_PolyLineRelative* *)
(**
PolyLineRelative - Draw set of lines defined by a set of deltas.
Draw a set of lines by drawing a line between 'CPX+x (0), CPY+y (0)'
and 'CPX+x (0)+x (1), CPY+y (0)+y (1)' followed by drawing a line
between 'CPX+x (0)+x (1), CPY+y (0)+y (1)' and
'CPX+x (0)+x (1)+x (2), CPY+y (0)+y (1)+y (2)', etc.
The line is drawn in the active window's line style.
To fill the polygon defined by the set of deltas 'x' and 'y', the
fill style is set to a value other than HOLLOWSTYLE.
If the 'x, y' pairs do not define a closed polygon a transparent line
will be added to close the polygon for the fill operation.
CALLING SEQUENCE -
PolyLineRelative (numberOfPoints, XVal, YVal)
ENTRY -
numberOfPoints : ModSys.S_Natural
The number of valid deltas in the 'x' and 'y' arrays.
XVal, YVal : array of GTCoordinate
The delta pairs defining the set of lines (polygon) to be
drawn.
*)
(* *HTMLGEN InsertProcDocEnd* *)
PROCEDURE Rectangle
(CONST lowerLeftX : GTCoordinate;
CONST lowerLeftY : GTCoordinate;
CONST upperRightX : GTCoordinate;
CONST upperRightY : GTCoordinate);
(* *HTMLGEN InsertProcDocStart SGK_Rectangle* *)
(**
Rectangle - Draw a rectangle defined by the given points.
Draw a rectangle defined by 'lowerLeftX, lowerLeftY' and 'upperRightX,
upperRightY'.
The rectangle is drawn in the active window's line style, however
the width parameter in the active line style is ignored .
The rectangle may be fill by following the same specifications defined
in the 'Polyline' primitive.
CALLING SEQUENCE -
Rectangle (lowerLeftX, lowerLeftY, upperRightX, upperRightY)
ENTRY -
lowerLeftX, lowerLeftY : GTCoordinate
Lower left corner of the rectangle in window coordinates.
upperRightX, upperRightY : GTCoordinate
Upper right corner of the rectangle in window coordinates.
*)
(* *HTMLGEN InsertProcDocEnd* *)
PROCEDURE RectangleRelative
(CONST width : GTCoordinate;
CONST height : GTCoordinate);
(* *HTMLGEN InsertProcDocStart SGK_RectangleRelative* *)
(**
RectangleRelative - Draw a rectangle defined by 'height' and 'width'.
Draw a rectangle defined by current point 'CP' and 'height' and 'width'.
The rectangle is drawn in the active window's line style, however
the width parameter has no meaning.
The rectangle may be fill by following the same specifications defined
in the 'Polyline' primitive.
CALLING SEQUENCE -
RectangleRelative (width, width)
ENTRY -
width : GTCoordinate
Width of the rectangle.
height : GTCoordinate
Height of the rectangle.
*)
(* *HTMLGEN InsertProcDocEnd* *)
PROCEDURE TextBox
(CONST XVal : GTCoordinate;
CONST YVal : GTCoordinate;
CONST width : GTCoordinate;
CONST height : GTCoordinate;
CONST theText : ARRAY OF CHAR;
CONST shrink : BOOLEAN;
CONST useDefault : BOOLEAN);
(* *HTMLGEN InsertProcDocStart SGK_TextBox* *)
(**
TextBox - Draw text within a given box at x, y.
Draw 'theText' within a text box area at 'x, y' in the active window using the active
window's text style, line style, and fill style.
CALLING SEQUENCE -
TextBox (XVal, YVal, width, height, theText, shrink, useDefault)
ENTRY -
XVal : GTCoordinate
The coordinates of the locus for the text drawing.
YVal : GTCoordinate
The coordinates of the locus for the text drawing.
width : GTCoordinate
The width of the box.
height : GTCoordinate
The height of the box.
theText : ARRAY OF CHAR
The text to be drawn.
shrink : BOOLEAN
True - If text will not fit shrink it.
False - If text will not fit crop it.
useDefault : BOOLEAN
Use the default?
*)
(* *HTMLGEN InsertProcDocEnd* *)
PROCEDURE Text
(CONST XVal : GTCoordinate;
CONST YVal : GTCoordinate;
CONST theText : ARRAY OF CHAR);
(* *HTMLGEN InsertProcDocStart SGK_Text* *)
(**
Text - Draw text with locus at x, y.
Draw 'theText' with locus 'x, y' in the active window using the active
window's text style, line style, and fill style.
CALLING SEQUENCE -
Text (XVal, YVal, theText)
ENTRY -
XVal : GTCoordinate
The coordinates of the locus for the text drawing.
YVal : GTCoordinate
The coordinates of the locus for the text drawing.
theText : ARRAY OF CHAR
The text to be drawn.
*)
(* *HTMLGEN InsertProcDocEnd* *)
PROCEDURE TextRelative
(CONST theText : ARRAY OF CHAR);
(* *HTMLGEN InsertProcDocStart SGK_TextRelative* *)
(**
TextRelative - Draw text relative to CP.
Draw 'theText' in the active window using the active window's CP,
text style, line style, and fill style.
CALLING SEQUENCE -
TextRelative (theText)
ENTRY -
theText : ARRAY OF CHAR
The text to be drawn.
*)
(* *HTMLGEN InsertProcDocEnd* *)
PROCEDURE ClearWindow;
(* *HTMLGEN InsertProcDocStart SGK_ClearWindow* *)
(**
ClearWindow - Paint active window with device's color one.
The active window is painted with solid fill in color table entry
one.
CALLING SEQUENCE -
ClearWindow
*)
(* *HTMLGEN InsertProcDocEnd* *)
PROCEDURE CloseWindow
(CONST WindowHandle : GPWindow);
(* *HTMLGEN InsertProcDocStart SGK_CloseWindow* *)
(**
CloseWindow - Terminate the window.
Remove the window, given by 'windowHandle', from the window list,
and deallocate all memory associated with the window.
If the closed window is the active window then the base window
becomes the active window.
CALLING SEQUENCE -
CloseWindow (windowHandle)
ENTRY -
windowHandle : GPWindow
A handle to an open window.
*)
(* *HTMLGEN InsertProcDocEnd* *)
PROCEDURE GetActiveWindow
() : GPWindow;
(* *HTMLGEN InsertProcDocStart SGK_GetActiveWindow* *)
(**
GetActiveWindow - Get the handle of the active window.
Get the handle associated with the active window.
CALLING SEQUENCE -
windowHandle := GetActiveWindow
EXIT -
windowHandle : GPWindow
The handle of the active window.
*)
(* *HTMLGEN InsertProcDocEnd* *)
PROCEDURE GetBaseWindow
() : GPWindow;
(* *HTMLGEN InsertProcDocStart SGK_GetBaseWindow* *)
(**
GetBaseWindow - Get the handle of the base window.
Get the handle associated with the base window.
CALLING SEQUENCE -
baseWindowHandle := GetBaseWindow
EXIT -
baseWindowHandle : GPWindow
The handle of the base window.
*)
(* *HTMLGEN InsertProcDocEnd* *)
PROCEDURE GetCP
(VAR XVal : GTCoordinate;
VAR YVal : GTCoordinate);
(* *HTMLGEN InsertProcDocStart SGK_GetCP* *)
(**
GetCP - Get the active window's current point (CP).
CALLING SEQUENCE -
GetCP (x, y)
EXIT -
XVal, YVal : GTCoordinate
The active window's current point coordinates.
*)
(* *HTMLGEN InsertProcDocEnd* *)
PROCEDURE GetCPX
() : GTCoordinate;
(* *HTMLGEN InsertProcDocStart SGK_GetCPX* *)
(**
GetCPX - Get X coordinate of active window's current point (CP).
CALLING SEQUENCE -
Cpx := GetCPX ()
EXIT -
GetCPX : GTCoordinate
The active window's current point X coordinates.
*)
(* *HTMLGEN InsertProcDocEnd* *)
PROCEDURE GetCPY
() : GTCoordinate;
(* *HTMLGEN InsertProcDocStart SGK_GetCPY* *)
(**
GetCPY - Get Y coordinate of active window's current point (CP).
CALLING SEQUENCE -
Cpy := GetCPY ()
EXIT -
GetCPY : GTCoordinate
The active window's current point Y coordinates.
*)
(* *HTMLGEN InsertProcDocEnd* *)
PROCEDURE GetPrinterDefaults
(VAR printDefaults : GRWinPrintDefaults);
(* *HTMLGEN InsertProcDocStart SGK_GetPrinterDefaults* *)
(**
GetPrinterDefaults - Get the printer's default settings.
Get the default settings for the printer.
CALLING SEQUENCE -
GetPrinterDefaults (printDefaults)
EXIT -
printDefaults : GRWinPrintDefaults
The printer's current default settings.
*)
(* *HTMLGEN InsertProcDocEnd* *)
PROCEDURE GetWinFontStyle
(VAR fontStyle : GRWinFontStyle);
(* *HTMLGEN InsertProcDocStart SGK_GetWinFontStyle* *)
(**
GetWinFontStyle - Get the window's font style.
Get the window's font style.
CALLING SEQUENCE -
GetWinFontStyle (fontStyle)
EXIT -
fontStyle : GRWinFontStyle
The font style of the window.
*)
(* *HTMLGEN InsertProcDocEnd* *)
PROCEDURE GetWinFillStyle
(VAR style : GRWinFillStyle);
(* *HTMLGEN InsertProcDocStart SGK_GetWinFillStyle* *)
(**
GetWinFillStyle - Get the window's fill style.
Get the window's fill style.
CALLING SEQUENCE -
GetWinFillStyle (Style)
EXIT -
Style : GRWinFillStyle
The fill style of the window.
*)
(* *HTMLGEN InsertProcDocEnd* *)
PROCEDURE GetFillStyle
(VAR style : GRFillStyle);
(* *HTMLGEN InsertProcDocStart SGK_GetFillStyle* *)
(**
GetFillStyle - Get the active window's fill style.
Get all of the attributes associated with fills in the active
window. These attributes are :
fillPattern : GAPattern;
fillColor : GTColorTableEntry;
hatchColor : GTColorTableEntry;
'fillColor' is used for bits set to 0 in 'style' and 'hatchColor'
is used for bits set to 1 in 'style'.
CALLING SEQUENCE -
GetFillStyle (style)
EXIT -
style : GRFillStyle
The fill style of the active window.
*)
(* *HTMLGEN InsertProcDocEnd* *)
PROCEDURE GetImage
(CONST lowerLeftX : GTCoordinate;
CONST lowerLeftY : GTCoordinate;
CONST upperRightX : GTCoordinate;
CONST upperRightY : GTCoordinate;
VAR hBitmap : WIN32.HBITMAP;
VAR memDC : WIN32.HDC);
(* *HTMLGEN InsertProcDocStart SGK_GetImage* *)
(**
GetImage - Copies an image from the active window to a buffer.
Copy an image from the active window, on the console device into
the buffer 'image' such that the lower left corner of the image
lies at 'lowerLeftX, lowerLeftY' and the upper right corner of
the image lies at 'upperRightX, upperRightY'.
If the image buffer size is greater than 'imageSize' then an error
is returned and no image is saved. Use GetImageSize to determine
the minimum 'imageSize' required to store the image.
CALLING SEQUENCE -
GetImage (lowerLeftX, lowerLeftY,
upperRightX, upperRightY,
imageSize, image)
ENTRY -
lowerLeftX : GTCoordinate
The lower left corner of the image to copy.
lowerLeftY : GTCoordinate
The lower left corner of the image to copy.
upperRightX : GTCoordinate
The upper right corner of the image to copy.
upperRightY : GTCoordinate
The upper right corner of the image to copy.
EXIT -
hBitmap : Windows.HBITMAP
The stored bitmap.
memDC : Windows.HDC
The memory DC where the bitmap is.
*)
(* *HTMLGEN InsertProcDocEnd* *)
PROCEDURE GetImageSize
(CONST lowerLeftX : GTCoordinate;
CONST lowerLeftY : GTCoordinate;
CONST upperRightX : GTCoordinate;
CONST upperRightY : GTCoordinate) : ModSys.S_Natural;
(* *HTMLGEN InsertProcDocStart SGK_GetImageSize* *)
(**
GetImageSize - Get the minimum buffer size for an image.
Get the minimum number of bytes required to store an image.
CALLING SEQUENCE -
size := GetImageSize (lowerLeftX, lowerLeftY,
upperRightX, upperRightY)
ENTRY -
lowerLeftX : GTCoordinate
The lower left corner of the image to size.
lowerLeftY : GTCoordinate
The lower left corner of the image to size.
upperRightX : GTCoordinate
The upper right corner of the image to size.
upperRightY : GTCoordinate
The upper right corner of the image to size.
EXIT -
size : ModSys.S_Natural
The bytes required to save an image.
*)
(* *HTMLGEN InsertProcDocEnd* *)
PROCEDURE GetLimits
(VAR lowerLeftX : GTCoordinate;
VAR lowerLeftY : GTCoordinate;
VAR upperRightX : GTCoordinate;
VAR upperRightY : GTCoordinate);
(* *HTMLGEN InsertProcDocStart SGK_GetLimits* *)
(**
GetLimits - Get active window's limits.
The limits of the active window are returned.
CALLING SEQUENCE -
GetLimits (lowerLeftX, lowerLeftY,
upperRightX, upperRightY)
EXIT -
lowerLeftX : GTCoordinate
X, Y limits of the lower left corner of the active window.
These limits are user defined.
lowerLeftY : GTCoordinate
X, Y limits of the lower left corner of the active window.
These limits are user defined.
upperRightX : GTCoordinate
X, Y limits of the upper right corner of the active window.
These limits are user defined.
upperRightY : GTCoordinate
X, Y limits of the upper right corner of the active window.
These limits are user defined.
*)
(* *HTMLGEN InsertProcDocEnd* *)
PROCEDURE GetLineStyle
(VAR style : GRLineStyle);
(* *HTMLGEN InsertProcDocStart SGK_GetLineStyle* *)
(**
GetLineStyle - Get the active window's line style.
Get the active window's line style.
The line style attributes are :
linePattern : GTLineStyle;
lineWidth : GTCoordinate; -- Thickness in window coordinates
lineColor : GTColorTableEntry;
No color is drawn for bits set to 0 in 'style' and 'color' is used
for bits set to 1 in 'style'.
'width' (in window coordinates) specifies the thickness of a line.
A value of 0.0 defines the smallest possible line width or one
pixel.
CALLING SEQUENCE -
GetLineStyle (style)
EXIT -
style : GRLineStyle
The active window's line style.
*)
(* *HTMLGEN InsertProcDocEnd* *)
PROCEDURE GetLocation
(VAR lowerLeftX : GTCoordinate;
VAR lowerLeftY : GTCoordinate;
VAR upperRightX : GTCoordinate;
VAR upperRightY : GTCoordinate);
(* *HTMLGEN InsertProcDocStart SGK_GetLocation* *)
(**
GetLocation - Get active window's location.
The location of the active window is returned.
CALLING SEQUENCE -
GetLocation (lowerLeftX, lowerLeftY,
upperRightX, upperRightY)
EXIT -
lowerLeftX : GTCoordinate
X, Y coordinates of the lower left corner of the active
window. These coordinates are relative to the base window's
limits.
lowerLeftY : GTCoordinate
X, Y coordinates of the lower left corner of the active
window. These coordinates are relative to the base window's
limits.
upperRightX : GTCoordinate
X, Y coordinates of the upper right corner of the active
window. These coordinates are relative to the base window's
limits.
upperRightY : GTCoordinate
X, Y coordinates of the upper right corner of the active
window. These coordinates are relative to the base window's
limits.
*)
(* *HTMLGEN InsertProcDocEnd* *)
PROCEDURE GetLocatorPriority
(VAR Priority : GTPriority);
(* *HTMLGEN InsertProcDocStart SGK_GetLocatorPriority* *)
(**
GetLocatorPriority - Get locator input priority for active window.
Get the priority for locator input associated with the active
window.
If multiple windows overlap on the device display the locator
input priority specifies which window is to receive locator input
focus. The highest priority window gets the focus.
CALLING SEQUENCE -
GetLocatorPriority (priority)
EXIT -
priority : GTPriority
The locator input priority associated with the active
window.
*)
(* *HTMLGEN InsertProcDocEnd* *)
PROCEDURE GetTextStyle
(VAR style : GRTextStyle);
(* *HTMLGEN InsertProcDocStart SGK_GetTextStyle* *)
(**
GetTextStyle - Get the text style of the active window.
Get all of the attributes associated with text drawn in the active
window. These attributes are :
horzSize : GTCoordinate; -- Char width in window coordinates
vertSize : GTCoordinate; -- Char height in window coordinates
charAngleDegrees : GTDegree; -- Char rotate angle from text angle
textAngleDegrees : GTDegree; -- Text rotate angle
font : GPFont; -- Handle of the font to use
horzJust : GEJust; -- Text width alignment with cur. pt.
vertJust : GEJust; -- Text height alignment with cur. pt.
horzSpacing : GTSpacing; -- Char-to-char width gap
vertSpacing : GTSpacing; -- Char-to-char height gap
CALLING SEQUENCE -
GetTextStyle (style)
EXIT -
style : GRTextStyle
Record containing the text style for the active window.
*)
(* *HTMLGEN InsertProcDocEnd* *)
PROCEDURE GetWriteMode
(VAR WriteMode : GEWriteModes);
(* *HTMLGEN InsertProcDocStart SGK_GetWriteMode* *)
(**
GetWriteMode - Get the active window's write mode.
The write mode indicates how a color to be written to the active
window is combined with the color already present at the CP.
The defined write modes are :
andMode -- Bit and current and device pixels
copyMode -- Copy current pixel to device
orMode -- Bit OR current and device pixels
xorMode -- Bit XOR current and device pixels
CALLING SEQUENCE -
GetWriteMode (writeMode)
EXIT -
writeMode : GEWriteModes
The active window's write mode.
*)
(* *HTMLGEN InsertProcDocEnd* *)
PROCEDURE OpenWindow
(VAR WindowHandle : GPWindow;
CONST locationLowerLeftX : GTCoordinate;
CONST locationLowerLeftY : GTCoordinate;
CONST locationUpperRightX : GTCoordinate;
CONST locationUpperRightY : GTCoordinate;
CONST limitLowerLeftX : GTCoordinate;
CONST limitLowerLeftY : GTCoordinate;
CONST limitUpperRightX : GTCoordinate;
CONST limitUpperRightY : GTCoordinate);
(* *HTMLGEN InsertProcDocStart SGK_OpenWindow* *)
(**
OpenWindow - Create a window on all active devices.
Create a window defined by its location and limits, and add the
new window to the window list.
The location is defined in terms of the base window limits defined
in OpenSGK.
The window is initialized as follows:
<CP> := limitLowerLeftX, limitLowerLeftY;
<Write Mode> := copyMode;
Location
<Lower Left> := locationLowerLeftX, locationLowerLeftY;
<Upper Right> := locationUpperRightX, locationUpperRightY;
Limits
<Lower Left> := limitLowerLeftX, limitLowerLeftY;
<Upper Right> := limitUpperRightX, limitUpperRightY;
Fill Style
fillPattern := SOLIDFILL;
fillColor := 1;
hatchColor := 2;
Line Style
linePattern := SOLIDLINE;
lineWidth := 0.0;
lineColor := 2;
Text Style
horzSize := (limitUpperRightX-limitLowerLeftX)/80.0*0.9;
vertSize := (limitUpperRightY-limitLowerLeftY)/25.0*0.9;
charAngleDegrees := 0.0;
textAngleDegrees := 0.0;
font := nil;
horzJust := leftJust;
vertJust := baseJust;
horzSpacing := (limitUpperRightX-limitLowerLeftX)/80.0*0.1;
vertSpacing := (limitUpperRightY-limitLowerLeftY)/25.0*0.1;
and the locator input priority is set to 0.
CALLING SEQUENCE -
OpenWindow (windowHandle,
locationLowerLeftX, locationLowerLeftY,
locationUpperRightX, locationUpperRightY,
limitLowerLeftX, limitLowerLeftY,
limitUpperRightX, limitUpperRightY)
ENTRY -
locationLowerLeftX : GTCoordinate
X, Y coordinates of the lower left corner of the window
being opened. These coordinates are relative to the base
window's limits.
locationLowerLeftY : GTCoordinate
X, Y coordinates of the lower left corner of the window
being opened. These coordinates are relative to the base
window's limits.
locationUpperRightX : GTCoordinate
X, Y coordinates of the upper right corner of the window
being opened. These coordinates are relative to the base
window's limits.
locationUpperRightY : GTCoordinate
X, Y coordinates of the upper right corner of the window
being opened. These coordinates are relative to the base
window's limits.
limitLowerLeftX : GTCoordinate
X, Y limits of the lower left corner of the window being
opened. These are user defined coordinates.
limitLowerLeftY : GTCoordinate
X, Y limits of the lower left corner of the window being
opened. These are user defined coordinates.
limitUpperRightX : GTCoordinate
X, Y limits of the upper right corner of the window being
opened. These are user defined coordinates.
limitUpperRightY : GTCoordinate
X, Y limits of the upper right corner of the window being
opened. These are user defined coordinates.
EXIT -
windowHandle : GPWindow
A handle to the opened window.
*)
(* *HTMLGEN InsertProcDocEnd* *)
PROCEDURE PaintWindow;
(* *HTMLGEN InsertProcDocStart SGK_PaintWindow* *)
(**
PaintWindow - Paint active window with active window's fill style.
CALLING SEQUENCE -
PaintWindow
*)
(* *HTMLGEN InsertProcDocEnd* *)
PROCEDURE PutImage
(CONST memDC : WIN32.HDC;
CONST hBitmap : WIN32.HBITMAP;
CONST lowerLeftX : GTCoordinate;
CONST lowerLeftY : GTCoordinate);
(* *HTMLGEN InsertProcDocStart SGK_PutImage* *)
(**
PutImage - Copies an image from a buffer to the active window.
Copy the image stored in the buffer 'image' to the active window,
on the console device, such that the lower left corner of the image
lies at 'lowerLeftX, lowerLeftY'.
CALLING SEQUENCE -
PutImage (image, lowerLeftX, lowerLeftY)
ENTRY -
hBitmap : Windows.HBITMAP
The stored bitmap.
memDC : Windows.HDC
The memory device containing the bitmap to copy.
lowerLeftX : GTCoordinate
The coordinates of the locus for the copy.
lowerLeftY : GTCoordinate
The coordinates of the locus for the copy.
*)
(* *HTMLGEN InsertProcDocEnd* *)
PROCEDURE ReleaseImage
(CONST memDC : WIN32.HDC);
(* *HTMLGEN InsertProcDocStart SGK_ReleaseImage* *)
(**
ReleaseImage - release the image DC.
Releases the memory device context used for the image.
CALLING SEQUENCE -
ReleaseImage (dc)
ENTRY -
memDC : Windows.HDC
The memory DC of the image saved.
*)
(* *HTMLGEN InsertProcDocEnd* *)
PROCEDURE SetActiveWindow
(CONST WindowHandle : GPWindow);
(* *HTMLGEN InsertProcDocStart SGK_SetActiveWindow* *)
(**
SetActiveWindow - Set the active window.
Set the active window to the window associated with
'windowHandle'.
CALLING SEQUENCE -
SetActiveWindow (windowHandle)
ENTRY -
windowHandle : GPWindow
The handle of the window to activate.
*)
(* *HTMLGEN InsertProcDocEnd* *)
PROCEDURE SetCP
(CONST XVal : GTCoordinate;
CONST YVal : GTCoordinate);
(* *HTMLGEN InsertProcDocStart SGK_SetCP* *)
(**
SetCP - Set the active window's current point (CP).
Set the active window's current point (CP) to 'x, y'.
The current point is the locus for all drawing done in the active
window.
CALLING SEQUENCE -
SetCP (x, y)
ENTRY -
XVal, YVal : GTCoordinate
The desired active window CP coordinates.
*)
(* *HTMLGEN InsertProcDocEnd* *)
PROCEDURE SetPrinterDefaults
(CONST printDefaults : GRWinPrintDefaults);
(* *HTMLGEN InsertProcDocStart SGK_SetPrinterDefaults* *)
(**
SetPrinterDefaults - Initialize the print dialog options.
For windows printing, set the default options in the print dialog
Currently, page orientation can be set. Paper size, etc could
be added as required. Make this call prior to opening the WINPRN device.
CALLING SEQUENCE -
SetPrinterDefaults (printDefaults)
ENTRY -
printDefaults : GRWinPrintDefaults
The desired initial settings for the print dialog options.
*)
(* *HTMLGEN InsertProcDocEnd* *)
PROCEDURE SetWinFontStyle
(CONST fontStyle : GRWinFontStyle);
(* *HTMLGEN InsertProcDocStart SGK_SetWinFontStyle* *)
(**
SetWinFontStyle - specify desired font attributes.
Before calling OpenFont, use this call to set the pitch and family
if desired. Could also be used in the future to specify italics
and pen width, etc.
CALLING SEQUENCE -
SetWinFontStyle (printDefaults)
ENTRY -
fontSTyle : GRWinFontStyle
The desired font attributes.
*)
(* *HTMLGEN InsertProcDocEnd* *)
PROCEDURE SetWinFillStyle
(CONST style : GRWinFillStyle);
(* *HTMLGEN InsertProcDocStart SGK_SetWinFillStyle* *)
(**
SetWinFillStyle - Define the window's fill style.
Set a window fill style.
CALLING SEQUENCE -
SetWinFillStyle (Style)
ENTRY -
Style : GRWinFillStyle
The desired fill style for the window.
*)
(* *HTMLGEN InsertProcDocEnd* *)
PROCEDURE SetFillStyle
(CONST style : GRFillStyle);
(* *HTMLGEN InsertProcDocStart SGK_SetFillStyle* *)
(**
SetFillStyle - Define the active window's fill style.
Define all of the attributes associated with fills in the active
window. These attributes are :
fillPattern : GAPattern;
fillColor : GTColorTableEntry;
hatchColor : GTColorTableEntry;
'fillColor' is used for bits set to 0 in 'style' and 'hatchColor'
is used for bits set to 1 in 'style'.
CALLING SEQUENCE -
SetFillStyle (style)
ENTRY -
style : GRFillStyle
The desired fill style for the active window.
*)
(* *HTMLGEN InsertProcDocEnd* *)
PROCEDURE SetLimits
(CONST lowerLeftX : GTCoordinate;
CONST lowerLeftY : GTCoordinate;
CONST upperRightX : GTCoordinate;
CONST upperRightY : GTCoordinate);
(* *HTMLGEN InsertProcDocStart SGK_SetLimits* *)
(**
SetLimits - Redefine active window's limits.
The active window's coordinate system is changed by setting its
limits. This can be used to scale the objects displayed in the
window.
CALLING SEQUENCE -
SetLimits (lowerLeftX, lowerLeftY,
upperRightX, upperRightY)
ENTRY -
lowerLeftX : GTCoordinate
X, Y limits of the lower left corner of the active window.
These are user defined coordinates.
lowerLeftY : GTCoordinate
X, Y limits of the lower left corner of the active window.
These are user defined coordinates.
upperRightX : GTCoordinate
X, Y limits of the upper right corner of the active window.
These are user defined coordinates.
upperRightY : GTCoordinate
X, Y limits of the upper right corner of the active window.
These are user defined coordinates.
*)
(* *HTMLGEN InsertProcDocEnd* *)
PROCEDURE SetLineStyle
(CONST style : GRLineStyle);
(* *HTMLGEN InsertProcDocStart SGK_SetLineStyle* *)
(**
SetLineStyle - Set the active window's line style.
Set the active window's line style.
The line style attributes are :
linePattern : GTLineStyle;
lineWidth : GTCoordinate; -- Thickness in window coordinates
lineColor : GTColorTableEntry;
No color is drawn for bits set to 0 in 'style' and 'color' is used
for bits set to 1 in 'style'.
'width' (in window coordinates) specifies the thickness of a line.
A value of 0.0 defines the smallest possible line width or one
pixel.
CALLING SEQUENCE -
SetLineStyle (style)
ENTRY -
style : GRLineStyle
The desired active window line style.
*)
(* *HTMLGEN InsertProcDocEnd* *)
PROCEDURE SetLocation
(CONST lowerLeftX : GTCoordinate;
CONST lowerLeftY : GTCoordinate;
CONST upperRightX : GTCoordinate;
CONST upperRightY : GTCoordinate);
(* *HTMLGEN InsertProcDocStart SGK_SetLocation* *)
(**
SetLocation - Redefine active window's location.
The location of the active window is redefined.
CALLING SEQUENCE -
SetLocation (lowerLeftX, lowerLeftY,
upperRightX, upperRightY)
ENTRY -
lowerLeftX : GTCoordinate
X, Y coordinates of the lower left corner of the active
window. These coordinates are relative to the base window's
limits.
lowerLeftY : GTCoordinate
X, Y coordinates of the lower left corner of the active
window. These coordinates are relative to the base window's
limits.
upperRightX : GTCoordinate
X, Y coordinates of the upper right corner of the active
window. These coordinates are relative to the base window's
limits.
upperRightY : GTCoordinate
X, Y coordinates of the upper right corner of the active
window. These coordinates are relative to the base window's
limits.
*)
(* *HTMLGEN InsertProcDocEnd* *)
PROCEDURE SetLocatorPriority
(CONST Priority : GTPriority);
(* *HTMLGEN InsertProcDocStart SGK_SetLocatorPriority* *)
(**
SetLocatorPriority - Set locator input priority for active window.
Set the priority for locator input to be associated with the
active window.
If multiple windows overlap on the device display the locator
input priority specifies which window is to receive locator input
focus. The highest priority window gets the focus.
CALLING SEQUENCE -
SetLocatorPriority (priority)
ENTRY -
priority : GTPriority
The locator input priority to be associated with the active
window.
*)
(* *HTMLGEN InsertProcDocEnd* *)
PROCEDURE SetTextStyle
(CONST style : GRTextStyle);
(* *HTMLGEN InsertProcDocStart SGK_SetTextStyle* *)
(**
SetTextStyle - Define the text style for the active window.
Define all of the attributes associated with text drawn in the
active window. These attributes are :
horzSize : GTCoordinate; -- Char width in window coordinates
***NOTE : for Windows, if you set horzSize to 0.0, Windows will
select a nice match based on the vertSize .. usually better
than you can do.***
vertSize : GTCoordinate; -- Char height in window coordinates
charAngleDegrees : GTDegree; -- Char rotate angle from text angle
textAngleDegrees : GTDegree; -- Text rotate angle
font : GPFont; -- Handle of the font to use
horzJust : GEJust; -- Text width alignment with cur. pt.
vertJust : GEJust; -- Text height alignment with cur. pt.
horzSpacing : GTSpacing; -- Char-to-char width gap
vertSpacing : GTSpacing; -- Char-to-char height gap
CALLING SEQUENCE -
SetTextStyle (style)
ENTRY -
style : GRTextStyle
Record containing the desired text style for the active
window.
*)
(* *HTMLGEN InsertProcDocEnd* *)
PROCEDURE SetWriteMode
(CONST WriteMode : GEWriteModes);
(* *HTMLGEN InsertProcDocStart SGK_SetWriteMode* *)
(**
SetWriteMode - Set the active window's write mode.
The write mode indicates how a color to be written to the active
window is combined with the color already present at the CP.
The defined write modes are :
andMode -- Bit and current and device pixels
copyMode -- Copy current pixel to device
orMode -- Bit OR current and device pixels
xorMode -- Bit XOR current and device pixels
CALLING SEQUENCE -
SetWriteMode (writeMode)
ENTRY -
writeMode : GEWriteModes
The desired write mode.
*)
(* *HTMLGEN InsertProcDocEnd* *)
PROCEDURE TransformXY
(CONST fromWindow : GPWindow;
CONST toWindow : GPWindow;
VAR XVal : GTCoordinate;
VAR YVal : GTCoordinate);
(* *HTMLGEN InsertProcDocStart SGK_TransformXY* *)
(**
TransformXY - convert the x, y pair to a different coordinate system.
Convert 'x, y' from the coordinate system in 'fromWindow' to
the coordinate system in 'toWindow'
CALLING SEQUENCE -
TransformXY (fromWindow, toWindow, XVal, YVal)
ENTRY -
fromWindow : SGK.GPWindow
The window handle of the coordinate system to transfer from
toWindow : SGK.GPWindow
The window handle of the coordinate system to transfer to
XVal, YVal : SGK.GTCoordinate
The point being transfered.
EXIT -
XVal, YVal : SGK.GTCoordinate
The transfered point.
*)
(* *HTMLGEN InsertProcDocEnd* *)
PROCEDURE CloseSGK;
(* *HTMLGEN InsertProcDocStart SGK_CloseSGK* *)
(**
CloseSGK - Closes the graphics system.
Closes the graphics system by deallocating the space acquired
during system operation, and setting the graphics state to closed.
CALLING SEQUENCE -
CloseSGK
*)
(* *HTMLGEN InsertProcDocEnd* *)
PROCEDURE GetClipState
(VAR clipState : GEClipStates);
(* *HTMLGEN InsertProcDocStart SGK_GetClipState* *)
(**
GetClipState - Get the system clip state.
CALLING SEQUENCE -
GetClipState (clipState)
EXIT -
clipState : GEClipStates
The system clip state. (clip, noClip)
*)
(* *HTMLGEN InsertProcDocEnd* *)
PROCEDURE GetSGKError
() : SGKErrors.ErrorType;
(* *HTMLGEN InsertProcDocStart SGK_GetSGKError* *)
(**
GetSGKError - Get SGK error status and set it to SGKErrors.ERROROK.
This procedure gets and returns the current error status of SGK.
In addition it sets the SGK's error status to SGKErrors.ERROROK.
CALLING SEQUENCE -
error := GetSGKError ()
EXIT -
error : SGKErrors.ErrorType
The current error status of SGK.
The SGK's error status is set to SGKErrors.ERROROK.
*)
(* *HTMLGEN InsertProcDocEnd* *)
PROCEDURE OpenSGK
(CONST lowerLeftX : GTCoordinate;
CONST lowerLeftY : GTCoordinate;
CONST upperRightX : GTCoordinate;
CONST upperRightY : GTCoordinate);
(* *HTMLGEN InsertProcDocStart SGK_OpenSGK* *)
(**
OpenSGK - Initialize the graphics system.
Initialize the graphics system by allocating space for all tables,
lists, and state variables.
The limits given by the parameters define the window limits for
the base window which encompasses the entire displayable area for
all opened devices.
The constant 'SGK.BASEWINDOWHANDLE' is a handle which points to
the base window.
The base window is initialized as follows:
<CP> := lowerLeftX, lowerLeftY;
<Write Mode> := copyMode;
Location
<Lower Left> := lowerLeftX, lowerLeftY;
<Upper Right> := upperRightX, upperRightY;
Limits
<Lower Left> := lowerLeftX, lowerLeftY;
<Upper Right> := upperRightX, upperRightY;
Fill Style
filePattern := SOLIDFILL;
fillColor := 1;
hatchColor := 2;
Line Style
linePattern := SOLIDLINE;
lineWidth := 0.0;
lineColor := 2;
Text Style
horzSize := (upperRightX-lowerLeftX)/80.0*0.9;
vertSize := (upperRightY-lowerLeftY)/25.0*0.9;
charAngleDegrees := 0.0;
textAngleDegrees := 0.0;
font := nil;
horzJust := leftJust;
vertJust := bottomJust;
horzSpacing := (upperRightX-lowerLeftX)/80.0*0.1;
vertSpacing := (upperRightY-lowerLeftY)/25.0*0.1;
and the locator input priority is set to 0.
The locator is initialized as follows:
pattern := LEFTARROWLOCATOR;
color0 := 1;
color1 := 16;
kbdArrowsEnabled := True;
kbdButtonsEnabled := True;
mouseButtonsEnabled := True;
mouseMovementEnabled := True;
mouseHorzSensitivity := 1;
mouseVertSensitivity := 1;
kbdSnapX := 1.0;
kbdSnapY := 1.0;
mouseSnapX := 1.0;
mouseSnapY := 1.0;
and the locator is limited to the base window described above.
The locator is not visible.
CALLING SEQUENCE -
OpenSGK (windowHandle, lowerLeftX, lowerLeftY, upperRightX, upperRightY)
ENTRY -
lowerLeftX : GTCoordinate
The base window limits.
lowerLeftY : GTCoordinate
The base window limits.
upperRightX : GTCoordinate
The base window limits.
upperRightY : GTCoordinate
The base window limits.
EXIT -
windowHandle : GPWindow
The handle to the base window.
*)
(* *HTMLGEN InsertProcDocEnd* *)
PROCEDURE SetClipState
(CONST clipState : GEClipStates);
(* *HTMLGEN InsertProcDocStart SGK_SetClipState* *)
(**
SetClipState - Set the system clip state.
Set the clipping state of the system.
CALLING SEQUENCE -
SetClipState (clipState)
ENTRY -
clipState : GEClipStates
The desired clip state for the system. (clip, noClip)
*)
(* *HTMLGEN InsertProcDocEnd* *)
PROCEDURE AbortPrint
() : BOOLEAN;
(* *HTMLGEN InsertProcDocStart SGK_AbortPrint* *)
(**
AbortPrint - Check if user wants to quit printing.
Check if the user has hit a key requesting that the printing
operation be stopped.
CALLING SEQUENCE -
GetOut := AbortPrint ()
EXIT -
AbortPrint : BOOLEAN
True - The user has chosen to stop printing.
False - No response from user, continue on.
*)
(* *HTMLGEN InsertProcDocEnd* *)
Send mail to
warren.merrill@inl.gov
with questions or comments about this web site.
Copyright © 1989-2008 Battelle Energy Alliance