Add final test for BPolygon, update Marc's BPolygon implementation a bit

and integrate it into the build.


git-svn-id: file:///srv/svn/repos/haiku/trunk/current@2136 a95241bf-73f2-0310-859d-f6bbb57e9c96

src/kits/interface/Polygon.cpp

@@ -38,13 +38,30 @@
 // Globals ---------------------------------------------------------------------
 
 //------------------------------------------------------------------------------
-BPolygon::BPolygon(const BPoint *ptArray, int32 numPoints)
+BPolygon::BPolygon(const BPoint *ptArray, int32 numPoints) :
+	fBounds(0.0, 0.0, 0.0, 0.0), fCount(numPoints), fPts(NULL)
 {
-	fCount = numPoints;
-	fPts = new BPoint[numPoints];
-	memcpy(fPts, ptArray, numPoints * sizeof(BPoint));
-
-	compute_bounds();
+	if (fCount > 0) {
+		fPts = new BPoint[numPoints];
+		
+		// Note the use of memcpy here.  The assumption is that an array of BPoints can
+		// be copied bit by bit and not use a copy constructor or an assignment
+		// operator.  This breaks the containment of BPoint but will result in better
+		// performance.  An example where the memcpy will fail would be if BPoint begins
+		// to do lazy copying through reference counting.  By copying the bits, we will
+		// copy reference counting state which will not be relevant at the destination.
+		// Luckily, BPoint is a very simple class which isn't likely to change much.
+		// However, it is a risk of this implementation.
+		//
+		// If necessary, this code can be changed to iterate over the input array of
+		// BPoints and use the assignment operator to copy from the source to the
+		// destination array, one element at a time.
+		//
+		// Similar use of memcpy appears later in this implementation also.
+		//
+		memcpy(fPts, ptArray, numPoints * sizeof(BPoint));
+		compute_bounds();
+	}
 }
 //------------------------------------------------------------------------------
 BPolygon::BPolygon(const BPolygon *poly)
@@ -53,7 +70,8 @@ BPolygon::BPolygon(const BPolygon *poly)
 }
 //------------------------------------------------------------------------------
 BPolygon::BPolygon ()
-	:	fCount(0),
+	:	fBounds(0.0, 0.0, 0.0, 0.0),
+	    fCount(0),
 		fPts(NULL)
 {
 }
@@ -66,11 +84,15 @@ BPolygon::~BPolygon ()
 //------------------------------------------------------------------------------
 BPolygon &BPolygon::operator=(const BPolygon &from)
 {
-	fBounds = from.fBounds;
-	fCount = from.fCount;
-	fPts = new BPoint[fCount];
-	memcpy(fPts, from.fPts, fCount * sizeof(BPoint));
-
+	// Make sure we aren't trying to perform a "self assignment".
+	if (this != &from) {
+		fBounds = from.fBounds;
+		fCount = from.fCount;
+		if (fCount > 0) {
+			fPts = new BPoint[fCount];
+			memcpy(fPts, from.fPts, fCount * sizeof(BPoint));
+		}
+	}
 	return *this;
 }
 //------------------------------------------------------------------------------
@@ -81,20 +103,17 @@ BRect BPolygon::Frame() const
 //------------------------------------------------------------------------------
 void BPolygon::AddPoints(const BPoint *ptArray, int32 numPoints)
 {
-	BPoint *newPts = new BPoint[fCount + numPoints];
-
-	if (fPts)
-	{
-		memcpy(newPts, fPts, fCount);
-		delete fPts;
+	if (numPoints > 0) {
+		BPoint *newPts = new BPoint[fCount + numPoints];
+		if (fPts) {
+			memcpy(newPts, fPts, fCount * sizeof(BPoint));
+			delete fPts;
+		}
+		memcpy(newPts + fCount, ptArray, numPoints * sizeof(BPoint));
+		fPts = newPts;
+		fCount += numPoints;
+		compute_bounds();
 	}
-
-	memcpy(newPts + fCount, ptArray, numPoints);
-
-	fPts = newPts;
-	fCount += numPoints;
-
-	compute_bounds();
 }
 //------------------------------------------------------------------------------
 int32 BPolygon::CountPoints() const
@@ -117,8 +136,10 @@ void BPolygon::PrintToStream () const
 //------------------------------------------------------------------------------
 void BPolygon::compute_bounds()
 {
-	if (fCount == 0)
+	if (fCount == 0) {
+		fBounds = BRect(0.0, 0.0, 0.0, 0.0);
 		return;
+	}
 
 	fBounds = BRect(fPts[0], fPts[0]);
 

src/kits/interface/interface.src

@@ -9,6 +9,7 @@ INTERFACE_KIT_SOURCE =
 	Font.cpp
 	PictureButton.cpp
 	Point.cpp
+	Polygon.cpp
 	RadioButton.cpp
 	Rect.cpp
 	StatusBar.cpp

src/tests/kits/interface/Jamfile

@@ -27,6 +27,7 @@ CommonTestLib libinterfacetest.so
 		PolygonTest.cpp
 		DummyPolygon.cpp
 		CreatePolygonTest.cpp
+		MapPolygonTest.cpp
 
 	: <boot!home!config!lib>libopenbeos.so
 		be stdc++.r4

src/tests/kits/interface/bpolygon/MapPolygonTest.cpp

@@ -0,0 +1,115 @@
+/*
+	$Id: MapPolygonTest.cpp,v 1.1 2002/12/03 04:07:20 jrand Exp $
+	
+	This file contains the implementation of the tests which show
+	that BPolygons can be created successfully a number of 
+	different ways.  The following use cases are tested:
+		- Map To
+	
+	*/
+
+
+#include "MapPolygonTest.h"
+#include "DummyPolygon.h"
+#include <Point.h>
+#include <Rect.h>
+#include <Polygon.h>
+
+
+/*
+ *  Method:  MapPolygonTest::MapPolygonTest()
+ *   Descr:  This is the constructor for this class.
+ */
+		
+
+	MapPolygonTest::MapPolygonTest(std::string name) :
+		TestCase(name)
+{
+	}
+
+
+/*
+ *  Method:  MapPolygonTest::~MapPolygonTest()
+ *   Descr:  This is the destructor for this class.
+ */
+ 
+
+	MapPolygonTest::~MapPolygonTest()
+{
+	}
+	
+	
+/*
+ *  Method:  MapPolygonTest::polygonMatches()
+ *   Descr:  This member function compares the passed in polygon to the
+ *           set of points and the expected frame rectangle.
+ */
+ 
+void MapPolygonTest::polygonMatches(BPolygon *srcPoly, const BPoint *pointArray,
+                                       int numPoints, const BRect expectedFrame)
+{
+	assert(numPoints == srcPoly->CountPoints());
+	assert(expectedFrame == srcPoly->Frame());
+	
+	const BPoint *srcPointArray = ((DummyPolygon *)srcPoly)->GetPoints();
+	int i;
+	for(i = 0; i < numPoints; i++) {
+		assert(srcPointArray[i] == pointArray[i]);
+	}
+}
+
+
+/*
+ *  Method:  MapPolygonTest::PerformTest()
+ *   Descr:  This member function tests the creation of BPolygon's.
+ *
+ *           The code does the following:
+ */
+
+
+	void MapPolygonTest::PerformTest(void)
+{
+	const int numPoints = 7;
+	BPoint pointArray[numPoints];
+	pointArray[0].x =  0.0;  pointArray[0].y = 10.0;
+	pointArray[1].x = 10.0;  pointArray[1].y =  0.0;
+	pointArray[2].x = 10.0;  pointArray[2].y =  5.0;
+	pointArray[3].x = 30.0;  pointArray[3].y =  5.0;
+	pointArray[4].x = 30.0;  pointArray[4].y = 15.0;
+	pointArray[5].x = 10.0;  pointArray[5].y = 15.0;
+	pointArray[6].x = 10.0;  pointArray[6].y = 20.0;
+	BRect pointArrayFrame(0.0, 0.0, 30.0, 20.0);
+	
+	BRect fromRect(1.0, 1.0, 3.0, 3.0);
+	BRect toRect(1.0, 4.0, 5.0, 10.0);
+	
+	BPoint mapPointArray[numPoints];
+	mapPointArray[0].x = -1.0;  mapPointArray[0].y = 31.0;
+	mapPointArray[1].x = 19.0;  mapPointArray[1].y =  1.0;
+	mapPointArray[2].x = 19.0;  mapPointArray[2].y = 16.0;
+	mapPointArray[3].x = 59.0;  mapPointArray[3].y = 16.0;
+	mapPointArray[4].x = 59.0;  mapPointArray[4].y = 46.0;
+	mapPointArray[5].x = 19.0;  mapPointArray[5].y = 46.0;
+	mapPointArray[6].x = 19.0;  mapPointArray[6].y = 61.0;
+	BRect mapPointArrayFrame(-1.0, 1.0, 59.0, 61.0);
+	
+	BPolygon testPoly1(pointArray, numPoints);
+	polygonMatches(&testPoly1, pointArray, numPoints, pointArrayFrame);
+	testPoly1.MapTo(fromRect, toRect);
+	polygonMatches(&testPoly1, mapPointArray, numPoints, mapPointArrayFrame);
+}
+	
+
+/*
+ *  Method:  PropertyConstructionTest::suite()
+ *   Descr:  This static member function returns a test caller for performing 
+ *           all combinations of "MapPolygonTest".
+ */
+
+ Test *MapPolygonTest::suite(void)
+{	
+	typedef CppUnit::TestCaller<MapPolygonTest>
+		MapPolygonTestCaller;
+		
+	return(new MapPolygonTestCaller("BPolygon::Map Polygon Test", &MapPolygonTest::PerformTest));
+	}

src/tests/kits/interface/bpolygon/MapPolygonTest.h

@@ -0,0 +1,41 @@
+/*
+	$Id: MapPolygonTest.h,v 1.1 2002/12/03 04:07:21 jrand Exp $
+	
+	This file contains the definition of a class for testing the
+	mapping of BPolygon objects.
+	
+	*/ 
+
+
+#ifndef MapPolygonTest_H
+#define MapPolygonTest_H
+
+
+#include "../common.h"
+
+
+class BPolygon;
+class BPoint;
+class BRect;
+
+	
+class MapPolygonTest :
+	public TestCase {
+	
+private:
+	void polygonMatches(BPolygon *, const BPoint *, int numPoints, BRect);
+	
+protected:
+	
+public:
+	static Test *suite(void);
+	void PerformTest(void);
+	MapPolygonTest(std::string name = "");
+	virtual ~MapPolygonTest();
+	};
+	
+#endif
+
+
+
+

src/tests/kits/interface/bpolygon/PolygonTest.cpp

@@ -1,11 +1,13 @@
 #include "../common.h"
 #include "CreatePolygonTest.h"
+#include "MapPolygonTest.h"
 
 Test *PolygonTestSuite()
 {
 	TestSuite *testSuite = new TestSuite();
 	
 	testSuite->addTest(CreatePolygonTest::suite());
+	testSuite->addTest(MapPolygonTest::suite());
 	
 	return(testSuite);
 }