bool ChannelModel::setData(const QModelIndex& index, const QVariant& value, int role)
{
if (m_currentLayer.isValid() && index.isValid())
{
QList<KoChannelInfo*> channels = m_currentLayer->colorSpace()->channels();
int channelIndex = KoChannelInfo::displayPositionToChannelIndex(index.row(), channels);
if (role == Qt::CheckStateRole) {
Q_ASSERT(index.row() < rowCount());
Q_ASSERT(index.column() < columnCount());
if (index.column() == 0) {
QBitArray flags = m_currentLayer->channelFlags();
flags = flags.isEmpty() ? m_currentLayer->colorSpace()->channelFlags(true, true) : flags;
flags.setBit(channelIndex, value.toInt() == Qt::Checked);
m_currentLayer->setChannelFlags(flags);
}
else { //if (index.column() == 1)
KisPaintLayer* paintLayer = dynamic_cast<KisPaintLayer*>(m_currentLayer.data());
QBitArray flags = paintLayer->channelLockFlags();
flags = flags.isEmpty() ? m_currentLayer->colorSpace()->channelFlags(true, true) : flags;
flags.setBit(channelIndex, value.toInt() == Qt::Unchecked);
paintLayer->setChannelLockFlags(flags);
}
m_currentLayer->setDirty();
return true;
}
}
return false;
}
QVariant ChannelModel::data(const QModelIndex& index, int role) const
{
if (m_currentLayer.isValid() && index.isValid())
{
QList<KoChannelInfo*> channels = m_currentLayer->colorSpace()->channels();
int channelIndex = KoChannelInfo::displayPositionToChannelIndex(index.row(), channels);
switch (role) {
case Qt::DisplayRole:
{
return channels.at(channelIndex)->name();
}
case Qt::CheckStateRole: {
Q_ASSERT(index.row() < rowCount());
Q_ASSERT(index.column() < columnCount());
if (index.column() == 0) {
QBitArray flags = m_currentLayer->channelFlags();
return (flags.isEmpty() || flags.testBit(channelIndex)) ? Qt::Checked : Qt::Unchecked;
}
QBitArray flags = dynamic_cast<const KisPaintLayer*>(m_currentLayer.data())->channelLockFlags();
return (flags.isEmpty() || flags.testBit(channelIndex)) ? Qt::Unchecked : Qt::Checked;
}
}
}
return QVariant();
}
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 KisConvolutionFilter::process(KisConstProcessingInformation srcInfo,
KisProcessingInformation dstInfo,
const QSize& size,
const KisFilterConfiguration* config,
KoUpdater* progressUpdater
) const
{
Q_UNUSED(config);
const KisPaintDeviceSP src = srcInfo.paintDevice();
KisPaintDeviceSP dst = dstInfo.paintDevice();
QPoint dstTopLeft = dstInfo.topLeft();
QPoint srcTopLeft = srcInfo.topLeft();
Q_ASSERT(src != 0);
Q_ASSERT(dst != 0);
KisConvolutionPainter painter(dst, dstInfo.selection());
QBitArray channelFlags;
if (config) {
channelFlags = config->channelFlags();
}
if (channelFlags.isEmpty() || !config) {
channelFlags = QBitArray(src->colorSpace()->channelCount(), true);
}
// disable alpha channel
channelFlags.clearBit(1);
painter.setChannelFlags(channelFlags);
painter.setProgress(progressUpdater);
painter.applyMatrix(m_matrix, src, srcTopLeft, dstTopLeft, size, BORDER_REPEAT);
}
void KisConvolutionFilter::process(KisPaintDeviceSP device,
const QRect& applyRect,
const KisFilterConfiguration* config,
KoUpdater* progressUpdater) const
{
Q_UNUSED(config);
QPoint srcTopLeft = applyRect.topLeft();
Q_ASSERT(device != 0);
KisConvolutionPainter painter(device);
QBitArray channelFlags;
if (config) {
channelFlags = config->channelFlags();
}
if (channelFlags.isEmpty() || !config) {
channelFlags = QBitArray(device->colorSpace()->channelCount(), true);
}
painter.setChannelFlags(channelFlags);
painter.setProgress(progressUpdater);
painter.applyMatrix(m_matrix, device, srcTopLeft, srcTopLeft, applyRect.size(), BORDER_REPEAT);
}
bool KoList::continueNumbering(int level) const
{
Q_ASSERT(level > 0 && level <= 10);
level = qMax(qMin(level, 10), 1);
QBitArray bitArray = d->properties.value(ContinueNumbering).toBitArray();
if (bitArray.isEmpty())
return false;
return bitArray.testBit(level-1);
}
void KisBlurFilter::processImpl(KisPaintDeviceSP device,
const QRect& rect,
const KisFilterConfiguration* config,
KoUpdater* progressUpdater
) const
{
QPoint srcTopLeft = rect.topLeft();
Q_ASSERT(device != 0);
if (!config) config = new KisFilterConfiguration(id().id(), 1);
QVariant value;
int shape = (config->getProperty("shape", value)) ? value.toInt() : 0;
uint halfWidth = (config->getProperty("halfWidth", value)) ? value.toUInt() : 5;
uint width = 2 * halfWidth + 1;
uint halfHeight = (config->getProperty("halfHeight", value)) ? value.toUInt() : 5;
uint height = 2 * halfHeight + 1;
int rotate = (config->getProperty("rotate", value)) ? value.toInt() : 0;
int strength = 100 - (config->getProperty("strength", value) ? value.toUInt() : 0);
int hFade = (halfWidth * strength) / 100;
int vFade = (halfHeight * strength) / 100;
KisMaskGenerator* kas;
dbgKrita << width << "" << height << "" << hFade << "" << vFade;
switch (shape) {
case 1:
kas = new KisRectangleMaskGenerator(width, width / height , hFade, vFade, 2);
break;
case 0:
default:
kas = new KisCircleMaskGenerator(width, width / height, hFade, vFade, 2);
break;
}
QBitArray channelFlags;
if (config) {
channelFlags = config->channelFlags();
}
if (channelFlags.isEmpty() || !config) {
channelFlags = QBitArray(device->colorSpace()->channelCount(), true);
}
KisConvolutionKernelSP kernel = KisConvolutionKernel::fromMaskGenerator(kas, rotate * M_PI / 180.0);
delete kas;
KisConvolutionPainter painter(device);
painter.setChannelFlags(channelFlags);
painter.setProgress(progressUpdater);
painter.applyMatrix(kernel, device, srcTopLeft, srcTopLeft, rect.size(), BORDER_REPEAT);
}
QBitArray KisResourcesSnapshot::channelLockFlags() const
{
QBitArray channelFlags;
KisPaintLayer *paintLayer;
if ((paintLayer = dynamic_cast<KisPaintLayer*>(m_d->currentNode.data()))) {
channelFlags = paintLayer->channelLockFlags();
if (m_d->globalAlphaLock) {
if (channelFlags.isEmpty()) {
channelFlags = paintLayer->colorSpace()->channelFlags(true, true);
}
channelFlags &= paintLayer->colorSpace()->channelFlags(true, false);
}
}
return channelFlags;
}
void KoList::setContinueNumbering(int level, bool enable)
{
Q_ASSERT(level > 0 && level <= 10);
level = qMax(qMin(level, 10), 1);
QBitArray bitArray = d->properties[ContinueNumbering].toBitArray();
if (bitArray.isEmpty())
bitArray.resize(10);
bitArray.setBit(level-1, enable);
d->properties[ContinueNumbering] = bitArray;
QTextList *textList = d->textLists.value(level-1).data();
if (!textList)
return;
QTextListFormat format = textList->format();
if (enable) {
format.setProperty(KListStyle::ContinueNumbering, true);
} else {
format.clearProperty(KListStyle::ContinueNumbering);
}
textList->setFormat(format);
}
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;
}
void KisGaussianBlurFilter::process(KisPaintDeviceSP device,
const QRect& rect,
const KisFilterConfiguration* config,
KoUpdater* progressUpdater
) const
{
QPoint srcTopLeft = rect.topLeft();
Q_ASSERT(device != 0);
if (!config) config = new KisFilterConfiguration(id().id(), 1);
QVariant value;
config->getProperty("horizRadius", value);
uint horizontalRadius = value.toUInt();
config->getProperty("vertRadius", value);
uint verticalRadius = value.toUInt();
QBitArray channelFlags;
if (config) {
channelFlags = config->channelFlags();
}
if (channelFlags.isEmpty() || !config) {
channelFlags = QBitArray(device->colorSpace()->channelCount(), true);
}
// compute horizontal kernel
uint horizKernelSize = horizontalRadius * 2 + 1;
Matrix<qreal, Dynamic, Dynamic> horizGaussian(1, horizKernelSize);
qreal horizSigma = horizontalRadius;
const qreal horizMultiplicand = 1 / (2 * M_PI * horizSigma * horizSigma);
const qreal horizExponentMultiplicand = 1 / (2 * horizSigma * horizSigma);
for (uint x = 0; x < horizKernelSize; x++)
{
uint xDistance = qAbs((int)horizontalRadius - (int)x);
horizGaussian(0, x) = horizMultiplicand * exp( -(qreal)((xDistance * xDistance) + (horizontalRadius * horizontalRadius)) * horizExponentMultiplicand );
}
// compute vertical kernel
uint verticalKernelSize = verticalRadius * 2 + 1;
Matrix<qreal, Dynamic, Dynamic> verticalGaussian(verticalKernelSize, 1);
qreal verticalSigma = verticalRadius;
const qreal verticalMultiplicand = 1 / (2 * M_PI * verticalSigma * verticalSigma);
const qreal verticalExponentMultiplicand = 1 / (2 * verticalSigma * verticalSigma);
for (uint y = 0; y < verticalKernelSize; y++)
{
uint yDistance = qAbs((int)verticalRadius - (int)y);
verticalGaussian(y, 0) = verticalMultiplicand * exp( -(qreal)((yDistance * yDistance) + (verticalRadius * verticalRadius)) * verticalExponentMultiplicand );
}
if ( (horizontalRadius > 0) && (verticalRadius > 0) )
{
KisPaintDeviceSP interm = new KisPaintDevice(device->colorSpace());
KisConvolutionKernelSP kernelHoriz = KisConvolutionKernel::fromMatrix(horizGaussian, 0, horizGaussian.sum());
KisConvolutionKernelSP kernelVertical = KisConvolutionKernel::fromMatrix(verticalGaussian, 0, verticalGaussian.sum());
KisConvolutionPainter horizPainter(interm);
horizPainter.setChannelFlags(channelFlags);
horizPainter.setProgress(progressUpdater);
horizPainter.applyMatrix(kernelHoriz, device,
srcTopLeft - QPoint(0, verticalRadius),
srcTopLeft - QPoint(0, verticalRadius),
rect.size() + QSize(0, 2 * verticalRadius), BORDER_REPEAT);
KisConvolutionPainter verticalPainter(device);
verticalPainter.setChannelFlags(channelFlags);
verticalPainter.setProgress(progressUpdater);
verticalPainter.applyMatrix(kernelVertical, interm, srcTopLeft, srcTopLeft, rect.size(), BORDER_REPEAT);
}
else
{
if (horizontalRadius > 0)
{
KisConvolutionPainter painter(device);
painter.setChannelFlags(channelFlags);
painter.setProgress(progressUpdater);
KisConvolutionKernelSP kernelHoriz = KisConvolutionKernel::fromMatrix(horizGaussian, 0, horizGaussian.sum());
painter.applyMatrix(kernelHoriz, device, srcTopLeft, srcTopLeft, rect.size(), BORDER_REPEAT);
}
if (verticalRadius > 0)
{
KisConvolutionPainter painter(device);
painter.setChannelFlags(channelFlags);
painter.setProgress(progressUpdater);
KisConvolutionKernelSP kernelVertical = KisConvolutionKernel::fromMatrix(verticalGaussian, 0, verticalGaussian.sum());
painter.applyMatrix(kernelVertical, device, srcTopLeft, srcTopLeft, rect.size(), BORDER_REPEAT);
}
}
}
void KisUnsharpFilter::process(KisPaintDeviceSP device,
const QRect& applyRect,
const KisFilterConfiguration* config,
KoUpdater* progressUpdater
) const
{
QPointer<KoUpdater> filterUpdater = 0;
QPointer<KoUpdater> convolutionUpdater = 0;
KoProgressUpdater* updater = 0;
if (progressUpdater) {
updater = new KoProgressUpdater(progressUpdater);
updater->start();
// Two sub-sub tasks that each go from 0 to 100.
convolutionUpdater = updater->startSubtask();
filterUpdater = updater->startSubtask();
}
if (!config) config = new KisFilterConfiguration(id().id(), 1);
QVariant value;
uint halfSize = (config->getProperty("halfSize", value)) ? value.toUInt() : 5;
uint brushsize = 2 * halfSize + 1;
double amount = (config->getProperty("amount", value)) ? value.toDouble() : 0.5;
uint threshold = (config->getProperty("threshold", value)) ? value.toUInt() : 10;
KisCircleMaskGenerator* kas = new KisCircleMaskGenerator(brushsize, 1, halfSize, halfSize, 2);
KisConvolutionKernelSP kernel = KisConvolutionKernel::fromMaskGenerator(kas);
KisPaintDeviceSP interm = new KisPaintDevice(*device);
const KoColorSpace * cs = interm->colorSpace();
KoConvolutionOp * convolutionOp = cs->convolutionOp();
KisConvolutionPainter painter(interm); // TODO no need for a full copy and then a transaction
if (progressUpdater) {
painter.setProgress(convolutionUpdater);
}
QBitArray channelFlags = config->channelFlags();
if (channelFlags.isEmpty()) {
channelFlags = cs->channelFlags();
}
painter.setChannelFlags(channelFlags);
painter.beginTransaction("convolution step");
painter.applyMatrix(kernel, interm, applyRect.topLeft(), applyRect.topLeft(), applyRect.size(), BORDER_REPEAT);
painter.deleteTransaction();
if (progressUpdater && progressUpdater->interrupted()) {
return;
}
KisHLineIteratorSP dstIt = device->createHLineIteratorNG(applyRect.x(), applyRect.y(), applyRect.width());
KisHLineConstIteratorSP intermIt = interm->createHLineConstIteratorNG(applyRect.x(), applyRect.y(), applyRect.width());
int cdepth = cs -> pixelSize();
quint8 *colors[2];
colors[0] = new quint8[cdepth];
colors[1] = new quint8[cdepth];
int pixelsProcessed = 0;
qreal weights[2];
qreal factor = 128;
// XXX: Added static cast to avoid warning
weights[0] = static_cast<qreal>(factor * (1. + amount));
weights[1] = static_cast<qreal>(-factor * amount);
int steps = 100 / applyRect.width() * applyRect.height();
for (int j = 0; j < applyRect.height(); j++) {
do {
quint8 diff = cs->difference(dstIt->oldRawData(), intermIt->oldRawData());
if (diff > threshold) {
memcpy(colors[0], dstIt->oldRawData(), cdepth);
memcpy(colors[1], intermIt->oldRawData(), cdepth);
convolutionOp->convolveColors(colors, weights, dstIt->rawData(), factor, 0, 2.0, channelFlags);
} else {
memcpy(dstIt->rawData(), dstIt->oldRawData(), cdepth);
}
++pixelsProcessed;
if (progressUpdater) filterUpdater->setProgress(steps * pixelsProcessed);
intermIt->nextPixel();
} while (dstIt->nextPixel());
if (progressUpdater && progressUpdater->interrupted()) {
return;
}
dstIt->nextRow();
intermIt->nextRow();
}
delete colors[0];
delete colors[1];
delete updater;
if (progressUpdater) progressUpdater->setProgress(100);
}
void KisMotionBlurFilter::process(KisPaintDeviceSP device,
const QRect& rect,
const KisFilterConfiguration* config,
KoUpdater* progressUpdater
) const
{
QPoint srcTopLeft = rect.topLeft();
Q_ASSERT(device != 0);
if (!config) config = new KisFilterConfiguration(id().id(), 1);
QVariant value;
config->getProperty("blurAngle", value);
uint blurAngle = value.toUInt();
config->getProperty("blurLength", value);
uint blurLength = value.toUInt();
if (blurLength == 0)
return;
QBitArray channelFlags;
if (config) {
channelFlags = config->channelFlags();
}
if (channelFlags.isEmpty() || !config) {
channelFlags = QBitArray(device->colorSpace()->channelCount(), true);
}
// convert angle to radians
qreal angleRadians = blurAngle / 360.0 * 2 * M_PI;
// construct image
qreal halfWidth = blurLength / 2.0 * cos(angleRadians);
qreal halfHeight = blurLength / 2.0 * sin(angleRadians);
int kernelWidth = ceil(fabs(halfWidth)) * 2;
int kernelHeight = ceil(fabs(halfHeight)) * 2;
// check for zero dimensions (vertical/horizontal motion vectors)
kernelWidth = (kernelWidth == 0) ? 1 : kernelWidth;
kernelHeight = (kernelHeight == 0) ? 1 : kernelHeight;
QImage kernelRepresentation(kernelWidth, kernelHeight, QImage::Format_RGB32);
kernelRepresentation.fill(0);
QPainter imagePainter(&kernelRepresentation);
imagePainter.setRenderHint(QPainter::Antialiasing);
imagePainter.setPen(QPen(QColor::fromRgb(255, 255, 255), 1.0));
imagePainter.drawLine(QPointF(kernelWidth / 2 - halfWidth, kernelHeight / 2 + halfHeight),
QPointF(kernelWidth / 2 + halfWidth, kernelHeight / 2 - halfHeight));
// construct kernel from image
Matrix<qreal, Dynamic, Dynamic> motionBlurKernel(kernelHeight, kernelWidth);
for (int j = 0; j < kernelHeight; ++j) {
for (int i = 0; i < kernelWidth; ++i) {
motionBlurKernel(j, i) = qRed(kernelRepresentation.pixel(i, j));
}
}
// apply convolution
KisConvolutionPainter painter(device);
painter.setChannelFlags(channelFlags);
painter.setProgress(progressUpdater);
KisConvolutionKernelSP kernel = KisConvolutionKernel::fromMatrix(motionBlurKernel, 0, motionBlurKernel.sum());
painter.applyMatrix(kernel, device, srcTopLeft, srcTopLeft, rect.size(), BORDER_REPEAT);
}
void KisLensBlurFilter::process(KisPaintDeviceSP device,
const QRect& rect,
const KisFilterConfiguration* config,
KoUpdater* progressUpdater
) const
{
QPoint srcTopLeft = rect.topLeft();
Q_ASSERT(device != 0);
if (!config) config = new KisFilterConfiguration(id().id(), 1);
QVariant value;
config->getProperty("irisShape", value);
QString irisShape = value.toString();
config->getProperty("irisRadius", value);
uint irisRadius = value.toUInt();
config->getProperty("irisRotation", value);
uint irisRotation = value.toUInt();
if (irisRadius < 1)
return;
QBitArray channelFlags;
if (config) {
channelFlags = config->channelFlags();
}
if (channelFlags.isEmpty() || !config) {
channelFlags = QBitArray(device->colorSpace()->channelCount(), true);
}
QPolygonF irisShapePoly;
int sides = 1;
qreal angle = 0;
if (irisShape == "Triangle") sides = 3;
else if (irisShape == "Quadrilateral (4)") sides = 4;
else if (irisShape == "Pentagon (5)") sides = 5;
else if (irisShape == "Hexagon (6)") sides = 6;
else if (irisShape == "Heptagon (7)") sides = 7;
else if (irisShape == "Octagon (8)") sides = 8;
else return;
for (int i = 0; i < sides; ++i) {
irisShapePoly << QPointF(0.5 * cos(angle), 0.5 * sin(angle));
angle += 2 * M_PI / sides;
}
QTransform transform;
transform.rotate(irisRotation);
transform.scale(irisRadius * 2, irisRadius * 2);
QPolygonF transformedIris;
for (int i = 0; i < irisShapePoly.count(); ++i) {
transformedIris << irisShapePoly[i] * transform;
}
// find extremes to determine kernel size required
qreal minX = 0, maxX = 0, minY = 0, maxY = 0;
for (int i = 0; i < transformedIris.count(); ++i) {
if (transformedIris[i].x() < minX) minX = transformedIris[i].x();
if (transformedIris[i].x() > maxX) maxX = transformedIris[i].x();
if (transformedIris[i].y() < minY) minY = transformedIris[i].y();
if (transformedIris[i].y() > maxY) maxY = transformedIris[i].y();
}
int kernelWidth = ceil(maxX) - ceil(minX);
int kernelHeight = ceil(maxY) - ceil(minY);
QImage kernelRepresentation(kernelWidth, kernelHeight, QImage::Format_RGB32);
kernelRepresentation.fill(0);
QPainter imagePainter(&kernelRepresentation);
imagePainter.setRenderHint(QPainter::Antialiasing);
imagePainter.setBrush(QColor::fromRgb(255, 255, 255));
QTransform offsetTransform;
offsetTransform.translate(-minX, -minY);
imagePainter.setTransform(offsetTransform);
imagePainter.drawPolygon(transformedIris, Qt::WindingFill);
// construct kernel from image
Matrix<qreal, Dynamic, Dynamic> irisKernel(kernelHeight, kernelWidth);
for (int j = 0; j < kernelHeight; ++j) {
for (int i = 0; i < kernelWidth; ++i) {
irisKernel(j, i) = qRed(kernelRepresentation.pixel(i, j));
}
}
// apply convolution
KisConvolutionPainter painter(device);
painter.setChannelFlags(channelFlags);
painter.setProgress(progressUpdater);
KisConvolutionKernelSP kernel = KisConvolutionKernel::fromMatrix(irisKernel, 0, irisKernel.sum());
painter.applyMatrix(kernel, device, srcTopLeft, srcTopLeft, rect.size(), BORDER_REPEAT);
}
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 );
}
}
}
}
