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 *