int MStyleSheetAttribute::attributeToInt(const QByteArray &attribute, bool *conversionOk)
{
    QByteArray value = attribute.trimmed();

    if (attribute.endsWith(units[PIXELS_UNIT])) {
        // strip "px" from the end
        value.truncate(value.length() - 2);
        return value.toInt(conversionOk);
    }

    if (attribute.endsWith(units[MM_UNIT])) {
        // strip "mm" from the end
        value.truncate(value.length() - 2);

        return MDeviceProfile::instance()->mmToPixels(value.toFloat(conversionOk));
    }

    if (attribute.endsWith(units[PT_UNIT])) {
        // strip "pt" from the end
        value.truncate(value.length() - 2);

        return MDeviceProfile::instance()->ptToPixels(value.toFloat(conversionOk));
    }

    return value.toInt(conversionOk);
}
Esempio n. 2
0
void PingPong::readSocket()
{
    if (!socket)
        return;
    const char sep = ' ';
    QByteArray line;
    while (socket->canReadLine()) {
        line = socket->readLine();
        //qDebug() << QString::fromUtf8(line.constData(), line.length());
        if (line.contains("result")) {
            QList<QByteArray> result = line.split(sep);
            if (result.size() > 2) {
                QByteArray leftSide = result.at(1);
                QByteArray rightSide = result.at(2);
                m_resultLeft = leftSide.toInt();
                m_resultRight = rightSide.toInt();
                Q_EMIT resultChanged();
                checkResult();
            }
        }
    }
    if ((m_proportionX == 0 || m_proportionY == 0)) {
        QList<QByteArray> boardSize = line.split(sep);
        if (boardSize.size() > 1) {
            QByteArray boardWidth = boardSize.at(0);
            QByteArray boardHeight = boardSize.at(1);
            m_proportionX = m_boardWidth/boardWidth.toFloat();
            m_proportionY = m_boardHeight/boardHeight.toFloat();
            setMessage("Screen adjusted. Get ready!");
            QTimer::singleShot(3000, this, SLOT(startGame()));
        }
    }
    else if (m_role == 1) {
        QList<QByteArray> boardSize = line.split(sep);
        if (boardSize.size() > 1) {
            QByteArray rightBlockY = boardSize.at(0);
            m_rightBlockY = m_proportionY * rightBlockY.toFloat();
            Q_EMIT rightBlockChanged();
        }
    }
    else if (m_role == 2) {
        QList<QByteArray> boardSize = line.split(sep);
        if (boardSize.size() > 2) {
            QByteArray ballX = boardSize.at(0);
            QByteArray ballY = boardSize.at(1);
            QByteArray leftBlockY = boardSize.at(2);
            m_ballX = m_proportionX * ballX.toFloat();
            m_ballY = m_proportionY * ballY.toFloat();
            m_leftBlockY = m_proportionY * leftBlockY.toFloat();
            Q_EMIT leftBlockChanged();
            Q_EMIT ballChanged();
        }
    }
}
int MonarkConnection::readConfiguredLoad()
{
    m_serial->write("B\r");
    if (!m_serial->waitForBytesWritten(500))
    {
        // failure to write to device, bail out
        this->exit(-1);
    }
    QByteArray data = readAnswer(500);
    data.remove(0,1);
    qDebug() << "Current configure load: " << data.toInt();
    return data.toInt();
}
Esempio n. 4
0
QT_BEGIN_NAMESPACE

QEglFSScreen::QEglFSScreen(EGLDisplay dpy)
    : m_dpy(dpy),
      m_surface(EGL_NO_SURFACE),
      m_cursor(0),
      m_rootContext(0)
{
#ifdef QEGL_EXTRA_DEBUG
    qWarning("QEglScreen %p\n", this);
#endif

    QByteArray hideCursorVal = qgetenv("QT_QPA_EGLFS_HIDECURSOR");
    bool hideCursor = false;
    if (hideCursorVal.isEmpty()) {
#if !defined(QT_NO_EVDEV) && (!defined(Q_OS_ANDROID) || defined(Q_OS_ANDROID_NO_SDK))
        QScopedPointer<QDeviceDiscovery> dis(QDeviceDiscovery::create(QDeviceDiscovery::Device_Mouse));
        hideCursor = dis->scanConnectedDevices().isEmpty();
#endif
    } else {
        hideCursor = hideCursorVal.toInt() != 0;
    }
    if (!hideCursor)
        m_cursor = QEglFSHooks::hooks()->createCursor(this);
}
Esempio n. 5
0
bool Matrix::getHdcpStatus(QByteArray input)
{
    QByteArray resp;
    QByteArray esc = "\x1B";
    resp = dxpClient->sendQuery(esc + "E" + input + "HDCP\r").trimmed();
    return resp.toInt();
}
Esempio n. 6
0
bool QXcbScreen::xResource(const QByteArray &identifier,
                           const QByteArray &expectedIdentifier,
                           int *value)
{
    Q_ASSERT(value != 0);
    if (identifier.startsWith(expectedIdentifier)) {
        QByteArray stringValue = identifier.mid(expectedIdentifier.size());

        bool ok;
        *value = stringValue.toInt(&ok);
        if (!ok) {
            if (stringValue == "hintfull")
                *value = QFontEngine::HintFull;
            else if (stringValue == "hintnone")
                *value = QFontEngine::HintNone;
            else if (stringValue == "hintmedium")
                *value = QFontEngine::HintMedium;
            else if (stringValue == "hintslight")
                *value = QFontEngine::HintLight;

            return *value != 0;
        }

        return true;
    }

    return false;
}
Esempio n. 7
0
CrossFlip::CrossFlip(QByteArray fileData){
    fileData = fileData.mid(fileData.indexOf("var boardinit"));
    fileData = fileData.mid(0, fileData.indexOf("</script>"));

    QByteArray board;
    board = fileData.mid(fileData.indexOf("\"")+1);
    board = board.mid(0, board.indexOf("\""));
    std::vector<bool> bufferBlocked, bufferStartValue;
    for(int i=0; i< board.size(); ++i){
        if(board[i] == ','){
            Blocked.push_back(bufferBlocked);
            startValue.push_back(bufferStartValue);
            bufferBlocked.clear();
            bufferStartValue.clear();
            continue;
        }
        if(board[i] == '0'){
            bufferBlocked.push_back(false);
            bufferStartValue.push_back(false);
        }else if(board[i] == '1'){
            bufferBlocked.push_back(false);
            bufferStartValue.push_back(true);
        }else if(board[i] == '2'){
            bufferBlocked.push_back(true);
            bufferStartValue.push_back(false);
        }
    }
    Blocked.push_back(bufferBlocked);
    startValue.push_back(bufferStartValue);
    QByteArray lev = fileData;
    lev = lev.mid(lev.indexOf("level"));
    lev = lev.mid(lev.indexOf("=")+2);
    lev = lev.mid(0, lev.indexOf(";"));
    level = lev.toInt();
}
Esempio n. 8
0
void QTcpClient::readMessage()
{
    qDebug()<<"////////////////";
    qint64 numc = 0;
    qint64 numb = tcpsocket->bytesAvailable();
    qDebug()<<numb<<"  numb";
    while(numc < numb)
    {
        int type = 0;
        int length = 0;
        QByteArray databy;
        databy = tcpsocket->read(1);
        numc++;
        type = databy.toInt();
        if(type != m_type)
        {
            databy = tcpsocket->readAll();
            databy.clear();
            continue;
        }
        databy.clear();
        databy = tcpsocket->read(4);
        numc = numc + 4;
        length = Char2Dec(databy.data());
        if(length == 0)
        {
            continue;
        }
        databy.clear();
        databy = tcpsocket->read(length);
        numc = numc +length;
        qDebug()<<m_time.currentDateTime().toString("hh:mm:ss.zzz")<<" Lib";
        (*g_callRead)(databy);
    }
}
QVariant StelJsonParserInstance::readOther()
{
	QByteArray str;
	char c;
	while (getChar(&c))
	{
		if (c==' ' || c==',' || c=='\n' || c=='\r' || c==']' || c=='\t' || c=='}')
		{
			ungetChar(c);
			break;
		}
		str+=c;
	}
	bool ok;
	const int i = str.toInt(&ok);
	if (ok)
		return i;
	const double d = str.toDouble(&ok);
	if (ok)
		return d;
	if (str=="true")
		return QVariant(true);
	if (str=="false")
		return QVariant(false);
	if (str=="null")
		return QVariant();
	QDateTime dt = QDateTime::fromString(str, Qt::ISODate);
	if (dt.isValid())
		return QVariant(dt);

	throw std::runtime_error(qPrintable(QString("Invalid JSON value: \"")+str+"\""));
}
Esempio n. 10
0
QString DevicePrivate::decodePropertyValue(const QByteArray &encoded) const
{
    QByteArray decoded;
    const int len = encoded.length();

    for (int i = 0; i < len; i++) {
        quint8 ch = encoded.at(i);

        if (ch == '\\') {
            if (i + 1 < len && encoded.at(i + 1) == '\\') {
                decoded.append('\\');
                i++;
                continue;
            } else if (i + 3 < len && encoded.at(i + 1) == 'x') {
                QByteArray hex = encoded.mid(i + 2, 2);
                bool ok;
                int code = hex.toInt(&ok, 16);
                if (ok)
                    decoded.append(char(code));
                i += 3;
                continue;
            }
        } else {
            decoded.append(ch);
        }
    }
    return QString::fromUtf8(decoded);
}
Esempio n. 11
0
unsigned int GyroscopeAdaptor::interval() const
{
    if (mode() == SysfsAdaptor::IntervalMode)
        return SysfsAdaptor::interval();
    QByteArray byteArray = readFromFile(dataRatePath_);
    return byteArray.size() > 0 ? byteArray.toInt() : 0;
}
Esempio n. 12
0
/**@brief convert QString to float (4 bytes, 32 bits);
 *
 *@param str [IN]: the string to convert;
 *@param data [OUT]: the result is stored in this parm;
 *@return bool: if convert succeed, return true; else, return false;
 *@note hex->decimal->float
 */
bool Lms511Thread::Str2Real(QByteArray str, float* data)
{
    bool ok = false;
    int n = str.toInt(&ok, 16);
    memcpy(data, &n, sizeof(float));
    return ok;
}
Esempio n. 13
0
bool QHttpNetworkReplyPrivate::parseStatus(const QByteArray &status)
{
    // from RFC 2616:
    //        Status-Line = HTTP-Version SP Status-Code SP Reason-Phrase CRLF
    //        HTTP-Version   = "HTTP" "/" 1*DIGIT "." 1*DIGIT
    // that makes: 'HTTP/n.n xxx Message'
    // byte count:  0123456789012

    static const int minLength = 11;
    static const int dotPos = 6;
    static const int spacePos = 8;
    static const char httpMagic[] = "HTTP/";

    if (status.length() < minLength
        || !status.startsWith(httpMagic)
        || status.at(dotPos) != '.'
        || status.at(spacePos) != ' ') {
        // I don't know how to parse this status line
        return false;
    }

    // optimize for the valid case: defer checking until the end
    majorVersion = status.at(dotPos - 1) - '0';
    minorVersion = status.at(dotPos + 1) - '0';

    int i = spacePos;
    int j = status.indexOf(' ', i + 1); // j == -1 || at(j) == ' ' so j+1 == 0 && j+1 <= length()
    const QByteArray code = status.mid(i + 1, j - i - 1);

    bool ok;
    statusCode = code.toInt(&ok);
    reasonPhrase = QString::fromLatin1(status.constData() + j + 1);

    return ok && uint(majorVersion) <= 9 && uint(minorVersion) <= 9;
}
Esempio n. 14
0
//读取数据
void MainWindow::readMyCom()
{
    QByteArray temp = myCom->readAll();

    if(!temp.isEmpty()){

        if(write2fileName.isEmpty()){
            ui->textBrowser->setTextColor(Qt::lightGray);
            ui->textBrowser->append(tr("接收: "));
            ui->textBrowser->setTextColor(Qt::black);
            if(ui->ccradioButton->isChecked()){
                ui->textBrowser->append(temp);
            }else if(ui->chradioButton->isChecked()){
                ui->textBrowser->append(tr("")+temp.toHex());
            }else{
                ui->textBrowser->append(tr("")+temp.toInt());
            }

        }else{
            QFile file(write2fileName);
            //如果打开失败则给出提示并退出函数
            if(!file.open(QFile::Append | QIODevice::Text)){
                QMessageBox::warning(this, tr("写入文件"), tr("打开文件 %1 失败, 无法写入\n%2").arg(write2fileName).arg(file.errorString()), QMessageBox::Ok);
                return;
            }
            QTextStream out(&file);
            out<<temp<<endl;
            file.close();
            ui->textBrowser->append(tr("接收:数据已经写入文件 %1").arg(write2fileName));
        }

        ui->recvbyteslcdNumber->display(ui->recvbyteslcdNumber->value() + temp.size());
        ui->statusBar->showMessage(tr("成功读取%1字节数据").arg(temp.size()));
    }
}
Esempio n. 15
0
static void QWebOSGLContext::initialize(EGLNativeDisplayType display)
{
    EGLint major, minor;

   if (!eglBindAPI(EGL_OPENGL_ES_API)) {
        qWarning("Could not bind GL_ES API\n");
        qFatal("EGL error");
    }

    s_eglDisplay = eglGetDisplay(display);
    if (s_eglDisplay == EGL_NO_DISPLAY)
        qDebug() << "Could not open egl display\n";

    if (!eglInitialize(s_eglDisplay, &major, &minor))
        qDebug() << "Could not initialize egl display";

    int swapInterval = 1;
    QByteArray swapIntervalString = qgetenv("QT_QPA_EGLFS_SWAPINTERVAL");
    if (!swapIntervalString.isEmpty()) {
        bool ok;
        swapInterval = swapIntervalString.toInt(&ok);
        if (!ok)
            swapInterval = 1;
    }

    eglSwapInterval(s_eglDisplay, swapInterval);
}
Esempio n. 16
0
void CGroupClient::cutMessageFromBuffer()
{
	QByteArray rest;

	if (currentMessageLen == 0) {
		int index = buffer.indexOf(' ');

		if (index == -1) {
			print_debug(DEBUG_GROUP, "Incoming buffer contains broken message");
			// zap the buffer in this case, and hope for the best
			buffer.clear();
			return;
		}

		QByteArray len = buffer.left(index);
		currentMessageLen = len.toInt();
//		print_debug(DEBUG_GROUP, "Incoming buffer length: %i, incoming message length %i",
//				buffer.size(), currentMessageLen);

		rest = buffer.right( buffer.size() - index - 1);
		buffer = rest;

		if (buffer.size() == currentMessageLen)
			cutMessageFromBuffer();

		return;
	}

//	print_debug(DEBUG_GROUP, "cutting off one message case");
	getParent()->incomingData(this, buffer.left(currentMessageLen));
	rest = buffer.right( buffer.size() - currentMessageLen);
	buffer = rest;
	currentMessageLen = 0;
}
Esempio n. 17
0
void YouTube::resumeVideoUpload() {
    uploadRetries--;

    QByteArray rangeHeader = uploadReply->rawHeader("Range");
    QByteArray startByte = rangeHeader.split('-').last();
    QByteArray locationHeader = uploadReply->rawHeader("Location");

    //qDebug() << rangeHeader << startByte << locationHeader;

    if (locationHeader.length() > 0) {
        uploadUrl = QUrl(locationHeader);
    }

    fileToBeUploaded->open(QIODevice::ReadOnly);
    int fs = fileToBeUploaded->size();
    QByteArray fileSize = QByteArray::number(fs);
    QByteArray endByte = QByteArray::number(fs - 1);
    QByteArray range(startByte + '-' + endByte + '/' + fileSize);
    QNetworkRequest request(uploadUrl);
    request.setRawHeader("Host", "uploads.gdata.youtube.com");
    request.setHeader(QNetworkRequest::ContentTypeHeader, "application/octet-stream");
    request.setHeader(QNetworkRequest::ContentLengthHeader, fs - startByte.toInt());
    request.setRawHeader("Content-Range", range);
    uploadReply = nam->put(request, fileToBeUploaded);
    connect(uploadReply, SIGNAL(uploadProgress(qint64,qint64)), this, SIGNAL(updateUploadProgress(qint64,qint64)));
    connect(uploadReply, SIGNAL(finished()), this, SLOT(uploadFinished()));
    emit uploadStatusChanged("started");
}
Esempio n. 18
0
/* ========================================================================== */
QVariant LispPlugin::read_from(QVariantList& tokenz) {
    if (tokenz.isEmpty())
        throw runtime_error("unexpected EOF while reading");

    QByteArray token = tokenz.takeFirst().toByteArray();
    if (token == "(") {
        //auto L = QVariant(QVariant::List);
        QVariantList L;
        while (tokenz[0] != ")")
            L.append(read_from(tokenz));
        tokenz.takeFirst(); // pop off )
        return L;
    } else if (token == ")") {
        throw std::runtime_error("enexcepted )");
    } else {
        bool successCast;

        auto i = token.toInt(&successCast);
        if (successCast) return i;

        auto d = token.toDouble(&successCast);
        if (successCast) return d;

        return QString(token);
    }
}
Esempio n. 19
0
static int getIntegerValue(const QString& path)
{
    QByteArray data = getByteArray(path);
    if (data.size())
	return data.toInt();
    return 0;
}
Esempio n. 20
0
void QMinimalEglScreen::createAndSetPlatformContext()
{
    QSurfaceFormat platformFormat;

    QByteArray depthString = qgetenv("QT_QPA_EGLFS_DEPTH");
    if (depthString.toInt() == 16) {
        platformFormat.setDepthBufferSize(16);
        platformFormat.setRedBufferSize(5);
        platformFormat.setGreenBufferSize(6);
        platformFormat.setBlueBufferSize(5);
        m_depth = 16;
        m_format = QImage::Format_RGB16;
    } else {
        platformFormat.setDepthBufferSize(24);
        platformFormat.setStencilBufferSize(8);
        platformFormat.setRedBufferSize(8);
        platformFormat.setGreenBufferSize(8);
        platformFormat.setBlueBufferSize(8);
        m_depth = 32;
        m_format = QImage::Format_RGB32;
    }

    if (!qEnvironmentVariableIsEmpty("QT_QPA_EGLFS_MULTISAMPLE"))
        platformFormat.setSamples(4);

    EGLConfig config = q_configFromGLFormat(m_dpy, platformFormat);

    EGLNativeWindowType eglWindow = 0;
#ifdef Q_OPENKODE
    if (kdInitializeNV() == KD_ENOTINITIALIZED) {
        qFatal("Did not manage to initialize openkode");
    }
    KDWindow *window = kdCreateWindow(m_dpy,config,0);

    kdRealizeWindow(window,&eglWindow);
#endif

#ifdef QEGL_EXTRA_DEBUG
    q_printEglConfig(m_dpy, config);
#endif

    m_surface = eglCreateWindowSurface(m_dpy, config, eglWindow, NULL);
    if (m_surface == EGL_NO_SURFACE) {
        qWarning("Could not create the egl surface: error = 0x%x\n", eglGetError());
        eglTerminate(m_dpy);
        qFatal("EGL error");
    }
    //    qWarning("Created surface %dx%d\n", w, h);

    QEGLPlatformContext *platformContext = new QMinimalEglContext(platformFormat, 0, m_dpy);
    m_platformContext = platformContext;

    EGLint w,h;                    // screen size detection
    eglQuerySurface(m_dpy, m_surface, EGL_WIDTH, &w);
    eglQuerySurface(m_dpy, m_surface, EGL_HEIGHT, &h);

    m_geometry = QRect(0,0,w,h);

}
Esempio n. 21
0
static int thumbnailerMaxCost()
{
    const QByteArray costEnv = qgetenv("NEMO_THUMBNAILER_CACHE_SIZE");

    bool ok = false;
    int cost = costEnv.toInt(&ok);
    return ok ? cost : 1360 * 768 * 3;
}
Esempio n. 22
0
static int get_env_int(const char *name, int defaultValue)
{
    QByteArray content = qgetenv(name);

    bool ok = false;
    int value = content.toInt(&ok);
    return ok ? value : defaultValue;
}
int byte2int (QByteArray num){
	bool ok;
	QByteArray tmp = num.mid(3,1).toHex().data();
	tmp.append(num.mid(2,1).toHex().data());
	tmp.append(num.mid(1,1).toHex().data());
	tmp.append(num.mid(0,1).toHex().data());
	return tmp.toInt(&ok,16);
}
static QEglContext *createContext(QPaintDevice *device)
{
    QEglContext *context;

    // Create the context object and open the display.
    context = new QEglContext();
    context->setApi(QEgl::OpenVG);
    if (!context->openDisplay(device)) {
        delete context;
        return 0;
    }

    // Set the swap interval for the display.
    QByteArray interval = qgetenv("QT_VG_SWAP_INTERVAL");
    if (!interval.isEmpty())
        eglSwapInterval(context->display(), interval.toInt());
    else
        eglSwapInterval(context->display(), 1);

    // Choose an appropriate configuration for rendering into the device.
    QEglProperties configProps;
    configProps.setPaintDeviceFormat(device);
    int redSize = configProps.value(EGL_RED_SIZE);
    if (redSize == EGL_DONT_CARE || redSize == 0)
        configProps.setPixelFormat(QImage::Format_ARGB32);  // XXX
#ifndef QVG_SCISSOR_CLIP
    // If we are using the mask to clip, then explicitly request a mask.
    configProps.setValue(EGL_ALPHA_MASK_SIZE, 1);
#endif
#ifdef EGL_VG_ALPHA_FORMAT_PRE_BIT
    configProps.setValue(EGL_SURFACE_TYPE, EGL_WINDOW_BIT | EGL_PBUFFER_BIT |
                         EGL_VG_ALPHA_FORMAT_PRE_BIT);
    configProps.setRenderableType(QEgl::OpenVG);
    if (!context->chooseConfig(configProps)) {
        // Try again without the "pre" bit.
        configProps.setValue(EGL_SURFACE_TYPE, EGL_WINDOW_BIT | EGL_PBUFFER_BIT);
        if (!context->chooseConfig(configProps)) {
            delete context;
            return 0;
        }
    }
#else
    configProps.setValue(EGL_SURFACE_TYPE, EGL_WINDOW_BIT | EGL_PBUFFER_BIT);
    configProps.setRenderableType(QEgl::OpenVG);
    if (!context->chooseConfig(configProps)) {
        delete context;
        return 0;
    }
#endif

    // Construct a new EGL context for the selected configuration.
    if (!context->createContext()) {
        delete context;
        return 0;
    }

    return context;
}
Esempio n. 25
0
void HTTPConnection::readHeaders() {
    while (_socket->canReadLine()) {
        QByteArray line = _socket->readLine();
        QByteArray trimmed = line.trimmed();
        if (trimmed.isEmpty()) {
            _socket->disconnect(this, SLOT(readHeaders()));

            QByteArray clength = requestHeader("Content-Length");
            if (clength.isEmpty()) {
                _parentManager->handleHTTPRequest(this, _requestUrl);

            } else {
                bool success = false;
                auto length = clength.toInt(&success);
                if (!success) {
                    qWarning() << "Invalid header." << _address << trimmed;
                    respond("400 Bad Request", "The header was malformed.");
                    return;
                }

                // Storing big requests in memory gets expensive, especially on servers
                // with limited memory. So we store big requests in a temporary file on disk
                // and map it to faster read/write access.
                static const int MAX_CONTENT_SIZE_IN_MEMORY = 10 * 1000 * 1000;
                if (length < MAX_CONTENT_SIZE_IN_MEMORY) {
                    _requestContent = MemoryStorage::make(length);
                } else {
                    _requestContent = FileStorage::make(length);
                }

                connect(_socket, SIGNAL(readyRead()), SLOT(readContent()));

                // read any content immediately available
                readContent();
            }
            return;
        }
        char first = line.at(0);
        if (first == ' ' || first == '\t') { // continuation
            _requestHeaders[_lastRequestHeader].append(trimmed);
            continue;
        }
        int idx = trimmed.indexOf(':');
        if (idx == -1) {
            qWarning() << "Invalid header." << _address << trimmed;
            respond("400 Bad Request", "The header was malformed.");
            return;
        }
        _lastRequestHeader = trimmed.left(idx).toLower();
        QByteArray& value = _requestHeaders[_lastRequestHeader];
        if (!value.isEmpty()) {
            value.append(", ");
        }
        value.append(trimmed.mid(idx + 1).trimmed());
    }
}
Esempio n. 26
0
bool Utility::fsCasePreserving()
{
#ifndef WITH_TESTING
    QByteArray env = qgetenv("OWNCLOUD_TEST_CASE_PRESERVING");
    if (!env.isEmpty())
        return env.toInt();
#endif

    return isWindows() || isMac();
}
Esempio n. 27
0
void PdbEngine::handleBreakInsert(const PdbResponse &response)
{
    //qDebug() << "BP RESPONSE: " << response.data;
    // "Breakpoint 1 at /pdb/math.py:10"
    BreakpointId id(response.cookie.toInt());
    BreakHandler *handler = breakHandler();
    QTC_ASSERT(response.data.startsWith("Breakpoint "), return);
    int pos1 = response.data.indexOf(" at ");
    QTC_ASSERT(pos1 != -1, return);
    QByteArray bpnr = response.data.mid(11, pos1 - 11);
    int pos2 = response.data.lastIndexOf(":");
    QByteArray file = response.data.mid(pos1 + 4, pos2 - pos1 - 4);
    QByteArray line = response.data.mid(pos2 + 1);
    BreakpointResponse br;
    br.number = bpnr.toInt();
    br.fileName = _(file);
    br.lineNumber = line.toInt();
    handler->setResponse(id, br);
}
Esempio n. 28
0
void gui::PacketFromData (packet & p,QByteArray * data)
{
	QVector <int> * poziceLomeno=new QVector <int> (0);
	int index=0;
	int pocatek=0;
	int flag=0;
	int options=0;
	QString receiver,sender ;
	QByteArray flagarray ,optionsarray ,receiverarray ,senderarray ,dataarray ;
	do
	{
	if (data->at (index)=='/')
	{
		poziceLomeno->append (index);
		index ++;
		index++;
	}
	else
	{
		index++;
	}
	}
	while (data->at (index)!='\0');
	for (int poziceVector=0;poziceVector<poziceLomeno->size ();poziceVector++)
	{
		int lomeno=poziceLomeno->at (poziceVector);
		switch (poziceVector)
		{
			case 0:
			flagarray.append (data->left (lomeno));
			p.flag=flagarray.toInt ();
			pocatek=lomeno+2;
			break;
			case 1:
			dataarray.append (data->mid (pocatek,lomeno-pocatek));
		
			p.data.append (dataarray);
			pocatek=lomeno+2;
				break;
			case 2:
			receiver.append (data->mid (pocatek,lomeno-pocatek));
			p.receiver.append (receiver);
			pocatek=lomeno+2;
			break;
			case 3:
			sender.append (data->mid (pocatek,lomeno-pocatek));
			p.sender.append (sender);
			pocatek=lomeno+2;
			optionsarray.append (data->at (data->size ()-1));
				p.options=optionsarray.toInt ();
				break;
			break;
		}
	}
}
Esempio n. 29
0
int KGameRenderer::frameCount(const QString& key) const
{
	//ensure that some theme is loaded
	if (!d->m_currentTheme)
	{
		d->_k_setTheme(d->m_provider->currentTheme());
	}
	//look up in in-process cache
	QHash<QString, int>::const_iterator it = d->m_frameCountCache.constFind(key);
	if (it != d->m_frameCountCache.constEnd())
	{
		return it.value();
	}
	//look up in shared cache (if SVG is not yet loaded)
	int count = -1;
	bool countFound = false;
	const QString cacheKey = d->m_frameCountPrefix + key;
	if (d->m_rendererPool.hasAvailableRenderers() && (d->m_strategies & KGameRenderer::UseDiskCache))
	{
		QByteArray buffer;
		if (d->m_imageCache->find(cacheKey, &buffer))
		{
			count = buffer.toInt();
			countFound = true;
		}
	}
	//determine from SVG
	if (!countFound)
	{
		QSvgRenderer* renderer = d->m_rendererPool.allocRenderer();
		//look for animated sprite first
		count = d->m_frameBaseIndex;
		while (renderer->elementExists(d->spriteFrameKey(key, count, false)))
		{
			++count;
		}
		count -= d->m_frameBaseIndex;
		//look for non-animated sprite instead
		if (count == 0)
		{
			if (!renderer->elementExists(key))
			{
				count = -1;
			}
		}
		d->m_rendererPool.freeRenderer(renderer);
		//save in shared cache for following requests
		if (d->m_strategies & KGameRenderer::UseDiskCache)
		{
			d->m_imageCache->insert(cacheKey, QByteArray::number(count));
		}
	}
	d->m_frameCountCache.insert(key, count);
	return count;
}
Esempio n. 30
0
void Moc::parseSignals(ClassDef *def)
{
    int defaultRevision = -1;
    if (test(Q_REVISION_TOKEN)) {
        next(LPAREN);
        QByteArray revision = lexemUntil(RPAREN);
        revision.remove(0, 1);
        revision.chop(1);
        bool ok = false;
        defaultRevision = revision.toInt(&ok);
        if (!ok || defaultRevision < 0)
            error("Invalid revision");
    }

    next(COLON);
    while (inClass(def) && hasNext()) {
        switch (next()) {
        case PUBLIC:
        case PROTECTED:
        case PRIVATE:
        case Q_SIGNALS_TOKEN:
        case Q_SLOTS_TOKEN:
            prev();
            return;
        case SEMIC:
            continue;
        case FRIEND:
            until(SEMIC);
            continue;
        case USING:
            error("'using' directive not supported in 'signals' section");
        default:
            prev();
        }
        FunctionDef funcDef;
        funcDef.access = FunctionDef::Protected;
        parseFunction(&funcDef);
        if (funcDef.isVirtual)
            warning("Signals cannot be declared virtual");
        if (funcDef.inlineCode)
            error("Not a signal declaration");
        if (funcDef.revision > 0) {
            ++def->revisionedMethods;
        } else if (defaultRevision != -1) {
            funcDef.revision = defaultRevision;
            ++def->revisionedMethods;
        }
        def->signalList += funcDef;
        while (funcDef.arguments.size() > 0 && funcDef.arguments.last().isDefault) {
            funcDef.wasCloned = true;
            funcDef.arguments.removeLast();
            def->signalList += funcDef;
        }
    }
}