3.3 Routines G-G
GCNListAdd()
Boolean GCNListAdd(
optr OD, /* optr to add to list */
ManufacturerID manufID, /* manufacturer ID of list */
word listType); /* list type */
This routine adds an object pointer (optr) to a GCN list interested in a particular change. The routine must be passed the optr to add, along with the manufID and the type of the list to add it to. If no list of the specified manufacturer and type currently exists, a new list will be created.
This routine will return true if the optr was successfully added to the GCN list and false if the optr could not be added. An optr cannot be added to a GCN list if it currently exists on that list.
Include: gcnlist.goh
GCNListAddHandles()
Boolean GCNListAddHandles(
MemHandle mh, /* handle of object to add */
ChunkHandle ch, /* chunk of object to add */
ManufacturerIDs manufID, /* manufacturer ID of list */
word listType); /* list type */
This routine is exactly the same as GCNListAdd(), except it takes the memory and chunk handles of the object rather than a complete optr.
Include: gcnlist.goh
GCNListAddToBlock()
Boolean GCNListAddToBlock(
optr OD, /* optr of list to add */
ManufacturerID manufID, /* manufacturer ID of list */
word listType, /* list type */
MemHandle mh, /* handle of block holding list */
ChunkHandle listOfLists);/* chunk of list of lists
* in block */
This routine adds a new GCN list to a block containing the GCN lists. Pass it the optr of the chunk containing the new GCN list as well as the list’s type and manufacturer ID. Pass also the memory handle and chunk handle of the chunk containing the GCN “list of lists” which will manage the new list.
This routine returns true of the new optr is added to the GCN mechanism, false if it could not be added (if it was already there).
Warnings: This routine may resize chunks in the block, so you should dereference any pointers after calling this routine.
Include: gcnlist.goh
GCNListCreateBlock()
ChunkHandle GCNListCreateBlock(
MemHandle mh); /* handle of the locked LMem block */
This routine creates a list of lists for the GCN mechanism. It is rarely, if ever, called by applications. Pass it the handle of the locked LMem block in which the list should be created.
Include: gcnlist.goh
GCNListDestroyBlock()
void GCNListDestroyBlock(
MemHandle mh, /* handle of locked block to
* be destroyed */
ChunkHandle listOfLists); /* chunk of list of lists */
This routine destroys a GCN list of lists and all the GCN lists associated with it. Pass it the handle of the locked LMem block containing the lists as well as the chunk handle of the chunk containing the list of lists.
Include: gcnlist.goh
GCNListDestroyList()
void GCNListDestroyList(
optr list); /* optr of the GCN list to be destroyed */
This routine destroys the specified GCN list.
Include: gcnlist.goh
GCNListRelocateBlock()
void GCNListRelocateBlock(
MemHandle mh, /* handle of locked LMem block
* containing GCN lists */
ChunkHandle listOfLists, /* chunk of list of lists */
MemHandle relocBlock); /* handle of block containing
* relocation information */
This routine relocates the GCN list of lists in the specified block, updating all the optrs stored therein.
Warnings: This routine can resize and/or move the LMem block, so you should dereference pointers after calling it.
Include: gcnlist.goh
GCNListRemove()
Boolean GCNListRemove(
optr OD, /* the optr to be removed */
ManufacturerID manufID, /* manufacturer ID of the list */
word listType); /* list type */
This routine removes the passed optr from the specified GCN list. The routine must be passed the optr to remove along with the manufacturer ID and list type of the list to remove it from.
This routine will return true if the optr was successfully removed from the GCN list and false if the optr could not be found on the GCN list and therefore could not be removed.
Include: gcnlist.goh
GCNListRemoveFromBlock()
Boolean GCNListRemoveFromBlock(
optr OD, /* optr of GCN list to remove */
ManufacturerID manufID, /* manufacturer of list to remove */
word listType, /* type of list being removed */
MemHandle mh, /* handle of locked LMem block
* containing the list of lists */
ChunkHandle listOfLists); /* chunk of list of lists */
This routine removes a GCN list from a GCN list block and from the list of lists therein.
Include: gcnlist.goh
GCNListRemoveHandles()
Boolean GCNListRemoveHandles(
MemHandle mh,
ChunkHandle ch,
ManufacturerID manufID,
word listType);
This routine is exactly the same as GCNListRemove(), except it specifies the object to be removed via handles rather than an optr.
Include: gcnlist.goh
See Also: GCNListRemove()
GCNListSend()
word GCNListSend(
ManufacturerID manufID, /* manufacturer of list */
word listType, /* notification type */
EventHandle event, /* event to be sent to list */
MemHandle dataBlock, /* data block, if any */
word gcnListSendFlags); /* GCNListSendFlags */
This routine sends a message to all objects in the specified GCN list. The message is specified in event, and the list is specified in manufID and listType. The message will be sent asynchronously (some time after the change has occurred) by the message queue.
The dataBlock parameter contains the memory handle of an extra data block to be sent with the notification, if any; this block should also be specified in the classed event. If no data block is required, pass a NullHandle. If a data block with a reference cound is used, increment the reference count by one before calling this routine; this routine decrements the count and frees the block if the count reaches zero.
The gcnListSendFlags parameter is of type GCNListSendFlags, which has only one meaningful flag for this routine:
GCNLSF_SET_STATUS
Causes the message sent to the GCN list to be set as the lists “status.” The list’s status message is then sent to any object adding itself to the list at a later time. If this flag is set, the event handle in event will be returned by the routine. If this flag is not set, the return value will be the number of messages sent out.
Include: gcnlist.goh
GCNListSendToBlock()
word GCNListSendToBlock(
ManufacturerID manufID, /* manufacturer id of list */
word listType, /* notification type */
EventHandle event, /* event to be sent to list */
MemHandle dataBlock, /* data block, if any */
MemHandle mh, /* handle of locked LMem block
* containing GCN list of lists */
ChunkHandle listOfLists,/* chunk of list of lists */
GCNListSendFlags flags); /* GCNListSendFlags */
This routine sends the specified event to the specified list, just as GCNListSend(). GCNListSentToBlock(), however, specifies a particular instance of the GCN list by specifying the appropriate list of lists in mh and listOfLists. Other parameters and return values are identical to GCNListSend().
See Also: GCNListSend()
Include: gcnlist.goh
GCNListSendToList()
void GCNListSendToList(
optr list, /* optr of GCN list */
EventHandle event, /* event to send to list */
MemHandle dataBlock, /* handle of data block, if any */
GCNListSendFlags flags); /* GCNListSendFlags */
This routine sends the specified event to the specified GCN list. The list is specified explicitly by optr as opposed to by manufacturer ID and type. The event will be sent via the proper queues to all objects registered on the list. After the notification is handled by all notified objects, the event will be freed, as will the data block passed. (If no data block, pass NullHandle in dataBlock)
The flags parameter can have one flag, GCNLSF_SET_STATUS. If this flag is set, the event passed will be set as the list’s status message.
Include: gcnlist.goh
See Also: GCNListSend()
GCNListSendToListHandles()
void GCNListSendToListHandles(
MemHandle mh, /* handle of list's block */
ChunkHandle ch, /* chunk of list */
EventHandle event, /* event to send to list */
MemHandle dataBlock, /* handle of data block, if any */
GCNListSendFlags flags); /* GCNListSendFlags */
This routine is exactly the same as GCNListSendToList(); the list is specified not by optr, however, but by a combination of its global and chunk handles.
See Also: GCNListSendToList()
Include: gcnlist.goh
GCNListUnRelocateBlock()
Boolean GCNListUnRelocateBlock(
MemHandle mh, /* handle of the locked lmem block
* containing the list of lists */
ChunkHandle listOfLists, /* chunk of the list of lists */
MemHandle relocBlock); /* handle of block containing
* relocation/unrelocation info */
This routine unrelocates the specified list of lists, updating all the optrs according to the information in relocBlock. This routine is rarely, if ever, used by applications; it is used primarily by the UI when shutting down to a state file.
It returns true if the specified list of lists has no lists saved to state and therefore is simply destroyed. The return value is false if the list of lists is saved to the state file normally.
Include: gcnlist.goh
GenCopyChunk()
word GenCopyChunk(
MemHandle destBlock, /* handle of locked LMem block into
* which chunk will be copied */
MemHandle blk, /* handle of locked source LMem block */
ChunkHandle chnk, /* chunk handle of chunk to be copied */
word flags); /* CompChildFlags */
This is a utility routine that copies one LMem chunk into a newly created chunk. The routine will allocate the new chunk in the block passed in destBlock and will return the chunk handle of the new chunk. It is used primarily by the UI to duplicate generic object chunks.
The source chunk is specified by the global handle blk and the chunk handle chnk. The flags parameter contains a record of CompChildFlags, of which only the CCF_MARK_DIRTY flag is meaningful. If this flag is set, the new chunk will be marked dirty.
Warnings: This routine may resize and/or move chunks and blocks, so you must dereference pointers after calling it.
Include: genC.goh
GenFindObjectInTree()
optr GenFindObjectInTree(
optr startObject, /* optr of object at which to start search */
dword childTable); /* pointer to table of bytes, each indicating
* the position of the child at the given
* level; -1 is the end of the table */
This utility routine finds the object having the optr startObject in the generic tree. Applications will not likely need this routine.
The childTable parameter points to a table of bytes, each byte representing the child number to be found at each level. The first byte indicates the child of startObject to get; the second byte indicates the child to get at the next level; the third byte indicates the child to get at the next level, and so on. A byte of -1 indicates the end of the table. The object found will be returned.
Include: genC.goh
GenInsertChild()
void GenInsertChild(
MemHandle mh, /* handle of parent */
ChunkHandle chnk, /* chunk of parent */
optr childToAdd, /* optr of new child */
optr referenceChild, /* optr of reference child */
word flags); /* CompChildFlags */
This utility routine adds a child object to a composite object. It is used almost exclusively by the UI for generic objects - applications will typically use MSG_GEN_ADD_CHILD.
See Also: MSG_GEN_ADD_CHILD
Warnings: This routine may move or resize chunks and/or object blocks; therefore, you must dereference pointers after calling it.
Include: genC.goh
GenProcessAction()
void GenProcessAction(
MemHandle mh, /* handle of object calling the routine */
ChunkHandle chnk, /* chunk of object calling the routine */
word mthd, /* message to send to actionOptr */
word dataCX, /* data to pass in CX register */
word dataDX, /* data to pass in DX register */
word dataBP, /* data to pass in BP register */
optr actionOptr);/* object to receive mthd */
This utility routine sends the action message specified in mthd to the action object specified in actionOptr. It is typically used by the UI and generic objects and corresponds to the GenClass message MSG_GEN_OUTPUT_ACTION.
Warnings: This routine may move or resize chunks and/or object blocks; therefore, you must dereference pointers after calling it.
See Also: MSG_GEN_OUTPUT_ACTION
Include: genC.goh
GenProcessGenAttrsAfterAction()
void GenProcessGenAttrsAfterAction(
MemHandle mh, /* handle of object calling the routine */
ChunkHandle chnk); /* chunk of object calling the routine */
This utility routine processes various attributes for a generic object after the object’s action message has been sent. It is used almost exclusively by the generic UI after MSG_GEN_OUTPUT_ACTION or GenProcessAction().
Warnings: This routine may move or resize chunks and/or object blocks; therefore, you must dereference pointers after calling it.
Include: genC.goh
GenProcessGenAttrsBeforeAction()
void GenProcessGenAttrsBeforeAction(
MemHandle mh, /* handle of object calling the routine */
ChunkHandle chnk); /* chunk of object calling the routine */
This utility routine processes various attributes for a generic object before the object’s action message has been sent. It is used almost exclusively by the generic UI before MSG_GEN_OUTPUT_ACTION or GenProcessAction().
Warnings: This routine may move or resize chunks and/or object blocks; therefore, you must dereference pointers after calling it.
Include: genC.goh
GenProcessUndoGetFile()
VMFileHandle GenProcessUndoGetFile();
This routine returns the handle of the file that holds the process’ undo information.
Include: Objects/gProcC.goh
GenProcessUndoCheckIfIgnoring()
Boolean GenProcessUndoCheckIfIgnoring();
This routine returns true if the process is currently ignoring actions.
Include: Objects/gProcC.goh
GenRemoveDownwardLink()
void GenRemoveDownwardLink(
MemHandle mh, /* handle of calling object */
ChunkHandle chnk, /* chunk of calling object */
word flags); /* CompChildFlags */
This utility routine removes a child from the generic tree, preserving the child’s upward link and usability flags. It is called primarily by the generic UI and is rarely used by applications. The flags parameter specifies whether the object linkage should be marked dirty by passing the CCF_MARK_DIRTY flag.
Warnings: This routine may move or resize chunks and/or object blocks; therefore, you must dereference pointers after calling it.
Include: genC.goh
GenSetUpwardLink()
void GenSetUpwardLink(
MemHandle mh, /* handle of calling object */
ChunkHandle chnk, /* chunk of calling object */
optr parent); /* optr of calling object's parent */
This utility routine converts the child/parent link to an upward-only link. Pass the handle and chunk of the locked child object and the optr of the parent composite.
Include: genC.goh
GeodeAllocQueue()
QueueHandle GeodeAllocQueue();
This routine allocates an event queue which can then be attached to a thread with ThreadAttachToQueue(). It returns the queue’s handle if one is allocated; it will return zero otherwise. This routine is used outside the kernel only in exceptional circumstances.
Be Sure To: You must free the queue when you are done with it; use GeodeFreeQueue().
Include: geode.h
GeodeDuplicateResource()
MemHandle GeodeDuplicateResource(
MemHandle mh); /* handle of geode resource to duplicate */
This routine reads a resource from a geode into a newly-allocated block (allocated by this routine). Any relocations on the resource to itself are adjusted to be the duplicated block. The handle of the duplicated block is returned.
Include: resource.h
GeodeFind()
GeodeHandle GeodeFind(
const char * name, /* geode's permanent name */
word numChars, /* number of characters to match:
* 8 for name, 12 for name.ext */
GeodeAttrs attrMatch, /* GeodeAttrs that must be set */
GeodeAttrs attrNoMatch); /* GeodeAttrs that must be off */
This routine finds a geode given its permanent name, returning the geode handle if found. If the geode can not be found, a null handle will be returned. Pass it the following:
name - A pointer to the null-terminated permanent name of the geode.
numChars - The number of characters to match before returning. Pass GEODE_NAME_SIZE to match the permanent name, (GEODE_NAME_SIZE + GEODE_EXT_SIZE) to match the name and extension.
attrMatch - A record of GeodeAttrs the subject geode must have set for a positive match.
attrNoMatch - A record of GeodeAttrs the subject geode must have cleared for a positive match.
Include: geode.h
GeodeFindResource()
word GeodeFindResource(
FileHandle file, /* geode's executable file */
word resNum, /* resource number to find */
word resOffset, /* offset to resource */
dword * base); /* pointer to second return value */
This routine locates a resource within a geode’s executable (.geo) file. It returns the size of the resource as well as the base position of the first byte of the resource in the file (pointed to by base). Pass the following:
file - The file handle of the geode’s executable file.
resNum - The number of the resource to be found.
resOffset - The offset within the resource at which to position the file’s read/write position.
base - A pointer to a dword value to be filled in by the routine. This value will be the base offset from the beginning of the file to the first byte of the resource.
Structures: A geode’s executable file is laid out as shown below.
0: Geode file header
1: Imported Library Table
2: Exported Routine Table
3: Resource Size Table
4: Resource Position Table
5: Relocation Table Size Table
6: Allocation Flags Table
7+: application resources
Include: geode.h
GeodeFlushQueue()
void GeodeFlushQueue(
QueueHandle source, /* source queue to flush */
QueueHandle dest, /* queue to hold flushed events */
optr obj /* object to handle flushed events */
MessageFlags flags); /* MF_INSERT_AT_FRONT or zero */
This routine flushes all events from one event queue into another, synchronously. Pass it the following:
source - The queue handle of the source queue (the one to be emptied).
dest - The queue handle of the destination queue that will receive the flushed events.
obj - The object that will handle flushed events that were destined for the process owning the source queue. If the process owning the destination queue should be used, pass the destination queue handle in the handle portion of the optr and a null chunk handle.
flags - A record of MessageFlags. The only meaningful flag for this routine is MF_INSERT_AT_FRONT, which should be set to flush source queue’s events to the front of the destination queue. If this flag is not passed, events will be appended to the queue.
Include: geode.h
GeodeFreeQueue()
void GeodeFreeQueue(
QueueHandle qh); /* handle of queue being freed */
This routine frees an event queue allocated with GeodeAllocQueue(). Any events still on the queue will be flushed as with GeodeFlushQueue(). You must pass the handle of the queue to be freed.
Include: geode.h
GeodeFreeDriver()
void GeodeFreeDriver(
GeodeHandle gh); /* handle of the driver */
This routine frees a driver geode that had been loaded with GeodeUseDriver(). Pass it the geode handle of the driver as returned by that routine.
Include: driver.h
GeodeFreeLibrary()
void GeodeFreeLibrary(
GeodeHandle gh); /* handle of the library */
This routine frees a library geode that had been loaded with GeodeUseLibrary(). Pass it the geode handle of the library.
Include: library.h
GeodeGetAppObject()
optr GeodeGetAppObject(
GeodeHandle gh); /* handle of the application geode */
This routine returns the optr of the specified geode’s GenApplication object. The geode should be an application. Pass zero to get the optr of the caller’s application object.
Include: geode.h
GeodeGetCodeProcessHandle()
GeodeHandle GeodeGetCodeProcessHandle();
This routine returns the geode handle of the geode that owns the block in which the code which calls this routine resides.
Include: geode.h
GeodeGetDefaultDriver()
GeodeHandle GeodeGetDefaultDriver(
GeodeDefaultDriverType type); /* type of default driver to get */
This routine returns the default driver’s geode handle for the type passed. The type must be one of the values of GeodeDefaultDriverType, which includes GDDT_FILE_SYSTEM (0)
GDDT_KEYBOARD (2)
GDDT_MOUSE (4)
GDDT_VIDEO (6)
GDDT_MEMORY_VIDEO (8)
GDDT_POWER_MANAGEMENT(10)
GDDT_TASK(12).
Include: driver.h
GeodeGetInfo()
word GeodeGetInfo(
GeodeHandle gh, /* handle of the subject geode */
GeodeGetInfoType info, /* type of information to return */
void * buf); /* buffer to contain returned info */
This routine returns information about the specified geode. The geode must be loaded already. The meaning of the returned word depends on the value passed in info; the GeodeGetInfoType is shown below. Pass the following:
gh - The geode handle of the geode.
info - The type of information requested; this should be one of the values listed below.
buf - A pointer to a locked or fixed buffer which will contain returned information for various types requested.
GeodeGetInfoType has the following enumerations (only one may be requested at a time):
GGIT_ATTRIBUTES
Get the geode’s attributes. The return value will be a record of GeodeAttrs corresponding to those attributes set for the geode. Pass a null buffer pointer.
GGIT_TYPE
Get the type of the geode. The returned value will be a value of GeosFileType indicating the type of file storing the geode. Pass a null buffer pointer.
GGIT_GEODE_RELEASE
Get the release number of the geode. The returned word will be the size of the buffer pointed to by buf, and the buffer will contain the ReleaseNumber structure of the geode.
GGIT_GEODE_PROTOCOL
Get the protocol level of the geode. The returned word will be the size of the buffer pointed to by buf, and the buffer will contain the ProtocolNumber structure of the geode.
GGIT_TOKEN_ID
Get the token identifier of the geode. The returned word will be the size of the buffer pointed to by buf, and the buffer will contain a GeodeToken structure containing the token characters and token ID of the geode’s token.
GGIT_PERM_NAME_AND_EXT
Get the permanent name of the geode, with the extension characters. The returned word will be the size of the buffer pointed to by buf, and the buffer will contain a null-terminated character string representing the geode’s permanent name (as set in its geode parameters file). Note that the buffer must be at least 13 bytes.
GGIT_PERM_NAME_ONLY
Get the permanent name of the geode without the extension characters. The returned word will be the size of the buffer pointed to by buf, and the buffer will contain the null-terminated character string representing the geode’s permanent name. The buffer must be at least nine bytes.
Include: geode.h
GeodeGetOptrNS()
optr GeodeGetOptrNS(
optr obj);
This routine unrelocates an optr, changing the virtual-segment handle to an actual global handle.
Include: resource.h
GeodeGetProcessHandle()
GeodeHandle GeodeGetProcessHandle();
This routine returns the geode handle of the current executing process (i.e. the owner of the current running thread). Use it when you need to pass your application’s geode handle or Process object’s handle to a routine or message.
Include: geode.h
GeodeGetUIData()
word GeodeGetUIData(
GeodeHandle gh);
Include: geode.h
GeodeInfoDriver()
DriverInfoStruct * GeodeInfoDriver(
GeodeHandle gh); /* handle of the driver to get information about */
This routine returns information about the specified driver geode. Pass the geode handle of the driver as returned by GeodeUseDriver(). It returns a pointer to a DriverInfoStruct structure, shown below.
typedef struct {
void (*DIS_strategy)();
DriverAttrs DIS_driverAttributes;
DriverType DIS_driverType;
} DriverInfoStruct;
For full information on this structure, see the DriverInfoStruct reference entry.
Include: driver.h
GeodeInfoQueue()
word GeodeInfoQueue(
QueueHandle qh); /* queue to query */
This routine returns information about a specific event queue. Pass the handle of the queue; for information about the current process’ queue, pass a null handle. This routine returns the number of events (or messages) currently in the queue.
Include: geode.h
GeodeLoad()
GeodeHandle GeodeLoad(
const char * name, /* file name of geode */
GeodeAttrs attrMatch, /* GeodeAttrs that must be set */
GeodeAttrs attrNoMatch, /* GeodeAttrs that must be clear */
word priority, /* priority of the loaded geode */
dword appInfo, /* special load information */
GeodeLoadError * err); /* returned error value */
This routine loads the specified geode from the given file and then executes the geode based on its type. It returns the geode handle of the loaded geode if successful; if unsuccessful, the returned value will be NullHandle and the err pointer will point to an error value. Pass this routine the following:
name - A pointer to the name of the geode’s file. This is a null-terminated character string that represents the full path of the file (or a path relative to the current working directory).
attrMatch - A record of GeodeAttrs that must be set in the specified geode for the load to be successful.
attrNoMatch - A record of GeodeAttrs that must be cleared in the specified geode for the load to be successful. (That is, each bit which is set in attrNoMatch must be clear in the geode’s GeodeAttrs field.)
priority - If the subject geode is a process, this is the priority at which its process thread will run.
appInfo - Two words of data to be passed directly to the loaded geode. For libraries and drivers, this should be a far pointer to a null-terminated string of parameters.
err - A pointer to an empty GeodeLoadError which will hold any returned error values.
Warnings: If you load a geode dynamically with GeodeLoad(), you must be sure to free it when you are done with GeodeFree().
Include: geode.h
See Also: UserLoadApplication()
GeodeLoadDGroup
void GeodeLoadDGroup(
MemHandle mh);
This routine forces the dgroup segment into the data-segment register.
Include: resource.h
GeodePrivAlloc()
word GeodePrivAlloc(
GeodeHandle gh, /* handle of the owner of the
* newly-allocated private data */
word numWords); /* number of words to allocate */
This routine allocates a string of contiguous words in all geodes’ private data areas; each set of words will be owned by the geode specified in gh. The data allocated can be accessed with GeodePrivWrite() and GeodePrivRead() and must be freed with GeodePrivFree(). The return value will be the offset to the start of the allocated range, or zero if the routine could not allocate the space.
Each geode has a block of private data the is accessed using the GeodePriv…() routines. A specific geode’s private data block is expanded only when a valid GeodePrivWrite() is performed for the geode. Space is “allocated” in the data blocks of all geodes (loaded or yet-to-be loaded) simultaneously via a call to GeodePrivAlloc(). Data that have never been written are returned as all zeros.
Include: geode.h
GeodePrivFree()
void GeodePrivFree(
word offset, /* offset returned by GeodePrivAlloc() */
word numWords); /* number of words to free */
This routine frees a group of contiguous words from all geodes’ private data areas. The space must previously have been allocated with GeodePrivAlloc(). Pass the offset to the words as returned by GeodePrivAlloc() as well as the number of words to be freed.
Include: geode.h
GeodePrivRead()
void GeodePrivRead(
GeodeHandle gh, /* handle of owner of private data */
word offset, /* offset returned by
* GeodePrivAlloc() */
word numWords, /* number of words to read */
word * dest); /* pointer to buffer into which data
* will be copied */
This routine reads a number of words from the geode’s private data area. Pass the following:
gh - The geode handle of the owner of the private data to be read.
offset - The offset to the private data as returned by GeodePrivAlloc().
numWords - The number of words to read.
dest - A pointer to a locked or fixed buffer into which the words should be read. It must be at least numWords words long.
Include: geode.h
GeodePrivWrite()
void GeodePrivWrite(
GeodeHandle gh, /* handle of owner of private data */
word offset, /* offset returned by
* GeodePrivAlloc() */
word numWords, /* number of words to be written */
word * src); /* buffer containing data */
This routine writes a number of words into a geode’s private data area. The area being written must have been allocated previously with GeodePrivAlloc(). Pass the following:
gh - The geode handle of the owner of the private data space.
offset - The offset to begin writing to, as returned by GeodePrivAlloc().
numWords - The number of words to be written. This should be no more than had been previously allocated.
src - A pointer to the locked or fixed buffer containing the data to be written.
Include: geode.h
GeodeSetDefaultDriver()
void GeodeSetDefaultDriver(
GeodeDefaultDriverType type, /* type of default driver to set */
GeodeHandle gh); /* driver to set as the default */
This routine sets the default driver for the indicated driver type. Pass the type of default driver in type and the handle of the driver in gh. The type must be a value of GeodeDefaultDriverType, which includes
GDDT_FILE_SYSTEM (0)
GDDT_KEYBOARD (2)
GDDT_MOUSE (4)
GDDT_VIDEO (6)
GDDT_MEMORY_VIDEO (8)
GDDT_POWER_MANAGEMENT(10)
GDDT_TASK(12)
Include: driver.h
GeodeSetUIData()
void GeodeSetUIData(
GeodeHandle gh,
word data)
GeodeUseDriver()
GeodeHandle GeodeUseDriver(
const char * name, /* file name of driver to load */
word protoMajor, /* expected major protocol */
word protoMinor, /* expected minor protocol */
GeodeLoadError * err); /* pointer to returned error */
This routine dynamically loads a driver geode given the driver’s file name. It returns the geode handle of the driver if successful; if unsuccessful, it returns an error code of type GeodeLoadError pointed to by err. Pass this routine the following:
name - A pointer to the driver’s null-terminated full path and file name.
protoMajor - The expected major protocol of the driver. If zero, any protocol is acceptable.
protoMinor - The expected minor protocol of the driver.
err - A pointer to a GeodeLoadError in which any error values will be returned.
Tips and Tricks: It is much easier to automatically load the drivers you need by noting them in your geode parameters file.
Be Sure To: If you use GeodeUseDriver() to dynamically load a driver, you must also use GeodeFreeDriver() to free it when you are done using it.
Include: driver.h
GeodeUseLibrary()
GeodeHandle GeodeUseLibrary(
const char * name, /* file name of library to load */
word protoMajor, /* expected major protocol */
word protoMinor, /* expected minor protocol */
GeodeLoadError * err); /* pointer to returned error */
This routine dynamically loads a library geode when given the library’s file name. (The library must be in the thread’s working directory.) It returns the geode handle of the loaded library if successful; if unsuccessful, it returns an error code (GeodeLoadError) pointed to by err. Pass this routine the following parameters:
name - A pointer to the library’s null-terminated file name.
protoMajor - The expected major protocol of the library. If zero, any protocol is acceptable.
protoMinor - The expected minor protocol of the library.
err - A pointer to a GeodeLoadError which will contain any returned error values.
Be Sure To: If you dynamically load a library with GeodeUseLibrary(), you must manually free it when finished, with GeodeFreeLibrary().
Include: library.h
GeoFree()
void * GeoFree(
void * blockPtr, /* address of memory to free */
GeodeHandle geodeHan); /* owner of block to be used */
The routine malloc() can free only memory in the malloc-block belonging to the calling geode. If you want to free memory in another geode’s malloc-block, call GeoFree(). Passing a null GeodeHandle will make GeoMalloc() act on memory in the calling geode’s malloc-block.
Include: geode.h
Warnings: Pass exactly the same address as the one returned to you when you allocated the memory. If you pass a different address, GeoFree() will take unpredictable actions, including possibly erasing other memory or crashing the system.
See Also: free()
GeoMalloc()
void * GeoMalloc(
size_t blockSize, /* # of bytes to allocate*/
GeodeHandle geodeHan, /* Owner of block to be used */
word zeroInit); /* Zero-initialize memory? */
The routine malloc() automatically allocates memory in the malloc-block belonging to the calling geode. It does not zero-initialize the memory. If you want to zero-initialize the memory, or want to allocate it in another geode’s malloc-block, call GeoMalloc(). Pass true (i.e., non-zero) in zeroInit to zero-initialize the memory.
Passing a null GeodeHandle will make GeoMalloc() allocate the memory in the calling geode’s malloc-block. If zeroInit is true, the memory will be initialized to null bytes; otherwise, the memory will be left uninitialized.
Include: geode.h
Warnings: All memory allocated with malloc() is freed when GEOS shuts down.
See Also: malloc()
GeoReAlloc()
void * GeoReAlloc(
void * blockPtr, /* address of memory to resize */
size_t newSize, /* New size in bytes */
GeodeHandle geodeHan); /* Owner of block to be used */
The routine realloc() can resize only memory in the malloc-block belonging to the calling geode. If you want to resize memory in another geode’s malloc-block, call GeoReAlloc(). Passing a null GeodeHandle will make GeoReAlloc() act on memory in the calling geode’s malloc-block.
If the block is resized larger, the new memory will not be zero-initialized. Resizing a block smaller will never fail. If GeoReAlloc() fails, it will return a null pointer (zero). If you pass a newSize of zero, the passed block pointer is freed and the return pointer is a null pointer.
Include: geode.h
Warnings: Pass exactly the same address as the one returned to you when you allocated the memory. If you pass a different address, GeoReAlloc() will take unpredictable actions, including possibly erasing other memory or crashing the system.
See Also: realloc()
GrApplyRotation()
void GrApplyRotation(
GStateHandle gstate, /* GState to alter */
WWFixedAsDWord angle); /* degrees counterclockwise */
Apply a rotation to the GState’s transformation matrix.
Include: graphics.h
GrApplyScale()
void GrApplyScale(
GStateHandle gstate, /* GState to alter */
WWFixedAsDWord xScale, /* new x scale factor */
WWFixedAsDWord yScale); /* new y scale factor */
Apply a scale factor to the GState’s transformation matrix.
Include: graphics.h
GrApplyTransform()
void GrApplyTransform(
GStateHandle gstate, /* GState to draw to */
const TransMatrix *tm); /* transformation matrix to apply */
Apply a transformation, expressed as a transformation matrix, to a GState’s coordinate system.
Include: graphics.h
GrApplyTranslation()
void GrApplyTranslation(
GStateHandle gstate, /* GState to alter */
WWFixedAsDWord xTrans, /* translation in x */
WWFixedAsDWord yTrans); /* translation in y */
Apply a translation to the GState.
Include: graphics.h
GrApplyTranslationDWord()
void GrApplyTranslationDWord(
GStateHandle gstate, /* GState to alter */
sdword xTrans, /* extended translation in x */
sdword yTrans); /* extended translation in y */
Apply a 32-bit integer extended translation to the GState.
Include: graphics.h
GrBeginPath()
void GrBeginPath(
GStateHandle gstate, /* GState to alter */
PathCombineType params); /* path parameters */
Starts or alters the path associated with a GState. All graphics operations that are executed until GrEndPath() is called become part of the path.
Depending on the value of the params field, the new path may replace the old path, or may be combined with the old path by intersection or union.
Include: graphics.h
GrBeginUpdate()
void GrBeginUpdate(
GStateHandle gstate); /* GState to draw to */
Called by an application to signal that it is about to begin updating the exposed region. This routine is normally called as part of a MSG_META_EXPOSED handler. Blanks out the invalid area.
Include: win.h
GrBitBlt()
void GrBitBlt(
GStateHandle gstate, /* GState to draw to */
sword sourceX, /* original x origin */
sword sourceY, /* original y origin */
sword destX, /* new x origin */
sword destY, /* new y origin */
word width, /* width of area */
word height, /* height of area */
BLTMode mode); /* draw mode (see below) */
Transfer a bit-boundary block of pixels between two locations in video memory. This routine is useful for animation and other applications which involve moving a drawing around the screen.
Structures:
typedef enum /* word */ {
BLTM_COPY, /* Leave source region alone */
BLTM_MOVE, /* Clear & invalidate source rect */
BLTM_CLEAR /* Clear source rectangle */
} BLTMode;
Include: graphics.h
GrBrushPolyline()
void GrBrushPolyline(
GStateHandle gstate, /* GState to draw to */
const Point * points, /* array of Point structures to draw */
word numPoints, /* number of points in array */
word brushH, /* brush height */
word brushW); /* brush width */
Draw a brushed connected polyline. Note that this routine ignores the GState’s line width, and instead uses a brush height and width, measured in pixels.
Include: graphics.h
GrCharMetrics()
dword GrCharMetrics(
GStatehandle gstate, /* GState to get metrics for */
GCM_info info, /* information to return */
word ch); /* character of type Chars */
Returns metric information for a single character of a font. This information is used to determine the drawing bounds for a character. To find out how wide a character is (how much space to leave for it if drawing a line of text character-by-character), use GrCharWidth() instead.
Structures:
typedef enum {
GCMI_MIN_X, /* return = value << 16 */
GCMI_MIN_X_ROUNDED, /* return = value */
GCMI_MIN_Y, /* return = value << 16 */
GCMI_MIN_Y_ROUNDED, /* return = value << 16 */
GCMI_MAX_X, /* return = value << 16 */
GCMI_MAX_X_ROUNDED, /* return = value << 16 */
GCMI_MAX_Y, /* return = value << 16 */
GCMI_MAX_Y_ROUNDED /* return = value << 16 */
} GCM_Info;
See Also: GrCharWidth()
Include: font.h
GrCharWidth()
dword GrCharWidth( /* Returns width << 16 */
GStateHandle gstate, /* GState to query */
word ch); /* character of type Chars */
Return the width of a single character. Note that this routine does not take into account track kerning, pairwise kerning, space padding, or other attributes that apply to multiple characters.
Include: graphics.h
GrCheckFontAvailID()
FontID GrCheckFontAvailID(
FontEnumFlags flags,
word family,
FontID id);
See if font (identified by ID) exists.
Include: graphics.h
GrCheckFontAvailName()
FontID GrCheckFontAvailName(
FontEnumFlags flags,
word family,
const char * name);
See if font (identified by name) exists.
Include: graphics.h
GrClearBitmap()
void GrClearBitmap(
GStateHandle gstate); /* GState to affect */
Clear out the content of a bitmap. Note that the part of the bitmap actually cleared depends on the bitmap mode. For the normal mode, the data portion of the bitmap is cleared. If the bitmap is in BM_EDIT_MASK mode, then the mask is cleared and the data portion is left alone.
Include: graphics.h
GrCloseSubPath()
void GrCloseSubPath(
GStateHandle gstate); /* GState to affect */
Geometrically closes the currently open path segment. Note that you must still call GrEndPath() to end the path definition.
Include: graphics.h
GrComment()
void GrComment(
GStateHandle gstate, /* GState to affect */
const void * data, /* comment string */
word size); /* Size of data, in bytes */
Write a comment out to a graphics string.
Include: graphics.h
GrCopyGString()
GSRetType GrCopyGString(
GStateHandle source, /* GState from which to get GString */
GStateHandle dest, /* GState to which to copy GString */
GSControl flags); /* flags for the copy */
Copy all or part of a Graphics String. The GSControl record can have the following flags:
GSC_ONE /* just do one element */
GSC_MISC /* return on MISC opcode */
GSC_LABEL /* return on GR_LABEL opcode */
GSC_ESCAPE /* return on GR_ESCAPE opcode */
GSC_NEW_PAGE /* return when we get to a NEW_PAGE */
GSC_XFORM /* return on TRANSFORMATIONopcode */
GSC_OUTPUT: /* return on OUTPUT opcode */
GSC_ATTR /* return on ATTRIBUTE opcode */
GSC_PATH /* return on PATH opcode */
The return value can be any one of GSRetType, a byte-size field:
GSRT_COMPLETE
GSRT_ONE
GSRT_MISC
GSRT_LABEL
GSRT_ESCAPE
GSRT_NEW_PAGE
GSRT_XFORM
GSRT_OUTPUT
GSRT_ATTR
GSRT_PATH
GSRT_FAULT
Include: gstring.h
GrCreateBitmap()
VMBlockHandle GrCreateBitmap(
BMFormat initFormat, /* color fomat of bitmap */
word initWidth, /* initial width of bitmap */
word initHeight, /* initial height of bitmap */
VMFileHandle vmFile, /* VM file to hold bitmap's data*/
optr exposureOD, /* optr to get MSG_META_EXPOSED */
GStateHandle * bmgs); /* Draws to this GState
* will draw to the bitmap */
This routine allocates memory for a bitmap and creates an off-screen window in which to hold the bitmap. This routine takes the following arguments:
initFormat - The depth of the bitmap’s color.
initWidth - Bitmap’s width.
initHeight - Bitmap’s height.
vmFile - File to hold the bitmap data; the routine will allocate a block within this file.
exposureOD - Object which will receive the “exposed” message when the bitmap’s window is invalidated. If this argument is zero, then no exposed message will be sent. Remember that an off-screen window is created to house the bitmap. When this window is first created, it will be invalid, and it is conceivable that later actions could cause it to become invalid again. On these occasions, the object specified by this argument will receive a MSG_META_EXPOSED.
bmgs - The GStateHandle pointed to by this argument can start out as null; the routine will use it to return the GState by which the bitmap can be drawn to. Any graphics routines which draw to this returned GState will be carried out upon the bitmap.
The routine returns a VMBlockHandle, the handle of the block within the passed VM file which contains the bitmap’s data. The block will be set up as the first block of a HugeArray. Its header area will be filled with the following:
Complex Bitmap Header
This is a CBitmap structure which contains some basic information about the bitmap.
Editing Mode
These flags can change how the bitmap is being edited.
Device Information Block
This internal structure contains information about and used by the video driver. (Don’t worry that you don’t know the size of this structure; remember that the CBitmap structure contains the offsets of the bitmap and palette data areas.)
Pallette Information (optional)
If the bitmap has its own pallette, this is where the palette data will be stored; it will consist of an array of 3-byte entries. Depending on how many colors the bitmap supports, there may be 16 or 256 entries in this array.
The bitmap’s raw data is in the VM block, but outside of the header area.
Include: graphics.h
GrCreateGString()
GStateHandle GrCreateGString(
Handle han, /* memory, stream, or VM file handle */
GStringType hanType, /* type of handle in han parameter */
word * gsBlock); /* returned for GST_MEMORY and
* GST_VMEM types only */
Open a graphics string and start redirecting graphics orders to the string. The hanType parameter must be GST_MEMORY, GST_STREAM, or GST_VMEM.
Include: gstring.h
GrCreatePalette()
word GrCreatePalette( /* Returns # of entries in color table
* or 0 for monochrome or 24-bit */
GStateHandle gstate);
Create a color mapping table and associate it with the current window. Initialize the table entries to the default palette for the device.
Include: graphics.h
GrCreateState()
GStateHandle GrCreateState(
WindowHandle win); /* Window in which GState will be active */
Create a graphics state (GState) block containg default GState information.
If zero is passed, then the GState created will have no window associated with it.
Include: graphics.h
GrDeleteGStringElement()
void GrDeleteGStringElement(
GStateHandle gstate, /* GState containing GString */
word count); /* number of elements to delete */
Delete a range of GString elements from the GString in the passed GState.
Include: graphics.h
GrDestroyBitmap()
void GrDestroyBitmap(
GStateHandle gstate, /* GState containing bitmap */
BMDestroy flags); /* flags for removing data */
Free the bitmap and disassociate it with its window. Depending on the passed flag, the bitmap’s data may be freed or preserved. Thus, it is possible to remove the GString used to edit the bitmap while maintaining the bitmap in a drawable state.
Structures:
typedef ByteEnum BMDestroy;
/* BMD_KILL_DATA,
BMD_LEAVE_DATA */
Include: graphics.h
GrDestroyGString()
void GrDestroyGString(
Handle gstring, /* Handle of GString */
GStateHandle gstate, /* NULL, or handle of another
* gstate to free*/
GStringKillType type); /* Kill type for data removal */
Destroys a GString. Depending on the GStringKillType argument, this either constitutes removing the GState from the GString data; or freeing both the GState and the GString’s data. If you have been drawing the GString to a GState, you should pass the GState’s handle as gstate, and this routine will do some cleaning up.
Structures:
typedef ByteEnum GStringKillType;
/* GSKT_KILL_DATA,
GSKT_LEAVE_DATA */
Include: gstring.h
GrDestroyPalette()
void GrDestroyPalette(
GStateHandle gstate); /* GState of palette to destroy */
Free any custom palette associated with the current window.
Include: graphics.h
GrDestroyState()
void GrDestroyState(
GStateHandle gstate); /* GState to be destroyed */
Free a graphics state block.
Include: graphics.h
GrDrawArc()
void GrDrawArc(
GStateHandle gstate, /* GState to draw to */
sword left, /* bounds of box outlining arc */
sword top,
sword right,
sword bottom,
word startAngle, /* angles in degrees
word endAngle, * counter-clockwise */
ArcCloseType arcType); /* how the arc is closed */
Draw an arc along the ellipse that is specified by a bounding box, from the starting angle to the ending angle.
Include: graphics.h
GrDrawArc3Point()
void GrDrawArc3Point(
GStateHandle gstate, /* GState to draw to */
const ThreePointArcParams *params); Draw a circular arc, given three points along the arc; both endpoints and any other point on the arc.
Include: graphics.h
GrDrawArc3PointTo()
void GrDrawArc3PointTo(
GStateHandle gstate, /* GState to draw to */
const ThreePointArcToParams *params);
As GrDrawArc3Point(), above, except that the current position is automatically used as one of the endpoints.
Include: graphics.h
GrDrawBitmap()
void GrDrawBitmap(
GStateHandle gstate, /* GState to draw to */
sword x, /* x starting point */
sword y, /* y starting point */
const Bitmap * bm, /* pointer to the bitmap */
Bitmap * _pascal (*callback) (Bitmap *bm)); /* NULL for no callback */
Draw a bitmap. Note that if the bitmap takes up a great deal of memory, it is necessary to manage its memory when drawing. If the bitmap resides in a HugeArray (true of any bitmap created using GrCreateBitmap()), then calling GrDrawHugeBitmap() will automatically take care of memory management. Otherwise, you may wish to provide a suitable callback routine. This routine should be declared _pascal and is passed a pointer into the passed bitmap and is expected to return a pointer to the next slice. This allows the bitmap to be drawn in horizontal bands, or swaths.
Include: graphics.h
GrDrawBitmapAtCP()
void GrDrawBitmapAtCP(
GStateHandle gstate, /* GState to draw to */
const Bitmap * bm, /* pointer to the bitmap */
Bitmap * (*callback) (Bitmap *bm)); /* NULL for no callback */
This routine is the same as GrDrawBitmap(), above, except that the bitmap is drawn at the current position.
Include: graphics.h
GrDrawChar()
void GrDrawChar(
GStateHandle gstate, /* GState to draw to */
sword x, /* x position at which to draw */
sword y, /* y position at which to draw */
word ch); /* character of type Chars */
Draw a character at the given position with the current text drawing attributes.
Include: graphics.h
GrDrawCharAtCP()
void GrDrawCharAtCP(
GStateHandle gstate, /* GState to draw to */
word ch); /* character of type Chars */
Draw a character at the current position with the current text drawing attributes.
Include: graphics.h
GrDrawCurve()
void GrDrawCurve(
GStateHandle gstate, /* GState to draw to */
const Point *points); /* array of four Points */
Draw a Bezier curve.
Include: graphics.h
GrDrawCurveTo()
void GrDrawCurveTo(
GStateHandle gstate, /* GState to draw to */
const Point *points); /* array of three Points */
Draw a Bezier curve, using the current postion as the first point.
Include: graphics.h
GrDrawEllipse()
void GrDrawEllipse(
GStateHandle gstate, /* GState to draw to */
sword left, /* bounding box bounds */
sword top,
sword right,
sword bottom);
Draw an ellipse, defined by its bounding box.
Include: graphics.h
GrDrawGString()
GSRetType GrDrawGString(
GStateHandle gstate, /* GState to draw to */
Handle gstringToDraw, /* GString to draw */
sword x, /* point at which to draw */
sword y,
GSControl flags, /* GSControl record */
GStringElement * lastElement); /* pointer to empty structure */
Draw a graphics string. The passed control flag allows drawing to stop upon encountering certain kinds of drawing elements. If this causes the drawing to stop in mid-string, then the routine will provide a pointer to the next GStringElement to be played.
You must provide a GState to draw to. You may wish to call GrSaveState() on the GState before drawing the GString (and call GrRestoreState() afterwards). If you will draw anything else to this GState after the GString, you must call GrDestroyGString() on the GString, and pass this GState’s handle as the gstate argument so that GrDestroyGString() can clean up the GState.
You must provide a GString to draw. The GString must be properly loaded (probably by means of GrLoadGString()).
You can provide a pair of coordinates at which to draw the GString. The graphics system will translate the coordinate system by these coordinates before carrying out the graphics commands stored in the GString.
You can provide a GSControl argument which requests that the system stop drawing the GString when it encounters a certain type of GString element. If the GString interpreter encounters one of these elements, it will immediately stop drawing. The GString will remember where it stopped drawing. If you call GrDrawGString() with that same GString, it will continue drawing where you left off.
You must provide a pointer to an empty GStringElement structure. GrDrawGString() will return a value here when it is finished drawing. If the GString has stopped drawing partway through due to a passed GSControl, the returned GStringElement value will tell you what sort of command was responsible for halting drawing. For instance, if you had instructed GrDrawGString() to halt on an `output’ element (GrDraw…() or GrFill…() commands), then when GrDrawGString() returns, you would check the value returned to see what sort of output element was present.
Include: gstring.h
GrDrawGStringAtCP()
GSRetType GrDrawGStringAtCP(
GStateHandle gstate, /* GState to draw to */
GStringeHandle gstringToDraw, /* GString to draw */
GSControl flags, /* GSControl flags */
GStringElement * lastElement); /* last element to draw */
Draw a graphics string as GrDrawGString(), above, except that drawing takes place at the current position.
You must provide a GState to draw to. You may wish to call GrSaveState() on the GState before drawing the GString (and call GrRestoreState() afterwards). If you will draw anything else to this GState after the GString, you must call GrDestroyGString() on the GString, and pass this GState’s handle as the gstate argument so that GrDestroyGString() can clean up the GState.
You must provide a GString to draw. The GString must be properly loaded (probably by means of GrLoadGString()).
You can provide a GSControl argument which requests that the system stop drawing the GString when it encounters a certain type of GString element. If the GString interpreter encounters one of these elements, it will immediately stop drawing. The GString will remember where it stopped drawing. If you call GrDrawGString() with that same GString, it will continue drawing where you left off.
You must provide a pointer to an empty GStringElement structure. GrDrawGString() will return a value here when it is finished drawing. If the GString has stopped drawing partway through due to a passed GSControl, the returned GStringElement value will tell you what sort of command was responsible for halting drawing. For instance, if you had instructed GrDrawGString() to halt on an `output’ element (GrDraw…() or GrFill…() commands), then when GrDrawGString() returns, you would check the value returned to see what sort of output element was present.
Include: gstring.h
GrDrawHLine()
void GrDrawHLine(
GStateHandle gstate, /* GState to draw to */
sword x1, /* first horizontal coordinate */
sword y, /* vertical position of line */
sword x2); /* second horizontal coordinate */
Draw a horizontal line.
Include: graphics.h
GrDrawHLineTo()
void GrDrawHLineTo(
GStateHandle gstate, /* GState to draw to */
sword x); /* ending horizontal coordinate */
Draw a horizontal line starting from the current position.
Include: graphics.h
GrDrawHugeBitmap()
void GrDrawHugeBitmap(
GStateHandle gstate, /* GState to draw to */
sword x /* Point at which to draw */
sword y,
VMFileHandle vmFile, /* VM File holding HugeArray */
VMBlockHandle vmBlk); /* VM block of HugeArray */
Draw a bitmap that resides in a HugeArray.
Include: graphics.h
See Also: GrDrawBitmap() , GrDrawHugeBitmapAtCP(), GrDrawHugeImage()
GrDrawHugeBitmapAtCP()
void GrDrawHugeBitmapAtCP(
GStateHandle gstate, /* GState to draw to */
VMFileHandle vmFile, /* VM file containing HugeArray */
VMBlockHandle vmBlk); /* VM block containing HugeArray */
As GrDrawHugeBitmap(), above, except that the bitmap is drawn at the current position.
Include: graphics.h
See Also: GrDrawBitmapAtCP(), GrDrawHugeBitmap()
GrDrawHugeImage()
void GrDrawHugeImage(
GStateHandle gstate, /* GState to draw to */
sword x /* point at which to draw */
sword y,
ImageFlags flags,
VMFileHandle vmFile, /* VM file holding HugeArray */
VMBlockHandle vmBlk); /* VM block holding HugeArray */
Draw a bitmap that resides in a HugeArray. Note that the bitmap will be drawn on an assumption of one device pixel per bitmap pixel. The bitmap will not draw rotated or scaled. Depending on the value of the flags argument, the bitmap may be expanded so that a square of device pixels displays each bitmap pixel.
Structures:
typedef ByteFlags ImageFlags;
/* The following flags be be combined using | and &:
IF_IGNORE_MASK,
IF_BORDER
* The flags should be combined with one ImageBitSize:
IF_BITSIZE */
#define IBS_1 0
#define IBS_2 1
#define IBS_4 2
#define IBS_8 3
#define IBS_16 4
Include: graphics.h
See Also: GrDrawImage() , GrDrawHugeBitmapAtCP()
GrDrawImage()
void GrDrawImage(
GStateHandle gstate, /* GState to draw to */
sword x /* point at which to draw */
sword y,
ImageFlags flags,
const Bitmap * bm); /* pointer to bitmap */
Draw a bitmap. Note that the bitmap will be drawn on an assumption of one device pixel per bitmap pixel. The bitmap will not draw rotated or scaled. Depending on the value of the flags argument, the bitmap may be expanded so that a square of device pixels displays each bitmap pixel.
Structures:
typedef ByteFlags ImageFlags;
/* The following flags be be combined using | and &:
IF_IGNORE_MASK,
IF_BORDER
* The flags should be combined with one ImageBitSize:
IF_BITSIZE */
#define IBS_1 0
#define IBS_2 1
#define IBS_4 2
#define IBS_8 3
#define IBS_16 4
Include: graphics.h
See Also: GrDrawHugeImage() , GrDrawBitmap()
GrDrawLine()
void GrDrawLine(
GStateHandle gstate, /* GState to draw to */
sword x1, /* First coordinate of line */
sword y1,
sword x2, /* Second coordinate of line */
sword y2);
Draw a line.
Include: graphics.h
See Also: GrDrawLineTo(), GrDrawHLine(), GrDrawVLine()
GrDrawLineTo()
void GrDrawLineTo(
GStateHandle gstate, /* GState to draw to */
sword x, /* Second coordinate of line */
sword y);
Draw a line starting from the current position.
Include: graphics.h
See Also: GrDrawLine(), GrDrawHLineTo(), GrDrawVLineTo()
GrDrawPath()
void GrDrawPath(
GStateHandle gstate); /* GState to draw to */
Draws the stroked version of the current path, using the current graphic line attributes.
Include: graphics.h
GrDrawPoint()
void GrDrawPoint(
GStateHandle gstate, /* GState to draw to */
sword x, /* Coordinates of point to draw */
sword y);
Draw a pixel.
Include: graphics.h
GrDrawPointAtCP()
void GrDrawPointAtCP(
GStateHandle gstate); /* GState to draw to */
Draw a pixel.
Include: graphics.h
GrDrawPolygon()
void GrDrawPolygon(
GStateHandle gstate, /* GState to draw to */
const Point * points, /* array of points in polygon */
word numPoints); /* number of points in array */
Draws a connected polygon.
Include: graphics.h
GrDrawPolyline()
void GrDrawPolyline(
GStateHandle gstate, /* GState to draw to */
const Point * points, /* array of points in polyline */
word numPoints); /* number of points in array */
Draws a simple polyline.
Include: graphics.h
GrDrawRect()
void GrDrawRect(
GStateHandle gstate, /* GState to draw to */
sword left, /* bounds of rectangle to draw */
sword top,
sword right,
sword bottom);
Draws the outline of a rectangle.
Include: graphics.h
GrDrawRectTo()
void GrDrawRectTo(
GStateHandle gstate, /* GState to draw to */
sword x, /* opposite corner of rectangle */
sword y);
Draws the outline of a rectangle, with one corner defined by the current position.
Include: graphics.h
GrDrawRegion()
void GrDrawRegion(
GStateHandle gstate, /* GState to draw to */
sword xPos, /* Position at which to draw */
sword yPos,
const Region * reg, /* Region definition */
sword param0, /* value to use with
* parameterized coordinates */
sword param)1; /* value to use with
* parameterized coordinates */
Draw a region. The area will be rendered filled with the GState’s area attributes.
Include: graphics.h
GrDrawRegionAtCP()
void GrDrawRegionAtCP(
GStateHandle gstate, /* GState to draw to */
const Region * reg, /* region definition */
sword param0, /* Value to use with parameterized coordinates */
sword param1, /* Value to use with parameterized coordinates */
sword param2, /* Value to use with parameterized coordinates */
sword param)3;/* Value to use with parameterized coordinates */
Draw a region at the current pen position. The area will be rendered filled with the GState’s area attributes.
Include: graphics.h
GrDrawRelArc3PointTo()
void GrDrawRelArc3PointTo(
const ThreePointRelArcToParams *params);
Draw a circular arc relative to the current point given two additional points: the other endpoint and any other point on the arc, both described in relative coordinates.
Include: graphics.h
GrDrawRelLineTo()
void GrDrawRelLineTo(
GStateHandle gstate, /* GState to draw to */
WWFixedAsDWord x, /* horizontal offset of second point */
WWFixedAsDWord y); /* vertical offset of second point */
Draw a line from the current pen position, given a displacement from the current pen position to draw to.
Include: graphics.h
GrDrawRoundRect()
void GrDrawRoundRect(
GStateHandle gstate, /* GState to draw to */
sword left, /* bounds of rectangle */
sword top,
sword right,
sword bottom,
word cornerRadius); /* radius of corner rounding */
Draw the outline of a rounded rectangle.
Include: graphics.h
GrDrawRoundRectTo()
void GrDrawRoundRectTo(
GStateHandle gstate, /* GState to draw to */
sword x, /* opposite corner of bounds */
sword y,
word cornerRadius); /* radius of corner rounding */
Draw the outline of a rounded rectangle, where one corner of the bounding rectangle is the current position.
Include: graphics.h
GrDrawSpline()
void GrDrawSpline(
GStateHandle gstate, /* GState to draw to */
const Point * points, /* array of points */
word numPoints,); /* number of points in array */
Draw a Bezier spline.
Include: graphics.h
See Also: GrDrawCurve()
GrDrawSplineTo()
void GrDrawSplineTo(
GStateHandle gstate, /* GState to draw to */
const Point *points, /* array of points */
word numPoints); /* number of points in array */
Draw a Bezier spline, using the current position as one endpoint.
Include: graphics.h
See Also: GrDrawCurveTo()
GrDrawText()
void GrDrawText(
GStateHandle gstate, /* GState to draw to */
sword x, /* point at which to draw */
sword y,
const Chars * str, /* pointer to character string */
word size); /* length of string */
Draw a string of text. The string is represented as an array of characters. Note that the text will be drawn using the GState’s font drawing attributes and that this routine does not accept any style run arguments.
If the passed size argument is zero, the string is assumed to be null-terminated.
Include: graphics.h
GrDrawTextAtCP()
void GrDrawTextAtCP(
GStateHandle gstate, /* GState to draw to */
const Chars * str, /* pointer to character string */
word size); /* length of string */
As GrDrawText(), above, except that the text is drawn at the current position.
If the passed size argument is zero, the string is assumed to be null-terminated.
Include: graphics.h
GrDrawVLine()
void GrDrawVLine(
GStateHandle gstate, /* GState to draw to */
sword x, /* horizontal position of line */
sword y1, /* first vertical coordinate */
sword y2); /* second vertical coordinate */
Draw a vertical line.
Include: graphics.h
GrDrawVLineTo()
void GrDrawVLine(
GStateHandle gstate, /* GState to draw to */
sword y); /* second vertical position */
Draw a vertical line starting from the current position.
Include: graphics.h
GrEditBitmap()
GStateHandle GrEditBitmap(
VMFileHandle vmFile, /* VM file of bitmap */
VMBlockHandle vmBlock, /* VM block of bitmap */
optr exposureOD); /* optr to get MSG_META_EXPOSED */
This routine attaches a GState to the passed bitmap so that new drawings may be be sent to the bitmap.
Include: graphics.h
GrEditGString()
GStateHandle GrEditGString(
Handle vmFile, /* VM file containing the GString */
word vmBlock); /* VM block containing the GString */
This routine takes the location of a GString data block stored in a VM file. It will associate a GState with this GString data and returns the handle of this GState. Any graphics commands issued using this GStateHandle will be appended to the GString.
Include: graphics.h
GrEndGString()
GStringErrorType GrEndGString(
GStateHandle gstate); /* GState to draw to */
Finish the definition of a graphics string.
Structures:
typedef enum {
GSET_NO_ERROR,
GSET_DISK_FULL
} GStringErrorType;
Include: graphics.h
GrEndPath()
void GrEndPath(
GStateHandle gstate); /* GState to draw to */
Finish definition of a path. Further graphics commands will draw to the display, as normal.
Include: graphics.h
GrEndUpdate()
void GrEndUpdate(
GStateHandle gstate); /* GState to draw to */
Unlocks window from an update.
Include: win.h
GrEnumFonts()
word GrEnumFonts( /* Return value = number of fonts found */
FontEnumStruct * buffer, /* buffer for returned values */
word size, /* number of structures to return */
FontEnumFlags flags, /* FontEnumFlags */
word family); /* FontFamily */
Generate a list of available fonts. The font information includes both the font’s ID and a string name.
Structures:
typedef struct {
FontID FES_ID;
char FES_name[FID_NAME_LEN];
} FontEnumStruct;
Include: font.h
GrEscape()
void GrEscape(
GStateHandle gstate, /* GState to draw to */
word code, /* escape code */
const void * data, /* pointer to the data */
word size); /* Size of data, in bytes */
Write an escape code to a graphics string.
Include: graphics.h
GrFillArc()
void GrFillArc(
GStateHandle gstate, /* GState to draw to */
sword left, /* bounding rectangle */
sword top,
sword right,
sword bottom,
word startAngle, /* angles in degrees
word endAngle * counter-clockwise */
ArcCloseType closeType); /* OPEN, CHORD, or PIE */
Fill an elliptical arc. The arc is defined by the bounding rectangle of the base ellipse and two angles. Depending on how the arc is closed, this will result in either a wedge or a chord fill.
Include: graphics.h
GrFillArc3Point()
void GrFillArc3Point(
GStateHandle gstate, /* GState to draw to */
const ThreePointParams *params);
Fill an arc. Depending on how the arc is closed, this will result in either a wedge or a chord fill. The arc is defined in terms of its endpoints and one other point, all of which must lie on the arc.
Include: graphics.h
GrFillArc3PointTo()
void GrFillArc3PointTo(
GStateHandle gstate, /* GState to draw to */
const ThreePointArcParams *params);
As GrFillArc3Point(), above, except that one endpoint of the arc is defined by the current position.
Include: graphics.h
GrFillBitmap()
void GrFillBitmap (
GStateHandle gstate, /* GState to draw to */
sword x, /* point at which to draw */
sword y,
const Bitmap * bm, /* pointer to bitmap */
Bitmap * (*callback) (Bitmap *bm));
Fill a monochrome bitmap with the current area attributes. The arguments to this routine are the same as those for GrDrawBitmap().
Include: graphics.h
GrFillBitmapAtCP()
void GrFillBitmapAtCP (
GStateHandle gstate, /* GState to draw to */
const Bitmap * bm, /* pointer to bitmap */
Bitmap * (*callback) (Bitmap *bm));
Fill a monochrome bitmap with the current area attributes. The bitmap will be drawn at the current position. The arguments to this routine are the same as those for GrDrawBitmapAtCP().
Include: graphics.h
GrFillEllipse()
void GrFillEllipse(
GStateHandle gstate, /* GState to draw to */
sword left, /* Bounds of bounding rectangle */
sword top,
sword right,
sword bottom);
Draw a filled ellipse. The ellipse’s dimensions are defined by its bounding box.
Include: graphics.h
GrFillPath()
void GrFillPath(
GStateHandle gstate, /* GState to draw to */
RegionFillRule rule); /* ODD_EVEN or WINDING */
Fill an area whose outline is defined by the GState’s path.
Include: graphics.h
GrFillPolygon()
void GrFillPolygon(
GStateHandle gstate, /* GState to draw to */
RegionFillRule windingRule, /* ODD_EVEN or WINDING */
const Point * points, /* array of points in polygon */
word numPoints); /* number of points in array */
Fill polygon. The polygon is defined by the passed array of points.
Include: graphics.h
GrFillRect()
void GrFillRect(
GStateHandle gstate, /* GState to draw to */
sword left, /* bounds of rectangle */
sword top,
sword right,
sword bottom);
Draw a filled rectangle.
Include: graphics.h
GrFillRectTo()
void GrFillRectTo(
GStateHandle gstate, /* GState to draw to */
sword x, /* opposite corner of rectangle */
sword y);
Draw a filled rectangle. The current position will define one of the corners.
Include: graphics.h
GrFillRoundRect()
void GrFillRoundRect(
GStateHandle gstate, /* GState to draw to */
sword left, /* bounds of rectangle */
sword top,
sword right,
sword bottom
word cornerRadius); /* radius of corner rounding */
Draw a filled rounded rectangle.
Include: graphics.h
GrFillRoundRectTo()
void GrFillRoundRectTo(
GStateHandle gstate, /* GState to draw to */
sword x, /* opposite corner of rectangle */
sword y
word cornerRadius); /* radius of corner roundings */
Draw a filled rounded rectangle, using the current position to define one corner of the bounding rectangle.
Include: graphics.h
GrFindNearestPointsize()
Boolean GrFindNearestPointsize( /* If false, then FontID invalid */
FontID id, /* fond ID */
dword sizeSHL16, /* point size */
TextStyle styles, /* style */
TextStyle * styleFound, /* buffer for style */
dword * sizeFoundSHL16); /* buffer for size */
Find the nearest available point size for a font. If the font passed in id exists, then styleFound will point to the styles available and sizeFoundSHL16 will point to the nearest point size to that passed. If the font is not found, the return valued will be true.
Include: font.h
GrFontMetrics()
dword GrFontMetrics(
GStateHandle gstate, /* subject GState */
GFM_info info); /* Type of information to return */
Get metrics information about a font. It returns the requested information based on the info parameter.
Structures:
typedef enum /* word */ {
GFMI_HEIGHT, /* return = val << 16 */
GFMI_MEAN, /* return = val << 16 */
GFMI_DESCENT, /* return = val << 16 */
GFMI_BASELINE, /* return = val << 16 */
GFMI_LEADING, /* return = val << 16 */
GFMI_AVERAGE_WIDTH, /* return = val << 16 */
GFMI_ASCENT, /* return = val << 16 */
GFMI_MAX_WIDTH, /* return = val << 16 */
GFMI_MAX_ADJUSTED_HEIGHT, /* return = val << 16 */
GFMI_UNDER_POS, /* return = val << 16 */
GFMI_UNDER_THICKNESS, /* return = val << 16 */
GFMI_ABOVE_BOX, /* return = val << 16 */
GFMI_ACCENT, /* return = val << 16 */
GFMI_MANUFACTURER, /* return = val */
GFMI_KERN_COUNT, /* return = Char */
GFMI_FIRST_CHAR, /* return = Char */
GFMI_LAST_CHAR, /* return = FontMaker */
GFMI_DEFAULT_CHAR, /* return = Char */
GFMI_STRIKE_POS, /* return = Char */
GFMI_BELOW_BOX, /* return = Char */
GFMI_HEIGHT_ROUNDED /* return = Char */
GFMI_DESCENT_ROUNDED, /* return = Char */
GFMI_BASELINE_ROUNDED, /* return = Char */
GFMI_LEADING_ROUNDED, /* return = Char */
GFMI_AVERAGE_WIDTH_ROUNDED, /* return = Char */
GFMI_ASCENT_ROUNDED, /* return = Char */
GFMI_MAX_WIDTH_ROUNDED, /* return = Char */
GFMI_MAX_ADJUSTED_HEIGHT_ROUNDED, /* ret = Char */
GFMI_UNDER_POS_ROUNDED, /* return = Char */
GFMI_UNDER_THICKNESS_ROUNDED, /* return = Char */
GFMI_ABOVE_BOX_ROUNDED, /* return = Char */
GFMI_ACCENT_ROUNDED=, /* return = Char */
GFMI_STRIKE_POS_ROUNDED, /* return = Char */
GFMI_BELOW_BOX_ROUNDED /* return = Char */
} GFM_info;
Include: font.h
GrGetAreaColor()
RGBColorAsDWord GrGetAreaColor(
GStateHandle gstate); /* GState of which to get color */
Get the color which is being used to fill areas.
Include: graphics.h
GrGetAreaColorMap()
ColorMapMode GrGetAreaColorMap(
GStateHandle gstate); /* GState of which to get area color map */
Get the mapping mode used for filling areas with unavailable colors.
Include: graphics.h
GrGetAreaMask()
SysDrawMask GrGetAreaMask(
GStateHandle gstate, /* GState of which to get mask */
DrawMask * dm); /* buffer for returned mask */
Get the draw mask used when filling areas. The dm argument should point to a buffer capable of holding at least eight bytes to get the bit-pattern of the mask; otherwise dm should be NULL. The returned buffer is the 8x8 bit pattern: each byte represents a row of the pattern, and the bytes are ordered from top row to bottom.
Include: graphics.h
GrGetAreaPattern()
GraphicPattern GrGetAreaPattern(
GStateHandle gstate, /* GState of area pattern */
const MemHandle * customPattern, /* pointer to handle of block for
* returned custom pattern */
word * customSize); /* pointer to size of returned
* buffer */
Get the area pattern used when filling areas.
Include: graphics.h
GrGetBitmap()
MemHandle GrGetBitmap(
GStateHandle gstate, /* GState containing bitmap */
sword x, /* bitmap origin */
sword y,
word width, /* bitmap width and height */
word height,
XYSize * sizeCopied); /* buffer for returned size */
Dump an area of the display to a bitmap. The handle of a block containing the bitmap is returned; the sizeCopied pointer points to the actual size of the bitmap successfully copied.
Include: graphics.h
GrGetBitmapMode()
BitmapMode GrGetBitmapMode(
GStateHandle gstate); /* GState containing bitmap */
Get mode bits for an editable bitmap.
Include: graphics.h
GrGetBitmapRes()
XYValueAsDWord GrGetBitmapRes(
const Bitmap * bm); /* pointer to the bitmap */
Get the resolution of a bitmap.
Include: graphics.h
GrGetBitmapSize()
XYValueAsDWord GrGetBitmapSize(
const Bitmap * bm); /* pointer to the bitmap */
Get the dimensions, in points, of a bitmap.
Include: graphics.h
GrGetClipRegion()
MemHandle GrGetClipRegion(
GStateHandle gstate, /* subject GState */
RegionFillRule rule); /* ODD_EVEN or WINDING */
Get the current clip region. A null handle (zero) will be returned if no clip paths are set for the GState.
Include: graphics.h
GrGetCurPos()
XYValueAsDWord GrGetCurPos(
GStateHandle gstate); /* subject GState */
Get the current pen position.
Include: graphics.h
GrGetCurPosWWFixed()
void GrGetCurPosWWFixed(
GStateHandle gstate, /* subject GState */
PointWWFixed *cp); /* buffer in which to return cur. pos. */
Get the current pen position.
Include: graphics.h
GrGetDefFontID()
FontID GrGetDefFontID(
dword * sizeSHL16); /* pointer to buffer for returned size */
Get the system default font (including size).
Include: font.h
GrGetFont()
FontID GrGetFont(
GStateHandle gstate, /* subject GState */
WWFixedAsDWord * pointSize); /* pointer to buffer for
* returned point size */
Get the passed GState’s current font, including point size.
Include: graphics.h
GrGetFontName()
FontID GrGetFontName(
FontID id, /* ID of font */
const char * name); /* buffer for returned name string */
Get the string name of a font. Note that if the returned FontID is zero, then the font was not found. The name string buffer should be a least FID_NAME_LEN in size.
Include: font.h
GrGetFontWeight()
FontWeight GrGetFontWeight(
GStateHandle gstate); /* GState containing the font */
Get the current font weight set for the passed GState.
Include: font.h
GrGetFontWidth()
FontWidth GrGetFontWidth(
GStateHandle gstate); /* GState containing the font */
Get the current font width set for the passed GState.
Include: font.h
GrGetGStringBounds()
void GrGetGStringBounds(
GStringHandle source, /* GString to be checked */
GStateHandle dest, /* handle of GState to use */
GSControl flags, /* GSControl flags */
Rectangle * bounds); /* returned bounds of GState */
This routine returns the coordinate bounds of the source GString drawn at the current position in the GString. The dest GState will be used if passed; to have no GState restrictions, pass a null handle. The bounds of the smallest containing rectangle will be returned in the structure pointed to by bounds.
Include: gstring.h
GrGetGStringBoundsDWord
void GrGetGStringBoundsDWord(
Handle gstring, /* GString to be checked */
GStateHandle gstate, /* handle of GState to use */
GSControl flags, /* GSControl flags */
RectDWord * bounds); /* returned bounds of GState */
This routine behaves as GrGetGStringBounds(), but has been alterred to work with 32-bit graphics spaces.
This routine returns the coordinate bounds of a GString drawn at the current position in the GString. The gstate GState will be used if passed; to have no GState restrictions, pass a null handle. The bounds of the smallest containing rectangle will be returned in the structure pointed to by bounds.
Include: gstring.h
GrGetGStringElement()
GStringElement GrGetGStringElement(
GStateHandle gstate, /* handle of GString's GState */
void * buffer, /* pointer to return buffer */
word bufSize, /* size of return buffer */
word * elementSize, /* size of GString element */
void ** pointerAfterData); /* pointer to pointer to
* next element in GString */
Extract the next element from a graphics string. The opcode is returned explicitly. The routine’s data can be returned in a buffer.
Include: gstring.h
GrGetInfo()
void GrGetInfo(
GStateHandle gstate, /* GState to get information about */
GrInfoTypes type, /* type of information to get */
void * data); /* buffer for returned information */
Get the private data, window handle, or pen position associated with the GState.
Structures:
typedef enum {
GIT_PRIVATE_DATA,
GIT_WINDOW,
GIT_PEN_POS
} GrInfoType
Include: graphics.h
GrGetLineColor()
RGBColorAsDWord GrGetLineColor(
GStateHandle gstate); /* subject GState */
Get the color used when drawing lines.
Include: graphics.h
GrGetLineColorMap()
ColorMapMode GrGetLineColorMap(
GStateHandle gstate); /* subject GState */
Get the mode used when drawing lines in an unavailable color.
Include: graphics.h
GrGetLineEnd()
LineEnd GrGetLineEnd(
GStateHandle gstate); /* subject GState */
Get the end used when drawing lines.
Include: graphics.h
GrGetLineJoin()
LineJoin GrGetLineJoin(
GStateHandle gstate); /* subject GState */
Get the join used when drawing corners.
Include: graphics.h
GrGetLineMask()
SysDrawMask GrGetLineMask(
GStateHandle gstate, /* subject GState */
DrawMask * dm); /* buffer for returned custom mask */
Get the drawing mask used when drawing lines. The dm argument should point to a buffer capable of holding at least eight bytes to get the bit-pattern of the mask; otherwise dm should be NULL. The returned buffer is the 8x8 bit pattern: each byte represents a row of the pattern, and the bytes are ordered from top row to bottom.
Include: graphics.h
GrGetLineStyle()
LineStyle GrGetLineStyle(
GStateHandle gstate); /* subject GState */
Get the style, or “dottedness,” used when drawing lines.
Include: graphics.h
GrGetLineWidth()
WWFixedAsDWord GrGetLineWidth(
GStateHandle gstate); /* subject GState */
Get the current line width.
Include: graphics.h
GrGetMaskBounds()
void GrGetMaskBounds(
GStateHandle gstate, /* subject GState */
Rectangle * bounds); /* buffer for returned bounds */
Get the 16-bit bounds of the current clip rectangle.
Include: graphics.h
GrGetMaskBoundsDWord()
void GrGetMaskBoundsDWord(
GStateHandle gstate, /* subject GState */
RectDWord * bounds); /* buffer for returned bounds */
Get the 16-bit bounds of the current clip rectangle, accurate to a fraction of a point.
Include: graphics.h
GrGetMiterLimit()
WWFixedAsDWord GrGetMiterLimit(
GStateHandle gstate); /* subject GState */
Get the miter limit to use when drawing mitered corners.
Include: graphics.h
GrGetMixMode()
MixMode GrGetMixMode(
GStateHandle gstate); /* subject GState */
Get the current mixing mode.
Include: graphics.h
GrGetPalette()
MemHandle GrGetPalette(
GStateHandle gstate, /* subject GState */
GetPalType flag, /* GPT_ACTIVE, GPT_CUSTOM, or
* GPT_DEFAULT */
word * numEntries); /* number of entries in block */
Return all or part of the window’s color lookup table. This routine returns the
handle of a block containing all the returned palette entries.
Include: graphics.h
GrGetPath()
MemHandle GrGetPath(
GStateHandle gstate, /* subject GState */
GetPathType ptype); /* Which path to retrieve */
Returns handle to block containing path data. This handle may be passed to GrSetPath(). Either the current path, the clipping path, or the window clipping path may be retrieved.
Include: graphics.h
GrGetPathBounds()
Boolean GrGetPathBounds(
GStateHandle gstate, /* subject GState */
GetPathType ptype,
Rectangle * bounds); /* buffer for returned bounds */
Returns the rectangular bounds that encompass the current path as it would be filled. A true return value indicates an error occurred or there was no path for the GState.
Include: graphics.h
GrGetPathBoundsDWord()
Boolean GrGetPathBoundsDWord(
GStateHandle gstate, /* subject GState */
GetPathType ptype,
RectDWord * bounds); /* buffer for returned bounds */
Returns the rectangular bounds that encompass the current path as it would be filled. A true return value indicates an error occurred or there was no path for the GState.
Include: graphics.h
GrGetPathPoints()
MemHandle GrGetPathPoints(
GStateHandle gstate, /* subject GState */
word resolution); /* dots per inch */
Returns a series of points that fall along the current path. The returned points are in document coordinates.
Include: graphics.h
GrGetPathRegion()
MemHandle GrGetPathRegion(
GStateHandle gstate, /* subject GState */
RegionFillRule rule); /* ODD_EVEN or WINDING */
Get the region enclosed by a path.
Include: graphics.h
GrGetPoint()
RGBColorAsDWord GrGetPoint(
GStateHandle gstate, /* subject GState */
sword x, /* coordinates of pixel */
sword y);
Get the color of the pixel corresponding to the specified coordinates.
Include: graphics.h
GrGetPtrRegBounds()
word GrGetPtrRegBounds( /* Returns size of Region data struct. */
const Region * reg, /* pointer to region */
Rectangle * bounds); /* returned bounds of region */
Get the bounds of the passed region.
Include: graphics.h
GrGetSubscriptAttr()
ScriptAttrAsWord GrGetSubscriptAttr(
GStateHandle gstate); /* subject GState */
Get the GState’s subscript drawing attributes. The high byte of the return value is the percentage of the font size for the subscript; the low byte is the percentage of the font size from the top at which the character gets drawn.
Include: font.h
GrGetSuperscriptAttr()
ScriptAttrAsWord GrGetSuperscriptAttr(
GStateHandle gstate); /* subject GState */
Get the GState’s superscript drawing attributes. The high byte of the return value is the percentage of the font size for the superscript; the low byte is the percentage of the font size from the bottom at which the character gets drawn.
Include: font.h
GrGetTextBounds()
Boolean GrGetTextBounds(
GStateHandle gstate, /* subject GState */
word xpos, /* position where text would be drawn */
word ypos,
const char * str, /* text string */
word count, /* max number of characters to check */
Rectangle * bounds); /* returned bounding rectangle */
Get the bounds required to draw the passed text. If the passed size argument is zero, the string is assumed to be null-terminated.
Include: graphics.h
GrGetTextColor()
RGBColorAsDWord GrGetTextColor(
GStateHandle gstate); /* subject GState */
Get the color used when drawing text.
Include: graphics.h
GrGetTextColorMap()
ColorMapMode GrGetTextColorMap(
GStateHandle gstate); /* subject GState */
Get the mode used when drawing text in an unavailable color.
Include: graphics.h
GrGetTextMask()
SystemDrawMask GrGetTextMask(
GStateHandle gstate, /* subject GState */
DrawMask * dm); /* returned custom mask, if any */
Get the draw mask used when drawing text.The dm argument should point to a buffer capable of holding at least eight bytes to get the bit-pattern of the mask; otherwise dm should be NULL. The returned buffer is the 8x8 bit pattern: each byte represents a row of the pattern, and the bytes are ordered from top row to bottom.
Include: graphics.h
GrGetTextMode()
TextMode GrGetTextMode(
GStateHandle gstate); /* subject GState */
Get the text mode, including information about the vertical offset used when drawing text.
Include: graphics.h
GrGetTextPattern()
GraphicPattern GrGetTextPattern(
GStateHandle gstate, /* subject GState */
const MemHandle * customPattern, /* pointer to returned handle
* of block containing the
* returned pattern */
word * customSize); /* size of returned block */
Get the graphics pattern used when drawing text.
Include: graphics.h
GrGetTextSpacePad()
WWFixedAsDWord GrGetTextSpacePad(
GStateHandle gstate); /* subject GState */
Get the space pad used when drawing strings of text.
Include: graphics.h
GrGetTextStyle()
TextStyle GrGetTextStyle(
GStateHandle gstate); /* subject GState */
Get the style used when drawing text.
Include: graphics.h
GrGetTrackKern()
word GrGetTrackKern(
GStateHandle gstate); /* subject GState */
Get the track kerning used when drawing strings of text.
Include: graphics.h
GrGetTransform()
void GrGetTransform(
GStateHandle gstate, /* subject GState */
TransMatrix * tm); /* pointer to returned TransMatrix */
Get the current coordinate transformation, expressed as a matrix.
Include: graphics.h
GrGetWinBounds()
void GrGetWinBounds(
GStateHandle gstate, /* subject GState */
Rectangle * bounds); /* returned window bounds */
Get the bounds of the GState’s associated window.
Include: graphics.h
GrGetWinBoundsDWord()
void GrGetWinBoundsDWord(
GStateHandle gstate, /* subject GState */
RectDWord * bounds); /* returned window bounds */
Get the bounds of the GState’s associated window, accurate to a fraction of a point.
Include: graphics.h
GrGetWinHandle()
WindowHandle GrGetWinHandle(
GStateHandle gstate); /* subject GState */
Get the handle of the GState’s associated window.
Include: graphics.h
GrGrabExclusive()
GStateHandle GrGrabExclusive(
GeodeHandle videoDriver, /* NULL for default */
GStateHandle gstate); /* subject GState */
Start drawing exclusively to a video driver.
Include: graphics.h
GrInitDefaultTransform()
void GrInitDefaultTransform(
GStateHandle gstate); /* subject GState */
Initialize the GState’s default transformation to hold hte value of the current transformation.
Include: graphics.h
GrInvalRect()
void GrInvalRect(
GStateHandle gstate, /* subject GState */
sword left, /* bounds to be invalidated */
sword top,
sword right,
sword bottom);
Invalidate the passed rectangular area. This area will be redrawn.
Include: graphics.h
GrInvalRectDWord()
void GrInvalRectDWord(
GStateHandle gstate, /* subject GState */
const RectDWord * bounds); /* bounds to be invalidated */
Invalidate the passed rectangular area. This area will be redrawn.
Include: graphics.h
GrLabel()
void GrLabel(
GStringHandle gstate, /* subject GState */
word label); /* label to write to GString */
Write the passed label into the passed GString.
Include: gstring.h
GrLoadGString()
GStringHandle GrLoadGString(
Handle han, /* handle of GString source */
GStringType hanType, /* handle type */
word vmBlock); /* if VM file, handle of VM block */
Load a graphics string from a file. Used with stream, VM, and pointer addressed GStrings.
Structures:
typedef ByteEnum GStringType;
/* GST_MEMORY,
GST_STREAM,
GST_VMEM,
GST_PTR,
GST_PATH */
Include: gstring.h
GrMapColorIndex()
RGBColorAsDWord GrMapColorIndex(
GStateHandle gstate, /* GState to use for mapping */
Color c); /* source color to be mapped */
Map a color index to its RGB equivalent using the color mapping scheme of the passed GState.
Include: graphics.h
GrMapColorRGB()
RGBColorAsDWord GrMapColorRGB(
GStateHandle gstate, /* GState to use for mapping */
word red, /* RGB values to map */
word green,
word blue);
Map an RGB color to an index.
Include: graphics.h
GrMoveReg()
void GrMoveReg(
Region * reg, /* pointer to region */
sword xOffset, /* amount to shift horizontally */
sword yOffset); /* amount to shift vertically */
Moves a region a given amount. Note that this operation affects only the region’s data structure. The region must be redrawn or used in some other way for the changes to have any visible effect.
Include: graphics.h
GrMoveTo()
void GrMoveTo(
GStateHandle gstate, /* subject GState */
sword x, /* new absolute pen position */
sword y);
Change the pen position.
Include: graphics.h
GrMulDWFixed()
void GrMulDWFixed(
const DWFixed * i, /* first number */
const DWFixed * j, /* second number */
DWFixed * result); /* pointer to returned result */
Multiply two fixed point numbers.
Include: graphics.h
GrMulWWFixed()
WWFixedAsDWord GrMulWWFixed(
WWFixedAsDWord i, /* first number */
WWFixedAsDWord j); /* second number */
Multiply two fixed point numbers.
Include: graphics.h
GrNewPage()
void GrNewPage(
GStateHandle gstate,
PageEndCommand pageEndCommand);
Begin drawing a new page. Normally used when printing documents.
Include: graphics.h
GrNullOp()
void GrNullOp(
GStateHandle gstate); /* subject GState */
Write a null operation element to a GString.
Include: graphics.h
GrQuickArcSine()
WWFixedAsDWord GrQuickArcSine(
WWFixedAsDWord deltaYDivDistance, /* delta y / distance */
word origDeltaX); /* original delta x */
Compute a fixed point arcsine. Angles are given in degrees counterclockwise of the positive x axis.
Include: graphics.h
GrQuickCosine()
WWFixedAsDWord GrQuickCosine(
WWFixedAsDWord angle); /* angle to cosine */
Compute a fixed point cosine. Angles are given in degrees counterclockwise of the positive x axis.
Include: graphics.h
GrQuickSine()
WWFixedAsDWord GrQuickSine(
WWFixedAsDWord angle); /* angle to sine */
Compute a fixed point sine. Angles are given in degrees counterclockwise of the positive x axis.
Include: graphics.h
GrQuickTangent()
WWFixedAsDWord GrQuickTangent(
WWFixedAsDWord angle); /* angle to tangent */
Compute a fixed point tangent. Angles are given in degrees counterclockwise of the positive x axis.
Include: graphics.h
GrReleaseExclusive()
void GrReleaseExclusive( /* TRUE if system had to force a redraw */
GeodeHandle videoDriver, /* handle of video driver */
GStateHandle gstate, /* GState that was drawing */
Rectangle *bounds); /* Bounds of aborted drawings */
Stop drawing exclusively to a video driver.
Include: graphics.h
GrRelMoveTo()
void GrRelMoveTo(
GStateHandle gstate, /* subject GState */
WWFixedAsDWord x, /* offsets to new pen position */
WWFixedAsDWord y);
Change the pen position to coordinate expressed relative to the current position.
Include: graphics.h
GrRestoreState()
void GrRestoreState(
GStateHandle gstate); /* subject GState */
Restore the values of a saved GState.
Include: graphics.h
GrSaveState()
void GrSaveState(
GStateHandle gstate); /* subject GState */
Save the values of a GState, so that they may be restored by GrRestoreState().
Include: graphics.h
GrSDivDWFByWWF()
void GrSDivDWFByWWF(
const DWFixed * dividend,
const WWFixed * divisor,
DWFixed * quotient) /* returned value */
Divide two fixed point numbers.
Include: graphics.h
GrSDivWWFixed()
WWFixedAsDWord GrSDivWWFixed(
WWFixedAsDWord dividend,
WWFixedAsDWord divisor)
Divide two fixed point numbers.
Include: graphics.h
GrSetAreaAttr()
void GrSetAreaAttr(
GStateHandle gstate, /* subject GState */
const AreaAttr * aa); /* AreaAttr structure */
Set all of the attributes used when filling areas.
Structures:
typedef struct {
byte AA_colorFlag;
RGBValue AA_color;
SystemDrawMask AA_mask;
ColorMapMode AA_mapMode;
} AreaAttr;
Include: graphics.h
GrSetAreaColor()
void GrSetAreaColor(
GStateHandle gstate, /* GState to set color for */
ColorFlag flag, /* flag of how to set color */
word redOrIndex, /* color index or red RGB value */
word green, /* green RGB value or zero */
word blue); /* blue RGB value or zero */
Set the color to use when filling areas. The flag parameter may be CF_RGB (to set RGB values), CF_INDEX (to set a palette index), CF_GRAY, or CF_SAME.
Include: graphics.h
GrSetAreaColorMap()
void GrSetAreaColorMap(
GStateHandle gstate, /* subject GState */
ColorMapMode colorMap); /* color mapping mode */
Set mode to use when trying to fill an area with an unavailable color.
Include: graphics.h
GrSetAreaMaskCustom()
void GrSetAreaMaskCustom(
GStateHandle gstate, /* subject GState */
const DrawMask * dm); /* pointer to new custom mask */
Set the drawing mask to use when filling areas.
Include: graphics.h
GrSetAreaMaskSys()
void GrSetAreaMaskSys(
GStateHandle gstate, /* subject GState */
SystemDrawMask sysDM); /* new system area mask */
Set the drawing mask to use when filling areas.
Include: graphics.h
GrSetAreaPattern()
void GrSetAreaPattern(
GStateHandle gstate, /* subject GState */
GraphicPattern pattern); /* new pattern */
Set the graphics pattern to use when filling areas.
Include: graphics.h
GrSetBitmapMode()
void GrSetBitmapMode(
GStateHandle gstate, /* subject GState */
word flags, /* BM_EDIT_MASK or BM_CLUSTERED_DITHER */
MemHandle colorCorr); /* handle of ColorTransfer */
Set the bitmap editing mode. This allows the editing of a bitmap’s mask, or turning on clustered dithering.
Include: graphics.h
GrSetBitmapRes()
Boolean GrSetBitmapRes(
GStateHandle gstate, /* subject GState */
word xRes, /* new resolutions */
word yRes);
Set a complex bitmap’s resolution.
Include: graphics.h
GrSetClipPath()
void GrSetClipPath(
GStateHandle gstate, /* subject GState */
PathCombineType params, /* how paths should be combined */
RegionFillRule rule); /* ODD_EVEN or WINDING */
Restrict the clipping region by intersecting it with the passed path.
Include: graphics.h
GrSetClipRect()
void GrSetClipRect(
GStateHandle gstate, /* subject GState */
PathCombineType flags, /* how paths should be combined */
sword left, /* bounds of clipping rectangle */
sword top,
sword right,
sword bottom);
Restrict the clipping region by intersecting it with the passed rectangle.
Include: graphics.h
GrSetCustomAreaPattern()
void GrSetCustomAreaPattern(
GStateHandle gstate, /* subject GState */
GraphicPattern pattern, /* new area pattern */
const void * patternData, /* pointer to pattern data */
word patternSize); /* size of pattern data buffer */
Set the graphics pattern to use when filling areas.
Include: graphics.h
GrSetCustomTextPattern()
void GrSetCustomTextPattern(
GStateHandle gstate, /* subject GState */
GraphicPattern pattern, /* new pattern */
const void * patternData); /* pointer to pattern data */
Set the graphic pattern used when drawing text.
Include: graphics.h
GrSetDefaultTransform()
void GrSetDefaultTransform(
GStateHandle gstate); /* subject GState */
Replace the current coordinate transformation with the default transformation.
**Include: **graphics.h
GrSetFont()
void GrSetFont(
GStateHandle gstate, /* subject GState */
FontID id, /* new font ID */
WWFixedAsDWord pointSize); /* new point size */
Set the font to use when drawing text.
Include: graphics.h
GrSetFontWeight()
void GrSetFontWeight(
GStateHandle gstate, /* subject GState */
FontWeight weight); /* new font weight */
Set the font weight to use when drawing text.
Include: font.h
GrSetFontWidth()
void GrSetFontWidth(
GStateHandle gstate, /* subject GState */
FontWidth width); /* new font width */
Set the font width to use when drawing text.
Include: font.h
GrSetGStringBounds()
void GrSetGStringBounds(
Handle gstate, /* GState or GString handle */
sword left, /* new bounds of GString */
sword top,
sword right,
sword bottom);
Optimization routine which allows you to set bounds values for a GString. This bounds information will be returned by GrGetGStringBounds() whenever that routine is called upon the affected GString.
Include: graphics.h
GrSetGStringPos()
void GrSetGStringPos(
GStateHandle gstate, /* subject GState */
GStringSetPosType type, /* how to set position */
word skip); /* number of elements to skip */
Set a graphics string’s “playing position.” Using this routine, it is possible to draw only selected elements of a GString.
Structures:
typedef ByteEnum GStringSetPosType;
/* GSSPT_SKIP,
GSSPT_RELATIVE,
GSSPT_BEGINNING,
GSSPT_END */
Include: gstring.h
GrSetLineAttr()
void GrSetLineAttr(
GStateHandle gstate, /* subject GState */
const LineAttr * la); /* new line attributes */
Set all attributes to use when drawing lines and corners.
Include: graphics.h
GrSetLineColor()
void GrSetLineColor(
GStateHandle gstate, /* subject GState */
ColorFlag flag, /* color flag */
word redOrIndex, /* new index or red RGB value */
word green, /* new green RGB value or zero */
word blue); /* new blue RGB value or zero */
Set the color to use when drawing lines.
Include: graphics.h
GrSetLineColorMap()
void GrSetLineColorMap(
GStateHandle gstate, /* subject GState */
ColorMapMode colorMap); /* new color map mode for lines */
Set the mode to use when trying to draw lines in an unavailable color.
Include: graphics.h
GrSetLineEnd()
void GrSetLineEnd(
GStateHandle gstate, /* subject GState */
LineEnd end); /* new line end specification */
Set the end to use when drawing lines.
Include: graphics.h
GrSetLineJoin()
void GrSetLineJoin(
GStateHandle gstate, /* subject GState */
LineJoin join); /* new line join specification */
Set the line join to use when drawing corners.
Include: graphics.h
GrSetLineMaskCustom()
void GrSetLineMaskCustom(
GStateHandle gstate, /* subject GState */
const DrawMask * dm); /* new line draw mask */
Set the drawing mask used when drawing lines.
Include: graphics.h
GrSetLineMaskSys()
void GrSetLineMaskSys(
GStateHandle gstate, /* subject GState */
SystemDrawMask sysDM); /* the new system line mask */
Set the drawing mask used when drawing lines.
Include: graphics.h
GrSetLineStyle()
void GrSetLineStyle(
GStateHandle gstate, /* subject GState */
LineStyle style, /* new line style */
word skipDistance, /* skip distance to first pair */
const DashPairArray * dpa, /* dash definition */
word numPairs); /* number of pairs */
Set the style, or “dottedness,” to use when drawing lines.
Include: graphics.h
GrSetLineWidth()
void GrSetLineWidth(
GStateHandle gstate, /* subject GState */
WWFixedAsDWord width); /* new line width */
Set the line width to use when drawing lines.
Include: graphics.h
GrSetMiterLimit()
void GrSetMiterLimit(
GStateHandle gstate, /* subject GState */
WWFixedAsDWord limit); /* new miter limit */
Set the miter limit to use when drawing mitered corners.
Include: graphics.h
GrSetMixMode()
void GrSetMixMode(
GStateHandle gstate, /* subject GState */
MixMode mode); /* new mix mode */
Set the GState’s mix mode, used to determine what happens when something is drawn on top of an existing drawing.
Include: graphics.h
GrSetNullTransform()
void GrSetNullTransform(
GStateHandle gstate); /* subject GState */
Clear the coordinate transformation. Most applications will actually want to replace the coordinate transformation with the default transformation using GrSetDefaultTransform().
Include: graphics.h
GrSetPalette()
void GrSetPalette(
GStateHandle gstate, /* subject GState */
SetPalType type, /* SPT_DEFAULT or SPT_CUSTOM */
const RGBValue *buffer, /* array of palette entries */
word index, /* First element to change */
word numEntries); /* number of entries in array */
Set one or more entries in a palette, a window’s color lookup table.
Include: graphics.h
GrSetPaletteEntry()
void GrSetPaletteEntry(
GStateHandle gstate, /* subject GState */
word index, /* index in palette to set */
word red, /* new RGB color values for entry */
word green,
word blue);
Set one entry in a palette, a GState’s color lookup table.
Include: graphics.h
GrSetPath()
void GrSetPath(
GStateHandle gstate, /* subject GState */
MemHandle pathGString); /* handle of path's block */
Takes the passed GState’s path with the path encoded in the block with the passed handle. To get such a handle, call GrGetPath()
Include: graphics.h
GrSetPrivateData()
void GrSetPrivateData(
GStateHandle gstate, /* subject GState */
word dataAX, /* data to set */
word dataBX,
word dataCX,
word dataDX);
Set the private data for a GState.
Include: graphics.h
GrSetStrokePath()
void GrSetStrokePath(
GStateHandle gstate); /* subject GState */
Replace a GState’s path with the path resulting from stroking the original path. Note that this stroked path may be drawn, but may not be used for clipping.
Include: graphics.h
GrSetSubscriptAttr()
void GrSetSubscriptAttr(
GStateHandle gstate, /* subject GState */
ScriptAttrAsWord attrs); /* new subscript percentages */
Get the attributes used when drawing subscript characters.
Include: font.h
GrSetSuperscriptAttr()
void GrSetSuperscriptAttr(
GStateHandle gstate, /* subject GState */
ScriptAttrAsWord attrs); /* new superscript percentages */
Get the attributes used when drawing superscript characters.
Include: font.h
GrSetTextAttr()
void GrSetTextAttr(
GStateHandle gstate, /* subject GState */
const TextAttr * ta); /* pointer to text attributes */
Set all attributes used when drawing characters and text strings.
Include: graphics.h
GrSetTextColor()
void GrSetTextColor(
GStateHandle gstate, /* subject GState */
ColorFlag flag, /* color flag */
word redOrIndex, /* palette index or red RGB value */
word green, /* green RGB value or zero */
word blue); /* blue RGB value or zero */
Set the color used when drawing text.
Include: graphics.h
GrSetTextColorMap()
void GrSetTextColorMap(
GStateHandle gstate, /* subject GState */
ColorMapMode colorMap); /* new color mapping mode */
Set the mode used when trying to draw text in an unavailable color.
Include: graphics.h
GrSetTextMaskCustom()
void GrSetTextMaskCustom(
GStateHandle gstate, /* subject GState */
const DrawMask * dm); /* pointer to custom mask */
Set the drawing mask used when drawing text.
Include: graphics.h
GrSetTextMaskSys()
void GrSetTextMaskSys(
GStateHandle gstate, /* subject GState */
SystemDrawMask sysDM); /* new system draw mask */
Set the drawing mask used when drawing text.
Include: graphics.h
GrSetTextMode()
void GrSetTextMode(
GStateHandle gstate, /* subject GState */
TextMode bitsToSet, /* TextMode flags to set */
TextMode bitsToClear); /* TextMode flags to clear */
Set the text mode associated with a GState. Using this routine, it is possible to change the vertical offset used when drawing text.
Include: graphics.h
GrSetTextPattern()
void GrSetTextPattern(
GStateHandle gstate, /* subject GState */
GraphicPattern pattern); /* new graphic pattern for text */
Set the graphic pattern used when drawing text.
Include: graphics.h
GrSetTextSpacePad()
void GrSetTextSpacePad(
GStateHandle gstate, /* subject GState */
WWFixedAsDWord padding); /* new space padding */
Set the space pad used when drawing text strings.
Include: graphics.h
GrSetTextStyle()
void GrSetTextStyle(
GStateHandle gstate, /* subject GState */
TextStyle bitsToSet, /* TextStyle flags to set */
TextStyle bitsToClear); /* TextStyle flags to clear */
Set the style to use when drawing text.
Include: graphics.h
GrSetTrackKern()
void GrSetTrackKern(
GStateHandle gstate, /* subject GState */
word tk); /* degree of track kerning */
Set the track kerning to use when drawing text strings.
Include: graphics.h
GrSetTransform()
void GrSetTransform(
GStateHandle gstate, /* subject GState */
const TransMatrix * tm); /* new transformation matrix */
Set the GState’s coordinate transformation.
Include: graphics.h
GrSetVMFile()
void GrSetVMFile(
GStateHandle gstate, /* subject GState */
VMFileHandle vmFile); /* new transformation matrix */
Update the VM file associated with a GState (this may apply when working with certain kinds of bitmaps and GStrings).
Include: graphics.h
GrSetWinClipPath()
void GrSetWinClipPath(
GStateHandle gstate, /* subject GState */
PathCombineType params, /* how paths are combined */
RegionFillRule rule); /* ODD_EVEN or WINDING */
Restrict the window’s clipping region by intersecting it with the passed path.
Include: graphics.h
GrSetWinClipRect()
void GrSetWinClipRect(
GStateHandle gstate, /* subject GState */
PathCombineType flags, /* how paths are combined */
sword left, /* new clipping rectangle bounds */
sword top,
sword right,
sword bottom);
Restrict the window’s clipping region by intersecting it with the passed rectangle.
Include: graphics.h
GrSqrRootWWFixed()
WWFixedAsDWord GrSqrRootWWFixed(
WWFixedAsDWord i); /* number to get the square root of */
Compute the square root of a fixed point number.
Include: graphics.h
GrTestPath()
Boolean GrTestPath(
GStateHandle gstate, /* subject GState */
GetPathType ptype); /* Type of path to check for */
Determine whether the GState has a path of the specified type.
Include: graphics.h
GrTestPointInPath()
Boolean GrTestPointInPath(
GStateHandle gstate, /* subject GState */
word xPos, /* point to test */
word yPos,
RegionFillRule rule); /* ODD_EVEN or WINDING */
Determine whether the passed point falls in the interior of the GState’s path.
Include: graphics.h
GrTestPointInPolygon()
Boolean GrTestPointInPolygon(
GStateHandle gstate, /* subject GState */
RegionFillRule rule, /* ODD_EVEN or WINDING */
Point * list, /* array of points in polygon */
word numPoints, /* number of points in array */
sword xCoord, /* coordinates of point to test */
sword yCoord);
Determine whether the passed point lies in the interior of the passed polygon.
Include: graphics.h
GrTestPointInReg()
Boolean GrTestPointInReg(
const Region * reg, /* pointer to region */
sword x, /* coordinates of point to test */
sword y,
Rectangle *boundingRect); /* returned bounding rectangle,
* if point in region */
Determine whether a point lies within the passed region. If the point is not in the region, the return value is true.
Include: graphics.h
GrTestRectInReg()
TestRectReturnType GrTestRectInReg(
const Region * reg /* pointer to region */
sword left, /* bounds of rectangle to be tested */
sword top,
sword right,
sword bottom);
Determine whether a rectangle lies within the clip region.
Structures:
typedef ByteEnum TestRectReturnType;
TRRT_OUT, /* rectangle completely out of region */
TRRT_PARTIAL, /* rectangle partially in region */
TRRT_IN /* rectangle completely in region */
Include: graphics.h
GrTextWidth()
word GrTextWidth(
GStateHandle gstate, /* subject GState */
const Chars * str, /* text string to check */
word size); /* maximum number of
* characters to check */
Compute the space the passed text string would require in a line of text. Use GrGetTextBounds() to determine the area necessary to render the text.
Include: graphics.h
GrTextWidthWWFixed()
WWFixedAsDWord GrTextWidthWWFixed( /* returns width << 16 */
GStateHandle gstate, /* subject GState */
const Chars * str, /* text string to check */
word size) /* maximum number of
* characters to check */
Compute the spacing the passed text string would require in a line of text, accurate to a fraction of a point. Use GrGetTextBounds() to determine the area necessary to render the text.
Include: graphics.h
GrTransform()
XYValueAsDWord GrTransform(
GStateHandle gstate, /* subject GState */
sword xCoord, /* coordinates to transform */
sword yCoord);
Apply the device’s transformation to the passed point.
Include: graphics.h
GrTransformDWFixed()
void GrTransformDWFixed(
GStateHandle gstate, /* subject GState */
PointDWFixed * coord); /* coordinates to transform */
Apply the device’s transformation to the passed point.
Include: graphics.h
GrTransformDWord()
void GrTransformDWord(
GStateHandle gstate, /* subject GState */
sdword xCoord, /* coordinates to transform */
sdword yCoord,
PointDWord * deviceCoordinates); /* pointer to returned
*device coordinates */
Apply the device’s transformation to the passed point.
Include: graphics.h
GrTransformWWFixed()
void GrTransformWWFixed(
GStateHandle gstate, /* subject GState */
WWFixedAsDWord xPos, /* coordinates to transform */
WWFixedAsDWord yPos,
PointWWFixed * deviceCoordinates); /* pointer to returned
*device coordinates */
Apply the device’s transformation to the passed point.
Include: graphics.h
GrUDivWWFixed()
WWFixedAsDWord GrUDivWWFixed(
WWFixedAsDWord dividend,
WWFixedAsDWord divisor);
Compute an unsigned division of two fixed point numbers.
Include: graphics.h
GrUntransform()
XYValueAsDWord GrUnTransformCoord(
GStateHandle gstate, /* subject GState */
sword xCoord, /* coordinates to untransform */
sword yCoord);
Apply the reverse of the device’s transformation to the passed point.
Include: graphics.h
GrUntransformDWFixed()
void GrUnTransCoordDWFixed(
GStateHandle gstate, /* subject GState */
PointDWFixed * coord); /* coordinates to untransform */
Apply the reverse of the device’s transformation to the passed point.
Include: graphics.h
GrUntransformDWord()
void GrUnTransformExtCoord(
GStateHandle gstate, /* subject GState */
sdword xCoord, /* coordinates to untransform */
sdword yCoord,
PointDWord * documentCoordinates); /* pointer to returned
*device coordinates */
Apply the reverse of the device’s transformation to the passed point.
Include: graphics.h
GrUntransformWWFixed()
void GrUnTransCoordWWFixed(
GStateHandle gstate, /* subject GState */
WWFixedAsDWord xPos, /* coordinates to untransform */
WWFixedAsDWord yPos,
PointWWFixed * documentCoordinates); /* pointer to returned
*device coordinates */
Apply the reverse of the device’s transformation to the passed point.
Include: graphics.h