QGraphicsItem *addSmiley() {
QPen thickPen(Qt::black);
thickPen.setWidth(2);
// add face
QGraphicsEllipseItem *face = new QGraphicsEllipseItem(QRect(-50, -50, 100, 100));
face->setPen(Qt::NoPen);
face->setBrush(Qt::yellow);
// add eyes
QGraphicsEllipseItem *leftEye = new QGraphicsEllipseItem(QRectF(-6, -12, 12, 24), face);
leftEye->setPen(thickPen);
leftEye->setBrush(Qt::white);
leftEye->setPos(-15, -25);
QGraphicsEllipseItem *rightEye = new QGraphicsEllipseItem(QRectF(-6, -12, 12, 24), face);
rightEye->setPen(thickPen);
rightEye->setBrush(Qt::white);
rightEye->setPos(15, -25);
// add smile
QPainterPath smileArc;
QRect rect(-33, -15, 66, 50);
smileArc.arcMoveTo(rect, 0);
smileArc.arcTo(rect, 0, -180);
QGraphicsPathItem *smile = new QGraphicsPathItem(smileArc, face);
smile->setPen(thickPen);
return face;
}
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);
}
}
}
void subObservationVisualiserBase::constructStandardPoints(const observation& subObs)
{
assert(standardPointsItem);
std::size_t nVertices = boost::num_vertices(contextObj.getGraph());
const std::vector<context::vertexPosition>& vertexPositions = contextObj.getVertexPositions();
const vertexState* state = subObs.getState();
QPen blackPen(QColor("black"));
QBrush blackBrush(QColor("black"));
QPen redPen(QColor("red"));
QBrush redBrush(QColor("red"));
QBrush noBrush;
noBrush.setStyle(Qt::NoBrush);
for(std::size_t vertexCounter = 0; vertexCounter < nVertices; vertexCounter++)
{
context::vertexPosition currentPosition = vertexPositions[vertexCounter];
float x = currentPosition.first;
float y = currentPosition.second;
QGraphicsEllipseItem* newItem = new QGraphicsEllipseItem(x - pointSize/2, y - pointSize/2, pointSize, pointSize, standardPointsItem);
if(state[vertexCounter].state == FIXED_OFF)
{
newItem->setBrush(noBrush);
newItem->setPen(blackPen);
}
else if(state[vertexCounter].state == FIXED_ON)
{
newItem->setBrush(blackBrush);
newItem->setPen(blackPen);
}
else if(state[vertexCounter].state == UNFIXED_OFF)
{
newItem->setBrush(noBrush);
newItem->setPen(redPen);
}
else if(state[vertexCounter].state == UNFIXED_ON)
{
newItem->setBrush(redBrush);
newItem->setPen(redPen);
}
else
{
throw std::runtime_error("Internal error");
}
}
}
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 GraphicsBoard::setHighlights(const QList<Chess::Square>& squares)
{
clearHighlights();
if (squares.isEmpty())
return;
TargetHighlights* targets = new TargetHighlights(this);
QRectF rect;
rect.setSize(QSizeF(m_squareSize / 3, m_squareSize / 3));
rect.moveCenter(QPointF(0, 0));
QPen pen(Qt::white, m_squareSize / 20);
QBrush brush(Qt::black);
for (const auto& sq : squares)
{
QGraphicsEllipseItem* dot = new QGraphicsEllipseItem(rect, targets);
dot->setCacheMode(DeviceCoordinateCache);
dot->setPen(pen);
dot->setBrush(brush);
dot->setPos(squarePos(sq));
}
m_highlightAnim = new QPropertyAnimation(targets, "opacity");
targets->setParent(m_highlightAnim);
m_highlightAnim->setStartValue(0.0);
m_highlightAnim->setEndValue(1.0);
m_highlightAnim->setDuration(500);
m_highlightAnim->setEasingCurve(QEasingCurve::InOutQuad);
m_highlightAnim->start(QAbstractAnimation::KeepWhenStopped);
}
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;
}
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;
}
QGraphicsItemGroup* SDefaultBrush::renderPath(QPainterPath path){
QGraphicsItemGroup* pGroup = new QGraphicsItemGroup();
QPen pen;
QColor c1 = mColor;
QColor c2 = mColor;
int alpha1 = 3*mColor.alpha()/4;
c1.setAlpha(alpha1);
int alpha2 = alpha1*mHardness/100;
c2.setAlpha(alpha2);
pen.setColor(QColor(Qt::transparent));
QRadialGradient gradient(500, 500, 500, 500, 500);
gradient.setColorAt(0, c1);
gradient.setColorAt(1, c2);
QBrush brush(gradient);
for(int i=0; i<path.length(); i+=(mWidth/2)*mSpacing){
QGraphicsEllipseItem* pEllipse = new QGraphicsEllipseItem();
pEllipse->setPen(pen);
pEllipse->setBrush(brush);
QPointF pt = path.pointAtPercent(path.percentAtLength(i));
pEllipse->setRect(pt.x()-mWidth/2, pt.y()-mWidth/2, mWidth, mWidth);
pGroup->addToGroup(pEllipse);
}
return pGroup;
}
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);
}
void MainWindow::slotAddEllipseItem() //在场景中加入一个椭圆形图元
{
QGraphicsEllipseItem *item = new QGraphicsEllipseItem(QRectF(0,0,80, 60));
item->setPen(Qt::NoPen);
item->setBrush(QColor(qrand()%256,qrand()%256,qrand()%256));
item->setFlag(QGraphicsItem::ItemIsMovable);
scene->addItem(item);
item->setPos((qrand()%int(scene->sceneRect().width()))-200,(qrand()%int(scene->sceneRect().height()))-200);
}
void IdentityItem::updateItem( const Polka::Identity &identity )
{
m_identity = identity;
foreach( QGraphicsItem *child, childItems() ) {
delete child;
}
if ( identity.type() == "group" ) {
int circleSize = m_itemSize + 14;
QGraphicsEllipseItem *groupCircle = new QGraphicsEllipseItem( this );
groupCircle->setRect( -circleSize/2, -circleSize/2,
circleSize, circleSize );
QPen pen;
pen.setBrush( Qt::white );
pen.setWidth( 4 );
groupCircle->setPen( pen );
}
QPixmap pixmap = m_model->pixmap( identity );
QGraphicsItem *item = new QGraphicsPixmapItem( pixmap, this );
item->setPos( -pixmap.width() / 2, -pixmap.height() / 2 );
QGraphicsTextItem *textItem = new QGraphicsTextItem( identity.name().value() );
int textWidth = textItem->boundingRect().width();
int textHeight = textItem->boundingRect().height();
m_nameItem = new RoundedRectItem( this );
m_nameItem->setRect( 0, 0, textWidth, textHeight );
m_nameItem->setBrush( QColor( 255,255,230 ) );
m_nameItem->setZValue( 10 );
textItem->setParentItem( m_nameItem );
m_nameItem->setPos( - textWidth / 2, 30 );
m_fanMenu = new FanMenu( this );
m_fanMenu->setZValue( 50 );
FanMenuItem *menuItem = m_fanMenu->addItem( i18n("Remove") );
connect( menuItem, SIGNAL( clicked() ), SLOT( emitRemoveIdentity() ) );
m_checkMenuItem = m_fanMenu->addItem( i18n("Check") );
connect( m_checkMenuItem, SIGNAL( clicked() ), SLOT( checkItem() ) );
if ( identity.type() == "group" ) {
menuItem = m_fanMenu->addItem( i18n("Go to") );
} else {
menuItem = m_fanMenu->addItem( i18n("Show") );
}
connect( menuItem, SIGNAL( clicked() ), SLOT( emitShowIdentity() ) );
m_fanMenu->setupItems();
hidePopups();
}
SEXP qt_qgraphicsEllipseItem(SEXP x, SEXP y,
SEXP width, SEXP height,
SEXP pars)
{
double
px = asReal(x), py = asReal(y),
pw = asReal(width), ph = asReal(height);
QGraphicsEllipseItem *item =
new QGraphicsEllipseItem(px - pw/2, py - ph/2, pw, ph, 0);
item->setBrush(asQBrush(pars));
item->setPen(asQPen(pars));
return wrapQGraphicsItem(item);
}
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::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 MainWindow::graphicalInit() {
scene = new QGraphicsScene(-50,-90,95,95);
ui->graphicsView->setScene(scene);
ui->graphicsView->setRenderHint(QPainter::Antialiasing);
scene->setBackgroundBrush(QBrush(QColor(12,20,30)));
scene->addPixmap(QPixmap("data/img/title.png"))->setPos(-280,-500);
QGraphicsEllipseItem* lbr = scene->addEllipse(-360,-360,720,720);
lbr->setPen(QPen(QBrush(QColor(255,255,255)),85));
QGraphicsEllipseItem* contour = scene->addEllipse(-340,-340,680,680);
contour->setBrush(QBrush(QColor(230,230,255)));
contour->setPen(QPen(QBrush(QColor(0,0,0)),5));
roue_g = new QGraphicsItemGroup(contour);
// roue_g->addToGroup(contour);
for(int i=0;i<playersList.size();i++) {
float angle = (float)i/(float)playersList.size()*2*3.14159- 3.14159/2;
QGraphicsLineItem* l = scene->addLine(10*cos(angle),10*sin(angle),340*cos(angle),340*sin(angle),QPen(QColor(i%2 == 0 ? 192: 0,0,0,192)));
roue_g->addToGroup(l);
QGraphicsPixmapItem* p = scene->addPixmap(photos[i]);
p->setScale(0.18f);
p->setPos(395*cos(angle+0.02),395*sin(angle+0.02));
p->setRotation(angle/(2*3.14159)*360 + 90+3*360/48/4);
roue_g->addToGroup(p);
}
}
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);
}
void HostItem::updateHalos()
{
int count = 1;
QMap<Job,QGraphicsEllipseItem*>::Iterator it;
for(it = m_jobHalos.begin(); it != m_jobHalos.end(); ++it) {
QGraphicsEllipseItem *halo = it.value();
halo->setRect(halo->x() - 5 - count * 3,
halo->y() - 5 - count * 3,
m_baseWidth + count * 6,
m_baseHeight + count * 6);
halo->setBrush(m_hostInfoManager->hostColor(it.key().client()));
halo->setPen(Qt::NoPen);
++count;
}
}
void GridLine::setPen (const QPen &pen)
{
for (int i = 0; i < m_segments.count(); i++) {
QGraphicsItem *item = m_segments [i];
if (item != 0) {
// Downcast since QGraphicsItem does not have a pen
QGraphicsLineItem *itemLine = dynamic_cast<QGraphicsLineItem*> (item);
QGraphicsEllipseItem *itemArc = dynamic_cast<QGraphicsEllipseItem*> (item);
if (itemLine != 0) {
itemLine->setPen (pen);
} else if (itemArc != 0) {
itemArc->setPen (pen);
}
}
}
}
void Checker::setLineColor (SideSegments &sideSegments,
const QPen &pen)
{
for (int i = 0; i < sideSegments.count(); i++) {
QGraphicsItem *item = sideSegments [i];
if (item != 0) {
// Downcast since QGraphicsItem does not have a pen
QGraphicsLineItem *itemLine = dynamic_cast<QGraphicsLineItem*> (item);
QGraphicsEllipseItem *itemArc = dynamic_cast<QGraphicsEllipseItem*> (item);
if (itemLine != 0) {
itemLine->setPen (pen);
} else if (itemArc != 0) {
itemArc->setPen (pen);
}
}
}
}
Peg::Peg(const QPoint& hole, Board* board, QGraphicsItem* parent)
: QGraphicsEllipseItem(0, 0, 20, 20, parent),
m_hole(hole),
m_board(board) {
setPen(Qt::NoPen);
QGraphicsEllipseItem* gloss = new QGraphicsEllipseItem(3, 1.5, 14, 9, this);
QLinearGradient gradient2(0, 0, 0, 9);
gradient2.setColorAt(0, QColor(255, 255, 255));
gradient2.setColorAt(1, QColor(255, 255, 255, 0));
gloss->setBrush(gradient2);
gloss->setPen(Qt::NoPen);
setZValue(2);
setPos(hole.x() * 20, hole.y() * 20);
setFlag(QGraphicsItem::ItemIsMovable, true);
setCursor(Qt::OpenHandCursor);
}
void fillItemFromEllipse(QGraphicsItemGroup *item, const CLBoundingBox *pBB, const CLEllipse *pEllipse, const CLGroup *group, const CLRenderResolver* resolver)
{
double x = pBB->getPosition().getX() + pEllipse->getCX().getAbsoluteValue() + pEllipse->getCX().getRelativeValue() / 100.0 * pBB->getDimensions().getWidth();
double y = pBB->getPosition().getY() + pEllipse->getCY().getAbsoluteValue() + pEllipse->getCY().getRelativeValue() / 100.0 * pBB->getDimensions().getHeight();
double rx = pEllipse->getRX().getAbsoluteValue() + pEllipse->getRX().getRelativeValue() / 100.0 * pBB->getDimensions().getWidth();
double ry = pEllipse->getRY().getAbsoluteValue() + pEllipse->getRY().getRelativeValue() / 100.0 * pBB->getDimensions().getHeight();
QGraphicsEllipseItem* ellipseItem = new QGraphicsEllipseItem(
x - rx, y - ry, rx * 2, ry * 2);
QPen *pen = getPen(pEllipse, group, resolver, pBB);
ellipseItem->setPen(*pen);
delete pen;
QBrush *brush = getBrush(pEllipse, group, resolver, pBB);
ellipseItem->setBrush(*brush);
delete brush;
transform(ellipseItem, pEllipse, group);
item->addToGroup(ellipseItem);
}
void TodoHandleItem::updateItem( const Bliss::Todo &todo )
{
m_todo = todo;
foreach( QGraphicsItem *child, childItems() ) {
delete child;
}
if ( todo.type() == "group" ) {
int circleSize = m_itemSize + 14;
QGraphicsEllipseItem *groupCircle = new QGraphicsEllipseItem( this );
groupCircle->setRect( -circleSize/2, -circleSize/2,
circleSize, circleSize );
QPen pen;
pen.setBrush( Qt::white );
pen.setWidth( 4 );
groupCircle->setPen( pen );
}
}
void Scene::mouseReleaseEvent(QGraphicsSceneMouseEvent *sEvent)
{
if (isActive())
{
if (isEllipse() && isEllipsePainting() && startPoint != endPoint)
if (sEvent->button() == Qt::LeftButton)
{
QGraphicsEllipseItem *finishedEllipseItem = new QGraphicsEllipseItem(ellipseItem->rect());
setEllipsePainting(false);
finishedEllipseItem->setPen(QPen(QColor(0, 0, 200), 4));
finishedEllipseItem->setBrush(QBrush(QColor(0, 0, 200, 50)));
finishedEllipseItem->setFlags(QGraphicsItem::ItemIsMovable | QGraphicsItem::ItemIsSelectable);
removeItem(ellipseItem);
addItem(finishedEllipseItem);
ellipseVector << finishedEllipseItem;
}
QGraphicsScene::mouseReleaseEvent(sEvent);
}
}
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();
}
}
MyScene::MyScene(qreal x,qreal y,qreal width,qreal height,QObject *parent):QGraphicsScene(x,y,width,height,parent) {
// 預計加一個圓形,然後,執徑逐漸變大
QGraphicsEllipseItem *ball = new QGraphicsEllipseItem(-15,-15,30,30);
ball->setPen(QPen(QColor(125,125,125,125),3));
addItem(ball);
ball->setPos(this->width()/2,this->height()/2); // setPos(x,y):設定此小座標的原點在此(x,y)
timeLine = new QTimeLine;
QGraphicsItemAnimation *headAnimation = new QGraphicsItemAnimation;
headAnimation->setItem(ball);
headAnimation->setTimeLine(timeLine);
headAnimation->setScaleAt(1,10,10);
timeLine->setUpdateInterval(1000 / 25);
timeLine->setCurveShape(QTimeLine::SineCurve);
timeLine->setLoopCount(0);
timeLine->setDuration(2000);
timeLine->start();
}
/*protected*/ void DrawCircle::makeFigure() {
ControlPanelEditor* ed = _parent->getEditor();
QRectF r = ed->getSelectRect();
if (!r.isValid()) {
return;
}
_radius = qMax(r.width(), r.height());
QGraphicsEllipseItem* rr = new QGraphicsEllipseItem(0, 0, _radius, _radius);
rr->setBrush(QBrush(_fillColor));
rr->setPen(QPen(QBrush(_lineColor),_lineWidth));
PositionableCircle* ps = new PositionableCircle(ed, rr);
ps->_itemGroup = new MyGraphicsItemGroup();
ps->_itemGroup->setName("PositionableCircle");
ps->_itemGroup->addToGroup(rr);
ps->setLocation(r.x(), r.y());
// ps->setHeight(_height);
// ps->setWidth(_width);
ps->setDisplayLevel(ControlPanelEditor::MARKERS);
setDisplayParams(ps);
ps->updateSize();
ed->putItem(ps);
DrawFrame::closingEvent(true);
}
void MyQGraphicsView::mousePressEvent(QMouseEvent * e)
{
qreal rad = 1;
QPointF pt = mapToScene(e->pos());
//QPointF pt = (e->pos());
qDebug()<<pt.x();
qDebug()<<pt.y();
if(pt.y()>=650)
return;
listofpoints.append(pt);
qDebug()<<listofpoints.size();
// path.lineTo(pt.x(),pt.y());
// qDebug()<<"element count"<<path.elementCount();
qDebug()<<"element count"<<listofpoints.size();
QGraphicsEllipseItem *ellipse = new QGraphicsEllipseItem(pt.x()-rad, pt.y()-rad, rad*3.0, rad*3.0);
ellipse->setPen(QPen());
ellipse->setBrush(QBrush(Qt::SolidPattern));
scene->addItem(ellipse);
}
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();
}
bool ZipplXmlReader::read( QIODevice *dev )
{
setDevice( dev );
bool res = true;
bool metaMode = false;
mCurrParent = 0;
mCurrSpot = 0;
QGraphicsScene *scene = mGraphWidget->scene();
int spotID = 0;
while (!atEnd()) {
readNext();
if( isStartElement() ) {
qDebug() << "XML name: " << name();
if( name() == "presentation") {
// presentation mode: debug & presentation
QString mode = attributes().value("mode").toString();
if( !mode.isEmpty() ) mMode = mode;
mPath = attributes().value("path").toString();
if( !mPath.endsWith('/') ) mPath += "/";
qreal dx = qrealAttrib("width") / -2.0;
qreal dy = qrealAttrib("height") / -2.0;
QRectF rect( dx, dy, -2.0*dx, -2.0*dy );
scene->setSceneRect( rect );
} else if( name() == "meta" ) {
metaMode = true;
} else if( name() == "title" && metaMode ) {
mPresentationTitle = readElementText();
} else if( name() == "description" && metaMode ) {
mPresentationDescr = readElementText();
} else if( name() == "date" && metaMode ) {
mPresentationDate = readElementText();
} else if( name() == "name" && metaMode ) {
mAuthorName = readElementText();
} else if( name() == "email" && metaMode ) {
mAuthorEmail = readElementText();
} else if( name() == "tocentry" ) {
if( mCurrSpot ) {
mCurrSpot->setData( TOCENTRY, readElementText() );
}
} else if( name() == "spot" ) {
if( mCurrParent != 0 ) {
qDebug() << "Strange: Current Parent should be zero here!";
}
QGraphicsRectItem *rectItem = new QGraphicsRectItem( );
rectItem->setPen( pen( rectItem->pen(), QColor("#aeaeae") ));
mCurrParent = rectItem;
mCurrSpot = rectItem;
mCurrParent->setData( ID, QVariant( spotID++ ));
mCurrParent->setPos( position() );
rectItem->setBrush( brush( rectItem->brush() ) );
scene->addItem( mCurrParent );
mSpots.append( mCurrParent );
// Prepare the hidden items list
GraphicsItemList list;
mHiddenItems.insert( mCurrParent, list );
} else if( name() == "hidden" ) {
QGraphicsRectItem *rectItem = new QGraphicsRectItem( mCurrParent, scene );
rectItem->setPen( QPen( QColor( 240, 240, 240 )));
// append this hidden item to the list of hiddens of the parent spot.
GraphicsItemList list = mHiddenItems[mCurrSpot];
list.append( rectItem );
mHiddenItems[mCurrSpot] = list;
mCurrParent = rectItem;
mCurrParent->setData( ID, QVariant( spotID++ ));
} else if( name() == "rect" ) {
if( mCurrParent ) { // within a spot
qDebug() << "Creating a rectangle!";
QGraphicsRectItem *rectItem = new QGraphicsRectItem( mCurrParent, scene );
qreal width = qrealAttrib( "width" );
qreal height = qrealAttrib( "height" );
QPointF pos = position();
if( width > 0 && height > 0 ) {
rectItem->setRect( pos.x(), pos.y(), width, height );
} else {
rectItem->setPos( pos );
}
rectItem->setPen( pen( rectItem->pen() ) );
mCurrParent = rectItem;
}
} else if( name() == "circle" ) {
QPointF pos = position();
QGraphicsEllipseItem *ellipse = new QGraphicsEllipseItem( mCurrParent, scene );
// ellipse->setBrush( getBrush() );
qreal r = 2.0 * qrealAttrib( "r" );
QRectF rect( pos, QSizeF( r, r ) );
ellipse->setPen( pen( ellipse->pen() ) );
ellipse->setRect( rect );
} else if( name() == "text" ) {
QGraphicsSimpleTextItem *textItem = new QGraphicsSimpleTextItem( mCurrParent, scene );
QString font = attributes().value("font").toString();
QString size = attributes().value("size").toString();
QFont currFont = textItem->font();
if( !font.isEmpty() ) {
currFont.setFamily( font );
textItem->setFont( currFont );
}
if( !size.isEmpty() ) {
currFont.setPointSize( size.toInt() );
textItem->setFont( currFont );
}
textItem->setPos( position() );
// set the brush
QBrush b( textItem->brush() );
b.setColor( color() );
textItem->setBrush( b );
QString text = readElementText();
textItem->setText( text );
} else if( name() == "image" ) {
if( handleImg( scene ) ) {
}
}
} else if( isEndElement() ) {
qDebug( ) << "XML CLOSE: " << name().toString();
if( name() == "spot" || name() == "toc" ) {
QRectF rect = mCurrParent->childrenBoundingRect();
rect.setX(0);
rect.setY(0);
qgraphicsitem_cast<QGraphicsRectItem*>(mCurrParent)->setRect( rect);
mCurrParent = 0;
} else if( name() == "rect" ) {
QGraphicsRectItem *item = qgraphicsitem_cast<QGraphicsRectItem*>(mCurrParent);
if( item->rect().isEmpty() )
item->setRect( mCurrParent->childrenBoundingRect() );
mCurrParent = mCurrParent->parentItem();
} else if( name() == "hidden") {
mCurrParent->setOpacity( 0.0 );
mCurrParent = mCurrParent->parentItem();
} else if( name() == "meta" ) {
metaMode = false;
}
}
}
createToc( scene );
return res;
}
