X-Git-Url: http://shamusworld.gotdns.org/cgi-bin/gitweb.cgi?a=blobdiff_plain;f=src%2Fcontainer.cpp;h=ced7326de4979b91e67d4d16dfe97694101d4837;hb=89b8b0c60579d8ef0cf9a13521e7bf7c7864883f;hp=bd37b7738610a1e4c54586699b2932cf57cec417;hpb=ef811c836c00cc94ce1eaea5c2e77e5278298b18;p=architektonas

diff --git a/src/container.cpp b/src/container.cpp
index bd37b77..ced7326 100644
--- a/src/container.cpp
+++ b/src/container.cpp
@@ -25,6 +25,7 @@ Container::Container(Vector p1, Object * p/*= NULL*/): Object(p1, p),
 	dragging(false), draggingHandle1(false), draggingHandle2(false)//, needUpdate(false)
 {
 	type = OTContainer;
+	state = OSInactive;
 }
 
 
@@ -34,6 +35,7 @@ Container::Container(const Container & copy): Object(copy.position, copy.parent)
 	// Use overloaded assignment operator
 	*this = copy;
 	type = OTContainer;
+	state = OSInactive;
 }
 
 
@@ -54,11 +56,18 @@ Container & Container::operator=(const Container & from)
 
 	// 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 this COPY constructor to be meaningful, we have to actually COPY the
+	// objects in this Container, not just MOVE a copy of the POINTER! D-:
+	std::vector<Object *>::const_iterator i;
+
+//	for(uint i=0; i<from.objects.size(); i++)
+	for(i=from.objects.begin(); i!=from.objects.end(); i++)
 	{
-		Object * object = from.objects[i];
+//		Object * object = from.objects[i];
+		Object * object = (*i)->Copy();
 
-		// Need to copy the object here...
+		// Need to actually COPY the object here, not copy the pointer only!!
+		// (which we do now, above :-P)
 
 		objects.push_back(object);
 	}
@@ -71,24 +80,23 @@ Container & Container::operator=(const Container & from)
 {
 	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);
 	}
 }
 
@@ -98,6 +106,7 @@ Container & Container::operator=(const Container & from)
 	return position;
 }
 
+
 /*
  We need at least *three* handles for this object:
  - one for moving
@@ -163,12 +172,28 @@ printf("Container::Collided: Deleting object ($%X)\n", *i);
 		state = (collision ? OSSelected : OSInactive);
 
 		if (state == OSSelected)
+		{
 			DeselectAll();
+			dragging = true;
+			oldPoint = point;
+		}
 	}
 
 	return collision;
 }
 
+/*
+What we need to do is check for whether or not we're a top level container,
+and override the passing of stuff into the objects held. So here, if we're *NOT*
+a top level container, instead of passing PointerMoved to our contained objects,
+we check to see if our bounds are met (for selection rectangle, e.g.).
+
+Also, for things like being able to split point's hot spots we need to be able
+to check for that crap in the top level container. Which means that objects can
+still know how to move themselves, but they can also defer to their container
+as well. Which also means that things like HitTest() need to be in the Object
+class so that we can leverage that stuff here as well.
+*/
 
 // The TLC is passing all mouse movement here, so we're doing the same here.
 // Need to adjust all other objects to handle things correctly.
@@ -179,14 +204,62 @@ printf("Container::Collided: Deleting object ($%X)\n", *i);
 // every object for collision.
 /*virtual*/ void Container::PointerMoved(Vector point)
 {
-//	objectWasDragged = true;
-//printf("CONTAINER: PointerMoved()\n");
+	std::vector<Object *>::iterator i;
+
+	if (!isTopLevelContainer)
+	{
+		// check for selection rectangle too
+		if (selectionInProgress)
+		{
+			if (selection.contains(Extents()))
+				state = OSSelected;
+			else
+				state = OSInactive;
+
+			return;
+		}
+
+		// No need to do any checking if we're already selected...
+//		if (state == OSSelected)
+//			return;
+
+//		oldState = state;
+//		needUpdate = true;
+//		if (dragging &&
+		bool oldHit = hit;
+		hit = false;
+
+		for(i=objects.begin(); i!=objects.end(); i++)
+		{
+			if ((*i)->HitTest(point))
+			{
+//				state = OSSelected;
+//				return;
+				hit = true;
+				break;
+			}
+		}
+
+		needUpdate = (oldHit != hit ? true : false);
+//		state = oldState;
+
+		if (dragging)
+		{
+			Vector delta = point - oldPoint;
+
+			for(i=objects.begin(); i!=objects.end(); i++)
+				(*i)->Translate(delta);
+
+			oldPoint = point;
+			needUpdate = true;
+		}
+
+		return;
+	}
 
 	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);
+//		if (objects[i]->GetState() == OSSelected)
 		(*i)->PointerMoved(point);
 	}
 
@@ -197,6 +270,12 @@ printf("Container::Collided: Deleting object ($%X)\n", *i);
 
 /*virtual*/ void Container::PointerReleased(void)
 {
+	if (!isTopLevelContainer)
+	{
+		dragging = false;
+		return;
+	}
+#if 0
 	dragging = false;
 	draggingHandle1 = false;
 	draggingHandle2 = false;
@@ -204,20 +283,31 @@ printf("Container::Collided: Deleting object ($%X)\n", *i);
 	// 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
+	// aggregate object.
+	if (!isTopLevelContainer)
+	{
+		return needUpdate;
+	}
+
 	// Search through objects for one that needs an update; if one is found,
 	// return immediately.
 	for(std::vector<Object *>::iterator i=objects.begin(); i!=objects.end(); i++)
@@ -237,6 +327,17 @@ printf("Container: Added object (=$%X). size = %li\n", object, objects.size());
 }
 
 
+/*virtual*/ QRectF Container::Extents(void)
+{
+	QRectF bounds;
+
+	for(std::vector<Object *>::iterator i=objects.begin(); i!=objects.end(); i++)
+		bounds = bounds.united((*i)->Extents());
+
+	return bounds;
+}
+
+
 void Container::Delete(Object * objectToDelete)
 {
 	std::vector<Object *>::iterator i = objects.begin();
@@ -337,8 +438,12 @@ 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++)
-		newContainer->Add(objects[i]);
+//	for(unsigned int i=0; i<objects.size(); i++)
+	for(std::vector<Object *>::iterator i=objects.begin(); i!=objects.end(); i++)
+	{
+		newContainer->Add(*i);
+		(*i)->Reparent(newContainer);
+	}
 
 	// & clear our vector
 	objects.clear();
@@ -361,21 +466,36 @@ void Container::MoveSelectedContentsTo(Container * newContainer)
 		}
 
 		newContainer->Add(*i);
+		(*i)->Reparent(newContainer);
 		objects.erase(i);
 	}
 }
 
 
+void Container::ResizeAllDimensions(double newSize)
+{
+	for(std::vector<Object *>::iterator i=objects.begin(); i!=objects.end(); i++)
+	{
+		if ((*i)->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)
+//	if (parent != NULL)
+	if (!isTopLevelContainer)
 		fprintf(file, "CONTAINER\n");
 
 	for(uint i=0; i<objects.size(); i++)
 		objects[i]->Enumerate(file);
 
-	if (parent != NULL)
+//	if (parent != NULL)
+	if (!isTopLevelContainer)
 		fprintf(file, "ENDCONTAINER\n");
 }