PythonTerminalEdit::PythonTerminalEdit(QWidget *parent) : QTextEdit(parent),
m_current(0), m_cursorPos(0), m_indent(0)
{
// Load the saved commands
QSettings settings;
int size = settings.beginReadArray("pythonCommands");
for (int i = 0; i < size; ++i) {
settings.setArrayIndex(i);
m_commandStack.append( settings.value("command").toString() );
}
settings.endArray();
// set the font
QFont font;
font.setFamily(QString::fromUtf8("Courier New"));
setFont(font);
printPrompt();
// connect(this, SIGNAL(cursorPositionChanged()), this, SLOT(setTextCursorToEnd()));
}
void LinuxDeviceConfigurations::load()
{
QSettings *settings = Core::ICore::instance()->settings();
settings->beginGroup(SettingsGroup);
m_nextId = settings->value(IdCounterKey, 1).toULongLong();
m_defaultSshKeyFilePath = settings->value(DefaultKeyFilePathKey,
LinuxDeviceConfiguration::defaultPrivateKeyFilePath()).toString();
int count = settings->beginReadArray(ConfigListKey);
for (int i = 0; i < count; ++i) {
settings->setArrayIndex(i);
LinuxDeviceConfiguration::Ptr devConf
= LinuxDeviceConfiguration::create(*settings, m_nextId);
m_devConfigs << devConf;
}
settings->endArray();
settings->endGroup();
ensureDefaultExists(LinuxDeviceConfiguration::Maemo5OsType);
ensureDefaultExists(LinuxDeviceConfiguration::HarmattanOsType);
ensureDefaultExists(LinuxDeviceConfiguration::MeeGoOsType);
ensureDefaultExists(LinuxDeviceConfiguration::GenericLinuxOsType);
}
void WebBrowser::onConfig()
{
bool ok;
QString text = QInputDialog::getText(this, tr("Cambiar Pagina de Inicio"),
tr("Página actual: ")+homepage_, QLineEdit::Normal,
address_->text(), &ok);
if (ok && !text.isEmpty()) {
if(!text.startsWith("http://")
&& !text.startsWith("https://")
&& text.length()!=0)
homepage_="http://"+text;
else
homepage_=text;
}
QSettings* settings = new QSettings("/home/nad/config.web.ini",QSettings::IniFormat);
settings->beginWriteArray("Config");
settings->setValue("homepage",homepage_);
settings->endArray();
}
void LibraryModel::DeleteGenerator(const QModelIndex& index) {
if (index.parent() != ItemToIndex(smart_playlist_node_)) return;
// Remove the item from the tree
smart_playlist_node_->DeleteNotify(index.row());
QSettings s;
s.beginGroup(kSmartPlaylistsSettingsGroup);
// Rewrite all the items to the settings
s.beginWriteArray(backend_->songs_table(),
smart_playlist_node_->children.count());
int i = 0;
for (LibraryItem* item : smart_playlist_node_->children) {
s.setArrayIndex(i++);
s.setValue("name", item->display_text);
s.setValue("type", item->key);
s.setValue("data", item->smart_playlist_data);
}
s.endArray();
}
void CSharesListDialog::saveSettings(QSettings &sett, const QVector<QSharedPointer<SShare> > &shares)
{
sett.beginGroup(ShareSettingsKeys::blockPrefix);
sett.remove("");
sett.endGroup();
sett.beginWriteArray(ShareSettingsKeys::blockPrefix);
QVector<QSharedPointer<SShare> >::ConstIterator it = shares.constBegin();
for(int i = 0; it != shares.constEnd(); ++i, ++it)
{
sett.setArrayIndex(i);
sett.setValue(ShareSettingsKeys::name, (*it)->name);
sett.setValue(ShareSettingsKeys::ip, (*it)->ip);
sett.setValue(ShareSettingsKeys::path, (*it)->path);
sett.setValue(ShareSettingsKeys::username, (*it)->username);
sett.setValue(ShareSettingsKeys::password, (*it)->password);
sett.setValue(ShareSettingsKeys::type, (int) (*it)->type);
}
sett.endArray();
sett.sync();
}
void DeviceSerial::deviceCfgLoad( QSettings &pDataStream )
{
DeviceSerial *DevCur;
while( !mDeviceList.isEmpty() )
{
DevCur = mDeviceList.takeFirst();
delDevice( DevCur );
}
pDataStream.beginGroup( "serial" );
int DevCnt = pDataStream.beginReadArray( "devices" );
for( int i = 0 ; i < DevCnt ; i++ )
{
pDataStream.setArrayIndex( i );
if( ( DevCur = newDevice() ) == 0 )
{
continue;
}
DevCur->setName( pDataStream.value( "name", DevCur->name() ).toString() );
DevCur->setUuid( pDataStream.value( "uuid", DevCur->uuid() ).value<QUuid>() );
DevCur->cfgLoad( pDataStream );
if( pDataStream.value( "enabled", false ).toBool() )
{
DevCur->setEnabled( true );
}
}
pDataStream.endArray();
pDataStream.endGroup();
}
void RenderDialog::accept()
{
if (QFileInfo(absoluteFilePath()).exists())
{
QMessageBox::StandardButton b = QMessageBox::question(this,
tr("File already exists"),
tr("Do you want to overwrite %1?")
.arg(QFileInfo(absoluteFilePath()).fileName()),
QMessageBox::Yes | QMessageBox::No,
QMessageBox::NoButton );
if (b == QMessageBox::No)
return;
}
QSettings settings;
size = m_sizeComboBox->currentText();
preset = m_qualityComboBox->currentText();
m_sizeComboBox->removeItem(m_sizeComboBox->currentIndex());
settings.beginWriteArray("renderdialog/sizes");
settings.setArrayIndex(0);
settings.setValue("dim", size);
int cnt = 10;
for (int i = 0; i < cnt; ++i)
{
QString text(m_sizeComboBox->itemText(i));
if (text.isEmpty())
break;
settings.setArrayIndex(i+1);
settings.setValue("dim", text);
}
settings.endArray();
settings.setValue("renderdialog/last_size", size);
settings.setValue("renderdialog/last_quality", preset);
QDialog::accept();
}
void GlooxProtocol::RestoreAccounts ()
{
QSettings settings (QSettings::IniFormat, QSettings::UserScope,
QCoreApplication::organizationName (),
QCoreApplication::applicationName () + "_Azoth_Xoox_Accounts");
int size = settings.beginReadArray ("Accounts");
for (int i = 0; i < size; ++i)
{
settings.setArrayIndex (i);
QByteArray data = settings.value ("SerializedData").toByteArray ();
GlooxAccount *acc = GlooxAccount::Deserialize (data, this);
if (!acc)
{
qWarning () << Q_FUNC_INFO
<< "unserializable acount"
<< i;
continue;
}
Accounts_ << acc;
}
settings.endArray ();
}
void AccountManager::save() const
{
QSettings settings;
settings.remove("accounts/list/");
if(!m_accounts.isEmpty()) {
settings.beginWriteArray("accounts/list/", m_accounts.size());
int i=0;
for(auto a: m_accounts) {
settings.setArrayIndex(i++);
settings.setValue("id", a->id());
settings.setValue("type", a->type());
}
settings.endArray();
}
settings.sync();
}
void MainWindow::readSettings() {
QSettings settings;
settings.beginGroup("WorkFilterModelCollection");
const int count = settings.beginReadArray("filters");
for (int i = 0; i < count; i++) {
settings.setArrayIndex(i);
QString label("filtered");
if (settings.contains("label"))
label = settings.value("label").toString();
addFilterTab(settings.value("expression").toString(), label);
}
settings.endArray();
settings.endGroup();
/*
settings.beginGroup("MainWindow");
if (settings.contains("geometry")) {
restoreGeometry(settings.value("geometry").toByteArray());
}
settings.endGroup();
*/
}
void GraphItemModel::readSettings(QSettings& settings)
{
settings.beginGroup("NodeModel");
int size = settings.beginReadArray("nodes");
Node* tmp=NULL;
for (int i = 0; i < size; ++i) {
settings.setArrayIndex(i);
tmp=new Node(NULL);
tmp->setStringManager(m_stringManager);
tmp->setId(settings.value("id").toString());
tmp->setText(settings.value("text").toString());
//tmp->getColorTheme()->readSetting(settings);
m_list->append(tmp);
}
settings.endArray();
settings.endGroup();
/*if(m_list->size()==0)
{
Node* tmp=new Node(NULL);
tmp->setColor(Qt::blue);
tmp->setStringManager(m_stringManager);
tmp->setText(tr("Male"));
addItems(tmp);
tmp=new Node(NULL);
tmp->setColor(Qt::red);
tmp->setText(tr("Female"));
tmp->setStringManager(m_stringManager);
addItems(tmp);
tmp=new Node(NULL);
tmp->setColor(Qt::green);
tmp->setText(tr("Place"));
tmp->setStringManager(m_stringManager);
addItems(tmp);
}*/
}
void SyntroDB::restoreWindowState()
{
QSettings *settings = SyntroUtils::getSettings();
settings->beginGroup("Window");
restoreGeometry(settings->value("Geometry").toByteArray());
restoreState(settings->value("State").toByteArray());
int count = settings->beginReadArray("Grid");
for (int i = 0; i < count && i < m_rxStreamTable->columnCount(); i++) {
settings->setArrayIndex(i);
int width = settings->value("columnWidth").toInt();
if (width > 0)
m_rxStreamTable->setColumnWidth(i, width);
}
settings->endArray();
settings->endGroup();
delete settings;
}
void PresetManager::saveSpecialSet(const presetElementVec &preset, bool usesTimeAxis) const
{
// This preset is stored in the APM Planner ini file and loaded / stored on every
// access. This guarantees that a saved set is immediate loadable from another analysis window.
QSettings graphSettings;
graphSettings.beginGroup("LOGANALYSIS");
graphSettings.remove(""); // removes all entries from this group
graphSettings.beginWriteArray("GRAPH_ELEMENTS");
for(int i = 0; i < preset.size(); ++i)
{
graphSettings.setArrayIndex(i);
graphSettings.setValue("NAME", preset.at(i).m_graph);
graphSettings.setValue("COLOR/RED", preset.at(i).m_color.red());
graphSettings.setValue("COLOR/GREEN", preset.at(i).m_color.green());
graphSettings.setValue("COLOR/BLUE", preset.at(i).m_color.blue());
if(preset.at(i).m_manualRange)
{ // only store scaling if set to manual
graphSettings.setValue("Y_AXIS_MIN", preset.at(i).m_range.lower);
graphSettings.setValue("Y_AXIS_MAX", preset.at(i).m_range.upper);
}
else if(preset.at(i).m_group.size() > 0)
{ // store group name if grouped
graphSettings.setValue("GROUP", preset.at(i).m_group);
}
}
graphSettings.endArray();
graphSettings.beginGroup("GRAPH_SETTINGS");
graphSettings.setValue("TIME_AXIS", usesTimeAxis);
graphSettings.endGroup();
graphSettings.endGroup(); // "LOGANALYSIS"
graphSettings.sync();
QLOG_DEBUG() << "PresetManager::saveSpecialSet - Special View saved.";
}
QtVersionManager::QtVersionManager()
: m_emptyVersion(new QtVersion)
{
QSettings *s = Core::ICore::instance()->settings();
m_defaultVersion = s->value(defaultQtVersionKey, 0).toInt();
m_idcount = 1;
int size = s->beginReadArray(QtVersionsSectionName);
for (int i = 0; i < size; ++i) {
s->setArrayIndex(i);
// Find the right id
// Either something saved or something generated
// Note: This code assumes that either all ids are read from the settings
// or generated on the fly.
int id = s->value("Id", -1).toInt();
if (id == -1)
id = getUniqueId();
else if (id > m_idcount)
m_idcount = id;
QtVersion *version = new QtVersion(s->value("Name").toString(),
s->value("Path").toString(),
id,
s->value("IsSystemVersion", false).toBool());
version->setMingwDirectory(s->value("MingwDirectory").toString());
version->setPrependPath(s->value("PrependPath").toString());
version->setMsvcVersion(s->value("msvcVersion").toString());
m_versions.append(version);
}
s->endArray();
updateUniqueIdToIndexMap();
++m_idcount;
addNewVersionsFromInstaller();
updateSystemVersion();
writeVersionsIntoSettings();
updateDocumentation();
}
void StManagerStudyListComp::updateRecentExams ( const TableRow *row, const QString &prefix )
{
ResultSet resultSet;
loadRecentExams( resultSet, prefix );
StudyFilter::filterDuplicates( &resultSet, row );
resultSet.push_back( *row );
if ( resultSet.size() > RECENT_EXAMS_NUMBER ) {
resultSet.erase( resultSet.begin() );
}
QSettings settings;
settings.beginWriteArray( prefix );
for ( unsigned i = 0; i < resultSet.size(); i++ )
{
settings.setArrayIndex( i );
updateRecentRow ( &resultSet[i], settings );
}
settings.endArray();
}
void RegexpMatcherManager::RestoreSettings ()
{
QSettings settings (Proxy::Instance ()->GetOrganizationName (),
Proxy::Instance ()->GetApplicationName () + "_Aggregator");
int size = settings.beginReadArray ("RegexpMatcher");
for (int i = 0; i < size; ++i)
{
settings.setArrayIndex (i);
QByteArray data = settings.value ("Item").toByteArray ();
RegexpItem item;
try
{
item.Deserialize (data);
}
catch (const std::runtime_error& e)
{
qWarning () << Q_FUNC_INFO << e.what ();
continue;
}
Items_.push_back (item);
}
settings.endArray ();
}
void laborOptimizerPlan::read_details(QSettings &s){
qDeleteAll(plan_details);
plan_details.clear();
int count = s.beginReadArray("jobs");
for(int i=0; i<count; i++){
PlanDetail *d = new PlanDetail();
s.setArrayIndex(i);
d->labor_id = s.value("labor_id").toInt();
QString role_name = s.value("role_name").toString();
d->role_name = role_name;
if(role_name=="")
d->use_skill = true;
else
d->use_skill = false;
d->priority = s.value("priority").toFloat();
d->ratio = s.value("max_laborers").toFloat();
d->group_ratio = 0.0;
plan_details.append(d);
}
s.endArray();
}
void LibraryModel::UpdateGenerator(const QModelIndex& index, GeneratorPtr gen) {
if (index.parent() != ItemToIndex(smart_playlist_node_)) return;
LibraryItem* item = IndexToItem(index);
if (!item) return;
// Update the config
QSettings s;
s.beginGroup(kSmartPlaylistsSettingsGroup);
// Count the existing items
const int count = s.beginReadArray(backend_->songs_table());
s.endArray();
s.beginWriteArray(backend_->songs_table(), count);
SaveGenerator(&s, index.row(), gen);
// Update the text of the item
item->display_text = gen->name();
item->sort_text = item->display_text;
item->key = gen->type();
item->smart_playlist_data = gen->Save();
item->ChangedNotify();
}
void
PitchBendSequenceDialog::savePreset(int preset)
{
/* A preset is stored in one element in an array. There is a
different array for each controller or pitchbend. */
QSettings settings;
settings.beginGroup(PitchBendSequenceConfigGroup);
settings.beginWriteArray(m_control.getName().data());
settings.setArrayIndex(preset);
settings.setValue("pre_bend_value", m_prebendValue->value());
settings.setValue("pre_bend_duration_value", m_prebendDuration->value());
settings.setValue("sequence_ramp_duration", m_sequenceRampDuration->value());
settings.setValue("sequence_ramp_end_value", m_sequenceEndValue->value());
settings.setValue("vibrato_start_amplitude", m_vibratoStartAmplitude->value());
settings.setValue("vibrato_end_amplitude", m_vibratoEndAmplitude->value());
settings.setValue("vibrato_frequency", m_vibratoFrequency->value());
settings.setValue("step_count", m_resolution->value());
settings.setValue("step_size", m_stepSize->value());
settings.setValue("ramp_mode", getRampMode());
settings.setValue("step_size_calculation", getStepSizeCalculation());
settings.endArray();
settings.endGroup();
}
void SingleAccAuth::SaveQueue () const
{
QSettings settings (QCoreApplication::organizationName (),
QCoreApplication::applicationName () + "_Scroblibre");
settings.beginGroup ("Queues");
settings.beginGroup (BaseURL_.toString ());
settings.beginGroup (Login_);
auto save = [&settings] (const SubmitInfo& info) -> void
{
settings.setValue ("Artist", info.Info_.Artist_);
settings.setValue ("Album", info.Info_.Album_);
settings.setValue ("Title", info.Info_.Title_);
settings.setValue ("TS", info.TS_);
settings.setValue ("Length", info.Info_.Length_);
settings.setValue ("Track", info.Info_.TrackNumber_);
};
settings.remove ("LastSubmit");
settings.beginGroup ("LastSubmit");
if (LastSubmit_.IsValid ())
save (LastSubmit_);
settings.endGroup ();
settings.beginWriteArray ("Items");
for (auto i = 0; i < Queue_.size (); ++i)
{
settings.setArrayIndex (i);
save (Queue_.at (i));
}
settings.endArray ();
settings.endGroup ();
settings.endGroup ();
settings.endGroup ();
}
void RecentFiles::retrieveFromStorage( QSettings& settings )
{
LOG(logDEBUG) << "RecentFiles::retrieveFromStorage";
recentFiles_.clear();
if ( settings.contains( "RecentFiles/version" ) ) {
// Unserialise the "new style" stored history
settings.beginGroup( "RecentFiles" );
if ( settings.value( "version" ) == RECENTFILES_VERSION ) {
int size = settings.beginReadArray( "filesHistory" );
for (int i = 0; i < size; ++i) {
settings.setArrayIndex(i);
QString search = settings.value( "name" ).toString();
recentFiles_.append( search );
}
settings.endArray();
}
else {
LOG(logERROR) << "Unknown version of highlighterSet, ignoring it...";
}
settings.endGroup();
}
}
Gui::Gui(QWidget* parent)
: QWidget(parent)
{
setupUi(this);
QSettings* settings = *gwinshellInstance->settings;
if (settings == NULL) return;
// Read in the array of websites from options
table->setSortingEnabled(false);
int count = settings->beginReadArray("winshell/cmds");
table->setRowCount(count);
for(int i = 0; i < count; ++i) {
settings->setArrayIndex(i);
table->setItem(i, 0, new QTableWidgetItem(settings->value("name").toString()));
table->setItem(i, 1, new QTableWidgetItem(settings->value("file").toString()));
table->setItem(i, 2, new QTableWidgetItem(settings->value("args").toString()));
}
settings->endArray();
table->setSortingEnabled(true);
connect(tableNew, SIGNAL(clicked(bool)), this, SLOT(newRow(void)));
connect(tableRemove, SIGNAL(clicked(bool)), this, SLOT(remRow(void)));
}
void MidiTimelineNode::loadSettings( QSettings &pSettings )
{
pSettings.beginGroup( "timeline" );
mTimelineControl->cfgLoad( pSettings );
pSettings.endGroup();
pSettings.beginGroup( "time" );
mKF->cfgLoad( pSettings );
pSettings.endGroup();
mEvents.clear();
int EvtCnt = pSettings.beginReadArray( "events" );
mEvents.reserve( EvtCnt );
fugio::MidiEvent ME = { 0, 0 };
for( int i = 0 ; i < EvtCnt ; i++ )
{
pSettings.setArrayIndex( i );
ME.timestamp = pSettings.value( "t" ).toUInt();
ME.message = pSettings.value( "m" ).toUInt();
mEvents << ME;
}
pSettings.endArray();
mKF->setTimeMax( qreal( ME.timestamp ) / 1000.0 );
}
void MainWindow::loadSettings(QString settingsName)
{
QSettings *s = new QSettings(tr(APPLICATION_COMPANY), tr(APPLICATION_NAME), this);
s->beginGroup(settingsName);
s->beginGroup(tr("MasterController"));
master->setName(s->value(tr("name"), tr("Master")).toString());
master->setVisible(s->value(tr("visible"), tr("true")).toBool());
s->endGroup();
int size = s->beginReadArray(tr("LightControllers"));
for(int i = 0; i < controllers.size(); i++){
LightController *lc = controllers.at(i);
for(int j = 0; j < size; j++){
s->setArrayIndex(j);
if(s->value(tr("id"), tr("")).toString() == lc->id()){
lc->loadSettings(s);
}
}
}
s->endArray();
presetController->loadSettings(s);
audio->loadSettings(s);
s->endGroup();
GLOBAL_settingsChanged = false;
s->sync();
}
table_model::table_model(QObject *parent) :
QAbstractTableModel(parent)
{
QSettings settings;
int size = settings.beginReadArray("friends");
for (int i = 0; i < size; ++i)
{
settings.setArrayIndex(i);
friend_t p;
p.player.setPattern(settings.value("name").toString());
p.clan.setPattern(settings.value("clan").toString());
friends.append(p);
}
settings.endArray();
if(!size)
{
friend_t ruclan;
ruclan.player.setPattern("*");
ruclan.clan.setPattern(".ru!");
friends.append(ruclan);
}
}
void PropertiesManager::createTimeDerivativeProperties(TimeDerivativeTextItem *td)
{
//move up down
root->actionMove_Up->setEnabled(true);
root->actionMove_Down->setEnabled(true);
root->actionDeleteItems->setEnabled(true);
QLabel *label = new QLabel("<b>Edit Time Derivative</b>");
addRow(label);
QComboBox *var = new QComboBox();
for (int i=0; i< root->al->StateVariableList.size(); i++)
{
var->addItem(root->al->StateVariableList[i]->getName());
if (td->getVariable() != NULL){
if (root->al->StateVariableList[i]->getName().compare(td->getVariable()->getName()) == 0)
{
var->setCurrentIndex(i);
}
}
else
var->setCurrentIndex(-1);
}
connect(var, SIGNAL(currentIndexChanged(QString)), td, SLOT(setVariable(QString)));
addRow(tr("&Variable:"),var);
QLineEdit *maths = new QLineEdit();
maths->installEventFilter(&eventFilterObject);
maths->setText(td->getMaths()->equation);
connect(maths, SIGNAL(textEdited(QString)), td, SLOT(setMaths(QString)));
addRow(tr("&Maths:"),maths);
addWidget(new QLabel(tr("<i>in physiological units</i>")));
QStringList errs;
td->time_derivative->maths->validateMathInLine(root->al.data(), &errs);
// sort out errors
QSettings settings;
int num_errs = settings.beginReadArray("warnings");
settings.endArray();
if (num_errs != 0) {
// show errors by changing lineedit colour
QPalette p = maths->palette();
p.setColor( QPalette::Normal, QPalette::Base, QColor(255, 200, 200) );
maths->setPalette(p);
// clear errors
settings.remove("warnings");
}
if (num_errs == 0) {
// show no errors by changing lineedit colour
QPalette p = maths->palette();
p.setColor( QPalette::Normal, QPalette::Base, QColor(255, 255, 255) );
maths->setPalette(p);
// clear errors
settings.remove("warnings");
}
}
Main::Main(const char *prefix) :
CoastalMain()
{
ui.setupUi((QMainWindow *)this);
ui.statusbar->showMessage(tr("loading..."));
program_name = "Coastal Search";
program_about = "Coastal File Search Utility";
QWidget *toolbar = extendToolbar(ui.toolBar);
tb.setupUi(toolbar);
ind = NULL;
if(prefix)
QDir::setCurrent(prefix);
dir.setPath(QDir::currentPath());
history.append(dir.path());
QSettings settings;
resize(settings.value("size", QSize(760, 540)).toSize());
if(settings.value("case", false).toBool())
casefilter = true;
if(settings.value("text", false).toBool())
CoastalView::setSensitive();
if(types) {
ui.filterTypes->setText(types);
ui.filterTypes->setEnabled(false);
}
else {
QString filter = settings.value("filter", ".txt;.log").toString();
ui.filterTypes->setText(filter);
int paths = settings.beginReadArray("paths");
// qDebug() << "SIZE " << paths << endl;
for(int path = 0; path < paths; ++path) {
settings.setArrayIndex(path);
QString temp = settings.value("path").toString();
// qDebug() << "STR " << path << " VALUE " << temp << endl;
if(temp == dir.path())
continue;
history.append(temp);
}
settings.endArray();
}
ui.indexView->setContextMenuPolicy(Qt::CustomContextMenu);
connect(ui.indexView, SIGNAL(customContextMenuRequested(const QPoint&)), this, SLOT(open(const QPoint&)));
connect(ui.actionQuit, SIGNAL(triggered()), qApp, SLOT(quit()));
connect(ui.actionAbout, SIGNAL(triggered()), this, SLOT(about()));
connect(ui.actionClear, SIGNAL(triggered()), this, SLOT(clear()));
connect(ui.actionSearch, SIGNAL(triggered()), this, SLOT(reload()));
connect(ui.actionOptions, SIGNAL(triggered()), this, SLOT(options()));
connect(ui.actionSupport, SIGNAL(triggered()), this, SLOT(support()));
connect(ui.pathButton, SIGNAL(clicked()), this, SLOT(changeDir()));
connect(ui.pathBox, SIGNAL(currentIndexChanged(int)), this, SLOT(selectDir(int)));
connect(tb.searchText, SIGNAL(returnPressed()), this, SLOT(reload()));
connect(ui.searchName, SIGNAL(returnPressed()), this, SLOT(reload()));
connect(ui.filterTypes, SIGNAL(returnPressed()), this, SLOT(reload()));
connect(ui.tabs, SIGNAL(tabCloseRequested(int)), this, SLOT(close(int)));
connect(ui.indexView, SIGNAL(activated(const QModelIndex&)), this, SLOT(open(const QModelIndex&)));
setContextMenuPolicy(Qt::CustomContextMenu);
connect(this, SIGNAL(customContextMenuRequested(const QPoint&)), this, SLOT(menu(const QPoint&)));
connect(ui.actionView, SIGNAL(triggered()), this, SLOT(view()));
connect(ui.actionOpen, SIGNAL(triggered()), this, SLOT(open()));
// adding history triggers selectDir...
ui.pathBox->addItems(history);
clear();
}
/**
* This method is an extension of the constructor. It was implemented to reduce the amount of code duplicated between the constuctors.
*/
bool eVisGenericEventBrowserGui::initBrowser()
{
//setup gui
setWindowTitle( tr( "Generic Event Browser" ) );
connect( treeEventData, SIGNAL( itemDoubleClicked( QTreeWidgetItem *, int ) ), this, SLOT( launchExternalApplication( QTreeWidgetItem *, int ) ) );
mHighlightSymbol.load( ":/evis/eVisHighlightSymbol.png" );
mPointerSymbol.load( ":/evis/eVisPointerSymbol.png" );
mCompassOffset = 0.0;
//Flag to let us know if the browser fully loaded
mBrowserInitialized = false;
//Initialize some class variables
mDefaultEventImagePathField = 0;
mDefaultCompassBearingField = 0;
mDefaultCompassOffsetField = 0;
//initialize Display tab GUI elements
pbtnNext->setEnabled( false );
pbtnPrevious->setEnabled( false );
//Set up Attribute display
treeEventData->setColumnCount( 2 );
QStringList treeHeaders;
treeHeaders << tr( "Field" ) << tr( "Value" );
treeEventData->setHeaderLabels( treeHeaders );
//Initialize Options tab GUI elements
cboxEventImagePathField->setEnabled( true );
chkboxEventImagePathRelative->setChecked( false );
chkboxDisplayCompassBearing->setChecked( false );
cboxCompassBearingField->setEnabled( true );
rbtnManualCompassOffset->setChecked( false );
dsboxCompassOffset->setEnabled( true );
dsboxCompassOffset->setValue( 0.0 );
rbtnAttributeCompassOffset->setChecked( false );
cboxCompassOffsetField->setEnabled( true );
chkboxUseOnlyFilename->setChecked( false );
QString myThemePath = QgsApplication::activeThemePath();
pbtnResetEventImagePathData->setIcon( QIcon( QPixmap( myThemePath + "/mActionDraw.svg" ) ) );
pbtnResetCompassBearingData->setIcon( QIcon( QPixmap( myThemePath + "/mActionDraw.svg" ) ) );
pbtnResetCompassOffsetData->setIcon( QIcon( QPixmap( myThemePath + "/mActionDraw.svg" ) ) );
pbtnResetBasePathData->setIcon( QIcon( QPixmap( myThemePath + "/mActionDraw.svg" ) ) );
pbtnResetUseOnlyFilenameData->setIcon( QIcon( QPixmap( myThemePath + "/mActionDraw.svg" ) ) );
pbtnResetApplyPathRulesToDocs->setIcon( QIcon( QPixmap( myThemePath + "/mActionDraw.svg" ) ) );
chkboxSaveEventImagePathData->setChecked( false );
chkboxSaveCompassBearingData->setChecked( false );
chkboxSaveCompassOffsetData->setChecked( false );
chkboxSaveBasePathData->setChecked( false );
chkboxSaveUseOnlyFilenameData->setChecked( false );
//Set up Configure External Application buttons
pbtnAddFileType->setIcon( QIcon( QPixmap( myThemePath + "/mActionNewAttribute.png" ) ) );
pbtnDeleteFileType->setIcon( QIcon( QPixmap( myThemePath + "/mActionDeleteAttribute.png" ) ) );
//Check to for interface, not null when launched from plugin toolbar, otherwise expect map canvas
if ( mInterface )
{
//check for active layer
if ( mInterface->activeLayer() )
{
//verify that the active layer is a vector layer
if ( QgsMapLayer::VectorLayer == mInterface->activeLayer()->type() )
{
mVectorLayer = ( QgsVectorLayer* )mInterface->activeLayer();
mCanvas = mInterface->mapCanvas();
}
else
{
QMessageBox::warning( this, tr( "Warning" ), tr( "This tool only supports vector data" ) );
return false;
}
}
else
{
QMessageBox::warning( this, tr( "Warning" ), tr( "No active layers found" ) );
return false;
}
}
//check for map canvas, if map canvas is null, throw error
else if ( mCanvas )
{
//check for active layer
if ( mCanvas->currentLayer() )
{
//verify that the active layer is a vector layer
if ( QgsMapLayer::VectorLayer == mCanvas->currentLayer()->type() )
{
mVectorLayer = ( QgsVectorLayer* )mCanvas->currentLayer();
}
else
{
QMessageBox::warning( this, tr( "Warning" ), tr( "This tool only supports vector data" ) );
return false;
}
}
else
{
QMessageBox::warning( this, tr( "Warning" ), tr( "No active layers found" ) );
return false;
}
}
else
{
QMessageBox::warning( this, tr( "Error" ), tr( "Unable to connect to either the map canvas or application interface" ) );
return false;
}
//Connect rendering routine for highlighting symbols and load symbols
connect( mCanvas, SIGNAL( renderComplete( QPainter * ) ), this, SLOT( renderSymbol( QPainter * ) ) );
mDataProvider = mVectorLayer->dataProvider();
/*
* A list of the selected feature ids is made so that we can move forward and backward through
* the list. The data providers only have the ability to get one feature at a time or
* sequentially move forward through the selected features
*/
if ( 0 == mVectorLayer->selectedFeatureCount() ) //if nothing is selected select everything
{
mVectorLayer->invertSelection();
mFeatureIds = mVectorLayer->selectedFeaturesIds().toList();
}
else //use selected features
{
mFeatureIds = mVectorLayer->selectedFeaturesIds().toList();
}
if ( 0 == mFeatureIds.size() )
return false;
//get the first feature in the list so we can set the field in the pulldown menues
QgsFeature* myFeature = featureAtId( mFeatureIds.at( mCurrentFeatureIndex ) );
if ( !myFeature )
{
QMessageBox::warning( this, tr( "Error" ), tr( "An invalid feature was received during initialization" ) );
return false;
}
QgsFields myFields = mDataProvider->fields();
mIgnoreEvent = true; //Ignore indexChanged event when adding items to combo boxes
for ( int x = 0; x < myFields.count(); x++ )
{
QString name = myFields.at( x ).name();
cboxEventImagePathField->addItem( name );
cboxCompassBearingField->addItem( name );
cboxCompassOffsetField->addItem( name );
if ( myFeature->attribute( x ).toString().contains( QRegExp( "(jpg|jpeg|tif|tiff|gif)", Qt::CaseInsensitive ) ) )
{
mDefaultEventImagePathField = x;
}
if ( name.contains( QRegExp( "(comp|bear)", Qt::CaseInsensitive ) ) )
{
mDefaultCompassBearingField = x;
}
if ( name.contains( QRegExp( "(offset|declination)", Qt::CaseInsensitive ) ) )
{
mDefaultCompassOffsetField = x;
}
}
mIgnoreEvent = false;
//Set Display tab gui items
if ( mFeatureIds.size() > 1 )
{
pbtnNext->setEnabled( true );
}
setWindowTitle( tr( "Event Browser - Displaying records 01 of %1" ).arg( mFeatureIds.size(), 2, 10, QChar( '0' ) ) );
//Set Options tab gui items
initOptionsTab();
//Load file associations into Configure External Applications tab gui items
QSettings myQSettings;
myQSettings.beginWriteArray( "/eVis/filetypeassociations" );
int myTotalAssociations = myQSettings.childGroups().count();
int myIterator = 0;
while ( myIterator < myTotalAssociations )
{
myQSettings.setArrayIndex( myIterator );
tableFileTypeAssociations->insertRow( tableFileTypeAssociations->rowCount() );
tableFileTypeAssociations->setItem( myIterator, 0, new QTableWidgetItem( myQSettings.value( "extension", "" ).toString() ) );
tableFileTypeAssociations->setItem( myIterator, 1, new QTableWidgetItem( myQSettings.value( "application", "" ).toString() ) );
myIterator++;
}
myQSettings.endArray();
mBrowserInitialized = true;
return true;
}
void EnggDiffractionViewQtGUI::saveSettings() const {
QSettings qs;
qs.beginGroup(QString::fromStdString(g_settingsGroup));
qs.setValue("user-params-RBNumber", m_ui.lineEdit_RBNumber->text());
qs.setValue("user-params-current-vanadium-num",
m_uiTabCalib.lineEdit_current_vanadium_num->text());
qs.setValue("user-params-current-ceria-num",
m_uiTabCalib.lineEdit_current_ceria_num->text());
qs.setValue("current-calib-filename",
m_uiTabCalib.lineEdit_current_calib_filename->text());
qs.setValue("user-params-new-vanadium-num",
m_uiTabCalib.MWRunFiles_new_vanadium_num->getText());
qs.setValue("user-params-new-ceria-num",
m_uiTabCalib.MWRunFiles_new_ceria_num->getText());
qs.setValue("user-params-calib-cropped-group-checkbox",
m_uiTabCalib.groupBox_calib_cropped->isChecked());
qs.setValue("user-params-calib-cropped-spectrum-nos",
m_uiTabCalib.lineEdit_cropped_spec_nos->text());
qs.setValue("user-params-calib-cropped-customise-name",
m_uiTabCalib.lineEdit_cropped_customise_bank_name->text());
qs.setValue("user-param-calib-plot-data",
m_uiTabCalib.checkBox_PlotData_Calib->isChecked());
// user params - focusing
qs.setValue("user-params-focus-runno",
m_uiTabFocus.MWRunFiles_run_num->getText());
qs.beginWriteArray("user-params-focus-bank_i");
qs.setArrayIndex(0);
qs.setValue("value", m_uiTabFocus.checkBox_focus_bank1->isChecked());
qs.setArrayIndex(1);
qs.setValue("value", m_uiTabFocus.checkBox_focus_bank2->isChecked());
qs.endArray();
qs.setValue("user-params-focus-cropped-runno",
m_uiTabFocus.MWRunFiles_cropped_run_num->getText());
qs.setValue("user-params-focus-cropped-spectrum-nos",
m_uiTabFocus.lineEdit_cropped_spec_nos->text());
qs.setValue("user-params-focus-texture-runno",
m_uiTabFocus.MWRunFiles_texture_run_num->getText());
qs.setValue("user-params-focus-texture-detector-grouping-file",
m_uiTabFocus.lineEdit_texture_grouping_file->text());
qs.setValue("user-params-focus-cropped-group-checkbox",
m_uiTabFocus.groupBox_cropped->isChecked());
qs.setValue("user-params-focus-texture-group-checkbox",
m_uiTabFocus.groupBox_texture->isChecked());
qs.setValue("user-params-focus-plot-focused-ws",
m_uiTabFocus.checkBox_plot_focused_ws->isChecked());
qs.setValue("user-params-focus-save-output-files",
m_uiTabFocus.checkBox_plot_focused_ws->isChecked());
qs.setValue("user-params-focus-plot-type",
m_uiTabFocus.comboBox_PlotData->currentIndex());
qs.setValue("user-params-multiple-runs-focus-mode",
m_uiTabFocus.comboBox_Multi_Runs->currentIndex());
// pre-processing (re-binning)
qs.setValue("user-params-preproc-runno",
m_uiTabPreproc.MWRunFiles_preproc_run_num->getText());
qs.setValue("user-params-time-bin",
m_uiTabPreproc.doubleSpinBox_time_bin->value());
qs.setValue("user-params-nperiods", m_uiTabPreproc.spinBox_nperiods->value());
qs.value("user-params-step-time",
m_uiTabPreproc.doubleSpinBox_step_time->value());
// TODO: this should become << >> operators on EnggDiffCalibSettings
qs.setValue("input-dir-calib-files",
QString::fromStdString(m_calibSettings.m_inputDirCalib));
qs.setValue("input-dir-raw-files",
QString::fromStdString(m_calibSettings.m_inputDirRaw));
qs.setValue("pixel-calib-filename",
QString::fromStdString(m_calibSettings.m_pixelCalibFilename));
// 'advanced' block
qs.setValue("force-recalc-overwrite", m_calibSettings.m_forceRecalcOverwrite);
qs.setValue("template-gsas-prm",
QString::fromStdString(m_calibSettings.m_templateGSAS_PRM));
qs.setValue("rebin-calib", m_calibSettings.m_rebinCalibrate);
// 'focusing' block
qs.setValue("focus-dir", QString::fromStdString(m_focusDir));
qs.setValue("selected-tab-index", m_ui.tabMain->currentIndex());
qs.setValue("interface-win-geometry", saveGeometry());
qs.endGroup();
}
void EnggDiffractionViewQtGUI::readSettings() {
QSettings qs;
qs.beginGroup(QString::fromStdString(g_settingsGroup));
m_ui.lineEdit_RBNumber->setText(
qs.value("user-params-RBNumber", "").toString());
m_uiTabCalib.lineEdit_current_vanadium_num->setText(
qs.value("user-params-current-vanadium-num", "").toString());
m_uiTabCalib.lineEdit_current_ceria_num->setText(
qs.value("user-params-current-ceria-num", "").toString());
QString calibFname = qs.value("current-calib-filename", "").toString();
m_uiTabCalib.lineEdit_current_calib_filename->setText(calibFname);
m_uiTabCalib.MWRunFiles_new_vanadium_num->setUserInput(
qs.value("user-params-new-vanadium-num", "").toString());
m_uiTabCalib.MWRunFiles_new_ceria_num->setUserInput(
qs.value("user-params-new-ceria-num", "").toString());
m_uiTabCalib.groupBox_calib_cropped->setChecked(
qs.value("user-params-calib-cropped-group-checkbox", false).toBool());
m_uiTabCalib.comboBox_calib_cropped_bank_name->setCurrentIndex(0);
m_uiTabCalib.lineEdit_cropped_spec_nos->setText(
qs.value("user-params-calib-cropped-spectrum-nos", "").toString());
m_uiTabCalib.lineEdit_cropped_customise_bank_name->setText(
qs.value("user-params-calib-cropped-customise-name", "cropped")
.toString());
m_uiTabCalib.checkBox_PlotData_Calib->setChecked(
qs.value("user-param-calib-plot-data", true).toBool());
// user params - focusing
m_uiTabFocus.MWRunFiles_run_num->setUserInput(
qs.value("user-params-focus-runno", "").toString());
qs.beginReadArray("user-params-focus-bank_i");
qs.setArrayIndex(0);
m_uiTabFocus.checkBox_focus_bank1->setChecked(
qs.value("value", true).toBool());
qs.setArrayIndex(1);
m_uiTabFocus.checkBox_focus_bank2->setChecked(
qs.value("value", true).toBool());
qs.endArray();
m_uiTabFocus.MWRunFiles_cropped_run_num->setUserInput(
qs.value("user-params-focus-cropped-runno", "").toString());
m_uiTabFocus.lineEdit_cropped_spec_nos->setText(
qs.value("user-params-focus-cropped-spectrum-nos", "").toString());
m_uiTabFocus.MWRunFiles_texture_run_num->setUserInput(
qs.value("user-params-focus-texture-runno", "").toString());
m_uiTabFocus.lineEdit_texture_grouping_file->setText(
qs.value("user-params-focus-texture-detector-grouping-file", "")
.toString());
m_uiTabFocus.groupBox_cropped->setChecked(
qs.value("user-params-focus-cropped-group-checkbox", false).toBool());
m_uiTabFocus.groupBox_texture->setChecked(
qs.value("user-params-focus-texture-group-checkbox", false).toBool());
m_uiTabFocus.checkBox_plot_focused_ws->setChecked(
qs.value("user-params-focus-plot-focused-ws", true).toBool());
m_uiTabFocus.checkBox_save_output_files->setChecked(
qs.value("user-params-focus-save-output-files", true).toBool());
m_uiTabFocus.comboBox_PlotData->setCurrentIndex(
qs.value("user-params-focus-plot-type", 0).toInt());
m_uiTabFocus.comboBox_Multi_Runs->setCurrentIndex(
qs.value("user-params-multiple-runs-focus-mode", 0).toInt());
// pre-processing (re-binning)
m_uiTabPreproc.MWRunFiles_preproc_run_num->setUserInput(
qs.value("user-params-preproc-runno", "").toString());
m_uiTabPreproc.doubleSpinBox_time_bin->setValue(
qs.value("user-params-time-bin", 0.1).toDouble());
m_uiTabPreproc.spinBox_nperiods->setValue(
qs.value("user-params-nperiods", 2).toInt());
m_uiTabPreproc.doubleSpinBox_step_time->setValue(
qs.value("user-params-step-time", 1).toDouble());
// settings
QString lastPath =
MantidQt::API::AlgorithmInputHistory::Instance().getPreviousDirectory();
// TODO: as this is growing, it should become << >> operators on
// EnggDiffCalibSettings
m_calibSettings.m_inputDirCalib =
qs.value("input-dir-calib-files", lastPath).toString().toStdString();
m_calibSettings.m_inputDirRaw =
qs.value("input-dir-raw-files", lastPath).toString().toStdString();
const std::string fullCalib = guessDefaultFullCalibrationPath();
m_calibSettings.m_pixelCalibFilename =
qs.value("pixel-calib-filename", QString::fromStdString(fullCalib))
.toString()
.toStdString();
// 'advanced' block
m_calibSettings.m_forceRecalcOverwrite =
qs.value("force-recalc-overwrite", false).toBool();
const std::string templ = guessGSASTemplatePath();
m_calibSettings.m_templateGSAS_PRM =
qs.value("template-gsas-prm", QString::fromStdString(templ))
.toString()
.toStdString();
m_calibSettings.m_rebinCalibrate =
qs.value("rebin-calib", g_defaultRebinWidth).toFloat();
// 'focusing' block
m_focusDir = qs.value("focus-dir").toString().toStdString();
m_ui.tabMain->setCurrentIndex(qs.value("selected-tab-index").toInt());
restoreGeometry(qs.value("interface-win-geometry").toByteArray());
qs.endGroup();
}
