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;
}
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);
}
// Compare images:
QBitArray OKFilter::imageToVect(const QString &inputImage)
{
// Check src file:
QFileInfo fi(inputImage);
// Check files:
if (!fi.exists())
return QBitArray();
QImage img(inputImage);
if (img.isNull())
return QBitArray();
QBitArray result;
result.resize(img.width()*img.height());
int c = 0;
for (int j=0; j<img.height(); j++)
for (int i=0; i<img.width(); i++)
{
QRgb color = img.pixel(i, j);
int alpha = qAlpha(color);
result[c++] = (alpha>0);
}
return result;
}
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 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 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");
}
}
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;
}
quint32 CBerBitStringStorage::deserialize(CBerByteArrayInputStream& iStream, QObject* obj, CBerLength& length, quint32 codeLength)
{
length.decode(iStream);
qDebug() << "CBerBitStringStorage::deserialize, length extracted: " << length.getVal();
qint32 lenVal = length.getVal();
QByteArray data(lenVal, Qt::Initialization::Uninitialized);
if (data.size() > 0)
{
QBitArray val;
qint32 rdLength = iStream.read(data, 0, lenVal);
if (rdLength == lenVal)
{
val.resize(rdLength);
for (qint32 i=0; i<rdLength; ++i)
{
if (data[i]) val.setBit(i);
else val.clearBit(i);
}
codeLength += rdLength + 1;
QBitArray* pVal = &val;
QVariant wrvar(PtrMetaTypes::s_QBitArrayPtrMetaType, &pVal);
obj->metaObject()->property(3).write(obj, wrvar);
}
}
return codeLength;
}
// 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);
}
QList<QWidget *> FatherBlock::GetEnableBlocksWidget(int theStatusIndex)
{
QList<QWidget *>theBlockWidgets;
if(theStatusIndex == -1)
{
theStatusIndex = m_current_status_index;
}
if(theStatusIndex < m_status_list.count())
{
QBitArray theStatus = m_status_list[theStatusIndex];
int count = theStatus.count()-1;
while(count >= 0)
{
if(theStatus.testBit(count) == true)
{
QWidget *ChildBlockWidget = GetSingleBlock(m_block_type);
ChildBlockWidget->setStyleSheet(m_BlockStyleSheet);
ChildBlockWidget->setGeometry(m_blocks_list[count]->geometry());
ChildBlockWidget->setGeometry(ChildBlockWidget->x()+this->x(),ChildBlockWidget->y()+this->y(),ChildBlockWidget->width(),ChildBlockWidget->height());
theBlockWidgets.append(ChildBlockWidget);
}
count--;
}
}
return theBlockWidgets;
}
/**
* Spread contacts in the blockmap to any touched neighbors.
*
* @param box Map space region in which to perform spreading.
*/
void spread(AABoxd const &box)
{
BlockmapCellBlock const cellBlock = _blockmap.toCellBlock(box);
BlockmapCell cell;
for(cell.y = cellBlock.min.y; cell.y < cellBlock.max.y; ++cell.y)
for(cell.x = cellBlock.min.x; cell.x < cellBlock.max.x; ++cell.x)
{
if(_spreadBlocks)
{
// Should we skip this cell?
int cellIndex = _blockmap.toCellIndex(cell.x, cell.y);
if(_spreadBlocks->testBit(cellIndex))
continue;
// Mark the cell as processed.
_spreadBlocks->setBit(cellIndex);
}
_blockmap.forAllInCell(cell, [this] (void *element)
{
spreadContact(*static_cast<Contact *>(element));
return LoopContinue;
});
}
}
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);
}
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);
}
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);
}
void KisSaveXmlVisitor::saveLayer(QDomElement & el, const QString & layerType, const KisLayer * layer)
{
QString channelFlagsString;
QBitArray channelFlags = layer->channelFlags();
for ( int i = 0; i < channelFlags.count(); ++i ) {
if ( channelFlags[i] )
channelFlagsString += '1';
else
channelFlagsString += '0';
}
el.setAttribute( CHANNEL_FLAGS, channelFlagsString );
el.setAttribute(NAME, layer->name());
el.setAttribute(OPACITY, layer->opacity());
el.setAttribute(COMPOSITE_OP, layer->compositeOp()->id());
el.setAttribute(VISIBLE, layer->visible());
el.setAttribute(LOCKED, layer->userLocked());
el.setAttribute(NODE_TYPE, layerType);
el.setAttribute(FILE_NAME, LAYER + QString::number( m_count ) );
el.setAttribute(X, layer->x());
el.setAttribute(Y, layer->y());
m_nodeFileNames[layer] = LAYER + QString::number( m_count );
dbgFile << "Saved layer "
<< layer->name()
<< " of type " << layerType
<< " with filename " << LAYER + QString::number( m_count );
}
// Run:
bool OKFilter::execute(const QList<QDir> &directories, const QString &srcFile)
{
if (directories.size() < 2)
return false;
// Get reference file:
QString refFile = directories.first().absoluteFilePath(srcFile);
QImage img(refFile);
int nPixels = img.width()*img.height();
int threshold = qRound(.5*nPixels);
// Get reference state:
QBitArray refState = imageToVect(refFile);
for (int i=1; i<directories.size(); i++)
{
// Exists?
QString file = directories[i].absoluteFilePath(srcFile);
QBitArray currentState = imageToVect(file);
QBitArray tmp = (~refState & currentState) | (refState & ~currentState);
int nErrors = tmp.count(true);
if (nErrors > threshold)
return false;
}
return true;
}
//! Compute hidden value according to stegotable
bool StegoTable::computeValue(float miv, bool next)
{
QBitArray stegoTable = next ? getNextTable() : _stTables[_indexTable[_currentTable]];
int index = floor(miv / (double)_k);
/*m_logger->debug("miv: " + QString::number(miv)
+ "=> stegotable index: " + QString::number(index));*/
return stegoTable.at(index);
}
QRect ImageOverlayRegionFinder::growRegion(int row, int column, QBitArray &mask)
{
QRect region;
region.setCoords(column, row, column, row);
QQueue<int> queue;
queue.enqueue(getDataIndex(row, column));
while (!queue.isEmpty())
{
int i = queue.dequeue();
if (m_overlay.getData()[i] > 0 && !mask.testBit(i))
{
mask.setBit(i);
row = getRowIndex(i);
column = getColumnIndex(i);
if (row < region.top())
{
region.setTop(row);
}
if (row > region.bottom())
{
region.setBottom(row);
}
if (column < region.left())
{
region.setLeft(column);
}
if (column > region.right())
{
region.setRight(column);
}
if (column - 1 >= 0)
{
queue.enqueue(getDataIndex(row, column - 1));
}
if (column + 1 < static_cast<signed>(m_overlay.getColumns()))
{
queue.enqueue(getDataIndex(row, column + 1));
}
if (row - 1 >= 0)
{
queue.enqueue(getDataIndex(row - 1, column));
}
if (row + 1 < static_cast<signed>(m_overlay.getRows()))
{
queue.enqueue(getDataIndex(row + 1, column));
}
}
}
return region;
}
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));
}
}
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);
}
QString KRA::flagsToString(const QBitArray& flags, int size, char trueToken, char falseToken, bool defaultTrue)
{
size = (size < 0) ? flags.count() : size;
QString string(size, defaultTrue ? trueToken : falseToken);
for(int i=0; i<qMin(size, flags.count()); ++i)
string[i] = flags[i] ? trueToken : falseToken;
return string;
}
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;
}
QByteArray bitsToBytes(QBitArray bits)
{
QByteArray bytes;
bytes.resize(qCeil(bits.count() / 8.0));
bytes.fill(0);
for(int b = 0; b < bits.count(); ++b)
{
bytes[b / 8] = (bytes.at(b / 8) | ((bits[b] ? 1 : 0) << (b % 8)));
}
return bytes;
}
void ReadBitsHelper(int arrlen, int offset, int n_bits)
{
QByteArray msg(arrlen, 'a');
QBitArray bits(n_bits, true);
Serialization::WriteBitArray(bits, msg, offset);
QBitArray out = Serialization::ReadBitArray(msg, offset, n_bits);
EXPECT_EQ(n_bits, out.count());
for(int i=0; i<n_bits; i++) {
EXPECT_EQ(true, out[i]);
}
}
void DashLabel::updateValue(QVariant value){
if(value.type() == QVariant::Double || value.type() == QVariant::String){
setText(value.toString());
}else if(value.type() == QVariant::BitArray){
QString text;
QBitArray bit = value.toBitArray();
for(int i=0; i<bit.count(); i++){
text.append(bit[i]?'1':'0');
setText(text);
}
}
}
void QLCDNumber::setNumDigits( int numDigits )
{
if ( numDigits > 99 ) {
#if defined(QT_CHECK_RANGE)
qWarning( "QLCDNumber::setNumDigits: (%s) Max 99 digits allowed",
name( "unnamed" ) );
#endif
numDigits = 99;
}
if (numDigits < 0 ) {
#if defined(QT_CHECK_RANGE)
qWarning( "QLCDNumber::setNumDigits: (%s) Min 0 digits allowed",
name( "unnamed" ) );
#endif
numDigits = 0;
}
if ( digitStr.isNull() ) { // from constructor
ndigits = numDigits;
digitStr.fill( ' ', ndigits );
points.fill( 0, ndigits );
digitStr[ndigits - 1] = '0'; // "0" is the default number
} else {
bool doDisplay = ndigits == 0;
if ( numDigits == ndigits ) // no change
return;
register int i;
int dif;
if ( numDigits > ndigits ) { // expand
dif = numDigits - ndigits;
QString buf;
buf.fill( ' ', dif );
digitStr.insert( 0, buf );
points.resize( numDigits );
for ( i=numDigits-1; i>=dif; i-- )
points.setBit( i, points.testBit(i-dif) );
for ( i=0; i<dif; i++ )
points.clearBit( i );
} else { // shrink
dif = ndigits - numDigits;
digitStr = digitStr.right( numDigits );
QBitArray tmpPoints = points.copy();
points.resize( numDigits );
for ( i=0; i<(int)numDigits; i++ )
points.setBit( i, tmpPoints.testBit(i+dif) );
}
ndigits = numDigits;
if ( doDisplay )
display( value() );
update();
}
}
void
VolumeMask::erodeBitmask(int mind, int maxd,
int minw, int maxw,
int minh, int maxh)
{
// QProgressDialog progress("Eroding Tag Mask",
// "Cancel",
// 0, 100,
// 0);
QBitArray bitcopy = m_bitmask;
for(int d=mind; d<=maxd; d++)
{
emit progressChanged((int)(100.0*(float)d/(float)m_depth));
qApp->processEvents();
for(int w=minw; w<=maxw; w++)
for(int h=minh; h<=maxh; h++)
{
qint64 bidx = (d*m_width*m_height +
w*m_height + h);
if (bitcopy.testBit(bidx))
{
int d0 = qMax(d-1, mind);
int d1 = qMin(d+1, maxd);
int w0 = qMax(w-1, minw);
int w1 = qMin(w+1, maxw);
int h0 = qMax(h-1, minh);
int h1 = qMin(h+1, maxh);
bool ok = true;
for(int d2=d0; d2<=d1; d2++)
for(int w2=w0; w2<=w1; w2++)
for(int h2=h0; h2<=h1; h2++)
{
qint64 idx = d2*m_width*m_height +
w2*m_height + h2;
ok &= bitcopy.testBit(idx);
}
if (!ok) // surface voxel
m_bitmask.setBit(bidx, false); // set bit to 0
}
}
}
emit progressReset();
}
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);
}
/**
* Helper function to initialize a bitarray from a string
*/
static QBitArray QStringToQBitArray(const QString &str)
{
QBitArray ba;
ba.resize(str.length());
int i;
QChar tru('1');
for (i = 0; i < str.length(); i++)
{
if (str.at(i) == tru)
{
ba.setBit(i, true);
}
}
return ba;
}
/*!
Sets the current number of digits to \a numDigits. Must
be in the range 0..99.
*/
void QLCDNumber::setDigitCount(int numDigits)
{
Q_D(QLCDNumber);
if (numDigits > 99) {
qWarning("QLCDNumber::setNumDigits: (%s) Max 99 digits allowed",
objectName().toLocal8Bit().constData());
numDigits = 99;
}
if (numDigits < 0) {
qWarning("QLCDNumber::setNumDigits: (%s) Min 0 digits allowed",
objectName().toLocal8Bit().constData());
numDigits = 0;
}
if (d->digitStr.isNull()) { // from constructor
d->ndigits = numDigits;
d->digitStr.fill(QLatin1Char(' '), d->ndigits);
d->points.fill(0, d->ndigits);
d->digitStr[d->ndigits - 1] = QLatin1Char('0'); // "0" is the default number
} else {
bool doDisplay = d->ndigits == 0;
if (numDigits == d->ndigits) // no change
return;
int i;
int dif;
if (numDigits > d->ndigits) { // expand
dif = numDigits - d->ndigits;
QString buf;
buf.fill(QLatin1Char(' '), dif);
d->digitStr.insert(0, buf);
d->points.resize(numDigits);
for (i=numDigits-1; i>=dif; i--)
d->points.setBit(i, d->points.testBit(i-dif));
for (i=0; i<dif; i++)
d->points.clearBit(i);
} else { // shrink
dif = d->ndigits - numDigits;
d->digitStr = d->digitStr.right(numDigits);
QBitArray tmpPoints = d->points;
d->points.resize(numDigits);
for (i=0; i<(int)numDigits; i++)
d->points.setBit(i, tmpPoints.testBit(i+dif));
}
d->ndigits = numDigits;
if (doDisplay)
display(value());
update();
}
}
