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

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