void Tests::haveChunks()
{
qDebug() << "===== haveChunks() =====";
QList<Common::Hash> hashes;
hashes
<< Common::Hash::fromStr("f6126deaa5e1d9692d54e3bef0507721372ee7f8") // "/sharedDirs/share3/aaaa bbbb cccc.txt"
<< Common::Hash::fromStr("4c24e58c47746ea04296df9342185d9b3a447899") // "/sharedDirs/share1/v.txt"
<< Common::Hash::fromStr("954531aef8ac193ad62f4de783da9d7e6ebd59dd") // "/sharedDirs/share1/y.txt" (deleted)
<< Common::Hash::fromStr("8374d82e993012aa23b293f319eef2c21d2da3b9"); // Random hash
QBitArray expectedResult(hashes.size());
expectedResult[0] = true;
expectedResult[1] = true;
expectedResult[2] = false;
expectedResult[3] = false;
QBitArray result = this->fileManager->haveChunks(hashes);
QCOMPARE(result.size(), hashes.size());
for (int i = 0; i < result.size(); i++)
{
QVERIFY(result[i] == expectedResult[i]);
qDebug() << hashes[i].toStr() << " : " << (result[i] ? "Yes" : "No");
}
}
QBitArray generate(QBitArray aPayload, QBitArray aPoly)
{
using namespace NsConverter;
const int n = aPoly.size();
QBitArray shiftReg(n, false);
for(int i=aPayload.size()-1; i>=0; i--)
{
if( shiftReg[n-1] != aPayload[i] )
{
//qDebug()<<"--------------------";
// qDebug()<<" poly "<<aPoly;
//qDebug()<<" shiftxor before shift"<<shiftReg;
shiftReg = shiftReg<<1;
//qDebug()<<" shiftxor before xor"<<shiftReg;
shiftReg ^= aPoly;
// qDebug()<<" shiftxor after"<<shiftReg;
}
else
{
shiftReg = shiftReg<<1;
}
}
return shiftReg;
}
QByteArray dehuffman(QByteArray data, MainWindow *mainWindow)
{
QHash<quint8, QBitArray> codes;
qint32 size;
QBitArray bits;
{
QDataStream stream(data);
stream >> codes >> size >> bits;
Q_ASSERT(stream.status() == QDataStream::Ok);
}
QHash<QBitArray, quint8> table;
for (int i = 0; i < tableSize; ++i)
if (codes.contains(i)) table[codes[i]] = i;
QByteArray result;
result.reserve(data.size());
int index = 0;
for (int i = 0; i < size; ++i)
{
mainWindow->setProgress(qRound(static_cast<qreal>(100 * i) / size));
QBitArray b;
while (!table.contains(b))
{
b.resize(b.size() + 1);
if (bits[index]) b.setBit(b.size() - 1);
++index;
}
result.append(table[b]);
}
return result;
}
void KisResourcesSnapshot::setupPainter(KisPainter* painter)
{
painter->setPaintColor(m_d->currentFgColor);
painter->setBackgroundColor(m_d->currentBgColor);
painter->setGenerator(m_d->currentGenerator);
painter->setPattern(m_d->currentPattern);
painter->setGradient(m_d->currentGradient);
QBitArray lockflags = channelLockFlags();
if (lockflags.size() > 0) {
painter->setChannelFlags(lockflags);
}
painter->setOpacity(m_d->opacity);
painter->setCompositeOp(m_d->compositeOp);
painter->setMirrorInformation(m_d->axesCenter, m_d->mirrorMaskHorizontal, m_d->mirrorMaskVertical);
painter->setStrokeStyle(m_d->strokeStyle);
painter->setFillStyle(m_d->fillStyle);
/**
* The paintOp should be initialized the last, because it may
* ask the painter for some options while initialization
*/
painter->setPaintOpPreset(m_d->currentPaintOpPreset, m_d->image);
}
Number(const QBitArray &bitArray)
{
bits = bitArray.size();
value = 0;
for (quint8 i=0; i<bits; i++)
if (bitArray.at(i)) value += 1 << (bits-i-1);
}
static QBitArray tryCompress(const QBitArray &data)
{
qint32 closest = data.size();
for (quint8 i=32; i>0; i--) {
Count most, least;
count(data, i, most, least);
least = leastCommon(compress(data, most.number, Number()));
if (least.number.bits >= most.number.bits) break;
QBitArray compressed = compress(data, most.number, least.number);
if (compressed.size() < data.size()) return compressed;
closest = qMin(closest, compressed.size()-data.size());
}
qDebug("Could not compress, got as close as %d bits", closest);
return data;
}
// Sends the complete list of pieces that we have downloaded.
void PeerWireClient::sendPieceList(const QBitArray &bitField)
{
// The bitfield message may only be sent immediately after the
// handshaking sequence is completed, and before any other
// messages are sent.
if (!sentHandShake)
sendHandShake();
// Don't send the bitfield if it's all zeros.
if (bitField.count(true) == 0)
return;
int bitFieldSize = bitField.size();
int size = (bitFieldSize + 7) / 8;
QByteArray bits(size, '\0');
for (int i = 0; i < bitFieldSize; ++i) {
if (bitField.testBit(i)) {
quint32 byte = quint32(i) / 8;
quint32 bit = quint32(i) % 8;
bits[byte] = uchar(bits.at(byte)) | (1 << (7 - bit));
}
}
char message[] = {0, 0, 0, 1, 5};
toNetworkData(bits.size() + 1, &message[0]);
write(message, sizeof(message));
write(bits);
}
bool ARehabMainWindow::validateJointSelection(void)
{
bool validate = true, someBitActive = false;
//QBitArray nullBitArray(21, false);
//QBitArray bitArray = jointSelectorWidget->getJointSelectorModel();
QBitArray bitArray = jointSelectorWidget->getJointSelectorModel();
for (unsigned int i = 0; i < bitArray.size(); ++i)
{
someBitActive |= jointSelectorWidget->getJointSelectorModel()[i];
}
if (!someBitActive)
{
ui.lbValidationJoints->setPixmap(QPixmap(QString::fromUtf8(":/svg/bad.svg")));
//ui.lbValidationJoints->show();
validate = false;
}
else
{
this->arehabFileMetadata.jointsInvolved = this->jointSelectorWidget->getJointSelectorModel();
ui.lbValidationJoints->setPixmap(QPixmap(QString::fromUtf8(":/svg/checked.svg")));
//ui.lbValidationJoints->show();
}
return validate;
}
bool PropertyBitmaskConverter::applyMaskWithInValues_helper(QVariant &inVariant, QVariant &outVariant)
{
bool ok(true);
QBitArray inBitRepres = variantToBitArray(inVariant, ok);
qDebug()<<"In value \t"<<inBitRepres;
if (!ok)
return ok;
QBitArray outBitRepres = variantToBitArray(outVariant, ok);
qDebug()<<"Out value \t"<<outBitRepres;
if (!ok)
return ok;
Q_ASSERT(!_bitmaskFromInternal.isNull());
QBitArray maskCopy = _bitmaskFromInternal;
if (outBitRepres.count() != 0)
maskCopy.truncate(outBitRepres.size());
else
outBitRepres.resize(maskCopy.count());
inBitRepres.truncate(maskCopy.count());
qDebug()<<"Mask (mod)\t"<<maskCopy;
//! \todo optimize and beautify it
if (inVariant.type() == QVariant::Bool)
inBitRepres = maskCopy;
else
inBitRepres &= (maskCopy);//get only masked bits
outBitRepres &= (~maskCopy);//clear mask bits
outBitRepres |= inBitRepres;//set relevant bits from mask
qDebug()<<"Out res\t"<<outBitRepres;
return variantFromBitArray(outVariant, outBitRepres);
}
QBitArray BuddyMonitor::ShouldRevealNyms(const QBitArray &nyms)
{
if(m_min_anon == 0) {
return nyms;
}
Q_ASSERT(nyms.size() == m_bp->GetCount());
QList<QBitArray> member_set = m_member_set;
QBitArray useful_members = GetUsefulMembers();
QBitArray rv(nyms.size(), false);
for(int idx = 0; idx < m_bp->GetCount(); idx++) {
if(!nyms[idx]) {
continue;
}
QBitArray new_set = m_nym_set[idx] & useful_members;
if(new_set.count(true) < m_min_anon) {
continue;
}
QList<QBitArray> t_member_set = member_set;
bool bad = false;
for(int jdx = 0; jdx < m_bp->GetCount(); jdx++) {
if(useful_members[jdx]) {
continue;
}
if(member_set[jdx][idx] && member_set[jdx].count(true) == m_min_anon) {
bad = true;
break;
}
member_set[jdx][idx] = false;
}
if(bad) {
member_set = t_member_set;
} else {
rv[idx] = true;
}
}
Q_ASSERT((nyms | rv) == nyms);
Q_ASSERT(rv.size() <= nyms.size());
return rv;
}
/******************************************************************************
* Replaces the particle selection.
******************************************************************************/
void ParticleSelectionSet::setParticleSelection(const PipelineFlowState& state, const QBitArray& selection, SelectionMode mode)
{
// Make a backup of the old snapshot so it may be restored.
if(dataset()->undoStack().isRecording())
dataset()->undoStack().push(new ReplaceSelectionOperation(this));
ParticlePropertyObject* identifierProperty = ParticlePropertyObject::findInState(state, ParticleProperty::IdentifierProperty);
if(identifierProperty && useIdentifiers()) {
OVITO_ASSERT(selection.size() == identifierProperty->size());
_selection.clear();
int index = 0;
if(mode == SelectionReplace) {
_selectedIdentifiers.clear();
for(int id : identifierProperty->constIntRange()) {
if(selection.testBit(index++))
_selectedIdentifiers.insert(id);
}
}
else if(mode == SelectionAdd) {
for(int id : identifierProperty->constIntRange()) {
if(selection.testBit(index++))
_selectedIdentifiers.insert(id);
}
}
else if(mode == SelectionSubtract) {
for(int id : identifierProperty->constIntRange()) {
if(selection.testBit(index++))
_selectedIdentifiers.remove(id);
}
}
}
else {
_selectedIdentifiers.clear();
if(mode == SelectionReplace)
_selection = selection;
else if(mode == SelectionAdd) {
_selection.resize(selection.size());
_selection |= selection;
}
else if(mode == SelectionSubtract) {
_selection.resize(selection.size());
_selection &= ~selection;
}
}
notifyDependents(ReferenceEvent::TargetChanged);
}
int CompassPort::toDecInt(QBitArray bitdata)
{
int res = 0;
int k=1,s=0;
if(bitdata[0] == true)
{
bitdata=~bitdata;
k=-1;
s=1;
}
for(int i = 0;i < bitdata.size();i++)
{
res+=pow(2,i)*bitdata[(bitdata.size()-1)-i];
}
return (res+s)*k;
}
int Kompas::toDecInt(QBitArray bitdata)
{
int res = 0;
int k=1,s=0;
if(bitdata[0] == true)
{
//bitdata=bitdata - QBitArray(16).setBit(15,true);
bitdata=~bitdata;
k=-1;
s=1;
}
for(int i = 0;i < bitdata.size();i++)
{
res+=pow(2,i)*bitdata[(bitdata.size()-1)-i];
}
return (res+s)*k;
}
quint32 CBerBitStringStorage::serialize(CBerByteArrayOutputStream& berOStream, QObject* obj)
{
QBitArray BA = *ptrValue(obj, 3);
quint32 codeLength = 0;
for (qint32 i = BA.size()-1; i >= 0; --i)
{
quint8 data = (BA[i] == false) ? 0 : 0xFF;
berOStream.write(data);
}
berOStream.write( (quint8) (BA.size()) );
codeLength = BA.size() + 1;
CBerLength::encodeLength(berOStream, codeLength);
return codeLength;
}
void KisChannelFlagsWidget::setChannelFlags(const QBitArray & cf)
{
dbgUI << "KisChannelFlagsWidget::setChannelFlags " << cf.isEmpty();
if (cf.isEmpty()) return;
QBitArray channelFlags = m_colorSpace->setChannelFlagsToColorSpaceOrder(cf);
for (int i = 0; i < qMin(m_channelChecks.size(), channelFlags.size()); ++i) {
m_channelChecks.at(i)->setChecked(channelFlags.testBit(i));
}
}
void EventsModel::setFilterTypes(const QBitArray &typemap)
{
bool fast = true;
if (!m_filter.types.isNull() && m_filter.types.size() == typemap.size())
{
for (int i = 0; i < typemap.size(); ++i)
{
if (typemap[i] && !m_filter.types[i])
{
fast = false;
break;
}
}
}
m_filter.types = typemap;
applyFilters(!fast);
}
QString BaseStateAbstract::write(QBitArray barray)
{
QString ret;
for (int i = 0; i < barray.size(); i++) {
if (barray.at(i))
ret.append(B_ONE);
else
ret.append(B_ZERO);
}
return ret;
}
static QBitArray compress(const QBitArray &data, const Number &before, const Number &after)
{
const int bits = before.bits;
Number beforeSize(before.bits, 5);
Number afterSize(after.bits, 5);
QBitArray result(data.size() + beforeSize.bits + before.bits);
quint64 resultIndex = 0;
for (quint8 i=0; i<beforeSize.bits; i++) result.setBit(resultIndex + i, beforeSize[i]);
resultIndex += beforeSize.bits;
for (quint8 i=0; i<before.bits; i++) result.setBit(resultIndex + i, before[i]);
resultIndex += before.bits;
for (quint8 i=0; i<afterSize.bits; i++) result.setBit(resultIndex + i, afterSize[i]);
resultIndex += afterSize.bits;
for (quint8 i=0; i<after.bits; i++) result.setBit(resultIndex + i, after[i]);
resultIndex += after.bits;
Number index(0, bits);
for (quint8 i=0; i<bits-1; i++)
index << data.at(i);
quint64 i = 0;
while (i < data.size()-bits) {
index << data.at(i + bits - 1);
if (index == before) {
for (quint8 j=0; j<after.bits; j++) result.setBit(resultIndex+j, after[j]);
resultIndex += after.bits;
i += before.bits;
} else {
result.setBit(resultIndex++, data.at(i++));
}
}
while (i < data.size())
result.setBit(resultIndex++, data.at(i++));
result.resize(resultIndex);
return result;
}
int main(int argc, char *argv[])
{
if (argc != 2) {
printf("compress <file>\n");
return 1;
}
QFile file(argv[1]);
file.open(QFile::ReadOnly);
QByteArray byteArray = file.readAll();
file.close();
QBitArray data(8*byteArray.size());
for (int i=0; i<byteArray.size(); i++)
for (int j=0; j<8; j++)
data.setBit(i*8+j, byteArray[i] & (1 << j));
QBitArray result = tryCompress(data);
qDebug("Size change = %d", data.size() - result.size());
return 0;
}
QBitArray KisChannelFlagsWidget::channelFlags() const
{
bool allTrue = true;
QBitArray ba(m_channelChecks.size());
for (int i = 0; i < m_channelChecks.size(); ++i) {
bool flag = m_channelChecks.at(i)->isChecked();
if (!flag) allTrue = false;
ba.setBit(i, flag);
dbgUI << " channel " << i << " is " << flag << ", allTrue = " << allTrue << ", so ba.testBit("<<i<<")" << " is " << ba.testBit(i);
}
if (allTrue)
return QBitArray();
else {
QBitArray result = m_colorSpace->setChannelFlagsToPixelOrder(ba);
for (int i = 0; i < result.size(); ++i) {
dbgUI << "On conversion to the pixel order, flag " << i << " is " << result.testBit(i);
}
return result;
}
}
void tst_QBitArray::resize()
{
// -- check that a resize handles the bits correctly
QBitArray a = QStringToQBitArray(QString("11"));
a.resize(10);
QVERIFY(a.size() == 10);
QCOMPARE( a, QStringToQBitArray(QString("1100000000")) );
a.setBit(9);
a.resize(9);
// now the bit in a should have been gone:
QCOMPARE( a, QStringToQBitArray(QString("110000000")) );
// grow the array back and check the new bit
a.resize(10);
QCOMPARE( a, QStringToQBitArray(QString("1100000000")) );
// other test with and
a.resize(9);
QBitArray b = QStringToQBitArray(QString("1111111111"));
b &= a;
QCOMPARE( b, QStringToQBitArray(QString("1100000000")) );
}
static void count(const QBitArray &data, quint8 bits, Count &most, Count &least)
{
Number index(0, bits);
for (quint8 i=0; i<bits-1; i++)
index << data.at(i);
const quint64 size = quint64(1) << bits;
quint8 *counts = new quint8[size];
memset(counts, 0, size);
for (quint64 i=0; i<data.size()-bits; i++) {
index << data.at(i + bits - 1);
if (counts[index] < 255) counts[index]++;
}
most = Count(Number(), 0);
least = Count(Number(), 255);
for (quint64 i=0; i<size; i++) {
if (counts[i] > most.count) most = Count(Number(i, bits), counts[i]);
if (counts[i] < least.count) least = Count(Number(i, bits), counts[i]);
}
delete[] counts;
}
/// not threadsafe
i64 DataFile::readScans(std::vector<int16> & scans_out, u64 pos, u64 num2read, const QBitArray & channelSubset, unsigned downSampleFactor)
{
if (pos > scanCt) return -1;
if (num2read + pos > scanCt) num2read = scanCt - pos;
QBitArray chset = channelSubset;
if (chset.size() != (i64)nChans) chset.fill(true, nChans);
if (downSampleFactor <= 0) downSampleFactor = 1;
unsigned nChansOn = chset.count(true);
int sizeofscans;
if ( (num2read / downSampleFactor) * downSampleFactor < num2read )
sizeofscans = ((num2read / downSampleFactor)+1) * nChansOn;
else
sizeofscans = ((num2read / downSampleFactor)) * nChansOn;
scans_out.resize(sizeofscans);
u64 cur = pos;
i64 nout = 0;
std::vector<int> onChans;
onChans.reserve(chset.size());
for (int i = 0, n = chset.size(); i < n; ++i)
if (chset.testBit(i)) onChans.push_back(i);
qint64 maxBufSize = nChans*sRate*1; // read about max 1sec worth of data at a time as an optimization
qint64 desiredBufSize = num2read*nChans; // but first try and do the entire requested read at once in our buffer if it fits within our limits..
if (desiredBufSize > maxBufSize) desiredBufSize = maxBufSize;
std::vector<int16> buf(desiredBufSize);
if (int(buf.size()) < nChans) buf.resize(nChans); // minimum read is 1 scan
while (cur < pos + num2read) {
if (!dataFile.seek(cur * sizeof(int16) * nChans)) {
Error() << "Error seeking in dataFile::readScans()!";
scans_out.clear();
return -1;
}
qint64 nr = dataFile.read(reinterpret_cast<char *>(&buf[0]), sizeof(int16) * buf.size());
if (nr < int(sizeof(int16) * nChans)) {
Error() << "Short read in dataFile::readScans()!";
scans_out.clear();
return -1;
}
int nscans = int(nr/sizeof(int16))/nChans;
if (nscans <= 0) {
Error() << "Short read in dataFile::readScans()... nscans <= 0!";
scans_out.clear();
return -1;
}
const int16 *bufptr = &buf[0];
const int onChansSize = int(onChans.size());
const int skip = nChans*downSampleFactor;
for (int sc = 0; sc < nscans && cur < pos + num2read; /* .. */) {
if (int(nChansOn) == nChans) {
i64 i_out = nout * nChans;
for (int i = 0; i < nChans; ++i)
scans_out[i_out + i] = int16(bufptr[i]);
} else {
// not all chans on, put subset 1 by 1 in the output vector
i64 i_out = nout*i64(nChansOn);
for (int i = 0; i < onChansSize; ++i)
scans_out[i_out++] = int16(bufptr[onChans[i]]);
}
++nout;
bufptr += skip;
sc += downSampleFactor;
cur += downSampleFactor;
}
}
return nout;
}
QByteArray huffman(QByteArray data, MainWindow *mainWindow)
{
// count
int count[tableSize];
qFill(&count[0], &count[tableSize - 1], 0);
for (int i = 0; i < data.size(); ++i)
++count[static_cast<quint8>(data[i])];
QMultiMap<int, QList<QPair<quint8, QBitArray> > > p; // <count, <symbol, code> >
for (int i = 0; i < tableSize; ++i)
{
if (count[i] == 0) continue;
QList<QPair<quint8, QBitArray> > list;
list.append(qMakePair(static_cast<quint8>(i), QBitArray()));
p.insert(count[i], list);
}
// caculate codes from bottom to top
while (p.size() > 1)
{
const int count0 = p.begin().key();
QList<QPair<quint8, QBitArray> > list0 = p.begin().value();
p.erase(p.begin());
const int count1 = p.begin().key();
QList<QPair<quint8, QBitArray> > list1 = p.begin().value();
p.erase(p.begin());
for (QList<QPair<quint8, QBitArray> >::Iterator iter = list0.begin(); iter != list0.end(); ++iter)
{
iter->second.resize(iter->second.size() + 1);
iter->second.setBit(iter->second.size() - 1, false);
}
for (QList<QPair<quint8, QBitArray> >::Iterator iter = list1.begin(); iter != list1.end(); ++iter)
{
iter->second.resize(iter->second.size() + 1);
iter->second.setBit(iter->second.size() - 1, true);
}
p.insert(count0 + count1, list0 + list1);
}
// extract codes
QHash<quint8, QBitArray> codes;
for (QList<QPair<quint8, QBitArray> >::ConstIterator iter = p.begin().value().constBegin(); iter != p.begin().value().constEnd(); ++iter)
{
QBitArray code;
code.resize(iter->second.size());
for (int j = 0; j < code.size(); ++j)
if (iter->second[code.size() - j - 1])
code.setBit(j);
codes[iter->first] = code;
}
// encode
QBitArray bits;
for (int i = 0; i < data.size(); ++i)
{
mainWindow->setProgress(qRound(static_cast<qreal>(100 * i) / data.size()));
const QBitArray &code = codes[static_cast<quint8>(data[i])];
const int oldSize = bits.size();
bits.resize(oldSize + code.size());
for (int i = 0; i < code.size(); ++i)
if (code[i]) bits.setBit(oldSize + i);
}
QByteArray result;
{
QDataStream stream(&result, QIODevice::WriteOnly);
stream << codes << static_cast<qint32>(data.size()) << bits;
}
return result;
}
QVector<float> DownloadedPiecesBar::bitfieldToFloatVector(const QBitArray &vecin, int reqSize)
{
QVector<float> result(reqSize, 0.0);
if (vecin.isEmpty()) return result;
const float ratio = vecin.size() / (float)reqSize;
// simple linear transformation algorithm
// for example:
// image.x(0) = pieces.x(0.0 >= x < 1.7)
// image.x(1) = pieces.x(1.7 >= x < 3.4)
for (int x = 0; x < reqSize; ++x) {
// don't use previously calculated value "ratio" here!!!
// float cannot save irrational number like 7/9, if this number will be rounded up by std::ceil
// give you x2 == pieces.size(), and index out of range: pieces[x2]
// this code is safe, so keep that in mind when you try optimize more.
// tested with size = 3000000ul
// R - real
const float fromR = (x * vecin.size()) / (float)reqSize;
const float toR = ((x + 1) * vecin.size()) / (float)reqSize;
// C - integer
int fromC = fromR;// std::floor not needed
int toC = std::ceil(toR);
// position in pieces table
// libtorrent::bitfield::m_size is unsigned int(31 bits), so qlonglong is not needed
// tested with size = 3000000ul
int x2 = fromC;
// little speed up for really big pieces table, 10K+ size
const int toCMinusOne = toC - 1;
// value in returned vector
float value = 0;
// case when calculated range is (15.2 >= x < 15.7)
if (x2 == toCMinusOne) {
if (vecin[x2]) {
value += toR - fromR;
}
++x2;
}
// case when (15.2 >= x < 17.8)
else {
// subcase (15.2 >= x < 16)
if (x2 != fromR) {
if (vecin[x2]) {
value += 1.0 - (fromR - fromC);
}
++x2;
}
// subcase (16 >= x < 17)
for (; x2 < toCMinusOne; ++x2) {
if (vecin[x2]) {
value += 1.0;
}
}
// subcase (17 >= x < 17.8)
if (x2 == toCMinusOne) {
if (vecin[x2]) {
value += 1.0 - (toC - toR);
}
++x2;
}
}
// normalization <0, 1>
value /= ratio;
// float precision sometimes gives > 1, because in not possible to store irrational numbers
value = qMin(value, (float)1.0);
result[x] = value;
}
return result;
}
//! \internal
void XmlPreferencesPrivate::writeSection(XmlWriter& out, const QString& name, const Section& section)
{
QHash<QString,QString> attrs;
attrs.insert("name", name);
out.writeOpenTag("section", attrs);
attrs.clear();
for (Section::ConstIterator sectionIterator = section.constBegin();
sectionIterator != section.constEnd(); ++sectionIterator)
{
const EncVariant& v = sectionIterator.value();
attrs.insert("name", sectionIterator.key());
switch (v.data.type())
{
case QVariant::String :
attrs.insert("type", "string");
out.writeTaggedString("setting", v.data.toString(), attrs);
break;
case QVariant::StringList :
{
attrs.insert("type", "stringlist");
out.writeOpenTag("setting", attrs);
attrs.clear();
QStringList list = v.data.toStringList();
for (int i = 0; i < list.size(); ++i)
out.writeTaggedString("value", list.at(i), attrs);
out.writeCloseTag("setting");
}
break;
case QVariant::Bool :
attrs.insert("type", "bool");
out.writeTaggedString("setting", v.data.toBool() ? "true" : "false", attrs);
break;
case QVariant::Int :
attrs.insert("type", "int");
out.writeTaggedString("setting", QString::number(v.data.toInt()), attrs);
break;
case QVariant::LongLong :
attrs.insert("type", "int64");
out.writeTaggedString("setting", QString::number(v.data.toLongLong()), attrs);
break;
case QVariant::Rect :
{
attrs.insert("type", "rect");
QRect rect = v.data.toRect();
QString s = QString("%1;%2;%3;%4").arg(rect.x()).arg(rect.y()).arg(rect.width()).arg(rect.height());
out.writeTaggedString("setting", s, attrs);
}
break;
case QVariant::Point :
{
attrs.insert("type", "point");
QPoint point = v.data.toPoint();
QString s = QString("%1;%2").arg(point.x()).arg(point.y());
out.writeTaggedString("setting", s, attrs);
}
break;
case QVariant::Size :
{
attrs.insert("type", "size");
QSize size = v.data.toSize();
QString s = QString("%1;%2").arg(size.width()).arg(size.height());
out.writeTaggedString("setting", s, attrs);
}
break;
case QVariant::ByteArray :
{
attrs.insert("type", "bytearray");
const QByteArray ba = v.data.toByteArray();
switch (v.encoding)
{
case XmlPreferences::Base64:
attrs.insert("encoding", "base64");
out.writeTaggedString("setting", Base64::encode(ba), attrs);
break;
default:
attrs.insert("encoding", "csv");
QString s;
for (uint i = 0; i < (uint) ba.size(); ++i)
(i != 0) ? s += "," + QString::number((uint)ba.at(i), 16) : s += QString::number((uint)ba.at(i), 16);
out.writeTaggedString("setting", s, attrs);
}
attrs.clear();
}
break;
case QVariant::BitArray :
{
attrs.insert("type", "bitarray");
const QBitArray ba = v.data.toBitArray();
attrs.insert("size", QString::number(ba.size()));
switch (v.encoding)
{
case XmlPreferences::Base64:
attrs.insert("encoding", "base64");
out.writeTaggedString("setting", Base64::encode(ba), attrs);
break;
default:
attrs.insert("encoding", "csv");
QString s;
for (uint i = 0; i < (uint) ba.size(); ++i)
(i != 0) ? s += ba.testBit(i) ? ",1" : ",0" : s += ba.testBit(i) ? "1" : "0";
out.writeTaggedString("setting", s, attrs);
}
attrs.clear();
}
break;
#ifndef QT_CORE_ONLY
case QVariant::Color :
attrs.insert("type", "color");
out.writeTaggedString("setting", v.data.value<QColor>().name(), attrs);
break;
#endif // QT_CORE_ONLY
default:
;
}
}
out.writeCloseTag("section");
}
void UDPListener::processPendingMulticastDatagrams()
{
while (this->multicastSocket.hasPendingDatagrams())
{
QHostAddress peerAddress;
const Common::MessageHeader& header = UDPListener::readDatagramToBuffer(this->multicastSocket, peerAddress);
if (header.isNull())
continue;
switch (header.getType())
{
case Common::MessageHeader::CORE_IM_ALIVE:
{
Protos::Core::IMAlive IMAliveMessage;
const bool readOk = IMAliveMessage.ParseFromArray(this->bodyBuffer, header.getSize());
if (!readOk)
{
L_WARN(QString("Unable to read the IMAlive message from peer %1 %2").arg(header.getSenderID().toStr()).arg(peerAddress.toString()));
break;
}
else if (IMAliveMessage.version() != PROTOCOL_VERSION) // If the protocol version doesn't match we don't add the peer.
{
L_WARN(
QString("The peer %1 %2 %3 doesn't have the same protocol version (%4) as us (%5). It will be ignored.")
.arg(Common::ProtoHelper::getStr(IMAliveMessage, &Protos::Core::IMAlive::nick))
.arg(header.getSenderID().toStr())
.arg(peerAddress.toString())
.arg(IMAliveMessage.version())
.arg(PROTOCOL_VERSION)
);
break;
}
this->peerManager->updatePeer(
header.getSenderID(),
peerAddress,
IMAliveMessage.port(),
Common::ProtoHelper::getStr(IMAliveMessage, &Protos::Core::IMAlive::nick),
IMAliveMessage.amount(),
Common::ProtoHelper::getStr(IMAliveMessage, &Protos::Core::IMAlive::core_version)
);
if (IMAliveMessage.chunk_size() > 0)
{
QList<Common::Hash> hashes;
hashes.reserve(IMAliveMessage.chunk_size());
for (int i = 0; i < IMAliveMessage.chunk_size(); i++)
hashes << IMAliveMessage.chunk(i).hash();
QBitArray bitArray = this->fileManager->haveChunks(hashes);
if (!bitArray.isNull()) // If we own at least one chunk we reply with a CHUNKS_OWNED message.
{
Protos::Core::ChunksOwned chunkOwnedMessage;
chunkOwnedMessage.set_tag(IMAliveMessage.tag());
chunkOwnedMessage.mutable_chunk_state()->Reserve(bitArray.size());
for (int i = 0; i < bitArray.size(); i++)
chunkOwnedMessage.add_chunk_state(bitArray[i]);
this->send(Common::MessageHeader::CORE_CHUNKS_OWNED, header.getSenderID(), chunkOwnedMessage);
}
}
}
break;
case Common::MessageHeader::CORE_CHAT_MESSAGE:
{
Protos::Core::ChatMessage chatMessage;
chatMessage.ParseFromArray(this->bodyBuffer, header.getSize());
emit newChatMessage(header.getSenderID(), chatMessage);
}
break;
case Common::MessageHeader::CORE_FIND: // Find.
{
Protos::Core::Find findMessage;
findMessage.ParseFromArray(this->bodyBuffer, header.getSize());
QList<Protos::Common::FindResult> results =
this->fileManager->find(
Common::ProtoHelper::getStr(findMessage, &Protos::Core::Find::pattern),
SETTINGS.get<quint32>("max_number_of_search_result_to_send"),
SETTINGS.get<quint32>("max_udp_datagram_size") - Common::MessageHeader::HEADER_SIZE
);
for (QMutableListIterator<Protos::Common::FindResult> i(results); i.hasNext();)
{
Protos::Common::FindResult& result = i.next();
result.set_tag(findMessage.tag());
this->send(Common::MessageHeader::CORE_FIND_RESULT, header.getSenderID(), result);
}
}
break;
default:
L_WARN(QString("Unkown header type from multicast socket : %1").arg(header.getType(), 0, 16));
}
}
}
void InputDaemon::modifyUnplugEvents(QQueue<SDL_Event> *sdlEventQueue)
{
QHashIterator<InputDevice*, InputDeviceBitArrayStatus*> genIter(releaseEventsGenerated);
while (genIter.hasNext())
{
genIter.next();
InputDevice *device = genIter.key();
InputDeviceBitArrayStatus *generatedTemp = genIter.value();
QBitArray tempBitArray = generatedTemp->generateFinalBitArray();
//qDebug() << "ARRAY: " << tempBitArray;
unsigned int bitArraySize = tempBitArray.size();
//qDebug() << "ARRAY SIZE: " << bitArraySize;
if (bitArraySize > 0 && tempBitArray.count(true) == bitArraySize)
{
if (pendingEventValues.contains(device))
{
InputDeviceBitArrayStatus *pendingTemp = pendingEventValues.value(device);
QBitArray pendingBitArray = pendingTemp->generateFinalBitArray();
QBitArray unplugBitArray = createUnplugEventBitArray(device);
unsigned int pendingBitArraySize = pendingBitArray.size();
if (bitArraySize == pendingBitArraySize &&
pendingBitArray == unplugBitArray)
{
QQueue<SDL_Event> tempQueue;
while (!sdlEventQueue->isEmpty())
{
SDL_Event event = sdlEventQueue->dequeue();
switch (event.type)
{
case SDL_JOYBUTTONDOWN:
case SDL_JOYBUTTONUP:
{
tempQueue.enqueue(event);
break;
}
case SDL_JOYAXISMOTION:
{
if (event.jaxis.which != device->getSDLJoystickID())
{
tempQueue.enqueue(event);
}
else
{
InputDevice *joy = trackjoysticks.value(event.jaxis.which);
if (joy)
{
JoyAxis *axis = joy->getActiveSetJoystick()->getJoyAxis(event.jaxis.axis);
if (axis)
{
if (axis->getThrottle() != JoyAxis::NormalThrottle)
{
event.jaxis.value = axis->getProperReleaseValue();
}
}
}
tempQueue.enqueue(event);
}
break;
}
case SDL_JOYHATMOTION:
{
tempQueue.enqueue(event);
break;
}
case SDL_CONTROLLERAXISMOTION:
{
if (event.caxis.which != device->getSDLJoystickID())
{
tempQueue.enqueue(event);
}
else
{
InputDevice *joy = trackcontrollers.value(event.caxis.which);
if (joy)
{
SetJoystick* set = joy->getActiveSetJoystick();
JoyAxis *axis = set->getJoyAxis(event.caxis.axis);
if (axis)
{
if (event.caxis.axis == SDL_CONTROLLER_AXIS_TRIGGERLEFT ||
event.caxis.axis == SDL_CONTROLLER_AXIS_TRIGGERRIGHT)
{
event.caxis.value = axis->getProperReleaseValue();
}
}
}
tempQueue.enqueue(event);
}
break;
}
case SDL_CONTROLLERBUTTONDOWN:
case SDL_CONTROLLERBUTTONUP:
{
tempQueue.enqueue(event);
break;
}
case SDL_JOYDEVICEREMOVED:
case SDL_JOYDEVICEADDED:
{
tempQueue.enqueue(event);
break;
}
default:
{
tempQueue.enqueue(event);
}
}
}
sdlEventQueue->swap(tempQueue);
}
}
}
}
}
void SerialDecoderNode::inputsUpdated( qint64 pTimeStamp )
{
if( mPinInputBits->isUpdated( pTimeStamp ) )
{
QBitArray InpDat = variant( mPinInputBits ).toBitArray();
if( !InpDat.isEmpty() )
{
QBitArray SrcDat;
QByteArray DstDat;
// Prepend any buffered data
if( !mBitBuf.isEmpty() )
{
int InpSze = InpDat.size();
int BufSze = mBitBuf.size();
SrcDat.resize( BufSze + InpSze );
for( int i = 0 ; i < BufSze ; i++ )
{
SrcDat.setBit( i, mBitBuf.testBit( i ) );
}
for( int i = 0 ; i < InpSze ; i++ )
{
SrcDat.setBit( BufSze + i, InpDat.testBit( i ) );
}
mBitBuf.clear();
}
else
{
SrcDat.swap( InpDat );
}
// Look for data
// qDebug() << "R:" << SrcDat;
int SrcOff;
for( SrcOff = 0 ; SrcOff < SrcDat.size() - 9 ; )
{
if( SrcDat.testBit( SrcOff ) || !SrcDat.testBit( SrcOff + 9 ) )
{
SrcOff++;
continue;
}
QBitArray T( 8 );
quint8 C = 0;
for( int j = 0 ; j < 8 ; j++ )
{
C |= ( SrcDat.testBit( SrcOff + 1 + j ) ? 0x01 : 0x00 ) << j;
T.setBit( j, SrcDat.testBit( SrcOff + 1 + j ) );
}
// qDebug() << SrcOff << T;
DstDat.append( C );
SrcOff += 10;
}
if( SrcOff < SrcDat.size() )
{
if( SrcOff > 0 )
{
mBitBuf.resize( SrcDat.size() - SrcOff );
for( int i = 0 ; i < mBitBuf.size() ; i++ )
{
mBitBuf.setBit( i, SrcDat.testBit( SrcOff + i ) );
}
}
else
{
SrcDat.swap( mBitBuf );
}
// qDebug() << "B" << mBitBuf;
}
if( !DstDat.isEmpty() )
{
mValOutputData->setVariant( DstDat );
pinUpdated( mPinOutputData );
}
}
}
}
