X-Git-Url: http://shamusworld.gotdns.org/cgi-bin/gitweb.cgi?a=blobdiff_plain;f=src%2Fglyphpoints.cpp;h=025f0e1ef3fde7be1c709ee943ada7084d23e7d9;hb=c7d608c4fcdd370274964cc861b674c2fae69468;hp=e6dc52c11ca5ec7ffef3dad62ddcbef2fa1c0fe0;hpb=cf3ec188764cdf34ff3472ee9806aba3a772d2df;p=ttedit

diff --git a/src/glyphpoints.cpp b/src/glyphpoints.cpp
old mode 100755
new mode 100644
index e6dc52c..025f0e1
--- a/src/glyphpoints.cpp
+++ b/src/glyphpoints.cpp
@@ -10,7 +10,7 @@
 // JLH = James L. Hammons <jlhamm@acm.org>
 //
 // Who  When        What
-// ---  ----------  ------------------------------------------------------------
+// ---  ----------  -----------------------------------------------------------
 // JLH  ??/??/200?  Created this file
 // JLH  05/18/2004  Added pure point adding, inserting, better polygon handling
 //
@@ -31,16 +31,16 @@
 }*/
 
 GlyphPoints::GlyphPoints(int nPts/*=0*/, int nPlys/*=0*/, int * xa/*=null*/, int * ya/*=null*/,
-	bool * oca/*=null*/, uint16 * pa/*=null*/): x(NULL), y(NULL), onCurve(NULL), polyEnd(NULL)
+	bool * oca/*=null*/, uint16_t * pa/*=null*/): x(NULL), y(NULL), onCurve(NULL), polyEnd(NULL)
 //GlyphPoints::GlyphPoints(int nPts, int nPlys/*=0*/, int * xa/*=null*/, int * ya/*=null*/,
-//	bool * oca/*=null*/, uint16 * pa/*=null*/): x(NULL), y(NULL), onCurve(NULL), polyEnd(NULL)
+//	bool * oca/*=null*/, uint16_t * pa/*=null*/): x(NULL), y(NULL), onCurve(NULL), polyEnd(NULL)
 {
 	AllocateAndCopy(nPts, nPlys, xa, ya, oca, pa);
 
 	if (nPlys == 0)
 	{
 		numPolys = 1;
-		polyEnd = new uint16[numPolys];
+		polyEnd = new uint16_t[numPolys];
 		polyEnd[0] = numPoints - 1;
 	}
 #ifdef DEBUG
@@ -74,23 +74,10 @@ WriteLogMsg("GlyphPoints: Copy constructor. %u points, %u polys.\n", numPoints,
 GlyphPoints::~GlyphPoints()
 {
 	FreeAllocatedMemory();
-#if 0
-	if (x)
-		delete[] x;
-
-	if (y)
-		delete[] y;
-
-	if (onCurve)
-		delete[] onCurve;
-
-	if (polyEnd)
-		delete[] polyEnd;
-#endif
 }
 
 
-void GlyphPoints::AllocateAndCopy(int nPts, int nPlys, int * xa, int * ya, bool * oca, uint16 * pa)
+void GlyphPoints::AllocateAndCopy(int nPts, int nPlys, int * xa, int * ya, bool * oca, uint16_t * pa)
 {
 	numPoints = nPts, numPolys = nPlys;
 
@@ -115,7 +102,7 @@ void GlyphPoints::AllocateAndCopy(int nPts, int nPlys, int * xa, int * ya, bool
 
 	if (numPolys)
 	{
-		polyEnd = new uint16[numPolys];
+		polyEnd = new uint16_t[numPolys];
 
 		if (pa)									// Copy poly ends in if they're passed in...
 			for(int i=0; i<nPlys; i++)
@@ -145,19 +132,6 @@ GlyphPoints& GlyphPoints::operator=(const GlyphPoints &c)
 	if (this == &c)
 		return *this;							// Take care of self-assignment
 
-#if 0
-	if (x)
-		delete[] x;
-
-	if (y)
-		delete[] y;
-
-	if (onCurve)
-		delete[] onCurve;
-
-	if (polyEnd)
-		delete[] polyEnd;
-#endif
 	FreeAllocatedMemory();
 	AllocateAndCopy(c.numPoints, c.numPolys, c.x, c.y, c.onCurve, c.polyEnd);
 
@@ -174,7 +148,7 @@ GlyphPoints GlyphPoints::operator+(const GlyphPoints &c)
 	int * totX = new int[totPoints];
 	int * totY = new int[totPoints];
 	bool * totOnCurve = new bool[totPoints];
-	uint16 * totPolyEnd = new uint16[totPolys];
+	uint16_t * totPolyEnd = new uint16_t[totPolys];
 
 	for(int i=0; i<numPoints; i++)
 	{
@@ -215,7 +189,7 @@ GlyphPoints GlyphPoints::operator+(const IPoint &c)
 	int * totX = new int[numPoints + 1];
 	int * totY = new int[numPoints + 1];
 	bool * totOnCurve = new bool[numPoints + 1];
-	uint16 * totPolyEnd = new uint16[numPolys];
+	uint16_t * totPolyEnd = new uint16_t[numPolys];
 
 	for(int i=0; i<numPoints; i++)
 		totX[i] = x[i], totY[i] = y[i], totOnCurve[i] = onCurve[i];
@@ -251,11 +225,16 @@ void GlyphPoints::Clear(void)
 	onCurve = NULL;
 	polyEnd = NULL;
 	numPoints = numPolys = pointsAllocated = polysAllocated = 0;
+
+	numPolys = 1;
+	polyEnd = new uint16_t[numPolys];
+	polyEnd[0] = numPoints - 1;
 }
 
 
-void GlyphPoints::InsertPoint(uint16 pt, int xx, int yy, bool oc)
+void GlyphPoints::InsertPoint(uint16_t pt, int xx, int yy, bool oc)
 {
+//wouldn't it be better to treat this case as inserting at the end?
 	if (pt > numPoints)							// > because we can insert at end...!
 		throw GP_OUT_OF_RANGE;
 
@@ -276,7 +255,6 @@ void GlyphPoints::InsertPoint(uint16 pt, int xx, int yy, bool oc)
 //we're adding to the end of the structure: [DONE, below]
 	int polyInsert = (pt == numPoints ? numPolys - 1 : GetPoly(pt));
 	for(int i=polyInsert; i<numPolys; i++)
-//	for(int i=GetPoly(pt); i<numPolys; i++)
 		polyEnd[i]++;							// Bump polygons' end point
 
 	numPoints++;
@@ -289,7 +267,7 @@ void GlyphPoints::InsertPoint(uint16 pt, int xx, int yy, bool oc)
 }
 
 
-void GlyphPoints::InsertPoint(uint16 pt, const IPoint &p)
+void GlyphPoints::InsertPoint(uint16_t pt, const IPoint &p)
 {
 	InsertPoint(pt, p.x, p.y, p.onCurve);
 }
@@ -301,10 +279,10 @@ void GlyphPoints::InsertPoint(uint16 pt, const IPoint &p)
 // size counters down as needed. In the future, we'll keep track so we
 // don't have to reallocate *every* damn time a point is added...
 //
-void GlyphPoints::DeletePoint(uint16 pt)
+void GlyphPoints::DeletePoint(uint16_t pt)
 {
 	// Adjust polygon ends appropriately
-	uint16 poly = GetPoly(pt);
+	uint16_t poly = GetPoly(pt);
 
 	for(int i=poly; i<numPolys; i++)
 		polyEnd[i]--;
@@ -328,18 +306,18 @@ void GlyphPoints::DeletePoint(uint16 pt)
 }
 
 
-uint16 GlyphPoints::GetNumPoints(void)
+uint16_t GlyphPoints::GetNumPoints(void)
 {
 	return numPoints;
 }
 
 
-uint16 GlyphPoints::GetNumPoints(uint16 poly)
+uint16_t GlyphPoints::GetNumPoints(uint16_t poly)
 {
 	if (poly >= numPolys)
 #ifdef DEBUG
 {
-WriteLogMsg("Exception: GetNumPoints(uint16). poly=%u, numPolys=%u\xD\xA", poly, numPolys);
+WriteLogMsg("Exception: GetNumPoints(uint16_t). poly=%u, numPolys=%u\xD\xA", poly, numPolys);
 #endif
 		throw GP_OUT_OF_RANGE;
 #ifdef DEBUG
@@ -350,18 +328,18 @@ WriteLogMsg("Exception: GetNumPoints(uint16). poly=%u, numPolys=%u\xD\xA", poly,
 }
 
 
-uint16 GlyphPoints::GetNumPolys(void)
+uint16_t GlyphPoints::GetNumPolys(void)
 {
 	return numPolys;
 }
 
 
-int GlyphPoints::GetX(uint16 pt)
+int GlyphPoints::GetX(uint16_t pt)
 {
 	if (pt >= numPoints)
 #ifdef DEBUG
 {
-WriteLogMsg("Exception: GetX(uint16). pt=%u, numPoints=%u\xD\xA", pt, numPoints);
+WriteLogMsg("Exception: GetX(uint16_t). pt=%u, numPoints=%u\xD\xA", pt, numPoints);
 #endif
 		throw GP_OUT_OF_RANGE;
 #ifdef DEBUG
@@ -372,12 +350,12 @@ WriteLogMsg("Exception: GetX(uint16). pt=%u, numPoints=%u\xD\xA", pt, numPoints)
 }
 
 
-int GlyphPoints::GetY(uint16 pt)
+int GlyphPoints::GetY(uint16_t pt)
 {
 	if (pt >= numPoints)
 #ifdef DEBUG
 {
-WriteLogMsg("Exception: GetY(uint16). pt=%u, numPoints=%u\xD\xA", pt, numPoints);
+WriteLogMsg("Exception: GetY(uint16_t). pt=%u, numPoints=%u\xD\xA", pt, numPoints);
 #endif
 		throw GP_OUT_OF_RANGE;
 #ifdef DEBUG
@@ -388,12 +366,28 @@ WriteLogMsg("Exception: GetY(uint16). pt=%u, numPoints=%u\xD\xA", pt, numPoints)
 }
 
 
-bool GlyphPoints::GetOnCurve(uint16 pt)
+Vector GlyphPoints::GetXY(uint16_t pt)
+{
+	if (pt >= numPoints)
+#ifdef DEBUG
+{
+WriteLogMsg("Exception: GetXY(uint16_t). pt=%u, numPoints=%u\xD\xA", pt, numPoints);
+#endif
+		throw GP_OUT_OF_RANGE;
+#ifdef DEBUG
+}
+#endif
+
+	return Vector(x[pt], y[pt]);
+}
+
+
+bool GlyphPoints::GetOnCurve(uint16_t pt)
 {
 	if (pt >= numPoints)
 #ifdef DEBUG
 {
-WriteLogMsg("Exception: GetOnCurve(uint16). pt=%u, numPoints=%u\xD\xA", pt, numPoints);
+WriteLogMsg("Exception: GetOnCurve(uint16_t). pt=%u, numPoints=%u\xD\xA", pt, numPoints);
 #endif
 		throw GP_OUT_OF_RANGE;
 #ifdef DEBUG
@@ -404,12 +398,12 @@ WriteLogMsg("Exception: GetOnCurve(uint16). pt=%u, numPoints=%u\xD\xA", pt, numP
 }
 
 
-int GlyphPoints::GetX(uint16 poly, uint16 pt)
+int GlyphPoints::GetX(uint16_t poly, uint16_t pt)
 {
 	if (pt >= GetNumPoints(poly))
 #ifdef DEBUG
 {
-WriteLogMsg("Exception: GetX(uint16, uint16). poly= %u, pt=%u, numPoints=%u\xD\xA", poly, pt, numPoints);
+WriteLogMsg("Exception: GetX(uint16_t, uint16_t). poly= %u, pt=%u, numPoints=%u\xD\xA", poly, pt, numPoints);
 #endif
 		throw GP_OUT_OF_RANGE;
 #ifdef DEBUG
@@ -420,18 +414,18 @@ WriteLogMsg("Exception: GetX(uint16, uint16). poly= %u, pt=%u, numPoints=%u\xD\x
 }
 
 
-int GlyphPoints::GetNextX(uint16 poly, uint16 pt)
+int GlyphPoints::GetNextX(uint16_t poly, uint16_t pt)
 {
 	return GetX(poly, GetNext(poly, pt));
 }
 
 
-int GlyphPoints::GetY(uint16 poly, uint16 pt)
+int GlyphPoints::GetY(uint16_t poly, uint16_t pt)
 {
 	if (pt >= GetNumPoints(poly))
 #ifdef DEBUG
 {
-WriteLogMsg("Exception: GetY(uint16, uint16). poly= %u, pt=%u, numPoints=%u\xD\xA", poly, pt, numPoints);
+WriteLogMsg("Exception: GetY(uint16_t, uint16_t). poly= %u, pt=%u, numPoints=%u\xD\xA", poly, pt, numPoints);
 #endif
 		throw GP_OUT_OF_RANGE;
 #ifdef DEBUG
@@ -442,24 +436,33 @@ WriteLogMsg("Exception: GetY(uint16, uint16). poly= %u, pt=%u, numPoints=%u\xD\x
 }
 
 
-int GlyphPoints::GetNextY(uint16 poly, uint16 pt)
+int GlyphPoints::GetNextY(uint16_t poly, uint16_t pt)
 {
 	return GetY(poly, GetNext(poly, pt));
 }
 
 
-IPoint GlyphPoints::GetPoint(uint16 poly, uint16 pt)
+IPoint GlyphPoints::GetPoint(uint16_t poly, uint16_t pt)
 {
-	return IPoint(GetX(poly, pt), GetY(poly, pt));
+	return IPoint(GetX(poly, pt), GetY(poly, pt), GetOnCurve(poly, pt));
+}
+
+
+IPoint GlyphPoints::GetPoint(uint16_t pointNumber)
+{
+	if (pointNumber > numPoints)
+		throw GP_OUT_OF_RANGE;
+
+	return IPoint(x[pointNumber], y[pointNumber], onCurve[pointNumber]);
 }
 
 
-bool GlyphPoints::GetOnCurve(uint16 poly, uint16 pt)
+bool GlyphPoints::GetOnCurve(uint16_t poly, uint16_t pt)
 {
 	if (pt >= GetNumPoints(poly))
 #ifdef DEBUG
 {
-WriteLogMsg("Exception: GetOnCurve(uint16, uint16). poly= %u, pt=%u, numPoints=%u\xD\xA", poly, pt, numPoints);
+WriteLogMsg("Exception: GetOnCurve(uint16_t, uint16_t). poly= %u, pt=%u, numPoints=%u\xD\xA", poly, pt, numPoints);
 #endif
 		throw GP_OUT_OF_RANGE;
 #ifdef DEBUG
@@ -470,24 +473,24 @@ WriteLogMsg("Exception: GetOnCurve(uint16, uint16). poly= %u, pt=%u, numPoints=%
 }
 
 
-bool GlyphPoints::GetPrevOnCurve(uint16 poly, uint16 pt)
+bool GlyphPoints::GetPrevOnCurve(uint16_t poly, uint16_t pt)
 {
 	return GetOnCurve(poly, GetPrev(poly, pt));
 }
 
 
-bool GlyphPoints::GetNextOnCurve(uint16 poly, uint16 pt)
+bool GlyphPoints::GetNextOnCurve(uint16_t poly, uint16_t pt)
 {
 	return GetOnCurve(poly, GetNext(poly, pt));
 }
 
 
-uint16 GlyphPoints::GetPolyStart(uint16 poly)
+uint16_t GlyphPoints::GetPolyStart(uint16_t poly)
 {
 	if (poly >= numPolys)
 #ifdef DEBUG
 {
-WriteLogMsg("Exception: GetPolyEnd(uint16). poly=%u, numPolys=%u\xD\xA", poly, numPolys);
+WriteLogMsg("Exception: GetPolyEnd(uint16_t). poly=%u, numPolys=%u\xD\xA", poly, numPolys);
 #endif
 		throw GP_OUT_OF_RANGE;
 #ifdef DEBUG
@@ -499,12 +502,12 @@ WriteLogMsg("Exception: GetPolyEnd(uint16). poly=%u, numPolys=%u\xD\xA", poly, n
 }
 
 
-uint16 GlyphPoints::GetPolyEnd(uint16 poly)
+uint16_t GlyphPoints::GetPolyEnd(uint16_t poly)
 {
 	if (poly >= numPolys)
 #ifdef DEBUG
 {
-WriteLogMsg("Exception: GetPolyEnd(uint16). poly=%u, numPolys=%u\xD\xA", poly, numPolys);
+WriteLogMsg("Exception: GetPolyEnd(uint16_t). poly=%u, numPolys=%u\xD\xA", poly, numPolys);
 #endif
 		throw GP_OUT_OF_RANGE;
 #ifdef DEBUG
@@ -525,19 +528,19 @@ void GlyphPoints::OffsetPoints(int xOff, int yOff)
 //
 // Offset only a specific polygon in the glyph
 //
-void GlyphPoints::OffsetPoly(uint16 poly, int32 xOff, int32 yOff)
+void GlyphPoints::OffsetPoly(uint16_t poly, int32_t xOff, int32_t yOff)
 {
 	if (poly >= numPolys)
 #ifdef DEBUG
 {
-WriteLogMsg("Exception: GetPolyEnd(uint16). poly=%u, numPolys=%u\xD\xA", poly, numPolys);
+WriteLogMsg("Exception: GetPolyEnd(uint16_t). poly=%u, numPolys=%u\xD\xA", poly, numPolys);
 #endif
 		throw GP_OUT_OF_RANGE;
 #ifdef DEBUG
 }
 #endif
 
-	uint16 polyStart = (poly == 0 ? 0 : polyEnd[poly - 1] + 1);
+	uint16_t polyStart = (poly == 0 ? 0 : polyEnd[poly - 1] + 1);
 
 	for(int i=0; i<GetNumPoints(poly); i++)
 		x[polyStart + i] += xOff, y[polyStart + i] += yOff;
@@ -552,12 +555,12 @@ void GlyphPoints::ScalePoints(float sc)
 }
 
 
-void GlyphPoints::SetXY(uint16 pt, int xx, int yy)
+void GlyphPoints::SetXY(uint16_t pt, int xx, int yy)
 {
 	if (pt >= numPoints)
 #ifdef DEBUG
 {
-WriteLogMsg("Exception: SetXY(uint16, int, int). pt=%u, numPoints=%u\xD\xA", pt, numPoints);
+WriteLogMsg("Exception: SetXY(uint16_t, int, int). pt=%u, numPoints=%u\xD\xA", pt, numPoints);
 #endif
 		throw GP_OUT_OF_RANGE;
 #ifdef DEBUG
@@ -568,12 +571,12 @@ WriteLogMsg("Exception: SetXY(uint16, int, int). pt=%u, numPoints=%u\xD\xA", pt,
 }
 
 
-void GlyphPoints::SetOnCurve(uint16 pt, bool oc)
+void GlyphPoints::SetOnCurve(uint16_t pt, bool oc)
 {
 	if (pt >= numPoints)
 #ifdef DEBUG
 {
-WriteLogMsg("Exception: SetOnCurve(uint16, bool). pt=%u, numPoints=%u\xD\xA", pt, numPoints);
+WriteLogMsg("Exception: SetOnCurve(uint16_t, bool). pt=%u, numPoints=%u\xD\xA", pt, numPoints);
 #endif
 		throw GP_OUT_OF_RANGE;
 #ifdef DEBUG
@@ -584,10 +587,26 @@ WriteLogMsg("Exception: SetOnCurve(uint16, bool). pt=%u, numPoints=%u\xD\xA", pt
 }
 
 
-uint16 GlyphPoints::GetPrev(uint16 pt)
+void GlyphPoints::SetPoint(const uint16_t pointNum, const IPoint point)
+{
+	if (pointNum >= numPoints)
+#ifdef DEBUG
+{
+WriteLogMsg("Exception: SetPoint(uint16_t, IPoint). pt=%u, numPoints=%u\xD\xA", pointNum, numPoints);
+#endif
+		throw GP_OUT_OF_RANGE;
+#ifdef DEBUG
+}
+#endif
+
+	x[pointNum] = point.x, y[pointNum] = point.y, onCurve[pointNum] = point.onCurve;
+}
+
+
+uint16_t GlyphPoints::GetPrev(uint16_t pt)
 {
 // pt = 7, polyEnd = 4, 9, 15
-	uint16 min = 0, max = numPoints - 1;
+	uint16_t min = 0, max = numPoints - 1;
 
 	for(int i=0; i<numPolys; i++)
 	{
@@ -601,7 +620,7 @@ uint16 GlyphPoints::GetPrev(uint16 pt)
 		}
 	}
 
-	uint16 retVal = pt - 1;
+	uint16_t retVal = pt - 1;
 
 	if (pt == min)
 		retVal = max;
@@ -610,9 +629,9 @@ uint16 GlyphPoints::GetPrev(uint16 pt)
 }
 
 
-uint16 GlyphPoints::GetNext(uint16 pt)
+uint16_t GlyphPoints::GetNext(uint16_t pt)
 {
-	uint16 min = 0, max = numPoints - 1;
+	uint16_t min = 0, max = numPoints - 1;
 
 	for(int i=0; i<numPolys; i++)
 	{
@@ -626,7 +645,7 @@ uint16 GlyphPoints::GetNext(uint16 pt)
 		}
 	}
 
-	uint16 retVal = pt + 1;
+	uint16_t retVal = pt + 1;
 
 	if (pt == max)
 		retVal = min;
@@ -639,7 +658,7 @@ uint16 GlyphPoints::GetNext(uint16 pt)
 // Get previous point for this polygon using wraparound.
 // Note that pt is a zero-based index!
 //
-uint16 GlyphPoints::GetPrev(uint16 poly, uint16 pt)
+uint16_t GlyphPoints::GetPrev(uint16_t poly, uint16_t pt)
 {
 	return (pt == 0 ? GetNumPoints(poly) - 1 : pt - 1);
 }
@@ -649,18 +668,19 @@ uint16 GlyphPoints::GetPrev(uint16 poly, uint16 pt)
 // Get next point for this polygon using wraparound.
 // Note that pt is a zero-based index!
 //
-uint16 GlyphPoints::GetNext(uint16 poly, uint16 pt)
+uint16_t GlyphPoints::GetNext(uint16_t poly, uint16_t pt)
 {
 	return (pt == GetNumPoints(poly) - 1 ? 0 : pt + 1);
 }
 
 
-uint16 GlyphPoints::GetPoly(uint16 pt)
+#warning "!!! This function returns incorrect results !!!"
+uint16_t GlyphPoints::GetPoly(uint16_t pt)
 {
 	if (pt >= numPoints)
 #ifdef DEBUG
 {
-WriteLogMsg("Exception: GetPoly(uint16). pt=%u, numPoints=%u\xD\xA", pt, numPoints);
+WriteLogMsg("Exception: GetPoly(uint16_t). pt=%u, numPoints=%u\xD\xA", pt, numPoints);
 #endif
 		throw GP_OUT_OF_RANGE;
 #ifdef DEBUG
@@ -671,7 +691,7 @@ WriteLogMsg("Exception: GetPoly(uint16). pt=%u, numPoints=%u\xD\xA", pt, numPoin
 		if (pt <= polyEnd[i])
 			return i;
 
-	return (uint16)-1;
+	return (uint16_t)-1;
 }
 
 
@@ -680,9 +700,9 @@ void GlyphPoints::AddNewPolyAtEnd(void)
 	if (numPoints == 0)							// By default, we already *have* a poly
 		return;
 
-	uint16 * newPolyEnd = new uint16[numPolys + 1];
+	uint16_t * newPolyEnd = new uint16_t[numPolys + 1];
 
-	for(uint16 i=0; i<numPolys; i++)
+	for(uint16_t i=0; i<numPolys; i++)
 		newPolyEnd[i] = polyEnd[i];
 
 	newPolyEnd[numPolys] = newPolyEnd[numPolys - 1];
@@ -692,41 +712,75 @@ void GlyphPoints::AddNewPolyAtEnd(void)
 }
 
 
-IPoint GlyphPoints::GetMidpointToPrev(uint16 poly, uint16 pt)
+IPoint GlyphPoints::GetMidpointToPrev(uint16_t poly, uint16_t pt)
 {
-	uint16 prev = GetPrev(poly, pt);
+	uint16_t prev = GetPrev(poly, pt);
 
-	int32 x1 = GetX(poly, pt), y1 = GetY(poly, pt);
-	int32 x2 = GetX(poly, prev), y2 = GetY(poly, prev);
+	int32_t x1 = GetX(poly, pt), y1 = GetY(poly, pt);
+	int32_t x2 = GetX(poly, prev), y2 = GetY(poly, prev);
 
 	return IPoint((x1 + x2) / 2.0f, (y1 + y2) / 2.0f);
 }
 
 
-IPoint GlyphPoints::GetMidpointToNext(uint16 poly, uint16 pt)
+IPoint GlyphPoints::GetMidpointToNext(uint16_t poly, uint16_t pt)
 {
-	uint16 next = GetNext(poly, pt);
+	uint16_t next = GetNext(poly, pt);
 
-	int32 x1 = GetX(poly, pt), y1 = GetY(poly, pt);
-	int32 x2 = GetX(poly, next), y2 = GetY(poly, next);
+	int32_t x1 = GetX(poly, pt), y1 = GetY(poly, pt);
+	int32_t x2 = GetX(poly, next), y2 = GetY(poly, next);
 
 	return IPoint((x1 + x2) / 2.0f, (y1 + y2) / 2.0f);
 }
 
 
-IPoint GlyphPoints::GetPrevPoint(uint16 poly, uint16 pt)
+IPoint GlyphPoints::GetPrevPoint(uint16_t poly, uint16_t pt)
 {
-	uint16 prevPt = GetPrev(poly, pt);
+	uint16_t prevPt = GetPrev(poly, pt);
 
-	return IPoint(GetX(poly, prevPt), GetY(poly, prevPt));
+	return IPoint(GetX(poly, prevPt), GetY(poly, prevPt), GetOnCurve(poly, prevPt));
 }
 
 
-IPoint GlyphPoints::GetNextPoint(uint16 poly, uint16 pt)
+IPoint GlyphPoints::GetNextPoint(uint16_t poly, uint16_t pt)
 {
-	uint16 nextPt = GetNext(poly, pt);
+	uint16_t nextPt = GetNext(poly, pt);
 
-	return IPoint(GetX(poly, nextPt), GetY(poly, nextPt));
+	return IPoint(GetX(poly, nextPt), GetY(poly, nextPt), GetOnCurve(poly, nextPt));
+}
+
+
+uint16_t GlyphPoints::GetPolyForPoint(IPoint point)
+{
+	uint16_t poly = 0;
+
+	for(uint16_t i=0; i<numPoints; i++)
+	{
+		if (i > polyEnd[poly])
+			poly++;
+
+		if (IPoint(x[i], y[i]) == point)
+			return poly;
+	}
+
+	return 0xFFFF;
+}
+
+
+uint16_t GlyphPoints::GetPolyForPointNumber(uint16_t pointNumber)
+{
+	// If there's only one poly, we know where the point is...
+	if (numPolys <= 1)
+		return 0;
+
+	// Otherwise, do a linear search through the polys to find the right one
+	for(uint16_t i=0; i<numPolys; i++)
+	{
+		if (pointNumber >= GetPolyStart(i) && pointNumber <= polyEnd[i])
+			return i;
+	}
+
+	return 0xFFFF;
 }
 
 
@@ -773,17 +827,19 @@ void GlyphPoints::RotatePoints(const double angle, const IPoint pt)
 }
 
 
-IPoint GlyphPoints::GetPolyCentroid(const int16 poly)
+IPoint GlyphPoints::GetPolyCentroid(const int16_t poly)
 {
 	// We should throw an exception here, but meh
 	// (this actually short circuits the exception handling in all the GetPolyXXX() functions)
+	// [now we do!]
 	if (poly >= numPolys)
-		return IPoint(0, 0);
+		throw GP_OUT_OF_RANGE;
+//		return IPoint(0, 0);
 
 //	if (poly >= numPolys)
 //#ifdef DEBUG
 //{
-//WriteLogMsg("Exception: GetPolyEnd(uint16). poly=%u, numPolys=%u\xD\xA", poly, numPolys);
+//WriteLogMsg("Exception: GetPolyEnd(uint16_t). poly=%u, numPolys=%u\xD\xA", poly, numPolys);
 //#endif
 //		throw GP_OUT_OF_RANGE;
 //#ifdef DEBUG
@@ -791,9 +847,9 @@ IPoint GlyphPoints::GetPolyCentroid(const int16 poly)
 //#endif
 
 	IPoint centroid;								// Initializes to (0, 0)
-	uint16 numPointsInPoly = GetNumPoints(poly);
+	uint16_t numPointsInPoly = GetNumPoints(poly);
 
-	for(uint16 i=GetPolyStart(poly); i<=GetPolyEnd(poly); i++)
+	for(uint16_t i=GetPolyStart(poly); i<=GetPolyEnd(poly); i++)
 	{
 		centroid.x += x[i];
 		centroid.y += y[i];
@@ -806,14 +862,14 @@ IPoint GlyphPoints::GetPolyCentroid(const int16 poly)
 }
 
 
-void GlyphPoints::RotatePolyAroundCentroid(const int16 poly, const double angle)
+void GlyphPoints::RotatePolyAroundCentroid(const int16_t poly, const double angle)
 {
 	if (poly >= numPolys)
 		return;
 
 	IPoint centroid = GetPolyCentroid(poly);
 
-	for(uint16 i=GetPolyStart(poly); i<=GetPolyEnd(poly); i++)
+	for(uint16_t i=GetPolyStart(poly); i<=GetPolyEnd(poly); i++)
 	{
 		IPoint rotated = RotatePoint(angle, IPoint(x[i], y[i]), centroid);
 		x[i] = rotated.x;
@@ -822,6 +878,27 @@ void GlyphPoints::RotatePolyAroundCentroid(const int16 poly, const double angle)
 }
 
 
+void GlyphPoints::InvertPolyDrawSequence(const uint16_t poly)
+{
+	if (poly >= numPolys)
+		throw GP_OUT_OF_RANGE;
+
+	uint16_t pointNum1 = GetPolyStart(poly);
+	uint16_t pointNum2 = GetPolyEnd(poly);
+
+	// Algorithm: Step through points in the polygon, swapping 1st and last, then
+	// 2nd and (last - 1), 3rd and (last - 2), etc. We only do this for half the
+	// points, as doing it for all would undo the swapping we did in the 1st half.
+	for(uint16_t i=0; i<GetNumPoints(poly)/2; i++)
+	{
+		IPoint point1 = GetPoint(pointNum1 + i);
+		IPoint point2 = GetPoint(pointNum2 - i);
+		SetPoint(pointNum2 - i, point1);
+		SetPoint(pointNum1 + i, point2);
+	}
+}
+
+
 // really need to do checking on the results from fscanf...
 bool GlyphPoints::LoadGlyphFromFile(FILE * file)
 {
@@ -830,24 +907,29 @@ bool GlyphPoints::LoadGlyphFromFile(FILE * file)
 
 	FreeAllocatedMemory();
 
-	fscanf(file, "%s V%f", line, &version);
-	fscanf(file, "%s %u", line, &numPoints);
+	int num = fscanf(file, "TTEGLYPH V%f\n", &version);
+
+	// Check to see if this is really a glyph file
+	if ((num != 1) || (version != 1.0))
+		return false;
+
+	num = fscanf(file, "POINTS %u\n", &numPoints);
 	x = new int[numPoints];
 	y = new int[numPoints];
 	onCurve = new bool[numPoints];
 
 	for(int i=0; i<numPoints; i++)
 	{
-		fscanf(file, "%d %d %s", &x[i], &y[i], &line);
+		fscanf(file, "%d %d %s\n", &x[i], &y[i], (char *)&line);
 		onCurve[i] = (line[0] == 'T' ? true : false);
 	}
 
-	fscanf(file, "%s %u", line, &numPolys);
-	polyEnd = new uint16[numPolys];
+	num = fscanf(file, "POLYS %u\n", &numPolys);
+	polyEnd = new uint16_t[numPolys];
 
 	for(int i=0; i<numPolys; i++)
 	{
-		fscanf(file, "%u", &polyEnd[i]);
+		fscanf(file, "%u\n", &polyEnd[i]);
 	}
 
 	return true;