trktool.h

hl2 source code. Do not use it illegal.

	TRK_CSTR					fieldName,				// Input
	TRK_UINT FAR*				pFieldValue);			// Output

TRKAPI TrkGetStringFieldValue(
	TRK_RECORD_HANDLE			trkRecordHandle,		// Input
	TRK_CSTR					fieldName,				// Input
	TRK_UINT					fieldValueBufferSize,	// Input
	TRK_STR						fieldValue);			// Output

TRKAPI TrkSetNumericFieldValue(
	TRK_RECORD_HANDLE			trkRecordHandle,		// Input
	TRK_CSTR					fieldName,				// Input
	TRK_UINT					fieldValue);			// Input

TRKAPI TrkSetStringFieldValue(
	TRK_RECORD_HANDLE			trkRecordHandle,		// Input
	TRK_CSTR					fieldName,				// Input
	TRK_CSTR					fieldValue);			// Input

// *********************************************************

// Provide a Transaction ID representing the most recent
// change to a particular Field in the current record.

TRKAPI TrkGetFieldTransactionID(
	TRK_RECORD_HANDLE			trkRecordHandle,		// Input
	TRK_CSTR					fieldName,				// Input
	TRK_TRANSACTION_ID FAR*		pTransactionID);		// Output

// *********************************************************

// Provide permission information on a Record which is about
// to be Submitted to or Updated in the DB.
//
// Note that permissions depend on the state of the record
// in the DB.  For example, a field may be modifiable upon Submit
// but not Update, and vice-versa.

enum _TrkFieldAccessMode {
	TRK_READ_ONLY = 0,
	TRK_READ_WRITE = 2 };

TRKAPI TrkGetFieldAccessRights(
	TRK_RECORD_HANDLE			trkRecordHandle,		// Input
	TRK_CSTR					fieldName,				// Input
	TRK_ACCESS_MODE FAR*		pAccessMode);			// Output

// *********************************************************

// Get or set data in a record's Description.

// TrkGetDescriptionData and TrkSetDescriptionData may be
// called multiple times to read data which exceeds the size
// of the caller's buffer.

TRKAPI TrkGetDescriptionDataLength(
	TRK_RECORD_HANDLE			trkRecordHandle,		// Input
	TRK_UINT FAR*				pDataBufferSize);		// Output

TRKAPI TrkGetDescriptionData(
	TRK_RECORD_HANDLE			trkRecordHandle,		// Input
	TRK_UINT					maxBufferSize,			// Input
	TRK_STR						data,					// Output
	TRK_UINT FAR*				pDataRemaining);		// Output

TRKAPI TrkSetDescriptionData(
	TRK_RECORD_HANDLE			trkRecordHandle,		// Input
	TRK_UINT					currentBufferSize,		// Input
	TRK_CSTR					data,					// Input
	TRK_UINT					dataRemaining);			// Input

// Provide permission information.

TRKAPI TrkGetDescriptionAccessRights(
	TRK_RECORD_HANDLE			trkRecordHandle,		// Input
	TRK_ACCESS_MODE FAR*		pAccessMode);			// Output

// Provide a Transaction ID representing the most recent
// change to the description.

TRKAPI TrkGetDescriptionTransactionID(
	TRK_RECORD_HANDLE			trkRecordHandle,		// Input
	TRK_TRANSACTION_ID FAR*		pTransactionID);		// Output

// *********************************************************

// Tracker Note Handles are used in place of Tracker Record
// Handles in those functions below which operate on Note
// data.  TrkNoteHandleAlloc must be called first to create
// a Note Handle.  TrkNoteHandleFree releases all memory
// associated with that handle.
//
// If desired, multiple Note Handles may be used concurrently.

TRKAPI TrkNoteHandleAlloc(
	TRK_RECORD_HANDLE			trkRecordHandle,		// Input
	TRK_NOTE_HANDLE FAR*		pTrkNoteHandle);		// Output

TRKAPI TrkNoteHandleFree(
	TRK_NOTE_HANDLE FAR*		pTrkNoteHandle);		// Input/Output

// *********************************************************

// TrkInitNoteList initializes an in-memory list of entries which
// are accessed sequentially.  TrkGetNextNote is used to read
// the current Note (including the first, if present).
// TrkGetNextNote can be thought of as making a note 'current'
// in that subsequent calls to the various note access functions
// will operate on data for that particular Note.  TrkAddNewNote
// is used to insert a new Note in the list at the current
// position, (making the new note current).  A new Note may be
// appended to the list by adding it after the last Note.

TRKAPI TrkInitNoteList(
	TRK_NOTE_HANDLE				trkNoteHandle);			// Input

TRKAPI TrkGetNextNote(
	TRK_NOTE_HANDLE				trkNoteHandle);			// Input

TRKAPI TrkAddNewNote(
	TRK_NOTE_HANDLE				trkNoteHandle);			// Input

TRKAPI TrkDeleteNote(
	TRK_NOTE_HANDLE				trkNoteHandle);			// Input

// *********************************************************

// Get or set data in a Note.

// TrkGetNoteData and TrkSetNoteData may be called multiple
// times to read data which exceeds the size of the caller's
// buffer.

// "Set" functions only modify the in-memory copy of the data.

TRKAPI TrkGetNoteTitle(
	TRK_NOTE_HANDLE				trkNoteHandle,			// Input
	TRK_UINT					bufferSize,				// Input
	TRK_STR						noteTitle);				// Output

TRKAPI TrkSetNoteTitle(
	TRK_NOTE_HANDLE				trkNoteHandle,			// Input
	TRK_CSTR					noteTitle);				// Input


TRKAPI TrkGetNoteAuthor(
	TRK_NOTE_HANDLE				trkNoteHandle,			// Input
	TRK_UINT					bufferSize,				// Input
	TRK_STR						authorName);			// Output

TRKAPI TrkSetNoteAuthor(
	TRK_NOTE_HANDLE				trkNoteHandle,			// Input
	TRK_CSTR					authorName);			// Input


TRKAPI TrkGetNoteCreateTime(
	TRK_NOTE_HANDLE				trkNoteHandle,			// Input
	TRK_TIME FAR*				pCreateTime);			// Output

TRKAPI TrkSetNoteCreateTime(
	TRK_NOTE_HANDLE				trkNoteHandle,			// Input
	TRK_TIME					createTime);			// Input


TRKAPI TrkGetNoteModifyTime(
	TRK_NOTE_HANDLE				trkNoteHandle,			// Input
	TRK_TIME FAR*				pModifyTime);			// Output

TRKAPI TrkSetNoteModifyTime(
	TRK_NOTE_HANDLE				trkNoteHandle,			// Input
	TRK_TIME					modifyTime);			// Input


TRKAPI TrkGetNoteDataLength(
	TRK_NOTE_HANDLE				trkNoteHandle,			// Input
	TRK_UINT FAR*				pDataBufferSize);		// Output


TRKAPI TrkGetNoteData(
	TRK_NOTE_HANDLE				trkNoteHandle,			// Input
	TRK_UINT					maxBufferSize,			// Input
	TRK_STR						noteData,				// Output
	TRK_UINT FAR*				pDataRemaining);		// Output

TRKAPI TrkSetNoteData(
	TRK_NOTE_HANDLE				trkNoteHandle,			// Input
	TRK_UINT					currentBufferSize,		// Input
	TRK_CSTR					noteData,				// Input
	TRK_UINT					dataRemaining);			// Input

// *********************************************************

// Provide a Transaction ID representing the most recent
// change to a particular Note in the current record.

TRKAPI TrkGetNoteTransactionID(
	TRK_NOTE_HANDLE				trkNoteHandle,			// Input
	TRK_TRANSACTION_ID FAR*		pTransactionID);		// Output

// *********************************************************

// Tracker Attached File Handles are used in place of Tracker Record
// Handles in those functions below which operate on Attached File
// data.  TrkAttachedFileHandleAlloc must be called first to create
// an Attached File Handle.  TrkAttachedFileHandleFree releases all
// memory associated with that handle.
//
// If desired, multiple Attached File Handles may be used concurrently.

TRKAPI TrkAttachedFileHandleAlloc(
	TRK_RECORD_HANDLE			trkRecordHandle,		// Input
	TRK_ATTFILE_HANDLE FAR*		pTrkAttFileHandle);		// Output

TRKAPI TrkAttachedFileHandleFree(
	TRK_ATTFILE_HANDLE FAR*		pTrkAttFileHandle);		// Input/Output

// *********************************************************

// TrkInitAttachedFileList initializes an in-memory list of the Files
// which are attached to the current record, and are accessed
// sequentially.  TrkGetNextAttachedFile is used to make each
// successive Attached File current.  Subsequent calls to the various
// AttFile access functions will operate on data for the current
// Attached File.  TrkAddNewAttachedFile is used to insert
// a new AttachedFile in the list at the current position, (making
// the new Attached File current).  A new Attached File may be
// appended to the list by adding it after the last Attached File.

TRKAPI TrkInitAttachedFileList(
	TRK_ATTFILE_HANDLE			trkAttFileHandle);		// Input

TRKAPI TrkGetNextAttachedFile(
	TRK_ATTFILE_HANDLE			trkAttFileHandle);		// Input

enum _TrkFileStorageMode {
	TRK_FILE_BINARY	= 0,
	TRK_FILE_ASCII	= 1 };

TRKAPI TrkAddNewAttachedFile(
	TRK_ATTFILE_HANDLE			trkAttFileHandle,		// Input
	TRK_CSTR					filename,				// Input
	TRK_FILE_STORAGE_MODE		storageMode);			// Input

TRKAPI TrkDeleteAttachedFile(
	TRK_ATTFILE_HANDLE			trkAttFileHandle);		// Input

// *********************************************************

// Extract or get information about an Attached File.  The function
// TrkExtractAttachedFile copies the file contents out of the
// database and into the caller-specified file name.  If the file
// already exists, it is overwritten.

TRKAPI TrkGetAttachedFileName(
	TRK_ATTFILE_HANDLE			trkAttFileHandle,		// Input
	TRK_UINT					bufferSize,				// Input
	TRK_STR						filename);				// Output

TRKAPI TrkGetAttachedFileTime(
	TRK_ATTFILE_HANDLE			trkAttFileHandle,		// Input
	TRK_TIME FAR*				pTimestamp);			// Output

TRKAPI TrkGetAttachedFileStorageMode(
	TRK_ATTFILE_HANDLE			trkAttFileHandle,		// Input
	TRK_FILE_STORAGE_MODE FAR*	pStorageMode);			// Output

TRKAPI TrkExtractAttachedFile(
	TRK_ATTFILE_HANDLE			trkAttFileHandle,		// Input
	TRK_CSTR					filename);				// Input

// *********************************************************

// Provide a Transaction ID representing when a particular
// Attached File was added to the current record.

TRKAPI TrkGetAttachedFileTransactionID(
	TRK_ATTFILE_HANDLE			trkAttFileHandle,		// Input
	TRK_TRANSACTION_ID FAR*		pTransactionID);		// Output

// *********************************************************

// Tracker Association Handles are used in place of Tracker
// Record Handles in those functions below which operate on
// Module Association data.  TrkAssociationHandleAlloc must
// be called first to create an Association Handle.
// TrkAssociationHandleFree releases all memory associated with
// that handle.
//
// If desired, multiple Association Handles may be used
// concurrently.

TRKAPI TrkAssociationHandleAlloc(
	TRK_RECORD_HANDLE			trkRecordHandle,		// Input
	TRK_ASSOC_HANDLE FAR*		pTrkAssociationHandle);	// Output

TRKAPI TrkAssociationHandleFree(
	TRK_ASSOC_HANDLE FAR*		pTrkAssociationHandle);	// Input/Output

// *********************************************************

// TrkInitAssociationList initializes an in-memory list of the
// Modules which are associated with the current record, and are
// accessed sequentially.  TrkGetNextAssociation is used to make
// each successive Association current.  Subsequent calls to the
// various Association access functions will operate on data for
// the current Association.  TrkAddNewAssociation is used to
// insert a new Association in the list at the current position,
// (making the new Association current).  A new Association may
// be appended to the list by adding it after the last
// Association.

TRKAPI TrkInitAssociationList(
	TRK_ASSOC_HANDLE			trkAssociationHandle);	// Input

TRKAPI TrkGetNextAssociation(
	TRK_ASSOC_HANDLE			trkAssociationHandle);	// Input

TRKAPI TrkAddNewAssociation(
	TRK_ASSOC_HANDLE			trkAssociationHandle);	// Input

TRKAPI TrkDeleteAssociation(
	TRK_ASSOC_HANDLE			trkAssociationHandle);	// Input

// *********************************************************

// Get or set data in an Association.

// TrkGetAssociationText and TrkSetAssociationText may be
// called multiple times to read data which exceeds the size
// of the caller's buffer.

// "Set" functions only modify the in-memory copy of the data.

TRKAPI TrkGetAssociationModuleName(
	TRK_ASSOC_HANDLE			trkAssociationHandle,	// Input
	TRK_UINT					bufferSize,				// Input
	TRK_STR						moduleName);			// Output

TRKAPI TrkSetAssociationModuleName(
	TRK_ASSOC_HANDLE			trkAssociationHandle,	// Input
	TRK_CSTR					moduleName);			// Input


TRKAPI TrkGetAssociationUser(
	TRK_ASSOC_HANDLE			trkAssociationHandle,	// Input
	TRK_UINT					bufferSize,				// Input
	TRK_STR						userName);				// Output

TRKAPI TrkSetAssociationUser(
	TRK_ASSOC_HANDLE			trkAssociationHandle,	// Input