void QgsOracleColumnTypeThread::run()
{
mStopped = false;
QString conninfo = QgsOracleConn::toPoolName( QgsOracleConn::connUri( mName ) );
QgsOracleConn *conn = QgsOracleConnPool::instance()->acquireConnection( conninfo );
if ( !conn )
{
QgsDebugMsg( "Connection failed - " + conninfo );
mStopped = true;
return;
}
emit progressMessage( tr( "Retrieving tables of %1…" ).arg( mName ) );
QVector<QgsOracleLayerProperty> layerProperties;
if ( !conn->supportedLayers( layerProperties,
mSchema,
QgsOracleConn::geometryColumnsOnly( mName ),
QgsOracleConn::userTablesOnly( mName ),
mAllowGeometrylessTables ) ||
layerProperties.isEmpty() )
{
return;
}
int i = 0, n = layerProperties.size();
for ( QVector<QgsOracleLayerProperty>::iterator it = layerProperties.begin(),
end = layerProperties.end();
it != end; ++it )
{
QgsOracleLayerProperty &layerProperty = *it;
if ( !mStopped )
{
emit progress( i++, n );
emit progressMessage( tr( "Scanning column %1.%2.%3…" )
.arg( layerProperty.ownerName,
layerProperty.tableName,
layerProperty.geometryColName ) );
conn->retrieveLayerTypes( layerProperty, mUseEstimatedMetadata, QgsOracleConn::onlyExistingTypes( mName ) );
}
if ( mStopped )
{
layerProperty.types.clear();
layerProperty.srids.clear();
}
// Now tell the layer list dialog box...
emit setLayerType( layerProperty );
}
// store the list for later use (cache)
if ( !mStopped )
mLayerProperties = layerProperties;
emit progress( 0, 0 );
emit progressMessage( tr( "Table retrieval finished." ) );
QgsOracleConnPool::instance()->releaseConnection( conn );
}
// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
void VolumeMesh::compute()
{
CHECK_FOR_CANCELED(Surface Meshing)
progressMessage(AIM_STRING("Running Volume Meshing"), 0 );
MAKE_OUTPUT_FILE_PATH ( meshFile , DREAM3D::VolumeMeshing::MeshFile)
MAKE_OUTPUT_FILE_PATH ( meshFile2 , DREAM3D::VolumeMeshing::MeshFile2)
MAKE_OUTPUT_FILE_PATH ( qualFile , DREAM3D::VolumeMeshing::ElementQualityFile)
MAKE_OUTPUT_FILE_PATH ( voxelsFile , DREAM3D::VolumeMeshing::VoxelsFile)
m_ErrorCondition = MeshGenerator_Main(m_NodesFile,
m_TrianglesFile,
meshFile, // Vtk file
meshFile2, // Vtk File
qualFile, //"element_quality_measures_v5.txt"
voxelsFile, //"voxels_v5.txt"
m_XDim, m_YDim, m_ZDim,
m_XRes, m_YRes, m_ZRes, m_NumGrains);
progressMessage(AIM_STRING("Surface Volume Complete"), 100 );
#if DREAM3D_USE_QT
emit finished();
#endif
}
void QgsOracleColumnTypeThread::run()
{
QgsDataSourceURI uri = QgsOracleConn::connUri( mName );
QgsOracleConn *conn = QgsOracleConn::connectDb( uri.connectionInfo() );
if ( !conn )
{
QgsDebugMsg( "Connection failed - " + uri.connectionInfo() );
return;
}
mStopped = false;
emit progressMessage( tr( "Retrieving tables of %1..." ).arg( mName ) );
QVector<QgsOracleLayerProperty> layerProperties;
if ( !conn->supportedLayers( layerProperties,
QgsOracleConn::geometryColumnsOnly( mName ),
QgsOracleConn::userTablesOnly( mName ),
mAllowGeometrylessTables ) ||
layerProperties.isEmpty() )
{
return;
}
int i = 0, n = layerProperties.size();
for ( QVector<QgsOracleLayerProperty>::iterator it = layerProperties.begin(),
end = layerProperties.end();
it != end; ++it )
{
QgsOracleLayerProperty &layerProperty = *it;
if ( !mStopped )
{
emit progress( i++, n );
emit progressMessage( tr( "Scanning column %1.%2.%3..." )
.arg( layerProperty.ownerName )
.arg( layerProperty.tableName )
.arg( layerProperty.geometryColName ) );
conn->retrieveLayerTypes( layerProperty, mUseEstimatedMetadata, QgsOracleConn::onlyExistingTypes( mName ) );
}
if ( mStopped )
{
layerProperty.types.clear();
layerProperty.srids.clear();
}
// Now tell the layer list dialog box...
emit setLayerType( layerProperty );
}
emit progress( 0, 0 );
emit progressMessage( tr( "Table retrieval finished." ) );
conn->disconnect();
}
void Character::sendStatus()
{
MessageOut attribMsg(GPMSG_PLAYER_ATTRIBUTE_CHANGE);
for (std::set<size_t>::const_iterator i = mModifiedAttributes.begin(),
i_end = mModifiedAttributes.end(); i != i_end; ++i)
{
int attr = *i;
attribMsg.writeInt16(attr);
attribMsg.writeInt32(getAttribute(attr) * 256);
attribMsg.writeInt32(getModifiedAttribute(attr) * 256);
}
if (attribMsg.getLength() > 2) gameHandler->sendTo(this, attribMsg);
mModifiedAttributes.clear();
MessageOut expMsg(GPMSG_PLAYER_EXP_CHANGE);
for (std::set<size_t>::const_iterator i = mModifiedExperience.begin(),
i_end = mModifiedExperience.end(); i != i_end; ++i)
{
int skill = *i;
expMsg.writeInt16(skill);
expMsg.writeInt32(getExpGot(skill));
expMsg.writeInt32(getExpNeeded(skill));
expMsg.writeInt16(levelForExp(getExperience(skill)));
}
if (expMsg.getLength() > 2) gameHandler->sendTo(this, expMsg);
mModifiedExperience.clear();
if (mUpdateLevelProgress)
{
mUpdateLevelProgress = false;
MessageOut progressMessage(GPMSG_LEVEL_PROGRESS);
progressMessage.writeInt8(mLevelProgress);
gameHandler->sendTo(this, progressMessage);
}
}
void QgsGeomColumnTypeThread::run()
{
if ( !mConn )
return;
mStopped = false;
int i = 0;
foreach ( QgsPostgresLayerProperty layerProperty, layerProperties )
{
if ( !mStopped )
{
emit progress( i++, layerProperties.size() );
emit progressMessage( tr( "Scanning column %1.%2.%3..." ).arg( layerProperty.schemaName ).arg( layerProperty.tableName ).arg( layerProperty.geometryColName ) );
mConn->retrieveLayerTypes( layerProperty, mUseEstimatedMetadata );
}
if ( mStopped )
{
layerProperty.type = "";
layerProperty.srid = "";
}
// Now tell the layer list dialog box...
emit setLayerType( layerProperty );
}
mConn->disconnect();
mConn = 0;
}
void PackageScanner::scannerDone()
{
emit progressValue( DEFAULT_PROGRESS_MAX );
emit progressMessage( tr( "Found %1 packages" ).arg( mPackageList.count() ));
emit updated();
delete mScanner;
mScanner = 0;
reset();
}
void PackageScanner::refresh()
{
emit progressMessage( tr( "Scanning for packages..." ));
emit progressValue( 0 );
mScanner = new ScannerThread( this );
connect( mScanner, SIGNAL(finished()),
this, SLOT(scannerDone()) );
connect( mScanner, SIGNAL(terminated()),
this, SLOT(scannerDone()) );
mScanner->start();
}
/* self */
void XMLerSaveFileThread::run ()
{
if ( !_document ) {
emit warning ( tr("Document is empty or doesn't set.") );
return;
}
QFile xml ( fileName() );
if ( !xml.open ( QIODevice::WriteOnly ) ) {
emit error ( tr("Can not open file %1.").arg( fileName() ) );
return;
}
QXmlStreamWriter writer( &xml );
/* set information about document */
writer.setAutoFormatting ( _document->autoFormatting() );
writer.setAutoFormattingIndent ( _document->formattingIndent() );
writer.setCodec ( _document->codec() );
emit beginProgress ( progressMessage(), 0 );
emit beginProgress ( progressMessage(), _document->size() );
bool result = true;
qint64 pos = 0;
/* save a document */
result = saveNode ( writer, _document, pos );
xml.close();
emit endProgress ();
/* set filename */
if ( result && _document->fileName() != fileName() )
_document->setFileName ( fileName() );
if ( !result )
emit error ( tr("Error while writing the document.").arg( fileName() ) );
else
emit done ();
}
void AbstractRemoteLinuxDeployStep::run(QFutureInterface<bool> &fi)
{
connect(deployService(), SIGNAL(errorMessage(QString)), SLOT(handleErrorMessage(QString)));
connect(deployService(), SIGNAL(progressMessage(QString)), SLOT(handleProgressMessage(QString)));
connect(deployService(), SIGNAL(stdOutData(QString)), SLOT(handleStdOutData(QString)));
connect(deployService(), SIGNAL(stdErrData(QString)), SLOT(handleStdErrData(QString)));
connect(deployService(), SIGNAL(finished()), SLOT(handleFinished()));
m_d->hasError = false;
m_d->future = fi;
deployService()->start();
}
DeviceTestDialog::DeviceTestDialog(const ProjectExplorer::IDevice::ConstPtr &deviceConfiguration,
QWidget *parent)
: QDialog(parent), d(new DeviceTestDialogPrivate(deviceConfiguration->createDeviceTester()))
{
d->ui.setupUi(this);
d->deviceTester->setParent(this);
connect(d->deviceTester, SIGNAL(progressMessage(QString)), SLOT(handleProgressMessage(QString)));
connect(d->deviceTester, SIGNAL(errorMessage(QString)), SLOT(handleErrorMessage(QString)));
connect(d->deviceTester, SIGNAL(finished(ProjectExplorer::DeviceTester::TestResult)),
SLOT(handleTestFinished(ProjectExplorer::DeviceTester::TestResult)));
d->deviceTester->testDevice(deviceConfiguration);
}
/*!
Construct a new \c PackageScanner object, which will scan the \a dir
directory, when the refresh() call is made.
*/
PackageScanner::PackageScanner( const QString &dir, QObject *parent )
: QAbstractListModel( parent )
, mDir( dir )
, mScanner( 0 )
, mConnector( 0 )
{
refresh();
mConnector = new DeviceConnector();
QObject::connect( mConnector, SIGNAL(finishedConnect()),
this, SLOT(connectorComplete()) );
QObject::connect( mConnector, SIGNAL(deviceConnMessage(QString)),
this, SIGNAL(progressMessage(QString)) );
QObject::connect( mConnector, SIGNAL(sendProgress(int)),
this, SIGNAL(progressValue(int)) );
}
int Downloader::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
_id = QObject::qt_metacall(_c, _id, _a);
if (_id < 0)
return _id;
if (_c == QMetaObject::InvokeMetaMethod) {
if (_id < 9)
qt_static_metacall(this, _c, _id, _a);
_id -= 9;
}
#ifndef QT_NO_PROPERTIES
else if (_c == QMetaObject::ReadProperty) {
void *_v = _a[0];
switch (_id) {
case 0: *reinterpret_cast< int*>(_v) = progressTotal(); break;
case 1: *reinterpret_cast< int*>(_v) = progressValue(); break;
case 2: *reinterpret_cast< QString*>(_v) = progressMessage(); break;
}
_id -= 3;
} else if (_c == QMetaObject::WriteProperty) {
_id -= 3;
} else if (_c == QMetaObject::ResetProperty) {
_id -= 3;
} else if (_c == QMetaObject::QueryPropertyDesignable) {
_id -= 3;
} else if (_c == QMetaObject::QueryPropertyScriptable) {
_id -= 3;
} else if (_c == QMetaObject::QueryPropertyStored) {
_id -= 3;
} else if (_c == QMetaObject::QueryPropertyEditable) {
_id -= 3;
} else if (_c == QMetaObject::QueryPropertyUser) {
_id -= 3;
}
#endif // QT_NO_PROPERTIES
return _id;
}
status_t
MovieEncoder::Encode()
{
int32 framesLeft = fFileList->CountItems();
int32 framesWritten = 0;
if (framesLeft <= 0) {
DisposeData();
BMessage message(kEncodingFinished);
message.AddInt32("status", (int32)B_ERROR);
fMessenger.SendMessage(&message);
return B_ERROR;
}
// Create movie
char movieName[B_FILE_NAME_LENGTH];
MakeUniqueName(fOutputFile.Path(), movieName, B_FILE_NAME_LENGTH);
entry_ref movieRef;
get_ref_for_path(movieName, &movieRef);
media_file_format fileFormat;
if (!GetMediaFileFormat(fFamily, fileFormat)) {
BMessage message(kEncodingFinished);
message.AddInt32("status", (int32)B_ERROR);
fMessenger.SendMessage(&message);
return B_ERROR;
}
BBitmap* bitmap = BTranslationUtils::GetBitmapFile(fFileList->ItemAt(0));
BRect sourceFrame = bitmap->Bounds();
delete bitmap;
if (!fDestFrame.IsValid())
fDestFrame = sourceFrame.OffsetToCopy(B_ORIGIN);
BitmapMovie* movie = new BitmapMovie(fDestFrame.IntegerWidth() + 1,
fDestFrame.IntegerHeight() + 1, fColorSpace);
status_t error = movie->CreateFile(movieRef, fileFormat, fFormat, fCodecInfo);
if (error < B_OK) {
delete movie;
DisposeData();
BMessage message(kEncodingFinished);
message.AddInt32("status", (int32)error);
fMessenger.SendMessage(&message);
return error;
}
// Bitmap and view used to convert the source bitmap
// to the correct size and depth
BBitmap* destBitmap = new BBitmap(fDestFrame, fColorSpace, true);
BView* destDrawer = new BView(fDestFrame, "drawing view", B_FOLLOW_NONE, 0);
if (destBitmap->Lock()) {
destBitmap->AddChild(destDrawer);
destBitmap->Unlock();
}
const uint32 keyFrameFrequency = 10;
BMessage progressMessage(B_UPDATE_STATUS_BAR);
progressMessage.AddFloat("delta", 1.0);
bool keyFrame = true;
for (int32 i = 0; i < fFileList->CountItems(); i++) {
if (framesWritten % keyFrameFrequency == 0)
keyFrame = true;
const char* fileName = fFileList->ItemAt(i);
BBitmap* frame = BTranslationUtils::GetBitmapFile(fileName);
if (frame == NULL)
continue;
// Draw scaled
if (error == B_OK) {
destBitmap->Lock();
destDrawer->DrawBitmap(frame, frame->Bounds(), destDrawer->Bounds());
destDrawer->Sync();
destBitmap->Unlock();
}
delete frame;
if (error == B_OK)
error = movie->WriteFrame(destBitmap, keyFrame);
if (error == B_OK) {
framesWritten++;
keyFrame = false;
} else {
printf("%s\n", strerror(error));
break;
}
if (fMessenger.IsValid())
fMessenger.SendMessage(new BMessage(progressMessage));
}
//printf("%ld frames written\n", framesWritten);
delete movie;
delete destBitmap;
//delete cursor;
DisposeData();
BMessage message(kEncodingFinished);
message.AddInt32("status", (int32)B_OK);
fMessenger.SendMessage(&message);
return B_OK;
}
status_t
MovieEncoder::Encode()
{
int32 framesLeft = fFileList->CountItems();
int32 framesWritten = 0;
if (framesLeft <= 0) {
DisposeData();
BMessage message(kEncodingFinished);
message.AddInt32("status", (int32)B_ERROR);
fMessenger.SendMessage(&message);
return B_ERROR;
}
// Create movie
char movieName[B_FILE_NAME_LENGTH];
MakeUniqueName(fOutputFile.Path(), movieName, B_FILE_NAME_LENGTH);
entry_ref movieRef;
get_ref_for_path(movieName, &movieRef);
BBitmap* bitmap = BTranslationUtils::GetBitmapFile(fFileList->ItemAt(0));
BRect sourceFrame = bitmap->Bounds();
delete bitmap;
if (!fDestFrame.IsValid())
fDestFrame = sourceFrame.OffsetToCopy(B_ORIGIN);
BitmapMovie* movie = new BitmapMovie(fDestFrame.IntegerWidth() + 1,
fDestFrame.IntegerHeight() + 1, fColorSpace);
status_t status = movie->CreateFile(movieRef, fFileFormat, fFormat, fCodecInfo);
if (status < B_OK) {
delete movie;
DisposeData();
BMessage message(kEncodingFinished);
message.AddInt32("status", (int32)status);
fMessenger.SendMessage(&message);
return status;
}
// Bitmap and view used to convert the source bitmap
// to the correct size and depth
BBitmap* destBitmap = new BBitmap(fDestFrame, fColorSpace, true);
BView* destDrawer = new BView(fDestFrame, "drawing view", B_FOLLOW_NONE, 0);
if (destBitmap->Lock()) {
destBitmap->AddChild(destDrawer);
destBitmap->Unlock();
}
const uint32 keyFrameFrequency = 10;
// TODO: Make this tunable
BMessage progressMessage(B_UPDATE_STATUS_BAR);
progressMessage.AddFloat("delta", 1.0);
status = B_OK;
for (int32 i = 0; i < fFileList->CountItems(); i++) {
bool keyFrame = (framesWritten % keyFrameFrequency == 0);
const char* fileName = fFileList->ItemAt(i);
BBitmap* frame = BTranslationUtils::GetBitmapFile(fileName);
if (frame == NULL) {
// TODO: What to do here ? Exit with an error ?
continue;
}
// Draw scaled
if (status == B_OK) {
destBitmap->Lock();
destDrawer->DrawBitmap(frame, frame->Bounds(), destDrawer->Bounds());
destDrawer->Sync();
destBitmap->Unlock();
}
delete frame;
if (status == B_OK)
status = movie->WriteFrame(destBitmap, keyFrame);
if (status != B_OK)
break;
framesWritten++;
if (fMessenger.IsValid())
fMessenger.SendMessage(new BMessage(progressMessage));
}
delete movie;
delete destBitmap;
DisposeData();
if (fMessenger.IsValid()) {
BMessage message(kEncodingFinished);
message.AddInt32("status", (int32)status);
message.AddInt32("frames", (int32)framesWritten);
fMessenger.SendMessage(&message);
}
return status;
}
void QgsGeomColumnTypeThread::run()
{
QgsDataSourceUri uri = QgsPostgresConn::connUri( mName );
mConn = QgsPostgresConnPool::instance()->acquireConnection( uri.connectionInfo( false ) );
if ( !mConn )
{
QgsDebugMsg( "Connection failed - " + uri.connectionInfo( false ) );
return;
}
mStopped = false;
bool dontResolveType = QgsPostgresConn::dontResolveType( mName );
emit progressMessage( tr( "Retrieving tables of %1…" ).arg( mName ) );
QVector<QgsPostgresLayerProperty> layerProperties;
if ( !mConn->supportedLayers( layerProperties,
QgsPostgresConn::geometryColumnsOnly( mName ),
QgsPostgresConn::publicSchemaOnly( mName ),
mAllowGeometrylessTables ) ||
layerProperties.isEmpty() )
{
QgsPostgresConnPool::instance()->releaseConnection( mConn );
mConn = nullptr;
return;
}
int i = 0, n = layerProperties.size();
for ( QVector<QgsPostgresLayerProperty>::iterator it = layerProperties.begin(),
end = layerProperties.end();
it != end; ++it )
{
QgsPostgresLayerProperty &layerProperty = *it;
if ( !mStopped )
{
emit progress( i++, n );
emit progressMessage( tr( "Scanning column %1.%2.%3…" )
.arg( layerProperty.schemaName,
layerProperty.tableName,
layerProperty.geometryColName ) );
if ( !layerProperty.geometryColName.isNull() &&
( layerProperty.types.value( 0, QgsWkbTypes::Unknown ) == QgsWkbTypes::Unknown ||
layerProperty.srids.value( 0, std::numeric_limits<int>::min() ) == std::numeric_limits<int>::min() ) )
{
if ( dontResolveType )
{
QgsDebugMsg( QStringLiteral( "skipping column %1.%2 without type constraint" ).arg( layerProperty.schemaName, layerProperty.tableName ) );
continue;
}
mConn->retrieveLayerTypes( layerProperty, mUseEstimatedMetadata );
}
}
if ( mStopped )
{
layerProperty.types.clear();
layerProperty.srids.clear();
break;
}
// Now tell the layer list dialog box...
emit setLayerType( layerProperty );
}
emit progress( 0, 0 );
emit progressMessage( mStopped ? tr( "Table retrieval stopped." ) : tr( "Table retrieval finished." ) );
QgsPostgresConnPool::instance()->releaseConnection( mConn );
mConn = nullptr;
}
// When this is running, no member variable should be accessed
// from other threads
status_t
MovieEncoder::_EncoderThread()
{
int32 framesLeft = fFileList->CountItems();
int32 framesWritten = 0;
if (framesLeft <= 0) {
DisposeData();
BMessage message(kEncodingFinished);
message.AddInt32("status", (int32)B_ERROR);
fMessenger.SendMessage(&message);
return B_ERROR;
}
// Create movie
entry_ref movieRef;
get_ref_for_path(fOutputFile.Path(), &movieRef);
BitmapEntry* entry = fFileList->ItemAt(0);
BBitmap* bitmap = entry->Bitmap();
BRect sourceFrame = bitmap->Bounds();
delete bitmap;
if (!fDestFrame.IsValid())
fDestFrame = sourceFrame.OffsetToCopy(B_ORIGIN);
// Calc the average time difference between the first 100 frames,
// and use it to calculate the framerate.
// TODO: Actually we could just calculate the number of frames and
// the time difference between the first and the last one.
/*int32 maxTimeStampNum = std::min((int32)100, fFileList->CountItems());
bigtime_t previousFrameTime = entry->TimeStamp();
bigtime_t diffSum = 0;
for (int32 i = 0; i < maxTimeStampNum; i++) {
BitmapEntry* entry = fFileList->ItemAt(i);
bigtime_t currentFrameTime = entry->TimeStamp();
diffSum += currentFrameTime - previousFrameTime;
previousFrameTime = currentFrameTime;
}
float medianDiffTime = diffSum / maxTimeStampNum;
*/
int32 numFrames = fFileList->CountItems();
BitmapEntry* firstEntry = fFileList->ItemAt(0);
BitmapEntry* lastEntry = fFileList->ItemAt(numFrames - 1);
int frameSeconds = (1000000 * numFrames) / (lastEntry->TimeStamp() - firstEntry->TimeStamp());
media_format inputFormat = fFormat;
inputFormat.u.raw_video.field_rate = frameSeconds;
status_t status = _CreateFile(movieRef, fFileFormat, inputFormat, fCodecInfo);
if (status < B_OK) {
DisposeData();
BMessage message(kEncodingFinished);
message.AddInt32("status", (int32)status);
fMessenger.SendMessage(&message);
return status;
}
// Bitmap and view used to convert the source bitmap
// to the correct size and depth
BBitmap* destBitmap = new BBitmap(fDestFrame, fColorSpace, true);
BView* destDrawer = new BView(fDestFrame, "drawing view", B_FOLLOW_NONE, 0);
if (destBitmap->Lock()) {
destBitmap->AddChild(destDrawer);
destBitmap->Unlock();
}
const uint32 keyFrameFrequency = 10;
// TODO: Make this tunable
BMessage progressMessage(B_UPDATE_STATUS_BAR);
progressMessage.AddFloat("delta", 1.0);
destBitmap->Bounds().PrintToStream();
PrintMediaFormat(inputFormat);
status = B_OK;
while (BitmapEntry* entry = const_cast<FileList*>(fFileList)->Pop()) {
if (fKillThread)
break;
bool keyFrame = (framesWritten % keyFrameFrequency == 0);
BBitmap* frame = entry->Bitmap();
if (frame == NULL) {
// TODO: What to do here ? Exit with an error ?
std::cerr << "Error while loading bitmap entry" << std::endl;
delete entry;
continue;
}
// Draw scaled
if (status == B_OK) {
destBitmap->Lock();
destDrawer->DrawBitmap(frame, frame->Bounds(), destDrawer->Bounds());
destDrawer->Sync();
destBitmap->Unlock();
}
delete frame;
delete entry;
if (status == B_OK)
status = _WriteFrame(destBitmap, keyFrame);
if (status != B_OK)
break;
framesWritten++;
if (fMessenger.IsValid())
fMessenger.SendMessage(new BMessage(progressMessage));
else {
// BMessenger is no longer valid. This means that the application
// has been closed or it has crashed.
break;
}
}
delete destBitmap;
DisposeData();
if (fMessenger.IsValid()) {
BMessage message(kEncodingFinished);
message.AddInt32("status", (int32)status);
message.AddInt32("frames", (int32)framesWritten);
fMessenger.SendMessage(&message);
}
return status;
}
/* Slots */
void XMLerFileOperThread::on_beginProgress ( qint64 totalSize )
{
emit beginProgress ( progressMessage(), totalSize );
}
