void KisCoordinatesConverterTest::testMirroringCanvasBiggerThanImage()
{
    KisImageSP image;
    KisCoordinatesConverter converter;
    initImage(&image, &converter);

    QSize widgetSize(2000,2000);
    QSize flakeSize(1000,1000);
    QRectF testRect(300, 100, 200, 200);

    converter.setImage(image);
    converter.setDocumentOffset(QPoint(-50,-50));
    converter.setCanvasWidgetSize(widgetSize);

    QTransform imageToWidget;
    QTransform documentToWidget;
    QTransform flakeToWidget;
    QTransform viewportToWidget;

    converter.mirror(converter.imageCenterInWidgetPixel(), true, false);
    converter.setZoom(1.);

    // image pixels == flake pixels

    QRectF viewportRect = converter.imageToViewport(testRect);
    QRectF widgetRect = converter.viewportToWidget(viewportRect);

    QCOMPARE(widgetRect, QRectF(550,150,200,200));
    QCOMPARE(viewportRect, QRectF(300,100,200,200));
}
void KisCoordinatesConverterTest::testRotation()
{
    KisImageSP image;
    KisCoordinatesConverter converter;
    initImage(&image, &converter);

    QSize widgetSize(1000,500);
    QRectF testRect(800, 100, 300, 300);

    converter.setImage(image);
    converter.setDocumentOffset(QPoint(0,0));
    converter.setCanvasWidgetSize(widgetSize);

    converter.rotate(converter.widgetCenterPoint(), 30);
    converter.setZoom(1.);

    QTransform viewportToWidget = converter.viewportToWidgetTransform();

    QRectF boundingRect = viewportToWidget.mapRect(testRect);
    QRectF directRect = converter.viewportToWidget(testRect);

    QCOMPARE(boundingRect, directRect);

    QRectF referenceRect(QPointF(742.82,53.5898), QSizeF(409.808,409.808));

#define FUZZY(a,b) ((a)-(b) < 0.01)

    QVERIFY(FUZZY(boundingRect.top(), referenceRect.top()));
    QVERIFY(FUZZY(boundingRect.left(), referenceRect.left()));
    QVERIFY(FUZZY(boundingRect.width(), referenceRect.width()));
    QVERIFY(FUZZY(boundingRect.height(), referenceRect.height()));
}
    QSize PreviewContentWidget::sizeHint() const
    {
        if (PreviewGenuineSize_.isEmpty())
        {
            return getMinPreviewSize().toSize();
        }

        const auto &previewScaledSize = getPreviewScaledSizeF();

        const auto bubbleSize = getTextBubbleSize();

        const auto width = previewScaledSize.width();
        const auto height = (
            bubbleSize.height() +
            getTextBottomMargin() +
            previewScaledSize.height()
        );

        QSize widgetSize(
            std::max(width, getMinPreviewSize().width()),
            std::max(height, getMinPreviewSize().height())
        );

        return widgetSize;
    }
Esempio n. 4
0
void MainWindow::populateStore()
{

    int row = 0;
    int i = 0;
    for(auto item : store) {
        QString name(item.first.c_str());
        QString price(QString::number(item.second));
        QPushButton *button = new QPushButton(name);
        QLabel *label = new QLabel("$"+price);
        button->setObjectName(name);
        label->setObjectName(price);
        shopSignalMapper->setMapping(button, name);
        connect(button, SIGNAL(clicked()), shopSignalMapper, SLOT(map()));
        label->setAlignment(Qt::AlignCenter);
        ui->shopLayout->addWidget(button, row, i, Qt::AlignCenter);
        ui->shopLayout->addWidget(label, row+1, i, Qt::AlignCenter);
        QSize widgetSize(50, 50);
        button->setFixedSize(widgetSize);
        label->setFixedSize(widgetSize);
        i++;
        if(i == 9) {
            i = 0;
            row += 2;
        }
    }
}
Esempio n. 5
0
void ToyGrid::SetGridSize(const QSize &gridSize)
{
	QSize gs(gridSize);
	if(gs.width() < 1)
		gs.setWidth(1);
	if(gs.height() < 1)
		gs.setHeight(1);
	
	if(m_GridSize != gs)
	{
		QSize widgetSize(0, 0);
		if( !m_List.empty() )
			widgetSize = m_List.front()->size();
		
		m_GridSize = gs;
		
		size_t numWidgets = static_cast<size_t>(m_GridSize.width() * m_GridSize.height());
		
		// remove excess
		while(m_List.size() > numWidgets)
		{
			m_List.back()->deleteLater();
			m_List.pop_back();
		}
		
		// add new
		while(m_List.size() < numWidgets)
		{
			ToyWidget *widget = CreateWidget();
			if( widget )
			{
				m_List.push_back(widget);
				ApplyDefaultSettings(widget, m_List.size());
				widget->SetMode(m_Mode);
				
				if( !m_Loading )
					widget->show();
				
				connect(widget, SIGNAL(edit(ToyWidget*)), this, SLOT(onWidgetEdited(ToyWidget*)));
			}
			else
				break;
		}
	EditorWidgetBase* EditorWidgetManager::open(const String& name)
	{
		auto iterFind = mActiveWidgets.find(name);

		if(iterFind != mActiveWidgets.end())
			return iterFind->second;

		EditorWindow* window = EditorWindow::create();
		EditorWidgetBase* newWidget = create(name, window->widgets());
		if(newWidget == nullptr)
		{
			window->close();
			return nullptr;
		}

		Vector2I widgetSize(newWidget->getDefaultWidth(), newWidget->getDefaultHeight());
		Vector2I windowSize = EditorWidgetContainer::widgetToWindowSize(widgetSize);
		window->setSize((UINT32)windowSize.x, (UINT32)windowSize.y);

		return newWidget;
	}
void NumberEntryWidget::parented()
{
    mEntryWidget.setParent(this, Rectangle(widgetSize()));
}