void tst_QFormLayout::itemAt()
{
QFormLayout layout;
QWidget w1;
QWidget w2;
QWidget w3;
QWidget w4;
QWidget w5;
QHBoxLayout l6;
layout.setWidget(5, QFormLayout::LabelRole, &w1);
layout.setWidget(3, QFormLayout::FieldRole, &w2);
layout.setWidget(3, QFormLayout::LabelRole, &w3);
layout.addRow(&w4, &w5);
layout.addRow("Foo:", &l6);
QCOMPARE(layout.count(), 7);
QBitArray scoreBoard(7);
for (int i = 0; i < 7; ++i) {
QLayoutItem *item = layout.itemAt(i);
QVERIFY(item != 0);
if (item->widget() == &w1) {
scoreBoard[0] = true;
} else if (item->widget() == &w2) {
scoreBoard[1] = true;
} else if (item->widget() == &w3) {
scoreBoard[2] = true;
} else if (item->widget() == &w4) {
scoreBoard[3] = true;
} else if (item->widget() == &w5) {
scoreBoard[4] = true;
} else if (item->layout() == &l6) {
scoreBoard[5] = true;
} else if (qobject_cast<QLabel *>(item->widget())) {
scoreBoard[6] = true;
}
}
QCOMPARE(scoreBoard.count(false), 0);
}
bool run()
{
DFG_ASSERT(m_graph, nullptr, m_graph.m_form == ThreadedCPS);
ScoreBoard scoreBoard(m_graph.m_nextMachineLocal);
scoreBoard.assertClear();
for (size_t blockIndex = 0; blockIndex < m_graph.numBlocks(); ++blockIndex) {
BasicBlock* block = m_graph.block(blockIndex);
if (!block)
continue;
if (!block->isReachable)
continue;
if (!ASSERT_DISABLED) {
// Force usage of highest-numbered virtual registers.
scoreBoard.sortFree();
}
for (size_t indexInBlock = 0; indexInBlock < block->size(); ++indexInBlock) {
Node* node = block->at(indexInBlock);
if (!node->shouldGenerate())
continue;
switch (node->op()) {
case Phi:
case Flush:
case PhantomLocal:
continue;
case GetLocal:
ASSERT(!node->child1()->hasResult());
break;
default:
break;
}
// First, call use on all of the current node's children, then
// allocate a VirtualRegister for this node. We do so in this
// order so that if a child is on its last use, and a
// VirtualRegister is freed, then it may be reused for node.
if (node->flags() & NodeHasVarArgs) {
for (unsigned childIdx = node->firstChild(); childIdx < node->firstChild() + node->numChildren(); childIdx++)
scoreBoard.useIfHasResult(m_graph.m_varArgChildren[childIdx]);
} else {
scoreBoard.useIfHasResult(node->child1());
scoreBoard.useIfHasResult(node->child2());
scoreBoard.useIfHasResult(node->child3());
}
if (!node->hasResult())
continue;
VirtualRegister virtualRegister = scoreBoard.allocate();
node->setVirtualRegister(virtualRegister);
// 'mustGenerate' nodes have their useCount artificially elevated,
// call use now to account for this.
if (node->mustGenerate())
scoreBoard.use(node);
}
scoreBoard.assertClear();
}
// Record the number of virtual registers we're using. This is used by calls
// to figure out where to put the parameters.
m_graph.m_nextMachineLocal = scoreBoard.highWatermark();
return true;
}
bool run()
{
ScoreBoard scoreBoard(m_graph.m_nextMachineLocal);
scoreBoard.assertClear();
#if DFG_ENABLE(DEBUG_PROPAGATION_VERBOSE)
bool needsNewLine = false;
#endif
for (size_t blockIndex = 0; blockIndex < m_graph.numBlocks(); ++blockIndex) {
BasicBlock* block = m_graph.block(blockIndex);
if (!block)
continue;
if (!block->isReachable)
continue;
for (size_t indexInBlock = 0; indexInBlock < block->size(); ++indexInBlock) {
Node* node = block->at(indexInBlock);
#if DFG_ENABLE(DEBUG_PROPAGATION_VERBOSE)
if (needsNewLine)
dataLogF("\n");
dataLogF(" @%u:", node->index());
needsNewLine = true;
#endif
if (!node->shouldGenerate())
continue;
switch (node->op()) {
case Phi:
case Flush:
case PhantomLocal:
continue;
case GetLocal:
ASSERT(!node->child1()->hasResult());
break;
default:
break;
}
// First, call use on all of the current node's children, then
// allocate a VirtualRegister for this node. We do so in this
// order so that if a child is on its last use, and a
// VirtualRegister is freed, then it may be reused for node.
if (node->flags() & NodeHasVarArgs) {
for (unsigned childIdx = node->firstChild(); childIdx < node->firstChild() + node->numChildren(); childIdx++)
scoreBoard.useIfHasResult(m_graph.m_varArgChildren[childIdx]);
} else {
scoreBoard.useIfHasResult(node->child1());
scoreBoard.useIfHasResult(node->child2());
scoreBoard.useIfHasResult(node->child3());
}
if (!node->hasResult())
continue;
VirtualRegister virtualRegister = scoreBoard.allocate();
#if DFG_ENABLE(DEBUG_PROPAGATION_VERBOSE)
dataLogF(
" Assigning virtual register %u to node %u.",
virtualRegister, node->index());
#endif
node->setVirtualRegister(virtualRegister);
// 'mustGenerate' nodes have their useCount artificially elevated,
// call use now to account for this.
if (node->mustGenerate())
scoreBoard.use(node);
}
scoreBoard.assertClear();
}
#if DFG_ENABLE(DEBUG_PROPAGATION_VERBOSE)
if (needsNewLine)
dataLogF("\n");
#endif
// Record the number of virtual registers we're using. This is used by calls
// to figure out where to put the parameters.
m_graph.m_nextMachineLocal = scoreBoard.highWatermark();
// 'm_numCalleeRegisters' is the number of locals and temporaries allocated
// for the function (and checked for on entry). Since we perform a new and
// different allocation of temporaries, more registers may now be required.
// This also accounts for the number of temporaries that may be needed if we
// OSR exit, due to inlining. Hence this computes the number of temporaries
// that could be used by this code block even if it exits; it may be more
// than what this code block needs if it never exits.
unsigned calleeRegisters = scoreBoard.highWatermark() + m_graph.m_parameterSlots;
for (InlineCallFrameSet::iterator iter = m_graph.m_inlineCallFrames->begin(); !!iter; ++iter) {
InlineCallFrame* inlineCallFrame = *iter;
CodeBlock* codeBlock = baselineCodeBlockForInlineCallFrame(inlineCallFrame);
unsigned requiredCalleeRegisters = VirtualRegister(inlineCallFrame->stackOffset).toLocal() + 1 + codeBlock->m_numCalleeRegisters;
if (requiredCalleeRegisters > calleeRegisters)
calleeRegisters = requiredCalleeRegisters;
}
if ((unsigned)codeBlock()->m_numCalleeRegisters < calleeRegisters)
codeBlock()->m_numCalleeRegisters = calleeRegisters;
#if DFG_ENABLE(DEBUG_VERBOSE)
dataLogF("Num callee registers: %u\n", calleeRegisters);
#endif
return true;
}
void ChallengeViewer::sceneCompletedHook()
{
// create a map with names and scores
qglColor(Qt::black);
QMultiMap<int, QStringList> scores;
for (World::ObjectsIterator it = world->objects.begin(); it != world->objects.end(); ++it)
{
AsebaFeedableEPuck *epuck = dynamic_cast<AsebaFeedableEPuck*>(*it);
if (epuck)
{
QStringList entry;
entry << epuck->name << QString::number(epuck->port) << QString::number((int)epuck->energy) << QString::number((int)epuck->score);
scores.insert((int)epuck->score, entry);
renderText(epuck->pos.x, epuck->pos.y, 10, epuck->name, labelFont);
}
}
// build score texture
QImage scoreBoard(512, 256, QImage::Format_ARGB32);
scoreBoard.setDotsPerMeterX(2350);
scoreBoard.setDotsPerMeterY(2350);
QPainter painter(&scoreBoard);
//painter.fillRect(scoreBoard.rect(), QColor(224,224,255,196));
painter.fillRect(scoreBoard.rect(), QColor(224,255,224,196));
// draw lines
painter.setBrush(Qt::NoBrush);
QPen pen(Qt::black);
pen.setWidth(2);
painter.setPen(pen);
painter.drawRect(scoreBoard.rect());
pen.setWidth(1);
painter.setPen(pen);
painter.drawLine(22, 34, 504, 34);
painter.drawLine(312, 12, 312, 247);
painter.drawLine(312, 240, 504, 240);
// draw title
painter.setFont(titleFont);
painter.drawText(35, 28, "name");
painter.drawText(200, 28, "port");
painter.drawText(324, 28, "energy");
painter.drawText(430, 28, "points");
// display entries
QMapIterator<int, QStringList> it(scores);
it.toBack();
int pos = 61;
while (it.hasPrevious())
{
it.previous();
painter.drawText(200, pos, it.value().at(1));
pos += 24;
}
it.toBack();
painter.setFont(entryFont);
pos = 61;
while (it.hasPrevious())
{
it.previous();
painter.drawText(35, pos, it.value().at(0));
painter.drawText(335, pos, it.value().at(2));
painter.drawText(445, pos, it.value().at(3));
pos += 24;
}
glDisable(GL_LIGHTING);
glEnable(GL_TEXTURE_2D);
GLuint tex = bindTexture(scoreBoard, GL_TEXTURE_2D);
glEnable(GL_BLEND);
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
glCullFace(GL_FRONT);
glColor4d(1, 1, 1, 0.75);
for (int i = 0; i < 4; i++)
{
glPushMatrix();
glTranslated(world->w/2, world->h/2, 50);
glRotated(90*i, 0, 0, 1);
glBegin(GL_QUADS);
glTexCoord2d(0, 0);
glVertex3d(-20, -20, 0);
glTexCoord2d(1, 0);
glVertex3d(20, -20, 0);
glTexCoord2d(1, 1);
glVertex3d(20, -20, 20);
glTexCoord2d(0, 1);
glVertex3d(-20, -20, 20);
glEnd();
glPopMatrix();
}
glCullFace(GL_BACK);
glColor3d(1, 1, 1);
for (int i = 0; i < 4; i++)
{
glPushMatrix();
glTranslated(world->w/2, world->h/2, 50);
glRotated(90*i, 0, 0, 1);
glBegin(GL_QUADS);
glTexCoord2d(0, 0);
glVertex3d(-20, -20, 0);
glTexCoord2d(1, 0);
glVertex3d(20, -20, 0);
glTexCoord2d(1, 1);
glVertex3d(20, -20, 20);
glTexCoord2d(0, 1);
glVertex3d(-20, -20, 20);
glEnd();
glPopMatrix();
}
deleteTexture(tex);
glDisable(GL_TEXTURE_2D);
glColor4d(7./8.,7./8.,1,0.75);
glPushMatrix();
glTranslated(world->w/2, world->h/2, 50);
glBegin(GL_QUADS);
glVertex3d(-20,-20,20);
glVertex3d(20,-20,20);
glVertex3d(20,20,20);
glVertex3d(-20,20,20);
glVertex3d(-20,20,0);
glVertex3d(20,20,0);
glVertex3d(20,-20,0);
glVertex3d(-20,-20,0);
glEnd();
glPopMatrix();
// save image
static int imageCounter = 0;
if (savingVideo)
grabFrameBuffer().save(QString("frame%0.bmp").arg(imageCounter++), "BMP");
}
