Example #1
0
bool SkyQPainter::drawConstellationArtImage(ConstellationsArt *obj)
{
    double zoom = Options::zoomFactor();

    bool visible = false;
    obj->EquatorialToHorizontal(KStarsData::Instance()->lst(), KStarsData::Instance()->geo()->lat());
    QPointF constellationmidpoint = m_proj->toScreen(obj, true, &visible);

    if ( !visible || !m_proj->onScreen(constellationmidpoint))
        return false;

    //qDebug() << "o->pa() " << obj->pa();
    float positionangle = m_proj->findPA(obj, constellationmidpoint.x(), constellationmidpoint.y());
    //qDebug() << " final PA " << positionangle;


    float w = obj->getWidth()*60*dms::PI*zoom/10800;
    float h = obj->getHeight()*60*dms::PI*zoom/10800;

    save();

    setRenderHint(QPainter::SmoothPixmapTransform);

    translate(constellationmidpoint);
    rotate(positionangle);
    setOpacity(0.7);
    drawImage( QRect(-0.5*w, -0.5*h, w, h), obj->image() );
    setOpacity(1);

    setRenderHint(QPainter::SmoothPixmapTransform, false);
    restore();
    return true;
}
Example #2
0
GameView::GameView(): QGraphicsView(),
 m_scene(new QGraphicsScene(this)),
 m_controller(new Controller(m_scene.get())),
 m_accelerated(false)
{
    // set scene size
    m_scene->setSceneRect(0, 0, Globs::SCREEN_WIDTH, Globs::SCREEN_HEIGHT);
    setScene(m_scene.get());
    setRenderHint(QPainter::Antialiasing);
    setRenderHint(QPainter::SmoothPixmapTransform);

    // set the view size
    setHorizontalScrollBarPolicy(Qt::ScrollBarAlwaysOff);
    setVerticalScrollBarPolicy(Qt::ScrollBarAlwaysOff);
    setFixedSize(Globs::SCREEN_WIDTH, Globs::SCREEN_HEIGHT);

    // render the tanks
    for(auto tank : m_controller->get_tanks())
    {
        m_scene->addItem(tank.get());
    }

    for(auto ammo : m_controller->get_ammo())
    {
        m_scene->addItem(ammo.get());
    }

    emit m_controller->start_loop(static_cast<int>(1000/Globs::FPS));
}
Example #3
0
QtTextureViewer::QtTextureViewer(QWidget* parent)
    : QGraphicsView(parent)
{
    m_scene = new QGraphicsScene();
    m_scene->setSceneRect(0, 0, 2048, 2048);
    setScene(m_scene);

    centerOn(1024, 1024);

    m_pixmapItem = new QGraphicsPixmapItem();
    m_scene->addItem(m_pixmapItem);

    setBackground();
    setHorizontalScrollBarPolicy(Qt::ScrollBarAlwaysOff);
    setVerticalScrollBarPolicy(Qt::ScrollBarAlwaysOff);
    setRenderHint(QPainter::Antialiasing, false);
    setTransformationAnchor(AnchorUnderMouse);
    setDragMode(ScrollHandDrag);
    viewport()->setCursor(Qt::ArrowCursor);

    // Turn this off to make background grid pixmap sharp
    setRenderHint(QPainter::SmoothPixmapTransform, false);

    // Zoom in out to the current cursor location
    setTransformationAnchor(QGraphicsView::AnchorUnderMouse);
}
Example #4
0
Space::Space(Manager *manager, qulonglong id, QString name, QWidget *parent)
    : QGraphicsView(parent)
{
    // setup
    m_manager = manager;
    m_id = id;
    m_name = name;
    setRenderHint(QPainter::Antialiasing, true);
    setRenderHint(QPainter::HighQualityAntialiasing, true);
    setScene(new QGraphicsScene());
    setMouseTracking(true);
    // ... background
    QString bg_stylesheet = "QGraphicsView { background: qlineargradient(x1: 0,"
                            "                                            y1: 0,"
                            "                                            x2: 0,"
                            "                                            y2: 1,"
                            "                                            stop: 0 black,"
                            "                                            stop: 1 gray);"
                            "}"
                            "QScrollBar:vertical {"
                            "border: none;"
                            "background: #575757;"
                            "width: 15px;"
                            "margin: 15px 0px 15px 0px;"
                            "}"
                            "QScrollBar::sub-line:vertical {"
                            "image: url(:/up_arrow);"
                            "height: 15px;"
                            "subcontrol-position: top;"
                            "subcontrol-origin: margin;"
                            "}"
                            "QScrollBar::add-line:vertical {"
                            "image: url(:/down_arrow);"
                            "height: 15px;"
                            "subcontrol-position: bottom;"
                            "subcontrol-origin: margin;"
                            "}"
                            "QScrollBar:horizontal {"
                            "border: none;"
                            "background: #575757;"
                            "width: 15px;"
                            "margin: 0px 15px 0px 15px;}"
                            "QScrollBar::sub-line:horizontal {"
                            "image: url(:/left_arrow);"
                            "height: 15px;"
                            "subcontrol-position: left;"
                            "subcontrol-origin: margin;"
                            "}"
                            "QScrollBar::add-line:horizontal {"
                            "image: url(:/right_arrow);"
                            "height: 15px;"
                            "subcontrol-position: right;"
                            "subcontrol-origin: margin;"
                            "}";
    this->setStyleSheet(bg_stylesheet);
    // ... spacebar
    QSettings settings;
    m_taskbar = new TaskBar(m_manager, this, QGraphicsView::scene(), this);
}
Example #5
0
void SkyQPainter::begin()
{
    QPainter::begin(m_pd);
    bool aa = !m_sm->isSlewing() && Options::useAntialias();
    setRenderHint(QPainter::Antialiasing, aa );
    setRenderHint(QPainter::HighQualityAntialiasing, aa);
    m_proj = m_sm->projector();
}
 DrawingView1(QWidget* parent=0) : QGraphicsView(parent) {
     setGeometry(200,100,600,400);
     setWindowTitle("FlAG Game");
     setRenderHint(QPainter::Antialiasing);
     setRenderHint(QPainter::HighQualityAntialiasing);
     setRenderHint(QPainter::TextAntialiasing);
     setRenderHint(QPainter::SmoothPixmapTransform);
 }
void CanvasContainer::setSmoothScale(bool smooth)
{
    smoothScaleFlag = smooth;
    if (!smoothScaleFlag)
    {
        setRenderHint(QPainter::Antialiasing, false);
        setRenderHint(QPainter::SmoothPixmapTransform, false);
    }
}
Example #8
0
MainView::MainView(Scene *scene) :
	View(scene, nullptr), miniMap(new MiniMap(scene, this)), scaleLevel(SCALING_FACTOR)
{
	setRenderHint(QPainter::Antialiasing);
	setRenderHint(QPainter::TextAntialiasing);

	setTransformationAnchor(QGraphicsView::AnchorUnderMouse);

	setMiniMapSize(MINIMAP_DEFAULT_WIDTH, MINIMAP_DEFAULT_HEIGHT);
}
//------------------------------------------------------------------------------
// Name: GraphWidgetBase(QWidget *parent)
//------------------------------------------------------------------------------
GraphWidgetBase::GraphWidgetBase(QWidget *parent) : QGraphicsView(parent) {

	setRenderHint(QPainter::Antialiasing);
	setRenderHint(QPainter::TextAntialiasing);
	setTransformationAnchor(AnchorUnderMouse);
	setResizeAnchor(AnchorUnderMouse);

	scene_ = new QGraphicsScene(this);
	scene_->setItemIndexMethod(QGraphicsScene::BspTreeIndex);
	setScene(scene_);
}
Example #10
0
AniPreviewView::AniPreviewView(AniPreviewWnd* pParent) : QGraphicsView(pParent), m_pWnd(pParent)
{
	AniPreviewScene *scene = new AniPreviewScene(this);
	setScene(scene);
	scene->setSceneRect(-2000, -2000, 4000, 4000);
	
	setRenderHint(QPainter::Antialiasing);
	setCacheMode(CacheBackground);
	setViewportUpdateMode(BoundingRectViewportUpdate);
	setRenderHint(QPainter::Antialiasing);
	setTransformationAnchor(AnchorUnderMouse);
	centerOn(QPoint(0, 0));
}
Example #11
0
void MyGraphicsView::setAntialiasing(bool antialiasingOn)
{
    if (antialiasingOn)
    {
        setRenderHint(QPainter::Antialiasing, true);
        setRenderHint(QPainter::TextAntialiasing, true);
        g_settings->labelFont.setStyleStrategy(QFont::PreferDefault);
    }
    else
    {
        setRenderHint(QPainter::Antialiasing, false);
        setRenderHint(QPainter::TextAntialiasing, false);
        g_settings->labelFont.setStyleStrategy(QFont::NoAntialias);
    }
}
SchematicSceneViewer::SchematicSceneViewer(QWidget *parent)
	: QGraphicsView(parent), m_buttonState(Qt::NoButton), m_oldWinPos(), m_oldScenePos(), m_firstShowing(true)
{
	setObjectName("SchematicSceneViewer");

	setHorizontalScrollBarPolicy(Qt::ScrollBarAlwaysOff);
	setVerticalScrollBarPolicy(Qt::ScrollBarAlwaysOff);
	setDragMode(QGraphicsView::NoDrag);
	setTransformationAnchor(QGraphicsView::NoAnchor);
	setRenderHint(QPainter::SmoothPixmapTransform);
	setRenderHint(QPainter::TextAntialiasing);
	setRenderHint(QPainter::Antialiasing);
	setInteractive(true);
	setViewportUpdateMode(QGraphicsView::SmartViewportUpdate);
	show();
}
Example #13
0
ChannelViewer::ChannelViewer(QWidget *parent) :
    QGraphicsView(parent)
{
    if (_extrapolationTypeName.size() == 0) {
        QHashIterator<QString, Channel::ExtrapolateType> it(_extrapolationNameType);
        while (it.hasNext()) {
            it.next();
            _extrapolationTypeName[it.value()] = it.key();
        }
    }
    if (_tangentTypeName.size() == 0) {
        QHashIterator<QString, Keyframe::TangentType> it(_tangentNameType);
        while (it.hasNext()) {
            it.next();
            _tangentTypeName[it.value()] = it.key();
        }
    }
    _ui = NULL;
    _scene = new QGraphicsScene(this);
    _scene->setBackgroundBrush(QBrush(QColor(69, 69, 61)));
    setScene(_scene);
    _innerCurve = NULL;
    _outerCurve = NULL;
    _mainGrid = NULL;
    _grid = NULL;
    setRenderHint(QPainter::Antialiasing);
    _isDragging = false;
    _selectionRect = NULL;
}
Example #14
0
FMSampleTextView::FMSampleTextView ( QWidget* parent )
		: QGraphicsView ( parent ),
		hasPendingUpdate ( false )
{
#if 0
	QGLFormat glfmt;
	glfmt.setSampleBuffers ( true );
	QGLWidget *glwgt = new QGLWidget ( glfmt );
// 	qDebug()<<"GL:: A DR S"<<glwgt->format().alpha()<<glwgt->format().directRendering()<<glwgt->format().sampleBuffers();
// 	setViewport(glwgt);
	if ( glwgt->format().sampleBuffers() )
	{
		setViewport ( glwgt );
		qDebug() <<"opengl enabled - DirectRendering("<< glwgt->format().directRendering() <<") - SampleBuffers("<< glwgt->format().sampleBuffers() <<")";
	}
	else
	{
		qDebug() <<"opengl disabled - DirectRendering("<< glwgt->format().directRendering() <<") - SampleBuffers("<< glwgt->format().sampleBuffers() <<")";
		delete glwgt;
	}
#endif

	setInteractive ( false );
	setHorizontalScrollBarPolicy(Qt::ScrollBarAlwaysOff);
	setVerticalScrollBarPolicy(Qt::ScrollBarAlwaysOff);
	theRect = 0;
	fPage = 0;
	isSelecting = false;
	isPanning = false;
	setAlignment ( Qt::AlignTop | Qt::AlignHCenter );
	setTransformationAnchor ( QGraphicsView::NoAnchor );
	setRenderHint ( QPainter::Antialiasing, true );
	setBackgroundBrush(Qt::white);
}
Example #15
0
GraphView::GraphView(QGraphicsScene * scene, QWidget * parent) : QGraphicsView (scene, parent)
{
    yScale=0;
    setAttribute(Qt::WA_AcceptTouchEvents);
    setDragMode(ScrollHandDrag);

       setMouseTracking(true);
       setRenderHint(QPainter::Antialiasing, true);
       setRenderHint(QPainter::TextAntialiasing, true);
       setRenderHint(QPainter::SmoothPixmapTransform, true);
       //setAlignment((Qt::AlignRight | Qt::AlignTop));

       createGKey();


}
GraphGraphicsView::GraphGraphicsView(QWidget *parent) :
    QGraphicsView(parent)
{
    setScene(&scene);
    resize(1000,500);
    setBackgroundBrush(Qt::white);
    setFocus();

    QLinearGradient linearGrad(-500, -500, 500, 500); // átmenetes ecset
    linearGrad.setColorAt(0, QColor(255, 255, 255));
    linearGrad.setColorAt(1, QColor(192, 192, 192));
    setBackgroundBrush(linearGrad);
    setRenderHint(QPainter::Antialiasing);
    setFrameStyle(QFrame::NoFrame);
    setHorizontalScrollBarPolicy(Qt::ScrollBarAlwaysOff);
    setVerticalScrollBarPolicy(Qt::ScrollBarAlwaysOff);

    qsrand(QTime::currentTime().msec());

    randomGraph();

    dDialog = new dijkstraDialog();
    source = -1;
    destination = -1;

    QObject::connect(dDialog, SIGNAL(runDijkstraFromTo(int,int)),
                     this, SLOT(runDijkstra(int,int)));
}
Example #17
0
QTCOMMERCIALCHART_USE_NAMESPACE

ChartView::ChartView(QWidget *parent)
    : QChartView(new QChart(), parent),
      m_scatter(0),
      m_scatter2(0)
{
    setRenderHint(QPainter::Antialiasing);

    chart()->setTitle("Click to interact with scatter points");

    m_scatter = new QScatterSeries();
    for(qreal x(0.5); x <= 4.0; x += 0.5) {
        for(qreal y(0.5); y <= 4.0; y += 0.5) {
            *m_scatter << QPointF(x, y);
        }
    }
    m_scatter2 = new QScatterSeries();

    chart()->addSeries(m_scatter2);
    chart()->addSeries(m_scatter);
    chart()->axisX()->setRange(0, 4.5);
    chart()->axisY()->setRange(0, 4.5);

    connect(m_scatter, SIGNAL(clicked(QPointF)), this, SLOT(handleClickedPoint(QPointF)));
}
Example #18
0
Overview::Overview(QWidget* parent)
	: QGraphicsView(parent),
	m_min_scale_level(0),
	m_scale_level(0)
{
	setWindowTitle(tr("Overview"));
	setWindowFlags(Qt::Tool);

	setBackgroundBrush(Qt::darkGray);
	setBackgroundRole(QPalette::Window);
	setRenderHint(QPainter::SmoothPixmapTransform, true);
	setDragMode(ScrollHandDrag);
	setFrameStyle(NoFrame);

	// Create scene
	QGraphicsScene* scene = new QGraphicsScene(this);
	setScene(scene);
	m_pixmap = new QGraphicsPixmapItem;
	m_pixmap->setTransformationMode(Qt::SmoothTransformation);
	scene->addItem(m_pixmap);
	reset();

	// Restore geometry
	QSettings settings;
	if (settings.contains("Overview/Geometry")) {
		restoreGeometry(settings.value("Overview/Geometry").toByteArray());
		setMinimumSize(size());
	} else {
		resize(400, 400);
		setMinimumSize(size());
	}
	m_default = settings.value("Overview/Default", true).toBool();
}
CodeMiniMap::CodeMiniMap(QWidget  *parent)
{
	mParent = parent;
	mCodeView = 0;
	codepixmap = 0;

	mScene = new QGraphicsScene(this);
    mScene->setItemIndexMethod(QGraphicsScene::BspTreeIndex);
	mScene->setSceneRect(-this->geometry().width()/2,-this->geometry().height()/2,this->geometry().width(),this->geometry().height());
	setScene(mScene);

	setViewportUpdateMode(QGraphicsView::FullViewportUpdate);
	setRenderHint(QPainter::Antialiasing,true);

	m_intrect = new CodeViewInteractiveRect(this);
	mScene->addItem(m_intrect);
	m_intrect->setPos(QPointF(0.0,0.0));

	m_intrect->rect_height = scene()->sceneRect().height();
	m_intrect->rect_width = scene()->sceneRect().width();
	zoomlevel = 1.0f;

	//this->horizontalScrollBar()->hide();
	//this->verticalScrollBar()->hide();
	this->setHorizontalScrollBarPolicy(Qt::ScrollBarAlwaysOff);
	this->setVerticalScrollBarPolicy(Qt::ScrollBarAlwaysOff);
}
Example #20
0
SinglePlayerView::SinglePlayerView( QPixmap prevBg, QWidget *parent ) :
		QGraphicsView( parent )
{
	scene = new QGraphicsScene;
	scene->setItemIndexMethod( QGraphicsScene::NoIndex );

	data = olddata = NULL;
	model = oldmodel = NULL;
	msganimation = NULL;
	msgtline = NULL;
	loading = NULL;
	board = NULL;
	msg = NULL;

	isloading = false;
	currentScore = 0;
	timeLeft = 0;
	lives = 5;

	setScene( scene );
	setCacheMode( CacheBackground );
	setRenderHint( QPainter::Antialiasing );
	setTransformationAnchor( QGraphicsView::AnchorUnderMouse );
	setResizeAnchor( QGraphicsView::AnchorViewCenter );
	setVerticalScrollBarPolicy( Qt::ScrollBarAlwaysOff );
	setHorizontalScrollBarPolicy( Qt::ScrollBarAlwaysOff );
	setViewportUpdateMode( QGraphicsView::SmartViewportUpdate );
	setOptimizationFlag( QGraphicsView::DontClipPainter );
	setMouseTracking( true );

	prevbg = new QGraphicsPixmapItem( prevBg );
	prevbg->setZValue( 0 );
	scene->addItem( prevbg );
}
CItemBoxView::CItemBoxView( QWidget *parent /*= 0*/ )
:QGraphicsView(parent)
{
	setCacheMode(QGraphicsView::CacheBackground);//ÉèÖûº´æ±³¾°£¬ÕâÑù¿ÉÒÔ¼Ó¿ìäÖȾËÙ¶È/
	//setDragMode(QGraphicsView::ScrollHandDrag);
	setRenderHint(QPainter::Antialiasing);// ʹÓÿ¹¾â³ÝäÖȾ
	setViewportUpdateMode(QGraphicsView::BoundingRectViewportUpdate);
	//setBackgroundBrush(QColor(0, 200, 0));
	setWindowTitle(QObject::tr(DEFVALUE_String_CItemBoxView_Title.c_str()));

	m_pItemBoxScene = NULL;
	m_pItemBoxScene = new CItemBoxScene(NULL);
	m_pItemBoxScene->setSceneRect(0, 0, DEFVALUE_Int_Wide_CItemBoxView - 1, DEFVALUE_Int_Hight_CItemBoxView - 1);

	QRectF rectItem = QRectF(DEF_VALUE_InfomationRectItem_X, DEF_VALUE_InfomationRectItem_Y, DEF_VALUE_InfomationRectItem_Width, DEF_VALUE_InfomationRectItem_Height);
	CRectItemInBox* pRectItemInBox = NULL;
	CTextItemInBox* pTextItemInBox = NULL;

	pTextItemInBox = new CTextItemInBox(NULL, m_pItemBoxScene);
	pTextItemInBox->setPos(20, 20);
	m_pItemBoxScene->addItem(pTextItemInBox);
	pTextItemInBox = NULL;

	pRectItemInBox = new CRectItemInBox(rectItem, NULL, m_pItemBoxScene);
	pRectItemInBox->setItemPos(QPointF(20, 100));
	m_pItemBoxScene->addItem(pRectItemInBox);
	pRectItemInBox = NULL;

	this->setScene(m_pItemBoxScene);
	this->resize(DEFVALUE_Int_Wide_CItemBoxView, DEFVALUE_Int_Hight_CItemBoxView);
}
Example #22
0
/*!
  */
BoardView::BoardView(QWidget *parent)
    : QGraphicsView(parent)
{
    setCacheMode(CacheBackground);

    setMouseTracking(true);
    setRenderHint(QPainter::Antialiasing);
    setViewportUpdateMode(QGraphicsView::BoundingRectViewportUpdate);

    setBackgroundBrush(QColor(230, 200, 167));

    if (isRunningOnDesktop()) {
        // run on PC desktop.
        m_scene = new QGraphicsScene(-225, -225, 450, 450);
    } else {
        // run on a phone/mobile device.
        m_scene = new QGraphicsScene(-90, -90, 180, 180);
    }
    setScene(m_scene);

    m_grid = new GridItem(9);
    m_scene->addItem(m_grid);

    //
    PathFinder::instance()->init(m_grid->dim());

    // initializes the ball items provider
    BallItemsProvider::instance()->init(m_grid);
    //

    BallItemsProvider::instance()->nextBalls(true);
}
Example #23
0
KiviatView::KiviatView( QWidget * p, int _axisCount)
   : QGraphicsView(p),
     axisCount(_axisCount)
{
   //Connect Scene to View
   setScene(&scene);

   //Turn of scrollbars ( the kiviat-diagram is resized, see also resizeEvent)
   setHorizontalScrollBarPolicy(Qt::ScrollBarAlwaysOff);
   setVerticalScrollBarPolicy(Qt::ScrollBarAlwaysOff);

   //Init Properties with default values
   prop_markerCount=5;
   prop_activeAlpha = 220;
   prop_inactiveAlpha= 80;
   prop_cornerPointRadius=10;
   prop_angleOffset=0;

   curDataItem=-1;

   labelFont.setPointSize(labelFont.pointSize()*1.5);

   setRenderHint(QPainter::Antialiasing,true);
   redrawAll();
};
Example #24
0
void GameView::setUpUI()
{
    powerUi = new PowerInterface(am);
    powerUi->setX(0);
    powerUi->setY(0);
    powerUi->setMana(P_INITIAL_MANA);

    ressUi = new RessourcesInterface(am);
    ressUi->setX(0);
    ressUi->setY(280);
    ressUi->bt50Pressed();

    const PowerCountDown &pcd = powerUi->getCountDownManager();
    connect(&pcd,SIGNAL(powerFinishing(ACTIONS,Node*,Node*)),this,SLOT(onPowerFinishing(ACTIONS,Node*,Node*)));
    connect(&pcd,SIGNAL(powerStarting(ACTIONS,Node*,Node*)),this,SLOT(onPowerStarting(ACTIONS,Node*,Node*)));
    connect(&am,SIGNAL(doAction(ACTIONS,Node*)),this,SLOT(onDoAction(ACTIONS,Node*)));
    connect(&am,SIGNAL(doAction(ACTIONS,Node*,Node*)),this,SLOT(onDoAction(ACTIONS,Node*,Node*)));

    // Désactivation des scrollbars
    setVerticalScrollBarPolicy ( Qt::ScrollBarAlwaysOff );
    setHorizontalScrollBarPolicy ( Qt::ScrollBarAlwaysOff );
    setViewportUpdateMode( QGraphicsView::BoundingRectViewportUpdate);
    setRenderHint( QPainter::Antialiasing, true);

    setScene(scene);

    scene->addItem(powerUi);
    scene->addItem(ressBar);
    scene->addItem(ressUi);
}
void ChangeTableLens::SetData(TransMapData* data) {
	this->dataset_ = data;

	if (sorting_item_ == NULL) {
		sorting_item_ = new ChangeSortingItem;
	}
	sorting_item_->SetData(dataset_);

	if (scene_ == NULL) {
		scene_ = new QGraphicsScene(this);
		scene_->setItemIndexMethod(QGraphicsScene::NoIndex);
		setScene(scene_);

		setCacheMode(CacheBackground);
		setViewportUpdateMode(BoundingRectViewportUpdate);
		setRenderHint(QPainter::Antialiasing);
		setTransformationAnchor(AnchorUnderMouse);

		this->setBackgroundBrush(Qt::color0);
		this->autoFillBackground();

		scene_->addItem(sorting_item_);
	}

	this->update();
}
Example #26
0
GraphWidget::GraphWidget(QWidget *parent)
    : timerId(0)
{

	
	
	myMainwindow = dynamic_cast<QoccMainWindow*>(parent);
    QGraphicsScene *scene = new QGraphicsScene(this);
    scene->setItemIndexMethod(QGraphicsScene::NoIndex);
    scene->setSceneRect(0, 0, 8000, 8000);
    setScene(scene);
	//setViewport(new QGLWidget(QGLFormat(QGL::SampleBuffers)));
	//setViewport(new QGLWidget());
	setRenderHint(QPainter::Antialiasing, false);
    //setDragMode(QGraphicsView::RubberBandDrag);
    setOptimizationFlags(QGraphicsView::DontSavePainterState);
    setViewportUpdateMode(QGraphicsView::SmartViewportUpdate);
	setCacheMode(CacheBackground);
	
	
    //setRenderHint(QPainter::Antialiasing);
    setTransformationAnchor(AnchorUnderMouse);
    setResizeAnchor(AnchorViewCenter);

    scale(qreal(0.8), qreal(0.8));
    setMinimumSize(400, 400);
    setWindowTitle(tr("Elastic Nodes"));
}
Example #27
0
SCgView::SCgView(QWidget *parent, SCgWindow *window) :
    QGraphicsView(parent),
    mActionChangeContent(0),
    mActionShowContent(0),
    mActionShowAllContent(0),
    mActionHideAllContent(0),
    mActionDeleteContent(0),
    mActionChangeIdtf(0),
    mActionDelete(0),
    mActionContourDelete(0),
    mActionSwapPairOrient(0),
    mActionCopy(0),
    mActionCut(0),
    mActionPaste(0),
    mActionSelectAll(0),
    mContextMenu(0),
    mContextObject(0),
    mWindow(window),
    isSceneRectControlled(false)
{
    setCacheMode(CacheNone);//CacheBackground);
    setViewportUpdateMode(BoundingRectViewportUpdate);
    setRenderHint(QPainter::Antialiasing);
    setTransformationAnchor(AnchorUnderMouse);
    setResizeAnchor(AnchorViewCenter);
    setOptimizationFlag(DontAdjustForAntialiasing);
    setDragMode(QGraphicsView::RubberBandDrag);
    setAcceptDrops(true);
    connect(mWindow->undoStack(), SIGNAL(indexChanged(int)), this, SLOT(updateActionsState(int)) );
    createActions();
}
Example #28
0
GraphView::GraphView(QWidget *parent)
    :QGraphicsView(parent)
{
    setCacheMode(CacheBackground);
    setRenderHint(QPainter::Antialiasing);
    setTransformationAnchor(AnchorUnderMouse);
}
FormEditorGraphicsView::FormEditorGraphicsView(QWidget *parent) :
    QGraphicsView(parent)
{
    setTransformationAnchor(QGraphicsView::AnchorUnderMouse);
    setResizeAnchor(QGraphicsView::AnchorViewCenter);
    setCacheMode(QGraphicsView::CacheNone);
//    setCacheMode(QGraphicsView::CacheBackground);
    setViewportUpdateMode(QGraphicsView::SmartViewportUpdate);
    setOptimizationFlags(QGraphicsView::DontSavePainterState);
//    setViewportUpdateMode(QGraphicsView::NoViewportUpdate);
    setRenderHint(QPainter::Antialiasing, false);

    setFrameShape(QFrame::NoFrame);

    setAutoFillBackground(true);
    setBackgroundRole(QPalette::Window);

    const int checkerbordSize= 20;
    QPixmap tilePixmap(checkerbordSize * 2, checkerbordSize * 2);
    tilePixmap.fill(Qt::white);
    QPainter tilePainter(&tilePixmap);
    QColor color(220, 220, 220);
    tilePainter.fillRect(0, 0, checkerbordSize, checkerbordSize, color);
    tilePainter.fillRect(checkerbordSize, checkerbordSize, checkerbordSize, checkerbordSize, color);
    tilePainter.end();

    setBackgroundBrush(tilePixmap);

    viewport()->setMouseTracking(true);
}
Example #30
0
WaitWidget::WaitWidget(const QString &message, QWidget *parent):
		QGraphicsView(parent),
		d(new WaitWidgetPrivate)
{
	if ( !message.isEmpty() ) {
		d->m_message = QString("%1\r\n").arg(message);
	}
	createUi();

	// Fondo transparente
	setStyleSheet("background: transparent");
	// Se desactivan las barras
	setHorizontalScrollBarPolicy(Qt::ScrollBarAlwaysOff);
	setVerticalScrollBarPolicy(Qt::ScrollBarAlwaysOff);
	setAttribute(Qt::WA_DeleteOnClose);

	setupScene();
	setScene(&d->m_scene);

	d->m_shadow = new QGraphicsDropShadowEffect(this);
	d->m_shadow->setBlurRadius(5);
	d->m_shadow->setOffset(QPointF(3, 3));
	setGraphicsEffect(d->m_shadow);

	setRenderHint(QPainter::Antialiasing, true);
	setFrameStyle(QFrame::NoFrame);
}