void ChooseDialog::ok() { qWarning( "ChooseDialog::ok(): Not implemented yet" ); }
int runRcc(int argc, char *argv[]) { QString outFilename; bool helpRequested = false; bool list = false; bool projectRequested = false; QStringList filenamesIn; QStringList args = qCmdLineArgs(argc, argv); RCCResourceLibrary library; //parse options QString errorMsg; for (int i = 1; i < args.count() && errorMsg.isEmpty(); i++) { if (args[i].isEmpty()) continue; if (args[i][0] == QLatin1Char('-')) { // option QString opt = args[i]; if (opt == QLatin1String("-o")) { if (!(i < argc-1)) { errorMsg = QLatin1String("Missing output name"); break; } outFilename = args[++i]; } else if (opt == QLatin1String("-name")) { if (!(i < argc-1)) { errorMsg = QLatin1String("Missing target name"); break; } library.setInitName(args[++i]); } else if (opt == QLatin1String("-root")) { if (!(i < argc-1)) { errorMsg = QLatin1String("Missing root path"); break; } library.setResourceRoot(QDir::cleanPath(args[++i])); if (library.resourceRoot().isEmpty() || library.resourceRoot().at(0) != QLatin1Char('/')) errorMsg = QLatin1String("Root must start with a /"); } else if (opt == QLatin1String("-compress")) { if (!(i < argc-1)) { errorMsg = QLatin1String("Missing compression level"); break; } library.setCompressLevel(args[++i].toInt()); } else if (opt == QLatin1String("-threshold")) { if (!(i < argc-1)) { errorMsg = QLatin1String("Missing compression threshold"); break; } library.setCompressThreshold(args[++i].toInt()); } else if (opt == QLatin1String("-binary")) { library.setFormat(RCCResourceLibrary::Binary); } else if (opt == QLatin1String("-namespace")) { library.setUseNameSpace(!library.useNameSpace()); } else if (opt == QLatin1String("-verbose")) { library.setVerbose(true); } else if (opt == QLatin1String("-list")) { list = true; } else if (opt == QLatin1String("-version") || opt == QLatin1String("-v")) { fprintf(stderr, "Qt Resource Compiler version %s\n", QT_VERSION_STR); return 1; } else if (opt == QLatin1String("-help") || opt == QLatin1String("-h")) { helpRequested = true; } else if (opt == QLatin1String("-no-compress")) { library.setCompressLevel(-2); } else if (opt == QLatin1String("-project")) { projectRequested = true; } else { errorMsg = QString::fromLatin1("Unknown option: '%1'").arg(args[i]); } } else { if (!QFile::exists(args[i])) { qWarning("%s: File does not exist '%s'", qPrintable(args[0]), qPrintable(args[i])); return 1; } filenamesIn.append(args[i]); } } if (projectRequested && !helpRequested) { return createProject(outFilename); } if (!filenamesIn.size() || !errorMsg.isEmpty() || helpRequested) { showHelp(args[0], errorMsg); return 1; } QFile errorDevice; errorDevice.open(stderr, QIODevice::WriteOnly|QIODevice::Text); if (library.verbose()) errorDevice.write("Qt resource compiler\n"); library.setInputFiles(filenamesIn); if (!library.readFiles(list, errorDevice)) return 1; // open output QFile out; QIODevice::OpenMode mode = QIODevice::WriteOnly; if (library.format() == RCCResourceLibrary::C_Code) mode |= QIODevice::Text; if (outFilename.isEmpty() || outFilename == QLatin1String("-")) { // using this overload close() only flushes. out.open(stdout, mode); } else { out.setFileName(outFilename); if (!out.open(mode)) { const QString msg = QString::fromUtf8("Unable to open %1 for writing: %2\n").arg(outFilename).arg(out.errorString()); errorDevice.write(msg.toUtf8()); return 1; } } // do the task if (list) { const QStringList data = library.dataFiles(); for (int i = 0; i < data.size(); ++i) { out.write(qPrintable(QDir::cleanPath(data.at(i)))); out.write("\n"); } return 0; } return library.output(out, errorDevice) ? 0 : 1; }
void InstrumentTrack::processInEvent( const MidiEvent& event, const MidiTime& time, f_cnt_t offset ) { if( Engine::getSong()->isExporting() ) { return; } bool eventHandled = false; switch( event.type() ) { // we don't send MidiNoteOn, MidiNoteOff and MidiKeyPressure // events to instrument as NotePlayHandle will send them on its // own case MidiNoteOn: if( event.velocity() > 0 ) { if( m_notes[event.key()] == NULL ) { NotePlayHandle* nph = NotePlayHandleManager::acquire( this, offset, typeInfo<f_cnt_t>::max() / 2, Note( MidiTime(), MidiTime(), event.key(), event.volume( midiPort()->baseVelocity() ) ), NULL, event.channel(), NotePlayHandle::OriginMidiInput ); m_notes[event.key()] = nph; if( ! Engine::mixer()->addPlayHandle( nph ) ) { m_notes[event.key()] = NULL; } } eventHandled = true; break; } case MidiNoteOff: if( m_notes[event.key()] != NULL ) { // do actual note off and remove internal reference to NotePlayHandle (which itself will // be deleted later automatically) Engine::mixer()->requestChangeInModel(); m_notes[event.key()]->noteOff( offset ); if (isSustainPedalPressed() && m_notes[event.key()]->origin() == m_notes[event.key()]->OriginMidiInput) { m_sustainedNotes << m_notes[event.key()]; } m_notes[event.key()] = NULL; Engine::mixer()->doneChangeInModel(); } eventHandled = true; break; case MidiKeyPressure: if( m_notes[event.key()] != NULL ) { // setVolume() calls processOutEvent() with MidiKeyPressure so the // attached instrument will receive the event as well m_notes[event.key()]->setVolume( event.volume( midiPort()->baseVelocity() ) ); } eventHandled = true; break; case MidiPitchBend: // updatePitch() is connected to m_pitchModel::dataChanged() which will send out // MidiPitchBend events m_pitchModel.setValue( m_pitchModel.minValue() + event.pitchBend() * m_pitchModel.range() / MidiMaxPitchBend ); break; case MidiControlChange: if( event.controllerNumber() == MidiControllerSustain ) { if( event.controllerValue() > MidiMaxControllerValue/2 ) { m_sustainPedalPressed = true; } else if (isSustainPedalPressed()) { for (NotePlayHandle* nph : m_sustainedNotes) { if (nph && nph->isReleased()) { if( nph->origin() == nph->OriginMidiInput) { nph->setLength( MidiTime( static_cast<f_cnt_t>( nph->totalFramesPlayed() / Engine::framesPerTick() ) ) ); midiNoteOff( *nph ); } } } m_sustainedNotes.clear(); m_sustainPedalPressed = false; } } if( event.controllerNumber() == MidiControllerAllSoundOff || event.controllerNumber() == MidiControllerAllNotesOff || event.controllerNumber() == MidiControllerOmniOn || event.controllerNumber() == MidiControllerOmniOff || event.controllerNumber() == MidiControllerMonoOn || event.controllerNumber() == MidiControllerPolyOn ) { silenceAllNotes(); } break; case MidiMetaEvent: // handle special cases such as note panning switch( event.metaEvent() ) { case MidiNotePanning: if( m_notes[event.key()] != NULL ) { eventHandled = true; m_notes[event.key()]->setPanning( event.panning() ); } break; default: qWarning( "InstrumentTrack: unhandled MIDI meta event: %i", event.metaEvent() ); break; } break; default: break; } if( eventHandled == false && instrument()->handleMidiEvent( event, time, offset ) == false ) { qWarning( "InstrumentTrack: unhandled MIDI event %d", event.type() ); } }
void DBusConnection::dbusError(const QDBusError &error) { qWarning() << "Accessibility encountered a DBus error:" << error; }
bool QFile::copy(const QString &newName) { Q_D(QFile); if (d->fileName.isEmpty()) { qWarning("QFile::copy: Empty or null file name"); return false; } if (QFile(newName).exists()) { // ### Race condition. If a file is moved in after this, it /will/ be // overwritten. On Unix, the proper solution is to use hardlinks: // return ::link(old, new) && ::remove(old); See also rename(). d->setError(QFile::CopyError, tr("Destination file exists")); return false; } unsetError(); close(); if(error() == QFile::NoError) { if (d->engine()->copy(newName)) { unsetError(); return true; } else { bool error = false; if(!open(QFile::ReadOnly)) { error = true; d->setError(QFile::CopyError, tr("Cannot open %1 for input").arg(d->fileName)); } else { QString fileTemplate = QLatin1String("%1/qt_temp.XXXXXX"); #ifdef QT_NO_TEMPORARYFILE QFile out(fileTemplate.arg(QFileInfo(newName).path())); if (!out.open(QIODevice::ReadWrite)) error = true; #else QTemporaryFile out(fileTemplate.arg(QFileInfo(newName).path())); if (!out.open()) { out.setFileTemplate(fileTemplate.arg(QDir::tempPath())); if (!out.open()) error = true; } #endif if (error) { out.close(); close(); d->setError(QFile::CopyError, tr("Cannot open for output")); } else { char block[4096]; qint64 totalRead = 0; while(!atEnd()) { qint64 in = read(block, sizeof(block)); if (in <= 0) break; totalRead += in; if(in != out.write(block, in)) { close(); d->setError(QFile::CopyError, tr("Failure to write block")); error = true; break; } } if (totalRead != size()) { // Unable to read from the source. The error string is // already set from read(). error = true; } if (!error && !out.rename(newName)) { error = true; close(); d->setError(QFile::CopyError, tr("Cannot create %1 for output").arg(newName)); } #ifdef QT_NO_TEMPORARYFILE if (error) out.remove(); #else if (!error) out.setAutoRemove(false); #endif } } if(!error) { QFile::setPermissions(newName, permissions()); close(); unsetError(); return true; } } } return false; }
QList<QNetworkProxy> macQueryInternal(const QNetworkProxyQuery &query) { QList<QNetworkProxy> result; // obtain a dictionary to the proxy settings: CFDictionaryRef dict = SCDynamicStoreCopyProxies(NULL); if (!dict) { qWarning("QNetworkProxyFactory::systemProxyForQuery: SCDynamicStoreCopyProxies returned NULL"); return result; // failed } if (isHostExcluded(dict, query.peerHostName())) { CFRelease(dict); return result; // no proxy for this host } // is there a PAC enabled? If so, use it first. CFNumberRef pacEnabled; if ((pacEnabled = (CFNumberRef)CFDictionaryGetValue(dict, kSCPropNetProxiesProxyAutoConfigEnable))) { int enabled; if (CFNumberGetValue(pacEnabled, kCFNumberIntType, &enabled) && enabled) { // PAC is enabled CFStringRef pacUrl = (CFStringRef)CFDictionaryGetValue(dict, kSCPropNetProxiesProxyAutoConfigURLString); QString url = QCFString::toQString(pacUrl); // ### TODO: Use PAC somehow } } // no PAC, decide which proxy we're looking for based on the query bool isHttps = false; QString protocol = query.protocolTag().toLower(); // try the protocol-specific proxy QNetworkProxy protocolSpecificProxy; if (protocol == QLatin1String("ftp")) { protocolSpecificProxy = proxyFromDictionary(dict, QNetworkProxy::FtpCachingProxy, kSCPropNetProxiesFTPEnable, kSCPropNetProxiesFTPProxy, kSCPropNetProxiesFTPPort); } else if (protocol == QLatin1String("http")) { protocolSpecificProxy = proxyFromDictionary(dict, QNetworkProxy::HttpProxy, kSCPropNetProxiesHTTPEnable, kSCPropNetProxiesHTTPProxy, kSCPropNetProxiesHTTPPort); } else if (protocol == QLatin1String("https")) { isHttps = true; protocolSpecificProxy = proxyFromDictionary(dict, QNetworkProxy::HttpProxy, kSCPropNetProxiesHTTPSEnable, kSCPropNetProxiesHTTPSProxy, kSCPropNetProxiesHTTPSPort); } if (protocolSpecificProxy.type() != QNetworkProxy::DefaultProxy) result << protocolSpecificProxy; // let's add SOCKSv5 if present too QNetworkProxy socks5 = proxyFromDictionary(dict, QNetworkProxy::Socks5Proxy, kSCPropNetProxiesSOCKSEnable, kSCPropNetProxiesSOCKSProxy, kSCPropNetProxiesSOCKSPort); if (socks5.type() != QNetworkProxy::DefaultProxy) result << socks5; // let's add the HTTPS proxy if present (and if we haven't added // yet) if (!isHttps) { QNetworkProxy https = proxyFromDictionary(dict, QNetworkProxy::HttpProxy, kSCPropNetProxiesHTTPSEnable, kSCPropNetProxiesHTTPSProxy, kSCPropNetProxiesHTTPSPort); if (https.type() != QNetworkProxy::DefaultProxy && https != protocolSpecificProxy) result << https; } CFRelease(dict); return result; }
void TrackDashboard::onArtistGotInfo( WsReply* reply ) { ui.spinner->hide(); ui.similarArtists->clear(); QString css = "<style>" "body{padding:0;margin:0;color:#bbb;}" "#stats{color:#444444;margin:0;line-height:1.3;font-weight:bold}" "#extended{display:none;}" "p{line-height:1.6em}" "h1 a{color:#fff;margin:0 0 2px 0}" "h1 a:hover{text-decoration:underline}" "a{color:#00aeef;text-decoration:none}" "a:hover{text-decoration:underline}" "body{font-size:11px}" "h1{font-size:18px}" #ifdef Q_WS_MAC "body{font-family:Lucida Grande}" #endif "</style>"; QTextStream html( &css, QIODevice::Append ); try { WsDomElement e = reply->lfm()["artist"]; QString name = e["name"].text(); QString url = e["url"].text(); uint plays = e["stats"]["playcount"].text().toUInt(); uint listeners = e["stats"]["listeners"].text().toUInt(); QString content = e["bio"]["content"].text(); QString editmessage = tr("Edit it too!"); html << "<h1><a href=\"" << url << "\">" << name << "</a></h1>" << "<p id=stats>" << tr( "%L1 listeners" ).arg( listeners ) << "<br>" << tr( "%L1 plays" ).arg( plays ); if (content.isEmpty()) { // this should be all one tr, but meh. html << "<p>" << tr("We don't have a description for this artist yet.") << "<p><a href='" << url << "/+wiki/edit'>" << tr("Why not write one?") << "</a>"; } else { QStringList bio = formatBio( content ); html << "<span id=content>" << bio.at( 0 ) << "</span>" << "<p id=editme style='margin-top:0'>" << tr("This information was created by users like you! ") << "<a href=\"" << url << "/wiki/edit" << "\">" << editmessage << "</a>" << "<button onclick=\"toggleMoreInfo();\">More..</button>"; } foreach (WsDomElement artist, e["similar"].children( "artist" )) ui.similarArtists->addItem( artist["name"].text() ); } catch (std::runtime_error& e) { qWarning() << e.what(); html << "<h1>" << m_track.artist() << "</h1>" << "<p>" << tr( "Unable to contact Last.fm.<br>Your scrobbles are being cached." ); } ui.bio->setHtml( *html.string() ); resizeEvent( 0 ); ui.info->show(); }
static KLockFile::LockResult deleteStaleLock(const QString &lockFile, KDE_struct_stat &st_buf, bool &linkCountSupport, const KComponentData &componentData) { // This is dangerous, we could be deleting a new lock instead of // the old stale one, let's be very careful // Create temp file KTemporaryFile *ktmpFile = new KTemporaryFile(componentData); ktmpFile->setFileTemplate(lockFile); if (!ktmpFile->open()) return KLockFile::LockError; QByteArray lckFile = QFile::encodeName(lockFile); QByteArray tmpFile = QFile::encodeName(ktmpFile->fileName()); delete ktmpFile; // link to lock file if (::link(lckFile, tmpFile) != 0) return KLockFile::LockFail; // Try again later // check if link count increased with exactly one // and if the lock file still matches KDE_struct_stat st_buf1; KDE_struct_stat st_buf2; memcpy(&st_buf1, &st_buf, sizeof(KDE_struct_stat)); st_buf1.st_nlink++; if ((KDE_lstat(tmpFile, &st_buf2) == 0) && st_buf1 == st_buf2) { if ((KDE_lstat(lckFile, &st_buf2) == 0) && st_buf1 == st_buf2) { // - - if yes, delete lock file, delete temp file, retry lock qWarning("WARNING: deleting stale lockfile %s", lckFile.data()); ::unlink(lckFile); ::unlink(tmpFile); return KLockFile::LockOK; } } // SMBFS supports hardlinks by copying the file, as a result the above test will always fail if (linkCountSupport) { linkCountSupport = testLinkCountSupport(tmpFile); } if (!linkCountSupport) { // Without support for link counts we will have a little race condition qWarning("WARNING: deleting stale lockfile %s", lckFile.data()); ::unlink(tmpFile); if (::unlink(lckFile) < 0) { qWarning("WARNING: Problem deleting stale lockfile %s: %s", lckFile.data(), strerror(errno)); return KLockFile::LockFail; } return KLockFile::LockOK; } // Failed to delete stale lock file qWarning("WARNING: Problem deleting stale lockfile %s", lckFile.data()); ::unlink(tmpFile); return KLockFile::LockFail; }
bool QGLContext::chooseContext( const QGLContext* shareContext ) { Display* disp = d->paintDevice->x11Display(); vi = chooseVisual(); if ( !vi ) return FALSE; if ( deviceIsPixmap() && (((XVisualInfo*)vi)->depth != d->paintDevice->x11Depth() || ((XVisualInfo*)vi)->screen != d->paintDevice->x11Screen()) ) { XFree( vi ); XVisualInfo appVisInfo; memset( &appVisInfo, 0, sizeof(XVisualInfo) ); appVisInfo.visualid = XVisualIDFromVisual( (Visual*)d->paintDevice->x11Visual() ); appVisInfo.screen = d->paintDevice->x11Screen(); int nvis; vi = XGetVisualInfo( disp, VisualIDMask | VisualScreenMask, &appVisInfo, &nvis ); if ( !vi ) return FALSE; int useGL; glXGetConfig( disp, (XVisualInfo*)vi, GLX_USE_GL, &useGL ); if ( !useGL ) return FALSE; //# Chickening out already... } int res; glXGetConfig( disp, (XVisualInfo*)vi, GLX_LEVEL, &res ); glFormat.setPlane( res ); glXGetConfig( disp, (XVisualInfo*)vi, GLX_DOUBLEBUFFER, &res ); glFormat.setDoubleBuffer( res ); glXGetConfig( disp, (XVisualInfo*)vi, GLX_DEPTH_SIZE, &res ); glFormat.setDepth( res ); glXGetConfig( disp, (XVisualInfo*)vi, GLX_RGBA, &res ); glFormat.setRgba( res ); glXGetConfig( disp, (XVisualInfo*)vi, GLX_ALPHA_SIZE, &res ); glFormat.setAlpha( res ); glXGetConfig( disp, (XVisualInfo*)vi, GLX_ACCUM_RED_SIZE, &res ); glFormat.setAccum( res ); glXGetConfig( disp, (XVisualInfo*)vi, GLX_STENCIL_SIZE, &res ); glFormat.setStencil( res ); glXGetConfig( disp, (XVisualInfo*)vi, GLX_STEREO, &res ); glFormat.setStereo( res ); Bool direct = format().directRendering() ? True : False; if ( shareContext && ( !shareContext->isValid() || !shareContext->cx ) ) { #if defined(QT_CHECK_NULL) qWarning("QGLContext::chooseContext(): Cannot share with invalid context"); #endif shareContext = 0; } // 1. Sharing between rgba and color-index will give wrong colors. // 2. Contexts cannot be shared btw. direct/non-direct renderers. // 3. Pixmaps cannot share contexts that are set up for direct rendering. if ( shareContext && (format().rgba() != shareContext->format().rgba() || (deviceIsPixmap() && glXIsDirect( disp, (GLXContext)shareContext->cx )))) shareContext = 0; cx = 0; if ( shareContext ) { cx = glXCreateContext( disp, (XVisualInfo *)vi, (GLXContext)shareContext->cx, direct ); if ( cx ) d->sharing = TRUE; } if ( !cx ) cx = glXCreateContext( disp, (XVisualInfo *)vi, None, direct ); if ( !cx ) return FALSE; glFormat.setDirectRendering( glXIsDirect( disp, (GLXContext)cx ) ); if ( deviceIsPixmap() ) { #if defined(GLX_MESA_pixmap_colormap) && defined(QGL_USE_MESA_EXT) gpm = glXCreateGLXPixmapMESA( disp, (XVisualInfo *)vi, d->paintDevice->handle(), choose_cmap( disp, (XVisualInfo *)vi ) ); #else gpm = (Q_UINT32)glXCreateGLXPixmap( disp, (XVisualInfo *)vi, d->paintDevice->handle() ); #endif if ( !gpm ) return FALSE; } return TRUE; }
/** * Install a package given from a QIODevice */ KissReturn KissArchive::install(QIODevice* in) { QStringList files; QStringList dirs; // Reads the file's "magic" to make sure we have a Kiss Archive char magic[2]; in->read(magic, 2); if(magic[0] != kissMagic[0] || magic[1] != kissMagic[1]) { qWarning() << "Bad Magic"; return KissReturn(true, QObject::tr("Bad Magic. Probably not a KISS Archive")); } // Read platforms, halt if current platform not detected unsigned numPlatforms = 0; in->read((char*)&numPlatforms, sizeof(unsigned)); bool match = false; for(unsigned i = 0; i < numPlatforms; ++i) { if(QString(in->read(3).data()) == OS_NAME) { match = true; } } if(!match) { qWarning() << "Incorrect OS"; return KissReturn(true, QObject::tr("This OS is not supported by the archive")); } // Checks the Kiss Archive Specification version, so we know how to extract unsigned version = 0; in->read((char*)&version, sizeof(unsigned)); if(kissVersion != version) { return KissReturn(true, QObject::tr("Version mismatch. Expected: ") + kissVersion + QObject::tr(", got ") + version); } // Reads archive name and internal version unsigned nameSize = 0; in->read((char*)&nameSize, sizeof(unsigned)); QString name(in->read(nameSize).data()); unsigned pVersion = 0; in->read((char*)&pVersion, sizeof(unsigned)); if(KissArchive::version(name) >= pVersion) { qWarning() << "Higher version already installed. Skipping."; return KissReturn(true, QObject::tr("Higher version of same archive already installed")); } else if(KissArchive::version(name) < pVersion) { uninstall(name); } // Recursively extract files and dirs unsigned numFiles = 0; in->read((char*)&numFiles, sizeof(unsigned)); for(unsigned i = 0; i < numFiles; ++i) { unsigned strLength = 0; in->read((char*)&strLength, sizeof(unsigned)); QString str = QString(in->read(strLength).data()); files << str; unsigned dataLength = 0; in->read((char*)&dataLength, sizeof(unsigned)); const QByteArray& data = qUncompress(in->read(dataLength)); if(str.isEmpty()) continue; QFile f(str); const QString& filePath = QFileInfo(str).path(); QDir dir; if(!dir.exists(filePath)) { dir.mkpath(filePath); dirs.prepend(filePath); } if(!f.open(QIODevice::WriteOnly)) { qWarning() << "Unable to open" << str << "for writing."; } f.write(data); } qWarning() << files; QSettings installed(KISS_ARCHIVE_FILE, QSettings::IniFormat); installed.setValue(name + INSTALLED_VERSION_STRING, pVersion); installed.setValue(name + INSTALLED_FILES_STRING, files); installed.setValue(name + INSTALLED_DIRS_STRING, dirs); installed.sync(); return KissReturn(false); }
Widget::Widget() : QWidget(), m_label(new QLabel) { setLayout(new QVBoxLayout); layout()->addWidget(m_label); setWindowFlags(Qt::WindowStaysOnTopHint | Qt::X11BypassWindowManagerHint | Qt::WindowDoesNotAcceptFocus | Qt::Tool); setAttribute(Qt::WA_TranslucentBackground); m_label->setTextInteractionFlags(Qt::TextSelectableByKeyboard); m_label->setTextFormat(Qt::PlainText); m_label->setWordWrap(true); layout()->setMargin(0); setMaximumWidth(1000); setMaximumHeight(1000); setMinimumWidth(500); setMinimumHeight(128); m_label->setAlignment(Qt::AlignLeft | Qt::AlignTop); m_label->setMargin(5); QFont font; font.setPixelSize(15); setFont(font); //connect(qApp->clipboard(), &QClipboard::dataChanged, this, &Widget::onClipboardUpdated); connect(qApp->clipboard(), &QClipboard::dataChanged, &m_updateTimer, [=]() { m_updateTimer.start(10); }); connect(&m_updateTimer, &QTimer::timeout, this, &Widget::onClipboardUpdated); m_updateTimer.setSingleShot(true); m_timer.setSingleShot(true); connect(&m_timer, &QTimer::timeout, this, &QWidget::hide); QString stylesheet( "QLabel {\n" " border: 3px solid white;\n" " background-color: rgba(0, 0, 0, 128);\n" " selection-color: black;\n" " selection-background-color: white;\n" "}\n" ); const QString configLocation = QStandardPaths::writableLocation(QStandardPaths::AppConfigLocation); QDir configDir(configLocation); if (!configDir.exists()) { configDir.mkpath(configLocation); } QString stylePath = configDir.absoluteFilePath("pastenotifier.qss"); QFile styleFile(stylePath); if (styleFile.exists()) { if (styleFile.open(QIODevice::ReadOnly)) { qDebug() << "Loading stylesheet" << stylePath; stylesheet = QString::fromLocal8Bit(styleFile.readAll()); } else { qWarning() << "Unable to open qss file:" << stylePath << styleFile.errorString(); } } else { if (styleFile.open(QIODevice::WriteOnly)) { styleFile.write(stylesheet.toUtf8()); } else { qWarning() << "Unable to open qss file for writing:" << stylePath << styleFile.errorString(); } } QAction *showAction = new QAction(this); connect(showAction, &QAction::triggered, [=](){ setWindowOpacity(1); show(); m_timer.start(5000); }); showAction->setObjectName("showpastenotifier"); KGlobalAccel::setGlobalShortcut(showAction, QKeySequence(Qt::CTRL + Qt::ALT + Qt::Key_V)); setStyleSheet(stylesheet); onClipboardUpdated(); }
bool QtLockedFile::lock(LockMode mode, bool block) { if (!isOpen()) { qWarning("QtLockedFile::lock(): file is not opened"); return false; } if (mode == m_lock_mode) return true; if (m_lock_mode != 0) unlock(); if (m_semaphore_hnd == 0) { QFileInfo fi(*this); QString sem_name = QString::fromLatin1(SEMAPHORE_PREFIX) + fi.absoluteFilePath().toLower(); m_semaphore_hnd = CreateSemaphoreW(0, SEMAPHORE_MAX, SEMAPHORE_MAX, (TCHAR*)sem_name.utf16()); if (m_semaphore_hnd == 0) { qWarning("QtLockedFile::lock(): CreateSemaphore: %s", errorCodeToString(GetLastError()).toLatin1().constData()); return false; } } bool gotMutex = false; int decrement; if (mode == ReadLock) { decrement = 1; } else { decrement = SEMAPHORE_MAX; if (m_mutex_hnd == 0) { QFileInfo fi(*this); QString mut_name = QString::fromLatin1(MUTEX_PREFIX) + fi.absoluteFilePath().toLower(); m_mutex_hnd = CreateMutexW(NULL, FALSE, (TCHAR*)mut_name.utf16()); if (m_mutex_hnd == 0) { qWarning("QtLockedFile::lock(): CreateMutex: %s", errorCodeToString(GetLastError()).toLatin1().constData()); return false; } } DWORD res = WaitForSingleObject(m_mutex_hnd, block ? INFINITE : 0); if (res == WAIT_TIMEOUT) return false; if (res == WAIT_FAILED) { qWarning("QtLockedFile::lock(): WaitForSingleObject (mutex): %s", errorCodeToString(GetLastError()).toLatin1().constData()); return false; } gotMutex = true; } for (int i = 0; i < decrement; ++i) { DWORD res = WaitForSingleObject(m_semaphore_hnd, block ? INFINITE : 0); if (res == WAIT_TIMEOUT) { if (i) { // A failed nonblocking rw locking. Undo changes to semaphore. if (ReleaseSemaphore(m_semaphore_hnd, i, NULL) == 0) { qWarning("QtLockedFile::unlock(): ReleaseSemaphore: %s", errorCodeToString(GetLastError()).toLatin1().constData()); // Fall through } } if (gotMutex) ReleaseMutex(m_mutex_hnd); return false; } if (res != WAIT_OBJECT_0) { if (gotMutex) ReleaseMutex(m_mutex_hnd); qWarning("QtLockedFile::lock(): WaitForSingleObject (semaphore): %s", errorCodeToString(GetLastError()).toLatin1().constData()); return false; } } m_lock_mode = mode; if (gotMutex) ReleaseMutex(m_mutex_hnd); return true; }
static void parse( MetaTranslator *tor, const char *initialContext, const char *defaultContext ) { QMap<QCString, QCString> qualifiedContexts; QStringList namespaces; QCString context; QCString text; QCString com; QCString functionContext = initialContext; QCString prefix; bool utf8 = FALSE; bool missing_Q_OBJECT = FALSE; yyTok = getToken(); while ( yyTok != Tok_Eof ) { switch ( yyTok ) { case Tok_class: /* Partial support for inlined functions. */ yyTok = getToken(); if ( yyBraceDepth == (int) namespaces.count() && yyParenDepth == 0 ) { do { /* This code should execute only once, but we play safe with impure definitions such as 'class Q_EXPORT QMessageBox', in which case 'QMessageBox' is the class name, not 'Q_EXPORT'. */ functionContext = yyIdent; yyTok = getToken(); } while ( yyTok == Tok_Ident ); while ( yyTok == Tok_Gulbrandsen ) { yyTok = getToken(); functionContext += "::"; functionContext += yyIdent; yyTok = getToken(); } if ( yyTok == Tok_Colon ) { missing_Q_OBJECT = TRUE; } else { functionContext = defaultContext; } } break; case Tok_namespace: yyTok = getToken(); if ( yyTok == Tok_Ident ) { QCString ns = yyIdent; yyTok = getToken(); if ( yyTok == Tok_LeftBrace && yyBraceDepth == (int) namespaces.count() + 1 ) namespaces.append( QString(ns) ); } break; case Tok_tr: case Tok_trUtf8: utf8 = ( yyTok == Tok_trUtf8 ); yyTok = getToken(); if ( match(Tok_LeftParen) && matchString(&text) ) { com = ""; if ( match(Tok_RightParen) || (match(Tok_Comma) && matchString(&com) && match(Tok_RightParen)) ) { if ( prefix.isNull() ) { context = functionContext; if ( !namespaces.isEmpty() ) context.prepend( (namespaces.join(QString("::")) + QString("::")).latin1() ); } else { context = prefix; } prefix = (const char *) 0; if ( qualifiedContexts.contains(context) ) context = qualifiedContexts[context]; tor->insert( MetaTranslatorMessage(context, text, com, QString::null, utf8) ); if ( lacks_Q_OBJECT.contains(context) ) { qWarning( "%s:%d: Class '%s' lacks Q_OBJECT macro", (const char *) yyFileName, yyLineNo, (const char *) context ); lacks_Q_OBJECT.remove( context ); } else { needs_Q_OBJECT.insert( context, 0 ); } } } break; case Tok_translate: utf8 = FALSE; yyTok = getToken(); if ( match(Tok_LeftParen) && matchString(&context) && match(Tok_Comma) && matchString(&text) ) { com = ""; if ( match(Tok_RightParen) || (match(Tok_Comma) && matchString(&com) && (match(Tok_RightParen) || match(Tok_Comma) && matchEncoding(&utf8) && match(Tok_RightParen))) ) tor->insert( MetaTranslatorMessage(context, text, com, QString::null, utf8) ); } break; case Tok_Q_OBJECT: missing_Q_OBJECT = FALSE; yyTok = getToken(); break; case Tok_Ident: if ( !prefix.isNull() ) prefix += "::"; prefix += yyIdent; yyTok = getToken(); if ( yyTok != Tok_Gulbrandsen ) prefix = (const char *) 0; break; case Tok_Comment: com = yyComment; com = com.simplifyWhiteSpace(); if ( com.left(sizeof(MagicComment) - 1) == MagicComment ) { com.remove( 0, sizeof(MagicComment) - 1 ); int k = com.find( ' ' ); if ( k == -1 ) { context = com; } else { context = com.left( k ); com.remove( 0, k + 1 ); tor->insert( MetaTranslatorMessage(context, "", com, QString::null, FALSE) ); } /* Provide a backdoor for people using "using namespace". See the manual for details. */ k = 0; while ( (k = context.find("::", k)) != -1 ) { qualifiedContexts.insert( context.mid(k + 2), context ); k++; } } yyTok = getToken(); break; case Tok_Arrow: yyTok = getToken(); if ( yyTok == Tok_tr || yyTok == Tok_trUtf8 ) qWarning( "%s:%d: Cannot invoke tr() like this", (const char *) yyFileName, yyLineNo ); break; case Tok_Gulbrandsen: // at top level? if ( yyBraceDepth == (int) namespaces.count() && yyParenDepth == 0 ) functionContext = prefix; yyTok = getToken(); break; case Tok_RightBrace: case Tok_Semicolon: if ( yyBraceDepth >= 0 && yyBraceDepth + 1 == (int) namespaces.count() ) namespaces.remove( namespaces.fromLast() ); if ( yyBraceDepth == (int) namespaces.count() ) { if ( missing_Q_OBJECT ) { if ( needs_Q_OBJECT.contains(functionContext) ) { qWarning( "%s:%d: Class '%s' lacks Q_OBJECT macro", (const char *) yyFileName, yyLineNo, (const char *) functionContext ); } else { lacks_Q_OBJECT.insert( functionContext, 0 ); } } functionContext = defaultContext; missing_Q_OBJECT = FALSE; } yyTok = getToken(); break; default: yyTok = getToken(); } } if ( yyBraceDepth != 0 ) fprintf( stderr, "%s:%d: Unbalanced braces in C++ code (or abuse of the C++" " preprocessor)\n", (const char *)yyFileName, yyBraceLineNo ); else if ( yyParenDepth != 0 ) fprintf( stderr, "%s:%d: Unbalanced parentheses in C++ code (or abuse of the C++" " preprocessor)\n", (const char *)yyFileName, yyParenLineNo ); }
static int getToken() { const char tab[] = "abfnrtv"; const char backTab[] = "\a\b\f\n\r\t\v"; uint n; yyIdentLen = 0; yyCommentLen = 0; yyStringLen = 0; while ( yyCh != EOF ) { yyLineNo = yyCurLineNo; if ( isalpha(yyCh) || yyCh == '_' ) { do { if ( yyIdentLen < sizeof(yyIdent) - 1 ) yyIdent[yyIdentLen++] = (char) yyCh; yyCh = getChar(); } while ( isalnum(yyCh) || yyCh == '_' ); yyIdent[yyIdentLen] = '\0'; switch ( yyIdent[0] ) { case 'Q': if ( strcmp(yyIdent + 1, "_OBJECT") == 0 ) { return Tok_Q_OBJECT; } else if ( strcmp(yyIdent + 1, "T_TR_NOOP") == 0 ) { return Tok_tr; } else if ( strcmp(yyIdent + 1, "T_TRANSLATE_NOOP") == 0 ) { return Tok_translate; } break; case 'T': // TR() for when all else fails if ( qstricmp(yyIdent + 1, "R") == 0 ) return Tok_tr; break; case 'c': if ( strcmp(yyIdent + 1, "lass") == 0 ) return Tok_class; break; case 'f': /* QTranslator::findMessage() has the same parameters as QApplication::translate(). */ if ( strcmp(yyIdent + 1, "indMessage") == 0 ) return Tok_translate; break; case 'n': if ( strcmp(yyIdent + 1, "amespace") == 0 ) return Tok_namespace; break; case 'r': if ( strcmp(yyIdent + 1, "eturn") == 0 ) return Tok_return; break; case 's': if ( strcmp(yyIdent + 1, "truct") == 0 ) return Tok_class; break; case 't': if ( strcmp(yyIdent + 1, "r") == 0 ) { return Tok_tr; } else if ( qstrcmp(yyIdent + 1, "rUtf8") == 0 ) { return Tok_trUtf8; } else if ( qstrcmp(yyIdent + 1, "ranslate") == 0 ) { return Tok_translate; } } return Tok_Ident; } else { switch ( yyCh ) { case '#': /* Early versions of lupdate complained about unbalanced braces in the following code: #ifdef ALPHA while ( beta ) { #else while ( gamma ) { #endif delta; } The code contains, indeed, two opening braces for one closing brace; yet there's no reason to panic. The solution is to remember yyBraceDepth as it was when #if, #ifdef or #ifndef was met, and to set yyBraceDepth to that value when meeting #elif or #else. */ do { yyCh = getChar(); } while ( isspace(yyCh) && yyCh != '\n' ); switch ( yyCh ) { case 'i': yyCh = getChar(); if ( yyCh == 'f' ) { // if, ifdef, ifndef yySavedBraceDepth.push( yyBraceDepth ); yySavedParenDepth.push( yyParenDepth ); } break; case 'e': yyCh = getChar(); if ( yyCh == 'l' ) { // elif, else if ( !yySavedBraceDepth.isEmpty() ) { yyBraceDepth = yySavedBraceDepth.top(); yyParenDepth = yySavedParenDepth.top(); } } else if ( yyCh == 'n' ) { // endif if ( !yySavedBraceDepth.isEmpty() ) { yySavedBraceDepth.pop(); yySavedParenDepth.pop(); } } } while ( isalnum(yyCh) || yyCh == '_' ) yyCh = getChar(); break; case '/': yyCh = getChar(); if ( yyCh == '/' ) { do { yyCh = getChar(); } while ( yyCh != EOF && yyCh != '\n' ); } else if ( yyCh == '*' ) { bool metAster = FALSE; bool metAsterSlash = FALSE; while ( !metAsterSlash ) { yyCh = getChar(); if ( yyCh == EOF ) { fprintf( stderr, "%s: Unterminated C++ comment starting at" " line %d\n", (const char *) yyFileName, yyLineNo ); yyComment[yyCommentLen] = '\0'; return Tok_Comment; } if ( yyCommentLen < sizeof(yyComment) - 1 ) yyComment[yyCommentLen++] = (char) yyCh; if ( yyCh == '*' ) metAster = TRUE; else if ( metAster && yyCh == '/' ) metAsterSlash = TRUE; else metAster = FALSE; } yyCh = getChar(); yyCommentLen -= 2; yyComment[yyCommentLen] = '\0'; return Tok_Comment; } break; case '"': yyCh = getChar(); while ( yyCh != EOF && yyCh != '\n' && yyCh != '"' ) { if ( yyCh == '\\' ) { yyCh = getChar(); if ( yyCh == '\n' ) { yyCh = getChar(); } else if ( yyCh == 'x' ) { QCString hex = "0"; yyCh = getChar(); while ( isxdigit(yyCh) ) { hex += (char) yyCh; yyCh = getChar(); } sscanf( hex, "%x", &n ); if ( yyStringLen < sizeof(yyString) - 1 ) yyString[yyStringLen++] = (char) n; } else if ( yyCh >= '0' && yyCh < '8' ) { QCString oct = ""; do { oct += (char) yyCh; yyCh = getChar(); } while ( yyCh >= '0' && yyCh < '8' ); sscanf( oct, "%o", &n ); if ( yyStringLen < sizeof(yyString) - 1 ) yyString[yyStringLen++] = (char) n; } else { const char *p = strchr( tab, yyCh ); if ( yyStringLen < sizeof(yyString) - 1 ) yyString[yyStringLen++] = ( p == 0 ) ? (char) yyCh : backTab[p - tab]; yyCh = getChar(); } } else { if ( yyStringLen < sizeof(yyString) - 1 ) yyString[yyStringLen++] = (char) yyCh; yyCh = getChar(); } } yyString[yyStringLen] = '\0'; if ( yyCh != '"' ) qWarning( "%s:%d: Unterminated C++ string", (const char *) yyFileName, yyLineNo ); if ( yyCh == EOF ) { return Tok_Eof; } else { yyCh = getChar(); return Tok_String; } break; case '-': yyCh = getChar(); if ( yyCh == '>' ) { yyCh = getChar(); return Tok_Arrow; } break; case ':': yyCh = getChar(); if ( yyCh == ':' ) { yyCh = getChar(); return Tok_Gulbrandsen; } return Tok_Colon; case '\'': yyCh = getChar(); if ( yyCh == '\\' ) yyCh = getChar(); do { yyCh = getChar(); } while ( yyCh != EOF && yyCh != '\'' ); yyCh = getChar(); break; case '{': if (yyBraceDepth == 0) yyBraceLineNo = yyCurLineNo; yyBraceDepth++; yyCh = getChar(); return Tok_LeftBrace; case '}': if (yyBraceDepth == 0) yyBraceLineNo = yyCurLineNo; yyBraceDepth--; yyCh = getChar(); return Tok_RightBrace; case '(': if (yyParenDepth == 0) yyParenLineNo = yyCurLineNo; yyParenDepth++; yyCh = getChar(); return Tok_LeftParen; case ')': if (yyParenDepth == 0) yyParenLineNo = yyCurLineNo; yyParenDepth--; yyCh = getChar(); return Tok_RightParen; case ',': yyCh = getChar(); return Tok_Comma; case ';': yyCh = getChar(); return Tok_Semicolon; default: yyCh = getChar(); } } } return Tok_Eof; }
/*! * Sets the list of subtypes for this service. * * \sa serviceSubTypes * \sa addServiceSubType * \sa removeServiceSubType * \sa hasServiceSubType */ void QxtDiscoverableService::setServiceSubTypes(const QStringList& subtypes) { if(state() != Unknown) qWarning() << "QxtDiscoverableService: Setting service subtypes while not in Unknown state has no effect"; qxt_d().serviceSubTypes = subtypes; }
QList< QgsRelief::ReliefColor > QgsRelief::calculateOptimizedReliefClasses() { QList< QgsRelief::ReliefColor > resultList; int nCellsX, nCellsY; GDALDatasetH inputDataset = openInputFile( nCellsX, nCellsY ); if ( inputDataset == NULL ) { return resultList; } //open first raster band for reading (elevation raster is always single band) GDALRasterBandH elevationBand = GDALGetRasterBand( inputDataset, 1 ); if ( elevationBand == NULL ) { GDALClose( inputDataset ); return resultList; } //1. get minimum and maximum of elevation raster -> 252 elevation classes int minOk, maxOk; double minMax[2]; minMax[0] = GDALGetRasterMinimum( elevationBand, &minOk ); minMax[1] = GDALGetRasterMaximum( elevationBand, &maxOk ); if ( !minOk || !maxOk ) { GDALComputeRasterMinMax( elevationBand, true, minMax ); } //2. go through raster cells and get frequency of classes //store elevation frequency in 256 elevation classes double frequency[252]; double frequencyClassRange = ( minMax[1] - minMax[0] ) / 252.0; //initialize to zero for ( int i = 0; i < 252; ++i ) { frequency[i] = 0; } float* scanLine = ( float * ) CPLMalloc( sizeof( float ) * nCellsX ); int elevationClass = -1; for ( int i = 0; i < nCellsY; ++i ) { GDALRasterIO( elevationBand, GF_Read, 0, i, nCellsX, 1, scanLine, nCellsX, 1, GDT_Float32, 0, 0 ); for ( int j = 0; j < nCellsX; ++j ) { elevationClass = frequencyClassForElevation( scanLine[j], minMax[0], frequencyClassRange ); if ( elevationClass < 0 ) { elevationClass = 0; } else if ( elevationClass >= 252 ) { elevationClass = 251; } frequency[elevationClass] += 1.0; } } CPLFree( scanLine ); //log10 transformation for all frequency values for ( int i = 0; i < 252; ++i ) { frequency[i] = log10( frequency[i] ); } //start with 9 uniformly distributed classes QList<int> classBreaks; classBreaks.append( 0 ); classBreaks.append( 28 ); classBreaks.append( 56 ); classBreaks.append( 84 ); classBreaks.append( 112 ); classBreaks.append( 140 ); classBreaks.append( 168 ); classBreaks.append( 196 ); classBreaks.append( 224 ); classBreaks.append( 252 ); for ( int i = 0; i < 10; ++i ) { optimiseClassBreaks( classBreaks, frequency ); } //debug, print out all the classbreaks for ( int i = 0; i < classBreaks.size(); ++i ) { qWarning( "%d", classBreaks[i] ); } //set colors according to optimised class breaks QList<QColor> colorList; colorList.push_back( QColor( 7, 165, 144 ) ); colorList.push_back( QColor( 12, 221, 162 ) ); colorList.push_back( QColor( 33, 252, 183 ) ); colorList.push_back( QColor( 247, 252, 152 ) ); colorList.push_back( QColor( 252, 196, 8 ) ); colorList.push_back( QColor( 252, 166, 15 ) ); colorList.push_back( QColor( 175, 101, 15 ) ); colorList.push_back( QColor( 255, 133, 92 ) ); colorList.push_back( QColor( 204, 204, 204 ) ); resultList.reserve( classBreaks.size() ); for ( int i = 1; i < classBreaks.size(); ++i ) { double minElevation = minMax[0] + classBreaks[i - 1] * frequencyClassRange; double maxElevation = minMax[0] + classBreaks[i] * frequencyClassRange; resultList.push_back( QgsRelief::ReliefColor( colorList.at( i - 1 ), minElevation, maxElevation ) ); } return resultList; }
/*! * Removes a subtype from the service. * * \sa serviceSubTypes * \sa setServiceSubTypes * \sa addServiceSubType * \sa hasServiceSubType */ void QxtDiscoverableService::removeServiceSubType(const QString& subtype) { if(state() != Unknown) qWarning() << "QxtDiscoverableService: Setting service subtypes while not in Unknown state has no effect"; qxt_d().serviceSubTypes.removeAll(subtype); }
void MidiController::visit(const HidControllerPreset* preset) { Q_UNUSED(preset); qWarning() << "ERROR: Attempting to load an HidControllerPreset to a MidiController!"; // TODO(XXX): throw a hissy fit. }
void StaticFileController::service(HttpRequest& request, HttpResponse& response) { QByteArray path=request.getPath(); // Check if we have the file in cache qint64 now=QDateTime::currentMSecsSinceEpoch(); mutex.lock(); CacheEntry* entry=cache.object(path); if (entry && (cacheTimeout==0 || entry->created>now-cacheTimeout)) { QByteArray document=entry->document; //copy the cached document, because other threads may destroy the cached entry immediately after mutex unlock. QByteArray filename=entry->filename; mutex.unlock(); qDebug("StaticFileController: Cache hit for %s",path.data()); setContentType(filename,response); response.setHeader("Cache-Control","max-age="+QByteArray::number(maxAge/1000)); response.write(document); } else { mutex.unlock(); // The file is not in cache. qDebug("StaticFileController: Cache miss for %s",path.data()); // Forbid access to files outside the docroot directory if (path.contains("/..")) { qWarning("StaticFileController: detected forbidden characters in path %s",path.data()); response.setStatus(403,"forbidden"); response.write("403 forbidden",true); return; } // If the filename is a directory, append index.html. if (QFileInfo(docroot+path).isDir()) { path+="/index.html"; } // Try to open the file QFile file(docroot+path); qDebug("StaticFileController: Open file %s",qPrintable(file.fileName())); if (file.open(QIODevice::ReadOnly)) { setContentType(path,response); response.setHeader("Cache-Control","max-age="+QByteArray::number(maxAge/1000)); if (file.size()<=maxCachedFileSize) { // Return the file content and store it also in the cache entry=new CacheEntry(); while (!file.atEnd() && !file.error()) { QByteArray buffer=file.read(65536); response.write(buffer); entry->document.append(buffer); } entry->created=now; entry->filename=path; mutex.lock(); cache.insert(request.getPath(),entry,entry->document.size()); mutex.unlock(); } else { // Return the file content, do not store in cache while (!file.atEnd() && !file.error()) { response.write(file.read(65536)); } } file.close(); } else { if (file.exists()) { qWarning("StaticFileController: Cannot open existing file %s for reading",qPrintable(file.fileName())); response.setStatus(403,"forbidden"); response.write("403 forbidden",true); } else { response.setStatus(404,"not found"); response.write("404 not found",true); } } } }
void MidiController::createOutputHandlers() { if (m_preset.outputMappings.isEmpty()) { return; } QHashIterator<ConfigKey, MidiOutputMapping> outIt(m_preset.outputMappings); QStringList failures; while (outIt.hasNext()) { outIt.next(); const MidiOutputMapping& mapping = outIt.value(); QString group = mapping.controlKey.group; QString key = mapping.controlKey.item; unsigned char status = mapping.output.status; unsigned char control = mapping.output.control; unsigned char on = mapping.output.on; unsigned char off = mapping.output.off; double min = mapping.output.min; double max = mapping.output.max; controllerDebug(QString( "Creating output handler for %1,%2 between %3 and %4 to MIDI out: 0x%5 0x%6, on: 0x%7 off: 0x%8") .arg(group, key, QString::number(min), QString::number(max), QString::number(status, 16).toUpper(), QString::number(control, 16).toUpper().rightJustified(2,'0'), QString::number(on, 16).toUpper().rightJustified(2,'0'), QString::number(off, 16).toUpper().rightJustified(2,'0'))); MidiOutputHandler* moh = new MidiOutputHandler(this, mapping); if (!moh->validate()) { QString errorLog = QString("MIDI output message 0x%1 0x%2 has invalid MixxxControl %3, %4") .arg(QString::number(status, 16).toUpper(), QString::number(control, 16).toUpper().rightJustified(2,'0')) .arg(group, key).toUtf8(); qWarning() << errorLog; int deckNum = 0; if (ControllerDebug::enabled()) { failures.append(errorLog); } else if (PlayerManager::isDeckGroup(group, &deckNum)) { int numDecks = PlayerManager::numDecks(); if (deckNum <= numDecks) { failures.append(errorLog); } } delete moh; continue; } m_outputs.append(moh); } if (!failures.isEmpty()) { ErrorDialogProperties* props = ErrorDialogHandler::instance()->newDialogProperties(); props->setType(DLG_WARNING); props->setTitle(tr("MixxxControl(s) not found")); props->setText(tr("One or more MixxxControls specified in the " "outputs section of the loaded preset were invalid.")); props->setInfoText(tr("Some LEDs or other feedback may not work correctly.")); QString detailsText = tr("* Check to see that the MixxxControl " "names are spelled correctly in the mapping " "file (.xml)\n"); detailsText += tr("* Make sure the MixxxControls in question actually exist." " Visit this wiki page for a complete list: "); detailsText += "http://mixxx.org/wiki/doku.php/mixxxcontrols\n\n"; detailsText += failures.join("\n"); props->setDetails(detailsText); ErrorDialogHandler::instance()->requestErrorDialog(props); } }
void QPoint::warningDivByZero() { #if defined(CHECK_MATH) qWarning( "QPoint: Division by zero error" ); #endif }
bool Chaser::loadXML(const QDomElement& root) { if (root.tagName() != KXMLQLCFunction) { qWarning() << Q_FUNC_INFO << "Function node not found"; return false; } if (root.attribute(KXMLQLCFunctionType) != typeToString(Function::Chaser)) { qWarning() << Q_FUNC_INFO << root.attribute(KXMLQLCFunctionType) << "is not a chaser"; return false; } /* Load chaser contents */ QDomNode node = root.firstChild(); while (node.isNull() == false) { QDomElement tag = node.toElement(); if (tag.tagName() == KXMLQLCBus) { m_legacyHoldBus = tag.text().toUInt(); } else if (tag.tagName() == KXMLQLCFunctionSpeed) { loadXMLSpeed(tag); } else if (tag.tagName() == KXMLQLCFunctionDirection) { loadXMLDirection(tag); } else if (tag.tagName() == KXMLQLCFunctionRunOrder) { loadXMLRunOrder(tag); } else if (tag.tagName() == KXMLQLCChaserSpeedModes) { QString str; str = tag.attribute(KXMLQLCFunctionSpeedFadeIn); setFadeInMode(stringToSpeedMode(str)); str = tag.attribute(KXMLQLCFunctionSpeedFadeOut); setFadeOutMode(stringToSpeedMode(str)); str = tag.attribute(KXMLQLCFunctionSpeedDuration); setDurationMode(stringToSpeedMode(str)); } else if (tag.tagName() == KXMLQLCChaserSequenceTag) { QString str = tag.attribute(KXMLQLCChaserSequenceBoundScene); enableSequenceMode(str.toUInt()); if (tag.hasAttribute(KXMLQLCChaserSequenceStartTime)) m_startTime = tag.attribute(KXMLQLCChaserSequenceStartTime).toUInt(); if (tag.hasAttribute(KXMLQLCChaserSequenceColor)) m_color = QColor(tag.attribute(KXMLQLCChaserSequenceColor)); } else if (tag.tagName() == KXMLQLCFunctionStep) { //! @todo stepNumber is useless if the steps are in the wrong order ChaserStep step; int stepNumber = -1; if (step.loadXML(tag, stepNumber) == true) { if (isSequence() == true) step.fid = getBoundSceneID(); if (stepNumber >= m_steps.size()) m_steps.append(step); else m_steps.insert(stepNumber, step); } } else { qWarning() << Q_FUNC_INFO << "Unknown chaser tag:" << tag.tagName(); } node = node.nextSibling(); } return true; }
bool QFile::rename(const QString &newName) { Q_D(QFile); if (d->fileName.isEmpty()) { qWarning("QFile::rename: Empty or null file name"); return false; } if (d->fileName == newName) { d->setError(QFile::RenameError, tr("Destination file is the same file.")); return false; } if (!exists()) { d->setError(QFile::RenameError, tr("Source file does not exist.")); return false; } // If the file exists and it is a case-changing rename ("foo" -> "Foo"), // compare Ids to make sure it really is a different file. if (QFile::exists(newName)) { if (d->fileName.compare(newName, Qt::CaseInsensitive) || QFileSystemEngine::id(QFileSystemEntry(d->fileName)) != QFileSystemEngine::id(QFileSystemEntry(newName))) { // ### Race condition. If a file is moved in after this, it /will/ be // overwritten. On Unix, the proper solution is to use hardlinks: // return ::link(old, new) && ::remove(old); d->setError(QFile::RenameError, tr("Destination file exists")); return false; } #ifndef QT_NO_TEMPORARYFILE // This #ifndef disables the workaround it encloses. Therefore, this configuration is not recommended. #ifdef Q_OS_LINUX // rename() on Linux simply does nothing when renaming "foo" to "Foo" on a case-insensitive // FS, such as FAT32. Move the file away and rename in 2 steps to work around. QTemporaryFile tempFile(d->fileName + QStringLiteral(".XXXXXX")); tempFile.setAutoRemove(false); if (!tempFile.open(QIODevice::ReadWrite)) { d->setError(QFile::RenameError, tempFile.errorString()); return false; } tempFile.close(); if (!d->engine()->rename(tempFile.fileName())) { d->setError(QFile::RenameError, tr("Error while renaming.")); return false; } if (tempFile.rename(newName)) { d->fileEngine->setFileName(newName); d->fileName = newName; return true; } d->setError(QFile::RenameError, tempFile.errorString()); // We need to restore the original file. if (!tempFile.rename(d->fileName)) { d->setError(QFile::RenameError, errorString() + QLatin1Char('\n') + tr("Unable to restore from %1: %2"). arg(QDir::toNativeSeparators(tempFile.fileName()), tempFile.errorString())); } return false; #endif // Q_OS_LINUX #endif // QT_NO_TEMPORARYFILE } unsetError(); close(); if(error() == QFile::NoError) { if (d->engine()->rename(newName)) { unsetError(); // engine was able to handle the new name so we just reset it d->fileEngine->setFileName(newName); d->fileName = newName; return true; } if (isSequential()) { d->setError(QFile::RenameError, tr("Will not rename sequential file using block copy")); return false; } QFile out(newName); if (open(QIODevice::ReadOnly)) { if (out.open(QIODevice::WriteOnly | QIODevice::Truncate)) { bool error = false; char block[4096]; qint64 bytes; while ((bytes = read(block, sizeof(block))) > 0) { if (bytes != out.write(block, bytes)) { d->setError(QFile::RenameError, out.errorString()); error = true; break; } } if (bytes == -1) { d->setError(QFile::RenameError, errorString()); error = true; } if(!error) { if (!remove()) { d->setError(QFile::RenameError, tr("Cannot remove source file")); error = true; } } if (error) { out.remove(); } else { d->fileEngine->setFileName(newName); setPermissions(permissions()); unsetError(); setFileName(newName); } close(); return !error; } close(); } d->setError(QFile::RenameError, out.isOpen() ? errorString() : out.errorString()); } return false; }
SceneOpenGL::SceneOpenGL(Workspace* ws) : Scene(ws) , m_resetModelViewProjectionMatrix(true) , init_ok(false) { initGLX(); // check for FBConfig support if (!hasGLExtension("GLX_SGIX_fbconfig") || !glXGetFBConfigAttrib || !glXGetFBConfigs || !glXGetVisualFromFBConfig || !glXCreatePixmap || !glXDestroyPixmap || !glXCreateWindow || !glXDestroyWindow) { kError(1212) << "GLX_SGIX_fbconfig or required GLX functions missing"; return; // error } if (!selectMode()) return; // error if (!initBuffer()) // create destination buffer return; // error if (!initRenderingContext()) return; // error // Initialize OpenGL GLPlatform *glPlatform = GLPlatform::instance(); glPlatform->detect(); glPlatform->printResults(); initGL(); if (glPlatform->isSoftwareEmulation()) { kError(1212) << "OpenGL Software Rasterizer detected. Falling back to XRender."; QTimer::singleShot(0, Workspace::self(), SLOT(fallbackToXRenderCompositing())); return; } if (!hasGLExtension("GL_ARB_texture_non_power_of_two") && !hasGLExtension("GL_ARB_texture_rectangle")) { kError(1212) << "GL_ARB_texture_non_power_of_two and GL_ARB_texture_rectangle missing"; return; // error } if (glPlatform->isMesaDriver() && glPlatform->mesaVersion() < kVersionNumber(7, 10)) { kError(1212) << "KWin requires at least Mesa 7.10 for OpenGL compositing."; return; } if (db) glDrawBuffer(GL_BACK); // Check whether certain features are supported has_waitSync = false; if (options->isGlVSync()) { if (glXGetVideoSync && glXSwapInterval && glXIsDirect(display(), ctxbuffer)) { unsigned int sync; if (glXGetVideoSync(&sync) == 0) { if (glXWaitVideoSync(1, 0, &sync) == 0) { // NOTICE at this time we should actually check whether we can successfully // deactivate the swapInterval "glXSwapInterval(0) == 0" // (because we don't actually want it active unless we explicitly run a glXSwapBuffers) // However mesa/dri will return a range error (6) because deactivating the // swapinterval (as of today) seems completely unsupported has_waitSync = true; glXSwapInterval(0); } else qWarning() << "NO VSYNC! glXWaitVideoSync(1,0,&uint) isn't 0 but" << glXWaitVideoSync(1, 0, &sync); } else qWarning() << "NO VSYNC! glXGetVideoSync(&uint) isn't 0 but" << glXGetVideoSync(&sync); } else qWarning() << "NO VSYNC! glXGetVideoSync, glXSwapInterval, glXIsDirect" << bool(glXGetVideoSync) << bool(glXSwapInterval) << glXIsDirect(display(), ctxbuffer); } debug = qstrcmp(qgetenv("KWIN_GL_DEBUG"), "1") == 0; // scene shader setup if (GLPlatform::instance()->supports(GLSL)) { if (!ShaderManager::instance()->isValid()) { kDebug(1212) << "No Scene Shaders available"; } else { // push one shader on the stack so that one is always bound // consistency with GLES ShaderManager::instance()->pushShader(ShaderManager::SimpleShader); } } // OpenGL scene setup setupModelViewProjectionMatrix(); if (checkGLError("Init")) { kError(1212) << "OpenGL compositing setup failed"; return; // error } // set strict binding if (options->isGlStrictBindingFollowsDriver()) { options->setGlStrictBinding(!glPlatform->supports(LooseBinding)); } kDebug(1212) << "DB:" << db << ", Direct:" << bool(glXIsDirect(display(), ctxbuffer)) << endl; init_ok = true; }
void WordPredict::updateWords() { WeightedList list(m_max); int bestWord = -1; qreal bestWordWeight = -1.0f; DawgReduction<WPWord>::WordList words = reduction->words(); for(int ii = 0; ii < words.count(); ++ii) { #ifndef PRED_NO_INCREMENTAL_CALCULATIONS qreal weight = incrWeightForWord(words.at(ii)); if(weight == -1) { words.at(ii)->isValid = false; continue; } if(words.at(ii)->isWord) list.addWord(weight, words.at(ii)->word); if(bestWord == -1 || weight < bestWordWeight) { bestWord = ii; bestWordWeight = weight; } #else Word word; word.frequency = words.at(ii)->frequency; word.word = words.at(ii)->word; qreal weight = weightForWord(word); words.at(ii)->weight = weight; if(weight == -1) { words.at(ii)->isValid = false; continue; } if(words.at(ii)->isWord) list.addWord(weight, word.word); if(bestWord == -1 || weight < bestWordWeight) { bestWord = ii; bestWordWeight = weight; } #endif } if(bestWord != -1) m_prefixedWord = words.at(bestWord)->word; else m_prefixedWord = QString(); qreal baseWordScore = list.minWeight() * 10.0f; QStringList l_words = list.words(); QList<qreal> l_weights = list.weights(); QList<QPair<QString, qreal> > finalwords; for(int ii = 0; ii < l_words.count(); ++ii) if(l_weights.at(ii) <= baseWordScore) finalwords << qMakePair(l_words.at(ii), l_weights.at(ii)); qSort(finalwords.begin(), finalwords.end()); m_words = QStringList(); m_weights = QList<qreal>(); for(int ii = 0; ii < finalwords.count(); ++ii) { m_words << finalwords.at(ii).first; m_weights << finalwords.at(ii).second; } if(!m_words.isEmpty()) m_word = m_words.first(); else m_word = QString(); #ifdef PRED_DEBUG qWarning() << "Top words are" << l_words; qWarning() << "Best word is" << m_word; qWarning() << "Best words are" << m_words; qWarning() << "Best word weights are" << m_weights; //qWarning() << "Best word freqs are" << l_freq; QString xstr; QString ystr; for(int ii = 0; ii < m_points.count(); ++ii) { if(!ii) { xstr += "(" + QString::number(m_points.at(ii).x()) + ") "; ystr += "(" + QString::number(m_points.at(ii).y()) + ") "; } else { xstr += QString::number(m_points.at(ii).x() - m_points.at(ii - 1).x()) + " "; ystr += QString::number(m_points.at(ii - 1).y() - m_points.at(ii).y()) + " "; } } qWarning() << "X motion" << xstr; qWarning() << "Y motion" << ystr; qWarning() << "Movement: " << movementDesc(); #endif }
void QItemDelegate::doLayout(const QStyleOptionViewItem &option, QRect *checkRect, QRect *pixmapRect, QRect *textRect, bool hint) const { Q_ASSERT(checkRect && pixmapRect && textRect); Q_D(const QItemDelegate); const QWidget *widget = d->widget(option); QStyle *style = widget ? widget->style() : QApplication::style(); const bool hasCheck = checkRect->isValid(); const bool hasPixmap = pixmapRect->isValid(); const bool hasText = textRect->isValid(); const int textMargin = hasText ? style->pixelMetric(QStyle::PM_FocusFrameHMargin, 0, widget) + 1 : 0; const int pixmapMargin = hasPixmap ? style->pixelMetric(QStyle::PM_FocusFrameHMargin, 0, widget) + 1 : 0; const int checkMargin = hasCheck ? style->pixelMetric(QStyle::PM_FocusFrameHMargin, 0, widget) + 1 : 0; int x = option.rect.left(); int y = option.rect.top(); int w, h; textRect->adjust(-textMargin, 0, textMargin, 0); // add width padding if (textRect->height() == 0 && (!hasPixmap || !hint)) { //if there is no text, we still want to have a decent height for the item sizeHint and the editor size textRect->setHeight(option.fontMetrics.height()); } QSize pm(0, 0); if (hasPixmap) { pm = pixmapRect->size(); pm.rwidth() += 2 * pixmapMargin; } if (hint) { h = qMax(checkRect->height(), qMax(textRect->height(), pm.height())); if (option.decorationPosition == QStyleOptionViewItem::Left || option.decorationPosition == QStyleOptionViewItem::Right) { w = textRect->width() + pm.width(); } else { w = qMax(textRect->width(), pm.width()); } } else { w = option.rect.width(); h = option.rect.height(); } int cw = 0; QRect check; if (hasCheck) { cw = checkRect->width() + 2 * checkMargin; if (hint) w += cw; if (option.direction == Qt::RightToLeft) { check.setRect(x + w - cw, y, cw, h); } else { check.setRect(x + checkMargin, y, cw, h); } } // at this point w should be the *total* width QRect display; QRect decoration; switch (option.decorationPosition) { case QStyleOptionViewItem::Top: { if (hasPixmap) pm.setHeight(pm.height() + pixmapMargin); // add space h = hint ? textRect->height() : h - pm.height(); if (option.direction == Qt::RightToLeft) { decoration.setRect(x, y, w - cw, pm.height()); display.setRect(x, y + pm.height(), w - cw, h); } else { decoration.setRect(x + cw, y, w - cw, pm.height()); display.setRect(x + cw, y + pm.height(), w - cw, h); } break; } case QStyleOptionViewItem::Bottom: { if (hasText) textRect->setHeight(textRect->height() + textMargin); // add space h = hint ? textRect->height() + pm.height() : h; if (option.direction == Qt::RightToLeft) { display.setRect(x, y, w - cw, textRect->height()); decoration.setRect(x, y + textRect->height(), w - cw, h - textRect->height()); } else { display.setRect(x + cw, y, w - cw, textRect->height()); decoration.setRect(x + cw, y + textRect->height(), w - cw, h - textRect->height()); } break; } case QStyleOptionViewItem::Left: { if (option.direction == Qt::LeftToRight) { decoration.setRect(x + cw, y, pm.width(), h); display.setRect(decoration.right() + 1, y, w - pm.width() - cw, h); } else { display.setRect(x, y, w - pm.width() - cw, h); decoration.setRect(display.right() + 1, y, pm.width(), h); } break; } case QStyleOptionViewItem::Right: { if (option.direction == Qt::LeftToRight) { display.setRect(x + cw, y, w - pm.width() - cw, h); decoration.setRect(display.right() + 1, y, pm.width(), h); } else { decoration.setRect(x, y, pm.width(), h); display.setRect(decoration.right() + 1, y, w - pm.width() - cw, h); } break; } default: qWarning("doLayout: decoration position is invalid"); decoration = *pixmapRect; break; } if (!hint) { // we only need to do the internal layout if we are going to paint *checkRect = QStyle::alignedRect(option.direction, Qt::AlignCenter, checkRect->size(), check); *pixmapRect = QStyle::alignedRect(option.direction, option.decorationAlignment, pixmapRect->size(), decoration); // the text takes up all available space, unless the decoration is not shown as selected if (option.showDecorationSelected) *textRect = display; else *textRect = QStyle::alignedRect(option.direction, option.displayAlignment, textRect->size().boundedTo(display.size()), display); } else { *checkRect = check; *pixmapRect = decoration; *textRect = display; } }
int main(int argc, char *argv[]) { QString outFilename; bool helpRequested = false, list = false; QStringList files; QStringList args = qCmdLineArgs(argc, argv); //parse options QString errorMsg; for (int i = 1; i < args.count() && errorMsg.isEmpty(); i++) { if (args[i].isEmpty()) continue; if (args[i][0] == '-') { // option QString opt = args[i]; if (opt == QLatin1String("-o")) { if (!(i < argc-1)) { errorMsg = QLatin1String("Missing output name"); break; } outFilename = args[++i]; } else if (opt == QLatin1String("-name")) { if (!(i < argc-1)) { errorMsg = QLatin1String("Missing target name"); break; } initName = args[++i]; } else if (opt == QLatin1String("-root")) { if (!(i < argc-1)) { errorMsg = QLatin1String("Missing root path"); break; } resourceRoot = QDir::cleanPath(args[++i]); if(resourceRoot.isEmpty() || resourceRoot.at(0) != QLatin1Char('/')) errorMsg = QLatin1String("Root must start with a /"); } else if (opt == QLatin1String("-compress")) { if (!(i < argc-1)) { errorMsg = QLatin1String("Missing compression level"); break; } compressLevel = args[++i].toInt(); } else if (opt == QLatin1String("-threshold")) { if (!(i < argc-1)) { errorMsg = QLatin1String("Missing compression threshold"); break; } compressThreshold = args[++i].toInt(); } else if (opt == QLatin1String("-binary")) { writeBinary = true; } else if (opt == QLatin1String("-verbose")) { verbose = true; } else if (opt == QLatin1String("-list")) { list = true; } else if (opt == QLatin1String("-version") || opt == QLatin1String("-v")) { fprintf(stderr, "Qt Resource Compiler version %s\n", QT_VERSION_STR); return 1; } else if (opt == QLatin1String("-help") || opt == QLatin1String("-h")) { helpRequested = true; } else if (opt == QLatin1String("-no-compress")) { compressLevel = -2; } else { errorMsg = QString::fromLatin1("Unknown option: '%1'").arg(args[i]); } } else { if (!QFile::exists(args[i])) { qWarning("%s: File does not exist '%s'", qPrintable(args[0]), qPrintable(args[i])); return 1; } files.append(args[i]); } } if (!files.size() || !errorMsg.isEmpty() || helpRequested) return showHelp(args[0], errorMsg); return int(!processResourceFile(files, outFilename, list)); }
bool GeometryRenderer::updateBuffers(Geometry *geo) { g = geo; if (!g) { vbo.destroy(); #if QT_VAO vao.destroy(); #endif ibo.destroy(); return true; } if (try_ibo && g->indexCount() > 0) { if (!ibo.isCreated()) { if (!ibo.create()) { try_ibo = false; qDebug("IBO is not supported"); } } if (ibo.isCreated()) { ibo.bind(); ibo.allocate(g->indexData(), g->indexDataSize()); ibo.release(); } } if (!try_vbo) return false; #if QT_VAO if (try_vao) { qDebug("updating vao..."); if (!vao.isCreated()) { if (!vao.create()) { try_vao = false; qDebug("VAO is not supported"); } } } QOpenGLVertexArrayObject::Binder vao_bind(&vao); Q_UNUSED(vao_bind); #endif if (!vbo.isCreated()) { if (!vbo.create()) { try_vbo = false; // not supported by OpenGL try_vao = false; // also disable VAO. destroy? qWarning("VBO is not supported"); return false; } } //qDebug("updating vbo..."); vbo.bind(); //check here vbo.allocate(g->vertexData(), g->vertexCount()*g->stride()); //qDebug("allocate(%p, %d*%d)", g->vertexData(), g->vertexCount(), g->stride()); #if QT_VAO if (try_vao) { for (int an = 0; an < g->attributes().size(); ++an) { // FIXME: assume bind order is 0,1,2... const Attribute& a = g->attributes().at(an); //DYGL(glVertexAttribPointer(an, a.tupleSize(), a.type(), a.normalize(), g->stride(), reinterpret_cast<const void *>(qptrdiff(a.offset())))); /// FIXME: why qopengl function crash? program->enableAttributeArray(an); //TODO: in setActiveShader program->setAttributeBuffer(an, a.type(), a.offset(), a.tupleSize(), g->stride()); //DYGL(glEnableVertexAttribArray(an)); } } #endif vbo.release(); return true; }
/** * @brief AbstractProjectGenerator::AbstractProjectGenerator */ AbstractProjectGenerator::AbstractProjectGenerator() : AbstractProjectGenerator(nullptr, nullptr, "") { qWarning() << "Project generator created with empty databases and (or) with empty output path"; }
static QVariantMap createVariantMap(jobject data) { QVariantMap res; QAndroidJniEnvironment env; /* Reference : https://community.oracle.com/thread/1549999 */ // Get the HashMap Class jclass jclass_of_hashmap = (env)->GetObjectClass(data); // Get link to Method "entrySet" jmethodID entrySetMethod = (env)->GetMethodID(jclass_of_hashmap, "entrySet", "()Ljava/util/Set;"); // Invoke the "entrySet" method on the HashMap object jobject jobject_of_entryset = env->CallObjectMethod(data, entrySetMethod); // Get the Set Class jclass jclass_of_set = (env)->FindClass("java/util/Set"); // Problem during compilation !!!!! if (jclass_of_set == 0) { qWarning() << "java/util/Set lookup failed\n"; return res; } jclass jclass_of_string = env->FindClass("java/lang/String"); jclass jclass_of_integer = env->FindClass("java/lang/Integer"); jclass jclass_of_boolean = env->FindClass("java/lang/Boolean"); // Get link to Method "iterator" jmethodID iteratorMethod = env->GetMethodID(jclass_of_set, "iterator", "()Ljava/util/Iterator;"); // Invoke the "iterator" method on the jobject_of_entryset variable of type Set jobject jobject_of_iterator = env->CallObjectMethod(jobject_of_entryset, iteratorMethod); // Get the "Iterator" class jclass jclass_of_iterator = (env)->FindClass("java/util/Iterator"); // Get link to Method "hasNext" jmethodID hasNextMethod = env->GetMethodID(jclass_of_iterator, "hasNext", "()Z"); jmethodID nextMethod = env->GetMethodID(jclass_of_iterator, "next", "()Ljava/lang/Object;"); while (env->CallBooleanMethod(jobject_of_iterator, hasNextMethod) ) { QAndroidJniObject entry = env->CallObjectMethod(jobject_of_iterator,nextMethod); QAndroidJniObject key = entry.callObjectMethod("getKey","()Ljava/lang/Object;"); QAndroidJniObject value = entry.callObjectMethod("getValue","()Ljava/lang/Object;"); QString k = key.toString(); if (!value.isValid()) continue; if (env->IsInstanceOf(value.object<jobject>(),jclass_of_boolean)) { res[k] = QVariant::fromValue<bool>(value.callMethod<jboolean>("booleanValue","()Z")); } else if (env->IsInstanceOf(value.object<jobject>(),jclass_of_integer)) { res[k] = value.callMethod<jint>("intValue","()I"); } else if (env->IsInstanceOf(value.object<jobject>(),jclass_of_string)) { QString v = value.toString(); res[k] = v; } } if (env->ExceptionOccurred()) { env->ExceptionDescribe(); env->ExceptionClear(); } // Delete local reference return res; }