Exemplo n.º 1
0
MainWindow::MainWindow(QWidget *parent) :
        QMainWindow(parent),
        ui(new Ui::MainWindow)
{
    ui->setupUi(this);

    Space* mySpace = new Space(100);
//    SpaceGUI* spaceGUI = new SpaceGUI(mySpace);
    spaceGUI = new SpaceGUI(mySpace);

    //TODO: only for test
    mySpace->SetValue(1, 25);

    CAutomaton = new CellularAutomaton(mySpace);

    myRule = new RuleMoore();

    CAutomaton->SetRule(myRule);

    ui->graphicsView->setAlignment(Qt::AlignLeft | Qt::AlignTop);

    QGraphicsScene* scene = new QGraphicsScene(ui->graphicsView);
    scene->setBackgroundBrush(Qt::green);
    ui->graphicsView->setScene(scene);

    scene->addItem(spaceGUI);



}
Database_Tilesets::Database_Tilesets(QWidget *parent) : QWidget(parent)
{
	QGraphicsScene *scene;
	setupUi(this);
	twTilesetList->horizontalHeader()->setResizeMode(QHeaderView::Stretch);
	twTilesetList->horizontalHeader()->setHidden(true);
	twTilesetList->verticalHeader()->setHidden(true);
	twTerrainList->horizontalHeader()->setResizeMode(QHeaderView::Stretch);
	twTerrainList->horizontalHeader()->setHidden(true);
	twTerrainList->verticalHeader()->setHidden(true);
	cboxPhase->setEnabled(false);
	gvTileEditor->changeView(TileView::VIEW_TERRAIN);
	tilesetRef = NULL;
	ignoreEvents = true;
	bTileGroupSideButton->setSpinBox(sbTileGroup);
	bFPSSideButton->setSpinBox(sbFPS);
	gvTilePreview->setBackgroundBrush(QBrush(QImage(":/icons/graphicsview_background.png")));
	scene = new QGraphicsScene(0.0, 0.0, 32.0, 32.0);
	scene->setBackgroundBrush(QBrush(QImage(":/icons/graphicsview_background.png")));
	gvTilePreview->setScene(scene);
	tilePreviewItem = new QGraphicsPixmapItem;
	tilePreviewItem->setPos(0.0, 0.0);
	tilePreviewItem->setVisible(false);
	scene->addItem(tilePreviewItem);
	tilePreviewTimer = new QTimer(this);
	tilePreviewFrame = 0;
	tilePreviewDir = 1;
	currentTileID = 0;
	QObject::connect(sbTileView, SIGNAL(rangeChanged(int, int)), gvTileEditor, SLOT(setScrollBarRange(int, int)));
	QObject::connect(sbTileView, SIGNAL(valueChanged(int)), gvTileEditor, SLOT(setScrollBarValue(int)));
	QObject::connect(tilePreviewTimer, SIGNAL(timeout()), this, SLOT(animateTilePreview()));
}
Exemplo n.º 3
0
void MainWindow::drawLines(std::vector<Point> points){

    QGraphicsScene * scene = this->ui->gv_Visualizer->scene();
    scene->clear();
    QRect geo = this->ui->gv_Visualizer->rect();
    scene->setBackgroundBrush(Qt::black);
    QPen pen;
    Point previous;
    for(std::vector<Point>::iterator it = points.begin(); it != points.end(); ++it){
        if(it == points.begin()){
            previous = *it;
        }else{
            int alpha = 255;
            if((previous.r || previous.g || previous.b)){
                pen = QPen(QColor(previous.r?255:0,previous.g?255:0,previous.b?255:0,alpha));
            }else{
                pen = QPen(QColor(0,255,0,70));
                pen.setStyle(Qt::DashDotDotLine);
            }
            scene->addLine(previous.x*geo.width()/65535,previous.y*geo.height()/65535,(*it).x*geo.width()/65535,(*it).y*geo.height()/65535,pen);
            previous = *it;
        }
    }
    this->ui->gv_Visualizer->setScene(scene);
    this->ui->gv_Visualizer->update();

}
Exemplo n.º 4
0
MainWindow::MainWindow(QWidget *parent) :
    QMainWindow(parent),
    _elapsedSteps(0),
    ui(new Ui::MainWindow)
{
    ui->setupUi(this);
    QGraphicsScene *scene = new QGraphicsScene(ui->graphicsView);
    scene->setBackgroundBrush(QBrush(QColor(255, 255, 255, 255)));
    ui->graphicsView->setScene(scene);

#if defined(MOBILE)
    ui->surrenderButton->hide();
    ui->newGameButton->hide();
    ui->saveButton->hide();
    ui->loadButton->hide();
    ui->stepsLabel->hide();

    ui->graphicsView->setOptimizationFlag(QGraphicsView::DontAdjustForAntialiasing);
    ui->graphicsView->setOptimizationFlag(QGraphicsView::DontSavePainterState);
    ui->graphicsView->setViewportUpdateMode(QGraphicsView::SmartViewportUpdate);
#else
    ui->menuBar->hide();
#endif

#if defined(HAVE_OPENGL)
    ui->graphicsView->setViewport(new QGLWidget(ui->graphicsView));
#endif
}
Exemplo n.º 5
0
PlayScene::PlayScene(){
    //creat a scene
    QGraphicsScene *scene = new QGraphicsScene();
    scene->setSceneRect(0,0,1024,768);
    scene->setBackgroundBrush(QBrush(QImage("D:/img/img/bg.png")));

    //add a view
    QGraphicsView *view = new QGraphicsView(scene);
    view->setHorizontalScrollBarPolicy(Qt::ScrollBarAlwaysOff);
    view->setVerticalScrollBarPolicy(Qt::ScrollBarAlwaysOff);
    view->setFixedSize(1024,768);


    //add Rec
    Rec *rec = new Rec();
    rec->setFlag(QGraphicsItem::ItemIsFocusable);
    rec->setFocus();
    scene->addItem(rec);

    BlueHit *bluehit = new BlueHit();
    scene->addItem(bluehit);
    bluehit->setPos(80,190);

    //QTimer *timer = new QTimer();
    //QObject::connect(timer,SIGNAL(timeout()),bluehit,SLOT(create()));

    Drum *drum = new Drum();
    scene->addItem(drum);
    drum->setPos(1000,250);


    //show the view
    view->show();
}
Exemplo n.º 6
0
Feeding::Feeding(QWidget *parent)
{
    QGraphicsScene * scene = new QGraphicsScene(NULL);

    scene->setSceneRect(0,0,600,480);
    setScene(scene);

    setHorizontalScrollBarPolicy(Qt::ScrollBarAlwaysOff);
    setVerticalScrollBarPolicy(Qt::ScrollBarAlwaysOff);
    setFixedSize(600,481);

    setFocusPolicy(Qt::NoFocus);

    basket = new Basket(this);
    scene->addItem(basket);
    basket->setPos(225,425);
    basket->setFlag(QGraphicsItem::ItemIsFocusable);
    basket->setFocus();
    scene->setFocusItem(basket);
    scene->clearFocus();

    QTimer * spawnTimer = new QTimer(this);
    QObject::connect(spawnTimer,SIGNAL(timeout()),this,SLOT(spawn()));
    int spawnTime = 1500 + (rand() % 501);

    spawnTimer->start(spawnTime);

    score = new scoreFood();
    scene->addItem(score);

    scene->setBackgroundBrush(QBrush(QImage(":/feeding/backgroundPark1.png")));

}
Exemplo n.º 7
0
	void ARehabMainWindow::resizeEvent(QResizeEvent * event)
	{
		QGraphicsScene * scene = ui.graphicsInicial->scene();
		scene->setSceneRect(0, 0, ui.graphicsInicial->width(), ui.graphicsInicial->height());
		float wImage = this->pixmapItemInitial->boundingRect().width();
		float hImage = this->pixmapItemInitial->boundingRect().height();
		float wGraphicsView = ui.graphicsInicial->width();
		float hGraphicsView = ui.graphicsInicial->height();
		float scaleH = hGraphicsView / hImage;
		pixmapItemInitial->setScale(scaleH);
		pixmapItemInitial->setPos((wGraphicsView / 2.0f) - (scaleH*wImage / 2.0f), 0);

		QRadialGradient gradient(wGraphicsView / 2.0f, hGraphicsView / 2.0f, hGraphicsView);
		gradient.setColorAt(0.95, QColor(200, 200, 200));
		gradient.setColorAt(0.5, QColor(255, 255, 255));
		gradient.setColorAt(0, QColor(255, 255, 255));
		scene->setBackgroundBrush(QBrush(gradient));

		proxyBtNuevo->setPos((wGraphicsView / 2.0f) - (btNew->width() / 2.0f), hGraphicsView / 2.0f);
		proxyBtLoad->setPos((wGraphicsView / 2.0f) - (btLoad->width() / 2.0f), 80 + (hGraphicsView / 2.0f));
		proxyBtLoadResults->setPos((wGraphicsView / 2.0f) - (btLoadResults->width() / 2.0f), 160 + (hGraphicsView / 2.0f));

		ui.graphicsInicial->update();

		QMainWindow::resizeEvent(event);
	}
Exemplo n.º 8
0
  NodeStatInspector::NodeStatInspector(QWidget* parent)
    : QWidget(parent) {
    setWindowFlags(Qt::Tool);
    QGraphicsScene* scene = new QGraphicsScene();
    
    scene->addEllipse(70,10,16,16,QPen(),QBrush(DrawingCursor::white));
    scene->addEllipse(70,60,16,16,QPen(),QBrush(DrawingCursor::blue));
    scene->addRect(32,100,12,12,QPen(),QBrush(DrawingCursor::red));

    QPolygonF poly;
    poly << QPointF(78,100) << QPointF(78+8,100+8)
         << QPointF(78,100+16) << QPointF(78-8,100+8);
    scene->addPolygon(poly,QPen(),QBrush(DrawingCursor::green));

    scene->addEllipse(110,100,16,16,QPen(),QBrush(DrawingCursor::white));
    
    QPen pen;
    pen.setStyle(Qt::DotLine);
    pen.setWidth(0);
    scene->addLine(78,26,78,60,pen);
    scene->addLine(78,76,38,100,pen);
    scene->addLine(78,76,78,100,pen);
    scene->addLine(78,76,118,100,pen);
    
    scene->addLine(135,10,145,10);
    scene->addLine(145,10,145,110);
    scene->addLine(145,60,135,60);
    scene->addLine(145,110,135,110);
    
    nodeDepthLabel = scene->addText("0");
    nodeDepthLabel->setPos(150,20);
    subtreeDepthLabel = scene->addText("0");
    subtreeDepthLabel->setPos(150,75);

    choicesLabel = scene->addText("0");
    choicesLabel->setPos(45,57);

    solvedLabel = scene->addText("0");
    solvedLabel->setPos(78-solvedLabel->document()->size().width()/2,120);
    failedLabel = scene->addText("0");
    failedLabel->setPos(30,120);
    openLabel = scene->addText("0");
    openLabel->setPos(110,120);

    QGraphicsView* view = new QGraphicsView(scene);
    view->setRenderHints(view->renderHints() | QPainter::Antialiasing);
    view->show();

    scene->setBackgroundBrush(Qt::white);

    boxLayout = new QVBoxLayout();
    boxLayout->setContentsMargins(0,0,0,0);
    boxLayout->addWidget(view);
    setLayout(boxLayout);

    setWindowTitle("Gist node statistics");
    setAttribute(Qt::WA_QuitOnClose, false);
    setAttribute(Qt::WA_DeleteOnClose, false);
  }
Exemplo n.º 9
0
QGraphicsScene * ClusteredArranger::arrange(SegmentList const & segments) const {
   QGraphicsScene * arrangement = new QGraphicsScene();

   QTime time;
   time.start();

   // determine background
   Segment * background = determineBackground(segments);
   SegmentList segmentsWOBack = removeBackground(segments, background);
   arrangement->setBackgroundBrush(QBrush(QColor(background->color().toQRgb())));
   segmentsWOBack.calculateFeatureVariances();

   // initialize layout
   //initializeLayout(segmentsWOBack, segmentsWOBack.featX(), segmentsWOBack.featY());
   initializeLayout(segmentsWOBack, xAxisBox->currentIndex(), yAxisBox->currentIndex());

   // find clusters
   time.restart();
   QList<SegmentList> clusters = meanShift(segmentsWOBack);
   qDebug("Segments clustered in %f seconds", time.restart()/1000.0);
   qDebug("  %d clusters found", clusters.size());

   // refine clusters
   //int counter = 0;
   foreach (SegmentList cluster, clusters) {
      if (clusterBox->currentIndex() == 0) {
         refineLayoutCircles(cluster);
      }
      else if (clusterBox->currentIndex() == 1) {
         refineLayoutPiles(cluster);
      }

      // debug output
      /*QGraphicsScene scene;
      scene.setBackgroundBrush(QBrush(QColor(255, 255, 255)));
      foreach(Segment * const segment, cluster) {
         scene.addItem(segment->toQGraphicsItem());
         // without the following line QPainter tends to crash
         scene.width();
      }
      ++counter;
      saveScene(&scene, QString("Test%1.png").arg(counter, 2));*/
   }

   // refine layout
   if (clusterBox->currentIndex() == 0) {
      refineLayoutByPlace(clusters);
   }
   else if (clusterBox->currentIndex() == 1) {
      refineLayoutBySize(clusters);
   }

   // convert the segments to QGraphicsItems and add to QGraphicsScene
   foreach(Segment const * const segment, segmentsWOBack) {
      arrangement->addItem(segment->toQGraphicsItem());
      // without the following line QPainter tends to crash
      arrangement->width();
   }
Exemplo n.º 10
0
int main(int argc, char **argv)
{
    Q_INIT_RESOURCE(stickman);
    QApplication app(argc, argv);

    StickMan *stickMan = new StickMan;
    stickMan->setDrawSticks(false);

    QGraphicsTextItem *textItem = new QGraphicsTextItem();
    textItem->setHtml("<font color=\"white\"><b>Stickman</b>"
        "<p>"
        "Tell the stickman what to do!"
        "</p>"
        "<p><i>"
        "<li>Press <font color=\"purple\">J</font> to make the stickman jump.</li>"
        "<li>Press <font color=\"purple\">D</font> to make the stickman dance.</li>"
        "<li>Press <font color=\"purple\">C</font> to make him chill out.</li>"
        "<li>When you are done, press <font color=\"purple\">Escape</font>.</li>"
        "</i></p>"
        "<p>If he is unlucky, the stickman will get struck by lightning, and never jump, dance or chill out again."
        "</p></font>");
    qreal w = textItem->boundingRect().width();
    QRectF stickManBoundingRect = stickMan->mapToScene(stickMan->boundingRect()).boundingRect();
    textItem->setPos(-w / 2.0, stickManBoundingRect.bottom() + 25.0);

    QGraphicsScene scene;
    scene.addItem(stickMan);

    scene.addItem(textItem);
    scene.setBackgroundBrush(Qt::black);

    GraphicsView view;
    view.setRenderHints(QPainter::Antialiasing);
    view.setTransformationAnchor(QGraphicsView::NoAnchor);
    view.setScene(&scene);

    QRectF sceneRect = scene.sceneRect();
    // making enough room in the scene for stickman to jump and die
    view.resize(sceneRect.width() + 100, sceneRect.height() + 100);
    view.setSceneRect(sceneRect);

    view.show();
    view.setFocus();

    LifeCycle cycle(stickMan, &view);
    cycle.setDeathAnimation(":/animations/dead.bin");

    cycle.addActivity(":/animations/jumping.bin", Qt::Key_J);
    cycle.addActivity(":/animations/dancing.bin", Qt::Key_D);
    cycle.addActivity(":/animations/chilling.bin", Qt::Key_C);

    cycle.start();


    return app.exec();
}
Exemplo n.º 11
0
	void ARehabMainWindow::loadGuiInitial(void)
	{
		float wGraphicsView = ui.graphicsInicial->width();
		float hGraphicsView = ui.graphicsInicial->height();

		ui.btHelp->setIcon(QPixmap(QString::fromUtf8(":/svg/help.svg")));
		ui.btAbout->setIcon(QPixmap(QString::fromUtf8(":/svg/about.svg")));

		ui.graphicsInicial->verticalScrollBar()->blockSignals(true);
		ui.graphicsInicial->horizontalScrollBar()->blockSignals(true);
		ui.graphicsInicial->setScene(new QGraphicsScene);
		QGraphicsScene * scene = ui.graphicsInicial->scene();
		scene->setSceneRect(0, 0, ui.graphicsInicial->width(), ui.graphicsInicial->height());

		QRadialGradient gradient(wGraphicsView / 2.0f, hGraphicsView / 2.0f, hGraphicsView);
		gradient.setColorAt(0.95, QColor(200, 200, 200));
		gradient.setColorAt(0.5, QColor(255, 255, 255));
		gradient.setColorAt(0, QColor(255, 255, 255));
		scene->setBackgroundBrush(QBrush(gradient));

		QPixmap pix1(":/images/banner.png");
		this->pixmapItemInitial = scene->addPixmap(pix1);

		float wImage = this->pixmapItemInitial->boundingRect().width();
		float hImage = this->pixmapItemInitial->boundingRect().height();
		float scaleH = hGraphicsView / hImage;

		pixmapItemInitial->setTransformationMode(Qt::SmoothTransformation);
		pixmapItemInitial->setScale(scaleH);
		pixmapItemInitial->setPos((wGraphicsView / 2.0f) - (scaleH*wImage / 2.0f), 0);

		QFont btFont("Calibri", 16, QFont::Light);

		btNew = new QPushButton("Nuevo Ejercicio");
		btNew->setMinimumSize(360, 60);
		btNew->setFont(btFont);
		proxyBtNuevo = scene->addWidget(btNew);

		btLoad = new QPushButton("Cargar Ejercicio");
		btLoad->setMinimumSize(360, 60);
		btLoad->setFont(btFont);
		proxyBtLoad = scene->addWidget(btLoad);

		btLoadResults = new QPushButton("Cargar Resultados de Paciente");
		btLoadResults->setMinimumSize(360, 60);
		btLoadResults->setFont(btFont);
		proxyBtLoadResults = scene->addWidget(btLoadResults);

		QGridLayout * layoutBottomFrame = reinterpret_cast<QGridLayout*>(ui.bottomFrame->layout());
		if (layoutBottomFrame)
		{
			layoutBottomFrame->addWidget(this->guistatewidget, 0, 1);
			this->guistatewidget->hide();
		}
	}
Exemplo n.º 12
0
void QARehabFileControlWidget::loadSVGFiles(void)
{
    QGraphicsScene * scene = this->scene();
    scene->setSceneRect(0, 0, this->width(), this->height());
    scene->setBackgroundBrush(QBrush(QColor(100, 100, 100, 255)));

    containerRect = new QGraphicsRectItem(0, 0, this->width(), this->height());
    containerRect->setPen(Qt::NoPen);
    containerRect->setBrush(QBrush(QColor(200, 200, 200, 50), Qt::CrossPattern));

    QPolygonF polygon;
    polygon.append(QPointF(80, 0));
    polygon.append(QPointF(0, 80));
    polygon.append(QPointF(400, 80));
    polygon.append(QPointF(320, 0));
    itemBtContainer = new QGraphicsPolygonItem(polygon, containerRect);
    itemBtContainer->setPen(Qt::NoPen);
    itemBtContainer->setBrush(QBrush(QColor(200, 200, 200, 100)));

    svgRestart = new QSVGInteractiveItem(":/svg/restart.svg", itemBtContainer);

    svgPlayPause = new QSVGInteractiveItem(":/svg/play.svg", itemBtContainer);
    svgPlayPause->setCheckable(true);

    svgKinectMaximize = new QSVGInteractiveItem(":/svg/maximize.svg", itemBtContainer);
    svgKinectMaximize->setCheckable(true);

    itemTimeline = new QGraphicsRectItem(0, 0, this->width() - 160, 5, containerRect);
    itemTimeline->setPen(Qt::NoPen);
    itemTimeline->setBrush(QBrush(QColor(200, 200, 255, 200)));

    itemCuttingInterval = new QGraphicsRectItem(0, 0, this->width() - 160, 20, containerRect);
    itemCuttingInterval->setPen(Qt::NoPen);
    itemCuttingInterval->setBrush(QBrush(QColor(100, 200, 0, 100)));

    svgLeftSelector = new QSVGInteractiveItem(":/svg/intervalLeft.svg", containerRect);
    svgRightSelector = new QSVGInteractiveItem(":/svg/intervalRight.svg", containerRect);

    QFont font("Verdana", 8);
    itemTXModelLeftValue = new QGraphicsSimpleTextItem("Left", this->svgLeftSelector);
    itemTXModelLeftValue->setFont(font);
    itemTXModelLeftValue->setPen(Qt::NoPen);
    itemTXModelLeftValue->setBrush(QBrush(QColor(200, 200, 200, 200)));
    itemTXModelRightValue = new QGraphicsSimpleTextItem("Right", this->svgRightSelector);
    itemTXModelRightValue->setFont(font);
    itemTXModelRightValue->setPen(Qt::NoPen);
    itemTXModelRightValue->setBrush(QBrush(QColor(200, 200, 200, 200)));
    itemTXModelRightValue->setText(QString::number(this->model.rightValue));
    itemTXModelLeftValue->setText(QString::number(this->model.leftValue));

    scene->addItem(containerRect);
}
Exemplo n.º 13
0
StepBox::StepBox(std::vector<Block> blocks, std::vector<QColor> colors, int blockWidth, QWidget *parent) :
QGraphicsView(parent), blocks(blocks), colors(colors), blockWidth(blockWidth), state(NEXT)
{
	QGraphicsScene *sc = new QGraphicsScene();
	sc->setBackgroundBrush(Qt::transparent);
	sc->setSceneRect(-10, -10, 6 * blockWidth + 20, 9 * blockWidth + 20);
	setScene(sc);
	UI::init(this, false);
	this->setMinimumSize(6 * blockWidth + 20, 9 * blockWidth + 20);

	rects.resize(0);
	draw();
}
Exemplo n.º 14
0
void SpinMirror::setFrame()
{
    // Paint the left hand frame of the main spinbox.
    // Use the part to the left of the edit field, plus a slice at
    // the left of the edit field stretched for the rest of the width.
    // This avoids possibly grabbing text and displaying it in the
    // spin button area.
    QGraphicsScene* c = scene();
    QStyleOptionSpinBox option;
    option.initFrom(mMainSpinbox);
    QRect r = spinBoxEditFieldRect(mMainSpinbox, option);
    bool rtl = QApplication::isRightToLeft();
    QPixmap p;
    if (mMirrored)
    {
        int x = rtl ? 0 : mMainSpinbox->width() - width();
        p = grabWidget(mMainSpinbox, QRect(x, 0, width(), height()));
    }
    else
    {
        // Grab a single pixel wide vertical slice through the main spinbox, between the
        // frame and edit field.
        bool oxygen  = mMainSpinbox->style()->inherits("Oxygen::Style"); // KDE >= 4.4 Oxygen style
        bool oxygen1 = mMainSpinbox->style()->inherits("OxygenStyle");   // KDE <= 4.3 Oxygen style
        int editOffsetY = oxygen ? 5 : oxygen1 ? 6 : 2;   // offset to edit field
        int editOffsetX = (oxygen || oxygen1) ? 4 : 2;   // offset to edit field
        int x = rtl ? r.right() - editOffsetX : r.left() + editOffsetX;
        p = grabWidget(mMainSpinbox, QRect(x, 0, 1, height()));
        // Blot out edit field stuff from the middle of the slice
        QPixmap dot = grabWidget(mMainSpinbox, QRect(x, editOffsetY, 1, 1));
        QPainter painter(&p);
        painter.drawTiledPixmap(0, editOffsetY, 1, height() - 2*editOffsetY, dot, 0, 0);
        painter.end();
        // Horizontally fill the mirror widget with the vertical slice
        p = p.scaled(size());
        // Grab the left hand border of the main spinbox, and draw it into the mirror widget.
        QRect endr = rect();
        if (rtl)
        {
            int mr = mMainSpinbox->width() - 1;
            endr.setWidth(mr - r.right() + editOffsetX);
            endr.moveRight(mr);
        }
        else
            endr.setWidth(r.left() + editOffsetX);
        x = rtl ? width() - endr.width() : 0;
        mMainSpinbox->render(&p, QPoint(x, 0), endr, QWidget::DrawWindowBackground | QWidget::DrawChildren | QWidget::IgnoreMask);
    }
    c->setBackgroundBrush(p);
}
Exemplo n.º 15
0
Form::Form(QWidget *parent)
    : QWidget(parent)
{
  this->setupUi(this);
  //connect( this->ui.pushButton, SIGNAL( clicked() ), this, SLOT(pushButton_SetLabelText()) );

  QColor sceneBackgroundColor;
  sceneBackgroundColor.setRgb(153, 255, 0);
  
  QGraphicsScene* scene = new QGraphicsScene();
  QBrush brush;
  brush.setStyle(Qt::SolidPattern);
  brush.setColor(sceneBackgroundColor);
  scene->setBackgroundBrush(brush);
  this->graphicsView->setScene(scene);
}
Exemplo n.º 16
0
Seperator::Seperator(bool hasArrow, int height, QWidget *parent) :
QGraphicsView(parent)
{
	QGraphicsScene *sc = new QGraphicsScene();
	sc->setBackgroundBrush(Qt::transparent);
	sc->setSceneRect(-18, 0, 40, height);
	setScene(sc);
	UI::init(this, false);
	this->setMinimumSize(40, height);

	sc->addLine(0, 0, 0, height, QPen(QColor(100, 149, 199), 3));
	if (hasArrow) {
		QGraphicsPixmapItem * arrow =
				new QGraphicsPixmapItem(QPixmap("./data/makeAndBreak/BlueNext.png"));
		arrow->setPos(-18, height / 2 - 20);
		sc->addItem(arrow);
	}
}
Exemplo n.º 17
0
Game::Game(QWidget *parent)
{
    QRect rec = QApplication::desktop()->screenGeometry();
    int height = rec.height();
    int width = rec.width();

    QGraphicsScene *scene = new QGraphicsScene();
    scene->setSceneRect(0,0,width,height);

    QGraphicsView *view = new QGraphicsView(scene);

    scene->setBackgroundBrush(QImage("://img/bg.png"));

    //player
    ship *player=new ship();
    scene->addItem(player);
    player->setPos(width/2, height-70);

    //scoring
    score = new Score();
    scene->addItem(score);

    //life
    life = new Life();
    life->setPos(life->x(),life->y()+25);
    scene->addItem(life);

    player->setFlag(QGraphicsItem::ItemIsFocusable);
    player->setFocus();

    //enemies
    QTimer*timer=new QTimer();
    QObject::connect(timer,SIGNAL(timeout()),player,SLOT(spawn()));
    timer->start(2000);

    //music
    QMediaPlayer * music = new QMediaPlayer();
    music->setMedia(QUrl("qrc:/sounds/bgmusic.mp3"));
    music->play();

    view->setHorizontalScrollBarPolicy(Qt::ScrollBarAlwaysOff);
    view->setVerticalScrollBarPolicy(Qt::ScrollBarAlwaysOff);
    view->showFullScreen();
}
Exemplo n.º 18
0
void MainWindow::showCurrentFrame()
{
    cv::Mat frame = vmstream.getCurrentFrame();
    if (frame.empty())
    {
        stop();
        return;
    }

    int w = frame.cols, h = frame.rows;
    QImage image(frame.data, w, h, QImage::Format_RGB888);
    double dw = double(w)/ui->videoFrame->width();
    double dh = double(h)/ui->videoFrame->height();
    double scale = MAX(dw, dh);
    image = image.scaled(floor(w/scale), floor(h/scale));
    QGraphicsPixmapItem* pixmapItem = new QGraphicsPixmapItem(QPixmap::fromImage(image));
    QGraphicsScene* oldScene = ui->videoFrame->scene();
    QGraphicsScene* scene = new QGraphicsScene(ui->videoFrame);
    scene->setBackgroundBrush(QBrush(Qt::black));
    scene->addItem(pixmapItem);
    ui->videoFrame->setScene(scene);
    delete oldScene;
	ui->frameLabel->setText(QString::number(vmstream.getCurrentFrameNumber()));

    if (coordinatesIsNeeded)
    {
        GpsCoordinates coords = vmstream.getCurrentCoordinates();
        ui->coord_x->setText(QString::number(coords.first));
        ui->coord_y->setText(QString::number(coords.second));
        if (vmstream.hasSpeed())
        {
            float speed = vmstream.getCurrentSpeed();
            ui->speedLabel->setText(QString::number(speed));
        }
    }
    else
    {
        clearDataLabels();
    }

    updateVideSlider();
}
MainWindowSample::MainWindowSample(Controller* modelController, QWidget *parent) :
  QWidget(parent),
  ui(new Ui::MainWindowSample)
{
  ui->setupUi(this);

  ViewController* controller = new ViewController(modelController, this);

  QGraphicsScene * scene = new QGraphicsScene(this);
  scene->setBackgroundBrush(Qt::darkGray);

  Field * middleField = modelController -> getModelBoard() -> getMiddleField();

  gui::Board * board = new gui::Board(controller, middleField);
  board -> setPos(0, 0);
  scene -> addItem(board);

  ui->graphicsView->setScene(scene);
  ui->graphicsView->show();
}
Exemplo n.º 20
0
int main(int argc, char **argv)
{
    QApplication app(argc, argv);

    QGraphicsScene scene;
    scene.setSceneRect(0,0,854,480);

    QGraphicsView view(&scene);
    view.viewport()->setAttribute(Qt::WA_AcceptTouchEvents);

    view.setFixedSize(854,480);
    view.setVerticalScrollBarPolicy(Qt::ScrollBarAlwaysOff);
    view.setHorizontalScrollBarPolicy(Qt::ScrollBarAlwaysOff);
    view.setStyleSheet( "QGraphicsView { border-style: none; }" );
    scene.setBackgroundBrush(QBrush(QColor(100,100,100), Qt::SolidPattern));

    QSvgRenderer *m_renderer = new QSvgRenderer();
    m_renderer->load(QString(":/images/joystick.svg"));

    QGraphicsSvgItem *m_logo = new QGraphicsSvgItem();
    m_logo->setSharedRenderer(m_renderer);
    m_logo->setElementId(QString("opheader"));
    m_logo->setPos(283,415);
    scene.addItem(m_logo);

    //inverted left and right
    Joystick *left = new Joystick(464,65,350,350,false,true);
    scene.addItem(left);

    Joystick *right = new Joystick(38,65,350,350,true,true);
    scene.addItem(right);

    cccom teste;
    QObject::connect(left,SIGNAL(JoystickUpdate(int,int)),&teste,SLOT(updateSticksTY(int,int)));
    QObject::connect(right,SIGNAL(JoystickUpdate(int,int)),&teste,SLOT(updateSticksPR(int,int)));

    view.showFullScreen();
    return app.exec();
}
Exemplo n.º 21
0
int main(int argc, char *argv[])
{
    QApplication app(argc, argv);

    QGraphicsScene scene;
    scene.setBackgroundBrush(Qt::black);

    CubeItem *item = new CubeItem();
    item->setRect(0, 0, 600, 480);
    item->camera()->setEye(QVector3D(-5.0f, 3.0f, 6.0f));
    scene.addItem(item);
    item->setFocus();

    Graph graph;
    item->setScene(graph.scene());

    QGLFormat format(QGLFormat::defaultFormat());
    format.setSampleBuffers(true);
    QGraphicsView view(&scene);
    view.setViewport(new QGLWidget(format));
    view.show();

    return app.exec();
}
Exemplo n.º 22
0
Designer::Designer(MainWindow *mw, QWidget *parent)
: QGraphicsView(parent), timerId(0)
{
	layout = new QGridLayout();
	QGraphicsScene *scene = new QGraphicsScene();
	scene->setBackgroundBrush(QBrush(UI::DARK_BLUE));
	this->setScene(scene);
	layout->setRowMinimumHeight(5, 20);
	layout->setRowStretch(0, 1);
	layout->setRowStretch(7, 1);
	layout->setColumnStretch(0, 1);
	layout->setColumnStretch(9, 1);

	//BUILDING AREA
	mainWindow = mw;
	buildingArea = new BuildingArea(this);
	layout->addWidget(buildingArea, 1, 5, 4, 1);

	//LOGO
	logo = new QLabel();
	logo->setPixmap(QPixmap("./data/makeAndBreak/RI_logo.png"));
	layout->addWidget(logo, 6, 1, 1, 1, Qt::AlignCenter);

	//INSTRUCTIONS
	initInstructions();

	//BUTTON
	initButton();

	//INFO
	info = new InfoPanel();
	layout->addWidget(info, 6, 3, 1, 5);
	updateCV();

	this->setLayout(layout);
}
Exemplo n.º 23
0
Arquivo: main.cpp Projeto: Afreeca/qt
int main(int argc, char **argv)
{
    Q_INIT_RESOURCE(stickman);
    QApplication app(argc, argv);

    StickMan *stickMan = new StickMan;
    stickMan->setDrawSticks(false);

#if defined(Q_WS_S60) || defined(Q_WS_MAEMO_5) || defined(Q_WS_SIMULATOR)
    RectButton *buttonJump = new RectButton("Jump"); buttonJump->setPos(100, 125);
    RectButton *buttonDance = new RectButton("Dance"); buttonDance->setPos(100, 200);
    RectButton *buttonChill = new RectButton("Chill"); buttonChill->setPos(100, 275);
#else
    QGraphicsTextItem *textItem = new QGraphicsTextItem();
    textItem->setHtml("<font color=\"white\"><b>Stickman</b>"
        "<p>"
        "Tell the stickman what to do!"
        "</p>"
        "<p><i>"
        "<li>Press <font color=\"purple\">J</font> to make the stickman jump.</li>"
        "<li>Press <font color=\"purple\">D</font> to make the stickman dance.</li>"
        "<li>Press <font color=\"purple\">C</font> to make him chill out.</li>"
        "<li>When you are done, press <font color=\"purple\">Escape</font>.</li>"
        "</i></p>"
        "<p>If he is unlucky, the stickman will get struck by lightning, and never jump, dance or chill out again."
        "</p></font>");
    qreal w = textItem->boundingRect().width();
    QRectF stickManBoundingRect = stickMan->mapToScene(stickMan->boundingRect()).boundingRect();
    textItem->setPos(-w / 2.0, stickManBoundingRect.bottom() + 25.0);
#endif

    QGraphicsScene scene;
    scene.addItem(stickMan);

#if defined(Q_WS_S60) || defined(Q_WS_MAEMO_5) || defined(Q_WS_SIMULATOR)
    scene.addItem(buttonJump);
    scene.addItem(buttonDance);
    scene.addItem(buttonChill);
#else
    scene.addItem(textItem);
#endif
    scene.setBackgroundBrush(Qt::black);

    GraphicsView view;
    view.setRenderHints(QPainter::Antialiasing);
    view.setTransformationAnchor(QGraphicsView::NoAnchor);
    view.setScene(&scene);

    QRectF sceneRect = scene.sceneRect();
    // making enough room in the scene for stickman to jump and die
    view.resize(sceneRect.width() + 100, sceneRect.height() + 100);
    view.setSceneRect(sceneRect);

#if defined(Q_WS_S60) || defined(Q_WS_MAEMO_5) || defined(Q_WS_SIMULATOR)
    view.setHorizontalScrollBarPolicy(Qt::ScrollBarAlwaysOff);
    view.setVerticalScrollBarPolicy(Qt::ScrollBarAlwaysOff);
    view.showMaximized();
    view.fitInView(scene.sceneRect(), Qt::KeepAspectRatio);
#else
    view.show();
    view.setFocus();
#endif

    LifeCycle cycle(stickMan, &view);
    cycle.setDeathAnimation(":/animations/dead");

#if defined(Q_WS_S60) || defined(Q_WS_MAEMO_5) || defined(Q_WS_SIMULATOR)
    cycle.addActivity(":/animations/jumping", Qt::Key_J, buttonJump, SIGNAL(clicked()));
    cycle.addActivity(":/animations/dancing", Qt::Key_D, buttonDance, SIGNAL(clicked()));
    cycle.addActivity(":/animations/chilling", Qt::Key_C, buttonChill, SIGNAL(clicked()));
#else
    cycle.addActivity(":/animations/jumping", Qt::Key_J);
    cycle.addActivity(":/animations/dancing", Qt::Key_D);
    cycle.addActivity(":/animations/chilling", Qt::Key_C);
#endif

    cycle.start();


    return app.exec();
}
Exemplo n.º 24
0
//! [0]
PadNavigator::PadNavigator(const QSize &size, QWidget *parent)
    : QGraphicsView(parent)
{
//! [0]
//! [1]
    // Splash item
    SplashItem *splash = new SplashItem;
    splash->setZValue(1);
//! [1]

//! [2]
    // Pad item
    FlippablePad *pad = new FlippablePad(size);
    QGraphicsRotation *flipRotation = new QGraphicsRotation(pad);
    QGraphicsRotation *xRotation = new QGraphicsRotation(pad);
    QGraphicsRotation *yRotation = new QGraphicsRotation(pad);
    flipRotation->setAxis(Qt::YAxis);
    xRotation->setAxis(Qt::YAxis);
    yRotation->setAxis(Qt::XAxis);
    pad->setTransformations(QList<QGraphicsTransform *>()
                            << flipRotation
                            << xRotation << yRotation);
//! [2]

//! [3]
    // Back (proxy widget) item
    QGraphicsProxyWidget *backItem = new QGraphicsProxyWidget(pad);
    QWidget *widget = new QWidget;
    form.setupUi(widget);
    form.hostName->setFocus();
    backItem->setWidget(widget);
    backItem->setVisible(false);
    backItem->setFocus();
    backItem->setCacheMode(QGraphicsItem::ItemCoordinateCache);
    const QRectF r = backItem->rect();
    backItem->setTransform(QTransform()
                           .rotate(180, Qt::YAxis)
                           .translate(-r.width()/2, -r.height()/2));
//! [3]

//! [4]
    // Selection item
    RoundRectItem *selectionItem = new RoundRectItem(QRectF(-60, -60, 120, 120), Qt::gray, pad);
    selectionItem->setZValue(0.5);
//! [4]

//! [5]
    // Splash animations
    QPropertyAnimation *smoothSplashMove = new QPropertyAnimation(splash, "y");
    QPropertyAnimation *smoothSplashOpacity = new QPropertyAnimation(splash, "opacity");
    smoothSplashMove->setEasingCurve(QEasingCurve::InQuad);
    smoothSplashMove->setDuration(250);
    smoothSplashOpacity->setDuration(250);
//! [5]

//! [6]
    // Selection animation
    QPropertyAnimation *smoothXSelection = new QPropertyAnimation(selectionItem, "x");
    QPropertyAnimation *smoothYSelection = new QPropertyAnimation(selectionItem, "y");
    QPropertyAnimation *smoothXRotation = new QPropertyAnimation(xRotation, "angle");
    QPropertyAnimation *smoothYRotation = new QPropertyAnimation(yRotation, "angle");
    smoothXSelection->setDuration(125);
    smoothYSelection->setDuration(125);
    smoothXRotation->setDuration(125);
    smoothYRotation->setDuration(125);
    smoothXSelection->setEasingCurve(QEasingCurve::InOutQuad);
    smoothYSelection->setEasingCurve(QEasingCurve::InOutQuad);
    smoothXRotation->setEasingCurve(QEasingCurve::InOutQuad);
    smoothYRotation->setEasingCurve(QEasingCurve::InOutQuad);
//! [6]

//! [7]
    // Flip animation setup
    QPropertyAnimation *smoothFlipRotation = new QPropertyAnimation(flipRotation, "angle");
    QPropertyAnimation *smoothFlipScale = new QPropertyAnimation(pad, "scale");
    QPropertyAnimation *smoothFlipXRotation = new QPropertyAnimation(xRotation, "angle");
    QPropertyAnimation *smoothFlipYRotation = new QPropertyAnimation(yRotation, "angle");
    QParallelAnimationGroup *flipAnimation = new QParallelAnimationGroup(this);
    smoothFlipScale->setDuration(500);
    smoothFlipRotation->setDuration(500);
    smoothFlipXRotation->setDuration(500);
    smoothFlipYRotation->setDuration(500);
    smoothFlipScale->setEasingCurve(QEasingCurve::InOutQuad);
    smoothFlipRotation->setEasingCurve(QEasingCurve::InOutQuad);
    smoothFlipXRotation->setEasingCurve(QEasingCurve::InOutQuad);
    smoothFlipYRotation->setEasingCurve(QEasingCurve::InOutQuad);
    smoothFlipScale->setKeyValueAt(0, qvariant_cast<qreal>(1.0));
    smoothFlipScale->setKeyValueAt(0.5, qvariant_cast<qreal>(0.7));
    smoothFlipScale->setKeyValueAt(1, qvariant_cast<qreal>(1.0));
    flipAnimation->addAnimation(smoothFlipRotation);
    flipAnimation->addAnimation(smoothFlipScale);
    flipAnimation->addAnimation(smoothFlipXRotation);
    flipAnimation->addAnimation(smoothFlipYRotation);
//! [7]

//! [8]
    // Flip animation delayed property assignment
    QSequentialAnimationGroup *setVariablesSequence = new QSequentialAnimationGroup;
    QPropertyAnimation *setFillAnimation = new QPropertyAnimation(pad, "fill");
    QPropertyAnimation *setBackItemVisibleAnimation = new QPropertyAnimation(backItem, "visible");
    QPropertyAnimation *setSelectionItemVisibleAnimation = new QPropertyAnimation(selectionItem, "visible");
    setFillAnimation->setDuration(0);
    setBackItemVisibleAnimation->setDuration(0);
    setSelectionItemVisibleAnimation->setDuration(0);
    setVariablesSequence->addPause(250);
    setVariablesSequence->addAnimation(setBackItemVisibleAnimation);
    setVariablesSequence->addAnimation(setSelectionItemVisibleAnimation);
    setVariablesSequence->addAnimation(setFillAnimation);
    flipAnimation->addAnimation(setVariablesSequence);
//! [8]

//! [9]
    // Build the state machine
    QStateMachine *stateMachine = new QStateMachine(this);
    QState *splashState = new QState(stateMachine);
    QState *frontState = new QState(stateMachine);
    QHistoryState *historyState = new QHistoryState(frontState);
    QState *backState = new QState(stateMachine);
//! [9]
//! [10]
    frontState->assignProperty(pad, "fill", false);
    frontState->assignProperty(splash, "opacity", 0.0);
    frontState->assignProperty(backItem, "visible", false);
    frontState->assignProperty(flipRotation, "angle", qvariant_cast<qreal>(0.0));
    frontState->assignProperty(selectionItem, "visible", true);
    backState->assignProperty(pad, "fill", true);
    backState->assignProperty(backItem, "visible", true);
    backState->assignProperty(xRotation, "angle", qvariant_cast<qreal>(0.0));
    backState->assignProperty(yRotation, "angle", qvariant_cast<qreal>(0.0));
    backState->assignProperty(flipRotation, "angle", qvariant_cast<qreal>(180.0));
    backState->assignProperty(selectionItem, "visible", false);
    stateMachine->addDefaultAnimation(smoothXRotation);
    stateMachine->addDefaultAnimation(smoothYRotation);
    stateMachine->addDefaultAnimation(smoothXSelection);
    stateMachine->addDefaultAnimation(smoothYSelection);
    stateMachine->setInitialState(splashState);
//! [10]

//! [11]
    // Transitions
    QEventTransition *anyKeyTransition = new QEventTransition(this, QEvent::KeyPress, splashState);
    anyKeyTransition->setTargetState(frontState);
    anyKeyTransition->addAnimation(smoothSplashMove);
    anyKeyTransition->addAnimation(smoothSplashOpacity);
//! [11]

//! [12]
    QKeyEventTransition *enterTransition = new QKeyEventTransition(this, QEvent::KeyPress,
                                                                   Qt::Key_Enter, backState);
    QKeyEventTransition *returnTransition = new QKeyEventTransition(this, QEvent::KeyPress,
                                                                    Qt::Key_Return, backState);
    QKeyEventTransition *backEnterTransition = new QKeyEventTransition(this, QEvent::KeyPress,
                                                                       Qt::Key_Enter, frontState);
    QKeyEventTransition *backReturnTransition = new QKeyEventTransition(this, QEvent::KeyPress,
                                                                        Qt::Key_Return, frontState);
    enterTransition->setTargetState(historyState);
    returnTransition->setTargetState(historyState);
    backEnterTransition->setTargetState(backState);
    backReturnTransition->setTargetState(backState);
    enterTransition->addAnimation(flipAnimation);
    returnTransition->addAnimation(flipAnimation);
    backEnterTransition->addAnimation(flipAnimation);
    backReturnTransition->addAnimation(flipAnimation);
//! [12]

//! [13]
    // Create substates for each icon; store in temporary grid.
    int columns = size.width();
    int rows = size.height();
    QVector< QVector< QState * > > stateGrid;
    stateGrid.resize(rows);
    for (int y = 0; y < rows; ++y) {
        stateGrid[y].resize(columns);
        for (int x = 0; x < columns; ++x)
            stateGrid[y][x] = new QState(frontState);
    }
    frontState->setInitialState(stateGrid[0][0]);
    selectionItem->setPos(pad->iconAt(0, 0)->pos());
//! [13]

//! [14]
    // Enable key navigation using state transitions
    for (int y = 0; y < rows; ++y) {
        for (int x = 0; x < columns; ++x) {
            QState *state = stateGrid[y][x];
            QKeyEventTransition *rightTransition = new QKeyEventTransition(this, QEvent::KeyPress,
                                                                           Qt::Key_Right, state);
            QKeyEventTransition *leftTransition = new QKeyEventTransition(this, QEvent::KeyPress,
                                                                          Qt::Key_Left, state);
            QKeyEventTransition *downTransition = new QKeyEventTransition(this, QEvent::KeyPress,
                                                                          Qt::Key_Down, state);
            QKeyEventTransition *upTransition = new QKeyEventTransition(this, QEvent::KeyPress,
                                                                        Qt::Key_Up, state);
            rightTransition->setTargetState(stateGrid[y][(x + 1) % columns]);
            leftTransition->setTargetState(stateGrid[y][((x - 1) + columns) % columns]);
            downTransition->setTargetState(stateGrid[(y + 1) % rows][x]);
            upTransition->setTargetState(stateGrid[((y - 1) + rows) % rows][x]);
//! [14]
//! [15]
            RoundRectItem *icon = pad->iconAt(x, y);
            state->assignProperty(xRotation, "angle", -icon->x() / 6.0);
            state->assignProperty(yRotation, "angle", icon->y() / 6.0);
            state->assignProperty(selectionItem, "x", icon->x());
            state->assignProperty(selectionItem, "y", icon->y());
            frontState->assignProperty(icon, "visible", true);
            backState->assignProperty(icon, "visible", false);

            QPropertyAnimation *setIconVisibleAnimation = new QPropertyAnimation(icon, "visible");
            setIconVisibleAnimation->setDuration(0);
            setVariablesSequence->addAnimation(setIconVisibleAnimation);
        }
    }
//! [15]

//! [16]
    // Scene
    QGraphicsScene *scene = new QGraphicsScene(this);
    scene->setBackgroundBrush(QPixmap(":/images/blue_angle_swirl.jpg"));
    scene->setItemIndexMethod(QGraphicsScene::NoIndex);
    scene->addItem(pad);
    scene->setSceneRect(scene->itemsBoundingRect());
    setScene(scene);
//! [16]

//! [17]
    // Adjust splash item to scene contents
    const QRectF sbr = splash->boundingRect();
    splash->setPos(-sbr.width() / 2, scene->sceneRect().top() - 2);
    frontState->assignProperty(splash, "y", splash->y() - 100.0);
    scene->addItem(splash);
//! [17]

//! [18]
    // View
    setVerticalScrollBarPolicy(Qt::ScrollBarAlwaysOff);
    setHorizontalScrollBarPolicy(Qt::ScrollBarAlwaysOff);
    setMinimumSize(50, 50);
    setViewportUpdateMode(FullViewportUpdate);
    setCacheMode(CacheBackground);
    setRenderHints(QPainter::Antialiasing
                   | QPainter::SmoothPixmapTransform
                   | QPainter::TextAntialiasing);
#ifndef QT_NO_OPENGL
    setViewport(new QOpenGLWidget);
#endif

    stateMachine->start();
//! [18]
}
Exemplo n.º 25
0
Creator::Creator(QApplication &app)
{
    //播放音乐文件
    media = new Phonon::MediaObject();
    audioOutput = new Phonon::AudioOutput(Phonon::VideoCategory);//声音
    Phonon::createPath(media, audioOutput);
    sourceList.append(QString("music/infinity.wma"));


    //建立pad
    pad = new RoundRectItem(QRectF(QPointF(0,0),QPointF(0,0)),QColor(0,0,255,0));
    pad->setZValue(0);

    //设置backwindow
    backWindow = new QGraphicsProxyWidget(pad);
    backWidget = new BackWidget();
    backWindow->setX(0);
    backWindow->setY(0);
 //   backWindow->widget()->setWindowOpacity(1);
    backWindow->setWidget(backWidget);
    backWindow->setZValue(0);


    //设置开始窗口按钮
    beginWindow = new QGraphicsProxyWidget(pad);
    beginWidget = new BeginBottum;
    beginWindow->setWidget(beginWidget);
    beginWindow->setX(backWindow->x()+400);
    beginWindow->setY(backWindow->y()+200);
    beginWindow->widget()->setWindowOpacity(1);
    beginWindow->setZValue(0.5);

    //设置音乐按键
    musicWindow = new QGraphicsProxyWidget(pad);
    musicWidget = new ClickBottum;
    musicWindow->setWidget(musicWidget);
    musicWindow->setX(backWindow->widget()->width()-120);
    musicWindow->setY(backWindow->y()+20);
    musicWindow->widget()->setWindowOpacity(1);
    musicWindow->setZValue(0.9);


    //设置AI对战窗口
    aiWindow = new QGraphicsProxyWidget(pad);
    aiWidget = new AIvsAI();
    aiWindow->setWidget(aiWidget);
    aiWindow->setX(backWindow->x());
    aiWindow->setY(backWindow->y());
    aiWindow->widget()->setWindowOpacity(0);
    aiWindow->setZValue(0.5);

    //按钮控件
    singleWindow = new QGraphicsProxyWidget(pad);
    singleWidget = new widgetssingle;
    singleWindow->setWidget(singleWidget);
    singleWindow->setX(backWindow->x()+400);
    singleWindow->setY(backWindow->y()+200);
    singleWindow->widget()->setWindowOpacity(0);
    singleWindow->setZValue(0.5);

    //回放器
    replayerWindow = new QGraphicsProxyWidget(pad);
    replayerWidget = new ReplayWindow();
    replayerWindow->setWidget(replayerWidget);
    replayerWindow->setX(backWindow->x());
    replayerWindow->setY(backWindow->y());
    replayerWindow->widget()->setWindowOpacity(0);
    replayerWindow->setZValue(0.5);

    //地图编辑器
    mapEditWindow = new QGraphicsProxyWidget(pad);
    mapWideget = new MapEditor();
    mapEditWindow->setWidget(mapWideget);
    mapEditWindow->setX(backWindow->x());
    mapEditWindow->setY(backWindow->y());
    mapEditWindow->widget()->setWindowOpacity(0);
    mapEditWindow->setZValue(0.5);

    //人机对战
    humanaiWindow = new QGraphicsProxyWidget(pad);
    humanaiWidget = new humanai();
    humanaiWindow->setX(backWindow->x());
    humanaiWindow->setY(backWindow->y());
    humanaiWindow->setWidget(humanaiWidget);
    humanaiWindow->widget()->setWindowOpacity(0);
    humanaiWindow->setZValue(0.5);

    //制作团队
    teamMeneWindow = new QGraphicsProxyWidget(pad);
    teamMeneWideget = new TeamMenu();
    teamMeneWindow->setWidget(teamMeneWideget);
    teamMeneWindow->setX(backWindow->x());
    teamMeneWindow->setY(backWindow->y());
    teamMeneWindow->widget()->setWindowOpacity(1);
    teamMeneWindow->setZValue(0.5);

    teamWindow = new QGraphicsProxyWidget(pad);
    teamWideget = new ProductionTeam();
    teamWindow->setWidget(teamWideget);
    teamWindow->widget()->setWindowOpacity(1);
    teamWindow->setZValue(0.5);
    teamWideget->setAutoFillBackground(true);
    QPalette Tpalette = teamWindow->palette();
    Tpalette.setBrush(QPalette::Window,
                      QBrush(Qt::black));
    teamWindow->setPalette(Tpalette);

//登陆
    LogInWindow = new QGraphicsProxyWidget(pad);
    logInwidget = new LogInWidget();
    LogInWindow->setWidget(logInwidget);
    LogInWindow->widget()->setWindowOpacity(0);
    LogInWindow->setZValue(0.5);
    LogInWindow->setX(0);
    LogInWindow->setY(0);

//测试赛
    TestWindow = new QGraphicsProxyWidget(pad);
    testwidget = new TestWidget();
    TestWindow->setWidget(testwidget);
    TestWindow->widget()->setWindowOpacity(0);
    TestWindow->setZValue(0.5);
    TestWindow->setX(0);
    TestWindow->setY(0);


//  beginWindow->close();
    aiWindow->close();
    singleWindow->close();
    replayerWindow->close();
    teamMeneWindow->close();
    teamWindow->close();
    mapEditWindow->close();
    humanaiWindow->close();
    LogInWindow->close();
    TestWindow->close();

    QObject::connect(beginWidget->returnUi()->exitmain,SIGNAL(clicked()),this,SLOT(close()));
    QObject::connect(beginWidget->returnUi()->startsingle,SIGNAL(clicked()),this,SLOT(BeginToSingle()));
    connect(this->singleWidget->ui->returnpre,SIGNAL(clicked()),this,SLOT(SingleToBegin()));
    connect(this->singleWidget->ui->aivsai,SIGNAL(clicked()),this,SLOT(SingleToAi()));
    connect(this->aiWidget->ui->ReturnPre,SIGNAL(clicked()),this,SLOT(AiToSingle()));
    connect(this->singleWidget->ui->replay,SIGNAL(clicked()),this,SLOT(SingleToReplayer()));
    connect(this->replayerWidget->returnUi()->pushButton,SIGNAL(clicked()),this,SLOT(ReplayerToSingle()));
    connect(this->beginWidget->returnUi()->team,SIGNAL(clicked()),this,SLOT(BeginToTeam()));
    connect(this->teamMeneWideget->returnUi()->pushButton,SIGNAL(clicked()),this,SLOT(TeamToBegin()));
    connect(this->musicWidget->ui->checkBox,SIGNAL(clicked()),this,SLOT(Music()));
    connect(this->replayerWidget->returnUi()->pushButton,SIGNAL(clicked()),this->replayerWidget,SLOT(GoInto()));
    connect(this->mapWideget->returnUi()->pushButton_5,SIGNAL(clicked()),this,SLOT(MapToSingle()));
    connect(this->singleWidget->ui->mapedit,SIGNAL(clicked()), this, SLOT(SingLeToMap()));
    connect(this->singleWidget->ui->playervsai,SIGNAL(clicked()),this,SLOT(SingleToHumanai()));
    connect(this->singleWidget->ui->playervsai, SIGNAL(clicked()), humanaiWidget, SLOT(initEmpty()));
    connect(this->humanaiWidget->returnUi()->Button_back, SIGNAL(clicked()), this, SLOT(HumanaiToSingle()));
    connect(this->media,SIGNAL(aboutToFinish()),this,SLOT(continueMusic()));
    connect(this->singleWidget->ui->levelmode,SIGNAL(clicked()),this,SLOT(SingleToLogIn()));
    connect(this->logInwidget->returnUi()->pushButton_2,SIGNAL(clicked()),this,SLOT(LogInToSingle()));
    connect(this->logInwidget,SIGNAL(login_success(QString)),this,SLOT(LogInToTest(QString)));
    connect(this->testwidget->returnUi()->pushButton,SIGNAL(clicked()),this,SLOT(TestToLogIn()));

//    connect(this->singleWidget->ui->replay,SIGNAL(clicked()),this->replayerWidget,SLOT(GoInto()));

    //设置界面背景
    QGraphicsScene *scene = new QGraphicsScene(this);
    scene->addItem(pad);
    scene->setBackgroundBrush(QBrush(QColor(0,0,0,255)));
    scene->setSceneRect(scene->itemsBoundingRect());

    setScene(scene);
    showFullScreen();

    //建立状态
    stateMachine = new QStateMachine(this);
    MainState = new QState(stateMachine);
    TeamState = new QState(stateMachine);
    BeginState = new QState(stateMachine);
    TestState = new QState(stateMachine);
    ReplayerState = new QState(stateMachine);
    WebState = new QState(stateMachine);
    MapState = new QState(stateMachine);
    HumanaiState = new QState(stateMachine);
    ChatState = new QState(stateMachine);
    WidState = new QState(stateMachine);

    BeginMenuState= new QState(stateMachine);
    SingleState= new QState(stateMachine);
    OldMenuState = new QState(stateMachine);
    CheckMenuState = new QState(stateMachine);
    TeamMenuState = new QState(stateMachine);
    LogState = new QState(stateMachine);

    MainState->assignProperty(MainState, "z", 0);
    MainState->assignProperty(beginWindow->widget(), "windowOpacity", 1);

    stateMachine->setInitialState(MainState);
    stateMachine->start();
}
Exemplo n.º 26
0
int main(int argc, char **argv)
{
    QApplication app(argc, argv);

    QGraphicsScene scene;
    scene.setSceneRect(0, 0, 800, 480);

    QSizeF minSize(30, 100);
    QSizeF prefSize(210, 100);
    QSizeF maxSize(300, 100);

    QGraphicsProxyWidget *a = createItem(minSize, prefSize, maxSize, "A");
    QGraphicsProxyWidget *b = createItem(minSize, prefSize, maxSize, "B");
    QGraphicsProxyWidget *c = createItem(minSize, prefSize, maxSize, "C");
    QGraphicsProxyWidget *d = createItem(minSize, prefSize, maxSize, "D");
    QGraphicsProxyWidget *e = createItem(minSize, prefSize, maxSize, "E");
    QGraphicsProxyWidget *f = createItem(QSizeF(30, 50), QSizeF(150, 50), maxSize, "F (overflow)");
    QGraphicsProxyWidget *g = createItem(QSizeF(30, 50), QSizeF(30, 100), maxSize, "G (overflow)");

    QGraphicsAnchorLayout *l = new QGraphicsAnchorLayout;
    l->setSpacing(0);

    QGraphicsWidget *w = new QGraphicsWidget(0, Qt::Window);
    w->setPos(20, 20);
    w->setLayout(l);

    // vertical
    QGraphicsAnchor *anchor = l->addAnchor(a, Qt::AnchorTop, l, Qt::AnchorTop);
    anchor = l->addAnchor(b, Qt::AnchorTop, l, Qt::AnchorTop);

    anchor = l->addAnchor(c, Qt::AnchorTop, a, Qt::AnchorBottom);
    anchor = l->addAnchor(c, Qt::AnchorTop, b, Qt::AnchorBottom);
    anchor = l->addAnchor(c, Qt::AnchorBottom, d, Qt::AnchorTop);
    anchor = l->addAnchor(c, Qt::AnchorBottom, e, Qt::AnchorTop);

    anchor = l->addAnchor(d, Qt::AnchorBottom, l, Qt::AnchorBottom);
    anchor = l->addAnchor(e, Qt::AnchorBottom, l, Qt::AnchorBottom);

    anchor = l->addAnchor(c, Qt::AnchorTop, f, Qt::AnchorTop);
    anchor = l->addAnchor(c, Qt::AnchorVerticalCenter, f, Qt::AnchorBottom);
    anchor = l->addAnchor(f, Qt::AnchorBottom, g, Qt::AnchorTop);
    anchor = l->addAnchor(c, Qt::AnchorBottom, g, Qt::AnchorBottom);

    // horizontal
    anchor = l->addAnchor(l, Qt::AnchorLeft, a, Qt::AnchorLeft);
    anchor = l->addAnchor(l, Qt::AnchorLeft, d, Qt::AnchorLeft);
    anchor = l->addAnchor(a, Qt::AnchorRight, b, Qt::AnchorLeft);

    anchor = l->addAnchor(a, Qt::AnchorRight, c, Qt::AnchorLeft);
    anchor = l->addAnchor(c, Qt::AnchorRight, e, Qt::AnchorLeft);

    anchor = l->addAnchor(b, Qt::AnchorRight, l, Qt::AnchorRight);
    anchor = l->addAnchor(e, Qt::AnchorRight, l, Qt::AnchorRight);
    anchor = l->addAnchor(d, Qt::AnchorRight, e, Qt::AnchorLeft);

    anchor = l->addAnchor(l, Qt::AnchorLeft, f, Qt::AnchorLeft);
    anchor = l->addAnchor(l, Qt::AnchorLeft, g, Qt::AnchorLeft);
    anchor = l->addAnchor(f, Qt::AnchorRight, g, Qt::AnchorRight);


    scene.addItem(w);
    scene.setBackgroundBrush(Qt::darkGreen);
    QGraphicsView *view = new QGraphicsView(&scene);
    view->show();

    return app.exec();
}
Exemplo n.º 27
0
//create all sub-widgets and display everything
void PlayScreen::display(int screenWidth, int screenHeight, int gridSize)
{
    this->screenWidth = screenWidth;
    this->screenHeight = screenHeight;

    grid = gridSize;
    numMoves = 0;
    seconds = 0;
    percentComplete = grid*grid;
    QFont font("Helvectica", 13);

    //set up scene and view
    QGraphicsScene *gScene = new QGraphicsScene(this);
    QGraphicsView *gView = new QGraphicsView(gScene);
    gView->setFixedSize(screenWidth, screenHeight);
    gScene->setBackgroundBrush(Qt::black);

    //set up all GridLayouts
    QGridLayout *layout = new QGridLayout(gView);
    playGrid = new QGridLayout();
    QGridLayout *menuGrid = new QGridLayout();
    layout->setContentsMargins(0,0,0,0);
    playGrid->setContentsMargins(0,0,0,0);
    menuGrid->setContentsMargins(0,0,0,0);
    gView->setLayout(layout);
    layout->addLayout(playGrid, 0, 0);
    layout->addLayout(menuGrid, 1, 0);

    //timer and move labels
    movesLabel = new QLabel("Moves: " + QString::number(numMoves));
    timerLabel = new QLabel("Time: 0:0");
    percentLabel = new QLabel("Percent: 0%");
    menuGrid->addWidget(movesLabel,0,0);
    menuGrid->addWidget(timerLabel,1,0);
    menuGrid->addWidget(percentLabel,2,0);
    movesLabel->setFont(font);
    timerLabel->setFont(font);
    percentLabel->setFont(font);

    //menu buttons
    QPushButton *winButton = new QPushButton("DEBUG WIN");
    QPushButton *pauseButton = new QPushButton("Pause/Play");
    QPushButton *giveUpButton = new QPushButton("Give Up");
    menuGrid->addWidget(winButton, 0, 1);
    menuGrid->addWidget(pauseButton, 1, 1);
    menuGrid->addWidget(giveUpButton, 2, 1);
    winButton->setFont(font);
    pauseButton->setFont(font);
    giveUpButton->setFont(font);
    connect(winButton, SIGNAL(clicked()), this, SLOT(winButtonClicked()));
    connect(pauseButton, SIGNAL(clicked()), this, SLOT(pauseButtonClicked()));
    connect(giveUpButton, SIGNAL(clicked()), this, SLOT(giveUpButtonClicked()));

    //import image
    QImageReader reader(imgPath);
    reader.setScaledSize(QSize(screenWidth, screenWidth));
    QImage image = reader.read();
    int eHeight = image.height();
    int eWidth = image.width();

    //cut image into tiles and position them
    for(int i = 0; i < grid; i++){
        for(int j = 0; j < grid; j++){
            if(!(i==grid-1 && j==grid-1)){
                QPixmap pixmap = QPixmap::fromImage(image.copy(i*(eWidth/grid), j*(eHeight/grid), eWidth/grid, eHeight/grid));
                QIcon icon(pixmap);
                Tile *button = new Tile(i, j, icon);
                button->setIconSize(QSize(eWidth/grid, eHeight/grid));

                playGrid->addWidget(button, j, i);
                connect(button, SIGNAL(tileClicked(Tile*)), this, SLOT(handleTileClick(Tile*)));
            }
        }
    }
Exemplo n.º 28
0
int main(int argc, char *argv[])
{
    QApplication a(argc, argv);
    MainWindow w;
    MyTimer timer;
    QPainterPath painter;
    QPainter paint;
    QBrush brush(Qt::red);
    QGraphicsScene scene;

   scene.addItem(r1);
   scene.addItem(r2);
   scene.addItem(r3);
   scene.addItem(r4);
   scene.addItem(r5);
   scene.addItem(r6);
   scene.addItem(r7);
   scene.addItem(r8);
   scene.addItem(r9);
   scene.addItem(r10);
   scene.addItem(r11);
   scene.addItem(r12);
   scene.addItem(r13);
   scene.addItem(r14);
   scene.addItem(r15);
   scene.addItem(r16);
   scene.addItem(r17);
   scene.addItem(r18);
   scene.addItem(r19);
   scene.addItem(r20);
   scene.addItem(r21);
   q1 = scene.addText("new text");
   q1->setPos(-100,0);

   r1->setBrush(QColor(255, 255, 255, 127));
   r2->setBrush(QColor(255, 255, 255, 127));
   r3->setBrush(QColor(255, 255, 255, 127));
   r4->setBrush(QColor(255, 255, 255, 127));
   r5->setBrush(QColor(255, 255, 255, 127));
   r6->setBrush(QColor(255, 255, 255, 127));
   r7->setBrush(QColor(255, 255, 255, 127));
   r8->setBrush(QColor(255, 255, 255, 127));
   r9->setBrush(QColor(255, 255, 255, 127));
   r10->setBrush(QColor(255, 255, 255, 127));
   r11->setBrush(QColor(255, 255, 255, 127));
   r12->setBrush(QColor(255, 255, 255, 127));
   r13->setBrush(QColor(255, 255, 255, 127));
   r14->setBrush(QColor(255, 255, 255, 127));
   r15->setBrush(QColor(255, 255, 255, 127));
   r16->setBrush(QColor(255, 255, 255, 127));
   r17->setBrush(QColor(255, 255, 255, 127));
   r18->setBrush(QColor(255, 255, 255, 127));
   r19->setBrush(QColor(255, 255, 255, 127));
   r20->setBrush(QColor(255, 255, 255, 127));
   r21->setBrush(QColor(255, 255, 255, 127));
   QPen pen(Qt::red);
   scene.addEllipse(-40,20,20,20,pen,brush);
   scene.addEllipse(300,80,20,20,pen,brush);
   scene.addEllipse(140,140,20,20,pen,brush);
   scene.setBackgroundBrush(QColor(160,200,190,140));
  QGraphicsView view(&scene);
   view.show();
   // window->setLayout(layout);
    //window->show();
        // w.show();
         return a.exec();
}
Exemplo n.º 29
0
MainWindow::MainWindow() : QMainWindow()
{
    // Create network view
    nView = new NetworkView();
    QGraphicsScene *scene = new QGraphicsScene();
    scene->setBackgroundBrush(QBrush(QColor(192, 192, 192)));
    nView->setScene(scene);
    setCentralWidget(nView);

    // Create tree view
    tView = new QTreeView(this);
    QDockWidget *treeDockWidget = new QDockWidget(tr("Tree"), this);
    treeDockWidget->setWidget(tView);
    addDockWidget(Qt::LeftDockWidgetArea, treeDockWidget);

    // Create controls view
    controls = new Controls();
    controlWidget = new QDockWidget(tr("Controls"), this);
    controlWidget->setWidget(controls);
    addDockWidget(Qt::LeftDockWidgetArea, controlWidget);
    controlWidget->hide();

    // Create properties view
    pView = new PropsView(this);
    propsWidget = new QDockWidget(tr("Properties"), this);
    propsWidget->setWidget(pView);
    addDockWidget(Qt::RightDockWidgetArea, propsWidget);
    propsWidget->hide();

    // Create edit view
    eView = new EditView(this);
    editWidget = new QDockWidget(tr("Edit Properties"), this);
    editWidget->setWidget(eView);
    addDockWidget(Qt::RightDockWidgetArea, editWidget);
    editWidget->hide();

    // Create menu
    fileMenu = menuBar()->addMenu(tr("&File"));
    fileMenu->addAction(tr("&Open..."), this, SLOT(openFile()), QKeySequence::Open);
    fileMenu->addAction(tr("Save &As..."), this, SLOT(saveAsFile()), QKeySequence::Save/*As*/);
    fileMenu->addSeparator();
    fileMenu->addAction(tr("Open in SUMO-GUI"), this, SLOT(openSUMO()));
    fileMenu->addAction(tr("Locate SUMO-GUI..."), this, SLOT(locateSUMO()));
    fileMenu->addSeparator();
    fileMenu->addAction(tr("E&xit"), this, SLOT(close()), QKeySequence::Quit);

    viewMenu = menuBar()->addMenu(tr("&View"));
    viewMenu->addAction(treeDockWidget->toggleViewAction());
    viewMenu->addAction(controlWidget->toggleViewAction());
    viewMenu->addAction(propsWidget->toggleViewAction());
    viewMenu->addAction(editWidget->toggleViewAction());

    specialEditorsMenu = menuBar()->addMenu(tr("&Special Editors"));
    nmlJuncIcon = QPixmap(":/icons/nmlJunc1616.png");
    tlLogicIcon = QPixmap(":/icons/tllogic1616.png");
    specialEditorsMenu->addAction(nmlJuncIcon, tr("&Junction Editor"), this, SLOT(openJunctionEditor()));
    specialEditorsMenu->addAction(tlLogicIcon, tr("&tlLogic Editor"), this, SLOT(openTLEditor()));

    // Read settings from the nefs.ini file
    QSettings settings(QCoreApplication::applicationDirPath() + "/nefs.ini", QSettings::IniFormat);
    xmlPath = settings.value("paths/work").toString();
    sumoguiPath = settings.value("paths/sumo").toString();

    // Status bar
    statusBar()->showMessage(tr("Ready"));

    // Title and icon
    setWindowTitle(tr("Network Editor for SUMO"));
    setWindowIcon(QIcon(QPixmap(":/icons/NE4S128.png")));

    modelLoaded = false;
}