QT_BEGIN_NAMESPACE
QQuickItem *QQuickTextUtil::createCursor(
QQmlComponent *component, QQuickItem *parent, const QRectF &rectangle, const char *className)
{
QQuickItem *item = 0;
if (component->isReady()) {
QQmlContext *creationContext = component->creationContext();
if (QObject *object = component->beginCreate(creationContext
? creationContext
: qmlContext(parent))) {
if ((item = qobject_cast<QQuickItem *>(object))) {
QQml_setParent_noEvent(item, parent);
item->setParentItem(parent);
item->setPosition(rectangle.topLeft());
item->setHeight(rectangle.height());
} else {
qmlInfo(parent) << tr("%1 does not support loading non-visual cursor delegates.")
.arg(QString::fromUtf8(className));
}
component->completeCreate();
return item;
}
} else if (component->isLoading()) {
QObject::connect(component, SIGNAL(statusChanged(QQmlComponent::Status)),
parent, SLOT(createCursor()), Qt::UniqueConnection);
return item;
}
qmlInfo(parent, component->errors()) << tr("Could not load cursor delegate");
return item;
}
void QQuickLoaderPrivate::setInitialState(QObject *obj)
{
Q_Q(QQuickLoader);
QQuickItem *item = qmlobject_cast<QQuickItem*>(obj);
if (item) {
// If the item doesn't have an explicit size, but the Loader
// does, then set the item's size now before bindings are
// evaluated, otherwise we will end up resizing the item
// later and triggering any affected bindings/anchors.
if (widthValid && !QQuickItemPrivate::get(item)->widthValid)
item->setWidth(q->width());
if (heightValid && !QQuickItemPrivate::get(item)->heightValid)
item->setHeight(q->height());
item->setParentItem(q);
}
if (obj) {
QQml_setParent_noEvent(itemContext, obj);
QQml_setParent_noEvent(obj, q);
itemContext = 0;
}
if (initialPropertyValues.isUndefined())
return;
QQmlComponentPrivate *d = QQmlComponentPrivate::get(component);
Q_ASSERT(d && d->engine);
QV4::ExecutionEngine *v4 = qmlGlobalForIpv.engine();
Q_ASSERT(v4);
QV4::Scope scope(v4);
QV4::ScopedValue ipv(scope, initialPropertyValues.value());
d->initializeObjectWithInitialProperties(qmlGlobalForIpv, ipv, obj);
}
QQuickItem * DataSetView::createColumnHeader(int col)
{
//std::cout << "createColumnHeader("<<col<<") called!\n" << std::flush;
if(_columnHeaderDelegate == NULL)
{
_columnHeaderDelegate = new QQmlComponent(qmlEngine(this));
_columnHeaderDelegate->setData("import QtQuick 2.10\nItem {\n"
"property alias text: tekst.text\n"
"Rectangle { color: \"lightGrey\"; anchors.fill: parent }\n"
"Text { id: tekst; anchors.centerIn: parent }\n"
"}", QUrl());
}
QQuickItem * columnHeader = NULL;
if(_columnHeaderItems.count(col) == 0 || _columnHeaderItems[col] == NULL)
{
if(_columnHeaderStorage.size() > 0)
{
#ifdef DEBUG_VIEWPORT
std::cout << "createColumnHeader("<<col<<") from storage!\n" << std::flush;
#endif
columnHeader = _columnHeaderStorage.top();
_columnHeaderStorage.pop();
}
else
{
#ifdef DEBUG_VIEWPORT
std::cout << "createColumnHeader("<<col<<") ex nihilo!\n" << std::flush;
#endif
columnHeader = qobject_cast<QQuickItem*>(_columnHeaderDelegate->create());
columnHeader->setParent(this);
columnHeader->setParentItem(this);
}
columnHeader->setProperty("z", 10);
columnHeader->setProperty("text", _model->headerData(col, Qt::Orientation::Horizontal).toString());
columnHeader->setZ(-3);
columnHeader->setHeight(_dataRowsMaxHeight);
columnHeader->setWidth(_dataColsMaxWidth[col]);
columnHeader->setVisible(true);
_columnHeaderItems[col] = columnHeader;
}
else
columnHeader = _columnHeaderItems[col];
columnHeader->setX(_colXPositions[col]);
columnHeader->setY(_viewportY);
return columnHeader;
}
QQuickItem * DataSetView::createRowNumber(int row)
{
//std::cout << "createRowNumber("<<row<<") called!\n" << std::flush;
if(_rowNumberDelegate == NULL)
{
_rowNumberDelegate = new QQmlComponent(qmlEngine(this));
_rowNumberDelegate->setData("import QtQuick 2.10\nItem {\n"
"property alias text: tekst.text\n"
"Rectangle { color: \"lightGrey\"; anchors.fill: parent }\n"
"Text { id: tekst; anchors.centerIn: parent }\n"
"}", QUrl());
}
QQuickItem * rowNumber = NULL;
if(_rowNumberItems.count(row) == 0 || _rowNumberItems[row] == NULL)
{
if(_rowNumberStorage.size() > 0)
{
#ifdef DEBUG_VIEWPORT
std::cout << "createRowNumber("<<row<<") from storage!\n" << std::flush;
#endif
rowNumber = _rowNumberStorage.top();
_rowNumberStorage.pop();
}
else
{
#ifdef DEBUG_VIEWPORT
std::cout << "createRowNumber("<<row<<") ex nihilo!\n" << std::flush;
#endif
rowNumber = qobject_cast<QQuickItem*>(_rowNumberDelegate->create());
rowNumber->setParent(this);
rowNumber->setParentItem(this);
}
rowNumber->setProperty("z", 10);
rowNumber->setProperty("text", QString::fromStdString(std::to_string(row + 1))); //Nobody wants zero-based rows...
rowNumber->setY(_dataRowsMaxHeight * (1 + row));
rowNumber->setZ(-3);
rowNumber->setHeight(_dataRowsMaxHeight);
rowNumber->setWidth(_rowNumberMaxWidth);
rowNumber->setVisible(true);
_rowNumberItems[row] = rowNumber;
}
else
rowNumber = _rowNumberItems[row];
rowNumber->setX(_viewportX);
return _rowNumberItems[row];
}
void QQuickStretchColumnContainer::updatePolish (void) {
const QList<QQuickItem *> childrenList = childItems ();
/// find items and stretchers
qreal tmpW = 0;
qreal tmpH = 0;
int nbItems = 0;
int nbStretch = 0;
for (QList<QQuickItem *>::const_iterator it = childrenList.constBegin (); it != childrenList.constEnd (); it++) {
QQuickItem * child = (* it);
if (child != Q_NULLPTR && !child->inherits ("QQuickRepeater") && child->isVisible ()) {
if (child->implicitWidth () > tmpW) {
tmpW = child->implicitWidth ();
}
if (child->implicitHeight () >= 0) {
tmpH += child->implicitHeight ();
}
else {
nbStretch++;
}
nbItems++;
}
}
/// resize layout
if (nbItems > 1) {
tmpH += (m_spacing * (nbItems -1));
}
setImplicitWidth (tmpW);
setImplicitHeight (tmpH);
const qreal layoutWidth = width ();
const qreal layoutHeight = height ();
const qreal autoSize = (nbStretch > 0 ? (layoutHeight - tmpH) / qreal (nbStretch) : 0);
/// position children
int currY = 0;
for (QList<QQuickItem *>::const_iterator it = childrenList.constBegin (); it != childrenList.constEnd (); it++) {
QQuickItem * child = (* it);
if (child != Q_NULLPTR && !child->inherits ("QQuickRepeater") && child->isVisible ()) {
if (currY) {
currY += m_spacing;
}
child->setY (currY);
child->setWidth (layoutWidth);
child->setHeight (child->implicitHeight () >= 0 ? child->implicitHeight () : autoSize);
currY += child->height ();
}
}
}
void TestSimpleQmlLoad::compileAndLoadBinding1()
{
QQmlEngine *engine = new QQmlEngine;
const QString TEST_FILE(":/testqml/testbinding1.qml");
QQmlComponent* component = compileAndLoad(engine, TEST_FILE);
QVERIFY(component);
QObject* myObject = component->create();
QVERIFY(myObject);
QQuickItem *item = qobject_cast<QQuickItem*>(myObject);
int height = item->height();
QVERIFY(height == 62);
QList<QQuickItem *> childs = item->childItems();
QVERIFY(childs.count() == 1);
QQuickItem *child = childs[0];
QVERIFY(child->height() == 62);
item->setHeight(2);
QVERIFY(child->height() == 2);
delete component;
delete engine;
}
void StretchRow::layoutChildrenWithDefaultSize() {
//static int count = 0;
//qDebug() << "Row Default Size" << ++count;
Q_ASSERT(m_defaultSize != 0);
const QList<QQuickItem *> childrenList = childItems();
if (childrenList.isEmpty()) return;
const int layoutHeight = height();
qreal currX = m_leftMargin;
for (QList<QQuickItem *>::const_iterator it = childrenList.constBegin(); it != childrenList.constEnd(); ++it) {
QQuickItem* child = (*it);
if (child == Q_NULLPTR || !child->isVisible()) {
continue;
}
// add spacing if it is not the first item:
if (currX > 0) {
currX += m_spacing;
}
if (currX != child->x()) child->setX(currX);
// check if item has a stretch proportion set:
if (child->implicitWidth() < 0) {
// yes -> set it to default size:
qreal newWidth = m_defaultSize * child->implicitWidth() * -1;
if (newWidth != child->width()) child->setWidth(newWidth);
}
// set height of all items to fill the layout:
if (layoutHeight != child->height()) child->setHeight(layoutHeight);
currX += child->width();
}
currX += m_rightMargin;
// set implicit size to fit all items:
if (currX != implicitWidth()) setImplicitWidth(currX);
}
void StretchColumn::layoutChildrenWithDefaultSize() {
//static int count = 0;
//qDebug() << "Column Default Size" << ++count;
Q_ASSERT(m_defaultSize != 0);
const QList<QQuickItem *> childrenList = childItems();
if (childrenList.isEmpty()) return;
const int contentWidth = width() - m_leftMargin - m_rightMargin;
qreal currY = 0;
for (QList<QQuickItem *>::const_iterator it = childrenList.constBegin(); it != childrenList.constEnd(); ++it) {
QQuickItem* child = (*it);
if (child == Q_NULLPTR || !child->isVisible()) {
continue;
}
// add spacing if it is not the first item:
if (currY > 0) {
currY += m_spacing;
}
if (currY != child->y()) child->setY(currY);
// check if item has a stretch proportion set:
if (child->implicitHeight() < 0) {
// yes -> set it to default size multiplied by relative size:
qreal newHeight = m_defaultSize * child->implicitHeight() * -1;
if (newHeight != child->height()) child->setHeight(newHeight);
}
// set width of all items to fill the layout:
if (m_leftMargin != child->x()) child->setX(m_leftMargin);
if (contentWidth != child->width()) child->setWidth(contentWidth);
currY += child->height();
}
// set implicit size to fit all items:
if (currY != implicitHeight()) setImplicitHeight(currY);
}
void tst_qquickwidget::resizemodeitem()
{
QWidget window;
window.setGeometry(0, 0, 400, 400);
QScopedPointer<QQuickWidget> view(new QQuickWidget);
view->setParent(&window);
view->setResizeMode(QQuickWidget::SizeRootObjectToView);
QCOMPARE(QSize(0,0), view->initialSize());
view->setSource(testFileUrl("resizemodeitem.qml"));
QQuickItem* item = qobject_cast<QQuickItem*>(view->rootObject());
QVERIFY(item);
window.show();
view->showNormal();
// initial size from root object
QCOMPARE(item->width(), 200.0);
QCOMPARE(item->height(), 200.0);
QCOMPARE(view->size(), QSize(200, 200));
QCOMPARE(view->size(), view->sizeHint());
QCOMPARE(view->size(), view->initialSize());
// size update from view
view->resize(QSize(80,100));
QTRY_COMPARE(item->width(), 80.0);
QCOMPARE(item->height(), 100.0);
QCOMPARE(view->size(), QSize(80, 100));
QCOMPARE(view->size(), view->sizeHint());
view->setResizeMode(QQuickWidget::SizeViewToRootObject);
// size update from view disabled
view->resize(QSize(60,80));
QCOMPARE(item->width(), 80.0);
QCOMPARE(item->height(), 100.0);
QTRY_COMPARE(view->size(), QSize(60, 80));
// size update from root object
item->setWidth(250);
item->setHeight(350);
QCOMPARE(item->width(), 250.0);
QCOMPARE(item->height(), 350.0);
QTRY_COMPARE(view->size(), QSize(250, 350));
QCOMPARE(view->size(), QSize(250, 350));
QCOMPARE(view->size(), view->sizeHint());
// reset window
window.hide();
view.reset(new QQuickWidget(&window));
view->setResizeMode(QQuickWidget::SizeViewToRootObject);
view->setSource(testFileUrl("resizemodeitem.qml"));
item = qobject_cast<QQuickItem*>(view->rootObject());
QVERIFY(item);
window.show();
view->showNormal();
// initial size for root object
QCOMPARE(item->width(), 200.0);
QCOMPARE(item->height(), 200.0);
QCOMPARE(view->size(), view->sizeHint());
QCOMPARE(view->size(), view->initialSize());
// size update from root object
item->setWidth(80);
item->setHeight(100);
QCOMPARE(item->width(), 80.0);
QCOMPARE(item->height(), 100.0);
QTRY_COMPARE(view->size(), QSize(80, 100));
QCOMPARE(view->size(), view->sizeHint());
// size update from root object disabled
view->setResizeMode(QQuickWidget::SizeRootObjectToView);
item->setWidth(60);
item->setHeight(80);
QCOMPARE(view->width(), 80);
QCOMPARE(view->height(), 100);
QCOMPARE(QSize(item->width(), item->height()), view->sizeHint());
// size update from view
view->resize(QSize(200,300));
QTRY_COMPARE(item->width(), 200.0);
QCOMPARE(item->height(), 300.0);
QCOMPARE(view->size(), QSize(200, 300));
QCOMPARE(view->size(), view->sizeHint());
window.hide();
// if we set a specific size for the view then it should keep that size
// for SizeRootObjectToView mode.
view.reset(new QQuickWidget(&window));
view->resize(300, 300);
view->setResizeMode(QQuickWidget::SizeRootObjectToView);
QCOMPARE(QSize(0,0), view->initialSize());
view->setSource(testFileUrl("resizemodeitem.qml"));
view->resize(300, 300);
item = qobject_cast<QQuickItem*>(view->rootObject());
QVERIFY(item);
window.show();
view->showNormal();
// initial size from root object
QCOMPARE(item->width(), 300.0);
QCOMPARE(item->height(), 300.0);
QTRY_COMPARE(view->size(), QSize(300, 300));
QCOMPARE(view->size(), view->sizeHint());
QCOMPARE(view->initialSize(), QSize(200, 200)); // initial object size
}
void StretchRow::layoutChildrenWithProportions() {
//static int count = 0;
//qDebug() << "Row Proportions" << ++count;
const QList<QQuickItem*> childrenList = childItems();
if (childrenList.isEmpty()) return;
if (width() <= 0) return;
int visibleItems = 0;
qreal availableForStretch = width() - m_leftMargin - m_rightMargin;
qreal sumStretchProportions = 0.0;
// iterate over all children and calculate available size to stretch items:
for (QList<QQuickItem *>::const_iterator it = childrenList.constBegin(); it != childrenList.constEnd(); ++it) {
QQuickItem* child = (*it);
if (child == Q_NULLPTR || !child->isVisible()) {
continue;
}
if (child->implicitWidth() >= 0) {
// no stretch proportion set -> leave size and remove it from available space:
availableForStretch -= child->width();
} else {
// a stretch proportion is set -> add it to sum:
sumStretchProportions += (child->implicitWidth() * -1);
}
visibleItems++;
}
// remove spacing from available space:
availableForStretch -= m_spacing * (visibleItems - 1);
const int layoutHeight = height();
QPointer<QQuickItem> lastStretchItem = nullptr;
qreal currX = m_leftMargin;
for (QList<QQuickItem *>::const_iterator it = childrenList.constBegin(); it != childrenList.constEnd(); ++it) {
QQuickItem* child = (*it);
if (child == Q_NULLPTR || !child->isVisible()) {
continue;
}
// add spacing if it is not the first item:
if (currX > 0) {
currX += m_spacing;
}
if (currX != child->x()) child->setX(currX);
// check if item has a stretch proportion set (if not do nothing):
if (child->implicitWidth() < 0) {
// get the stretch proportion:
qreal stretchProportion = (child->implicitWidth() * -1);
// calculate the relation of the total space available for stretched items
// that this item will use:
// (sumStretchProportion can not be 0 (in divison) because if this "if" is executed,
// there has been at least one item with a stretch proportion set)
qreal relationOfSpaceAvailableForStretch = stretchProportion / sumStretchProportions;
qreal newWidth = qRound(availableForStretch * relationOfSpaceAvailableForStretch);
if (newWidth != child->width()) child->setWidth(newWidth);
lastStretchItem = child;
}
// set height of all items to fill the layout:
if (layoutHeight != child->height()) child->setHeight(layoutHeight);
currX += child->width();
}
currX += m_rightMargin;
// check if last item fills whole remaining space in this layout:
// (can happen because of rounding mistakes)
if (lastStretchItem) {
double pxMissing = width() - currX;
if (pxMissing > 0.0001) {
// qInfo() << "StretchRow layout mismatch: " << pxMissing;
// it does not -> adjust it:
lastStretchItem->setWidth(lastStretchItem->width() + pxMissing);
}
}
}
void QQuickComponentsLinearLayout::reconfigureLayout()
{
if (!isComponentComplete())
return;
const int count = m_items.count();
if (count == 0)
return;
qreal totalSpacing = 0;
qreal totalSizeHint = 0;
qreal totalMinimumSize = 0;
qreal totalMaximumSize = 0;
QVector<QQuickComponentsLayoutInfo> itemData;
for (int i = 0; i < count; i++) {
QQuickItem *item = m_items.at(i);
QObject *attached = qmlAttachedPropertiesObject<QQuickComponentsLayout>(item);
QQuickComponentsLayoutAttached *info = static_cast<QQuickComponentsLayoutAttached *>(attached);
QQuickComponentsLayoutInfo data;
if (m_orientation == Horizontal) {
data.sizeHint = item->implicitWidth();
data.minimumSize = info->minimumWidth();
data.maximumSize = info->maximumWidth();
data.expansive = (info->horizontalSizePolicy() == QQuickComponentsLayout::Expanding);
data.stretch = info->horizontalSizePolicy() == Expanding ? 1.0 : 0;
} else {
data.sizeHint = item->implicitHeight();
data.minimumSize = info->minimumHeight();
data.maximumSize = info->maximumHeight();
data.expansive = (info->verticalSizePolicy() == QQuickComponentsLayout::Expanding);
data.stretch = info->verticalSizePolicy() == Expanding ? 1.0 : 0;
}
itemData.append(data);
// sum
totalSizeHint += data.sizeHint;
totalMinimumSize += data.minimumSize;
totalMaximumSize += data.maximumSize;
// don't count last spacing
if (i < count - 1)
totalSpacing += data.spacing + m_spacing;
}
if (m_orientation == Horizontal) {
qDeclarativeLayoutCalculate(itemData, 0, count, 0, width(), m_spacing);
for (int i = 0; i < count; i++) {
QQuickItem *item = m_items.at(i);
const QQuickComponentsLayoutInfo &data = itemData.at(i);
item->setX(data.pos);
item->setY(height()/2 - item->height()/2);
item->setWidth(data.size);
}
} else {
qDeclarativeLayoutCalculate(itemData, 0, count, 0, height(), m_spacing);
for (int i = 0; i < count; i++) {
QQuickItem *item = m_items.at(i);
const QQuickComponentsLayoutInfo &data = itemData.at(i);
item->setY(data.pos);
item->setX(width()/2 - item->width()/2);
item->setHeight(data.size);
}
}
// propagate hints to upper levels
QObject *attached = qmlAttachedPropertiesObject<QQuickComponentsLayout>(this);
QQuickComponentsLayoutAttached *info = static_cast<QQuickComponentsLayoutAttached *>(attached);
if (m_orientation == Horizontal) {
setImplicitWidth(totalSizeHint);
info->setMinimumWidth(totalMinimumSize + totalSpacing);
info->setMaximumWidth(totalMaximumSize + totalSpacing);
} else {
setImplicitHeight(totalSizeHint);
info->setMinimumHeight(totalMinimumSize + totalSpacing);
info->setMaximumHeight(totalMaximumSize + totalSpacing);
}
}