qelectrotech-source-mirror/sources/editor/graphicspart/abstractpartellipse.cpp

/*
	Copyright 2006-2020 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;
	
	emit rectChanged();
}

/**
	@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;
	prepareGeometryChange();
	m_start_angle = start_angle;
	emit startAngleChanged();
}

/**
	@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;
	prepareGeometryChange();
	m_span_angle = span_angle;
	emit spanAngleChanged();
}