void UIWizardFirstRunPage::onOpenMediumWithFileOpenDialog() { /* Get opened vboxMedium id: */ QUuid uMediumId; vboxGlobal().openMediumSelectorDialog(thisImp(), UIMediumDeviceType_DVD, uMediumId, "", "", "", true); /* Update medium-combo if necessary: */ if (!uMediumId.isNull()) m_pMediaSelector->setCurrentItem(uMediumId); }
void CtcpParser::parseStandard(IrcEventRawMessage *e, Message::Type messagetype, QByteArray dequotedMessage, CtcpEvent::CtcpType ctcptype, Message::Flags flags) { QByteArray ctcp; QList<CtcpEvent *> ctcpEvents; QUuid uuid; // needed to group all replies together // extract tagged / extended data int xdelimPos = -1; int xdelimEndPos = -1; int spacePos = -1; while ((xdelimPos = dequotedMessage.indexOf(XDELIM)) != -1) { if (xdelimPos > 0) displayMsg(e, messagetype, targetDecode(e, dequotedMessage.left(xdelimPos)), e->prefix(), e->target(), flags); xdelimEndPos = dequotedMessage.indexOf(XDELIM, xdelimPos + 1); if (xdelimEndPos == -1) { // no matching end delimiter found... treat rest of the message as ctcp xdelimEndPos = dequotedMessage.count(); } ctcp = xdelimDequote(dequotedMessage.mid(xdelimPos + 1, xdelimEndPos - xdelimPos - 1)); dequotedMessage = dequotedMessage.mid(xdelimEndPos + 1); //dispatch the ctcp command QString ctcpcmd = targetDecode(e, ctcp.left(spacePos)); QString ctcpparam = targetDecode(e, ctcp.mid(spacePos + 1)); spacePos = ctcp.indexOf(' '); if (spacePos != -1) { ctcpcmd = targetDecode(e, ctcp.left(spacePos)); ctcpparam = targetDecode(e, ctcp.mid(spacePos + 1)); } else { ctcpcmd = targetDecode(e, ctcp); ctcpparam = QString(); } ctcpcmd = ctcpcmd.toUpper(); // we don't want to block /me messages by the CTCP ignore list if (ctcpcmd == QLatin1String("ACTION") || !coreSession()->ignoreListManager()->ctcpMatch(e->prefix(), e->network()->networkName(), ctcpcmd)) { if (uuid.isNull()) uuid = QUuid::createUuid(); CtcpEvent *event = new CtcpEvent(EventManager::CtcpEvent, e->network(), e->prefix(), e->target(), ctcptype, ctcpcmd, ctcpparam, e->timestamp(), uuid); ctcpEvents << event; } } if (!ctcpEvents.isEmpty()) { _replies.insert(uuid, CtcpReply(coreNetwork(e), nickFromMask(e->prefix()))); CtcpEvent *flushEvent = new CtcpEvent(EventManager::CtcpEventFlush, e->network(), e->prefix(), e->target(), ctcptype, "INVALID", QString(), e->timestamp(), uuid); ctcpEvents << flushEvent; foreach(CtcpEvent *event, ctcpEvents) { emit newEvent(event); }
static QString stripCurlyBraces(const QUuid &uuid) { if (uuid.isNull()) return QString(); QString result = uuid.toString().toUpper(); result.chop(1); result.remove(0, 1); return result; }
void LimitedNodeList::fillPacketHeader(const NLPacket& packet, const QUuid& connectionSecret) { if (!NON_SOURCED_PACKETS.contains(packet.getType())) { packet.writeSourceID(getSessionUUID()); } if (!connectionSecret.isNull() && !NON_SOURCED_PACKETS.contains(packet.getType()) && !NON_VERIFIED_PACKETS.contains(packet.getType())) { packet.writeVerificationHashGivenSecret(connectionSecret); } }
bool fromJson(const QJsonObject& obj) { if (!obj["id"].isString() || !obj["x"].isDouble() || !obj["y"].isDouble()) { return false; } id = obj["id"].toString(); pos = QPointF(obj["x"].toDouble(), obj["y"].toDouble()); return !id.isNull(); }
void ClientTransferManager::onCoreTransferAdded(const QUuid &uuid) { if (uuid.isNull()) { qWarning() << Q_FUNC_INFO << "Invalid transfer uuid" << uuid.toString(); return; } auto transfer = new ClientTransfer(uuid, this); connect(transfer, SIGNAL(initDone()), SLOT(onTransferInitDone())); // we only want to add initialized transfers Client::signalProxy()->synchronize(transfer); }
void Node::addIgnoredNode(const QUuid& otherNodeID) { if (!otherNodeID.isNull() && otherNodeID != _uuid) { qCDebug(networking) << "Adding" << uuidStringWithoutCurlyBraces(otherNodeID) << "to ignore set for" << uuidStringWithoutCurlyBraces(_uuid); // add the session UUID to the set of ignored ones for this listening node _ignoredNodeIDSet.insert(otherNodeID); } else { qCWarning(networking) << "Node::addIgnoredNode called with null ID or ID of ignoring node."; } }
QList<btRigidBody*> ObjectConstraintSlider::getRigidBodies() { QList<btRigidBody*> result; result += getRigidBody(); QUuid otherEntityID; withReadLock([&]{ otherEntityID = _otherID; }); if (!otherEntityID.isNull()) { result += getOtherRigidBody(otherEntityID); } return result; }
int populatePacketHeader(char* packet, PacketType type, const QUuid& connectionUUID) { int numTypeBytes = packArithmeticallyCodedValue(type, packet); packet[numTypeBytes] = versionForPacketType(type); QUuid packUUID = connectionUUID.isNull() ? NodeList::getInstance()->getOwnerUUID() : connectionUUID; QByteArray rfcUUID = packUUID.toRfc4122(); memcpy(packet + numTypeBytes + sizeof(PacketVersion), rfcUUID.constData(), NUM_BYTES_RFC4122_UUID); // return the number of bytes written for pointer pushing return numTypeBytes + sizeof(PacketVersion) + NUM_BYTES_RFC4122_UUID; }
btTypedConstraint* ObjectConstraintBallSocket::getConstraint() { btPoint2PointConstraint* constraint { nullptr }; QUuid otherEntityID; glm::vec3 pivotInA; glm::vec3 pivotInB; withReadLock([&]{ constraint = static_cast<btPoint2PointConstraint*>(_constraint); pivotInA = _pivotInA; otherEntityID = _otherID; pivotInB = _pivotInB; }); if (constraint) { return constraint; } static QString repeatedBallSocketNoRigidBody = LogHandler::getInstance().addRepeatedMessageRegex( "ObjectConstraintBallSocket::getConstraint -- no rigidBody.*"); btRigidBody* rigidBodyA = getRigidBody(); if (!rigidBodyA) { qCDebug(physics) << "ObjectConstraintBallSocket::getConstraint -- no rigidBodyA"; return nullptr; } if (!otherEntityID.isNull()) { // This constraint is between two entities... find the other rigid body. btRigidBody* rigidBodyB = getOtherRigidBody(otherEntityID); if (!rigidBodyB) { qCDebug(physics) << "ObjectConstraintBallSocket::getConstraint -- no rigidBodyB"; return nullptr; } constraint = new btPoint2PointConstraint(*rigidBodyA, *rigidBodyB, glmToBullet(pivotInA), glmToBullet(pivotInB)); } else { // This constraint is between an entity and the world-frame. constraint = new btPoint2PointConstraint(*rigidBodyA, glmToBullet(pivotInA)); } withWriteLock([&]{ _constraint = constraint; }); // if we don't wake up rigidBodyA, we may not send the dynamicData property over the network forceBodyNonStatic(); activateBody(); updateBallSocket(); return constraint; }
void AssignmentClientMonitor::handleChildStatusPacket(QSharedPointer<ReceivedMessage> message) { // read out the sender ID QUuid senderID = QUuid::fromRfc4122(message->readWithoutCopy(NUM_BYTES_RFC4122_UUID)); auto nodeList = DependencyManager::get<NodeList>(); SharedNodePointer matchingNode = nodeList->nodeWithUUID(senderID); const HifiSockAddr& senderSockAddr = message->getSenderSockAddr(); AssignmentClientChildData* childData = nullptr; if (!matchingNode) { // The parent only expects to be talking with prorams running on this same machine. if (senderSockAddr.getAddress() == QHostAddress::LocalHost || senderSockAddr.getAddress() == QHostAddress::LocalHostIPv6) { if (!senderID.isNull()) { // We don't have this node yet - we should add it matchingNode = DependencyManager::get<LimitedNodeList>()->addOrUpdateNode(senderID, NodeType::Unassigned, senderSockAddr, senderSockAddr); auto childData = std::unique_ptr<AssignmentClientChildData> { new AssignmentClientChildData(Assignment::Type::AllTypes) }; matchingNode->setLinkedData(std::move(childData)); } else { // tell unknown assignment-client child to exit. qDebug() << "Asking unknown child at" << senderSockAddr << "to exit."; auto diePacket = NLPacket::create(PacketType::StopNode, 0); nodeList->sendPacket(std::move(diePacket), senderSockAddr); return; } } } else { childData = dynamic_cast<AssignmentClientChildData*>(matchingNode->getLinkedData()); } if (childData) { // update our records about how to reach this child matchingNode->setLocalSocket(senderSockAddr); // get child's assignment type out of the packet quint8 assignmentType; message->readPrimitive(&assignmentType); childData->setChildType(Assignment::Type(assignmentType)); // note when this child talked matchingNode->setLastHeardMicrostamp(usecTimestampNow()); } }
bool fromJson(const QJsonObject& obj) { if (!obj["id"].isString() || !obj["w"].isDouble() || !obj["h"].isDouble() || !obj["centered"].isBool()) { return false; } id = obj["id"].toString(); size = QSizeF(obj["w"].toDouble(), obj["h"].toDouble()); fixedPoint = obj["centered"].toBool() ? WindowPoint::CENTER : WindowPoint::TOP_LEFT; return !id.isNull(); }
QUuid PlaylistWindow::getItemAfter(QUuid list, QUuid item) { auto pl = PlaylistCollection::getSingleton()->playlistOf(list); if (!pl) return QUuid(); QUuid uuid = pl->queueTakeFirst(); if (!uuid.isNull()) return uuid; QSharedPointer<Item> after = pl->itemAfter(item); if (!after) return QUuid(); return after->uuid(); }
void Node::removeIgnoredNode(const QUuid& otherNodeID) { if (!otherNodeID.isNull() && otherNodeID != _uuid) { // insert/find are read locked concurrently. unsafe_erase is not concurrent, and needs a write lock. QWriteLocker lock { &_ignoredNodeIDSetLock }; qCDebug(networking) << "Removing" << uuidStringWithoutCurlyBraces(otherNodeID) << "from ignore set for" << uuidStringWithoutCurlyBraces(_uuid); // remove the session UUID from the set of ignored ones for this listening node _ignoredNodeIDSet.unsafe_erase(otherNodeID); } else { qCWarning(networking) << "Node::removeIgnoredNode called with null ID or ID of ignoring node."; } }
void UnplacedComponentsDock::on_lstUnplacedComponents_currentItemChanged(QListWidgetItem *current, QListWidgetItem *previous) { Q_UNUSED(previous); GenCompInstance* genComp = nullptr; if (mBoard && current) { QUuid genCompUuid = current->data(Qt::UserRole).toUuid(); Q_ASSERT(genCompUuid.isNull() == false); genComp = mProject.getCircuit().getGenCompInstanceByUuid(genCompUuid); } setSelectedGenCompInstance(genComp); }
bool OctreePacketData::appendValue(const QUuid& uuid) { QByteArray bytes = uuid.toRfc4122(); if (uuid.isNull()) { return appendValue((uint16_t)0); // zero length for null uuid } else { uint16_t length = bytes.size(); bool success = appendValue(length); if (success) { success = appendRawData((const unsigned char*)bytes.constData(), bytes.size()); } return success; } }
/*static*/ QString XmlNoteReader::findUuid(const QUuid uuid, const QString &path) { if(uuid.isNull()) return QString(); QDirIterator it(path, QDirIterator::Subdirectories); while(it.hasNext()) { QString filePath = it.next(); if(uuid == XmlNoteReader::uuid(filePath)) return filePath; } return QString(); }
void Node::addIgnoredNode(const QUuid& otherNodeID) { if (!otherNodeID.isNull() && otherNodeID != _uuid) { QWriteLocker lock { &_ignoredNodeIDSetLock }; qCDebug(networking) << "Adding" << uuidStringWithoutCurlyBraces(otherNodeID) << "to ignore set for" << uuidStringWithoutCurlyBraces(_uuid); // add the session UUID to the set of ignored ones for this listening node if (std::find(_ignoredNodeIDs.begin(), _ignoredNodeIDs.end(), otherNodeID) == _ignoredNodeIDs.end()) { _ignoredNodeIDs.push_back(otherNodeID); } } else { qCWarning(networking) << "Node::addIgnoredNode called with null ID or ID of ignoring node."; } }
void CDTMapToolSelectTrainingSamples::setSampleID(QUuid id) { if (id.isNull()) return; clearRubberBand(); model->clear(); model->setQuery(QString("select name,id from category where imageid = " "(select imageid from segmentationlayer where id = " "(select segmentationid from sample_segmentation " "where id = '%1'))").arg(id), QSqlDatabase::database("category")); sampleID = id; updateRubber(); }
QUuid ContextPrivate::registerExternalAsset( const QString &pFileName ) { QUuid AssIdx = mAssetMap.key( pFileName ); if( !AssIdx.isNull() ) { return( AssIdx ); } AssIdx = QUuid::createUuid(); mAssetMap.insert( AssIdx, pFileName ); return( AssIdx ); }
void Node::removeIgnoredNode(const QUuid& otherNodeID) { if (!otherNodeID.isNull() && otherNodeID != _uuid) { QWriteLocker lock { &_ignoredNodeIDSetLock }; qCDebug(networking) << "Removing" << uuidStringWithoutCurlyBraces(otherNodeID) << "from ignore set for" << uuidStringWithoutCurlyBraces(_uuid); // remove the session UUID from the set of ignored ones for this listening node, if it exists auto it = std::remove(_ignoredNodeIDs.begin(), _ignoredNodeIDs.end(), otherNodeID); if (it != _ignoredNodeIDs.end()) { _ignoredNodeIDs.erase(it); } } else { qCWarning(networking) << "Node::removeIgnoredNode called with null ID or ID of ignoring node."; } }
QString RecordBase::EncodeGuid ( const QUuid& uid ) { if (uid.isNull() == false) { QString guidStr = uid.toString(); guidStr.remove(QChar('{')).remove(QChar('}')); return guidStr; } return QString(); }
/*static*/ QUuid XmlNoteReader::parseUuid(QString idStr) { QUuid uuid; // try to parse the rightmost 32 digits and four hyphens uuid = QUuid(idStr.rightRef(32 + 4).toString()); if(uuid.isNull()) // if parsing fails, try more complex parsing { if(idStr.leftRef(QString("urn:uuid:").length()) == "urn:uuid:") // check if first 9 chars match "urn:uuid:" { QStringRef uuidRef = idStr.midRef(QString("urn:uuid:").length(),32+4); //32 digits and four hyphens uuid = QUuid(uuidRef.toString()); } else // try to parse the whole string { uuid = QUuid(idStr.simplified()); } } if(uuid.isNull()) qDebug("XmlNoteReader::parseUuid : error parsing UUID, null UUID has been generated"); return uuid; }
qint64 LimitedNodeList::writePacket(const NLPacket& packet, const HifiSockAddr& destinationSockAddr, const QUuid& connectionSecret) { if (!NON_SOURCED_PACKETS.contains(packet.getType())) { const_cast<NLPacket&>(packet).writeSourceID(getSessionUUID()); } if (!connectionSecret.isNull() && !NON_SOURCED_PACKETS.contains(packet.getType()) && !NON_VERIFIED_PACKETS.contains(packet.getType())) { const_cast<NLPacket&>(packet).writeVerificationHash(packet.payloadHashWithConnectionUUID(connectionSecret)); } emit dataSent(NodeType::Unassigned, packet.getDataSize()); return writeDatagram(QByteArray::fromRawData(packet.getData(), packet.getDataSize()), destinationSockAddr); }
/** Construct to hold the node that connects to the backend using 'frontend' */ Nodes::Nodes(Frontend frontend) { QUuid uid = frontend.UID(); if (uid.isNull()) return; d.reset( new NodesPvt() ); QMutexLocker lkr( &(d->datamutex) ); d->frontends.insert( uid, frontend ); d->free_frontends.append(uid); d->nodesem.reset( new QSemaphore(d->frontends.count()) ); }
Thing::Thing(const QUuid& specificUid) : m_qp_takerOwner(0) { //this is in general a bad thing, and the reason why uuids don't have operator=. HOWEVER, // in certain situations it's ok to do this, such as if an object will live on in a frozen state // (on disk, etc) if (specificUid.isNull()) { //can never allow an invalid one m_uid = QUuid::createUuid(); } else { m_uid = specificUid; } }
void CChatSessionG2::OnCHATANS(G2Packet *pPacket) { char szType[9]; quint32 nLength = 0, nNext = 0; bool bAccepted = false; while(pPacket->ReadPacket(&szType[0], nLength)) { nNext = pPacket->m_nPosition + nLength; if(strcmp("USERGUID", szType) == 0 && nLength >= 16) { QUuid oGUID; oGUID = pPacket->ReadGUID(); if( !oGUID.isNull() ) { m_oGUID = oGUID; emit guidChanged(oGUID); } } else if (strcmp("ACCEPT", szType) == 0 ) { emit systemMessage("Private conversation accepted, you're now chatting with " + m_sNick); qDebug() << "chat accepted"; bAccepted = true; } else if( strcmp("DENY", szType) == 0 ) { emit systemMessage("Private conversation denied by remote host, sorry."); qDebug() << "chat denied"; CNetworkConnection::Close(); return; } else if( strcmp("AWAY", szType) == 0 ) { emit systemMessage(m_sNick + " is away."); qDebug() << "he is away"; bAccepted = true; } pPacket->m_nPosition = nNext; } if( bAccepted ) m_nState = csActive; }
// This method is called when the edit packet layer has determined that it has a fully formed packet destined for // a known nodeID. void OctreeEditPacketSender::queuePacketToNode(const QUuid& nodeUUID, unsigned char* buffer, size_t length, qint64 satoshiCost) { bool wantDebug = false; DependencyManager::get<NodeList>()->eachNode([&](const SharedNodePointer& node){ // only send to the NodeTypes that are getMyNodeType() if (node->getType() == getMyNodeType() && ((node->getUUID() == nodeUUID) || (nodeUUID.isNull())) && node->getActiveSocket()) { // pack sequence number int numBytesPacketHeader = numBytesForPacketHeader(reinterpret_cast<char*>(buffer)); unsigned char* sequenceAt = buffer + numBytesPacketHeader; quint16 sequence = _outgoingSequenceNumbers[nodeUUID]++; memcpy(sequenceAt, &sequence, sizeof(quint16)); // send packet QByteArray packet(reinterpret_cast<const char*>(buffer), length); queuePacketForSending(node, packet); if (hasDestinationWalletUUID() && satoshiCost > 0) { // if we have a destination wallet UUID and a cost associated with this packet, signal that it // needs to be sent emit octreePaymentRequired(satoshiCost, nodeUUID, _destinationWalletUUID); } // add packet to history _sentPacketHistories[nodeUUID].packetSent(sequence, packet); // debugging output... if (wantDebug) { int numBytesPacketHeader = numBytesForPacketHeader(reinterpret_cast<const char*>(buffer)); unsigned short int sequence = (*((unsigned short int*)(buffer + numBytesPacketHeader))); quint64 createdAt = (*((quint64*)(buffer + numBytesPacketHeader + sizeof(sequence)))); quint64 queuedAt = usecTimestampNow(); quint64 transitTime = queuedAt - createdAt; qDebug() << "OctreeEditPacketSender::queuePacketToNode() queued " << buffer[0] << " - command to node bytes=" << length << " satoshiCost=" << satoshiCost << " sequence=" << sequence << " transitTimeSoFar=" << transitTime << " usecs"; } } }); }
SessionManager::Locker SessionManager::getDataByCookie(Cookies &cookies) { QUuid id; // get the cookie if (cookies.contains("WEXUS_SESSION_UUID")) id = QUuid(cookies["WEXUS_SESSION_UUID"].toString()); // make a new id if needed if (id.isNull()) { id = QUuid::createUuid(); cookies["WEXUS_SESSION_UUID"] = id.toString(); } // finally, extract the session return getData(id); }
SpatiallyNestableWeakPointer InterfaceParentFinder::find(QUuid parentID, bool& success, SpatialParentTree* entityTree) const { SpatiallyNestableWeakPointer parent; if (parentID.isNull()) { success = true; return parent; } // search entities if (entityTree) { parent = entityTree->findByID(parentID); } else { auto treeRenderer = qApp->getEntities(); EntityTreePointer tree = treeRenderer ? treeRenderer->getTree() : nullptr; parent = tree ? tree->findEntityByEntityItemID(parentID) : nullptr; } if (!parent.expired()) { success = true; return parent; } // search avatars QSharedPointer<AvatarManager> avatarManager = DependencyManager::get<AvatarManager>(); parent = avatarManager->getAvatarBySessionID(parentID); if (!parent.expired()) { success = true; return parent; } if (parentID == AVATAR_SELF_ID) { success = true; return avatarManager->getMyAvatar(); } // search overlays auto& overlays = qApp->getOverlays(); auto overlay = overlays.getOverlay(parentID); parent = std::dynamic_pointer_cast<SpatiallyNestable>(overlay); // this will return nullptr for non-3d overlays if (!parent.expired()) { success = true; return parent; } success = false; return parent; }