Various fixes to Container/Group handling, added DrawArcAction.

[architektonas] / src / container.cpp

diff --git a/src/container.cpp b/src/container.cpp
index 47295f40f043576fdcd24b9d37ef803af439918d..da491f617b8366ff71bacf1bba6b0ebda26a3bef 100644 (file)
--- 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;
 }
 
 
@@ -72,23 +74,20 @@ Container & Container::operator=(const Container & from)
        QRectF boundary;
 
        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
                (*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
@@ -163,7 +163,11 @@ printf("Container::Collided: Deleting object ($%X)\n", *i);
                state = (collision ? OSSelected : OSInactive);
 
                if (state == OSSelected)
+               {
                        DeselectAll();
+                       dragging = true;
+                       oldPoint = point;
+               }
        }
 
        return collision;
@@ -191,14 +195,62 @@ class so that we can leverage that stuff here as well.
 // 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);
        }
 
@@ -209,6 +261,12 @@ class so that we can leverage that stuff here as well.
 
 /*virtual*/ void Container::PointerReleased(void)
 {
+       if (!isTopLevelContainer)
+       {
+               dragging = false;
+               return;
+       }
+#if 0
        dragging = false;
        draggingHandle1 = false;
        draggingHandle2 = false;
@@ -216,20 +274,31 @@ 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
+       // 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++)
@@ -394,16 +463,30 @@ void Container::MoveSelectedContentsTo(Container * newContainer)
 }
 
 
+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");
 }