Element editor : hover a primitve will highlight it with a blue halo

git-svn-id: svn+ssh://svn.tuxfamily.org/svnroot/qet/qet/trunk@3694 bfdf4180-ca20-0410-9c96-a3a8aa849046

sources/editor/graphicspart/abstractpartellipse.cpp

@@ -0,0 +1,229 @@
+/*
+	Copyright 2006-2015 The QElectroTech Team
+	This file is part of QElectroTech.
+
+	QElectroTech is free software: you can redistribute it and/or modify
+	it under the terms of the GNU General Public License as published by
+	the Free Software Foundation, either version 2 of the License, or
+	(at your option) any later version.
+
+	QElectroTech is distributed in the hope that it will be useful,
+	but WITHOUT ANY WARRANTY; without even the implied warranty of
+	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+	GNU General Public License for more details.
+
+	You should have received a copy of the GNU General Public License
+	along with QElectroTech.  If not, see <http://www.gnu.org/licenses/>.
+*/
+#include "abstractpartellipse.h"
+
+/**
+ * @brief AbstractPartEllipse::AbstractPartEllipse
+ * Constructor
+ * @param editor : QETElementEditor of this part
+ * @param parent : parent item
+ */
+AbstractPartEllipse::AbstractPartEllipse(QETElementEditor *editor, QGraphicsItem *parent) :
+	CustomElementGraphicPart(editor, parent),
+	m_rect                  (QRectF(0, 0, 0, 0)),
+	m_start_angle           (0),
+	m_span_angle            (5760)
+{}
+
+/**
+ * @brief AbstractPartEllipse::~AbstractPartEllipse
+ * Destructor
+ */
+AbstractPartEllipse::~AbstractPartEllipse() {}
+
+/**
+ * @brief AbstractPartEllipse::startUserTransformation
+ * Start the user-induced transformation, provided this primitive is contained
+ * within the initial_selection_rect bounding rectangle.
+ * @param initial_selection_rect
+ */
+void AbstractPartEllipse::startUserTransformation(const QRectF &initial_selection_rect)
+{
+	Q_UNUSED(initial_selection_rect)
+		// we keep track of our own rectangle at the moment in scene coordinates too
+	saved_points_.clear();
+	saved_points_ << mapToScene(rect().topLeft()) << mapToScene(rect().bottomRight());
+}
+
+/**
+ * @brief AbstractPartEllipse::handleUserTransformation
+ * Handle the user-induced transformation from \a initial_selection_rect to \a new_selection_rect
+ * @param initial_selection_rect
+ * @param new_selection_rect
+ */
+void AbstractPartEllipse::handleUserTransformation(const QRectF &initial_selection_rect, const QRectF &new_selection_rect)
+{
+	QList<QPointF> mapped_points = mapPoints(initial_selection_rect, new_selection_rect, saved_points_);
+	setRect(QRectF(mapFromScene(mapped_points.at(0)), mapFromScene(mapped_points.at(1))));
+}
+
+/**
+ * @brief AbstractPartEllipse::boundingRect
+ * Bounding rectangle this part can fit into
+ * @return
+ */
+QRectF AbstractPartEllipse::boundingRect() const
+{
+	qreal adjust = (SHADOWS_HEIGHT + penWeight()) / 2;
+		//We add 0.5 because CustomElementGraphicPart::drawShadowShape
+		//draw a shape bigger of 0.5 when pen weight is to 0.
+	if (penWeight() == 0) adjust += 0.5;
+	QRectF r(m_rect.normalized());
+	r.adjust(-adjust, -adjust, adjust, adjust);
+	return(r);
+}
+
+/**
+ * @brief AbstractPartEllipse::sceneGeometricRect
+ * @return the minimum, margin-less rectangle this part can fit into in scene coordinates.
+ * It is different from boundingRect() because it is not supposed
+ * to imply any margin, and it is different from shape because it is a regular
+ * rectangle, not a complex shape.
+ */
+QRectF AbstractPartEllipse::sceneGeometricRect() const {
+	return(mapToScene(rect()).boundingRect());
+}
+
+/**
+ * @brief AbstractPartEllipse::sceneTopLeft
+ * @return return the top left of rectangle, in scene coordinate
+ */
+QPointF AbstractPartEllipse::sceneTopLeft() const {
+	return(mapToScene(rect().topLeft()));
+}
+
+/**
+ * @brief AbstractPartEllipse::rect
+ * Returns the item's ellipse geometry as a QRectF.
+ */
+QRectF AbstractPartEllipse::rect() const {
+	return m_rect;
+}
+
+/**
+ * @brief AbstractPartEllipse::setRect
+ * Sets the item's ellipse geometry to rect.
+ * The rectangle's left edge defines the left edge of the ellipse,
+ * and the rectangle's top edge describes the top of the ellipse
+ * The height and width of the rectangle describe the height and width of the ellipse.
+ * @param rect
+ */
+void AbstractPartEllipse::setRect(const QRectF &rect)
+{
+	if (rect == m_rect) return;
+	prepareGeometryChange();
+	m_rect = rect;
+}
+
+/**
+ * @brief AbstractPartEllipse::isUseless
+ * @return true if this part is irrelevant and does not deserve to be Retained / registered.
+ * An ellipse is relevant when is rect is not null.
+ */
+bool AbstractPartEllipse::isUseless() const {
+	return(rect().isNull());
+}
+
+/**
+ * @brief AbstractPartEllipse::setStartAngle
+ * Sets the start angle for an ellipse segment to angle, which is in 16ths of a degree.
+ * This angle is used together with spanAngle() for representing an ellipse segment (a pie).
+ * By default, the start angle is 0.
+ * @param start_angle
+ */
+void AbstractPartEllipse::setStartAngle(const int &start_angle)
+{
+	if (m_start_angle == start_angle) return;
+	m_start_angle = start_angle;
+	update();
+}
+
+/**
+ * @brief AbstractPartEllipse::setSpanAngle
+ * Returns the span angle of an ellipse segment in 16ths of a degree.
+ * This angle is used together with startAngle() for representing an ellipse segment (a pie).
+ * By default, this function returns 5760 (360 * 16, a full ellipse).
+ * @param span_angle
+ */
+void AbstractPartEllipse::setSpanAngle(const int &span_angle)
+{
+	if (m_span_angle == span_angle) return;
+	m_span_angle = span_angle;
+	update();
+}
+
+/**
+ * @brief AbstractPartEllipse::setCenterX
+ * Like setCenter but Y keep unchanged
+ * See setCenter(const QPointF &center)
+ * @param x
+ */
+void AbstractPartEllipse::setCenterX(const qreal x)
+{
+	QPointF pos = mapToParent(m_rect.center());
+	pos.setX(x);
+	setCenter(pos);
+}
+
+/**
+ * @brief AbstractPartEllipse::setCenterY
+ * Like setCenter but X keep unchanged
+ * See setCenter(const QPointF &center)
+ * @param y
+ */
+void AbstractPartEllipse::setCenterY(const qreal y)
+{
+	QPointF pos = mapToParent(m_rect.center());
+	pos.setY(y);
+	setCenter(pos);
+}
+
+/**
+ * @brief AbstractPartEllipse::setCenter
+ * This is a convenience method to setPos().
+ * Adjust the position of this item,
+ * so that the center of the rectangle is at the given position(position in parent coordinates).
+ * @param center
+ */
+void AbstractPartEllipse::setCenter(const QPointF &center)
+{
+	QPointF pos = center - m_rect.center();
+	setPos(pos);
+}
+
+/**
+ * @brief AbstractPartEllipse::setWidth
+ * Set new width for rectangle.
+ * The center of rectangle is unchanged,
+ * The coordinates of the left side and right side of the rectangle change
+ * @param w
+ */
+void AbstractPartEllipse::setWidth(const qreal w)
+{
+	qreal new_width = qAbs(w);
+	QRectF current_rect = rect();
+	current_rect.translate((new_width - current_rect.width()) / -2.0, 0.0);
+	current_rect.setWidth(new_width);
+	setRect(current_rect);
+}
+
+/**
+ * @brief AbstractPartEllipse::setHeight
+ * Set new height for rectangle
+ * The center of rectangle is unchanged
+ * The coordinates of the top side and bottom side of the rectangle change
+ * @param h
+ */
+void AbstractPartEllipse::setHeight(const qreal h)
+{
+	qreal new_height = qAbs(h);
+	QRectF current_rect = rect();
+	current_rect.translate(0.0, (new_height - current_rect.height()) / -2.0);
+	current_rect.setHeight(new_height);
+	setRect(current_rect);
+}