/*!
Creates an OpenCL program object from the list of \a binaries
for \a devices. The \a binaries and \a devices lists must have
the same number of elements.
\sa createProgramFromBinaryCode(), createProgramFromBinaryFile()
*/
QCLProgram QCLContext::createProgramFromBinaries
(const QList<QCLDevice> &devices, const QList<QByteArray> &binaries)
{
Q_D(QCLContext);
if (devices.size() != binaries.size() || devices.isEmpty()) {
reportError("QCLContext::createProgramFromBinaries:", CL_INVALID_VALUE);
return QCLProgram();
}
QVarLengthArray<cl_device_id> devs;
QVarLengthArray<const uchar *> bins;
QVarLengthArray<size_t> lens;
for (int index = 0; index < devices.size(); ++index) {
devs.append(devices.at(index).deviceId());
bins.append(reinterpret_cast<const uchar *>
(binaries.at(index).constData()));
lens.append(binaries.at(index).size());
}
cl_int error = CL_INVALID_CONTEXT;
cl_program prog = clCreateProgramWithBinary
(d->id, devs.size(), devs.data(), lens.data(), bins.data(), 0, &error);
reportError("QCLContext::createProgramFromBinaries:", error);
if (prog)
return QCLProgram(this, prog);
else
return QCLProgram();
}
// Read a UTF-16 string value.
static QString read_string( QIODevice *dev, int length )
{
QVarLengthArray<ushort> buf;
buf.reserve( length );
dev->read( (char *)(buf.data()), length * 2 );
return QString::fromUtf16( buf.data(), length );
}
void QNodeViewCanvas::drawBackground(QPainter* painter, const QRectF& rect)
{
// GW-TODO: Expose this to QStyle
painter->fillRect(rect, QBrush(QColor(50, 50, 50)));
const qint32 gridInterval = 50;
painter->setWorldMatrixEnabled(true);
// GW-TODO: Expose this to QStyle
QPen linePen(QColor(80, 80, 80), 1, Qt::DotLine, Qt::FlatCap, Qt::RoundJoin);
linePen.setCosmetic(true); // Performance optimization
painter->setPen(linePen);
const qreal left = qint32(rect.left()) - (qint32(rect.left()) % gridInterval);
const qreal top = qint32(rect.top()) - (qint32(rect.top()) % gridInterval);
QVarLengthArray<QLineF, 100> linesX;
for (qreal x = left; x < rect.right(); x += gridInterval)
linesX.append(QLineF(x, rect.top(), x, rect.bottom()));
QVarLengthArray<QLineF, 100> linesY;
for (qreal y = top; y < rect.bottom(); y += gridInterval)
linesY.append(QLineF(rect.left(), y, rect.right(), y));
painter->drawLines(linesX.data(), linesX.size());
painter->drawLines(linesY.data(), linesY.size());
}
QByteArray QBBSystemLocaleData::readPpsValue(const char *ppsObject, int ppsFd)
{
QByteArray result;
if (!ppsObject || ppsFd == -1)
return result;
// PPS objects are of unknown size, but must be read all at once.
// Relying on the file size may not be a good idea since the size may change before reading.
// Let's try with an initial size (512), and if the buffer is too small try with bigger one,
// until we succeed or until other non buffer-size-related error occurs.
// Using QVarLengthArray means the first try (of size == 512) uses a buffer on the stack - no allocation necessary.
// Hopefully that covers most use cases.
int bytes;
QVarLengthArray<char, 512> buffer;
for (;;) {
errno = 0;
bytes = qt_safe_read(ppsFd, buffer.data(), buffer.capacity() - 1);
const bool bufferIsTooSmall = (bytes == -1 && errno == EMSGSIZE && buffer.capacity() < MAX_PPS_SIZE);
if (!bufferIsTooSmall)
break;
buffer.resize(qMin(buffer.capacity()*2, MAX_PPS_SIZE));
}
// This method is called in the ctor(), so do not use qWarning to log warnings
// if qt_safe_read fails to read the pps file
// since the user code may install a message handler that invokes QLocale API again
// (i.e QDate, QDateTime, ...) which will cause a infinite loop.
if (bytes == -1) {
fprintf(stderr, "Failed to read pps object:%s, errno=%d\n", ppsObject, errno);
return result;
}
// ensure data is null terminated
buffer[bytes] = '\0';
pps_decoder_t ppsDecoder;
pps_decoder_initialize(&ppsDecoder, 0);
if (pps_decoder_parse_pps_str(&ppsDecoder, buffer.data()) == PPS_DECODER_OK) {
pps_decoder_push(&ppsDecoder, 0);
const char *ppsBuff;
if (pps_decoder_get_string(&ppsDecoder, ppsObject, &ppsBuff) == PPS_DECODER_OK) {
result = ppsBuff;
} else {
int val;
if (pps_decoder_get_int(&ppsDecoder, ppsObject, &val) == PPS_DECODER_OK)
result = QByteArray::number(val);
}
}
pps_decoder_cleanup(&ppsDecoder);
return result;
}
static inline QString qSystemDirectory()
{
QVarLengthArray<wchar_t, MAX_PATH> fullPath;
UINT retLen = ::GetSystemDirectory(fullPath.data(), MAX_PATH);
if (retLen > MAX_PATH) {
fullPath.resize(retLen);
retLen = ::GetSystemDirectory(fullPath.data(), retLen);
}
// in some rare cases retLen might be 0
return QString::fromWCharArray(fullPath.constData(), int(retLen));
}
static void stringToWCharArray(QVarLengthArray<wchar_t> &ret, const QString &string)
{
ret.resize(string.length());
int len = string.toWCharArray(ret.data());
ret.resize(len+1);
ret[len] = 0;
}
void drawBackground(QPainter *painter, const QRectF &rect)
{
QGraphicsScene::drawBackground(painter, rect);
const int gridSizeX = 1.0f;
const int gridSizeY = 60.0f*KLineSize;
qreal left = int(rect.left()) - (int(rect.left()) % gridSizeX);
qreal top = int(rect.top()) - (int(rect.top()) % gridSizeY);
QVarLengthArray<QLineF, 100> lines;
for (qreal x = left; x < rect.right(); x += gridSizeX)
lines.append(QLineF(x, rect.top(), x, rect.bottom()));
for (qreal y = top; y < rect.bottom(); y += gridSizeY)
lines.append(QLineF(rect.left(), y, rect.right(), y));
painter->setPen(QPen(QBrush(Qt::darkGray),0,Qt::DashDotDotLine));
painter->drawLines(lines.data(), lines.size());
painter->setPen(QPen(QBrush(Qt::lightGray),0,Qt::DashLine));
painter->drawLine(QLineF(16.66, rect.top(), 16.66, rect.bottom()));
painter->drawLine(QLineF(33.33, rect.top(), 33.33, rect.bottom()));
}
int main(int argc, char** argv)
{
QVarLengthArray<char*, 8> arguments;
for (int i = 0; i < argc; ++i)
arguments.append(argv[i]);
arguments.append(const_cast<char*>("-import"));
arguments.append(const_cast<char*>(IMPORT_DIR));
argc = arguments.count();
argv = arguments.data();
suppressDebugOutput();
addQtWebProcessToPath();
// Instantiate QApplication to prevent quick_test_main to instantiate a QGuiApplication.
// This can be removed as soon as we do not use QtWidgets any more.
QGuiApplication app(argc, argv);
qmlRegisterType<ByteArrayTestData>("Test", 1, 0, "ByteArrayTestData");
#ifdef DISABLE_FLICKABLE_VIEWPORT
QQuickWebViewExperimental::setFlickableViewportEnabled(false);
#endif
return quick_test_main(argc, argv, "qmltests", 0, QUICK_TEST_SOURCE_DIR);
}
void
dmz::QtCanvasScene::drawBackground (QPainter *painter, const QRectF &rect) {
painter->drawRect (sceneRect ());
if (_drawGrid) {
painter->fillRect (sceneRect (), QBrush (QColor (230, 240, 255)));
painter->setPen (QPen (Qt::lightGray, 1));
painter->setOpacity(0.75f);
const int gridSize = 100;
qreal left = int(rect.left ()) - (int(rect.left ()) % gridSize);
qreal top = int(rect.top ()) - (int(rect.top ()) % gridSize);
QVarLengthArray<QLineF, 100> lines;
for (qreal x = left; x < rect.right (); x += gridSize) {
lines.append (QLineF (x, rect.top (), x, rect.bottom ()));
}
for (qreal y = top; y < rect.bottom (); y += gridSize) {
lines.append (QLineF (rect.left (), y, rect.right (), y));
}
// qDebug () << lines.size ();
painter->drawLines (lines.data (), lines.size ());
QGraphicsScene::drawBackground (painter, rect);
}
}
void MocParser::loadIntData(uint *&data)
{
data = 0; // initialise
QVarLengthArray<uint> array;
QRegExp rx(QLatin1String("(\\d+|0x[0-9abcdef]+)"), Qt::CaseInsensitive);
while (!input->atEnd()) {
QString line = QLatin1String(readLine());
int pos = line.indexOf(QLatin1String("//"));
if (pos != -1)
line.truncate(pos); // drop comments
if (line == QLatin1String("};\n")) {
// end of data
data = new uint[array.count()];
memcpy(data, array.data(), array.count() * sizeof(*data));
return;
}
pos = 0;
while ((pos = rx.indexIn(line, pos)) != -1) {
QString num = rx.cap(1);
if (num.startsWith(QLatin1String("0x")))
array.append(num.mid(2).toUInt(0, 16));
else
array.append(num.toUInt());
pos += rx.matchedLength();
}
}
parseError();
}
static void init(QTextBoundaryFinder::BoundaryType type, const QChar *chars, int length, HB_CharAttributes *attributes)
{
QVarLengthArray<HB_ScriptItem> scriptItems;
const ushort *string = reinterpret_cast<const ushort *>(chars);
const ushort *unicode = string;
// correctly assign script, isTab and isObject to the script analysis
const ushort *uc = unicode;
const ushort *e = uc + length;
int script = QUnicodeTables::Common;
int lastScript = QUnicodeTables::Common;
const ushort *start = uc;
while (uc < e) {
int s = QUnicodeTables::script(*uc);
if (s != QUnicodeTables::Inherited)
script = s;
if (*uc == QChar::ObjectReplacementCharacter || *uc == QChar::LineSeparator || *uc == 9)
script = QUnicodeTables::Common;
if (script != lastScript) {
if (uc != start) {
HB_ScriptItem item;
item.pos = start - string;
item.length = uc - start;
item.script = (HB_Script)lastScript;
item.bidiLevel = 0; // ### what's the proper value?
scriptItems.append(item);
start = uc;
}
lastScript = script;
}
++uc;
}
if (uc != start) {
HB_ScriptItem item;
item.pos = start - string;
item.length = uc - start;
item.script = (HB_Script)lastScript;
item.bidiLevel = 0; // ### what's the proper value?
scriptItems.append(item);
}
qGetCharAttributes(string, length, scriptItems.data(), scriptItems.count(), attributes);
if (type == QTextBoundaryFinder::Word)
HB_GetWordBoundaries(string, length, scriptItems.data(), scriptItems.count(), attributes);
else if (type == QTextBoundaryFinder::Sentence)
HB_GetSentenceBoundaries(string, length, scriptItems.data(), scriptItems.count(), attributes);
}
void GraphWidget::drawBackground(QPainter *painter, const QRectF &rect)
{
Q_UNUSED(rect);
//return;
// Shadow
QRectF sceneRect = this->sceneRect();
QRectF rightShadow(sceneRect.right(), sceneRect.top() + 5, 5, sceneRect.height());
QRectF bottomShadow(sceneRect.left() + 5, sceneRect.bottom(), sceneRect.width(), 5);
if (rightShadow.intersects(rect) || rightShadow.contains(rect))
painter->fillRect(rightShadow, Qt::darkGray);
if (bottomShadow.intersects(rect) || bottomShadow.contains(rect))
painter->fillRect(bottomShadow, Qt::darkGray);
// Fill
QLinearGradient gradient(sceneRect.topLeft(), sceneRect.bottomRight());
gradient.setColorAt(0, QColor(100,107,126));
gradient.setColorAt(1, QColor(100,107,126));
painter->fillRect(rect.intersect(sceneRect), gradient);
//painter->setBrush(Qt::BrushStyle::DiagCrossPattern);
painter->drawRect(sceneRect);
// Text
//QRectF textRect(sceneRect.left() + 4, sceneRect.top() + 4,
// sceneRect.width() - 4, sceneRect.height() - 4);
//QString message(tr("Click and drag the nodes around, and zoom with the mouse "
// "wheel or the '+' and '-' keys"));
//QFont font = painter->font();
//font.setBold(true);
//font.setPointSize(14);
//painter->setFont(font);
//painter->setPen(Qt::lightGray);
////painter->drawText(textRect.translated(2, 2), message);
//painter->setPen(Qt::black);
//painter->drawText(textRect, message);
painter->setPen(QColor(135,142,157));
const int gridSize = 25;
qreal left = int(rect.left()) - (int(rect.left()) % gridSize);
qreal top = int(rect.top()) - (int(rect.top()) % gridSize);
QVarLengthArray<QLineF, 100> lines;
for (qreal x = left; x < rect.right(); x += gridSize)
lines.append(QLineF(x, rect.top(), x, rect.bottom()));
for (qreal y = top; y < rect.bottom(); y += gridSize)
lines.append(QLineF(rect.left(), y, rect.right(), y));
//qDebug() << lines.size();
painter->drawLines(lines.data(), lines.size());
}
XVisualInfo *qglx_findVisualInfo(Display *display, int screen, QSurfaceFormat *format)
{
Q_ASSERT(format);
XVisualInfo *visualInfo = 0;
GLXFBConfig config = qglx_findConfig(display,screen,*format);
if (config) {
visualInfo = glXGetVisualFromFBConfig(display, config);
*format = qglx_surfaceFormatFromGLXFBConfig(display, config);
}
// attempt to fall back to glXChooseVisual
bool reduced = true;
QSurfaceFormat reducedFormat = *format;
while (!visualInfo && reduced) {
QVarLengthArray<int, 13> attribs;
attribs.append(GLX_RGBA);
if (reducedFormat.redBufferSize() > 0) {
attribs.append(GLX_RED_SIZE);
attribs.append(reducedFormat.redBufferSize());
}
if (reducedFormat.greenBufferSize() > 0) {
attribs.append(GLX_GREEN_SIZE);
attribs.append(reducedFormat.greenBufferSize());
}
if (reducedFormat.blueBufferSize() > 0) {
attribs.append(GLX_BLUE_SIZE);
attribs.append(reducedFormat.blueBufferSize());
}
if (reducedFormat.stencilBufferSize() > 0) {
attribs.append(GLX_STENCIL_SIZE);
attribs.append(reducedFormat.stencilBufferSize());
}
if (reducedFormat.depthBufferSize() > 0) {
attribs.append(GLX_DEPTH_SIZE);
attribs.append(reducedFormat.depthBufferSize());
}
if (reducedFormat.swapBehavior() != QSurfaceFormat::SingleBuffer)
attribs.append(GLX_DOUBLEBUFFER);
attribs.append(XNone);
visualInfo = glXChooseVisual(display, screen, attribs.data());
if (visualInfo)
*format = reducedFormat;
reducedFormat = qglx_reduceSurfaceFormat(reducedFormat, &reduced);
}
return visualInfo;
}
NATRON_NAMESPACE_ANONYMOUS_ENTER
#if defined(Q_OS_WIN)
static QString
qSystemDirectory()
{
QVarLengthArray<wchar_t, MAX_PATH> fullPath;
UINT retLen = ::GetSystemDirectoryW(fullPath.data(), MAX_PATH);
if (retLen > MAX_PATH) {
fullPath.resize(retLen);
retLen = ::GetSystemDirectoryW(fullPath.data(), retLen);
}
if (!fullPath.constData()) {
return QString();
}
std::wstring ws(fullPath.constData(), retLen);
return QString::fromStdWString(ws);
}
void MovementScene::drawForeground(QPainter *painter, const QRectF &rect){
if(gridIsVisible){
painter->setWorldMatrixEnabled(true);
QVarLengthArray<QLineF, 100> linesX;
QVarLengthArray<QLineF, 100> linesY;
qreal left = int(rect.left()) - (int(rect.left()) % gridInterval );
qreal top = int(rect.top()) - (int(rect.top()) % gridInterval );
for (qreal x = left; x < rect.right(); x += gridInterval )
linesX.append(QLineF(x, rect.top(), x, rect.bottom()));
for (qreal y = top; y < rect.bottom(); y += gridInterval )
linesY.append(QLineF(rect.left(), y, rect.right(), y));
painter->setPen(QColor(196,220,255));
painter->drawLines(linesX.data(), linesX.size());
painter->drawLines(linesY.data(), linesY.size());
}
}
void QQuickTextNodeEngine::BinaryTreeNode::inOrder(const QVarLengthArray<BinaryTreeNode, 16> &binaryTree,
QVarLengthArray<int> *sortedIndexes, int currentIndex)
{
Q_ASSERT(currentIndex < binaryTree.size());
const BinaryTreeNode *node = binaryTree.data() + currentIndex;
if (node->leftChildIndex >= 0)
inOrder(binaryTree, sortedIndexes, node->leftChildIndex);
sortedIndexes->append(currentIndex);
if (node->rightChildIndex >= 0)
inOrder(binaryTree, sortedIndexes, node->rightChildIndex);
}
void UmlCanvas::drawBackground(QPainter& painter, const QRect& clip) {
if (show_grid()) {
int s = grid_size();
qreal left = int(clip.left())-(int(clip.left()) % s);
qreal top = int(clip.top())-(int(clip.top()) % s);
QVarLengthArray<QLineF, 100> lines;
for (qreal x = left; x < clip.right(); x += s)
lines.append(QLineF(x, clip.top(), x, clip.bottom()));
for (qreal y = top; y < clip.bottom(); y += s)
lines.append(QLineF(clip.left(), y, clip.right(), y));
painter.save();
painter.setPen(Qt::lightGray);
painter.drawLines(lines.data(), lines.size());
painter.restore();
}
}
void QGVScene::drawBackground(QPainter * painter, const QRectF & rect)
{
const int gridSize = 25;
const qreal left = int(rect.left()) - (int(rect.left()) % gridSize);
const qreal top = int(rect.top()) - (int(rect.top()) % gridSize);
QVarLengthArray<QLineF, 100> lines;
for (qreal x = left; x < rect.right(); x += gridSize)
lines.append(QLineF(x, rect.top(), x, rect.bottom()));
for (qreal y = top; y < rect.bottom(); y += gridSize)
lines.append(QLineF(rect.left(), y, rect.right(), y));
painter->setRenderHint(QPainter::Antialiasing, false);
painter->setPen(QColor(Qt::lightGray).lighter(110));
painter->drawLines(lines.data(), lines.size());
painter->setPen(Qt::black);
//painter->drawRect(sceneRect());
}
void LayoutGrid::paint(QPainter *painter, const QRectF &rect)
{
if (!isVisible())
return;
int gridSizeX = gridSpacingX();
int gridSizeY = gridSpacingY();
qreal left = int(rect.left()) - (int(rect.left()) % gridSizeX);
qreal top = int(rect.top()) - (int(rect.top()) % gridSizeY);
QVarLengthArray<QLineF, 200> lines;
for (qreal x = left; x < rect.right(); x += gridSizeX)
lines.append(QLineF(x, rect.top(), x, rect.bottom()));
for (qreal y = top; y < rect.bottom(); y += gridSizeY)
lines.append(QLineF(rect.left(), y, rect.right(), y));
painter->setPen(m_gridDotColor);
painter->drawLines(lines.data(), lines.size());
}
void TransferFunctionEditorView::drawBackground(QPainter* painter, const QRectF& rect) {
painter->fillRect(rect, QColor(89, 89, 89));
// overlay grid
int gridSpacing = 25;
QRectF sRect = sceneRect();
qreal right = int(sRect.right()) - (int(sRect.right()) % gridSpacing);
QVarLengthArray<QLineF, 100> lines;
for (qreal x = sRect.left(); x <= right; x += gridSpacing) {
lines.append(QLineF(x, sRect.top(), x, sRect.bottom()));
}
QPen gridPen;
gridPen.setColor(QColor(102, 102, 102));
gridPen.setWidthF(1.0);
gridPen.setCosmetic(true);
painter->setPen(gridPen);
painter->drawLines(lines.data(), lines.size());
// histogram
if (showHistogram_ > 0) {
updateHistogram();
for (auto& elem : histograms_) {
QPen pen;
pen.setColor(QColor(68, 102, 170, 150));
pen.setWidthF(2.0f);
pen.setCosmetic(true);
painter->setPen(pen);
QBrush brush;
brush.setColor(QColor(68, 102, 170, 100));
brush.setStyle(Qt::SolidPattern);
painter->setBrush(brush);
painter->drawPolygon(elem);
}
}
}
void BaseGraphicsView::drawBackground(QPainter *paint, const QRectF &rect)
{
QColor bgColor = QColor(57,57,57);
paint->fillRect(rect, bgColor);
// Draw grid
QColor gridColor = QColor(47,47,47);
int gridInterval = 20; //interval to draw grid lines at
paint->setWorldMatrixEnabled(true);
qreal left = int(rect.left()) - (int(rect.left()) % gridInterval );
qreal top = int(rect.top()) - (int(rect.top()) % gridInterval );
QVarLengthArray<QLineF, 100> lines;
for (qreal x = left; x < rect.right(); x += gridInterval)
lines.append(QLineF(x, rect.top(), x, rect.bottom()));
for (qreal y = top; y < rect.bottom(); y += gridInterval)
lines.append(QLineF(rect.left(), y, rect.right(), y));
paint->setPen(gridColor);
paint->drawLines(lines.data(), lines.size());
}
void Chip::paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget)
{
Q_UNUSED(widget);
QColor fillColor = (option->state & QStyle::State_Selected) ? color.dark(150) : color;
if (option->state & QStyle::State_MouseOver)
fillColor = fillColor.light(125);
if (option->levelOfDetail < 0.2) {
if (option->levelOfDetail < 0.125) {
painter->fillRect(QRectF(0, 0, 110, 70), fillColor);
return;
}
painter->setPen(QPen(Qt::black, 0));
painter->setBrush(fillColor);
painter->drawRect(13, 13, 97, 57);
return;
}
QPen oldPen = painter->pen();
QPen pen = oldPen;
int width = 0;
if (option->state & QStyle::State_Selected)
width += 2;
pen.setWidth(width);
painter->setBrush(QBrush(fillColor.dark(option->state & QStyle::State_Sunken ? 120 : 100)));
painter->drawRect(QRect(14, 14, 79, 39));
if (option->levelOfDetail >= 1) {
painter->setPen(QPen(Qt::gray, 1));
painter->drawLine(15, 54, 94, 54);
painter->drawLine(94, 53, 94, 15);
painter->setPen(QPen(Qt::black, 0));
}
// Draw text
if (option->levelOfDetail >= 2) {
QFont font("Times", 10);
font.setStyleStrategy(QFont::ForceOutline);
painter->setFont(font);
painter->save();
painter->scale(0.1, 0.1);
painter->drawText(170, 180, QString("Model: VSC-2000 (Very Small Chip) at %1x%2").arg(x).arg(y));
painter->drawText(170, 200, QString("Serial number: DLWR-WEER-123L-ZZ33-SDSJ"));
painter->drawText(170, 220, QString("Manufacturer: Chip Manufacturer"));
painter->restore();
}
// Draw lines
QVarLengthArray<QLineF, 36> lines;
if (option->levelOfDetail >= 0.5) {
for (int i = 0; i <= 10; i += (option->levelOfDetail > 0.5 ? 1 : 2)) {
lines.append(QLineF(18 + 7 * i, 13, 18 + 7 * i, 5));
lines.append(QLineF(18 + 7 * i, 54, 18 + 7 * i, 62));
}
for (int i = 0; i <= 6; i += (option->levelOfDetail > 0.5 ? 1 : 2)) {
lines.append(QLineF(5, 18 + i * 5, 13, 18 + i * 5));
lines.append(QLineF(94, 18 + i * 5, 102, 18 + i * 5));
}
}
if (option->levelOfDetail >= 0.4) {
const QLineF lineData[] = {
QLineF(25, 35, 35, 35),
QLineF(35, 30, 35, 40),
QLineF(35, 30, 45, 35),
QLineF(35, 40, 45, 35),
QLineF(45, 30, 45, 40),
QLineF(45, 35, 55, 35)
};
lines.append(lineData, 6);
}
painter->drawLines(lines.data(), lines.size());
// Draw red ink
if (stuff.size() > 1) {
painter->setPen(QPen(Qt::red, 1, Qt::SolidLine, Qt::RoundCap, Qt::RoundJoin));
painter->setBrush(Qt::NoBrush);
QPainterPath path;
path.moveTo(stuff.first());
for (int i = 1; i < stuff.size(); ++i)
path.lineTo(stuff.at(i));
painter->drawPath(path);
}
}
//! [1]
int myfunc(int n)
{
int *table = new int[n + 1];
...
int ret = table[n];
delete[] table;
return ret;
}
//! [1]
//! [2]
int myfunc(int n)
{
QVarLengthArray<int, 1024> array(n + 1);
...
return array[n];
}
//! [2]
//! [3]
QVarLengthArray<int> array(10);
int *data = array.data();
for (int i = 0; i < 10; ++i)
data[i] = 2 * i;
//! [3]
/*!
Creates an OpenCL context that is compatible with the current
QGLContext and \a platform. Returns false if there is no OpenGL
context current or the OpenCL context could not be created for
some reason.
This function will first try to create a QCLDevice::GPU device,
and will then fall back to QCLDevice::Default if a GPU is not found.
If \a platform is null, then the first platform that has a GPU
will be used. If there is no GPU, then the first platform with a
default device will be used.
\sa supportsObjectSharing()
*/
bool QCLContextGL::create(const QCLPlatform &platform)
{
Q_D(QCLContextGL);
// Bail out if the context already exists.
if (isCreated())
return true;
// Bail out if we don't have an OpenGL context.
if (!QGLContext::currentContext()) {
qWarning() << "QCLContextGL::create: needs a current GL context";
setLastError(CL_INVALID_CONTEXT);
return false;
}
// Find the first gpu device.
QList<QCLDevice> devices;
cl_device_type deviceType = CL_DEVICE_TYPE_GPU;
devices = QCLDevice::devices(QCLDevice::GPU, platform);
if (devices.isEmpty()) {
// Find the first default device.
devices = QCLDevice::devices(QCLDevice::Default, platform);
deviceType = CL_DEVICE_TYPE_DEFAULT;
}
if (devices.isEmpty()) {
qWarning() << "QCLContextGL::create: no gpu devices found";
setLastError(CL_DEVICE_NOT_FOUND);
return false;
}
QCLDevice gpu = devices[0];
QVarLengthArray<cl_device_id> devs;
foreach (QCLDevice dev, devices)
devs.append(dev.deviceId());
// Add the platform identifier to the properties.
QVarLengthArray<cl_context_properties> properties;
properties.append(CL_CONTEXT_PLATFORM);
properties.append(cl_context_properties(gpu.platform().platformId()));
bool hasSharing = false;
#ifndef QT_NO_CL_OPENGL
// Determine what kind of OpenCL-OpenGL sharing we have and enable it.
#if defined(__APPLE__) || defined(__MACOSX)
bool appleSharing = gpu.hasExtension("cl_apple_gl_sharing");
if (appleSharing) {
CGLContextObj cglContext = CGLGetCurrentContext();
CGLShareGroupObj cglShareGroup = CGLGetShareGroup(cglContext);
properties.append(CL_CGL_SHAREGROUP_KHR);
properties.append(cl_context_properties(cglShareGroup));
hasSharing = true;
}
#else
bool khrSharing = gpu.hasExtension("cl_khr_gl_sharing");
#if defined(QT_OPENGL_ES_2) || defined(QT_OPENGL_ES)
if (khrSharing) {
properties.append(CL_EGL_DISPLAY_KHR);
properties.append(cl_context_properties(eglGetCurrentDisplay()));
#ifdef EGL_OPENGL_ES_API
eglBindAPI(EGL_OPENGL_ES_API);
#endif
properties.append(CL_GL_CONTEXT_KHR);
properties.append(cl_context_properties(eglGetCurrentContext()));
hasSharing = true;
}
#elif defined(Q_WS_X11)
if (khrSharing) {
properties.append(CL_GLX_DISPLAY_KHR);
properties.append(cl_context_properties(glXGetCurrentDisplay()));
properties.append(CL_GL_CONTEXT_KHR);
properties.append(cl_context_properties(glXGetCurrentContext()));
hasSharing = true;
}
#else
// Needs to be ported to other platforms.
if (khrSharing)
qWarning() << "QCLContextGL::create: do not know how to enable sharing";
#endif
#endif
#endif // !QT_NO_CL_OPENGL
properties.append(0);
#ifndef QT_NO_CL_OPENGL
// Query the actual OpenCL devices we should use with the OpenGL context.
typedef cl_int (*q_PFNCLGETGLCONTEXTINFOKHR)
(const cl_context_properties *, cl_uint, size_t, void *, size_t *);
q_PFNCLGETGLCONTEXTINFOKHR getGLContextInfo =
(q_PFNCLGETGLCONTEXTINFOKHR)clGetExtensionFunctionAddress
("clGetGLContextInfoKHR");
if (getGLContextInfo && hasSharing) {
size_t size;
cl_device_id currentDev;
if(getGLContextInfo(properties.data(),
CL_DEVICES_FOR_GL_CONTEXT_KHR,
0, 0, &size) == CL_SUCCESS && size > 0) {
QVarLengthArray<cl_device_id> buf(size / sizeof(cl_device_id));
getGLContextInfo(properties.data(),
CL_DEVICES_FOR_GL_CONTEXT_KHR,
size, buf.data(), 0);
devs = buf;
gpu = QCLDevice(devs[0]);
}
if (getGLContextInfo(properties.data(),
CL_CURRENT_DEVICE_FOR_GL_CONTEXT_KHR,
sizeof(currentDev), ¤tDev, 0)
== CL_SUCCESS) {
gpu = QCLDevice(currentDev);
}
}
#endif
// Create the OpenCL context.
cl_context id;
cl_int error;
id = clCreateContext
(properties.data(), devs.size(), devs.data(),
qt_clgl_context_notify, 0, &error);
if (!id && hasSharing) {
// Try again without the sharing parameters.
properties.resize(2);
properties.append(0);
hasSharing = false;
id = clCreateContext
(properties.data(), devs.size(), devs.data(),
qt_clgl_context_notify, 0, &error);
}
setLastError(error);
if (id == 0) {
qWarning() << "QCLContextGL::create:" << errorName(error);
d->supportsSharing = false;
} else {
setContextId(id);
clReleaseContext(id); // setContextId() adds an extra reference.
setDefaultDevice(gpu);
d->supportsSharing = hasSharing;
}
return id != 0;
}
void QDBusMetaObjectGenerator::write(QDBusMetaObject *obj)
{
// this code here is mostly copied from qaxbase.cpp
// with a few modifications to make it cleaner
QString className = interface;
className.replace(QLatin1Char('.'), QLatin1String("::"));
if (className.isEmpty())
className = QLatin1String("QDBusInterface");
QVarLengthArray<int> idata;
idata.resize(sizeof(QDBusMetaObjectPrivate) / sizeof(int));
int methodParametersDataSize =
((aggregateParameterCount(signals_)
+ aggregateParameterCount(methods)) * 2) // types and parameter names
- signals_.count() // return "parameters" don't have names
- methods.count(); // ditto
QDBusMetaObjectPrivate *header = reinterpret_cast<QDBusMetaObjectPrivate *>(idata.data());
Q_STATIC_ASSERT_X(QMetaObjectPrivate::OutputRevision == 7, "QtDBus meta-object generator should generate the same version as moc");
header->revision = QMetaObjectPrivate::OutputRevision;
header->className = 0;
header->classInfoCount = 0;
header->classInfoData = 0;
header->methodCount = signals_.count() + methods.count();
header->methodData = idata.size();
header->propertyCount = properties.count();
header->propertyData = header->methodData + header->methodCount * 5 + methodParametersDataSize;
header->enumeratorCount = 0;
header->enumeratorData = 0;
header->constructorCount = 0;
header->constructorData = 0;
header->flags = RequiresVariantMetaObject;
header->signalCount = signals_.count();
// These are specific to QDBusMetaObject:
header->propertyDBusData = header->propertyData + header->propertyCount * 3;
header->methodDBusData = header->propertyDBusData + header->propertyCount * intsPerProperty;
int data_size = idata.size() +
(header->methodCount * (5+intsPerMethod)) + methodParametersDataSize +
(header->propertyCount * (3+intsPerProperty));
foreach (const Method &mm, signals_)
data_size += 2 + mm.inputTypes.count() + mm.outputTypes.count();
foreach (const Method &mm, methods)
data_size += 2 + mm.inputTypes.count() + mm.outputTypes.count();
idata.resize(data_size + 1);
QMetaStringTable strings(className.toLatin1());
int offset = header->methodData;
int parametersOffset = offset + header->methodCount * 5;
int signatureOffset = header->methodDBusData;
int typeidOffset = header->methodDBusData + header->methodCount * intsPerMethod;
idata[typeidOffset++] = 0; // eod
// add each method:
for (int x = 0; x < 2; ++x) {
// Signals must be added before other methods, to match moc.
QMap<QByteArray, Method> &map = (x == 0) ? signals_ : methods;
for (QMap<QByteArray, Method>::ConstIterator it = map.constBegin();
it != map.constEnd(); ++it) {
const Method &mm = it.value();
int argc = mm.inputTypes.size() + qMax(0, mm.outputTypes.size() - 1);
idata[offset++] = strings.enter(mm.name);
idata[offset++] = argc;
idata[offset++] = parametersOffset;
idata[offset++] = strings.enter(mm.tag);
idata[offset++] = mm.flags;
// Parameter types
for (int i = -1; i < argc; ++i) {
int type;
QByteArray typeName;
if (i < 0) { // Return type
if (!mm.outputTypes.isEmpty()) {
type = mm.outputTypes.first();
if (type == -1) {
type = IsUnresolvedType | strings.enter(mm.rawReturnType);
}
} else {
type = QMetaType::Void;
}
} else if (i < mm.inputTypes.size()) {
type = mm.inputTypes.at(i);
} else {
Q_ASSERT(mm.outputTypes.size() > 1);
type = mm.outputTypes.at(i - mm.inputTypes.size() + 1);
// Output parameters are references; type id not available
typeName = QMetaType::typeName(type);
typeName.append('&');
}
Q_ASSERT(type != QMetaType::UnknownType);
int typeInfo;
if (!typeName.isEmpty())
typeInfo = IsUnresolvedType | strings.enter(typeName);
else
typeInfo = type;
idata[parametersOffset++] = typeInfo;
}
// Parameter names
for (int i = 0; i < argc; ++i)
idata[parametersOffset++] = strings.enter(mm.parameterNames.at(i));
idata[signatureOffset++] = typeidOffset;
idata[typeidOffset++] = mm.inputTypes.count();
memcpy(idata.data() + typeidOffset, mm.inputTypes.data(), mm.inputTypes.count() * sizeof(int));
typeidOffset += mm.inputTypes.count();
idata[signatureOffset++] = typeidOffset;
idata[typeidOffset++] = mm.outputTypes.count();
memcpy(idata.data() + typeidOffset, mm.outputTypes.data(), mm.outputTypes.count() * sizeof(int));
typeidOffset += mm.outputTypes.count();
}
}
Q_ASSERT(offset == header->methodData + header->methodCount * 5);
Q_ASSERT(parametersOffset == header->propertyData);
Q_ASSERT(signatureOffset == header->methodDBusData + header->methodCount * intsPerMethod);
Q_ASSERT(typeidOffset == idata.size());
offset += methodParametersDataSize;
Q_ASSERT(offset == header->propertyData);
// add each property
signatureOffset = header->propertyDBusData;
for (QMap<QByteArray, Property>::ConstIterator it = properties.constBegin();
it != properties.constEnd(); ++it) {
const Property &mp = it.value();
// form is name, typeinfo, flags
idata[offset++] = strings.enter(it.key()); // name
Q_ASSERT(mp.type != QMetaType::UnknownType);
idata[offset++] = mp.type;
idata[offset++] = mp.flags;
idata[signatureOffset++] = strings.enter(mp.signature);
idata[signatureOffset++] = mp.type;
}
Q_ASSERT(offset == header->propertyDBusData);
Q_ASSERT(signatureOffset == header->methodDBusData);
char *string_data = new char[strings.blobSize()];
strings.writeBlob(string_data);
uint *uint_data = new uint[idata.size()];
memcpy(uint_data, idata.data(), idata.size() * sizeof(int));
// put the metaobject together
obj->d.data = uint_data;
obj->d.relatedMetaObjects = 0;
obj->d.static_metacall = 0;
obj->d.extradata = 0;
obj->d.stringdata = reinterpret_cast<const QByteArrayData *>(string_data);
obj->d.superdata = &QDBusAbstractInterface::staticMetaObject;
}
unsigned ProspectiveTokenizer::consumeEntity(TokenizerString& source, bool& notEnoughCharacters)
{
enum EntityState {
Initial,
NumberType,
MaybeHex,
Hex,
Decimal,
Named
};
EntityState entityState = Initial;
unsigned result = 0;
QVarLengthArray<QChar> seenChars;
QVarLengthArray<char> entityName;
while (!source.isEmpty()) {
seenChars.append(*source);
ushort cc = source->unicode();
switch (entityState) {
case Initial:
if (isWhitespace(cc) || cc == '<' || cc == '&')
return 0;
else if (cc == '#')
entityState = NumberType;
else if ((cc >= 'a' && cc <= 'z') || (cc >= 'A' && cc <= 'Z')) {
entityName.append(cc);
entityState = Named;
} else
return 0;
break;
case NumberType:
if (cc == 'x' || cc == 'X')
entityState = MaybeHex;
else if (cc >= '0' && cc <= '9') {
entityState = Decimal;
result = cc - '0';
} else {
source.push('#');
return 0;
}
break;
case MaybeHex:
if (cc >= '0' && cc <= '9')
result = cc - '0';
else if (cc >= 'a' && cc <= 'f')
result = 10 + cc - 'a';
else if (cc >= 'A' && cc <= 'F')
result = 10 + cc - 'A';
else {
source.push(seenChars[1]);
source.push('#');
return 0;
}
entityState = Hex;
break;
case Hex:
if (cc >= '0' && cc <= '9')
result = result * 16 + cc - '0';
else if (cc >= 'a' && cc <= 'f')
result = result * 16 + 10 + cc - 'a';
else if (cc >= 'A' && cc <= 'F')
result = result * 16 + 10 + cc - 'A';
else if (cc == ';') {
source.advance();
return legalEntityFor(result);
} else
return legalEntityFor(result);
break;
case Decimal:
if (cc >= '0' && cc <= '9')
result = result * 10 + cc - '0';
else if (cc == ';') {
source.advance();
return legalEntityFor(result);
} else
return legalEntityFor(result);
break;
case Named:
// This is the attribute only version, generic version matches somewhat differently
while (entityName.size() <= 8) {
if (cc == ';') {
const entity* e = kde_findEntity(entityName.data(), entityName.size());
if (e) {
source.advance();
return e->code;
}
break;
}
if (!(cc >= 'a' && cc <= 'z') && !(cc >= 'A' && cc <= 'Z') && !(cc >= '0' && cc <= '9')) {
const entity* e = kde_findEntity(entityName.data(), entityName.size());
if (e)
return e->code;
break;
}
entityName.append(cc);
source.advance();
if (source.isEmpty())
goto outOfCharacters;
cc = source->unicode();
seenChars.append(cc);
}
if (seenChars.size() == 2)
source.push(seenChars[0]);
else if (seenChars.size() == 3) {
source.push(seenChars[1]);
source.push(seenChars[0]);
} else
source.prepend(TokenizerString(QString(seenChars.data(), seenChars.size() - 1)));
return 0;
}
source.advance();
}
outOfCharacters:
notEnoughCharacters = true;
source.prepend(TokenizerString(QString(seenChars.data(), seenChars.size())));
return 0;
}
void QDBusMetaObjectGenerator::write(QDBusMetaObject *obj)
{
// this code here is mostly copied from qaxbase.cpp
// with a few modifications to make it cleaner
QString className = interface;
className.replace(QLatin1Char('.'), QLatin1String("::"));
if (className.isEmpty())
className = QLatin1String("QDBusInterface");
QVarLengthArray<int> idata;
idata.resize(sizeof(QDBusMetaObjectPrivate) / sizeof(int));
QDBusMetaObjectPrivate *header = reinterpret_cast<QDBusMetaObjectPrivate *>(idata.data());
header->revision = 1;
header->className = 0;
header->classInfoCount = 0;
header->classInfoData = 0;
header->methodCount = methods.count();
header->methodData = idata.size();
header->propertyCount = properties.count();
header->propertyData = header->methodData + header->methodCount * 5;
header->enumeratorCount = 0;
header->enumeratorData = 0;
header->propertyDBusData = header->propertyData + header->propertyCount * 3;
header->methodDBusData = header->propertyDBusData + header->propertyCount * intsPerProperty;
int data_size = idata.size() +
(header->methodCount * (5+intsPerMethod)) +
(header->propertyCount * (3+intsPerProperty));
foreach (const Method &mm, methods)
data_size += 2 + mm.inputTypes.count() + mm.outputTypes.count();
idata.resize(data_size + 1);
char null('\0');
QByteArray stringdata = className.toLatin1();
stringdata += null;
stringdata.reserve(8192);
int offset = header->methodData;
int signatureOffset = header->methodDBusData;
int typeidOffset = header->methodDBusData + header->methodCount * intsPerMethod;
idata[typeidOffset++] = 0; // eod
// add each method:
for (QMap<QByteArray, Method>::ConstIterator it = methods.constBegin();
it != methods.constEnd(); ++it) {
// form "prototype\0parameters\0typeName\0tag\0methodname\0inputSignature\0outputSignature"
const Method &mm = it.value();
idata[offset++] = stringdata.length();
stringdata += it.key(); // prototype
stringdata += null;
idata[offset++] = stringdata.length();
stringdata += mm.parameters;
stringdata += null;
idata[offset++] = stringdata.length();
stringdata += mm.typeName;
stringdata += null;
idata[offset++] = stringdata.length();
stringdata += mm.tag;
stringdata += null;
idata[offset++] = mm.flags;
idata[signatureOffset++] = stringdata.length();
stringdata += mm.name;
stringdata += null;
idata[signatureOffset++] = stringdata.length();
stringdata += mm.inputSignature;
stringdata += null;
idata[signatureOffset++] = stringdata.length();
stringdata += mm.outputSignature;
stringdata += null;
idata[signatureOffset++] = typeidOffset;
idata[typeidOffset++] = mm.inputTypes.count();
memcpy(idata.data() + typeidOffset, mm.inputTypes.data(), mm.inputTypes.count() * sizeof(int));
typeidOffset += mm.inputTypes.count();
idata[signatureOffset++] = typeidOffset;
idata[typeidOffset++] = mm.outputTypes.count();
memcpy(idata.data() + typeidOffset, mm.outputTypes.data(), mm.outputTypes.count() * sizeof(int));
typeidOffset += mm.outputTypes.count();
}
Q_ASSERT(offset == header->propertyData);
Q_ASSERT(signatureOffset == header->methodDBusData + header->methodCount * intsPerMethod);
Q_ASSERT(typeidOffset == idata.size());
// add each property
signatureOffset = header->propertyDBusData;
for (QMap<QByteArray, Property>::ConstIterator it = properties.constBegin();
it != properties.constEnd(); ++it) {
const Property &mp = it.value();
// form is "name\0typeName\0signature\0"
idata[offset++] = stringdata.length();
stringdata += it.key(); // name
stringdata += null;
idata[offset++] = stringdata.length();
stringdata += mp.typeName;
stringdata += null;
idata[offset++] = mp.flags;
idata[signatureOffset++] = stringdata.length();
stringdata += mp.signature;
stringdata += null;
idata[signatureOffset++] = mp.type;
}
Q_ASSERT(offset == header->propertyDBusData);
Q_ASSERT(signatureOffset == header->methodDBusData);
char *string_data = new char[stringdata.length()];
memcpy(string_data, stringdata, stringdata.length());
uint *uint_data = new uint[idata.size()];
memcpy(uint_data, idata.data(), idata.size() * sizeof(int));
// put the metaobject together
obj->d.data = uint_data;
obj->d.extradata = 0;
obj->d.stringdata = string_data;
obj->d.superdata = &QDBusAbstractInterface::staticMetaObject;
}
void MocParser::loadStringData(char *&stringdata)
{
stringdata = 0;
QVarLengthArray<char, 1024> array;
while (!input->atEnd()) {
QByteArray line = readLine();
if (line == "};\n") {
// end of data
stringdata = new char[array.count()];
memcpy(stringdata, array.data(), array.count() * sizeof(*stringdata));
return;
}
int start = line.indexOf('"');
if (start == -1)
parseError();
int len = line.length() - 1;
line.truncate(len); // drop ending \n
if (line.at(len - 1) != '"')
parseError();
--len;
++start;
for ( ; start < len; ++start)
if (line.at(start) == '\\') {
// parse escaped sequence
++start;
if (start == len)
parseError();
QChar c(QLatin1Char(line.at(start)));
if (!c.isDigit()) {
switch (c.toLatin1()) {
case 'a':
array.append('\a');
break;
case 'b':
array.append('\b');
break;
case 'f':
array.append('\f');
break;
case 'n':
array.append('\n');
break;
case 'r':
array.append('\r');
break;
case 't':
array.append('\t');
break;
case 'v':
array.append('\v');
break;
case '\\':
case '?':
case '\'':
case '"':
array.append(c.toLatin1());
break;
case 'x':
if (start + 2 <= len)
parseError();
array.append(char(line.mid(start + 1, 2).toInt(0, 16)));
break;
default:
array.append(c.toLatin1());
fprintf(stderr, PROGRAMNAME ": warning: invalid escape sequence '\\%c' found in input",
c.toLatin1());
}
} else {
// octal
QRegExp octal(QLatin1String("([0-7]+)"));
if (octal.indexIn(QLatin1String(line), start) == -1)
parseError();
array.append(char(octal.cap(1).toInt(0, 8)));
}
} else {
array.append(line.at(start));
}
}
parseError();
}
