void QGeoTileRequestManagerPrivate::tileFetched(const QGeoTileSpec &spec)
{
    map_->newTileFetched(spec);
    requested_.remove(spec);
    retries_.remove(spec);
    futures_.remove(spec);
}
Exemplo n.º 2
0
int mythfile_close(int fileID)
{
    int result = -1;

    LOG(VB_FILE, LOG_DEBUG, LOC + QString("mythfile_close(%1)").arg(fileID));

    m_fileWrapperLock.lockForRead();
    if (m_ringbuffers.contains(fileID))
    {
        RingBuffer *rb = m_ringbuffers[fileID];
        m_ringbuffers.remove(fileID);
        delete rb;

        result = 0;
    }
    else if (m_remotefiles.contains(fileID))
    {
        RemoteFile *rf = m_remotefiles[fileID];
        m_remotefiles.remove(fileID);
        delete rf;

        result = 0;
    }
    else if (m_localfiles.contains(fileID))
    {
        close(m_localfiles[fileID]);
        m_localfiles.remove(fileID);
        result = 0;
    }
    m_fileWrapperLock.unlock();

    return result;
}
    bool removeTimer(int id)
    {
        if (id >= timerInfos.size())
            return false;

        WinRTTimerInfo &info = timerInfos[id];
        if (info.timerId == INVALID_TIMER_ID)
            return false;

        if (info.interval > 0 && (!timerIdToHandle.contains(id) || !timerIdToCancelHandle.contains(id)))
            return false;

        info.timerId = INVALID_TIMER_ID;

        // Remove invalid timerinfos from the vector's end, if the timer with the highest id was removed
        int lastTimer = timerInfos.size() - 1;
        while (lastTimer >= 0 && timerInfos.at(lastTimer).timerId == INVALID_TIMER_ID)
            --lastTimer;
        if (lastTimer >= 0 && lastTimer != timerInfos.size() - 1)
            timerInfos.resize(lastTimer + 1);
        timerIdToObject.remove(id);
        // ... remove handle from all lists
        if (info.interval > 0) {
            HANDLE handle = timerIdToHandle.take(id);
            timerHandleToId.remove(handle);
            SetEvent(timerIdToCancelHandle.take(id));
        }
        return true;
    }
Exemplo n.º 4
0
static inline QHash<PropertyName, QVariant> getProperties(const ModelNode &node)
{
    QHash<PropertyName, QVariant> propertyHash;
    if (QmlObjectNode::isValidQmlObjectNode(node)) {
        foreach (const AbstractProperty &abstractProperty, node.properties()) {
            if (abstractProperty.isVariantProperty()
                    || (abstractProperty.isBindingProperty()
                        && !abstractProperty.name().contains("anchors.")))
                propertyHash.insert(abstractProperty.name(), QmlObjectNode(node).instanceValue(abstractProperty.name()));
        }

        if (QmlItemNode::isValidQmlItemNode(node)) {
            QmlItemNode itemNode(node);

            propertyHash.insert("width", itemNode.instanceValue("width"));
            propertyHash.insert("height", itemNode.instanceValue("height"));
            propertyHash.remove("x");
            propertyHash.remove("y");
            propertyHash.remove("rotation");
            propertyHash.remove("opacity");
        }
    }

    return propertyHash;
}
Exemplo n.º 5
0
void ObjectHelper::releaseObjectHelper(const Abstract3DRenderer *cacheId, ObjectHelper *&obj)
{
    Q_ASSERT(cacheId);

    if (obj) {
        QHash<QString, ObjectHelperRef *> *objectTable = cacheTable.value(cacheId, 0);
        if (objectTable) {
            // Delete object if last reference is released
            ObjectHelperRef *objRef = objectTable->value(obj->m_objectFile, 0);
            if (objRef) {
                objRef->refCount--;
                if (objRef->refCount <= 0) {
                    objectTable->remove(obj->m_objectFile);
                    delete objRef->obj;
                    delete objRef;
                }
            }
            if (objectTable->isEmpty()) {
                // Remove the entire cache if last object was removed
                cacheTable.remove(cacheId);
                delete objectTable;
            }
        } else {
            // Just delete the object if unknown cache
            delete obj;
        }
        obj = 0;
    }
}
Exemplo n.º 6
0
BattlePStorage::BattlePStorage(BattlePlugin *p)
{
    for (int i = 0; i < lastEnum; i++) {
        calls[i] = NULL;
    }

    QHash<QString, Hook> functions = p->getHooks();

    if (functions.contains("battleStarting(BattleInterface&)")) {
        calls[battleStarting] = functions.value("battleStarting(BattleInterface&)");

        functions.remove("battleStarting(BattleInterface&)");
    }

    if (functions.contains("emitCommand(BattleInterface&,int,int,QByteArray)")) {
        calls[emitCommand] = functions.value("emitCommand(BattleInterface&,int,int,QByteArray)");

        functions.remove("emitCommand(BattleInterface&,int,int,QByteArray)");
    }

    if (!functions.empty()) {
        /* To Do: Some way to propagate an error about unreckognized stuff, maybe cancel the plugin entirely */
    }

    plugin = p;
}
void QGeoTileRequestManagerPrivate::tileFetched(const QGeoTileSpec &spec)
{
    m_map->updateTile(spec);
    m_requested.remove(spec);
    m_retries.remove(spec);
    m_futures.remove(spec);
}
Exemplo n.º 8
0
void LoggerThread::handleItem(LoggingItem *item)
{
    if (item->type & kRegistering)
    {
        int64_t tid = getThreadTid(item);

        QMutexLocker locker(&logThreadMutex);
        logThreadHash[item->threadId] = strdup(item->threadName);

        if (debugRegistration)
        {
            snprintf(item->message, LOGLINE_MAX,
                     "Thread 0x%" PREFIX64 "X (%" PREFIX64 
                     "d) registered as \'%s\'",
                     (long long unsigned int)item->threadId,
                     (long long int)tid,
                     logThreadHash[item->threadId]);
        }
    }
    else if (item->type & kDeregistering)
    {
        int64_t tid = 0;

        {
            QMutexLocker locker(&logThreadTidMutex);
            if( logThreadTidHash.contains(item->threadId) )
            {
                tid = logThreadTidHash[item->threadId];
                logThreadTidHash.remove(item->threadId);
            }
        }

        QMutexLocker locker(&logThreadMutex);
        if (logThreadHash.contains(item->threadId))
        {
            if (debugRegistration)
            {
                snprintf(item->message, LOGLINE_MAX,
                         "Thread 0x%" PREFIX64 "X (%" PREFIX64 
                         "d) deregistered as \'%s\'",
                         (long long unsigned int)item->threadId,
                         (long long int)tid,
                         logThreadHash[item->threadId]);
            }
            item->threadName = logThreadHash[item->threadId];
            logThreadHash.remove(item->threadId);
        }
    }

    if (item->message[0] != '\0')
    {
        QMutexLocker locker(&loggerListMutex);

        QList<LoggerBase *>::iterator it;
        for (it = loggerList.begin(); it != loggerList.end(); ++it)
            (*it)->logmsg(item);
    }
}
QList<QSharedPointer<QGeoTileTexture> > QGeoTileRequestManagerPrivate::requestTiles(const QSet<QGeoTileSpec> &tiles)
{
    QSet<QGeoTileSpec> cancelTiles = requested_ - tiles;
    QSet<QGeoTileSpec> requestTiles = tiles - requested_;
    QSet<QGeoTileSpec> cached;
//    int tileSize = tiles.size();
//    int newTiles = requestTiles.size();

    typedef QSet<QGeoTileSpec>::const_iterator iter;

    QList<QSharedPointer<QGeoTileTexture> > cachedTex;

    QGeoTiledMappingManagerEngine *engine = map_ ?
                static_cast<QGeoTiledMappingManagerEngine *>(map_->engine()) : 0;

    // remove tiles in cache from request tiles
    if (engine) {
        iter i = requestTiles.constBegin();
        iter end = requestTiles.constEnd();
        for (; i != end; ++i) {
            QGeoTileSpec tile = *i;
            QSharedPointer<QGeoTileTexture> tex = engine->getTileTexture(tile);
            if (tex) {
                cachedTex << tex;
                cached.insert(tile);
            }
        }
    }

    requestTiles -= cached;

    requested_ -= cancelTiles;
    requested_ += requestTiles;

//    qDebug() << "required # tiles: " << tileSize << ", new tiles: " << newTiles << ", total server requests: " << requested_.size();

    if (!requestTiles.isEmpty() || !cancelTiles.isEmpty()) {
        if (engine) {
//            qDebug() << "new server requests: " << requestTiles.size() << ", server cancels: " << cancelTiles.size();
            engine->updateTileRequests(map_, requestTiles, cancelTiles);

            // Remove any cancelled tiles from the error retry hash to avoid
            // re-using the numbers for a totally different request cycle.
            iter i = cancelTiles.constBegin();
            iter end = cancelTiles.constEnd();
            for (; i != end; ++i) {
                retries_.remove(*i);
                futures_.remove(*i);
            }
        }
    }

    return cachedTex;
}
Exemplo n.º 10
0
static void patchANSI(QHash<QString, Key>& map){
    map.remove("bslash_iso");
    map.remove("hash");
    Key& enter = map["enter"];
    enter.x = ANSI_ENTER_X;
    enter.y = ANSI_ENTER_Y;
    enter.width = ANSI_ENTER_W;
    enter.height = ANSI_ENTER_H;
    Key& lshift = map["lshift"];
    lshift.x = ANSI_LSHIFT_X;
    lshift.width = ANSI_LSHIFT_W;
}
Exemplo n.º 11
0
 static void PostLoad(const QString &cacheKey)
 {
     m_loadingImagesLock.lock();
     m_loadingImages.remove(cacheKey);
     m_loadingImagesCond.wakeAll();
     m_loadingImagesLock.unlock();
 }
Exemplo n.º 12
0
// Load a theme from a given file
void Global::loadThemeFile(QHash<QString,QString> &resourceList, QFile &file, QString themeName) {
    if (!file.exists())
        return;
    if(!file.open(QIODevice::ReadOnly))
        return;

    QTextStream in(&file);
    bool themeFound = false;
    QString themeHeader = "[" + themeName.trimmed() + "]";
    while(!in.atEnd()) {
        QString line = in.readLine();
        if (!line.startsWith("#")){
            if (line.startsWith("[") && themeHeader != line)
                themeFound = false;
            if (line.startsWith("[") && themeHeader == line)
                themeFound = true;
            if (themeFound && !line.startsWith("[") && line != "") {
                QStringList fields = line.split("=");
                if (fields.size() >= 2) {
                    QString key = fields[0].simplified();
                    QString value = fields[1].split("#").at(0).simplified();
                    QFile f(value);
                    if (f.exists()) {
                        resourceList.remove(":"+key);
                        resourceList.insert(":"+key,value);
                    }
                }
            }
        }
    }

    file.close();
}
Exemplo n.º 13
0
QImage* ResourceManager::getImage(QString path, bool recache)
{
    if (recache && sSourceImageHash.contains(path))
    {
        delete sSourceImageHash[path];
        sSourceImageHash.remove(path);
    }

    if (!sSourceImageHash.contains(path))
    {
        QString fullPath = getResourcePath(path, ResourceManager::FileType_Image);
        QFileInfo fileInfo = QFileInfo (fullPath);

        if (!fileInfo.isFile()) {return NULL;}
        try
        {
            sSourceImageHash.insert(path, new QImage(fullPath));
        }
        catch(char *str)
        {
            printf("File:%s couldn't be loaded.", str);
            return NULL;
        }
    };

    return sSourceImageHash[path];
}
Exemplo n.º 14
0
void VDirectoryTree::updateItemDirectChildren(QTreeWidgetItem *p_item)
{
    QPointer<VDirectory> parentDir;
    if (p_item) {
        parentDir = getVDirectory(p_item);
    } else {
        parentDir = m_notebook->getRootDir();
    }

    const QVector<VDirectory *> &dirs = parentDir->getSubDirs();

    QHash<VDirectory *, QTreeWidgetItem *> itemDirMap;
    int nrChild = p_item ? p_item->childCount() : topLevelItemCount();
    for (int i = 0; i < nrChild; ++i) {
        QTreeWidgetItem *item = p_item ? p_item->child(i) : topLevelItem(i);
        itemDirMap.insert(getVDirectory(item), item);
    }

    for (int i = 0; i < dirs.size(); ++i) {
        VDirectory *dir = dirs[i];
        QTreeWidgetItem *item = itemDirMap.value(dir, NULL);
        if (item) {
            if (p_item) {
                p_item->removeChild(item);
                p_item->insertChild(i, item);
            } else {
                int topIdx = indexOfTopLevelItem(item);
                takeTopLevelItem(topIdx);
                insertTopLevelItem(i, item);
            }

            itemDirMap.remove(dir);
        } else {
            // Insert a new item
            if (p_item) {
                item = new QTreeWidgetItem(p_item);
            } else {
                item = new QTreeWidgetItem(this);
            }

            fillTreeItem(item, dir);
            buildSubTree(item, 1);
        }

        expandSubTree(item);
    }

    // Delete items without corresponding VDirectory
    for (auto iter = itemDirMap.begin(); iter != itemDirMap.end(); ++iter) {
        QTreeWidgetItem *item = iter.value();
        if (p_item) {
            p_item->removeChild(item);
        } else {
            int topIdx = indexOfTopLevelItem(item);
            takeTopLevelItem(topIdx);
        }

        delete item;
    }
}
Exemplo n.º 15
0
static int wrap_gzclose( int fd )
{
    if ( !gzHandles.contains( fd )) return -1;
    int result = gzclose( gzHandles[ fd ] );
    gzHandles.remove( fd );
    return result;
}
Exemplo n.º 16
0
void
Radio_Impl::setGroup(const QString& group)
{
	QString groupName;
	QWidget *window = this->window();
	
	fGroup = group;
	if (window)
		groupName = QString("[%1]/%2").arg(window->objectName()).arg(group);
	else
		groupName = QString("[]/%1").arg(group);
	
	if (fButtonGroup) {
		fButtonGroup->removeButton(this);
		if (fButtonGroup->buttons().size() == 0) {
			sButtonGroups.remove(fButtonGroup->objectName());
			delete fButtonGroup;
		}
	}
	
	fButtonGroup = sButtonGroups[groupName];
	if (!fButtonGroup) {
		fButtonGroup = new QButtonGroup();
		fButtonGroup->setObjectName(groupName);
		sButtonGroups[groupName] = fButtonGroup;
	}
	fButtonGroup->addButton(this);
}
bool QBluetoothServiceInfoPrivate::unregisterService()
{
    if (!registered)
        return false;
    if (serverChannel() == -1)
        return false;
    if ( __fakeServerPorts.key(serverChannel()) != 0) {
#ifdef QT_QNX_BT_BLUETOOTH
        QByteArray b_uuid = attributes.value(QBluetoothServiceInfo::ServiceId).
                value<QBluetoothUuid>().toByteArray();
        b_uuid = b_uuid.mid(1, b_uuid.length() - 2);
        if (bt_spp_close_server(b_uuid.data()) == -1)
            return false;
#else
        if (!ppsSendControlMessage("deregister_server", 0x1101, attributes.value(QBluetoothServiceInfo::ServiceId).value<QBluetoothUuid>(), QString(),
                                   attributes.value(QBluetoothServiceInfo::ServiceName).toString(),
                                   __fakeServerPorts.key(serverChannel()), BT_SPP_SERVER_SUBTYPE)) {
            return false;
        }
#endif
        else {
            __fakeServerPorts.remove(__fakeServerPorts.key(serverChannel()));
            registered = false;
            return true;
        }
    }
    else {
        return false;
    }
}
Exemplo n.º 18
0
int main(int argc, char **argv) {
    Q_UNUSED(argc);
    Q_UNUSED(argv);

    basicCheck();

    QHash<QString, int> hash;
    Trie<int> t;
    while (hash.count() < 500) {
        qDebug() << hash.count();
        QStringList key = generateKey();
        int value = qrand() % 50000;
        hash[key.join(QLatin1String(","))] = value;
        t.insert(key, value);

        QHashIterator<QString, int> i(hash);
        while (i.hasNext()) {
            i.next();
            if (t.find(i.key().split(QLatin1Char(','))).count() == 0)
                qDebug() << i.key();
            Q_ASSERT(t.find(i.key().split(QLatin1Char(','))).count() > 0);
            if (qrand() % 500 == 0) {
                t.remove(i.key().split(QLatin1Char(',')), i.value());
                hash.remove(i.key());
            }
            //cout << i.key() << ": " << i.value() << endl;
        }
    }
    return 0;
}
Exemplo n.º 19
0
void
InfoSystemCache::pruneTimerFired()
{
    qDebug() << Q_FUNC_INFO << "Pruning infosystemcache";
    qlonglong currentMSecsSinceEpoch = QDateTime::currentMSecsSinceEpoch();

    for ( int i = InfoNoInfo; i <= InfoLastInfo; i++ )
    {
        InfoType type = (InfoType)(i);
        QHash< QString, QString > fileLocationHash = m_fileLocationCache[type];
        const QString cacheDirName = m_cacheBaseDir + QString::number( (int)type );
        QFileInfoList fileList = QDir( cacheDirName ).entryInfoList( QDir::Files | QDir::NoDotAndDotDot );
        foreach ( QFileInfo file, fileList )
        {
            QString baseName = file.baseName();
            if ( file.suffix().toLongLong() < currentMSecsSinceEpoch )
            {
                if ( !QFile::remove( file.canonicalFilePath() ) )
                    tLog() << "Failed to remove stale cache file" << file.canonicalFilePath();
                else
                    qDebug() << "Removed stale cache file" << file.canonicalFilePath();
            }
            if ( fileLocationHash.contains( baseName ) )
                fileLocationHash.remove( baseName );
        }
        m_fileLocationCache[type] = fileLocationHash;
    }
Exemplo n.º 20
0
QHash< QString, QString > ImportOEBPS::LoadFolderStructure()
{ 
    QList< QString > keys = m_Files.keys();
    int num_files = keys.count();

    QFutureSynchronizer< tuple< QString, QString > > sync;

    for ( int i = 0; i < num_files; ++i )
    {   
        QString id = keys.at( i );
        sync.addFuture( QtConcurrent::run( 
                this, 
                &ImportOEBPS::LoadOneFile, 
                m_Files.value( id ),
                m_FileMimetypes.value( id ) ) );
    }

    sync.waitForFinished();

    QList< QFuture< tuple< QString, QString > > > futures = sync.futures();
    int num_futures = futures.count();

    QHash< QString, QString > updates;

    for ( int i = 0; i < num_futures; ++i )
    {
        tuple< QString, QString > result = futures.at( i ).result();
        updates[ result.get< 0 >() ] = result.get< 1 >();
    }

    updates.remove( UPDATE_ERROR_STRING );
    return updates;
}
Exemplo n.º 21
0
CompositeKey DatabaseOpenWidget::databaseKey()
{
    CompositeKey masterKey;

    if (m_ui->checkPassword->isChecked()) {
        masterKey.addKey(PasswordKey(m_ui->editPassword->text()));
    }

    QHash<QString, QVariant> lastKeyFiles = config()->get("LastKeyFiles").toHash();

    if (m_ui->checkKeyFile->isChecked()) {
        FileKey key;
        QString keyFilename = m_ui->comboKeyFile->currentText();
        QString errorMsg;
        if (!key.load(keyFilename, &errorMsg)) {
            MessageBox::warning(this, tr("Error"), tr("Can't open key file").append(":\n").append(errorMsg));
            return CompositeKey();
        }
        masterKey.addKey(key);
        lastKeyFiles[m_filename] = keyFilename;
    }
    else {
        lastKeyFiles.remove(m_filename);
    }

    if (config()->get("RememberLastKeyFiles").toBool()) {
        config()->set("LastKeyFiles", lastKeyFiles);
    }

    return masterKey;
}
Exemplo n.º 22
0
//お気に入りを更新
void WebPageForm::Private::updateFavorite(const QString &url, const QString &title, bool add)
{
    bool exist = false;
    bool update = false;

    settings.beginGroup(QStringLiteral(FAV_USER));

    QHash<QString, QVariant> list = settings.value(QStringLiteral(FAV_USER_BOOKMARK)).toHash();
    foreach (const QString &key, list.keys()) {
        if(url == key){
            //見つかった
            exist = true;
            if(add){
                //追加(ただしすでにある)
            }else{
                //削除
                list.remove(url);
                update = true;
            }
            break;
        }
    }
    if(!exist){
        list.insert(url, title);
        update = true;
    }
    if(update)
        settings.setValue(QStringLiteral(FAV_USER_BOOKMARK), list);

    settings.endGroup();
    settings.sync();

    if(update)
        emit q->updateFavorite();
}
QSpotifyPlaylistContainer::~QSpotifyPlaylistContainer()
{
    g_containerObjects.remove(m_container);
    sp_playlistcontainer_remove_callbacks(m_container, m_callbacks, 0);
    qDeleteAll(m_playlists);
    sp_playlistcontainer_release(m_container);
    delete m_callbacks;
}
Exemplo n.º 24
0
void UmlOperation::java(QHash<QByteArray, QByteArray*> & prop)
{
    QByteArray d = JavaSettings::operationDef();
    QByteArray * v;

    if ((v = prop.value("Java/Final")) != 0) {
        if (*v == "TRUE")
            set_isJavaFinal(TRUE);

        prop.remove("Java/Final");
    }

    if ((v = prop.value("Java/Synchronized")) != 0) {
        if (*v == "TRUE")
            set_isJavaSynchronized(TRUE);

        prop.remove("Java/Synchronized");
    }

    if ((v = prop.value("Java/Static")) != 0) {
        if (*v == "TRUE")
            set_isClassMember(TRUE);

        prop.remove("Java/Static");
    }

    if ((v = prop.value("Java/Abstract")) != 0) {
        if (*v == "TRUE")
            set_isAbstract(TRUE);

        prop.remove("Java/Abstract");
    }

    if ((v = prop.value("Java/Strictfp")) != 0) {
        if (*v == "TRUE") {
            int index = d.indexOf("${final}");

            if (index != -1)
                d.insert(index, "strictfp ");
        }

        prop.remove("Java/Strictfp");
    }

    set_JavaDef(d);
}
void RewriteActionCompressor::compressImports(QList<RewriteAction *> &actions) const
{
    QList<RewriteAction *> actionsToRemove;
    QHash<Import, RewriteAction *> addedImports;
    QHash<Import, RewriteAction *> removedImports;

    QMutableListIterator<RewriteAction *> iter(actions);
    iter.toBack();
    while (iter.hasPrevious()) {
        RewriteAction *action = iter.previous();

        if (RemoveImportRewriteAction *removeImportAction = action->asRemoveImportRewriteAction()) {
            const Import import = removeImportAction->import();
            if (removedImports.contains(import)) {
                actionsToRemove.append(action);
            } else if (RewriteAction *addImportAction = addedImports.value(import, 0)) {
                actionsToRemove.append(action);
                actionsToRemove.append(addImportAction);
                addedImports.remove(import);
                delete addImportAction;
            } else {
                removedImports.insert(import, action);
            }
        } else if (AddImportRewriteAction *addImportAction = action->asAddImportRewriteAction()) {
            const Import import = addImportAction->import();
            if (RewriteAction *duplicateAction = addedImports.value(import, 0)) {
                actionsToRemove.append(duplicateAction);
                addedImports.remove(import);
                delete duplicateAction;
                addedImports.insert(import, action);
            } else if (RewriteAction *removeAction = removedImports.value(import, 0)) {
                actionsToRemove.append(action);
                actionsToRemove.append(removeAction);
                removedImports.remove(import);
                delete removeAction;
            } else {
                addedImports.insert(import, action);
            }
        }
    }

    foreach (RewriteAction *action, actionsToRemove) {
        actions.removeOne(action);
        delete action;
    }
Exemplo n.º 26
0
bool GlobalHotImpl::unregister_hot(const QKeySequence &keys) {
  if (keys.isEmpty()) return false;
  Qt::KeyboardModifiers allMods = Qt::ShiftModifier | Qt::ControlModifier | Qt::AltModifier | Qt::MetaModifier;
  quint32 code = native_keycode(Qt::Key((keys[0] ^ allMods) & keys[0]));
  quint32 mods = native_modifiers(Qt::KeyboardModifiers(keys[0] & allMods));
  unregister_hot(code, mods);
  m_shortcuts.remove(qMakePair(code, mods));
  return true;
}
Exemplo n.º 27
0
void FdoSelectionManagerPrivate::handleCancelMessage(const XClientMessageEvent &event)
{
    const WId winId = event.window;
    const long messageId = event.data.l[2];

    if (messageRequests.contains(winId) && messageRequests[winId].messageId == messageId) {
        messageRequests.remove(winId);
    }
}
Exemplo n.º 28
0
void QSpotifySearch::clearSearch(sp_search *search)
{
    QMutexLocker lock(&g_mutex);
    if (search)
        sp_search_release(search);
    g_searchObjects.remove(search);
    if (search == m_sp_search)
        m_sp_search = nullptr;
}
Exemplo n.º 29
0
bool QxtGlobalShortcutPrivate::unregisterShortcut(quint32 nativeKey, quint32 nativeMods)
{
    Identifier id(nativeMods, nativeKey);
    if (!keyIDs.contains(id)) return false;

    EventHotKeyRef ref = keyRefs.take(keyIDs[id]);
    keyIDs.remove(id);
    return !UnregisterEventHotKey(ref);
}
Exemplo n.º 30
0
void HyperBusReciever::destroyStaticHyperBus(const QString &key)
{
    HyperBusReciever *res = static_hyperbus_objs.value(key);
    if(!res)
        return;

    static_hyperbus_objs.remove(key);
    delete res;
}