QGraphicsEllipseItem * GalaGV::makeMarkerItem(const QString &cords,const QString& sysid, ItemTyps itemtyp,QColor color, Typs typ)
{
QStringList cord = cords.split('/');
qreal x1 = cord.at(0).toFloat();
//qreal y1 = cord.at(1).toFloat();
qreal z1 = -1*cord.at(2).toFloat();
QGraphicsEllipseItem *item = new QGraphicsEllipseItem();
int size;
switch(typ){
case GalaGV::Plani:
item->setBrush(QBrush(Qt::white));
size = 2;
break;
case GalaGV::Mark:
size = 6;
break;
case GalaGV::BigMarker:
size = 10;
break;
}
item->setRect(x1-(size/2),z1-(size/2),size,size);
item->setPen(QPen(color));
item->setData(ID,sysid);
item->setData(Cords,cords);
item->setData(ItemTyp,itemtyp);
return item;
}
void GalaGV::setPlayerLogItems(const QList<Kampf> &list)
{
qDebug() << Q_FUNC_INFO <<list.size();
QString lastCords;
for(int var = 0; var < list.size(); ++var) {
const Kampf &k = list.at(var);
QColor c =Qt::red;
if(var == list.size()-1){
c = Qt::darkMagenta;
}
QGraphicsEllipseItem *item = makeMarkerItem(k.cords,k.sysid,Log,c,Mark);
item->setToolTip(k.toString());
item->show();
item->setFlags(QGraphicsItem::ItemIsSelectable);
item->setData(Bericht,k.berichtUrl);
scene()->addItem(item);
mData->mPlayerLogPlanis.append(item);
if(var>0){
QGraphicsLineItem *lineItem = makeLineItem(k.cords,lastCords,Qt::red);
scene()->addItem(lineItem);
mData->mPlayerLogPlanis.append(lineItem);
}
lastCords = k.cords;
}
}
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 GraphiItemCtrl::OnDrawEvent()
{
switch(i_CurrentType)
{
case ITM_TYPE_LINE:
{
QGraphicsLineItem* pLine = o_ItemScene.addLine(o_PointA.x(),o_PointA.y(),
o_PointB.x(), o_PointB.y(),o_CurrentPen);
int iKey = GetNextItemKey();
QLineF oLine = pLine->line();
map_Lines.insert(iKey,oLine);
map_LineItems.insert(iKey, pLine);
pLine->setData(CUSTDATA_KEY,iKey);
emit NotifyLineAdded(iKey,oLine);
break;
}
case ITM_TYPE_RECTANGLE:
{
double dWidth = o_PointB.x() - o_PointA.x();
double dHeight = o_PointB.y() - o_PointA.y();
QGraphicsRectItem* pRect = o_ItemScene.addRect(o_PointA.x(),o_PointA.y(),
dWidth ,dHeight,o_CurrentPen);
int iKey = GetNextItemKey();
QRectF oRect = pRect->rect();
map_Rects.insert(iKey, oRect);
pRect->setData(CUSTDATA_KEY,iKey);
emit NotifyRectAdded(iKey,oRect);
break;
}
case ITM_TYPE_ELIPSE:
{
double dWidth = o_PointB.x() - o_PointA.x();
double dHeight = o_PointB.y() - o_PointA.y();
QGraphicsEllipseItem* pElipse = o_ItemScene.addEllipse(o_PointA.x(),o_PointA.y(),
dWidth ,dHeight,o_CurrentPen);
int iKey = GetNextItemKey();
pElipse->setData(CUSTDATA_KEY, iKey);
QRectF oRect = pElipse->rect();
map_Elipses.insert(iKey,oRect);
emit NotifyElipseAdded(iKey,oRect);
break;
}
}
}
void GalaGV::showESysteme(const QString &ally, bool show)
{
if(!ally.isEmpty()){
mData->showESysteme.first = ally;
mData->showESysteme.second = show;
int gala =mData->gala;
QString key = ally+";"+QString::number(gala);
if(!mData->eSysteme.contains(key)){
QList<ESystem> l =mDB->eSysteme(ally,gala);
QString cords;
QHash<QString,QGraphicsEllipseItem*> hash;
for (int var = 0; var < l.size(); ++var) {
const ESystem & s = l.at(var);
cords = s.cords;
if(cords== "")
cords = mData->systeme.value(mData->gala).value(s.id)->data(Cords).toString();
QGraphicsEllipseItem *item = makeMarkerItem(cords,s.id,Ally,s.isWerft?Qt::yellow:QColor("#E87A1A"),Mark);
if(s.isChecked){
item->setOpacity(0.5);
}
item->setData(Esystem,QVariant::fromValue(s));
item->setFlag(QGraphicsItem::ItemIsSelectable,true);
item->setToolTip(s.namen.join(",")+" : "+(s.isWerft?"Werft":""));
hash.insert(s.id,item);
scene()->addItem(item);
}
mData->eSysteme.insert(key,hash);
qDebug() << Q_FUNC_INFO << mData->eSysteme.keys()<< mData->eSysteme.value(key).count();
}
if(show)
showItems(mData->eSysteme.value(key));
else
hideItems(mData->eSysteme.value(key));
}
}
bool PSV_ChartItem::addEllipseItem(PSV_CurveInfo &curveInfo)
{
if(curveInfo.m_isHidden)
{
return true;
}
setCurrentAxisType(curveInfo.m_axisType);
QMap<double, double> curveData = curveInfo.m_curveDataMap;
QMapIterator<double, double> iter(curveData);
QPolygonF polygon;
int m_radius = curveInfo.m_pointSize;
double pointY0 = getAxisY(*m_min_y_curP,m_radius);;
QPointF fisrtPoint(0,pointY0);
QString curveName = curveInfo.m_curveName;
QPen pen(curveInfo.m_pointColor);
QBrush brush(curveInfo.m_pointColor);
int count =1;
double previous_time = 1.0 * qrand();
QGraphicsEllipseItem* preItem = NULL;
int index = 1;
while(iter.hasNext())
{
iter.next();
double x = getAxisX(iter.key(),m_radius);
double y = getAxisY(iter.value(),m_radius);
QPointF point(x, y);
if(index == 1)
{
fisrtPoint = QPointF(x + m_radius,pointY0 + m_radius);
polygon.append(fisrtPoint);
}
polygon.append(QPointF(x+m_radius,y+m_radius));
if(index == curveData.count())
{
polygon.append(QPointF(x + m_radius,pointY0 + m_radius));
polygon.append(fisrtPoint);
}
index++;
QGraphicsEllipseItem *ellipse_item = new QGraphicsEllipseItem(this);
ellipse_item->setZValue(m_curveZValue);
ellipse_item->setRect(0,0,2*m_radius,2*m_radius);
ellipse_item->setPos(point);
ellipse_item->setFlag(QGraphicsItem::ItemIsSelectable);
ellipse_item->setPen(pen);
ellipse_item->setBrush(brush);
ellipse_item->setData(E_CURVE_NAME,curveName); //设置属于哪条曲线
ellipse_item->setData(E_AXIS_X,iter.key()); //设置对应的X坐标轴值
ellipse_item->setData(E_PREVIOUS_TIME,previous_time);
ellipse_item->setData(E_NEXT_TIME,previous_time);
ellipse_item->setData(E_POINT_TYPE,EV_FIRST);
ellipse_item->setData(E_ITEM_TYPE,PSV::ellipseItem);
ellipse_item->setToolTip(getToolTipText(iter.key(),iter.value()));
ellipse_item->installSceneEventFilter(this);
if(ellipse_item != NULL)
{
preItem->setData(E_NEXT_TIME,iter.key());
if(count == curveData.count() - 1)
{
ellipse_item->setData(E_POINT_TYPE,EV_LAST);
}
else if(count != 1)
{
ellipse_item->setData(E_POINT_TYPE,EV_MID);
}
}
preItem = ellipse_item;
previous_time = iter.key();
}
curveInfo.m_polygon = polygon;
m_curveZValue++;
return true;
}
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;
}
void CellScene::drawPoints()
{
points.clear();
for (unsigned i = 0; i < y_count; i++)
for (unsigned j = 0; j < x_count; j++) {
QPointF temp;
temp.setY(i * a * sin(M_PI / 3));
if (i % 2 != 0) {
if (j == 0)
temp.setX(a * cos(M_PI / 3));
if (j > 0) {
temp.setX(0);
for (unsigned k = 1; k <= j; k++)
temp.setX(temp.x() + ((k - 1) % 2 + 1) * a);
temp.setX(temp.x() + a * cos(M_PI / 3));
}
}
if (i % 2 == 0) {
if (j == 0)
temp.setX(0);
if (j > 0) {
temp.setX(0);
for (unsigned k = 1; k <= j; k++)
temp.setX(temp.x() + ((k) % 2 + 1) * a);
}
}
points.push_back(temp);
}
QGraphicsEllipseItem * pEllipseItem;
QGraphicsLineItem * pLineItem;
for (unsigned i = 0; i < points.size(); i++)
{
pEllipseItem = new QGraphicsEllipseItem(0, this);
pEllipseItem->setPen(QPen(Qt::blue, 2));
pEllipseItem->setRect(QRect(points[i].x(), points[i].y(), 4, 4));
pEllipseItem->setData(0, "cellpoint");
pEllipseItem->setData(1, "");
pEllipseItem->setData(3,points[i]/a);
}
//for (unsigned j=1;j<=y_count/2;j++)
// {
// for (unsigned i=0;i<x_count/2;i++)
// {
// pLineItem = new QGraphicsLineItem(0, this);
// pLineItem->setLine(points[2*i].x(),points[2*i].y(),points[2*i+j*x_count].x(),points[2*i+j*x_count].y());
// pLineItem->setPen(QPen(Qt::blue, 1));
// pLineItem->setData(0, "line");
// pLineItem = new QGraphicsLineItem(0, this);
// pLineItem->setLine(points[2*i+j*x_count].x(),points[2*i+j*x_count].y(),points[2*i+j*x_count+1].x(),points[2*i+j*x_count+1].y());
// pLineItem->setPen(QPen(Qt::blue, 1));
// pLineItem->setData(0, "line");
// pLineItem = new QGraphicsLineItem(0, this);
// pLineItem->setLine(points[2*i+1].x(),points[2*i+1].y(),points[2*i+j*x_count+1].x(),points[2*i+j*x_count+1].y());
// pLineItem->setPen(QPen(Qt::blue, 1));
// pLineItem->setData(0, "line");
// //pLineItem = new QGraphicsLineItem(points[2*i].x(),points[2*i].y(),points[2*i+j*x_count].x(),points[2*i+j*x_count].y(),this);
// }
//}
}
/**
* 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 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;
}
}
}
}
}
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));
}
}
}
}
