X-Git-Url: http://shamusworld.gotdns.org/cgi-bin/gitweb.cgi?a=blobdiff_plain;f=src%2Fcontainer.cpp;h=b3f7347c541897395a192c9b4e26f029226f11d6;hb=d00cd5f46252ca0fb3df6e8191dc75f8991b2aa2;hp=e909c04ae14b1ba8f9a7e6c0af4b2464cf76aff0;hpb=3047a65eb459ddb4a85e1a694aa2b2491437472e;p=architektonas

diff --git a/src/container.cpp b/src/container.cpp
index e909c04..b3f7347 100644
--- a/src/container.cpp
+++ b/src/container.cpp
@@ -1,3 +1,4 @@
+//
 // container.cpp: Container object
 //
 // Part of the Architektonas Project
@@ -19,30 +20,29 @@
 #include "dimension.h"
 #include "painter.h"
 
-
 Container::Container(Vector p1, Object * p/*= NULL*/): Object(p1, p),
 	isTopLevelContainer(false),
-	dragging(false), draggingHandle1(false), draggingHandle2(false)//, needUpdate(false)
+	dragging(false), draggingHandle1(false), draggingHandle2(false),
+	hit(false)//, needUpdate(false)
 {
 	type = OTContainer;
+	state = OSInactive;
 }
 
-
 // Copy constructor
 Container::Container(const Container & copy): Object(copy.position, copy.parent)
 {
 	// Use overloaded assignment operator
 	*this = copy;
 	type = OTContainer;
+	state = OSInactive;
 }
 
-
 Container::~Container()
 {
 	Clear();
 }
 
-
 // Assignment operator
 Container & Container::operator=(const Container & from)
 {
@@ -51,48 +51,42 @@ Container & Container::operator=(const Container & from)
 		return *this;
 
 	Clear();
+	std::vector<Object *>::const_iterator i;
 
-	// Small problem with this approach: if the copied object goes out of scope,
-	// all of the objects we copied in here will be deleted. D'oh!
-	for(uint i=0; i<from.objects.size(); i++)
+	for(i=from.objects.begin(); i!=from.objects.end(); i++)
 	{
-		Object * object = from.objects[i];
-
-		// Need to copy the object here...
-
+printf("Container: Copying object $%08X...\n", *i);
+		Object * object = (*i)->Copy();
 		objects.push_back(object);
 	}
 
 	return *this;
 }
 
-
 /*virtual*/ void Container::Draw(Painter * painter)
 {
 	QRectF boundary;
 
+//int a=1;
 	for(std::vector<Object *>::iterator i=objects.begin(); i!=objects.end(); i++)
-//	for(int i=0; i<(int)objects.size(); i++)
 	{
-#if 0
-//printf("Container: About to draw (object = $%X)\n", objects[i]);
-		objects[i]->Draw(painter);
-		bounds = bounds.united(objects[i].RectangularExtents());
-#else
+//printf("Containter::Draw item #%i [%X]...\n", a++, *i);
 		(*i)->Draw(painter);
 		boundary = boundary.united((*i)->Extents());
-#endif
 	}
 
-	if (state == OSSelected)
+	if ((state == OSSelected) || hit)
 	{
-		painter->SetPen(QPen(Qt::magenta, 2.0, Qt::DashLine));
+		if (hit)
+			painter->SetPen(QPen(Qt::magenta, 1.0, Qt::DashLine));
+		else
+			painter->SetPen(QPen(Qt::blue, 2.0, Qt::DashLine));
+
 		painter->SetBrush(QBrush(Qt::NoBrush));
-		painter->DrawRect(boundary);
+		painter->DrawPaddedRect(boundary);
 	}
 }
 
-
 /*virtual*/ Vector Container::Center(void)
 {
 	return position;
@@ -111,7 +105,6 @@ I click here and drag there?"
 Also: should put the snap logic into the Object base class (as a static method)...
 */
 
-
 // Need to add checking here for clicking on a member of a group (Container),
 // and checking for if it's a top level container (the DrawingView's document).
 /*
@@ -123,12 +116,13 @@ having to ungroup them first (like Inkscape).
 /*virtual*/ bool Container::Collided(Vector point)
 {
 	objectWasDragged = false;
-//	Vector v1 = position - point;
-
 	bool collision = false;
+	lastObjectClicked = NULL;
 
-	// NOTE that this deletes the object on mouse down instead of mouse up. Have to
-	// check to see how it feels to do it that way...
+	// NOTE that this deletes the object on mouse down instead of mouse up.
+	// Have to check to see how it feels to do it that way...
+	// N.B.: This only works because the toolAction is not set, &
+	//       Object::ignoreClicks isn't set either...
 	if (deleteActive)
 	{
 		for(std::vector<Object *>::iterator i=objects.begin(); i!=objects.end();)
@@ -149,10 +143,17 @@ printf("Container::Collided: Deleting object ($%X)\n", *i);
 		for(std::vector<Object *>::iterator i=objects.begin(); i!=objects.end(); i++)
 		{
 			if ((*i)->Collided(point))
+			{
 				collision = true;
+				lastObjectClicked = *i;
+//printf("Container::Collided: lastObjectClicked = %X\n", lastObjectClicked);
+			}
 		}
 	}
 
+	if (snapToGrid)
+		point = SnapPointToGrid(point);
+
 	// We check to see if the container we're trying to access is the
 	// DrawingView's document. If so, we ignore the state of the container.
 	// Otherwise, we care about the state of the container. :-)
@@ -163,7 +164,11 @@ printf("Container::Collided: Deleting object ($%X)\n", *i);
 		state = (collision ? OSSelected : OSInactive);
 
 		if (state == OSSelected)
+		{
 			DeselectAll();
+			dragging = true;
+			oldPoint = point;
+		}
 	}
 
 	return collision;
@@ -189,46 +194,85 @@ class so that we can leverage that stuff here as well.
 // into parts and keep subdividing until an acceptable number of objects lie within
 // the slice. This way, the GUI will still be responsive and *not* have to test
 // every object for collision.
-/*virtual*/ void Container::PointerMoved(Vector point)
+/*virtual*/ bool Container::PointerMoved(Vector point)
 {
+	std::vector<Object *>::iterator i;
+	lastObjectHovered = penultimateObjectHovered = NULL;
+
 	if (!isTopLevelContainer)
 	{
 		// check for selection rectangle too
+		if (selectionInProgress)
+		{
+			if (selection.contains(Extents()))
+				state = OSSelected;
+			else
+				state = OSInactive;
+
+			return false;
+		}
 
+		// No need to do any checking if we're already selected...
+//		if (state == OSSelected)
+//			return;
 
-		needUpdate = true;
+//		oldState = state;
+//		needUpdate = true;
+//		if (dragging &&
+		bool oldHit = hit;
+		hit = false;
 
-		for(std::vector<Object *>::iterator i=objects.begin(); i!=objects.end(); i++)
+		for(i=objects.begin(); i!=objects.end(); i++)
 		{
 			if ((*i)->HitTest(point))
 			{
-				state = OSSelected;
-				return;
+//				state = OSSelected;
+//				return;
+				hit = true;
+				break;
 			}
 		}
 
-		state = OSInactive;
-		return;
-	}
+		needUpdate = (oldHit != hit ? true : false);
+//		state = oldState;
 
-//	objectWasDragged = true;
-//printf("CONTAINER: PointerMoved()\n");
+		if (dragging)
+		{
+			Vector delta = point - oldPoint;
+
+			for(i=objects.begin(); i!=objects.end(); i++)
+				(*i)->Translate(delta);
+
+			oldPoint = point;
+			needUpdate = true;
+		}
+
+		return false;
+	}
 
 	for(std::vector<Object *>::iterator i=objects.begin(); i!=objects.end(); i++)
-//	for(int i=0; i<(int)objects.size(); i++)
 	{
-////		if (objects[i]->GetState() == OSSelected)
-//			objects[i]->PointerMoved(point);
-		(*i)->PointerMoved(point);
+//		if (objects[i]->GetState() == OSSelected)
+		if ((*i)->PointerMoved(point))
+		{
+			penultimateObjectHovered = lastObjectHovered;
+			lastObjectHovered = *i;
+		}
 	}
 
 	// Generic container doesn't need this???
 //	needUpdate = false;
+	return (lastObjectHovered == NULL ? false : true);
 }
 
-
 /*virtual*/ void Container::PointerReleased(void)
 {
+	if (!isTopLevelContainer)
+	{
+		dragging = false;
+		return;
+	}
+#if 0
 	dragging = false;
 	draggingHandle1 = false;
 	draggingHandle2 = false;
@@ -236,18 +280,21 @@ class so that we can leverage that stuff here as well.
 	// Here we check for just a click: If object was clicked and dragged, then
 	// revert to the old state (OSInactive). Otherwise, keep the new state that
 	// we set.
-/*Maybe it would be better to just check for "object was dragged" state and not have to worry
-about keeping track of old states...
+/*
+Maybe it would be better to just check for "object was dragged" state and not
+have to worry about keeping track of old states...
 */
 	if (objectWasDragged)
 		state = oldState;
 //Note that the preceeding is unnecessary for a generic container!
+#endif
 
-	for(int i=0; i<(int)objects.size(); i++)
-		objects[i]->PointerReleased();
+//	for(int i=0; i<(int)objects.size(); i++)
+//		objects[i]->PointerReleased();
+	for(std::vector<Object *>::iterator i=objects.begin(); i!=objects.end(); i++)
+		(*i)->PointerReleased();
 }
 
-
 /*virtual*/ bool Container::NeedsUpdate(void)
 {
 	// If this is *not* a top level container, then we treat it as an
@@ -268,14 +315,12 @@ about keeping track of old states...
 	return false;
 }
 
-
 /*virtual*/ void Container::Add(Object * object)
 {
 	objects.push_back(object);
 printf("Container: Added object (=$%X). size = %li\n", object, objects.size());
 }
 
-
 /*virtual*/ QRectF Container::Extents(void)
 {
 	QRectF bounds;
@@ -286,7 +331,6 @@ printf("Container: Added object (=$%X). size = %li\n", object, objects.size());
 	return bounds;
 }
 
-
 void Container::Delete(Object * objectToDelete)
 {
 	std::vector<Object *>::iterator i = objects.begin();
@@ -304,7 +348,6 @@ void Container::Delete(Object * objectToDelete)
 	}
 }
 
-
 void Container::DeleteSelectedItems(void)
 {
 	std::vector<Object *>::iterator i = objects.begin();
@@ -321,7 +364,6 @@ void Container::DeleteSelectedItems(void)
 	}
 }
 
-
 void Container::Clear(void)
 {
 	std::vector<Object *>::iterator i = objects.begin();
@@ -334,21 +376,18 @@ printf("Container: Deleting object ($%X)...\n", *i);
 	}
 }
 
-
 void Container::SelectAll(void)
 {
 	for(unsigned int i=0; i<objects.size(); i++)
 		objects[i]->state = OSSelected;
 }
 
-
 void Container::DeselectAll(void)
 {
 	for(unsigned int i=0; i<objects.size(); i++)
 		objects[i]->state = OSInactive;
 }
 
-
 int Container::ItemsSelected(void)
 {
 	int selected = 0;
@@ -360,7 +399,6 @@ int Container::ItemsSelected(void)
 	return selected;
 }
 
-
 Object * Container::SelectedItem(unsigned int index)
 {
 	unsigned int selectedIndex = 0;
@@ -379,7 +417,6 @@ Object * Container::SelectedItem(unsigned int index)
 	return NULL;
 }
 
-
 void Container::MoveContentsTo(Container * newContainer)
 {
 	// Sanity check
@@ -387,7 +424,6 @@ void Container::MoveContentsTo(Container * newContainer)
 		return;
 
 	// Shuffle the contents of this container to the new one
-//	for(unsigned int i=0; i<objects.size(); i++)
 	for(std::vector<Object *>::iterator i=objects.begin(); i!=objects.end(); i++)
 	{
 		newContainer->Add(*i);
@@ -398,6 +434,16 @@ void Container::MoveContentsTo(Container * newContainer)
 	objects.clear();
 }
 
+void Container::CopyContentsTo(Container * newContainer)
+{
+	// Sanity check
+	if (newContainer == NULL)
+		return;
+
+	// Shuffle the contents of this container to the new one
+	for(std::vector<Object *>::iterator i=objects.begin(); i!=objects.end(); i++)
+		newContainer->Add((*i)->Copy());
+}
 
 void Container::MoveSelectedContentsTo(Container * newContainer)
 {
@@ -420,36 +466,105 @@ void Container::MoveSelectedContentsTo(Container * newContainer)
 	}
 }
 
+void Container::CopySelectedContentsTo(Container * newContainer)
+{
+	// Sanity check
+	if (newContainer == NULL)
+		return;
+
+	// Copy the contents of this container to the new one
+	for(std::vector<Object *>::iterator i=objects.begin(); i!=objects.end(); i++)
+	{
+		if ((*i)->state == OSSelected)
+			newContainer->Add((*i)->Copy());
+	}
+}
 
 void Container::ResizeAllDimensions(double newSize)
 {
 	for(std::vector<Object *>::iterator i=objects.begin(); i!=objects.end(); i++)
 	{
-//		Object * object = *i;
-
 		if ((*i)->type == OTDimension)
-//		if (object->type == OTDimension)
-		{
 			((Dimension *)(*i))->size = newSize;
-		}
 		if ((*i)->type == OTContainer)
-		{
 			((Container *)(*i))->ResizeAllDimensions(newSize);
-		}
 	}
 }
 
-
 /*virtual*/ void Container::Enumerate(FILE * file)
 {
 	// Only put "CONTAINER" markers if *not* the top level container
-	if (parent != NULL)
-		fprintf(file, "CONTAINER\n");
+//	if (parent != NULL)
+	if (!isTopLevelContainer)
+		fprintf(file, "CONTAINER %i\n", layer);
 
 	for(uint i=0; i<objects.size(); i++)
 		objects[i]->Enumerate(file);
 
-	if (parent != NULL)
+//	if (parent != NULL)
+	if (!isTopLevelContainer)
 		fprintf(file, "ENDCONTAINER\n");
 }
 
+/*virtual*/ Object * Container::Copy(void)
+{
+#warning "!!! This doesn't take care of attached Dimensions !!!"
+/*
+This is a real problem. While having a pointer in the Dimension to this line's points
+is fast & easy, it creates a huge problem when trying to replicate an object like this.
+
+Maybe a way to fix that then, is to have reference numbers instead of pointers. That
+way, if you copy them, ... you might still have problems. Because you can't be sure if
+a copy will be persistant or not, you then *definitely* do not want them to have the
+same reference number.
+*/
+	Container * c = new Container(position, parent);
+	*c = *this;
+	return c;
+}
+
+/*virtual*/ void Container::Rotate(Point point, double angle)
+{
+	for(std::vector<Object *>::iterator i=objects.begin(); i!=objects.end(); i++)
+		(*i)->Rotate(point, angle);
+}
+
+/*virtual*/ void Container::RotateSelected(Point point, double angle)
+{
+	for(std::vector<Object *>::iterator i=objects.begin(); i!=objects.end(); i++)
+	{
+		if ((*i)->state == OSSelected)
+			(*i)->Rotate(point, angle);
+	}
+}
+
+/*virtual*/ void Container::Mirror(Point p1, Point p2)
+{
+	for(std::vector<Object *>::iterator i=objects.begin(); i!=objects.end(); i++)
+		(*i)->Mirror(p1, p2);
+}
+
+/*virtual*/ void Container::MirrorSelected(Point p1, Point p2)
+{
+	for(std::vector<Object *>::iterator i=objects.begin(); i!=objects.end(); i++)
+	{
+		if ((*i)->state == OSSelected)
+			(*i)->Mirror(p1, p2);
+	}
+}
+
+/*virtual*/ void Container::Save(void)
+{
+	Object::Save();
+
+	for(std::vector<Object *>::iterator i=objects.begin(); i!=objects.end(); i++)
+		(*i)->Save();
+}
+
+/*virtual*/ void Container::Restore(void)
+{
+	Object::Restore();
+
+	for(std::vector<Object *>::iterator i=objects.begin(); i!=objects.end(); i++)
+		(*i)->Restore();
+}