+
+// We want certain tools to be exclusive, and this approach isn't working correctly...
+void ApplicationWindow::DeleteTool(void)
+{
+ // For this tool, we check first to see if anything is selected. If so, we
+ // delete those and *don't* select the delete tool.
+ if (drawing->document.ItemsSelected() > 0)
+ {
+ drawing->document.DeleteSelectedItems();
+ drawing->update();
+ deleteAct->setChecked(false);
+ return;
+ }
+
+ // Otherwise, toggle the state of the tool
+ ClearUIToolStatesExcept(deleteAct);
+ SetInternalToolStates();
+}
+
+
+void ApplicationWindow::DimensionTool(void)
+{
+ ClearUIToolStatesExcept(addDimensionAct);
+ SetInternalToolStates();
+}
+
+
+void ApplicationWindow::RotateTool(void)
+{
+ ClearUIToolStatesExcept(rotateAct);
+ SetInternalToolStates();
+}
+
+
+void ApplicationWindow::AddLineTool(void)
+{
+ ClearUIToolStatesExcept(addLineAct);
+ SetInternalToolStates();
+}
+
+
+void ApplicationWindow::AddCircleTool(void)
+{
+ ClearUIToolStatesExcept(addCircleAct);
+ SetInternalToolStates();
+}
+
+
+void ApplicationWindow::AddArcTool(void)
+{
+ ClearUIToolStatesExcept(addArcAct);
+ SetInternalToolStates();
+}
+
+
+void ApplicationWindow::AddPolygonTool(void)
+{
+ ClearUIToolStatesExcept(addPolygonAct);
+ SetInternalToolStates();
+}
+
+
+void ApplicationWindow::ZoomInTool(void)
+{
+ double zoomFactor = 2.0;
+/*
+We need to find the center of the screen, then figure out where the new corner
+will be in the zoomed in window.
+
+So we know in Qt coords, the center is found via:
+size.width() / 2 --> xCenter
+size.height() / 2 --> yCenter
+
+transform x/yCenter to Cartesian coordinates. So far, so good.
+
+when zooming in, new origin will be (xCenter - origin.x) / 2, (yCenter - origin.y) / 2
+(after subtracting from center, that is...)
+*/
+ QSize size = drawing->size();
+ Vector center(size.width() / 2.0, size.height() / 2.0);
+//printf("Zoom in... Center=%.2f,%.2f; ", center.x, center.y);
+ center = Painter::QtToCartesianCoords(center);
+//printf("(%.2f,%.2f); origin=%.2f,%.2f; ", center.x, center.y, Painter::origin.x, Painter::origin.y);
+ Vector newOrigin = center - ((center - Painter::origin) / zoomFactor);
+//printf("newOrigin=%.2f,%.2f;\n", newOrigin.x, newOrigin.y);
+ Painter::origin = newOrigin;
+
+//printf("Zoom in... level going from %02f to ", Painter::zoom);
+ // This just zooms leaving origin intact... should zoom in at the current center! [DONE]
+ // This should actually be calculated by drawing->gridPixels / grid size.
+ Painter::zoom *= zoomFactor;
+ drawing->gridSpacing = 12.0 / Painter::zoom;
+// zoomIndicator->setText(QString("Grid: %2\" Zoom: %1%").arg(Painter::zoom * 100.0 * SCREEN_ZOOM).arg(drawing->gridSpacing));
+ zoomIndicator->setText(QString("Grid: %1\", BU: Inch").arg(drawing->gridSpacing));
+ drawing->UpdateGridBackground();
+ drawing->update();
+}
+
+
+void ApplicationWindow::ZoomOutTool(void)
+{
+/*
+Ok, real example.
+center = (436, 311)
+origin = (223, 160.5)
+newOrigin should be (-10, -10)
+Why isn't it?
+
+center - origin = (213, 150.5)
+origin - center = (-213, -150.5)
+x 2 = (-426, -301)
++ center = (-10, -10)
+
+*/
+ double zoomFactor = 2.0;
+ QSize size = drawing->size();
+ Vector center(size.width() / 2.0, size.height() / 2.0);
+//printf("Zoom out... Center=%.2f,%.2f; ", center.x, center.y);
+ center = Painter::QtToCartesianCoords(center);
+//printf("(%.2f,%.2f); origin=%.2f,%.2f; ", center.x, center.y, Painter::origin.x, Painter::origin.y);
+// Vector newOrigin = (center - Painter::origin) * zoomFactor;
+// Vector newOrigin = center - (Painter::origin * zoomFactor);
+ Vector newOrigin = center + ((Painter::origin - center) * zoomFactor);
+//printf("newOrigin=%.2f,%.2f;\n", newOrigin.x, newOrigin.y);
+ Painter::origin = newOrigin;
+//printf("Zoom out...\n");
+ // This just zooms leaving origin intact... should zoom out at the current center! [DONE]
+ Painter::zoom /= zoomFactor;
+ drawing->gridSpacing = 12.0 / Painter::zoom;
+// zoomIndicator->setText(QString("Grid: %2\" Zoom: %1%").arg(Painter::zoom * 100.0 * SCREEN_ZOOM).arg(drawing->gridSpacing));
+ zoomIndicator->setText(QString("Grid: %1\", BU: Inch").arg(drawing->gridSpacing));
+ drawing->UpdateGridBackground();
+ drawing->update();
+}
+
+
+void ApplicationWindow::ClearUIToolStatesExcept(QAction * exception)
+{
+ if (exception != addArcAct)
+ addArcAct->setChecked(false);
+
+ if (exception != addCircleAct)
+ addCircleAct->setChecked(false);
+
+ if (exception != addDimensionAct)
+ addDimensionAct->setChecked(false);
+
+ if (exception != addLineAct)
+ addLineAct->setChecked(false);
+
+ if (exception != addPolygonAct)
+ addPolygonAct->setChecked(false);
+
+ if (exception != deleteAct)
+ deleteAct->setChecked(false);
+
+ if (exception != rotateAct)
+ rotateAct->setChecked(false);
+}
+
+
+void ApplicationWindow::SetInternalToolStates(void)
+{
+ Object::SetDeleteActive(deleteAct->isChecked());
+ Object::SetDimensionActive(addDimensionAct->isChecked());
+ drawing->SetRotateToolActive(rotateAct->isChecked());
+
+ // We can be sure that if we've come here, then either an active tool is
+ // being deactivated, or a new tool is being created. In either case, the
+ // old tool needs to be deleted.
+ if (drawing->toolAction)
+ {
+ delete drawing->toolAction;
+ drawing->toolAction = NULL;
+ }
+
+ drawing->SetAddLineToolActive(addLineAct->isChecked());
+ drawing->SetAddCircleToolActive(addCircleAct->isChecked());
+ drawing->SetAddDimensionToolActive(addDimensionAct->isChecked());
+}
+
+
+void ApplicationWindow::HelpAbout(void)
+{
+ aboutWin->show();
+}
+
+
+void ApplicationWindow::Settings(void)
+{
+ SettingsDialog dlg(this);
+ dlg.generalTab->antialiasChk->setChecked(drawing->useAntialiasing);
+
+ if (dlg.exec() == false)
+ return;
+
+ // Deal with stuff here (since user hit "OK" button...)
+ drawing->useAntialiasing = dlg.generalTab->antialiasChk->isChecked();
+ WriteSettings();
+}
+
+
+//
+// Group a bunch of selected objects (which can include other groups) together
+// or ungroup a selected group.
+//
+void ApplicationWindow::HandleGrouping(void)
+{
+ int itemsSelected = drawing->document.ItemsSelected();
+
+ // If nothing selected, do nothing
+ if (itemsSelected == 0)
+ {
+ statusBar()->showMessage(tr("No objects selected to make a group from."));
+ return;
+ }
+
+ // If it's a group that's selected, ungroup it and leave the objects in a
+ // selected state
+ if (itemsSelected == 1)
+ {
+ Object * object = drawing->document.SelectedItem(0);
+
+#if 0
+if (object == NULL)
+ printf("SelectedItem = NULL!\n");
+else
+ printf("SelectedItem = %08X, type = %i\n", object, object->type);
+#endif
+
+ if (object == NULL || object->type != OTContainer)
+ {
+ statusBar()->showMessage(tr("A group requires two or more selected objects."));
+ return;
+ }
+
+ // Need the parent of the group, we're assuming here that the parent is
+ // the drawing's document. Does it matter? Maybe...
+ // Could just stipulate that grouping like this only takes place where the
+ // parent of the group is the drawing's document. Makes life much simpler.
+ ((Container *)object)->SelectAll();
+ ((Container *)object)->MoveContentsTo(&(drawing->document));
+ drawing->document.Delete(object);
+ statusBar()->showMessage(tr("Objects ungrouped."));
+ }
+ // Otherwise, if it's a group of 2 or more objects (which can be groups too)
+ // group them and select the group
+ else if (itemsSelected > 1)
+ {
+ Container * container = new Container(Vector(), &(drawing->document));
+ drawing->document.MoveSelectedContentsTo(container);
+ drawing->document.Add(container);
+ container->DeselectAll();
+ container->state = OSSelected;
+ statusBar()->showMessage(QString(tr("Grouped %1 objects.")).arg(itemsSelected));
+ }
+
+ drawing->update();
+}
+
+
+void ApplicationWindow::HandleGridSizeInPixels(int size)
+{
+ drawing->SetGridSize(size);
+ drawing->update();
+}
+
+