void StitcherView::drawConstraintFit(geometrically_constrained_system *gc){
for(int i = 0;i<gc->n_constraints;i++){
GeometryConstraintType type = gc->constraints[i].type;
double fit = gc->constraints[i].best_fit;
if(type == RadialLineConstraint){
qreal x1,x2,y1,y2;
qreal scale = 10000;
x1 = cos(fit)*scale;
y1 = sin(fit)*scale;
x2 = -x1;
y2 = -y1;
QGraphicsLineItem * item = new QGraphicsLineItem(x1,y1,x2,y2);
QPen p = item->pen();
p.setStyle(Qt::DashLine);
QVector<qreal> dashes;
dashes << 25 << 15;
p.setDashPattern(dashes);
p.setColor(Qt::white);
item->setPen(p);
item->setZValue(10000);
scene()->addItem(item);
constraintFit.append(item);
}else if(type == CircleConstraint){
double radius = fit;
QGraphicsEllipseItem * item = new QGraphicsEllipseItem(-radius,-radius,2*radius,2*radius);
QPen p = item->pen();
p.setStyle(Qt::DashLine);
QVector<qreal> dashes;
dashes << 25 << 15;
p.setDashPattern(dashes);
p.setColor(Qt::white);
item->setPen(p);
item->setZValue(10000);
scene()->addItem(item);
constraintFit.append(item);
}
sp_vector ** cp_g = control_point_list_to_global(gc->constraints[i].points,gc->constraints[i].n_points);
QColor color = QColor::fromHsvF(1.0/3+(double)i/gc->n_constraints,1,1,1);
for(int j = 0;j<gc->constraints[i].n_points;j++){
QGraphicsEllipseItem * point = new QGraphicsEllipseItem(-4,-4,8,8);
point->setZValue(10001);
point->setPos(sp_vector_get(cp_g[j],0),sp_vector_get(cp_g[j],1));
point->setPen(QPen(color, 2));
point->setFlags(point->flags() | QGraphicsItem::ItemIgnoresTransformations);
scene()->addItem(point);
constraintFit.append(point);
}
}
}
static QGraphicsEllipseItem* createPointItem() {
QGraphicsEllipseItem* item = new QGraphicsEllipseItem(-pointRadius, -pointRadius, 2.0 * pointRadius, 2.0 * pointRadius);
item->setBrush(pointBrush);
item->setPen(pointPen);
item->setZValue(1);
return item;
}
void PSV_CircularIndicatorItem::drawColorPie(int zValue)
{
double colorCircleRadius = m_colorCircleRadiusRatio * m_outerRadius;
QPointF topLeftPot(m_rect.center().x()-colorCircleRadius, m_rect.center().y()-colorCircleRadius);
QPointF bottomRightPot(m_rect.center().x()+colorCircleRadius, m_rect.center().y()+colorCircleRadius);
QRectF colorCircleRect=QRectF(topLeftPot, bottomRightPot);
QMapIterator<double,QColor> iter(m_levelInfos);
int startAngle = 225 * 16;
double dValue = m_max -m_min;
if(qAbs(dValue) < PSV_ZEOR)
{
dValue = 100;
m_max = 100;
m_min = 0;
}
int spanAngle = 0;
int topAngle = 0;
while(iter.hasNext())
{
iter.next();
spanAngle = (int)(16 * 270 * iter.key()) - topAngle;
topAngle += spanAngle;
QGraphicsEllipseItem* item = new QGraphicsEllipseItem(this);
item->setRect(colorCircleRect);
item->setStartAngle(startAngle - spanAngle);
item->setSpanAngle(spanAngle);
item->setPen(QPen(Qt::NoPen));
item->setBrush(QBrush(iter.value()));
item->setZValue(zValue);
startAngle = startAngle - spanAngle;
}
}
void QGraphicsGuideView::pathEndEvent(QMouseEvent *event) {
cout << "Drawing Path (Before Simplification): " << _drawingPath.elementCount() << endl;
// simplifyPainterPath();
if (_pathMode == FillMode) {
QPainter painter(&_userDrawingCanvas);
painter.setRenderHints(0);
painter.setBrush(QBrush(Qt::yellow,Qt::SolidPattern));
painter.setPen(Qt::NoPen);
painter.drawPath(_drawingPath);
painter.end();
this->scene()->removeItem(_drawingPathItem);
_drawingPathItem = NULL;
_updateRect = _drawingPath.boundingRect();
userDrawingToSlice();
sliceToLabelImage(true);
updateLabelItem();
sliceToVolume(true);
} else {
simplifyPainterPath();
cout << "Drawing Path (After Simplification): " << _drawingPath.elementCount() << endl;
for (int i = 0; i < _drawingPath.elementCount(); i++) {
QPainterPath::Element e = _drawingPath.elementAt(i);
QGraphicsEllipseItem* el = new QGraphicsEllipseItem(e.x-2,e.y-2,5,5,_drawingPathItem);
el->setBrush(QBrush(0xFFFFBBDD, Qt::SolidPattern));
el->setOpacity(1);
el->setZValue(2);
}
}
}
TmoodView::TmoodView(QWidget *parent) :
QGraphicsView(parent)
{
setScene(new QGraphicsScene(this));
setRenderHints(QPainter::Antialiasing | QPainter::TextAntialiasing);
setHorizontalScrollBarPolicy(Qt::ScrollBarAlwaysOff);
setVerticalScrollBarPolicy(Qt::ScrollBarAlwaysOff);
setFrameShape(QFrame::NoFrame);
setStyleSheet("background-color: transparent");
QPen commonPen(Qt::darkRed, 5, Qt::SolidLine, Qt::RoundCap);
QGraphicsEllipseItem *face = scene()->addEllipse(0, 0, 400, 400, commonPen, QBrush(Qt::yellow));
face->setZValue(1);
face->setGraphicsEffect(new QGraphicsDropShadowEffect);
QGraphicsEllipseItem *eye1 = scene()->addEllipse(100, 100, 20, 20, commonPen);
eye1->setZValue(2);
QGraphicsEllipseItem *eye2 = scene()->addEllipse(280, 100, 20, 20, commonPen);
eye2->setZValue(2);
QPainterPath path;
path.moveTo(200, 150);
path.cubicTo(180, 250, 200, 250, 200, 200);
QGraphicsPathItem *nose = scene()->addPath(path, commonPen);
nose->setZValue(2);
m_mood = new QGraphicsPathItem();
scene()->addItem(m_mood);
m_mood->setPen(commonPen);
m_mood->setZValue(3);
setMood(1.0);
}
void QGraphicsVolumeView::addWorkingSetItem(QGraphicsItem *sliceItem) {
const static int markerSize = 9;
QRectF rect = sliceItem->boundingRect();
QRectF ellipse = QRectF(rect.width() - markerSize - 3, 3, markerSize, markerSize);
QGraphicsEllipseItem* rectItem = new QGraphicsEllipseItem(ellipse, sliceItem);
rectItem->setZValue(1);
rectItem->setPen(QPen(Qt::green, 3));
rectItem->setData(AnnotationType, QVariant(WorkingSet));
}
void PSV_CircularIndicatorItem::drawCoverCircle(int zValue)
{
double coverCircleRadius = m_coverCircleRadiusRatio * m_outerRadius;
QRectF rect(m_rect.center().x()-coverCircleRadius, m_rect.center().y()-coverCircleRadius, coverCircleRadius*2, coverCircleRadius*2);
QGraphicsEllipseItem* item = new QGraphicsEllipseItem(rect, this);
item->setPen(QPen(Qt::NoPen));
item->setBrush(QBrush(QColor(130, 130, 130)));
item->setZValue(zValue);
}
GameBoardScene::GameBoardScene(int newWidth, int newHeight, QObject *parent) : QGraphicsScene(parent), width(newWidth), height(newHeight), acceptEvents(true)
{
//kDebug() << "GameBoardScene::GameBoardScene()";
for(int i = 0; i < (2*width*height + width + height); i++)
{
lineList.append(false); //simply fill array with 'false's
}
spacing = 40; //this hard coding doesn't matter since auto-resizing exists :)
for(int iWidth = 0; iWidth <= width; iWidth++)
{
for(int iHeight = 0; iHeight <= height; iHeight++)
{
int x = iWidth*spacing;
int y = iHeight*spacing;
QGraphicsEllipseItem *dot = new QGraphicsEllipseItem(QRectF(-2,-2,4,4));
dot->moveBy(x,y);
dot->setBrush(Qt::SolidPattern);
dot->setZValue(20); // set the elevation, the dot's are on top
addItem(dot);
}
}
QPen feintPen(Qt::DotLine); //for the guidelines between dots
feintPen.setWidth(1);
feintPen.setColor(Qt::lightGray);
for(int iWidth = 0; iWidth <= width; iWidth++)
{
addLine(QLineF(spacing*iWidth, 0, spacing*iWidth, spacing*height), feintPen);
}
for(int iHeight = 0; iHeight <= height; iHeight++)
{
addLine(QLineF(0, spacing*iHeight, spacing*width, spacing*iHeight), feintPen);
}
setBackgroundBrush(QBrush(Qt::white));
indicatorLine = new QGraphicsLineItem(1,1,1,1);
indicatorLine->setZValue(10);
indicatorLine->setPen(QPen(Qt::yellow, 2.5));
indicatorLine->hide();
addItem(indicatorLine);
QGraphicsEllipseItem tempItem;
QGraphicsEllipseItemType = tempItem.type();
qreal border = 10;
QRectF rect = sceneRect();
rect.setLeft(rect.left() - border);
rect.setRight(rect.right() + border);
rect.setTop(rect.top() - border);
rect.setBottom(rect.bottom() + border);
setSceneRect(rect);
}
void CSharedPainterScene::drawLineStart( const QPointF &pt, const QColor &clr, int width )
{
double x = pt.x() - (double(width) / 2.f);
double y = pt.y() - (double(width) / 2.f);
QRectF rect( x, y, width, width);
QGraphicsEllipseItem *item = addEllipse( rect, QPen(clr, 1), QBrush(clr) );
item->setZValue( currentZValue() );
tempLineItemList_.push_back( item );
}
void PSV_CircularIndicatorItem::drawCoverBall(int zValue)
{
qreal ballRadius=m_outerRadius * m_coverBallRadiusRatio;
QRadialGradient ballGradient(m_rect.center(), ballRadius, m_rect.center());
ballGradient.setColorAt(0.0, QColor(140, 140, 140));
ballGradient.setColorAt(0.7, QColor(140, 140, 140));
ballGradient.setColorAt(1.0, QColor(60, 60, 60));
//==================
QRectF rect(m_rect.center().x()-ballRadius, m_rect.center().y()-ballRadius, ballRadius*2, ballRadius*2);
QGraphicsEllipseItem* item = new QGraphicsEllipseItem(rect, this);
item->setPen(QPen(Qt::NoPen));
item->setBrush(ballGradient);
item->setZValue(zValue);
}
void HostItem::createJobHalo(const Job &job)
{
QGraphicsEllipseItem *halo = new QGraphicsEllipseItem(
centerPosX(), centerPosY(), m_baseWidth, m_baseHeight,
this, scene());
halo->setZValue(70 - m_jobHalos.size());
halo->setPen(QPen(Qt::NoPen));
halo->show();
m_jobHalos.insert(job, halo);
updateHalos();
}
void PSV_CircularIndicatorItem::drawInnerCircle(int zValue)
{
qreal innerRadius = m_innerRadiusRatio * m_outerRadius;
QRadialGradient innerGradient(m_rect.center(), innerRadius, m_rect.center());
innerGradient.setColorAt(0.0, QColor(130, 130, 130));
innerGradient.setColorAt(0.7, QColor(130, 130, 130));
innerGradient.setColorAt(1.0, QColor(80, 80, 80));
//==
QPen pen(Qt::NoPen);
QRectF rect(m_rect.center().x()-innerRadius, m_rect.center().y()-innerRadius, innerRadius*2, innerRadius*2);
QGraphicsEllipseItem* item = new QGraphicsEllipseItem(rect, this);
item->setPen(pen);
item->setBrush(innerGradient);
item->setZValue(zValue);
}
// draws the cv points
void CCurveScene::drawPoints()
{
while (_circleObjects.size()) {
delete _circleObjects[0];
_circleObjects.erase(_circleObjects.begin());
}
const int numCV = _cvs.size();
for (int i = 0; i < numCV; i++) {
const T_CURVE::CV& pt = _cvs[i];
QPen pen;
if (i == _selectedItem) {
pen = QPen(QColor(255,170,0),1.0);
} else {
pen = QPen(Qt::black,1.0);
}
_circleObjects.push_back(addEllipse(pt._pos*_width-4, _height+3, 8, 8, pen, QBrush(QColor(int(255 * pt._val[0] +0.5), int(255 * pt._val[1] + 0.5), int(255 * pt._val[2] + 0.5)))));
QGraphicsEllipseItem *circle = _circleObjects.back();
circle->setFlag(QGraphicsItem::ItemIsMovable, true);
circle->setZValue(2);
}
}
void PSV_CircularIndicatorItem::drawOuterCircle(int zValue)
{
QRadialGradient outerGradient(m_rect.center(), m_outerRadius, m_rect.center());
outerGradient.setColorAt(0.0, QColor(200, 200, 200));
outerGradient.setColorAt(0.9, QColor(80, 80, 80));
outerGradient.setColorAt(0.95, QColor(180, 180, 180));
outerGradient.setColorAt(1.0, QColor(80, 80, 80));
//==========================
QPen pen(Qt::NoPen);
QGraphicsEllipseItem* item = new QGraphicsEllipseItem(this);
item->setRect(m_rect.center().x() - m_outerRadius, m_rect.center().y() - m_outerRadius, m_outerRadius*2, m_outerRadius*2);
item->setPen(pen);
item->setBrush(outerGradient);
item->setZValue(zValue);
{//TEST
QGraphicsRectItem *item = new QGraphicsRectItem(m_rect, this);
item->setPen(QPen(Qt::blue));
// item->setPen();
}
}
void GalaGV::setMomentPos(QString index)
{
qDebug() << Q_FUNC_INFO ;
mData->momentPos.first =index;
QGraphicsEllipseItem *item = mData->systeme.value(mData->gala).value(mData->momentPos.first);
if(item != NULL){
QGraphicsEllipseItem *newItem = makeMarkerItem(item->data(Cords).toString(),mData->momentPos.first,Moment,QColor("#00D0F0"),Mark);
qDebug() << mData->momentPos.second;
newItem->setZValue(2);
scene()->addItem(newItem);
ensureVisible(newItem);
mSecondView->ensureVisible(newItem);
if(mData->momentPos.second != NULL)
delete mData->momentPos.second;
mData->momentPos.second = newItem;
calcNearSys(newItem->data(Cords).toString());
}
}
void GraphViewer::onSceneMousePress(QGraphicsSceneMouseEvent *mouseEvent)
{
if (_vertices.isEmpty())
_initialText->setVisible(false);
if (_scene.items(QRectF(
mouseEvent->scenePos().x() - VERTEX_SIZE*0.5,
mouseEvent->scenePos().y() - VERTEX_SIZE*0.5,
VERTEX_SIZE,
VERTEX_SIZE)
).isEmpty())
{
// Create new vertex
QGraphicsEllipseItem * vertex = _scene.addEllipse(
QRectF(-VERTEX_SIZE*0.5, -VERTEX_SIZE*0.5, VERTEX_SIZE, VERTEX_SIZE),
QPen(Qt::black, 0),
QBrush(Qt::white)
);
vertex->setTransform(
QTransform::fromTranslate(mouseEvent->scenePos().x(), mouseEvent->scenePos().y())
);
vertex->setZValue(VERTEX_CIRCLE_Z);
_vertices << vertex;
int id = _vertices.size()-1;
vertex->setData(KEY_VERTEX_ID, id);
QGraphicsSimpleTextItem * vertexId = _scene.addSimpleText(QString("%1").arg(id+1));
vertexId->setParentItem(vertex);
vertexId->setTransform(
QTransform::fromScale(0.005, 0.005)
* QTransform::fromTranslate(-VERTEX_SIZE*( (id < 9) ? 0.18 : 0.28 ), -VERTEX_SIZE*0.35)
);
vertexId->setZValue(VERTEX_TEXT_Z);
}
else
{
// Propose to draw new edge
QGraphicsItem * item = _scene.itemAt(mouseEvent->scenePos(), QTransform());
if (qgraphicsitem_cast<QGraphicsEllipseItem*>(item)
|| qgraphicsitem_cast<QGraphicsSimpleTextItem*>(item))
{
QGraphicsEllipseItem* vertex = qgraphicsitem_cast<QGraphicsEllipseItem*>(item->parentItem());
if (!vertex)
vertex = qgraphicsitem_cast<QGraphicsEllipseItem*>(item);
if (vertex)
{
_isDrawingEdge=true;
_drawingEdge = _scene.addLine(0.0,
0.0,
mouseEvent->scenePos().x()-vertex->scenePos().x(),
mouseEvent->scenePos().y()-vertex->scenePos().y(),
QPen(Qt::black, 0));
_drawingEdge->setTransform(QTransform::fromTranslate(vertex->scenePos().x(), vertex->scenePos().y()));
_drawingEdge->setZValue(VERTEX_CIRCLE_Z);
_drawingEdge->setData(KEY_EDGE_VERTEX1, vertex->data(KEY_VERTEX_ID));
}
}
}
}
void GameWidget::setController(GameController *gc)
{
_gameController = gc;
QBrush brush(QColor("red"));
QPen pen(brush, 2);
QPen pacmanPen(QBrush(QColor("yellow")), 2);
QPen ghostPen(QBrush(QColor("cyan")), 2);
// creation de la map
unsigned int vertexNumber = _gameController->getVertexNumber();
for(unsigned int i = 0; i < vertexNumber; ++i)
{
QGraphicsEllipseItem * ell = new QGraphicsEllipseItem( -GameWidget::RADIUS,
-GameWidget::RADIUS,
GameWidget::RADIUS * 2,
GameWidget::RADIUS * 2 );
ell->setPen( pen );
ell->setZValue(1);
_vertex.push_back( ell );
_scene->addItem( _vertex.back() );
}
positionVertex(_vertex.begin(), _vertex.end());
linkVertex(_scene, _vertex);
// creation du pacman et des ghosts
_pacman = new QGraphicsEllipseItem( -GameWidget::RADIUS + GameWidget::THICK * 2,
-GameWidget::RADIUS + GameWidget::THICK * 2,
GameWidget::RADIUS * 2 - GameWidget::THICK * 4,
GameWidget::RADIUS * 2 - GameWidget::THICK * 4
);
_pacman->setPen(pacmanPen);
_scene->addItem(_pacman);
this->updatePacman();
std::vector<unsigned int> ghostsPos = _gameController->getGhost();
unsigned int ghostNumber = ghostsPos.size();
for( unsigned int i = 0; i < ghostNumber; ++i )
{
QGraphicsEllipseItem * ghost = new QGraphicsEllipseItem( -GameWidget::RADIUS + GameWidget::THICK,
-GameWidget::RADIUS + GameWidget::THICK,
GameWidget::RADIUS * 2 - GameWidget::THICK * 2,
GameWidget::RADIUS * 2 - GameWidget::THICK * 2
);
ghost->setPen(ghostPen);
_scene->addItem(ghost);
_ghosts.push_back(ghost);
}
this->updateGhost();
QObject::connect(_btnNextMove, SIGNAL(clicked()), this, SLOT(nextMove()));
_gameController->setPacmanAI(_option.getPacmanAI());
//_gameController->benchmark(1000);
//_gameController->reset();
_view->setFocus();
}
void StitcherView::mouseReleaseEvent( QMouseEvent * event){
ImageView::mouseReleaseEvent(event);
if(mode == Line && event->button() & Qt::LeftButton){
setMode(Default);
QGraphicsLineItem * line = new QGraphicsLineItem(QLineF(mapToScene(lineOrigin),mapToScene(lineEnd)));
line->setData(0,QString("Helper"));
line->setZValue(11);
QPen pen = line->pen();
pen.setColor(Qt::white);
pen.setStyle(Qt::SolidLine);
line->setPen(pen);
graphicsScene->addItem(line);
}else if(mode == Circle && event->button() & Qt::LeftButton){
setMode(Default);
QPointF lineOriginF = mapToScene(lineOrigin);
QPointF lineEndF = mapToScene(lineEnd);
QPointF circleCenter = (lineOriginF+lineEndF)/2;
qreal circleRadius = sqrt((lineOriginF-lineEndF).x()* (lineOriginF-lineEndF).x()+
(lineOriginF-lineEndF).y()* (lineOriginF-lineEndF).y())/2;
if(QApplication::keyboardModifiers() & Qt::ShiftModifier){
circleCenter = mapFromScene(QPointF(0,0));
circleRadius = sqrt((circleCenter-lineEnd).x()* (circleCenter-lineEnd).x()+
(circleCenter-lineEnd).y()* (circleCenter-lineEnd).y());
circleCenter = QPointF(0,0);
}
QGraphicsEllipseItem * circle = new QGraphicsEllipseItem(QRect(circleCenter.x()-circleRadius,circleCenter.y()-circleRadius,circleRadius*2,circleRadius*2));
circle->setData(0,QString("Helper"));
circle->setZValue(11);
QPen pen = circle->pen();
pen.setColor(Qt::white);
pen.setStyle(Qt::SolidLine);
circle->setPen(pen);
graphicsScene->addItem(circle);
}else if(mode == AddPoint && event->button() & Qt::LeftButton){
QList<QGraphicsItem *> it = items(event->pos());
for(int i = 0; i < it.size(); i++){
if(ImageItem * item = qgraphicsitem_cast<ImageItem *>(it.at(i))){
item->addControlPoint(item->mapFromScene(mapToScene(event->pos())));
}
}
}else if(mode == DeletePoint && event->button() & Qt::LeftButton){
QList<QGraphicsItem *> it = items(event->pos());
for(int i = 0; i < it.size(); i++){
if(ImageItem * item = qgraphicsitem_cast<ImageItem *>(it.at(i))){
item->deleteControlPoint(item->mapFromScene(mapToScene(event->pos())));
}
}
}else if(mode == DeleteGuide && event->button() & Qt::LeftButton){
QList<QGraphicsItem *> it = items(event->pos());
QPointF pos = mapToScene(event->pos());
/* 10 px tolerance radius, delete the closest */
for(int i = 0; i < it.size(); i++){
if(QString("Helper") == it[i]->data(0)){
QGraphicsEllipseItem * elipse = qgraphicsitem_cast<QGraphicsEllipseItem *>(it[i]);
if(elipse){
// Check if click position close to the line
QPointF origin = elipse->rect().center();
qreal radius = elipse->rect().height()/2;
QPointF d = origin-pos;
if(abs(sqrt(d.x()*d.x()+d.y()*d.y())-radius) < 10){
delete elipse;
}
}
QGraphicsLineItem * line = qgraphicsitem_cast<QGraphicsLineItem *>(it[i]);
if(line){
delete line;
}
}
}
}
}
/**
* Evento chamado quando o mouse é clicado
*/
void GraphicsScene::mousePressEvent(QGraphicsSceneMouseEvent *mouseEvent)
{
if(!running)
{
QPointF pos = mouseEvent->scenePos(); //posição do mouse na hora do clique
//qDebug() << "x: " << pos.x() << " y: " << pos.y();
bool colidiu = false;
QList<QGraphicsItem *> cidades = this->items(); //lista de cidades na tela
if(mouseEvent->button() == Qt::LeftButton) //adicionar uma cidade
{
QRectF bboxCidade(pos.x(),pos.y(), cidadeWidth, cidadeHeigth); //bouding box da elipse da cidade
//gradiente de cores de cada cidade
QRadialGradient gradient(10, 10, 10, 10, 10);
gradient.setColorAt(0, QColor::fromRgbF(0.5, 0.8, 0.7, 1));
gradient.setColorAt(1, QColor::fromRgbF(0, 0, 0, 0));
gradient.setSpread(QGradient::ReflectSpread);
QBrush brush(gradient);
QGraphicsEllipseItem *cidade = new QGraphicsEllipseItem(bboxCidade);
cidade->setPen(QPen(Qt::black, 1, Qt::SolidLine, Qt::RoundCap, Qt::RoundJoin));
cidade->setBrush(brush);
cidade->setZValue(1.0);
for(int i = 0; i < cidades.size(); i++) //percorrendo a lista de cidades
{
if(cidades.at(i)->collidesWithItem(cidade) && cidades.at(i)->data(1).toBool())
{
colidiu = true;
break;
}
}
if(!colidiu) //se não houve colisão
{
cidade->setData(0, Cidade::getLastId() + 1);
cidade->setData(1, 1);
cidade->setData(4, pos);
this->addItem(cidade);
if(lastPos.x() != -10.0 && lastPos.y() != -10.0)
{
QPoint cids(Cidade::getLastId(),Cidade::getLastId() + 1);
//this->drawEdge(lastPos, pos, cids);
}
lastPos = pos;
emit cidadeCriada(pos); //sinal emitido quando uma cidade é criada
}
}
else if(mouseEvent->button() == Qt::RightButton) //remover uma cidade
{
for(int i = 0; i < cidades.size(); i++) //percorrendo a lista de cidades
{
if(cidades.at(i)->contains(pos) && cidades.at(i)->data(1).toInt() == 1) //o mouse foi clicado em cima de uma cidade
{
int chave = cidades.at(i)->data(0).toInt();
this->removeItem(cidades.at(i));
//this->removeEdge(chave);
if(items().size() == 0) lastPos = QPointF(-10,-10);
emit cidadeRemovida(chave); //sinal emitido quando uma cidade removida
}
}
}
}
}
void Gui::createLaserDistanceObjects()
{
// set colors
colorHelpLine = Qt::gray;
colorHelpLineText = Qt::gray;
//--------------------------------------------------------------
// create the FRONT laser line distances with text
//--------------------------------------------------------------
laserDistanceLineListFront = new QList <QGraphicsEllipseItem*>();
laserDistanceTextFront = new QList <QGraphicsSimpleTextItem*>();
// create and add twelve semi circles and text
for (int i=0; i<LASERDISTANCECIRCLES; i++)
{
// create semi circles
// position doesn't matter, because of moving circles in setLaserDistancePosition()! So we just take 0,0 here.
QGraphicsEllipseItem *semiCircle = new QGraphicsEllipseItem(0, 0, LASERDISTANCEFIRSTCIRCLE + (i*LASERDISTANCEDISTANCE), LASERDISTANCEFIRSTCIRCLE + (i*LASERDISTANCEDISTANCE));
// create an (empty) text
QGraphicsSimpleTextItem *text = new QGraphicsSimpleTextItem();
// set the start angle of the circle
semiCircle->setStartAngle(180*16);
// set the span angle of the circle
semiCircle->setSpanAngle(180*16);
// set semiCircle color
semiCircle->setPen(QPen(colorHelpLine));
// set text color
text->setBrush(QBrush(colorHelpLine));
// setting to the highest layer level
semiCircle->setZValue(4);
text->setZValue(4);
// add semiCircle to QList
laserDistanceLineListFront->append(semiCircle);
laserDistanceTextFront->append(text);
// add semiCircle to scene
scene->addItem(semiCircle);
// add text to scene
scene->addItem(text);
}
//--------------------------------------------------------------
// create the REAR laser line distances with text
//--------------------------------------------------------------
laserDistanceLineListRear = new QList <QGraphicsEllipseItem*>();
laserDistanceTextRear = new QList <QGraphicsSimpleTextItem*>();
// create and add twelve semi circles and text
for (int i=0; i<LASERDISTANCECIRCLES; i++)
{
// create semi circles
// position doesn't matter, because of moving circles in setLaserDistancePosition()! So we just take 0,0 here.
QGraphicsEllipseItem *semiCircle = new QGraphicsEllipseItem(0, 0, LASERDISTANCEFIRSTCIRCLE + (i*LASERDISTANCEDISTANCE), LASERDISTANCEFIRSTCIRCLE + (i*LASERDISTANCEDISTANCE));
// create an (empty) text
QGraphicsSimpleTextItem *text = new QGraphicsSimpleTextItem();
// set the start angle of the circle
semiCircle->setStartAngle(0);
// set the span angle of the circle
semiCircle->setSpanAngle(180*16);
// set semiCircle color
semiCircle->setPen(QPen(colorHelpLine));
// set text color
text->setBrush(QBrush(colorHelpLine));
// setting to the highest layer level
semiCircle->setZValue(4);
text->setZValue(4);
// add semiCircle to QList
laserDistanceLineListRear->append(semiCircle);
laserDistanceTextRear->append(text);
// add semiCircle to scene
scene->addItem(semiCircle);
// add text to scene
scene->addItem(text);
}
}
QGraphicsEllipseItem *GraphRenderer::addNode(repo::core::model::RepoNode *node, float row, float column)
{
float spacing = nodeDiameter / 4.0f;
QPen pen;
pen.setWidthF(penWidth);
QBrush brush(Qt::SolidPattern);
QColor dark;
QColor light;
switch (node->getTypeAsEnum())
{
case repo::core::model::NodeType::CAMERA :
dark = Qt::darkMagenta;
light = Qt::magenta;
break;
case repo::core::model::NodeType::MATERIAL :
dark = Qt::darkRed;
light = Qt::red;
break;
case repo::core::model::NodeType::MESH :
dark = Qt::darkBlue;
light = Qt::blue;
break;
case repo::core::model::NodeType::METADATA :
dark = Qt::darkCyan;
light = Qt::cyan;
break;
case repo::core::model::NodeType::REFERENCE :
dark = repo::gui::primitive::RepoColor::fromHex("#6e8b3d"); // DarkOliveGreen4
light = repo::gui::primitive::RepoColor::fromHex("#caff70"); // DarkOliveGreen1
break;
case repo::core::model::NodeType::REVISION :
dark = repo::gui::primitive::RepoColor::fromHex("#68228b"); // DarkOrchid4
light = repo::gui::primitive::RepoColor::fromHex("#bf3eff"); // DarkOrchid1
break;
case repo::core::model::NodeType::TEXTURE :
dark = Qt::darkYellow;
light = Qt::yellow;
break;
case repo::core::model::NodeType::TRANSFORMATION :
dark = Qt::darkGreen;
light = Qt::green;
break;
case repo::core::model::NodeType::UNKNOWN :
default :
dark = Qt::darkGray;
light = Qt::gray;
}
pen.setColor(dark);
brush.setColor(light);
qreal x = column * (nodeDiameter + spacing);
qreal y = row * (nodeDiameter + spacing) * 4;
QGraphicsEllipseItem *ellipse = addEllipse(
0, 0, nodeDiameter, nodeDiameter, pen, brush);
ellipse->setPos(x, y);
ellipse->setZValue(1.0f);
//--------------------------------------------------------------------------
QString toolTip;
toolTip += tr("_id") + "\t: '" + uuidToQString(node->getUniqueID()) + "',\n";
toolTip += tr("sid") + "\t: '" + uuidToQString(node->getSharedID()) + "',\n";
if (!node->getName().empty())
toolTip += tr("name") + "\t: '" + QString::fromStdString(node->getName()) + "',\n";
toolTip += tr("type") + "\t: '" + QString::fromStdString(node->getType()) + "'";
ellipse->setToolTip(toolTip);
//--------------------------------------------------------------------------
QVariant var;
var.setValue(node);
ellipse->setData(0, var);
//--------------------------------------------------------------------------
return ellipse;
}
