CSampleData Class Reference

Base class to hold an array of CSampleItems. More...

#include <samplist.h>

Inheritance diagram for CSampleData:

List of all members.

Public Member Functions
	CSampleData ()
	default constructor
	~CSampleData ()
	destructor, cleans out the list
CSampleData *	MakeCopy ()
	Makes a copy of this sample data.
virtual BOOL	InitialiseData (size_t Size=1000, UINT32 GrowBy=50)
	creates the list member variable
virtual BOOL	CollectData (DocCoord Coord, UINT32 Pressure)
	This is the function you should override in you derived classes to do the sampling with. For an example see CDistanceSampler::CollectData.
void	FinishSampling ()
	Tells the object that sampling has finished. As a security precaution we will add an extra 10 * m_RetrievalSampleRates worth of entries. The real reason for this hack is that once the path is entered it is then smoothed, which causes the path length to increase. Since we never sampled over this increased length we need to kind of pretend that we did.
BOOL	SetCollectionSampleRate (double Rate)
	Sets the sample rate to use for collecting data. Note that for current purposes this is only allowed to be 1. So you probably won't be using this function very often.
double	GetCollectionSampleRate ()
	as above
BOOL	SetRetrievalSampleRate (double Rate)
	Sets the sample rate to use for retrieving data,.
double	GetRetrievalSampleRate ()
	as above
void	SetSampleArray (SampleArray *pArray)
	sets the given array to use as our sample data
SampleArray *	GetSampleArray ()
size_t	GetNumItems ()
UINT32	GetMaxPressure ()
	as above
void	SetMaxPressure (UINT32 Max)
	To set our max pressure member. Do this by querying the WinTab device BEFORE you start collecting data.
BOOL	ReverseData ()
	Reverses the items in the data array, or rather just copies them into a new one.
BOOL	WriteNative (CXaraFileRecord *pRecord)
	Writes out the data contained in this SampleData to a record.
void	SetNumItemsFromArraySize ()
	Sets the num items member from the size of the array. Note that you should never really use this unless you are certain that a) your current m_NumItems is incorrect and b)You are certain that your array contains nothing but valid data. An example of when you should use this is if you decide to set the array from out side, rather than collect it through sampling. And you really shouldn't be doing that either.
BOOL	ClipArray (size_t Size)
	Clips the array to be the desired size, be careful with this as you will lose all data beyond the Size'th index.
void	Add (CSampleItem &Item)
	adds a new item to the end of the array
BOOL	SetAt (UINT32 Index, CSampleItem &Item)
	inserts Item at Index
BOOL	InsertAt (UINT32 Index, CSampleItem &Item)
BOOL	SetNext (CSampleItem &Item, BOOL Grow=FALSE)
	Increments our internal index and then inserts a new item at that position. If we hit the end of the array then we will add an element, so long as our flag is set Notes:.
BOOL	SetPrev (CSampleItem &Item)
	Decrements our internal index and then inserts Item into the array.
BOOL	RemoveAt (UINT32 Index)
	Removes item at Index.
BOOL	GetAt (UINT32 Index, CSampleItem *pItem)
	Retrieves the item at Index.
BOOL	GetAtPos (double Index, CSampleItem *pItem)
BOOL	GetNext (CSampleItem *pItem)
	Increments the internal index, then retrieves the item at that index.
BOOL	GetPrev (CSampleItem *pItem)
	Decrements our internal index and retrieves the item at that position.
INT32	GetCount ()
	To find the number of items in the array.
void	FreeExtra ()
	Asks the array to free any unused memory above its current upper bound. Recommneded that you call this if you do a big SetSize and don't use it all.
BOOL	InsertNewData (UINT32 Index, CSampleData *pData)
	To insert pData into our data array at Index. This function does the shuffling of existing array elements in order to insert the new data.
BOOL	RemoveData (UINT32 StartIndex, UINT32 EndIndex, SampleArray *pArray=NULL)
	To remove all the items between StartIndex and EndIndex, and optionally record them in pArray.
Protected Member Functions
BOOL	SetInternalCollectionIndex (UINT32 IndexRequested)
	Sets our collection internal array index to the position corresponding to the requested index.
BOOL	SetInternalRetrievalIndex (UINT32 IndexRequested)
	Sets our Retrieval internal array index to the position corresponding to the requested index.
BOOL	IncrementInternalIndex (double *CurrentIndex)
BOOL	DecrementInternalIndex (double *CurrentIndex)
	Decrements our internal array pointer and index counter, unless we have reached the start of the array in which case we set it to -1.
BOOL	GetItemAtInternalIndex (double Index, CSampleItem *pItem)
	Retrieves the item in the array indicated by the current internal index. Note that it is possible that this index may not be an integer in which case this function will generate a new CSampleItem by interpolation.
BOOL	ReSampleArray (SampleArray **ppArray, UINT32 NewNumItems)
	Resamples the data in the sample array so that we end up with NewNumItems in the section required. We will do this by selecting some resampling points in the original array, maintain these points at the same proportional position and interpolate to get the new points.
BOOL	InsertControlPoints (UINT32 Frequency, SampleArray *pOriginal, SampleArray *pNew)
	As part of the ReSampleArray process this function takes the case where we need to increase the number of control points. It therefore proceeds through the original array copying control points over at the same proportional position as they were in the original array.
BOOL	RemoveControlPoints (UINT32 Frequency, SampleArray *pOriginal, SampleArray *pNew)
BOOL	InterpolateItems (UINT32 StartIndex, UINT32 EndIndex, SampleArray *pArray)
	Interpolates between the two indexes in the array, creating intermediate items and inserting them.
BOOL	GetArraySection (UINT32 StartIndex, UINT32 EndIndex, SampleArray *pArraySection)
	To copy the data from the section specified into a new array that we will create.
Protected Attributes
SampleArray *	m_pSampleData
double	m_CollectionInternalIndex
double	m_RetrievalInternalIndex
double	m_CollectionSampleRate
double	m_RetrievalSampleRate
UINT32	m_ElementSize
size_t	m_NumItems
UINT32	m_MaxPressure
double	m_ScalePressure

---

Detailed Description

Base class to hold an array of CSampleItems.

Author:

Diccon_Yamanaka (Xara Group Ltd) <camelotdev@xara.com>

Date:

31/5/2000

Notes:

Definition at line 163 of file samplist.h.

---

Constructor & Destructor Documentation

CSampleData::CSampleData (   )

default constructor Author: Diccon_Yamanaka (Xara Group Ltd) <camelotdev@xara.com> Date: 31/5/2000 Parameters: -  [INPUTS] -  [OUTPUTS] Returns: this object Notes: Definition at line 318 of file samplist.cpp. { m_pSampleData = NULL; m_CollectionSampleRate = 1.0; m_RetrievalSampleRate = 1.0; m_CollectionInternalIndex = 0; m_RetrievalInternalIndex = 0; m_NumItems = 0; m_MaxPressure = 0; m_ElementSize = (UINT32)sizeof(CSampleItem); }

CSampleData::~CSampleData (   )

destructor, cleans out the list Author: Diccon_Yamanaka (Xara Group Ltd) <camelotdev@xara.com> Date: 31/5/2000 Parameters: -  [INPUTS] -  [OUTPUTS] Returns: - Notes: Definition at line 345 of file samplist.cpp. { if (m_pSampleData != NULL) { m_pSampleData->clear(); delete m_pSampleData; m_pSampleData = NULL; } }

---

Member Function Documentation

void CSampleData::Add (  CSampleItem &  Item  )

adds a new item to the end of the array Author: Diccon_Yamanaka (Xara Group Ltd) <camelotdev@xara.com> Date: 31/5/2000 Parameters: Item  - the item to insert [INPUTS] -  [OUTPUTS] Returns: - Notes: Definition at line 488 of file samplist.cpp. { if (m_pSampleData != NULL) m_pSampleData->push_back(Item); m_NumItems++; }

BOOL CSampleData::ClipArray (  size_t  Size  )

Clips the array to be the desired size, be careful with this as you will lose all data beyond the Size'th index. Author: Diccon_Yamanaka (Xara Group Ltd) <camelotdev@xara.com> Date: 13/12/99 Parameters: Size  - the desired array size [INPUTS] Returns: TRUE unless Size is bigger than the array we have Definition at line 1553 of file samplist.cpp. { ERROR2IF(m_pSampleData == NULL, FALSE, "Sample data is NULL in CSampleData::ClipArray"); ERROR2IF(Size > (UINT32)m_pSampleData->size(), FALSE, "Attempting to clip over the end of the array in CSampleData::ClipArray"); m_pSampleData->resize( Size ); if (m_NumItems > Size) m_NumItems = Size; return TRUE; }

BOOL CSampleData::CollectData (  DocCoord  Coord, UINT32  Pressure )  [virtual]

This is the function you should override in you derived classes to do the sampling with. For an example see CDistanceSampler::CollectData. Author: Diccon_Yamanaka (Xara Group Ltd) <camelotdev@xara.com> Date: 31/5/2000 Parameters: Coord  - the coordinate data [INPUTS] Pressure - the pressure data -  [OUTPUTS] Returns: always TRUE in the base class Notes: Reimplemented in CDistanceSampler. Definition at line 464 of file samplist.cpp. { return TRUE; }

BOOL CSampleData::DecrementInternalIndex (  double *  pCurrentIndex  )  [protected]

Decrements our internal array pointer and index counter, unless we have reached the start of the array in which case we set it to -1. Author: Diccon_Yamanaka (Xara Group Ltd) <camelotdev@xara.com> Date: 31/5/2000 Parameters: pCurrentIndex  - the index to be decremented, this should really only be either [INPUTS] the collection index or the retrieval index -  [OUTPUTS] Returns: TRUE, unless something went wrong Definition at line 1161 of file samplist.cpp. { // not allowed to use indexes that aren't one of our members, also // find out which sample rate to use here double SampleRate = 1.0; if (pCurrentIndex == &m_CollectionInternalIndex) { SampleRate = m_CollectionSampleRate; } else if (pCurrentIndex == &m_RetrievalInternalIndex) { SampleRate = m_RetrievalSampleRate; } else { ERROR3("Attempting to use non-member index in CSampleData::DecrementInternalIndex"); return FALSE; } // we need to have valid sample data ERROR2IF(m_pSampleData == NULL, FALSE, "Sample data is null in CSampleData::DecrementInternalIndex"); double TestIndex = *pCurrentIndex - SampleRate; if (TestIndex > 0) { *pCurrentIndex -= SampleRate; } else { *pCurrentIndex = -1; } return TRUE; }

void CSampleData::FinishSampling (   )

Tells the object that sampling has finished. As a security precaution we will add an extra 10 * m_RetrievalSampleRates worth of entries. The real reason for this hack is that once the path is entered it is then smoothed, which causes the path length to increase. Since we never sampled over this increased length we need to kind of pretend that we did. Author: Diccon_Yamanaka (Xara Group Ltd) <camelotdev@xara.com> Date: 13/12/99 Parameters: -  [INPUTS] Returns: - Definition at line 1487 of file samplist.cpp. { if (m_pSampleData != NULL) { // find out how many items to insert UINT32 NumExtraItems = (UINT32)(m_RetrievalSampleRate * 10); // get the last item we inserted UINT32 InsertIndex = (UINT32)m_CollectionInternalIndex; CSampleItem TheItem = (*m_pSampleData)[InsertIndex]; // make sure the array is big enough UINT32 CurrentSize = (INT32)m_pSampleData->size(); if (CurrentSize < InsertIndex+NumExtraItems) { m_pSampleData->resize( CurrentSize + NumExtraItems ); } for (UINT32 i = 1; i <= NumExtraItems; i++) { (*m_pSampleData)[InsertIndex + i] = TheItem; m_NumItems++; } } }

void CSampleData::FreeExtra (   )

Asks the array to free any unused memory above its current upper bound. Recommneded that you call this if you do a big SetSize and don't use it all. Author: Diccon_Yamanaka (Xara Group Ltd) <camelotdev@xara.com> Date: 31/5/2000 Parameters: -  [INPUTS] -  [OUTPUTS] Returns: - Definition at line 853 of file samplist.cpp. { if (m_pSampleData != NULL) m_pSampleData->resize( (INT32)m_NumItems ); }

BOOL CSampleData::GetArraySection (  UINT32  StartIndex, UINT32  EndIndex, SampleArray *  pSection )  [protected]

To copy the data from the section specified into a new array that we will create. Author: Diccon_Yamanaka (Xara Group Ltd) <camelotdev@xara.com> Date: 12/6/2000 Parameters: StartIndex  - the internal index at which to start the resampling [INPUTS] EndIndex - the internal index to finish the resampling pSection - a to an allocated sample array Allocatest  the array and fills it with data from the section [OUTPUTS] Returns: TRUE if successful, FALSE if something went wrong Errors: if StartIndex or EndIndex are invalid, or if we don't have a sample array Definition at line 1713 of file samplist.cpp. { // check our input conditions ERROR2IF(pSection == NULL, FALSE, "Sample array is NULL in CSampleData::GetArraySection"); if (EndIndex <= StartIndex || EndIndex > m_NumItems) { ERROR3("Invalid indexes in CSampleData::GetArraySection"); return FALSE; } UINT32 NumItems = EndIndex - StartIndex; pSection->resize(NumItems); // we want to make sure we retrieve all the items m_RetrievalSampleRate = 1.0; // We have to do the first one manually, due to my rather clumsy implementation CSampleItem TheItem; BOOL ok = GetAt(StartIndex, &TheItem); if (ok) (*pSection)[0] = TheItem; else ERROR3("Failed to retrieve first item in CSampleData::GetArraySection"); UINT32 Counter = 1; while (ok && (Counter < NumItems)) { ok = GetNext(&TheItem); (*pSection)[Counter] = TheItem; Counter++; } // Did we copy the right number of items? if (Counter != NumItems) { ERROR3("Error copying data in CSampleData::GetArraySection"); ok = FALSE; } else ok = TRUE; return ok; }

BOOL CSampleData::GetAt (  UINT32  Index, CSampleItem *  pItem )

Retrieves the item at Index. Author: Diccon_Yamanaka (Xara Group Ltd) <camelotdev@xara.com> Date: 31/5/2000 Parameters: Index  - the index to retrieve from [INPUTS] pItem  - the item at index [OUTPUTS] Returns: TRUE if successful, FALSE if Index is invalid or there is no array Notes: All the access functions set the m_ListPosition member variable which records the last list positon accessed. This means that you can the use GetNext or GetPrev to retrieve subsequent elements, which is much quicker than using GetAt all the time. Definition at line 695 of file samplist.cpp. { ERROR2IF(pItem == NULL, FALSE, "Item pointer is NULL in CSampleData::GetAt"); if (m_pSampleData != NULL) { if (SetInternalRetrievalIndex(Index)) { //TRACEUSER( "Diccon", _T("Get At: ")); CSampleItem TheItem; if (GetItemAtInternalIndex(m_RetrievalInternalIndex, &TheItem)) *pItem = TheItem; return TRUE; } else ERROR3("Trying to access element over the end of the array in CSampleData::GetAt"); } return FALSE; }

BOOL CSampleData::GetAtPos (  double  Index, CSampleItem *  pItem )

Definition at line 715 of file samplist.cpp. { ERROR2IF(pItem == NULL, FALSE, "Item pointer is NULL in CSampleData::GetAt"); if (m_pSampleData != NULL) { //if (SetInternalRetrievalIndex(Index)) { //TRACEUSER( "Diccon", _T("Get At: ")); UINT32 rounded = (UINT32) Index; CSampleItem TheItem; if (GetItemAtInternalIndex((double) rounded, &TheItem)) *pItem = TheItem; return TRUE; } //else // ERROR3("Trying to access element over the end of the array in CSampleData::GetAt"); } return FALSE; }

double CSampleData::GetCollectionSampleRate (   )

as above Author: Diccon_Yamanaka (Xara Group Ltd) <camelotdev@xara.com> Date: 31/5/2000 Parameters: -  [INPUTS] -  [OUTPUTS] Returns: the current collection sample rate Definition at line 1302 of file samplist.cpp. { return m_CollectionSampleRate; }

INT32 CSampleData::GetCount (  void   )

To find the number of items in the array. Author: Diccon_Yamanaka (Xara Group Ltd) <camelotdev@xara.com> Date: 31/5/2000 Parameters: -  [INPUTS] -  [OUTPUTS] Returns: the number of items in the array, or -1 if the array does not exist Definition at line 831 of file samplist.cpp. { if (m_pSampleData != NULL) return (INT32)m_pSampleData->size(); return -1; }

BOOL CSampleData::GetItemAtInternalIndex (  double  Index, CSampleItem *  pItem )  [protected]

Retrieves the item in the array indicated by the current internal index. Note that it is possible that this index may not be an integer in which case this function will generate a new CSampleItem by interpolation. Author: Diccon_Yamanaka (Xara Group Ltd) <camelotdev@xara.com> Date: 31/5/2000 Parameters: Index  - the index to get the value from. Note that this does not have to be [INPUTS] an integer, should really be the collection or retrieval index only pointer  to item retrieved [OUTPUTS] Returns: TRUE if all went well, FALSE if we don't have an array or the index is invalid Definition at line 1212 of file samplist.cpp. { // no reason why you shouldn't be using this function on values other than our member // indexes but that is not the intended purpose of this fn. hence the ERROR3 //if (Index != m_CollectionInternalIndex && Index != m_RetrievalInternalIndex) // ERROR3("Attempting to use non-member index in CSampleData::GetItemAtInternalIndex"); ERROR2IF(m_pSampleData == NULL, FALSE, "Sample data is null in CSampleData::GetItemAtInternalIndex"); BOOL Retval = FALSE; //TRACEUSER( "Diccon", _T("Retrieving item at %f\n"), Index); double UpperBound = (double)m_pSampleData->size() - 1; // If our index is -1 then we have run off the end of the array, so return the last item if (Index == -1) Index = UpperBound; if (Index <= UpperBound) { size_t LowIndex = (UINT32)Index; if (LowIndex > m_NumItems) //ERROR3("Attempting to access data that has not been collected in CSampleData::GetItemAtInternalIndex"); LowIndex = m_NumItems; //bodge alert! UINT32 HighIndex = (UINT32)Index+1; if (HighIndex < m_NumItems) { double Proportion = Index - (double)LowIndex; CSampleItem LowItem = (*m_pSampleData)[LowIndex]; CSampleItem HighItem = (*m_pSampleData)[HighIndex]; CSampleItem NewItem = LowItem.InterpolateItems(HighItem, (1-Proportion)); //TRACEUSER( "Diccon", _T("Lo = %d, Hi = %d, Prop =%f, Pressure = %d\n"), LowIndex, HighIndex, Proportion, NewItem.m_Pressure); *pItem = NewItem; } else *pItem = (*m_pSampleData)[LowIndex]; Retval = TRUE; } else ERROR3("Internal index is over the end of the array in CSampleData::GetItemAtInternalIndex"); return Retval; }

UINT32 CSampleData::GetMaxPressure (   )

as above Author: Diccon_Yamanaka (Xara Group Ltd) <camelotdev@xara.com> Date: 31/5/2000 Parameters: -  [INPUTS] -  [OUTPUTS] Returns: the maximum pressure value allowed by the device sending the pressure data Definition at line 1392 of file samplist.cpp. { return m_MaxPressure; }

BOOL CSampleData::GetNext (  CSampleItem *  pItem  )

Increments the internal index, then retrieves the item at that index. Author: Diccon_Yamanaka (Xara Group Ltd) <camelotdev@xara.com> Date: 31/5/2000 Parameters: -  [INPUTS] pItem  - the tail item [OUTPUTS] Returns: TRUE if successful, FALSE if we are at the end of the array or it doesn't exist Notes: It is recommended that you do a GetAt before you start doing GetNexts, otherwise I won't vouch for the position of the value of the internal index Definition at line 756 of file samplist.cpp. { BOOL Retval = FALSE; if (m_pSampleData != NULL) { //TRACEUSER( "Diccon", _T("Get Next: ")); if (IncrementInternalIndex(&m_RetrievalInternalIndex)) { // BODGE ALERT! if the retrieval index is -1 then this indicates that we // have reached the end of the array! However I am letting it pass on, // and have inserted more bodge code at GetItemAtInternalIndex to return // the last item. // if (m_RetrievalInternalIndex == -1.0) // ERROR3("Invalid index in CSampleData::GetNext"); { if (GetItemAtInternalIndex(m_RetrievalInternalIndex, pItem)) Retval = TRUE; } } else ERROR3("Unable to increment index in CSampleData::GetNext"); } return Retval; }

size_t CSampleData::GetNumItems (   )  [inline]

Definition at line 183 of file samplist.h. {return m_NumItems;}

BOOL CSampleData::GetPrev (  CSampleItem *  pItem  )

Decrements our internal index and retrieves the item at that position. Author: Diccon_Yamanaka (Xara Group Ltd) <camelotdev@xara.com> Date: 31/5/2000 Parameters: -  [INPUTS] pItem  - the previous item in the array [OUTPUTS] Returns: TRUE if successful, FALSE if we are at the start of the array or it doesn't exist Notes: Really only works if the internal index has been set by a previous function such as GetAt, SetAt, etc. Definition at line 799 of file samplist.cpp. { BOOL Retval = FALSE; if (m_pSampleData != NULL) { if (DecrementInternalIndex(&m_RetrievalInternalIndex)) { if (m_RetrievalInternalIndex != -1.0) { if (GetItemAtInternalIndex(m_RetrievalInternalIndex, pItem)) Retval = TRUE; } } else ERROR3("Unable to decrement index in CSampleData::GetPrev"); } return Retval; }

double CSampleData::GetRetrievalSampleRate (   )

as above Author: Diccon_Yamanaka (Xara Group Ltd) <camelotdev@xara.com> Date: 31/5/2000 Parameters: -  [INPUTS] -  [OUTPUTS] Returns: the current Retrieval sample rate Definition at line 1351 of file samplist.cpp. { return m_RetrievalSampleRate; }

SampleArray* CSampleData::GetSampleArray (   )  [inline]

Definition at line 182 of file samplist.h. { return m_pSampleData;}

BOOL CSampleData::IncrementInternalIndex (  double *  CurrentIndex  )  [protected]

Definition at line 1102 of file samplist.cpp. { // if we've already overrun then don't go any further if (*pCurrentIndex == -1) return TRUE; // not allowed to use indexes that aren't one of our members, also // find out which sample rate to use here double SampleRate = 1.0; if (pCurrentIndex == &m_CollectionInternalIndex) { SampleRate = m_CollectionSampleRate; } else if (pCurrentIndex == &m_RetrievalInternalIndex) { SampleRate = m_RetrievalSampleRate; } else { ERROR3("Attempting to use non-member index in CSampleData::IncrementInternalIndex"); return FALSE; } // we need to have valid sample data ERROR2IF(m_pSampleData == NULL, FALSE, "Sample data is null in CSampleData::IncrementInternalIndex"); double TestIndex = *pCurrentIndex + SampleRate; // TRACEUSER( "Diccon", _T(" Internal index = %f"), TestIndex); // TRACEUSER( "Diccon", _T(", Upper bound = %f\n"), (double)(m_pSampleData->size() - 1)); if (TestIndex <= (double)(m_pSampleData->size() - 1)) { *pCurrentIndex += SampleRate; } else { // TRACEUSER( "Diccon", _T("END OF ARRAY, Test index = %f, Num items = %d\n"), TestIndex, m_NumItems); *pCurrentIndex = -1; } return TRUE; }

BOOL CSampleData::InitialiseData (  size_t  Size = 1000, UINT32  GrowBy = 50 )  [virtual]

creates the list member variable Author: Diccon_Yamanaka (Xara Group Ltd) <camelotdev@xara.com> Date: 31/5/2000 Parameters: -  [INPUTS] -  [OUTPUTS] Returns: TRUE if we initialised ok, FALSE if we didn't get the memory Notes: Definition at line 425 of file samplist.cpp. { // if we've already got a list then delete it if (m_pSampleData != NULL) { m_pSampleData->clear(); delete m_pSampleData; m_pSampleData = NULL; } m_pSampleData = new SampleArray; if (m_pSampleData == NULL) return FALSE; if( Size < m_pSampleData->size() + GrowBy ) Size = m_pSampleData->size() + GrowBy; m_pSampleData->resize( Size ); return TRUE; }

BOOL CSampleData::InsertAt (  UINT32  Index, CSampleItem &  Item )

BOOL CSampleData::InsertControlPoints (  UINT32  Frequency, SampleArray *  pOriginal, SampleArray *  pNew )  [protected]

As part of the ReSampleArray process this function takes the case where we need to increase the number of control points. It therefore proceeds through the original array copying control points over at the same proportional position as they were in the original array. Author: Diccon_Yamanaka (Xara Group Ltd) <camelotdev@xara.com> Date: 12/6/2000 Parameters: Frequency  - the number of indexes per control point. i.e. 4 = a control point [INPUTS] every 4th index. pOriginal - the original array pNew - the new array, this MUST be allocated AND sized Returns: TRUE if successful, FALSE if something went wrong Definition at line 1666 of file samplist.cpp. { ERROR2IF(pOriginal == NULL, FALSE, "Original array is NULL in CSampleData::InsertControlPoints"); ERROR2IF(pNew == NULL, FALSE, "New array is NULL in CSampleData::InsertControlPoints"); double NumOrigItems = (double)pOriginal->size(); double NumNewItems = (double)pNew->size(); INT32 OrigIndex = 0; double dOrigIndex = 0; INT32 NewIndex = 0; CSampleItem TheItem; double OrigProportion; while (OrigIndex < NumOrigItems) { TheItem = (*pOriginal)[OrigIndex]; OrigProportion = dOrigIndex / NumOrigItems; NewIndex = (INT32)(OrigProportion * NumNewItems); if (NewIndex < NumNewItems) (*pNew)[NewIndex] = TheItem; else ERROR3("Attempting to set over the end of the new array in CSampleData::InsertControlPoints"); OrigIndex += Frequency; dOrigIndex += Frequency; } return TRUE; }

BOOL CSampleData::InsertNewData (  UINT32  Index, CSampleData *  pData )

To insert pData into our data array at Index. This function does the shuffling of existing array elements in order to insert the new data. Author: Diccon_Yamanaka (Xara Group Ltd) <camelotdev@xara.com> Date: 31/5/2000 Parameters: Index  - the index to insert at [INPUTS] pData - array of items to insert -  [OUTPUTS] Returns: TRUE if successful Definition at line 874 of file samplist.cpp. { ERROR2IF(pData == NULL, FALSE, "Attempting to insert null array in CSampleData::InsertNewData"); ERROR2IF(m_pSampleData == NULL, FALSE, "Member data array is NULL in CSampleData::InsertNewData"); if (Index > m_pSampleData->size() - 1) { ERROR3("Attempting to insert beyond end of array in CSampleData::InsertNewData"); return FALSE; } // find out how many elements we are inserting INT32 NumNewItems = (INT32)pData->GetNumItems(); if (NumNewItems <= 0) { ERROR3("Attempting to insert zero or fewer elements in BOOL CSampleData::InsertNewData"); return FALSE; } // Set our sample rates to 1.0 so that we don't skip any elements m_CollectionSampleRate = 1.0; m_RetrievalSampleRate = 1.0; pData->SetRetrievalSampleRate(1.0); // work out how many elements we have to move size_t NumMoveItems = m_pSampleData->size() - 1 - Index; // this keeps track of where we're moving from UINT32 MoveIndex = (UINT32)m_pSampleData->size() - 1; m_NumItems = m_pSampleData->size() + NumNewItems; // extend our array so we have room for the new data m_pSampleData->resize((INT32)m_NumItems); // start at the tail and work down, shifting existing elements up to make room CSampleItem TheItem; BOOL KeepGoing = GetAt(MoveIndex, &TheItem); // TRACEUSER( "Diccon", _T("SHIFTING %d ITEMS UP FROM %d TO %d\n"), NumMoveItems, MoveIndex-NumMoveItems, MoveIndex-NumMoveItems + NumNewItems); while (NumMoveItems && KeepGoing) { // copy the item to its place further up in the array (*m_pSampleData)[MoveIndex + NumNewItems] = TheItem; // get the next item KeepGoing = GetPrev(&TheItem); MoveIndex--; NumMoveItems--; } // TRACEUSER( "Diccon", _T("FINISHED SHIFTING UP\n")); // now we can insert our new data at Index // get the first item and set it, so we can use GetNext for each array KeepGoing = pData->GetAt(0, &TheItem); if (KeepGoing) SetAt(Index, TheItem); UINT32 Counter = 0; // TRACEUSER( "Diccon", _T("INSERTING NEW DATA\n")); while (NumNewItems && KeepGoing) { if (KeepGoing) KeepGoing = pData->GetNext(&TheItem); if (KeepGoing) SetNext(TheItem); //TRACEUSER( "Diccon", _T("Inserting item %d\n"), TheItem.m_Pressure); NumNewItems--; Counter++; } //TRACEUSER( "Diccon", _T("Added %d items at index %d\n"), Counter, Index); // hopefully that should have done the trick! return TRUE; }

BOOL CSampleData::InterpolateItems (  UINT32  StartIndex, UINT32  EndIndex, SampleArray *  pArray )  [protected]

Interpolates between the two indexes in the array, creating intermediate items and inserting them. Author: Diccon_Yamanaka (Xara Group Ltd) <camelotdev@xara.com> Date: 13/6/2000 Parameters: StartIndex,EndIndex  - the indexes to interpolate between [INPUTS] pArray - the array to do the interpolatin' on the  interpolated array [OUTPUTS] Returns: TRUE unless the indexes are wack Definition at line 1773 of file samplist.cpp. { ERROR2IF(pArray == NULL, FALSE, "Sample array is NULL in CSampleData::InterpolateItems"); size_t MaxIndex = pArray->size() - 1; if (EndIndex <= StartIndex || EndIndex > MaxIndex) { ERROR3("Invalid indexes in CSampleData::InterpolateItems"); return FALSE; } // get the two items to interpolate between CSampleItem FirstItem = (*pArray)[StartIndex]; CSampleItem LastItem = (*pArray)[EndIndex]; // get the proportional changes for each step UINT32 NumItems = EndIndex - StartIndex; double ItemProportion = 1 / (double)NumItems; MILLIPOINT XVal = (INT32)((double)(LastItem.m_Coord.x - FirstItem.m_Coord.x) * ItemProportion); MILLIPOINT YVal = (INT32)((double)(LastItem.m_Coord.y - FirstItem.m_Coord.y) * ItemProportion); INT32 PressVal = (INT32) (((double)(LastItem.m_Pressure - FirstItem.m_Pressure) * ItemProportion)); UINT32 Index = StartIndex + 1; CSampleItem NewItem = FirstItem; while (Index < EndIndex) { NewItem.m_Coord.x += XVal; NewItem.m_Coord.y += YVal; NewItem.m_Pressure += PressVal; (*pArray)[Index] = NewItem; Index++; } return TRUE; }

CSampleData * CSampleData::MakeCopy (   )

Makes a copy of this sample data. Author: Diccon_Yamanaka (Xara Group Ltd) <camelotdev@xara.com> Date: 31/5/2000 Parameters: -  [INPUTS] -  [OUTPUTS] Returns: a copy of this object, unless something goes wrong (i.e memory) in which case NULL Notes: Reimplemented in CDistanceSampler. Definition at line 370 of file samplist.cpp. { CSampleData* pNewData = new CSampleData; if (pNewData == NULL) return NULL; if (!pNewData->InitialiseData(m_NumItems)) { delete pNewData; return NULL; } m_RetrievalSampleRate = 1; // make sure we get all the items CSampleItem TheItem; // unfortunately my implementation is a bit clumsy so we have to do the first item // by hand BOOL Getok = GetAt(0, &TheItem); BOOL Setok = pNewData->SetAt(0, TheItem); //TRACEUSER( "Diccon", _T("Copying pressure %d\n"), TheItem.m_Pressure); if (Getok == FALSE || Setok == FALSE) ERROR3("Failed to get or set first item in CSampleData::MakeCopy"); UINT32 Counter = 1; // now we can loop through the rest while (Getok && Setok) { Getok = GetNext(&TheItem); Setok = pNewData->SetNext(TheItem); //TRACEUSER( "Diccon", _T("Copying pressure %d\n"), TheItem.m_Pressure); Counter++; } if (Counter != m_NumItems) TRACEUSER( "Diccon", _T("CSampleData::MakeCopy - Num items copied = %d, Actual num items = %d\n"), Counter, m_NumItems); return pNewData; }

BOOL CSampleData::RemoveAt (  UINT32  Index  )

Removes item at Index. Author: Diccon_Yamanaka (Xara Group Ltd) <camelotdev@xara.com> Date: 31/5/2000 Parameters: Index  - the position to remove from [INPUTS] -  [OUTPUTS] Returns: TRUE, unless we go over the end of the array Notes: Definition at line 651 of file samplist.cpp. { BOOL Retval = FALSE; if (m_pSampleData != NULL) { // we are not allowed to be setting data when the sample rate is not 1.0 if (m_CollectionSampleRate < MIN_COLLECTION_SAMPLE_RATE || m_CollectionSampleRate > MAX_COLLECTION_SAMPLE_RATE) { ERROR3("Attempting to remove data when SampleRate != 1"); return FALSE; } if (SetInternalRetrievalIndex(Index)) { m_pSampleData->erase( m_pSampleData->begin() + size_t(m_RetrievalInternalIndex) ); Retval = TRUE; m_NumItems--; } else ERROR3("Attempting to remove beyond the end of the array in CSampleData::RemoveAt"); } return Retval; }

BOOL CSampleData::RemoveControlPoints (  UINT32  Frequency, SampleArray *  pOriginal, SampleArray *  pNew )  [protected]

BOOL CSampleData::RemoveData (  UINT32  StartIndex, UINT32  EndIndex, SampleArray *  pArray = NULL )

To remove all the items between StartIndex and EndIndex, and optionally record them in pArray. Author: Diccon_Yamanaka (Xara Group Ltd) <camelotdev@xara.com> Date: 31/5/2000 Parameters: StartIndex  - the index to start removing from [INPUTS] EndIndex - the index to stop removing at pArray  (optional) - an array to store the removed elements in [OUTPUTS] Returns: TRUE if successful Definition at line 958 of file samplist.cpp. { // do some checks ERROR2IF(m_pSampleData == NULL, FALSE, "Attempting to remove from an array that doesn't exist in CSampleData::RemoveData"); ERROR2IF(EndIndex <= StartIndex, FALSE, "Invalid indexes in CSampleData::RemoveData"); UINT32 UpperBound = (UINT32)m_pSampleData->size() - 1; if (StartIndex > UpperBound || EndIndex > UpperBound) { ERROR3("Attempting to remove items beyond the bounds of the array in CSampleData::RemoveData"); return FALSE; } // Set our samples rate to 1.0 so that we don't skip any elements m_CollectionSampleRate = 1.0; m_RetrievalSampleRate = 1.0; // find out how many we're dealing with UINT32 NumRemoveItems = EndIndex - StartIndex; // TRACEUSER( "Diccon", _T("COPYING ITEMS TO BE REMOVED\n")); // first copy the removed items to the new array (if relevant) if (pArray != NULL) { pArray->resize( NumRemoveItems ); CSampleItem TheItem; for (UINT32 i = 0; i < NumRemoveItems; i++) { TheItem = (*m_pSampleData)[i + StartIndex]; (*pArray)[i] = TheItem; // TRACEUSER( "Diccon", _T("Removing data %d\n"), TheItem.m_Pressure); } } // now copy all elements beyond EndIndex back to StartIndex UINT32 NumMoveItems = UpperBound - EndIndex; UINT32 NumItemsMoved = 0; CSampleItem TheItem; // EndIndex +1 ?? // UINT32 Index = StartIndex; // TRACEUSER( "Diccon", _T("SHIFTING ITEMS DOWN FROM %d TO %d\n"), EndIndex, Index); // TRACEUSER( "Diccon", _T("Upper bound = %d\n"), UpperBound); BOOL ok = GetAt(EndIndex, &TheItem); INT32 RemoveCount = NumRemoveItems; while ((NumItemsMoved <= NumMoveItems) && ok) { (*m_pSampleData)[StartIndex++] = TheItem; ok = GetNext(&TheItem); NumItemsMoved++; if (RemoveCount > 0) { RemoveCount--; m_NumItems--; // decrement the number of items } } // TRACEUSER( "Diccon", _T("Removed %d items\n"), EndIndex - Index); // TRACEUSER( "Diccon", _T("Moved %d items from index %d to index %d\n"), NumItemsMoved, EndIndex, Index); // shrink the array to the new size m_pSampleData->resize( m_NumItems ); return TRUE; }

BOOL CSampleData::ReSampleArray (  SampleArray **  ppArray, UINT32  NewNumItems )  [protected]

Resamples the data in the sample array so that we end up with NewNumItems in the section required. We will do this by selecting some resampling points in the original array, maintain these points at the same proportional position and interpolate to get the new points. Author: Diccon_Yamanaka (Xara Group Ltd) <camelotdev@xara.com> Date: 12/6/2000 Parameters: pArray  - the array to be resampled [INPUTS] NewNumItems - the number of items we want to end up with in the array Returns: TRUE if successful, FALSE if something went wrong Notes: Because, in reality most of our 'sampled' points are actually interpolated from a smaller number of data points collected I feel that we don't actually lose much accuracy if we just take one in every four points as a control point. Definition at line 1586 of file samplist.cpp. { SampleArray* pArray = *ppArray; // check our input conditions ERROR2IF(pArray == NULL, FALSE, "Sample array is NULL in CSampleData::ReSampleData"); if (NewNumItems == 0) // well this is easy { pArray->clear(); return TRUE; } // allocate a new array to put the resampled data in SampleArray* pNewArray = new SampleArray; if (pNewArray == NULL) return FALSE; pNewArray->resize( NewNumItems ); // how many items per control item UINT32 ItemsPerControl = 4; // magic number alert!! // Insert the control points into the new array if (!InsertControlPoints(ItemsPerControl, pArray, pNewArray)) { pNewArray->clear(); delete pNewArray; return FALSE; } // proceed through the new array interpolating between the control points. // We will be able to tell the control points because their coordinates will be non-zero UINT32 ControlIndex1 = 0; // first point is a control point UINT32 ControlIndex2 = 0; CSampleItem TheItem; UINT32 Index = 0; while (Index < NewNumItems) { TheItem = (*pNewArray)[Index]; if (TheItem.m_Coord.x != 0 && TheItem.m_Coord.y != 0) // got another control { ControlIndex2 = Index; if (Index != 0) InterpolateItems(ControlIndex1, ControlIndex2, pNewArray); ControlIndex1 = ControlIndex2; // current control becomes first control } Index++; } // now we have to destroy the original array and swap the pointers delete pArray; *ppArray = pNewArray; return TRUE; }

BOOL CSampleData::ReverseData (   )

Reverses the items in the data array, or rather just copies them into a new one. Author: Diccon_Yamanaka (Xara Group Ltd) <camelotdev@xara.com> Date: 13/12/99 Parameters: -  [INPUTS] Returns: TRUE if successful, FALSE if we didn't get the memory Definition at line 1434 of file samplist.cpp. { if (m_pSampleData == NULL) return TRUE; //EASY size_t ArraySize = m_NumItems; if (ArraySize == 0) return TRUE; // also easy // make a new array SampleArray* pNewArray = new SampleArray; if (pNewArray == NULL) return FALSE; pNewArray->resize( ArraySize ); size_t UpperBound = ArraySize-1; CSampleItem TheItem; // BOOL ok = TRUE; // take the item at the start of our member array and set it at the end of the new array for (UINT32 Counter = 0; Counter < (UINT32)ArraySize ; Counter++) { TheItem = (*m_pSampleData)[Counter]; (*pNewArray)[UpperBound - Counter] = TheItem; } // swap the pointers SampleArray* pTemp = m_pSampleData; m_pSampleData = pNewArray; // clear out the original pTemp->clear(); delete pTemp; return TRUE; }

BOOL CSampleData::SetAt (  UINT32  Index, CSampleItem &  Item )

inserts Item at Index Author: Diccon_Yamanaka (Xara Group Ltd) <camelotdev@xara.com> Date: 31/5/2000 Parameters: Index  - the position to set Item at [INPUTS] Item - the item to insert -  [OUTPUTS] Returns: TRUE if successful, FALSE otherwise Notes: Currently it is not permitted to Set, Remove or Insert items if the sample rate is not 1. This is because a) I really don't want people changing data in the array once it has been collected (we're sampling remember) and b) Its a pain in the ass Definition at line 513 of file samplist.cpp. { BOOL Retval = FALSE; if (m_pSampleData != NULL) { // we are not allowed to be setting data when the sample rate is not 1.0 if (m_CollectionSampleRate < MIN_COLLECTION_SAMPLE_RATE || m_CollectionSampleRate > MAX_COLLECTION_SAMPLE_RATE) { ERROR3("Attempting to set data when SampleRate != 1"); return FALSE; } if (SetInternalCollectionIndex(Index)) { (*m_pSampleData)[size_t(m_CollectionInternalIndex)] = Item; Retval = TRUE; if ((UINT32)m_CollectionInternalIndex > m_NumItems) m_NumItems = (UINT32)m_CollectionInternalIndex; } else ERROR3("Attempting to set over the end of the array in CSampleData::SetAt"); } return Retval; }

BOOL CSampleData::SetCollectionSampleRate (  double  Rate  )

Sets the sample rate to use for collecting data. Note that for current purposes this is only allowed to be 1. So you probably won't be using this function very often. Author: Diccon_Yamanaka (Xara Group Ltd) <camelotdev@xara.com> Date: 31/5/2000 Parameters: Rate  - the sample rate to use [INPUTS] -  [OUTPUTS] Returns: TRUE if Rate is within the set bounds Definition at line 1276 of file samplist.cpp. { if (Rate < MIN_COLLECTION_SAMPLE_RATE || Rate > MAX_COLLECTION_SAMPLE_RATE) { ERROR3("Attempting to set invalid sample rate in CSampleData::SetCollectionSampleRate"); return FALSE; } m_CollectionSampleRate = Rate; return TRUE; }

BOOL CSampleData::SetInternalCollectionIndex (  UINT32  Index  )  [protected]

Sets our collection internal array index to the position corresponding to the requested index. Author: Diccon_Yamanaka (Xara Group Ltd) <camelotdev@xara.com> Date: 31/5/2000 Parameters: IndexRequested  - the requested index to set the array pointer to [INPUTS] -  [OUTPUTS] Returns: TRUE, unless index converts to an internal index that is out of bounds Definition at line 1036 of file samplist.cpp. { ERROR2IF(m_pSampleData == NULL, FALSE, "Sample data is null in CSampleData::SetInternalIndex"); BOOL Retval = FALSE; double TempIndex = m_CollectionSampleRate * Index; if (TempIndex <= (double)m_pSampleData->size() - 1 && TempIndex >= 0) { m_CollectionInternalIndex = TempIndex; Retval = TRUE; } else ERROR3("Attempting to set internal index beyond the end of the array in CSampleData::SetInternalIndex"); return Retval; }

BOOL CSampleData::SetInternalRetrievalIndex (  UINT32  Index  )  [protected]

Sets our Retrieval internal array index to the position corresponding to the requested index. Author: Diccon_Yamanaka (Xara Group Ltd) <camelotdev@xara.com> Date: 31/5/2000 Parameters: IndexRequested  - the requested index to set the array pointer to [INPUTS] -  [OUTPUTS] Returns: TRUE, unless index converts to an internal index that is out of bounds Definition at line 1069 of file samplist.cpp. { ERROR2IF(m_pSampleData == NULL, FALSE, "Sample data is null in CSampleData::SetInternalIndex"); BOOL Retval = FALSE; double TempIndex = m_RetrievalSampleRate * Index; if (TempIndex <= (double)m_pSampleData->size() - 1) { m_RetrievalInternalIndex = TempIndex; Retval = TRUE; } else ERROR3("Attempting to set internal index beyond the end of the array in CSampleData::SetInternalIndex"); return Retval; }

void CSampleData::SetMaxPressure (  UINT32  Max  )

To set our max pressure member. Do this by querying the WinTab device BEFORE you start collecting data. Author: Diccon_Yamanaka (Xara Group Ltd) <camelotdev@xara.com> Date: 31/5/2000 Parameters: Max  - the maximum pressure value allowed by the current pressure device [INPUTS] -  [OUTPUTS] Returns: - Definition at line 1370 of file samplist.cpp. { m_MaxPressure = Max; // +1 because values go from 0 -> MaxVal whereas we really want the number of values m_ScalePressure = (double)(MAXPRESSURE+1) / (Max+1); }

BOOL CSampleData::SetNext (  CSampleItem &  Item, BOOL  Grow = FALSE )

Increments our internal index and then inserts a new item at that position. If we hit the end of the array then we will add an element, so long as our flag is set Notes:. Author: Diccon_Yamanaka (Xara Group Ltd) <camelotdev@xara.com> Date: 31/5/2000 Parameters: Item  - the item to insert [INPUTS] Grow - do we wish to grow the array if we hit the end (defaults to FALSE) -  [OUTPUTS] Returns: TRUE, unless we hit the end of the array and do not widh to grow Definition at line 554 of file samplist.cpp. { BOOL Retval = FALSE; if (m_pSampleData != NULL) { // we are not allowed to be setting data when the sample rate is not 1.0 if (m_CollectionSampleRate < MIN_COLLECTION_SAMPLE_RATE || m_CollectionSampleRate > MAX_COLLECTION_SAMPLE_RATE) { ERROR3("Attempting to set data when SampleRate != 1"); return FALSE; } if (IncrementInternalIndex(&m_CollectionInternalIndex)) { // if internal index == -1 after incrementing it means we hit the end of the array if (m_CollectionInternalIndex != -1.0) { //TRACEUSER( "Diccon", _T("Setting at %f\n"), m_CollectionInternalIndex); (*m_pSampleData)[size_t(m_CollectionInternalIndex)] = Item; Retval = TRUE; if ((UINT32)m_CollectionInternalIndex > m_NumItems) m_NumItems = (UINT32)m_CollectionInternalIndex; } else { // we must have hit the end of the array, so we need to add if (Grow == TRUE) { m_pSampleData->push_back( Item ); Retval = TRUE; m_NumItems++; m_CollectionInternalIndex = m_NumItems; } } } else ERROR3("Failed to increment index in CSampleData::SetNext"); } return Retval; }

void CSampleData::SetNumItemsFromArraySize (   )

Sets the num items member from the size of the array. Note that you should never really use this unless you are certain that a) your current m_NumItems is incorrect and b)You are certain that your array contains nothing but valid data. An example of when you should use this is if you decide to set the array from out side, rather than collect it through sampling. And you really shouldn't be doing that either. Author: Diccon_Yamanaka (Xara Group Ltd) <camelotdev@xara.com> Date: 13/12/99 Parameters: -  [INPUTS] Returns: - Definition at line 1532 of file samplist.cpp. { if (m_pSampleData != NULL) m_NumItems = (UINT32)m_pSampleData->size(); else m_NumItems = 0; }

BOOL CSampleData::SetPrev (  CSampleItem &  Item  )

Decrements our internal index and then inserts Item into the array. Author: Diccon_Yamanaka (Xara Group Ltd) <camelotdev@xara.com> Date: 31/5/2000 Parameters: Item  - the item to insert [INPUTS] -  [OUTPUTS] Returns: TRUE if successful, FALSE if we're already at the head of the array Notes: Definition at line 610 of file samplist.cpp. { BOOL Retval = FALSE; if (m_pSampleData != NULL) { // we are not allowed to be setting data when the sample rate is not 1.0 if (m_CollectionSampleRate < MIN_COLLECTION_SAMPLE_RATE || m_CollectionSampleRate > MAX_COLLECTION_SAMPLE_RATE) { ERROR3("Attempting to set data when SampleRate != 1"); return Retval; } if (DecrementInternalIndex(&m_CollectionInternalIndex)) { if (m_CollectionInternalIndex != -1.0) { (*m_pSampleData)[size_t(m_CollectionInternalIndex)] = Item; Retval = TRUE; } else ERROR3("Attempting to SetPrev over the start of the array in CSampleData::SetPrev"); } ERROR3("Unable to decrement index in CSampleData::SetPrev"); } return Retval; }

BOOL CSampleData::SetRetrievalSampleRate (  double  Rate  )

Sets the sample rate to use for retrieving data,. Author: Diccon_Yamanaka (Xara Group Ltd) <camelotdev@xara.com> Date: 31/5/2000 Parameters: Rate  - the sample rate to use [INPUTS] -  [OUTPUTS] Returns: TRUE if Rate is within the set bounds Definition at line 1319 of file samplist.cpp. { // CGS: because of the way that I now use this function, its NOT fair to do the following .... if (Rate < MIN_RETRIEVAL_SAMPLE_RATE || Rate > MAX_RETRIEVAL_SAMPLE_RATE) { TRACE( _T("Sample rate passed to CSampleData::SetRetrievalSampleRate was oustide of range!") ); //ERROR3("Attempting to set invalid sample rate in CSampleData::SetRetrievalSampleRate"); //return FALSE; } if (Rate < MIN_RETRIEVAL_SAMPLE_RATE) Rate = MIN_RETRIEVAL_SAMPLE_RATE; if (Rate > MAX_RETRIEVAL_SAMPLE_RATE) Rate = MAX_RETRIEVAL_SAMPLE_RATE; m_RetrievalSampleRate = Rate; return TRUE; }

void CSampleData::SetSampleArray (  SampleArray *  pArray  )

sets the given array to use as our sample data Author: Diccon_Yamanaka (Xara Group Ltd) <camelotdev@xara.com> Date: 31/5/2000 Parameters: pArray  - the array to set as a data member [INPUTS] -  [OUTPUTS] Returns: - Definition at line 1410 of file samplist.cpp. { // if we've already got one then delete it if (m_pSampleData != NULL) { m_pSampleData->clear(); delete m_pSampleData; m_pSampleData = NULL; } m_pSampleData = pArray; }

BOOL CSampleData::WriteNative (  CXaraFileRecord *  pRecord  )

Writes out the data contained in this SampleData to a record. Author: Diccon_Yamanaka (Xara Group Ltd) <camelotdev@xara.com> Date: 13/12/99 Parameters: pRecord  - the record to write to [INPUTS] Returns: TRUE if the Node has written out a record to the filter Definition at line 1821 of file samplist.cpp. { ERROR2IF(pRecord == NULL, FALSE, "Record is NULL in CSampleData::WriteNative"); BOOL ok = TRUE; ok = pRecord->WriteINT32((INT32)m_NumItems); if (m_pSampleData != NULL) { CSampleItem TheItem; SetRetrievalSampleRate(1.0); // as we want BOOL KeepWriting = GetAt(0, &TheItem); // get the first itemto save out every item UINT32 Counter = 0; // note that GetNext returns FALSE it just means we've reached the end, not an error while (ok && Counter <= m_NumItems && KeepWriting) { if (ok) ok = TheItem.WriteNative(pRecord); KeepWriting = GetNext(&TheItem); Counter++; } } return ok; }

---

Member Data Documentation

double CSampleData::m_CollectionInternalIndex [protected]

Definition at line 234 of file samplist.h.

double CSampleData::m_CollectionSampleRate [protected]

Definition at line 237 of file samplist.h.

UINT32 CSampleData::m_ElementSize [protected]

Definition at line 240 of file samplist.h.

UINT32 CSampleData::m_MaxPressure [protected]

Definition at line 244 of file samplist.h.

size_t CSampleData::m_NumItems [protected]

Definition at line 242 of file samplist.h.

SampleArray* CSampleData::m_pSampleData [protected]

Definition at line 232 of file samplist.h.

double CSampleData::m_RetrievalInternalIndex [protected]

Definition at line 235 of file samplist.h.

double CSampleData::m_RetrievalSampleRate [protected]

Definition at line 238 of file samplist.h.

double CSampleData::m_ScalePressure [protected]

Definition at line 246 of file samplist.h.

---

The documentation for this class was generated from the following files:

• Kernel/samplist.h (r1785/r751)
• Kernel/samplist.cpp (r1785/r1282)

---