X-Git-Url: http://shamusworld.gotdns.org/cgi-bin/gitweb.cgi?a=blobdiff_plain;f=src%2Fcontainer.cpp;h=9cda1fa38b95e6c10d1af0659326a69af61c5501;hb=4d6ba8a6eb781dbee818b6a55d21df7b52468936;hp=bd37b7738610a1e4c54586699b2932cf57cec417;hpb=ef811c836c00cc94ce1eaea5c2e77e5278298b18;p=architektonas diff --git a/src/container.cpp b/src/container.cpp index bd37b77..9cda1fa 100644 --- a/src/container.cpp +++ b/src/container.cpp @@ -22,9 +22,11 @@ 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; } @@ -34,6 +36,7 @@ Container::Container(const Container & copy): Object(copy.position, copy.parent) // Use overloaded assignment operator *this = copy; type = OTContainer; + state = OSInactive; } @@ -51,15 +54,12 @@ Container & Container::operator=(const Container & from) return *this; Clear(); + std::vector::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; iCopy(); objects.push_back(object); } @@ -71,24 +71,23 @@ Container & Container::operator=(const Container & from) { QRectF boundary; +//int a=1; for(std::vector::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 +97,7 @@ Container & Container::operator=(const Container & from) return position; } + /* We need at least *three* handles for this object: - one for moving @@ -123,12 +123,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::iterator i=objects.begin(); i!=objects.end();) @@ -149,10 +150,17 @@ printf("Container::Collided: Deleting object ($%X)\n", *i); for(std::vector::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,12 +171,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 +203,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::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::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 +269,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 +282,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::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::iterator i=objects.begin(); i!=objects.end(); i++) @@ -237,6 +326,17 @@ printf("Container: Added object (=$%X). size = %li\n", object, objects.size()); } +/*virtual*/ QRectF Container::Extents(void) +{ + QRectF bounds; + + for(std::vector::iterator i=objects.begin(); i!=objects.end(); i++) + bounds = bounds.united((*i)->Extents()); + + return bounds; +} + + void Container::Delete(Object * objectToDelete) { std::vector::iterator i = objects.begin(); @@ -337,14 +437,29 @@ void Container::MoveContentsTo(Container * newContainer) return; // Shuffle the contents of this container to the new one - for(unsigned int i=0; iAdd(objects[i]); + for(std::vector::iterator i=objects.begin(); i!=objects.end(); i++) + { + newContainer->Add(*i); + (*i)->Reparent(newContainer); + } // & clear our vector 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::iterator i=objects.begin(); i!=objects.end(); i++) + newContainer->Add((*i)->Copy()); +} + + void Container::MoveSelectedContentsTo(Container * newContainer) { // Sanity check @@ -361,21 +476,121 @@ void Container::MoveSelectedContentsTo(Container * newContainer) } newContainer->Add(*i); + (*i)->Reparent(newContainer); objects.erase(i); } } +void Container::CopySelectedContentsTo(Container * newContainer) +{ + // Sanity check + if (newContainer == NULL) + return; + + // Copy the contents of this container to the new one + for(std::vector::iterator i=objects.begin(); i!=objects.end(); i++) + { + if ((*i)->state == OSSelected) + newContainer->Add((*i)->Copy()); + } +} + + +void Container::ResizeAllDimensions(double newSize) +{ + for(std::vector::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) - fprintf(file, "CONTAINER\n"); +// if (parent != NULL) + if (!isTopLevelContainer) + fprintf(file, "CONTAINER %i\n", layer); for(uint i=0; iEnumerate(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::iterator i=objects.begin(); i!=objects.end(); i++) + (*i)->Rotate(point, angle); +} + + +/*virtual*/ void Container::RotateSelected(Point point, double angle) +{ + for(std::vector::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::iterator i=objects.begin(); i!=objects.end(); i++) + (*i)->Mirror(p1, p2); +} + + +/*virtual*/ void Container::MirrorSelected(Point p1, Point p2) +{ + for(std::vector::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::iterator i=objects.begin(); i!=objects.end(); i++) + (*i)->Save(); +} + + +/*virtual*/ void Container::Restore(void) +{ + Object::Restore(); + + for(std::vector::iterator i=objects.begin(); i!=objects.end(); i++) + (*i)->Restore(); +} +