void VolumeURLListProperty::loadVolume(const std::string& url, bool invalidateUI /*=true*/)
throw (tgt::FileException, std::bad_alloc) {
if (!containsURL(url)) {
LWARNING("loadVolume(): passed URL not contained by this property: " << url);
return;
}
// delete volume, if already loaded and owned by the property
if (getVolume(url) && isOwner(url))
delete getVolume(url);
handleMap_.erase(url);
ownerMap_.erase(url);
ProgressBar* progressBar = getProgressBar();
if (progressBar) {
progressBar->setTitle("Loading volume");
progressBar->setProgressMessage("Loading volume ...");
}
VolumeSerializerPopulator serializerPopulator(progressBar);
VolumeBase* handle = serializerPopulator.getVolumeSerializer()->read(VolumeURL(url));
if (progressBar)
progressBar->hide();
if (handle) {
// url may have been altered by loading routine
if (url != handle->getOrigin().getURL()) {
bool selected = isSelected(url);
selectionMap_.erase(url);
selectionMap_[handle->getOrigin().getURL()] = selected;
for (size_t i=0; i<value_.size(); i++) {
if (value_[i] == url) {
value_[i] = handle->getOrigin().getURL();
break;
}
}
}
handleMap_[handle->getOrigin().getURL()] = handle;
ownerMap_[handle->getOrigin().getURL()] = true;
}
if(invalidateUI)
invalidate();
}
void VolumeURLProperty::loadVolume() throw (tgt::FileException, std::bad_alloc){
std::string url = get();
if (url.empty()) {
LWARNING("loadVolume(): empty URL");
return;
}
ProgressBar* progressBar = getProgressBar();
if (progressBar) {
progressBar->setTitle("Loading volume");
progressBar->setProgressMessage("Loading volume ...");
}
VolumeSerializerPopulator serializerPopulator(progressBar);
VolumeList* volumeList = serializerPopulator.getVolumeSerializer()->read(url);
if (progressBar)
progressBar->hide();
if (volumeList && !volumeList->empty()) {
VolumeBase* handle = volumeList->first();
tgtAssert(handle, "No handle");
setVolume(static_cast<Volume*>(handle));
// delete superfluous volumes
if (volumeList->size() > 1) {
LWARNING("More than one volume loaded from file: " + url + ". Discarding surplus volumes!");
for (size_t i=1; i<volumeList->size(); i++)
delete volumeList->at(i);
}
// property does take ownership of loaded handles
volumeOwner_ = true;
}
delete volumeList;
}
LxQtSensors::LxQtSensors(ILxQtPanelPlugin *plugin, QWidget* parent):
QFrame(parent),
mPlugin(plugin),
mSettings(plugin->settings())
{
mDetectedChips = mSensors.getDetectedChips();
/**
* We have all needed data to initialize default settings, we have to do it here as later
* we are using them.
*/
initDefaultSettings();
// Add GUI elements
ProgressBar* pg = NULL;
mLayout = new QBoxLayout(QBoxLayout::LeftToRight, this);
mLayout->setSpacing(0);
mLayout->setContentsMargins(0, 0, 0, 0);
QString chipFeatureLabel;
mSettings->beginGroup("chips");
for (int i = 0; i < mDetectedChips.size(); ++i)
{
mSettings->beginGroup(mDetectedChips[i].getName());
const QList<Feature>& features = mDetectedChips[i].getFeatures();
for (int j = 0; j < features.size(); ++j)
{
if (features[j].getType() == SENSORS_FEATURE_TEMP)
{
chipFeatureLabel = features[j].getLabel();
mSettings->beginGroup(chipFeatureLabel);
pg = new ProgressBar(this);
pg->setSizePolicy(QSizePolicy::Preferred, QSizePolicy::Preferred);
// Hide progress bar if it is not enabled
if (!mSettings->value("enabled").toBool())
{
pg->hide();
}
pg->setToolTip(chipFeatureLabel);
pg->setTextVisible(false);
QPalette pal = pg->palette();
QColor color(mSettings->value("color").toString());
pal.setColor(QPalette::Active, QPalette::Highlight, color);
pal.setColor(QPalette::Inactive, QPalette::Highlight, color);
pg->setPalette(pal);
mTemperatureProgressBars.push_back(pg);
mLayout->addWidget(pg);
mSettings->endGroup();
}
}
mSettings->endGroup();
}
mSettings->endGroup();
// Fit plugin to current panel
realign();
// Updated sensors readings to display actual values at start
updateSensorReadings();
// Run timer that will be updating sensor readings
mUpdateSensorReadingsTimer.setParent(this);
connect(&mUpdateSensorReadingsTimer, SIGNAL(timeout()), this, SLOT(updateSensorReadings()));
mUpdateSensorReadingsTimer.start(mSettings->value("updateInterval").toInt() * 1000);
// Run timer that will be showin warning
mWarningAboutHighTemperatureTimer.setParent(this);
connect(&mWarningAboutHighTemperatureTimer, SIGNAL(timeout()), this,
SLOT(warningAboutHighTemperature()));
if (mSettings->value("warningAboutHighTemperature").toBool())
{
mWarningAboutHighTemperatureTimer.start(mWarningAboutHighTemperatureTimerFreq);
}
}
void ImageSequenceSource::loadImageSequence(const std::string& d)
throw (tgt::FileException, std::bad_alloc) {
if (!isInitialized()) {
LERROR("loadImageSequence(): not initialized");
return;
}
// important: d might be cleared by clearSequence
std::string dir(d);
forceReload_ = false;
if (!imageSequence_) {
LERROR("No image sequence present");
return;
}
// clear current sequence
clearSequence();
if (dir.empty())
return;
LINFO("Loading images from directory " << dir << " ...");
currentDir_ = dir;
imageDirectory_.set(dir);
// load images as textures and collect them in an image sequence
std::vector<std::string> filenames = tgt::FileSystem::readDirectory(dir, true, false);
// create progress bar
ProgressBar* progressDialog = 0;
if (showProgressBar_.get() && !filenames.empty()) {
progressDialog = VoreenApplication::app()->createProgressDialog();
if (progressDialog) {
progressDialog->setTitle("Loading Images");
progressDialog->show();
progressDialog->setProgress(0.f);
progressDialog->forceUpdate();
}
}
tgt::Texture::Filter filterMode = textureFiltering_.get() ? tgt::Texture::LINEAR : tgt::Texture::NEAREST;
for (size_t i=0; i<filenames.size(); ++i) {
if (progressDialog) {
progressDialog->setMessage("Loading " + filenames[i] + " ...");
progressDialog->setProgress(static_cast<float>(i) / static_cast<float>(filenames.size()));
}
LINFO("Loading image " << filenames[i] << " ...");
tgt::Texture* texture = TexMgr.load(dir + "/" + filenames[i], filterMode,
false, false, true, false, !GpuCaps.isNpotSupported());
if (texture)
imageSequence_->add(texture);
else
LWARNING("Failed to load image: " << filenames[i]);
}
LGL_ERROR;
// upload texture data
if (uploadTextureData_.get()) {
LINFO("Uploading texture data ...");
for (unsigned int i=0; i<imageSequence_->size(); i++)
imageSequence_->at(i)->uploadTexture();
LGL_ERROR;
}
// clear progress
if (progressDialog) {
progressDialog->hide();
delete progressDialog;
progressDialog = 0;
}
// output sequence
outport_.setData(imageSequence_);
LINFO("Successfully loaded " << imageSequence_->size() << " images.");
numImages_.set(imageSequence_->size());
LGL_ERROR;
}
