void TileScene::drawBackground(QPainter *painter, const QRectF &exposed)
{
// Draws all tiles that intersect the exposed area.
for (int y = 0; y < numTilesV; ++y) {
for (int x = 0; x < numTilesH; ++x) {
QRectF rect = rectForTile(x, y);
if (exposed.intersects(rect))
painter->drawPixmap(rect.topLeft(), tiles[y][x]);
}
}
}
/*!
Run the snap algorithm to with the position of moving rect, to get a snap result.
*/
HsWidgetPositioningOnWidgetMove::Result HsSnapToLines::run(const QRectF &movingRect)
{
HsWidgetPositioningOnWidgetMove::Result result;
if (mSnapEnabled) {
mMovingRect = movingRect;
mHorizontalSnapPosition = 0.0;
mVerticalSnapPosition = 0.0;
mVerticalLine = QLineF();
mMinVerticalEdgesDistance = mSnapForce;
mVerticalDistanceFromSelectedRect = 0.0;
mContainerVerticalEdgeDistance = 0.0;
mHorizontalSnapFound = false;
mHorizontalLine = QLineF();
mMinHorizontalEdgesDistance = mSnapForce;
mHorizontalDistanceFromSelectedRect = 0.0;
mContainerHorizontalEdgeDistance = 0.0;
mVerticalSnapFound = false;
for (int i = 0; i < mInactiveSnapRects.count(); ++i) {
mInactiveSnapRectToCompare = mInactiveSnapRects[i];
mInactiveRectToCompare = mInactiveSnapRectToCompare.rectangle;
if (!movingRect.intersects(mInactiveRectToCompare)) { //Only compare if Inactive Rect and moving rect do not overlap.
// Horizontal - Direction Snapping
compareLeftSideOfMovingRectForSnapping();
compareRightSideOfMovingRectForSnapping();
// Vertical - Direction Snapping
compareTopOfMovingRectForSnapping();
compareBottomOfMovingRectForSnapping();
}
}
if (mHorizontalSnapFound) {
result.hasHorizontalSnap = true;
result.horizontalSnapPosition = mHorizontalSnapPosition;
extendVerticalLine();
result.verticalSnapLine = mVerticalLine;
}
if (mVerticalSnapFound) {
result.hasVerticalSnap = true;
result.verticalSnapPosition = mVerticalSnapPosition;
extendHorizontalLine();
result.horizontalSnapLine = mHorizontalLine;
}
}
return result;
}
bool AbstractItemContainer::itemVisibleInView(AbstractViewItem* item, const QRectF &viewRect, bool fullyVisible) const
{
if (!item || !m_itemView)
return false;
QRectF itemRectBoundingRect = item->mapToItem(m_itemView, item->boundingRect()).boundingRect();
if (fullyVisible && viewRect.contains(itemRectBoundingRect))
return true;
else if (viewRect.intersects(itemRectBoundingRect))
return true;
return false;
}
void CanvasView::drawForeground(QPainter *painter, const QRectF& rect)
{
if(_enableoutline && _showoutline && _outlinesize>1 && !_locked) {
const QRectF outline(_prevpoint-QPointF(_outlinesize,_outlinesize),
QSizeF(_dia, _dia));
if(rect.intersects(outline)) {
painter->save();
QPen pen(Qt::white);
pen.setCosmetic(true);
painter->setPen(pen);
painter->setCompositionMode(QPainter::CompositionMode_Difference);
painter->drawEllipse(outline);
painter->restore();
}
}
}
void QGraphVizPIP::drawBackground(QPainter *painter, const QRectF &rect)
{
if(!rect.intersects(scene()->sceneRect())) {
return;
}
QPen borderPen;
borderPen.setColor(Qt::black);
painter->setPen(borderPen);
QRectF border = QRectF(mapToScene(1.0, 1.0),
mapToScene(width()-2.0, height()-2.0));
painter->drawRect(border);
}
/*!
Create the list of rects and flag if their sides are snappable from top or bottom or left or right,
depending on other rects overlapping with the rect.
*/
void HsSnapToLines::createSnappableRectangles(const QList<QRectF> &inactiveRects)
{
mInactiveSnapRects.clear();
int i;
for (i = 0; i<inactiveRects.count(); ++i) {
QRectF rect = inactiveRects[i];
HsSnapRectangle snapRectangle(rect);
int j;
for (j = 0; j<inactiveRects.count(); ++j) {
QRectF rectToCompare = inactiveRects[j];
if (rect != rectToCompare) {
//Check if the rectangles being compared intersect each other
if (rectToCompare.intersects(rect)) {
//As the widgets intersect, check which corner is contained,
//The corner that is contained is not snappable, when the moving widget is in the same position
if (rectToCompare.contains(rect.topLeft())) {
snapRectangle.isLeftSnapableForAbove = false;
snapRectangle.isTopSnapableForLeft = false;
}
if (rectToCompare.contains(rect.topRight())) {
snapRectangle.isRightSnapableForAbove = false;
snapRectangle.isTopSnapableForRight = false;
}
if (rectToCompare.contains(rect.bottomRight())) {
snapRectangle.isRightSnapableForBelow = false;
snapRectangle.isBottomSnapableForRight = false;
}
if (rectToCompare.contains(rect.bottomLeft())) {
snapRectangle.isLeftSnapableForBelow = false;
snapRectangle.isBottomSnapableForLeft = false;
}
}
}
}
if (snapRectangle.isLeftSnapableForAbove || snapRectangle.isLeftSnapableForBelow ||
snapRectangle.isRightSnapableForAbove || snapRectangle.isRightSnapableForBelow ||
snapRectangle.isTopSnapableForLeft || snapRectangle.isTopSnapableForRight ||
snapRectangle.isBottomSnapableForLeft || snapRectangle.isBottomSnapableForRight) {
mInactiveSnapRects.append(snapRectangle);
}
}
}
bool intersect(const QGraphicsItem *item, const QRectF &exposeRect, Qt::ItemSelectionMode mode,
const QTransform &deviceTransform) const
{
QRectF brect = item->boundingRect();
_q_adjustRect(&brect);
// ### Add test for this (without making things slower?)
Q_UNUSED(exposeRect);
bool keep = true;
const QGraphicsItemPrivate *itemd = QGraphicsItemPrivate::get(item);
if (itemd->itemIsUntransformable()) {
// Untransformable items; map the scene rect to item coordinates.
const QTransform transform = item->deviceTransform(deviceTransform);
QRectF itemRect = (deviceTransform * transform.inverted()).mapRect(sceneRect);
if (mode == Qt::ContainsItemShape || mode == Qt::ContainsItemBoundingRect)
keep = itemRect.contains(brect) && itemRect != brect;
else
keep = itemRect.intersects(brect);
if (keep && (mode == Qt::ContainsItemShape || mode == Qt::IntersectsItemShape)) {
QPainterPath itemPath;
itemPath.addRect(itemRect);
keep = QGraphicsSceneIndexPrivate::itemCollidesWithPath(item, itemPath, mode);
}
} else {
Q_ASSERT(!itemd->dirtySceneTransform);
const QRectF itemSceneBoundingRect = itemd->sceneTransformTranslateOnly
? brect.translated(itemd->sceneTransform.dx(),
itemd->sceneTransform.dy())
: itemd->sceneTransform.mapRect(brect);
if (mode == Qt::ContainsItemShape || mode == Qt::ContainsItemBoundingRect)
keep = sceneRect != brect && sceneRect.contains(itemSceneBoundingRect);
else
keep = sceneRect.intersects(itemSceneBoundingRect);
if (keep && (mode == Qt::ContainsItemShape || mode == Qt::IntersectsItemShape)) {
QPainterPath rectPath;
rectPath.addRect(sceneRect);
if (itemd->sceneTransformTranslateOnly)
rectPath.translate(-itemd->sceneTransform.dx(), -itemd->sceneTransform.dy());
else
rectPath = itemd->sceneTransform.inverted().map(rectPath);
keep = QGraphicsSceneIndexPrivate::itemCollidesWithPath(item, rectPath, mode);
}
}
return keep;
}
void Window::mouseReleaseEvent(QGraphicsSceneMouseEvent *event)
{
QGraphicsObject::mouseReleaseEvent(event);
const QGraphicsScene *const currentScene = scene();
if (currentScene) {
QRectF currentSceneRect = currentScene->sceneRect();
QRectF windowRect = sceneBoundingRect();
//防止窗口移出当前scene
if (!currentSceneRect.intersects(windowRect)) {
setPos(m_windowLastPos);
}
else {
m_windowLastPos = pos();
}
}
}
void WidgetStyle::distinguishRect(const QRectF& rect)
{
m_deleteGraphicsWgt_.clear();
for(GraphicsWidget* wgt : m_scene->getItemWidget())
{
if(rect.intersects(wgt->boundingRectToScene()))
{
wgt->selectWidget(true);
m_deleteGraphicsWgt_.push_back(wgt);
}
else
{
auto iter = qFind(m_deleteGraphicsWgt_.begin(), m_deleteGraphicsWgt_.end(), wgt);
if(iter != m_deleteGraphicsWgt_.end())
m_deleteGraphicsWgt_.erase(iter);
wgt->selectWidget(false);
}
}
}
void EditorView::drawForeground(QPainter *painter, const QRectF& rect)
{
if(enableoutline_ && showoutline_ && outlinesize_>1) {
const QRectF outline(prevpoint_-QPointF(outlinesize_,outlinesize_),
QSizeF(dia_, dia_));
if(rect.intersects(outline)) {
//painter->setClipRect(0,0,board_->width(),board_->height()); // default
//painter->setClipRect(outline.adjusted(-7, -7, 7, 7)); // smaller clipping
//painter->setRenderHint(QPainter::Antialiasing, true); // default
QPen pen(background_);
painter->setPen(pen);
painter->drawEllipse(outline);
pen.setColor(foreground_);
pen.setStyle(Qt::DashLine);
painter->setPen(pen);
painter->drawEllipse(outline);
}
}
}
void PannerView::drawForeground(QPainter * p, const QRectF & rect )
{
if (m_zoomRect.isValid() && rect.intersects(m_zoomRect))
{
p->save();
if (m_zoomRect.width() > 10 && m_zoomRect.height() > 10)
{
p->setPen(Qt::red);
// substract pen width, i.e. draw inside
qreal penWidth = p->pen().widthF();
p->drawRect(m_zoomRect.adjusted(-penWidth, -penWidth, -penWidth, -penWidth));
}
else
{
QBrush brush(Qt::red);
p->fillRect(m_zoomRect, brush);
}
p->restore();
}
}
static bool intersect_point(const QGraphicsItem *item, const QRectF &exposeRect, Qt::ItemSelectionMode mode,
const QTransform &deviceTransform, const void *intersectData)
{
const QPointF scenePoint = *static_cast<const QPointF *>(intersectData);
QRectF brect = item->boundingRect();
_q_adjustRect(&brect);
// ### Add test for this (without making things slower?)
Q_UNUSED(exposeRect);
bool keep = false;
const QGraphicsItemPrivate *itemd = QGraphicsItemPrivate::get(item);
if (itemd->itemIsUntransformable()) {
// Untransformable items; map the scene point to item coordinates.
const QTransform transform = item->deviceTransform(deviceTransform);
QPointF itemPoint = (deviceTransform * transform.inverted()).map(scenePoint);
keep = brect.contains(itemPoint);
if (keep && (mode == Qt::ContainsItemShape || mode == Qt::IntersectsItemShape)) {
QPainterPath pointPath;
pointPath.addRect(QRectF(itemPoint, QSizeF(1, 1)));
keep = QGraphicsSceneIndexPrivate::itemCollidesWithPath(item, pointPath, mode);
}
} else {
Q_ASSERT(!itemd->dirtySceneTransform);
QRectF sceneBoundingRect = itemd->sceneTransformTranslateOnly
? brect.translated(itemd->sceneTransform.dx(),
itemd->sceneTransform.dy())
: itemd->sceneTransform.mapRect(brect);
keep = sceneBoundingRect.intersects(QRectF(scenePoint, QSizeF(1, 1)));
if (keep && (mode == Qt::ContainsItemShape || mode == Qt::IntersectsItemShape)) {
QPointF p = itemd->sceneTransformTranslateOnly
? QPointF(scenePoint.x() - itemd->sceneTransform.dx(),
scenePoint.y() - itemd->sceneTransform.dy())
: itemd->sceneTransform.inverted().map(scenePoint);
keep = item->contains(p);
}
}
return keep;
}
void KWCanvasBase::clipToDocument(const KoShape *shape, QPointF &move) const
{
Q_ASSERT(shape);
const QPointF absPos = shape->absolutePosition();
const QPointF destination = absPos + move;
qreal bottomOfPage = 0.0;
KWPage page;
foreach (const KWPage &p, m_document->pageManager()->pages()) {
bottomOfPage += p.height();
if (bottomOfPage >= absPos.y())
page = p;
if (bottomOfPage >= destination.y()) {
page = p;
break;
}
}
if (!page.isValid()) { // shape was not in any page to begin with, can't propose anything sane...
move.setX(0);
move.setY(0);
return;
}
QRectF pageRect(page.rect().adjusted(5, 5, -5, -5));
QPainterPath path(shape->absoluteTransformation(0).map(shape->outline()));
QRectF shapeBounds = path.boundingRect();
shapeBounds.moveTopLeft(shapeBounds.topLeft() + move);
if (!shapeBounds.intersects(pageRect)) {
if (shapeBounds.left() > pageRect.right()) // need to move to the left some
move.setX(move.x() + (pageRect.right() - shapeBounds.left()));
else if (shapeBounds.right() < pageRect.left()) // need to move to the right some
move.setX(move.x() + pageRect.left() - shapeBounds.right());
if (shapeBounds.top() > pageRect.bottom()) // need to move up some
move.setY(move.y() + (pageRect.bottom() - shapeBounds.top()));
else if (shapeBounds.bottom() < pageRect.top()) // need to move down some
move.setY(move.y() + pageRect.top() - shapeBounds.bottom());
}
// Also make sure any anchoring restrictions are adhered to
KWFrameLayout::proposeShapeMove(shape, move, page);
}
void Menu::moveVertically()
{
QList<QGraphicsItem *> items = this->items();
int sizeList = items.size();
QGraphicsItem * focusItem = this->focusItem();
QList<QGraphicsItem *>::const_iterator it = items.begin();
QList<QGraphicsItem *>::const_iterator tmpIt = it;
int index = items.indexOf(focusItem);
++index;
QRectF currentRectF = focusItem->boundingRect();
currentRectF.setHeight(this->getGeometry().height());
currentRectF.setWidth(currentRectF.width());
currentRectF.setX(currentRectF.x());
currentRectF.setY(0);
int i = 0;
bool haveRect = false;
while (i < sizeList && haveRect == false)
{
index = ((index < sizeList) ? index : (index - sizeList));
tmpIt = it;
tmpIt += index;
haveRect = currentRectF.intersects((*tmpIt)->boundingRect());
++index;
++i;
}
if (haveRect == true)
{
(*tmpIt)->setFocus();
}
else
{
index = items.indexOf(focusItem) + 1;
index = ((index < sizeList) ? index : (index - sizeList));
it += index;
(*it)->setFocus();
}
}
GCC_DIAG_UNUSED_PRIVATE_FIELD_ON
#include "Engine/EffectInstance.h"
#include "Engine/Node.h"
#include "Engine/NodeGroup.h"
#include "Engine/Settings.h"
#include "Engine/Utils.h" // convertFromPlainText
#include "Gui/BackdropGui.h"
#include "Gui/Edge.h"
#include "Gui/GuiApplicationManager.h"
#include "Gui/GuiMacros.h"
#include "Gui/NodeGui.h"
#include "Gui/TabWidget.h"
#include "Global/QtCompat.h"
NATRON_NAMESPACE_ENTER
void
NodeGraph::checkForHints(bool shiftdown,
bool controlDown,
const NodeGuiPtr& selectedNode,
const QRectF& visibleSceneR)
{
NodePtr internalNode = selectedNode->getNode();
if (!internalNode) {
return;
}
bool doMergeHints = shiftdown && controlDown;
bool doConnectionHints = controlDown;
//Ignore hints for backdrops
BackdropGuiPtr isBd = toBackdropGui( selectedNode );
if (isBd) {
return;
}
if (!doMergeHints) {
///for nodes already connected don't show hint
if ( ( internalNode->getNInputs() == 0) && internalNode->hasOutputConnected() ) {
doConnectionHints = false;
} else if ( ( internalNode->getNInputs() > 0) && internalNode->hasAllInputsConnected() && internalNode->hasOutputConnected() ) {
doConnectionHints = false;
}
}
if (!doConnectionHints) {
return;
}
QRectF selectedNodeBbox = selectedNode->boundingRectWithEdges(); //selectedNode->mapToParent( selectedNode->boundingRect() ).boundingRect();
double tolerance = 10;
selectedNodeBbox.adjust(-tolerance, -tolerance, tolerance, tolerance);
NodeGuiPtr nodeToShowMergeRect;
NodePtr selectedNodeInternalNode = selectedNode->getNode();
bool selectedNodeIsReader = selectedNodeInternalNode->getEffectInstance()->isReader() || selectedNodeInternalNode->getNInputs() == 0;
Edge* edge = 0;
std::set<NodeGuiPtr> nodesWithinRect;
getNodesWithinViewportRect(visibleWidgetRect(), &nodesWithinRect);
{
for (std::set<NodeGuiPtr>::iterator it = nodesWithinRect.begin(); it != nodesWithinRect.end(); ++it) {
OutputNodesMap outputs;
internalNode->getOutputs(outputs);
OutputNodesMap::const_iterator foundAsOutput = outputs.find((*it)->getNode());
if (foundAsOutput != outputs.end()) {
continue;
}
QRectF nodeBbox = (*it)->boundingRectWithEdges();
if ( ( (*it) != selectedNode ) && (*it)->isVisible() && nodeBbox.intersects(visibleSceneR) ) {
if (doMergeHints) {
//QRectF nodeRect = (*it)->mapToParent((*it)->boundingRect()).boundingRect();
NodePtr internalNode = (*it)->getNode();
if ( !internalNode->isOutputNode() && nodeBbox.intersects(selectedNodeBbox) ) {
bool nHasInput = internalNode->hasInputConnected();
int nMaxInput = internalNode->getNInputs();
bool selectedHasInput = selectedNodeInternalNode->hasInputConnected();
int selectedMaxInput = selectedNodeInternalNode->getNInputs();
double nPAR = internalNode->getEffectInstance()->getAspectRatio(-1);
double selectedPAR = selectedNodeInternalNode->getEffectInstance()->getAspectRatio(-1);
double nFPS = internalNode->getEffectInstance()->getFrameRate();
double selectedFPS = selectedNodeInternalNode->getEffectInstance()->getFrameRate();
bool isValid = true;
if ( (selectedPAR != nPAR) || (std::abs(nFPS - selectedFPS) > 0.01) ) {
if (nHasInput || selectedHasInput) {
isValid = false;
} else if ( !nHasInput && (nMaxInput == 0) && !selectedHasInput && (selectedMaxInput == 0) ) {
isValid = false;
}
}
if (isValid) {
nodeToShowMergeRect = (*it)->shared_from_this();
}
} else {
(*it)->setMergeHintActive(false);
}
} else { //!doMergeHints
edge = (*it)->hasEdgeNearbyRect(selectedNodeBbox);
///if the edge input is the selected node don't continue
if ( edge && ( edge->getSource() == selectedNode) ) {
edge = 0;
}
if ( edge && edge->isOutputEdge() ) {
if (selectedNodeIsReader) {
continue;
}
int prefInput = selectedNodeInternalNode->getPreferredInputForConnection();
if (prefInput == -1) {
edge = 0;
} else {
Node::CanConnectInputReturnValue ret = selectedNodeInternalNode->canConnectInput(edge->getSource()->getNode(),
prefInput);
if (ret != Node::eCanConnectInput_ok) {
edge = 0;
}
}
}
if ( edge && !edge->isOutputEdge() ) {
if ( (*it)->getNode()->getEffectInstance()->isReader() ||
( (*it)->getNode()->getNInputs() == 0 ) ) {
edge = 0;
continue;
}
//Check that the edge can connect to the selected node
{
Node::CanConnectInputReturnValue ret = edge->getDest()->getNode()->canConnectInput( selectedNodeInternalNode, edge->getInputNumber() );
if ( (ret == Node::eCanConnectInput_inputAlreadyConnected) &&
!selectedNodeIsReader ) {
ret = Node::eCanConnectInput_ok;
}
if (ret != Node::eCanConnectInput_ok) {
edge = 0;
}
}
//Check that the selected node can connect to the input of the edge
if (edge) {
NodeGuiPtr edgeHasSource = edge->getSource();
if (edgeHasSource) {
int prefInput = selectedNodeInternalNode->getPreferredInputForConnection();
if (prefInput != -1) {
Node::CanConnectInputReturnValue ret = selectedNodeInternalNode->canConnectInput(edgeHasSource->getNode(), prefInput);
if ( (ret == Node::eCanConnectInput_inputAlreadyConnected) &&
!selectedNodeIsReader ) {
ret = Node::eCanConnectInput_ok;
}
if (ret != Node::eCanConnectInput_ok) {
edge = 0;
}
}
}
}
}
if (edge) {
edge->setUseHighlight(true);
break;
}
} // doMergeHints
}
}
} // QMutexLocker l(&_imp->_nodesMutex);
if ( _imp->_highLightedEdge && ( _imp->_highLightedEdge != edge) ) {
_imp->_highLightedEdge->setUseHighlight(false);
_imp->_hintInputEdge->hide();
_imp->_hintOutputEdge->hide();
}
_imp->_highLightedEdge = edge;
if ( edge && edge->getSource() && edge->getDest() ) {
///setup the hints edge
///find out if the node is already connected to what the edge is connected
bool alreadyConnected = false;
const std::vector<NodeWPtr> & inpNodes = selectedNode->getNode()->getInputs();
for (std::size_t i = 0; i < inpNodes.size(); ++i) {
if ( inpNodes[i].lock() == edge->getSource()->getNode() ) {
alreadyConnected = true;
break;
}
}
if ( !_imp->_hintInputEdge->isVisible() ) {
if (!alreadyConnected) {
int prefInput = selectedNode->getNode()->getPreferredInputForConnection();
_imp->_hintInputEdge->setInputNumber(prefInput != -1 ? prefInput : 0);
_imp->_hintInputEdge->setSourceAndDestination(edge->getSource(), selectedNode);
_imp->_hintInputEdge->setVisible(true);
}
_imp->_hintOutputEdge->setInputNumber( edge->getInputNumber() );
_imp->_hintOutputEdge->setSourceAndDestination( selectedNode, edge->getDest() );
_imp->_hintOutputEdge->setVisible(true);
} else {
if (!alreadyConnected) {
_imp->_hintInputEdge->initLine();
}
_imp->_hintOutputEdge->initLine();
}
} else if (edge) {
///setup only 1 of the hints edge
if ( _imp->_highLightedEdge && !_imp->_hintInputEdge->isVisible() ) {
if ( edge->isOutputEdge() ) {
int prefInput = selectedNode->getNode()->getPreferredInputForConnection();
if (prefInput != -1) {
_imp->_hintInputEdge->setInputNumber(prefInput);
_imp->_hintInputEdge->setSourceAndDestination(edge->getSource(), selectedNode);
_imp->_hintInputEdge->setVisible(true);
}
} else {
_imp->_hintInputEdge->setInputNumber( edge->getInputNumber() );
_imp->_hintInputEdge->setSourceAndDestination( selectedNode, edge->getDest() );
_imp->_hintInputEdge->setVisible(true);
}
} else if ( _imp->_highLightedEdge && _imp->_hintInputEdge->isVisible() ) {
_imp->_hintInputEdge->initLine();
}
} else if (nodeToShowMergeRect) {
nodeToShowMergeRect->setMergeHintActive(true);
selectedNode->setMergeHintActive(true);
_imp->_mergeHintNode = nodeToShowMergeRect;
} else {
selectedNode->setMergeHintActive(false);
_imp->_mergeHintNode.reset();
}
} // NodeGraph::checkForHints
void
NodeGraph::mouseMoveEvent(QMouseEvent* e)
{
QPointF newPos = mapToScene( e->pos() );
QPointF lastMousePosScene = mapToScene( _imp->_lastMousePos.x(), _imp->_lastMousePos.y() );
double dx, dy;
{
QPointF newPosRoot = _imp->_root->mapFromScene(newPos);
QPointF lastMousePosRoot = _imp->_root->mapFromScene(lastMousePosScene);
dx = newPosRoot.x() - lastMousePosRoot.x();
dy = newPosRoot.y() - lastMousePosRoot.y();
}
_imp->_hasMovedOnce = true;
bool mustUpdate = true;
boost::shared_ptr<NodeCollection> collection = getGroup();
NodeGroup* isGroup = dynamic_cast<NodeGroup*>( collection.get() );
bool isGroupEditable = true;
bool groupEdited = true;
if (isGroup) {
isGroupEditable = isGroup->isSubGraphEditable();
groupEdited = isGroup->getNode()->hasPyPlugBeenEdited();
}
if (!groupEdited && isGroupEditable) {
///check if user is nearby unlock
int iw = _imp->unlockIcon.width();
int ih = _imp->unlockIcon.height();
int w = width();
if ( ( e->x() >= (w - iw - 10 - 15) ) && ( e->x() <= (w - 10 + 15) ) &&
( e->y() >= (10 - 15) ) && ( e->y() <= (10 + ih + 15) ) ) {
assert(isGroup);
QPoint pos = mapToGlobal( e->pos() );
QToolTip::showText( pos, GuiUtils::convertFromPlainText(QCoreApplication::translate("NodeGraph", "Clicking the unlock button will convert the PyPlug to a regular group saved in the project and dettach it from the script.\n"
"Any modification will not be written to the Python script. Subsequent loading of the project will no longer load this group from the python script."), Qt::WhiteSpaceNormal) );
}
}
QRectF sceneR = visibleSceneRect();
if ( groupEdited && (_imp->_evtState != eEventStateSelectionRect) && (_imp->_evtState != eEventStateDraggingArrow) ) {
// Set cursor
std::set<NodeGui*> visibleNodes;
getNodesWithinViewportRect(visibleWidgetRect(), &visibleNodes);
NodeGuiPtr selected;
Edge* selectedEdge = 0;
bool optionalInputsAutoHidden = areOptionalInputsAutoHidden();
for (std::set<NodeGui*>::iterator it = visibleNodes.begin(); it != visibleNodes.end(); ++it) {
QPointF evpt = (*it)->mapFromScene(newPos);
QRectF bbox = (*it)->mapToScene( (*it)->boundingRect() ).boundingRect();
if ( (*it)->isActive() && bbox.intersects(sceneR) ) {
if ( (*it)->contains(evpt) ) {
selected = (*it)->shared_from_this();
if (optionalInputsAutoHidden) {
(*it)->refreshEdgesVisility(true);
} else {
break;
}
} else {
Edge* edge = (*it)->hasEdgeNearbyPoint(newPos);
if (edge) {
selectedEdge = edge;
if (!optionalInputsAutoHidden) {
break;
}
} else if ( optionalInputsAutoHidden && !(*it)->getIsSelected() ) {
(*it)->refreshEdgesVisility(false);
}
}
}
}
if (selected) {
_imp->cursorSet = true;
setCursor( QCursor(Qt::OpenHandCursor) );
} else if (selectedEdge) {
} else if (!selectedEdge && !selected) {
if (_imp->cursorSet) {
_imp->cursorSet = false;
unsetCursor();
}
}
}
bool mustUpdateNavigator = false;
///Apply actions
switch (_imp->_evtState) {
case eEventStateDraggingArrow: {
QPointF np = _imp->_arrowSelected->mapFromScene(newPos);
if ( _imp->_arrowSelected->isOutputEdge() ) {
_imp->_arrowSelected->dragDest(np);
} else {
_imp->_arrowSelected->dragSource(np);
}
checkAndStartAutoScrollTimer(newPos);
mustUpdate = true;
break;
}
case eEventStateDraggingNode: {
mustUpdate = true;
mustUpdateNavigator = true;
bool controlDown = modifierHasControl(e);
bool shiftdown = modifierHasShift(e);
moveSelectedNodesBy(shiftdown, controlDown, lastMousePosScene, newPos, sceneR, true);
break;
}
case eEventStateMovingArea: {
mustUpdateNavigator = true;
moveRootInternal(dx, dy);
_imp->cursorSet = true;
setCursor( QCursor(Qt::SizeAllCursor) );
mustUpdate = true;
break;
}
case eEventStateResizingBackdrop: {
mustUpdateNavigator = true;
assert(_imp->_backdropResized);
QPointF p = _imp->_backdropResized->scenePos();
int w = newPos.x() - p.x();
int h = newPos.y() - p.y();
checkAndStartAutoScrollTimer(newPos);
mustUpdate = true;
pushUndoCommand( new ResizeBackdropCommand(_imp->_backdropResized, w, h) );
break;
}
case eEventStateSelectionRect: {
QPointF startDrag = _imp->_lastSelectionStartPointScene;
QPointF cur = newPos;
double xmin = std::min( cur.x(), startDrag.x() );
double xmax = std::max( cur.x(), startDrag.x() );
double ymin = std::min( cur.y(), startDrag.y() );
double ymax = std::max( cur.y(), startDrag.y() );
checkAndStartAutoScrollTimer(newPos);
QRectF selRect(xmin, ymin, xmax - xmin, ymax - ymin);
_imp->_selectionRect = selRect;
mustUpdate = true;
break;
}
case eEventStateDraggingNavigator: {
QPointF mousePosSceneCoordinates;
bool insideNavigator = isNearbyNavigator(e->pos(), mousePosSceneCoordinates);
if (insideNavigator) {
_imp->_refreshOverlays = true;
centerOn(mousePosSceneCoordinates);
_imp->_lastMousePos = e->pos();
update();
return;
}
break;
}
case eEventStateZoomingArea: {
int delta = 2 * ( ( e->x() - _imp->_lastMousePos.x() ) - ( e->y() - _imp->_lastMousePos.y() ) );
setTransformationAnchor(QGraphicsView::AnchorViewCenter);
wheelEventInternal(modCASIsControl(e), delta);
setTransformationAnchor(QGraphicsView::AnchorUnderMouse);
mustUpdate = true;
break;
}
default:
mustUpdate = false;
break;
} // switch
_imp->_lastMousePos = e->pos();
if (mustUpdateNavigator) {
_imp->_refreshOverlays = true;
mustUpdate = true;
}
if (mustUpdate) {
update();
}
QGraphicsView::mouseMoveEvent(e);
} // mouseMoveEvent
/*!
\return Bounding interval of the radial scale that is
visible on the canvas.
*/
QwtInterval QwtPolarPlot::visibleInterval() const
{
const QwtScaleDiv *sd = scaleDiv( QwtPolar::Radius );
const QRectF cRect = canvas()->contentsRect();
const QRectF pRect = plotRect( cRect );
if ( cRect.contains( pRect ) || !cRect.intersects( pRect ) )
{
return QwtInterval( sd->lowerBound(), sd->upperBound() );
}
const QPointF pole = pRect.center();
const QRectF scaleRect = pRect & cRect;
const QwtScaleMap map = scaleMap( QwtPolar::Radius );
double dmin = 0.0;
double dmax = 0.0;
if ( scaleRect.contains( pole ) )
{
dmin = 0.0;
QPointF corners[4];
corners[0] = scaleRect.bottomRight();
corners[1] = scaleRect.topRight();
corners[2] = scaleRect.topLeft();
corners[3] = scaleRect.bottomLeft();
dmax = 0.0;
for ( int i = 0; i < 4; i++ )
{
const double dist = qwtDistance( pole, corners[i] );
if ( dist > dmax )
dmax = dist;
}
}
else
{
if ( pole.x() < scaleRect.left() )
{
if ( pole.y() < scaleRect.top() )
{
dmin = qwtDistance( pole, scaleRect.topLeft() );
dmax = qwtDistance( pole, scaleRect.bottomRight() );
}
else if ( pole.y() > scaleRect.bottom() )
{
dmin = qwtDistance( pole, scaleRect.bottomLeft() );
dmax = qwtDistance( pole, scaleRect.topRight() );
}
else
{
dmin = scaleRect.left() - pole.x();
dmax = qMax( qwtDistance( pole, scaleRect.bottomRight() ),
qwtDistance( pole, scaleRect.topRight() ) );
}
}
else if ( pole.x() > scaleRect.right() )
{
if ( pole.y() < scaleRect.top() )
{
dmin = qwtDistance( pole, scaleRect.topRight() );
dmax = qwtDistance( pole, scaleRect.bottomLeft() );
}
else if ( pole.y() > scaleRect.bottom() )
{
dmin = qwtDistance( pole, scaleRect.bottomRight() );
dmax = qwtDistance( pole, scaleRect.topLeft() );
}
else
{
dmin = pole.x() - scaleRect.right();
dmax = qMax( qwtDistance( pole, scaleRect.bottomLeft() ),
qwtDistance( pole, scaleRect.topLeft() ) );
}
}
else if ( pole.y() < scaleRect.top() )
{
dmin = scaleRect.top() - pole.y();
dmax = qMax( qwtDistance( pole, scaleRect.bottomLeft() ),
qwtDistance( pole, scaleRect.bottomRight() ) );
}
else if ( pole.y() > scaleRect.bottom() )
{
dmin = pole.y() - scaleRect.bottom();
dmax = qMax( qwtDistance( pole, scaleRect.topLeft() ),
qwtDistance( pole, scaleRect.topRight() ) );
}
}
const double radius = pRect.width() / 2.0;
if ( dmax > radius )
dmax = radius;
QwtInterval interval;
interval.setMinValue( map.invTransform( dmin ) );
interval.setMaxValue( map.invTransform( dmax ) );
return interval;
}
void VectorMap::mercatorCreateFromPntMap( const PntMap* pntmap,
const ViewportParams* viewport )
{
m_polygons.clear();
int radius = viewport->radius();
// Calculate translation of center point
const qreal centerLon = viewport->centerLongitude();
const qreal centerLat = viewport->centerLatitude();
const qreal rad2Pixel = (float)( 2 * radius ) / M_PI;
GeoPolygon::PtrVector::ConstIterator itPolyLine = pntmap->constBegin();
GeoPolygon::PtrVector::ConstIterator itEndPolyLine = pntmap->constEnd();
const QRectF visibleArea ( 0, 0, viewport->width(), viewport->height() );
const int detail = getDetailLevel( radius );
for (; itPolyLine != itEndPolyLine; ++itPolyLine )
{
const GeoDataCoordinates::PtrVector boundary = (*itPolyLine)->getBoundary();
// Let's just use the top left and the bottom right bounding box point for
// this projection
// rather paint an invalid line then crashing here if the boundaries are not loaded yet
if ( boundary.size() < 3 )
continue;
ScreenPolygon boundingPolygon;
for ( int i = 1; i < 3; ++i ) {
qreal lon, lat;
boundary[i]->geoCoordinates(lon, lat);
const qreal x = (qreal)(viewport->width()) / 2.0 + rad2Pixel * (lon - centerLon);
const qreal y = (qreal)(viewport->height()) / 2.0 - rad2Pixel * ( atanh( sin( lat ) )
- atanh( sin( centerLat ) ) );
boundingPolygon << QPointF( x, y );
}
// This sorts out polygons by bounding box which aren't visible at all.
int offset = 0;
if ( boundingPolygon.at(0).x() < 0 || boundingPolygon.at(1).x() < 0 ) {
boundingPolygon.translate( 4 * radius, 0 );
offset += 4 * radius;
}
do {
offset -= 4 * radius;
boundingPolygon.translate( -4 * radius, 0 );
// FIXME: Get rid of this really fugly code once we have a
// proper LatLonBox check implemented and in place.
} while( ( (*itPolyLine)->getDateLine() != GeoPolygon::Even
&& visibleArea.intersects( (QRectF)( boundingPolygon.boundingRect() ) ) )
|| ( (*itPolyLine)->getDateLine() == GeoPolygon::Even
&& ( visibleArea.intersects( QRectF( boundingPolygon.at(1),
QPointF( (qreal)(viewport->width()) / 2.0
- rad2Pixel * ( centerLon
- M_PI )
+ offset,
boundingPolygon.at(0).y() ) ) )
|| visibleArea.intersects( QRectF( QPointF( (qreal)(viewport->width()) / 2.0
- rad2Pixel * ( centerLon
+ M_PI )
+ offset,
boundingPolygon.at(1).y() ),
boundingPolygon.at(0) ) ) ) ) );
offset += 4 * radius;
boundingPolygon.translate( 4 * radius, 0 );
// FIXME: Get rid of this really fugly code once we will have
// a proper LatLonBox check implemented and in place.
while ( ( (*itPolyLine)->getDateLine() != GeoPolygon::Even
&& visibleArea.intersects( (QRectF)( boundingPolygon.boundingRect() ) ) )
|| ( (*itPolyLine)->getDateLine() == GeoPolygon::Even
&& ( visibleArea.intersects(
QRectF( boundingPolygon.at(1),
QPointF( (qreal)(viewport->width()) / 2.0
- rad2Pixel * ( centerLon - M_PI )
+ offset,
boundingPolygon.at(0).y() ) ) )
|| visibleArea.intersects(
QRectF( QPointF( (qreal)(viewport->width()) / 2.0
- rad2Pixel * ( centerLon + M_PI )
+ offset,
boundingPolygon.at(1).y() ),
boundingPolygon.at(0) ) ) ) )
)
{
mercatorCreatePolyLine( *itPolyLine, detail, viewport, offset );
offset += 4 * radius;
boundingPolygon.translate( 4 * radius, 0 );
}
}
}
void TimelineBar::paintEvent(QPaintEvent *e)
{
QPainter p(viewport());
p.setFont(font());
p.setRenderHint(QPainter::TextAntialiasing);
// draw boundaries and background
{
QRectF r = viewport()->rect();
p.fillRect(r, palette().brush(QPalette::Window));
r = r.marginsRemoved(QMargins(borderWidth + margin, borderWidth + margin, borderWidth + margin,
borderWidth + margin));
p.fillRect(r, palette().brush(QPalette::Base));
p.drawRect(r);
}
QTextOption to;
to.setWrapMode(QTextOption::NoWrap);
to.setAlignment(Qt::AlignLeft | Qt::AlignVCenter);
QFontMetrics fm = p.fontMetrics();
{
QRectF titleRect = m_eidAxisRect;
titleRect.setLeft(titleRect.left() - m_titleWidth);
titleRect.setWidth(m_titleWidth);
p.setPen(QPen(palette().brush(QPalette::Text), 1.0));
// add an extra margin for the text
p.drawText(titleRect.marginsRemoved(QMarginsF(margin, 0, 0, 0)), eidAxisTitle, to);
titleRect.setLeft(titleRect.left() - margin);
titleRect.setTop(titleRect.top() - margin);
p.drawLine(titleRect.bottomLeft(), titleRect.bottomRight());
p.drawLine(titleRect.topRight(), titleRect.bottomRight());
}
QRectF eidAxisRect = m_eidAxisRect;
p.drawLine(eidAxisRect.bottomLeft(), eidAxisRect.bottomRight() + QPointF(margin, 0));
p.drawLine(m_highlightingRect.topLeft(), m_highlightingRect.topRight());
if(m_Draws.isEmpty())
return;
eidAxisRect.setLeft(m_eidAxisRect.left() + m_pan);
uint32_t maxEID = m_Draws.isEmpty() ? 0 : m_Draws.back();
to.setAlignment(Qt::AlignCenter | Qt::AlignVCenter);
p.setFont(Formatter::PreferredFont());
QRectF hoverRect = eidAxisRect;
// clip labels to the visible section
p.setClipRect(m_eidAxisRect.marginsAdded(QMargins(0, margin, margin, 0)));
// draw where we're hovering
{
QPoint pos = viewport()->mapFromGlobal(QCursor::pos());
if(m_dataArea.contains(pos))
{
uint32_t hoverEID = eventAt(pos.x());
hoverRect.setLeft(offsetOf(hoverEID));
hoverRect.setWidth(m_eidAxisLabelWidth);
// recentre
hoverRect.moveLeft(hoverRect.left() - m_eidAxisLabelWidth / 2 + m_eidWidth / 2);
QColor backCol = palette().color(QPalette::Base);
if(getLuminance(backCol) < 0.2f)
backCol = backCol.lighter(120);
else
backCol = backCol.darker(120);
QRectF backRect = hoverRect.marginsAdded(QMargins(0, margin - borderWidth, 0, 0));
backRect.setLeft(qMax(backRect.left(), m_eidAxisRect.left() + 1));
p.fillRect(backRect, backCol);
p.drawText(hoverRect, QString::number(hoverEID), to);
// re-add the top margin so the lines match up with the border around the EID axis
hoverRect = hoverRect.marginsAdded(QMargins(0, margin, 0, 0));
if(hoverRect.left() >= m_eidAxisRect.left())
p.drawLine(hoverRect.topLeft(), hoverRect.bottomLeft());
p.drawLine(hoverRect.topRight(), hoverRect.bottomRight());
// shrink the rect a bit for clipping against labels below
hoverRect.setX(qRound(hoverRect.x() + 0.5));
hoverRect.setWidth(int(hoverRect.width()));
}
else
{
hoverRect = QRectF();
}
}
QRectF labelRect = eidAxisRect;
labelRect.setWidth(m_eidAxisLabelWidth);
// iterate through the EIDs from 0, starting from possible a negative offset if the user has
// panned to the right.
for(uint32_t i = 0; i <= maxEID; i += m_eidAxisLabelStep)
{
labelRect.moveLeft(offsetOf(i) - labelRect.width() / 2 + m_eidWidth / 2);
// check if this label is visible at all, but don't draw labels that intersect with the hovered
// number
if(labelRect.right() >= 0 && !labelRect.intersects(hoverRect))
p.drawText(labelRect, QString::number(i), to);
// check if labelRect is off the edge of the screen
if(labelRect.left() >= m_eidAxisRect.right())
break;
}
// stop clipping
p.setClipRect(viewport()->rect());
// clip the markers
p.setClipRect(m_markerRect);
{
QPen pen = p.pen();
paintMarkers(p, m_RootMarkers, m_RootDraws, m_markerRect);
p.setPen(pen);
}
// stop clipping
p.setClipRect(viewport()->rect());
QRectF currentRect = eidAxisRect;
// draw the current label and line
{
uint32_t curEID = m_Ctx.CurEvent();
currentRect.setLeft(offsetOf(curEID));
currentRect.setWidth(
qMax(m_eidAxisLabelWidth, m_eidAxisLabelTextWidth + dataBarHeight + margin * 2));
// recentre
currentRect.moveLeft(currentRect.left() - currentRect.width() / 2 + m_eidWidth / 2);
// remember where the middle would have been, without clamping
qreal realMiddle = currentRect.center().x();
// clamp the position from the left or right side
if(currentRect.left() < eidAxisRect.left())
currentRect.moveLeft(eidAxisRect.left());
else if(currentRect.right() > eidAxisRect.right())
currentRect.moveRight(eidAxisRect.right());
// re-add the top margin so the lines match up with the border around the EID axis
QRectF currentBackRect = currentRect.marginsAdded(QMargins(0, margin, 0, 0));
p.fillRect(currentBackRect, palette().brush(QPalette::Base));
p.drawRect(currentBackRect);
// draw the 'current marker' pixmap
const QPixmap &px = Pixmaps::flag_green(devicePixelRatio());
p.drawPixmap(currentRect.topLeft() + QPointF(margin, 1), px, px.rect());
// move to where the text should be and draw it
currentRect.setLeft(currentRect.left() + margin * 2 + dataBarHeight);
p.drawText(currentRect, QString::number(curEID), to);
// draw a line from the bottom of the shadow downwards
QPointF currentTop = currentRect.center();
currentTop.setX(int(qBound(eidAxisRect.left(), realMiddle, eidAxisRect.right() - 2.0)) + 0.5);
currentTop.setY(currentRect.bottom());
QPointF currentBottom = currentTop;
currentBottom.setY(m_markerRect.bottom());
p.drawLine(currentTop, currentBottom);
}
to.setAlignment(Qt::AlignLeft | Qt::AlignTop);
if(!m_UsageTarget.isEmpty() || !m_HistoryTarget.isEmpty())
{
p.setRenderHint(QPainter::Antialiasing);
QRectF highlightLabel = m_highlightingRect.marginsRemoved(uniformMargins(margin));
highlightLabel.setX(highlightLabel.x() + margin);
QString text;
if(!m_HistoryTarget.isEmpty())
text = tr("Pixel history for %1").arg(m_HistoryTarget);
else
text = tr("Usage for %1:").arg(m_UsageTarget);
p.drawText(highlightLabel, text, to);
const int triRadius = fm.averageCharWidth();
const int triHeight = fm.ascent();
QPainterPath triangle;
triangle.addPolygon(
QPolygonF({QPoint(0, triHeight), QPoint(triRadius * 2, triHeight), QPoint(triRadius, 0)}));
triangle.closeSubpath();
enum
{
ReadUsage,
WriteUsage,
ReadWriteUsage,
ClearUsage,
BarrierUsage,
HistoryPassed,
HistoryFailed,
UsageCount,
};
const QColor colors[UsageCount] = {
// read
QColor(Qt::red),
// write
QColor(Qt::green),
// read/write
QColor(Qt::yellow),
// clear
QColor(Qt::blue),
// barrier
QColor(Qt::magenta),
// pass
QColor(Qt::green),
// fail
QColor(Qt::red),
};
// draw the key
if(m_HistoryTarget.isEmpty())
{
// advance past the first text to draw the key
highlightLabel.setLeft(highlightLabel.left() + fm.width(text));
text = lit(" Reads ( ");
p.drawText(highlightLabel, text, to);
highlightLabel.setLeft(highlightLabel.left() + fm.width(text));
QPainterPath path = triangle.translated(aliasAlign(highlightLabel.topLeft()));
p.fillPath(path, colors[ReadUsage]);
p.drawPath(path);
highlightLabel.setLeft(highlightLabel.left() + triRadius * 2);
text = lit(" ), Writes ( ");
p.drawText(highlightLabel, text, to);
highlightLabel.setLeft(highlightLabel.left() + fm.width(text));
path = triangle.translated(aliasAlign(highlightLabel.topLeft()));
p.fillPath(path, colors[WriteUsage]);
p.drawPath(path);
highlightLabel.setLeft(highlightLabel.left() + triRadius * 2);
text = lit(" ), Read/Write ( ");
p.drawText(highlightLabel, text, to);
highlightLabel.setLeft(highlightLabel.left() + fm.width(text));
path = triangle.translated(aliasAlign(highlightLabel.topLeft()));
p.fillPath(path, colors[ReadWriteUsage]);
p.drawPath(path);
highlightLabel.setLeft(highlightLabel.left() + triRadius * 2);
if(m_Ctx.CurPipelineState().SupportsBarriers())
{
text = lit(" ) Barriers ( ");
p.drawText(highlightLabel, text, to);
highlightLabel.setLeft(highlightLabel.left() + fm.width(text));
path = triangle.translated(aliasAlign(highlightLabel.topLeft()));
p.fillPath(path, colors[BarrierUsage]);
p.drawPath(path);
highlightLabel.setLeft(highlightLabel.left() + triRadius * 2);
}
text = lit(" ), and Clears ( ");
p.drawText(highlightLabel, text, to);
highlightLabel.setLeft(highlightLabel.left() + fm.width(text));
path = triangle.translated(aliasAlign(highlightLabel.topLeft()));
p.fillPath(path, colors[ClearUsage]);
p.drawPath(path);
highlightLabel.setLeft(highlightLabel.left() + triRadius * 2);
text = lit(" )");
p.drawText(highlightLabel, text, to);
}
PipRanges pipranges[UsageCount];
QRectF pipsRect = m_highlightingRect.marginsRemoved(uniformMargins(margin));
pipsRect.setX(pipsRect.x() + margin + m_titleWidth);
pipsRect.setHeight(triHeight + margin);
pipsRect.moveBottom(m_highlightingRect.bottom());
p.setClipRect(pipsRect);
qreal leftClip = -triRadius * 2.0;
qreal rightClip = pipsRect.width() + triRadius * 10.0;
if(!m_HistoryEvents.isEmpty())
{
for(const PixelModification &mod : m_HistoryEvents)
{
qreal pos = offsetOf(mod.eventId) + m_eidWidth / 2 - triRadius;
if(pos < leftClip || pos > rightClip)
continue;
if(mod.Passed())
pipranges[HistoryPassed].push(pos, triRadius);
else
pipranges[HistoryFailed].push(pos, triRadius);
}
}
else
{
for(const EventUsage &use : m_UsageEvents)
{
qreal pos = offsetOf(use.eventId) + m_eidWidth / 2 - triRadius;
if(pos < leftClip || pos > rightClip)
continue;
if(((int)use.usage >= (int)ResourceUsage::VS_RWResource &&
(int)use.usage <= (int)ResourceUsage::All_RWResource) ||
use.usage == ResourceUsage::GenMips || use.usage == ResourceUsage::Copy ||
use.usage == ResourceUsage::Resolve)
{
pipranges[ReadWriteUsage].push(pos, triRadius);
}
else if(use.usage == ResourceUsage::StreamOut || use.usage == ResourceUsage::ResolveDst ||
use.usage == ResourceUsage::ColorTarget ||
use.usage == ResourceUsage::DepthStencilTarget || use.usage == ResourceUsage::CopyDst)
{
pipranges[WriteUsage].push(pos, triRadius);
}
else if(use.usage == ResourceUsage::Clear)
{
pipranges[ClearUsage].push(pos, triRadius);
}
else if(use.usage == ResourceUsage::Barrier)
{
pipranges[BarrierUsage].push(pos, triRadius);
}
else
{
pipranges[ReadUsage].push(pos, triRadius);
}
}
}
for(int i = 0; i < UsageCount; i++)
{
QPainterPath path = pipranges[i].makePath(triRadius, triHeight, pipsRect.y());
if(!path.isEmpty())
{
p.drawPath(path);
p.fillPath(path, colors[i]);
}
}
}
else
{
QRectF highlightLabel = m_highlightingRect;
highlightLabel = highlightLabel.marginsRemoved(uniformMargins(margin));
highlightLabel.setX(highlightLabel.x() + margin);
p.drawText(highlightLabel, tr("No resource selected for highlighting."), to);
}
}
void PianoView::drawBackground(QPainter* p, const QRectF& r)
{
if (staff == 0)
return;
Score* _score = staff->score();
setFrameShape(QFrame::NoFrame);
QRectF r1;
r1.setCoords(-1000000.0, 0.0, 480.0, 1000000.0);
QRectF r2;
r2.setCoords(ticks + MAP_OFFSET, 0.0, 1000000.0, 1000000.0);
QColor bg(0x71, 0x8d, 0xbe);
p->fillRect(r, bg);
if (r.intersects(r1))
p->fillRect(r.intersected(r1), bg.darker(150));
if (r.intersects(r2))
p->fillRect(r.intersected(r2), bg.darker(150));
//
// draw horizontal grid lines
//
qreal y1 = r.y();
qreal y2 = y1 + r.height();
qreal kh = 13.0;
qreal x1 = r.x();
qreal x2 = x1 + r.width();
// int key = floor(y1 / 75);
int key = floor(y1 / kh);
qreal y = key * kh;
for (; key < 75; ++key, y += kh) {
if (y < y1)
continue;
if (y > y2)
break;
p->setPen(QPen((key % 7) == 5 ? Qt::lightGray : Qt::gray));
p->drawLine(QLineF(x1, y, x2, y));
}
//
// draw vertical grid lines
//
static const int mag[7] = {
1, 1, 2, 5, 10, 20, 50
};
Pos pos1 = pix2pos(x1);
Pos pos2 = pix2pos(x2);
//---------------------------------------------------
// draw raster
//---------------------------------------------------
int bar1, bar2, beat, tick;
pos1.mbt(&bar1, &beat, &tick);
pos2.mbt(&bar2, &beat, &tick);
int n = mag[magStep < 0 ? 0 : magStep];
bar1 = (bar1 / n) * n; // round down
if (bar1 && n >= 2)
bar1 -= 1;
bar2 = ((bar2 + n - 1) / n) * n; // round up
for (int bar = bar1; bar <= bar2;) {
Pos stick(_score->tempomap(), _score->sigmap(), bar, 0, 0);
if (magStep > 0) {
double x = double(pos2pix(stick));
if (x > 0) {
p->setPen(QPen(Qt::lightGray, 0.0));
p->drawLine(x, y1, x, y2);
}
else {
p->setPen(QPen(Qt::black, 0.0));
p->drawLine(x, y1, x, y1);
}
}
else {
int z = stick.timesig().timesig().numerator();
for (int beat = 0; beat < z; beat++) {
if (magStep == 0) {
Pos xx(_score->tempomap(), _score->sigmap(), bar, beat, 0);
int xp = pos2pix(xx);
if (xp < 0)
continue;
if (xp > 0) {
p->setPen(QPen(beat == 0 ? Qt::lightGray : Qt::gray, 0.0));
p->drawLine(xp, y1, xp, y2);
}
else {
p->setPen(QPen(Qt::black, 0.0));
p->drawLine(xp, y1, xp, y2);
}
}
else {
int k;
if (magStep == -1)
k = 2;
else if (magStep == -2)
k = 4;
else if (magStep == -3)
k = 8;
else if (magStep == -4)
k = 16;
else
k = 32;
int n = (MScore::division * 4) / stick.timesig().timesig().denominator();
for (int i = 0; i < k; ++i) {
Pos xx(_score->tempomap(), _score->sigmap(), bar, beat, (n * i)/ k);
int xp = pos2pix(xx);
if (xp < 0)
continue;
if (xp > 0) {
p->setPen(QPen(i == 0 && beat == 0 ? Qt::lightGray : Qt::gray, 0.0));
p->drawLine(xp, y1, xp, y2);
}
else {
p->setPen(QPen(Qt::black, 0.0));
p->drawLine(xp, y1, xp, y2);
}
}
}
}
}
if (bar == 0 && n >= 2)
bar += (n-1);
else
bar += n;
}
}
void WebViewCache::draw(QPainter * painter, QGraphicsEffectSource * source)
{
const QGraphicsItem *item = source->graphicsItem();
QSizeF itemSize = item->boundingRect().size();
if (!qFuzzyCompare(itemSize.width(), m_itemSize.width()) ||
!qFuzzyCompare(itemSize.height(), m_itemSize.height())) {
qDebug() << "Refresh tile cache, for new size" << itemSize;
for (int i = 0; i < m_tilePixmaps.size(); i++) {
QPixmapCache::remove(m_tilePixmaps[i]);
}
m_tilePixmaps.clear();
m_tileRects.clear();
int itemWidth = itemSize.width() + 0.5;
int itemHeight = itemSize.height() + 0.5;
int tilesX = itemWidth / TileSideLength;
int tilesY = itemHeight / TileSideLength;
if ((itemWidth % TileSideLength) != 0) {
++tilesX;
}
if ((itemHeight % TileSideLength) != 0) {
++tilesY;
}
int tilesCount = tilesX * tilesY;
m_tilePixmaps.resize(tilesCount);
m_tileRects.resize(tilesCount);
for (int i = 0; i < tilesX; i++) {
for (int j = 0; j < tilesY; j++) {
int x = i * TileSideLength;
int y = j * TileSideLength;
m_tileRects[i + j * tilesX]
= QRectF(x, y, TileSideLength, TileSideLength);
}
}
m_itemSize = itemSize;
}
const QGraphicsItem *parentItem = item->parentItem();
QPointF itemPos = item->pos();
QRectF parentRect = parentItem->boundingRect();
for (int i = 0; i < m_tileRects.size(); i++) {
QRectF tileRect = m_tileRects[i].translated(itemPos);
if (!tileRect.intersects(parentRect) && !tileRect.contains(parentRect)) {
continue;
}
QPixmap tilePixmap;
if (!QPixmapCache::find(m_tilePixmaps[i], &tilePixmap)) {
tilePixmap = QPixmap(TileSideLength, TileSideLength);
QWebFrame *webFrame = m_webView->page()->mainFrame();
QPainter tilePainter(&tilePixmap);
tilePainter.translate(-m_tileRects[i].left(), -m_tileRects[i].top());
webFrame->render(&tilePainter, m_tileRects[i].toRect());
tilePainter.end();
m_tilePixmaps[i] = QPixmapCache::insert(tilePixmap);
}
tileRect = tileRect.translated(-itemPos);
painter->drawPixmap(tileRect.topLeft(), tilePixmap);
}
}
void
NodeGraph::checkForHints(bool shiftdown,
bool controlDown,
const NodeGuiPtr& selectedNode,
const QRectF& visibleSceneR)
{
NodePtr internalNode = selectedNode->getNode();
bool doMergeHints = shiftdown && controlDown;
bool doConnectionHints = appPTR->getCurrentSettings()->isConnectionHintEnabled();
//Ignore hints for backdrops
BackdropGui* isBd = dynamic_cast<BackdropGui*>( selectedNode.get() );
if (isBd) {
return;
}
if (!doMergeHints) {
///for nodes already connected don't show hint
if ( ( internalNode->getMaxInputCount() == 0) && internalNode->hasOutputConnected() ) {
doConnectionHints = false;
} else if ( ( internalNode->getMaxInputCount() > 0) && internalNode->hasAllInputsConnected() && internalNode->hasOutputConnected() ) {
doConnectionHints = false;
}
}
if (!doConnectionHints) {
return;
}
QRectF selectedNodeBbox = selectedNode->boundingRectWithEdges(); //selectedNode->mapToParent( selectedNode->boundingRect() ).boundingRect();
double tolerance = 10;
selectedNodeBbox.adjust(-tolerance, -tolerance, tolerance, tolerance);
NodeGuiPtr nodeToShowMergeRect;
NodePtr selectedNodeInternalNode = selectedNode->getNode();
bool selectedNodeIsReader = selectedNodeInternalNode->getEffectInstance()->isReader() || selectedNodeInternalNode->getMaxInputCount() == 0;
Edge* edge = 0;
std::set<NodeGui*> nodesWithinRect;
getNodesWithinViewportRect(visibleWidgetRect(), &nodesWithinRect);
{
for (std::set<NodeGui*>::iterator it = nodesWithinRect.begin(); it != nodesWithinRect.end(); ++it) {
bool isAlreadyAnOutput = false;
const NodesWList& outputs = internalNode->getGuiOutputs();
for (NodesWList::const_iterator it2 = outputs.begin(); it2 != outputs.end(); ++it2) {
NodePtr node = it2->lock();
if (!node) {
continue;
}
if ( node == (*it)->getNode() ) {
isAlreadyAnOutput = true;
break;
}
}
if (isAlreadyAnOutput) {
continue;
}
QRectF nodeBbox = (*it)->boundingRectWithEdges();
if ( ( (*it) != selectedNode.get() ) && (*it)->isVisible() && nodeBbox.intersects(visibleSceneR) ) {
if (doMergeHints) {
//QRectF nodeRect = (*it)->mapToParent((*it)->boundingRect()).boundingRect();
NodePtr internalNode = (*it)->getNode();
if ( !internalNode->isOutputNode() && nodeBbox.intersects(selectedNodeBbox) ) {
bool nHasInput = internalNode->hasInputConnected();
int nMaxInput = internalNode->getMaxInputCount();
bool selectedHasInput = selectedNodeInternalNode->hasInputConnected();
int selectedMaxInput = selectedNodeInternalNode->getMaxInputCount();
double nPAR = internalNode->getEffectInstance()->getAspectRatio(-1);
double selectedPAR = selectedNodeInternalNode->getEffectInstance()->getAspectRatio(-1);
double nFPS = internalNode->getEffectInstance()->getFrameRate();
double selectedFPS = selectedNodeInternalNode->getEffectInstance()->getFrameRate();
bool isValid = true;
if ( (selectedPAR != nPAR) || (std::abs(nFPS - selectedFPS) > 0.01) ) {
if (nHasInput || selectedHasInput) {
isValid = false;
} else if ( !nHasInput && (nMaxInput == 0) && !selectedHasInput && (selectedMaxInput == 0) ) {
isValid = false;
}
}
if (isValid) {
nodeToShowMergeRect = (*it)->shared_from_this();
}
} else {
(*it)->setMergeHintActive(false);
}
} else { //!doMergeHints
edge = (*it)->hasEdgeNearbyRect(selectedNodeBbox);
///if the edge input is the selected node don't continue
if ( edge && ( edge->getSource() == selectedNode) ) {
edge = 0;
}
if ( edge && edge->isOutputEdge() ) {
if (selectedNodeIsReader) {
continue;
}
int prefInput = selectedNodeInternalNode->getPreferredInputForConnection();
if (prefInput == -1) {
edge = 0;
} else {
Node::CanConnectInputReturnValue ret = selectedNodeInternalNode->canConnectInput(edge->getSource()->getNode(),
prefInput);
if (ret != Node::eCanConnectInput_ok) {
edge = 0;
}
}
}
if ( edge && !edge->isOutputEdge() ) {
if ( (*it)->getNode()->getEffectInstance()->isReader() ||
( (*it)->getNode()->getMaxInputCount() == 0 ) ) {
edge = 0;
continue;
}
if ( (*it)->getNode()->getEffectInstance()->isInputRotoBrush( edge->getInputNumber() ) ) {
edge = 0;
continue;
}
//Check that the edge can connect to the selected node
{
Node::CanConnectInputReturnValue ret = edge->getDest()->getNode()->canConnectInput( selectedNodeInternalNode, edge->getInputNumber() );
if ( (ret == Node::eCanConnectInput_inputAlreadyConnected) &&
!selectedNodeIsReader ) {
ret = Node::eCanConnectInput_ok;
}
if (ret != Node::eCanConnectInput_ok) {
edge = 0;
}
}
//Check that the selected node can connect to the input of the edge
if (edge) {
NodeGuiPtr edgeHasSource = edge->getSource();
if (edgeHasSource) {
int prefInput = selectedNodeInternalNode->getPreferredInputForConnection();
if (prefInput != -1) {
Node::CanConnectInputReturnValue ret = selectedNodeInternalNode->canConnectInput(edgeHasSource->getNode(), prefInput);
if ( (ret == Node::eCanConnectInput_inputAlreadyConnected) &&
!selectedNodeIsReader ) {
ret = Node::eCanConnectInput_ok;
}
if (ret != Node::eCanConnectInput_ok) {
edge = 0;
}
}
}
}
}
if (edge) {
edge->setUseHighlight(true);
break;
}
} // doMergeHints
}
}
} // QMutexLocker l(&_imp->_nodesMutex);
if ( _imp->_highLightedEdge && ( _imp->_highLightedEdge != edge) ) {
_imp->_highLightedEdge->setUseHighlight(false);
_imp->_hintInputEdge->hide();
_imp->_hintOutputEdge->hide();
}
_imp->_highLightedEdge = edge;
if ( edge && edge->getSource() && edge->getDest() ) {
///setup the hints edge
///find out if the node is already connected to what the edge is connected
bool alreadyConnected = false;
const std::vector<NodeWPtr > & inpNodes = selectedNode->getNode()->getGuiInputs();
for (std::size_t i = 0; i < inpNodes.size(); ++i) {
if ( inpNodes[i].lock() == edge->getSource()->getNode() ) {
alreadyConnected = true;
break;
}
}
if ( !_imp->_hintInputEdge->isVisible() ) {
if (!alreadyConnected) {
int prefInput = selectedNode->getNode()->getPreferredInputForConnection();
_imp->_hintInputEdge->setInputNumber(prefInput != -1 ? prefInput : 0);
_imp->_hintInputEdge->setSourceAndDestination(edge->getSource(), selectedNode);
_imp->_hintInputEdge->setVisible(true);
}
_imp->_hintOutputEdge->setInputNumber( edge->getInputNumber() );
_imp->_hintOutputEdge->setSourceAndDestination( selectedNode, edge->getDest() );
_imp->_hintOutputEdge->setVisible(true);
} else {
if (!alreadyConnected) {
_imp->_hintInputEdge->initLine();
}
_imp->_hintOutputEdge->initLine();
}
} else if (edge) {
///setup only 1 of the hints edge
if ( _imp->_highLightedEdge && !_imp->_hintInputEdge->isVisible() ) {
if ( edge->isOutputEdge() ) {
int prefInput = selectedNode->getNode()->getPreferredInputForConnection();
_imp->_hintInputEdge->setInputNumber(prefInput != -1 ? prefInput : 0);
_imp->_hintInputEdge->setSourceAndDestination(edge->getSource(), selectedNode);
} else {
_imp->_hintInputEdge->setInputNumber( edge->getInputNumber() );
_imp->_hintInputEdge->setSourceAndDestination( selectedNode, edge->getDest() );
}
_imp->_hintInputEdge->setVisible(true);
} else if ( _imp->_highLightedEdge && _imp->_hintInputEdge->isVisible() ) {
_imp->_hintInputEdge->initLine();
}
} else if (nodeToShowMergeRect) {
nodeToShowMergeRect->setMergeHintActive(true);
selectedNode->setMergeHintActive(true);
_imp->_mergeHintNode = nodeToShowMergeRect;
} else {
selectedNode->setMergeHintActive(false);
_imp->_mergeHintNode.reset();
}
} // NodeGraph::checkForHints
//void GraphEdge::adjust()
void GraphEdge::updateGeometry()
{
if (!sourceNode_ || !destNode_) return;
//sourceNode_->adjustSize();
//destNode_->adjustSize();
// line from center of sourceNode_ to center of destNode_
QRectF sSBR (sourceNode_->sceneBoundingRect());
QRectF dSBR (destNode_->sceneBoundingRect());
QLineF centerline(sSBR.center(), dSBR.center());
// set the source and destination points
if(!sSBR.intersects(dSBR)) {
QPointF po;
if(QLineF::BoundedIntersection == centerline.intersect(QLineF(sSBR.topLeft(), sSBR.topRight()), &po)) sourcePoint = po;
else if(QLineF::BoundedIntersection == centerline.intersect(QLineF(sSBR.bottomRight(), sSBR.topRight()), &po)) sourcePoint = po;
else if(QLineF::BoundedIntersection == centerline.intersect(QLineF(sSBR.bottomLeft(), sSBR.bottomRight()), &po)) sourcePoint = po;
else if(QLineF::BoundedIntersection == centerline.intersect(QLineF(sSBR.topLeft(), sSBR.bottomLeft()), &po)) sourcePoint = po;
if(QLineF::BoundedIntersection == centerline.intersect(QLineF(dSBR.topLeft(), dSBR.topRight()), &po)) destPoint = po;
else if(QLineF::BoundedIntersection == centerline.intersect(QLineF(dSBR.bottomRight(), dSBR.topRight()), &po)) destPoint = po;
else if(QLineF::BoundedIntersection == centerline.intersect(QLineF(dSBR.bottomLeft(), dSBR.bottomRight()), &po)) destPoint = po;
else if(QLineF::BoundedIntersection == centerline.intersect(QLineF(dSBR.topLeft(), dSBR.bottomLeft()), &po)) destPoint = po;
} else {
sourcePoint = destPoint = (sSBR.bottomLeft().y() < dSBR.bottomLeft().y()) ? sSBR.bottomLeft() : dSBR.bottomLeft();
}
QLineF line(sourcePoint, destPoint);
// set label centered in the middle of the arrow
QRectF label (label_->boundingRect());
label.translate(line.pointAt(0.5));
if(sourcePoint != destPoint) label.translate(-label.width()/2, -label.height()/2);
// avoid overlapping
bool overlapped;
while(true) {
overlapped = false;
Graph *graph = reinterpret_cast<Graph *>(scene());
if(!graph) break;
Edges::const_iterator i = graph->edges_.constBegin();
while (i != graph->edges_.constEnd()) {
GraphEdge *e = i.value();
if(e != this && e->label()->geometry().intersects(label)) {
label.moveTo(label.x(), label.y() + 1 + e->label()->geometry().intersected(label).height());
overlapped = true;
}
++i;
}
// node overlapping
Nodes::const_iterator j = graph->nodes_.constBegin();
while (j != graph->nodes_.constEnd()) {
GraphNode *n = j.value();
if(n->geometry().intersects(label)) {
label.moveTo(label.x(), label.y() + 1 + n->geometry().intersected(label).height());
overlapped = true;
}
++j;
}
if(!overlapped) break;
};
label_->setGeometry(label);
labelRect_ = label;
prepareGeometryChange();
QGraphicsLayoutItem::updateGeometry();
}
