mirror of
https://github.com/OpenFOAM/ThirdParty-6.git
synced 2025-12-08 06:57:43 +00:00
1208 lines
36 KiB
C++
1208 lines
36 KiB
C++
// -*- c++ -*-
|
||
/*=========================================================================
|
||
|
||
Program: Visualization Toolkit
|
||
Module: pqPlotVariablesDialog.cxx
|
||
|
||
Copyright (c) Ken Martin, Will Schroeder, Bill Lorensen
|
||
All rights reserved.
|
||
See Copyright.txt or http://www.kitware.com/Copyright.htm for details.
|
||
|
||
This software is distributed WITHOUT ANY WARRANTY; without even
|
||
the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
|
||
PURPOSE. See the above copyright notice for more information.
|
||
|
||
=========================================================================*/
|
||
/*-------------------------------------------------------------------------
|
||
Copyright 2009 Sandia Corporation.
|
||
Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
|
||
the U.S. Government retains certain rights in this software.
|
||
-------------------------------------------------------------------------*/
|
||
|
||
#include "warningState.h"
|
||
|
||
#include "pqHoverLabel.h"
|
||
#include "pqPlotVariablesDialog.h"
|
||
#include "pqPlotter.h"
|
||
#include "pqSierraPlotToolsManager.h"
|
||
|
||
#include "vtkSMProxy.h"
|
||
#include "vtkSMStringVectorProperty.h"
|
||
|
||
#include "pqApplicationCore.h"
|
||
#include "pqDataRepresentation.h"
|
||
#include "pqDisplayPolicy.h"
|
||
#include "pqObjectBuilder.h"
|
||
#include "pqPipelineSource.h"
|
||
#include "pqSierraPlotToolsUtils.h"
|
||
#include "pqSMAdaptor.h"
|
||
#include "pqUndoStack.h"
|
||
|
||
#include <QApplication>
|
||
#include <QDesktopWidget>
|
||
#include <QGridLayout>
|
||
#include <QLabel>
|
||
#include <QList>
|
||
#include <QListWidget>
|
||
#include <QListWidgetItem>
|
||
#include <QMouseEvent>
|
||
#include <QPushButton>
|
||
#include <QtDebug>
|
||
#include <QToolTip>
|
||
|
||
#include "ui_pqVariablePlot.h"
|
||
|
||
// used to show line number in #pragma message
|
||
#define STRING2(x) #x
|
||
#define STRING(x) STRING2(x)
|
||
|
||
///////////////////////////////////////////////////////////////////////////////
|
||
class pqPlotVariablesDialog::pqUI : public Ui::pqVariablePlot {};
|
||
|
||
//
|
||
// This class stores the range values for a variable and its
|
||
// components.
|
||
//
|
||
class VarRange
|
||
{
|
||
public:
|
||
|
||
static const int MIN_ELEMENT_INDEX = 0;
|
||
static const int MAX_ELEMENT_INDEX = 1;
|
||
|
||
VarRange(QString name) :
|
||
varName(name),
|
||
numComponents(0),
|
||
numElements(0),
|
||
ranges(NULL)
|
||
{
|
||
}
|
||
|
||
virtual ~VarRange()
|
||
{
|
||
if (ranges)
|
||
{
|
||
for (int i=0; i < numComponents; i++)
|
||
{
|
||
delete [] ranges[i];
|
||
}
|
||
delete [] ranges;
|
||
|
||
ranges = 0;
|
||
}
|
||
|
||
if (magnitudes)
|
||
{
|
||
delete [] magnitudes;
|
||
}
|
||
}
|
||
|
||
QString varName;
|
||
int numComponents;
|
||
int numElements;
|
||
double **ranges;
|
||
double *magnitudes;
|
||
};
|
||
|
||
//
|
||
// This class encapsulates the concept/implementation of the GUI elements
|
||
// that make up a "range".
|
||
// The "range" consists of labels for the min & max, line edit boxes for the
|
||
// min and max values
|
||
//
|
||
//
|
||
class pqRangeWidget
|
||
{
|
||
public:
|
||
|
||
struct RangeWidgetGroup
|
||
{
|
||
RangeWidgetGroup(QLabel * minLabel, QLabel * maxLabel,
|
||
QLineEdit * minLineEdit, QLineEdit * maxLineEdit,
|
||
QFrame * minLabelEditFrame, QFrame * maxLabelEditFrame,
|
||
QHBoxLayout * minLayout, QHBoxLayout * maxLayout)
|
||
{
|
||
this->minRangeLabel = minLabel;
|
||
this->maxRangeLabel = maxLabel;
|
||
this->minLineEditRange = minLineEdit;
|
||
this->maxLineEditRange = maxLineEdit;
|
||
this->minFrame = minLabelEditFrame;
|
||
this->maxFrame = maxLabelEditFrame;
|
||
this->minHorizontalLayout = minLayout;
|
||
this->maxHorizontalLayout = maxLayout;
|
||
}
|
||
|
||
virtual ~RangeWidgetGroup()
|
||
{
|
||
delete this->minFrame;
|
||
delete this->maxFrame;
|
||
}
|
||
|
||
QLabel * minRangeLabel;
|
||
QLabel * maxRangeLabel;
|
||
QLineEdit * minLineEditRange;
|
||
QLineEdit * maxLineEditRange;
|
||
QFrame * minFrame;
|
||
QFrame * maxFrame;
|
||
QHBoxLayout * minHorizontalLayout;
|
||
QHBoxLayout * maxHorizontalLayout;
|
||
};
|
||
|
||
pqRangeWidget(QString variableAsString) :
|
||
varName(variableAsString)
|
||
{
|
||
}
|
||
|
||
virtual ~pqRangeWidget()
|
||
{
|
||
for (int i = 0; i < int(rangeWidgetGroups.size()); i++)
|
||
{
|
||
delete rangeWidgetGroups[i];
|
||
}
|
||
if (this->horizLine)
|
||
{
|
||
delete this->horizLine;
|
||
this->horizLine = NULL;
|
||
}
|
||
}
|
||
|
||
std::vector<RangeWidgetGroup *> rangeWidgetGroups;
|
||
QFrame * horizLine;
|
||
QString varName;
|
||
|
||
static int precision;
|
||
|
||
RangeWidgetGroup * allocAndMakeMinMax(VarRange * varRange, const QString & varToDisplay, int componentIndex,
|
||
QVBoxLayout * theVarRangeLayout, QWidget * parentWidget)
|
||
{
|
||
QLabel *minRangeLabel;
|
||
QLabel *maxRangeLabel;
|
||
QLineEdit *maxLineEditRange;
|
||
QLineEdit *minLineEditRange;
|
||
|
||
QString minStr = varToDisplay + QString(" min");
|
||
QString maxStr = varToDisplay + QString(" max");
|
||
|
||
// Annotate variable min/max
|
||
// varToDisplay Min, varToDisplay Max
|
||
//
|
||
|
||
QFrame * minFrame = new QFrame(parentWidget);
|
||
minFrame->setMaximumSize(QSize(16777215,40));
|
||
QHBoxLayout * minHorizontalLayout = new QHBoxLayout(minFrame);
|
||
minRangeLabel = new QLabel(minFrame);
|
||
minRangeLabel->setObjectName(varRange->varName + QString("_") + QString("minRangeLabel"));
|
||
minRangeLabel->setText(minStr);
|
||
minHorizontalLayout->addWidget(minRangeLabel);
|
||
minLineEditRange = new QLineEdit(minFrame);
|
||
minLineEditRange->setObjectName(varRange->varName + QString("_") + QString("minLineEditRange"));
|
||
|
||
double rangeVal=0.0;
|
||
if (componentIndex == -1)
|
||
{
|
||
// get the magnitude of the range
|
||
rangeVal = varRange->magnitudes[VarRange::MIN_ELEMENT_INDEX];
|
||
}
|
||
else
|
||
{
|
||
// get range itself
|
||
rangeVal = varRange->ranges[componentIndex][VarRange::MIN_ELEMENT_INDEX];
|
||
}
|
||
minLineEditRange->setText(QString("").setNum(rangeVal, 'e', pqRangeWidget::precision));
|
||
minHorizontalLayout->addWidget(minLineEditRange);
|
||
|
||
QFrame * maxFrame = new QFrame(parentWidget);
|
||
maxFrame->setMaximumSize(QSize(16777215,40));
|
||
QHBoxLayout * maxHorizontalLayout = new QHBoxLayout(maxFrame);
|
||
maxRangeLabel = new QLabel(maxFrame);
|
||
maxRangeLabel->setObjectName(varRange->varName + QString("_") + QString("maxRangeLabel"));
|
||
maxRangeLabel->setText(maxStr);
|
||
maxHorizontalLayout->addWidget(maxRangeLabel);
|
||
maxLineEditRange = new QLineEdit(maxFrame);
|
||
maxLineEditRange->setObjectName(varRange->varName + QString("_") + QString("maxLineEditRange"));
|
||
if (componentIndex == -1)
|
||
{
|
||
// get the magnitude of the range
|
||
rangeVal = varRange->magnitudes[VarRange::MAX_ELEMENT_INDEX];
|
||
}
|
||
else
|
||
{
|
||
// get range itself
|
||
rangeVal = varRange->ranges[componentIndex][VarRange::MAX_ELEMENT_INDEX];
|
||
}
|
||
maxLineEditRange->setText(QString("").setNum(rangeVal, 'e', pqRangeWidget::precision));
|
||
maxHorizontalLayout->addWidget(maxLineEditRange);
|
||
|
||
theVarRangeLayout->addWidget(minFrame);
|
||
theVarRangeLayout->addWidget(maxFrame);
|
||
|
||
RangeWidgetGroup * rangeWidgetGroup = new RangeWidgetGroup(minRangeLabel,
|
||
maxRangeLabel, minLineEditRange, maxLineEditRange,
|
||
minFrame, maxFrame, minHorizontalLayout, maxHorizontalLayout);
|
||
|
||
return rangeWidgetGroup;
|
||
}
|
||
|
||
void build(pqPlotVariablesDialog::pqUI *ui, VarRange * varRange,
|
||
int componentIndex)
|
||
{
|
||
rangeWidgetGroups.push_back(this->allocAndMakeMinMax(varRange, this->varName, componentIndex, ui->scrollWidgetLayout, ui->rangeScrollArea));
|
||
|
||
// Add a (QFrame) horizontal line for visual separation
|
||
horizLine = new QFrame(ui->rangeScrollArea);
|
||
horizLine->setFrameShape(QFrame::HLine);
|
||
ui->scrollWidgetLayout->addWidget(horizLine);
|
||
}
|
||
};
|
||
|
||
//
|
||
// Storage for pqRangeWidget
|
||
//
|
||
int pqRangeWidget::precision = 0;
|
||
|
||
//
|
||
// Internal implementation for pqPlotVariablesDialog
|
||
//
|
||
class pqPlotVariablesDialog::pqInternal
|
||
{
|
||
public:
|
||
|
||
static const int DEFAULT_FLOATING_POINT_PRECISION = 7;
|
||
|
||
enum separators_enum
|
||
{
|
||
e_unknownSep = -1,
|
||
e_commaSep = 0,
|
||
e_dashSep,
|
||
};
|
||
|
||
pqInternal() :
|
||
listWidget(NULL),
|
||
verticalSpacer(NULL),
|
||
plotType(-1)
|
||
{
|
||
varRanges.clear();
|
||
rangeWidgets.clear();
|
||
pqPlotVariablesDialog::pqInternal::precision = pqPlotVariablesDialog::pqInternal::DEFAULT_FLOATING_POINT_PRECISION;
|
||
|
||
// we set the pqRangeWidget::precision class variable here, because we want the DEFAULT_FLOATING_POINT_PRECISION
|
||
// to be associated with the pqPlotVariablesDialog::pqInternal, and not have to propagate it down
|
||
// to a "lower level" class
|
||
pqRangeWidget::precision = pqPlotVariablesDialog::pqInternal::precision;
|
||
|
||
validComponentSuffixes.append("_x");
|
||
validComponentSuffixes.append("_y");
|
||
validComponentSuffixes.append("_z");
|
||
validComponentSuffixes.append("_xx");
|
||
validComponentSuffixes.append("_xy");
|
||
|
||
// symetric -- could be xz, or zx, but Exodus reader stores as 'zx'
|
||
validComponentSuffixes.append("_zx");
|
||
|
||
validComponentSuffixes.append("_yy");
|
||
validComponentSuffixes.append("_yz");
|
||
validComponentSuffixes.append("_zz");
|
||
validComponentSuffixes.append("_magnitude");
|
||
|
||
componentArrayIndicesMap["_magnitude"] = -1; // treat magnitude special!
|
||
|
||
componentArrayIndicesMap["_x"] = 0;
|
||
componentArrayIndicesMap["_y"] = 1;
|
||
componentArrayIndicesMap["_z"] = 2;
|
||
|
||
// The Symmetric Tensor <20> six components index order is defined
|
||
// by the VTK Exodus reader
|
||
// see vtkExodusIIReaderPrivate.h
|
||
// and vtkExodusIIReader.cxx in VTK library
|
||
componentArrayIndicesMap["_xx"] = 0;
|
||
componentArrayIndicesMap["_yy"] = 1;
|
||
componentArrayIndicesMap["_zz"] = 2;
|
||
componentArrayIndicesMap["_xy"] = 3;
|
||
componentArrayIndicesMap["_yz"] = 4;
|
||
componentArrayIndicesMap["_zx"] = 5;
|
||
}
|
||
|
||
virtual ~pqInternal()
|
||
{
|
||
QMap<QString, VarRange *>::iterator mapI = varRanges.begin();
|
||
while (mapI != varRanges.end())
|
||
{
|
||
VarRange * vr = mapI.value();
|
||
delete vr;
|
||
mapI++;
|
||
}
|
||
}
|
||
|
||
virtual void addVariable(QString varName);
|
||
virtual double computeMagnitude(VarRange * vr, int k);
|
||
virtual bool addRangeToUI(pqPlotVariablesDialog::pqUI *ui, QString variableAsString);
|
||
virtual bool removeRangeFromUI(pqPlotVariablesDialog::pqUI *ui, QString variableAsString);
|
||
virtual bool inSelection(const QString & itemStr, QList<QListWidgetItem *> & selectedItems);
|
||
|
||
virtual int getPlotType() { return plotType; }
|
||
|
||
virtual void setPlotType(int type)
|
||
{
|
||
plotType = type;
|
||
}
|
||
|
||
virtual void setPlotter(pqPlotter * thePlotter)
|
||
{
|
||
plotter = thePlotter;
|
||
}
|
||
|
||
virtual pqPlotter * getPlotter()
|
||
{
|
||
return plotter;
|
||
}
|
||
|
||
//-----------------------------------------------------------------------------
|
||
void updateHoverWithPlotter(pqPlotVariablesDialog::pqUI * _ui)
|
||
{
|
||
_ui->variableVsWhatever->setPlotter(this->getPlotter());
|
||
}
|
||
|
||
//-----------------------------------------------------------------------------
|
||
int getNumberPostSeparator(int begIndex, QString lineEditText)
|
||
{
|
||
if (begIndex >= lineEditText.size())
|
||
{
|
||
return -1;
|
||
}
|
||
|
||
int index = begIndex;
|
||
while (! isSeparator(lineEditText[index]) && (index < lineEditText.size()) )
|
||
{
|
||
index++;
|
||
}
|
||
|
||
if (index >= lineEditText.size())
|
||
{
|
||
return lineEditText.size() - 1;
|
||
}
|
||
|
||
return index - 1;
|
||
}
|
||
|
||
//-----------------------------------------------------------------------------
|
||
bool isSeparator(QChar ch)
|
||
{
|
||
if (ch.toLatin1() == ',')
|
||
{
|
||
return true;
|
||
}
|
||
if (ch.toLatin1() == '-')
|
||
{
|
||
return true;
|
||
}
|
||
|
||
return false;
|
||
}
|
||
|
||
//-----------------------------------------------------------------------------
|
||
bool separator(QChar ch, separators_enum & sepType)
|
||
{
|
||
sepType = e_unknownSep;
|
||
if (ch.toLatin1() == ',')
|
||
{
|
||
sepType = e_commaSep;
|
||
return true;
|
||
}
|
||
if (ch.toLatin1() == '-')
|
||
{
|
||
sepType = e_dashSep;
|
||
return true;
|
||
}
|
||
|
||
//qWarning() << "pqPlotVariablesDialog::pqInternal: * Error * Invalide range separator " << ;
|
||
|
||
return false;
|
||
}
|
||
|
||
//-----------------------------------------------------------------------------
|
||
int findSeparator(int parseIndex, separators_enum & sepType, QString lineEditText)
|
||
{
|
||
int i=parseIndex;
|
||
sepType = e_unknownSep;
|
||
while (! this->separator(lineEditText[i], sepType) && i < lineEditText.length())
|
||
{
|
||
i++;
|
||
}
|
||
|
||
if (i >= lineEditText.length())
|
||
{
|
||
return -1;
|
||
}
|
||
|
||
return i;
|
||
}
|
||
|
||
//-----------------------------------------------------------------------------
|
||
// This method parses a string for a number.
|
||
// if the starting parseIndex is a separator, this is an error
|
||
//
|
||
QPair<int,int> parseNumberRange(int & parseIndex, separators_enum & sepType, QString lineEditText)
|
||
{
|
||
sepType = e_unknownSep;
|
||
|
||
QPair<int,int> retRange(-1,-1);
|
||
int rangeBeg = -1;
|
||
int rangeEnd = -1;
|
||
|
||
if (lineEditText.length() <= 0)
|
||
{
|
||
return retRange;
|
||
}
|
||
|
||
if (isSeparator(lineEditText[parseIndex]))
|
||
{
|
||
return retRange;
|
||
}
|
||
|
||
if (parseIndex >= lineEditText.length())
|
||
{
|
||
return retRange;
|
||
}
|
||
|
||
// look for separator, starting at parseIndex
|
||
int separatorIndex = this->findSeparator(parseIndex, sepType, lineEditText);
|
||
|
||
if (separatorIndex == -1)
|
||
{
|
||
rangeBeg = this->util.getNumber(parseIndex, lineEditText.length()-1, lineEditText);
|
||
parseIndex = -1; // end of line or something
|
||
}
|
||
else
|
||
{
|
||
switch(sepType)
|
||
{
|
||
case e_commaSep:
|
||
rangeBeg = this->util.getNumber(parseIndex, separatorIndex-1, lineEditText);
|
||
parseIndex = separatorIndex + 1;
|
||
break;
|
||
|
||
case e_dashSep:
|
||
{
|
||
rangeBeg = this->util.getNumber(parseIndex, separatorIndex-1, lineEditText);
|
||
int rangeEndIndex = this->getNumberPostSeparator(separatorIndex+1, lineEditText);
|
||
if (rangeEndIndex != -1)
|
||
{
|
||
rangeEnd = this->util.getNumber(separatorIndex+1, rangeEndIndex, lineEditText);
|
||
parseIndex = rangeEndIndex + 1;
|
||
|
||
// if the next char is a separator, then advance the index to parse at
|
||
if (isSeparator(lineEditText[parseIndex]))
|
||
{
|
||
parseIndex++;
|
||
}
|
||
}
|
||
else
|
||
{
|
||
// error with range specification
|
||
rangeBeg = -1;
|
||
rangeEnd = -1;
|
||
}
|
||
break;
|
||
}
|
||
|
||
case e_unknownSep:
|
||
//Do something here?
|
||
break;
|
||
}
|
||
}
|
||
|
||
retRange.first = rangeBeg;
|
||
retRange.second = rangeEnd;
|
||
|
||
return retRange;
|
||
}
|
||
|
||
//-----------------------------------------------------------------------------
|
||
QString removeAllWhiteSpace_andValidate(QString inString, bool & errFlag)
|
||
{
|
||
errFlag = false;
|
||
QString retString("");
|
||
|
||
// pass 1 - remove all whitespace
|
||
retString = this->util.removeAllWhiteSpace(inString);
|
||
|
||
// pass 2 - look for invalid characters
|
||
for (int i = 0; i < retString.length(); i++)
|
||
{
|
||
if ( ! this->util.validChar(retString[i].toLatin1()))
|
||
{
|
||
errFlag = true;
|
||
break;
|
||
}
|
||
}
|
||
|
||
// pass 3 -- set an error flag if the stripped string is empty
|
||
if (retString.length() <= 0)
|
||
{
|
||
qWarning() << "removeAllWhiteSpace_andValidate: ERROR - selection string: " << inString << ", is empty";
|
||
errFlag = true;
|
||
}
|
||
|
||
return retString;
|
||
}
|
||
|
||
//-----------------------------------------------------------------------------
|
||
QString componentSuffixString(QString variableAsString)
|
||
{
|
||
for (int i = 0; i < this->validComponentSuffixes.size(); i++)
|
||
{
|
||
if (variableAsString.endsWith(this->validComponentSuffixes[i]))
|
||
{
|
||
return this->validComponentSuffixes[i];
|
||
}
|
||
}
|
||
|
||
return QString("");
|
||
}
|
||
|
||
//-----------------------------------------------------------------------------
|
||
int componentArrayIndexFromSuffix(QString variableAsString)
|
||
{
|
||
int index = 0;
|
||
|
||
QString suffixString = this->componentSuffixString(variableAsString);
|
||
|
||
if (suffixString != QString(""))
|
||
{
|
||
index = this->componentArrayIndicesMap[suffixString];
|
||
}
|
||
|
||
return index;
|
||
}
|
||
|
||
//-----------------------------------------------------------------------------
|
||
QString stripComponentSuffix(QString variableAsString)
|
||
{
|
||
QString retString = this->util.removeAllWhiteSpace(variableAsString);
|
||
|
||
QString suffixString = componentSuffixString(retString);
|
||
|
||
if (suffixString.size() > 0)
|
||
{
|
||
int positionToTruncate = retString.size() - suffixString.size();
|
||
if (positionToTruncate > 0)
|
||
{
|
||
retString.truncate(positionToTruncate);
|
||
}
|
||
}
|
||
|
||
return retString;
|
||
}
|
||
|
||
//=============================================================================
|
||
|
||
QStringList validComponentSuffixes;
|
||
QMap<QString,int> componentArrayIndicesMap;
|
||
QMap<QString, VarRange *> varRanges;
|
||
QMap<QString, bool> variableSelectionStates; // to keep track of selection state
|
||
QVector<pqRangeWidget *> rangeWidgets;
|
||
QListWidget * listWidget;
|
||
QSpacerItem * verticalSpacer;
|
||
pqSierraPlotToolsUtils util;
|
||
|
||
static int precision;
|
||
|
||
int plotType;
|
||
pqPlotter * plotter;
|
||
};
|
||
|
||
int pqPlotVariablesDialog::pqInternal::precision = pqPlotVariablesDialog::pqInternal::DEFAULT_FLOATING_POINT_PRECISION;
|
||
|
||
//-----------------------------------------------------------------------------
|
||
void pqPlotVariablesDialog::pqInternal::addVariable(QString varName)
|
||
{
|
||
VarRange * vr = this->varRanges[varName];
|
||
if (vr == NULL)
|
||
{
|
||
vr = new VarRange(varName);
|
||
this->varRanges[varName] = vr;
|
||
}
|
||
}
|
||
|
||
//-----------------------------------------------------------------------------
|
||
bool pqPlotVariablesDialog::pqInternal::removeRangeFromUI(pqPlotVariablesDialog::pqUI *_ui, QString variableAsString)
|
||
{
|
||
pqRangeWidget * rangeWidget;
|
||
|
||
int i;
|
||
for (i = 0; i < this->rangeWidgets.size(); i++)
|
||
{
|
||
rangeWidget = this->rangeWidgets[i];
|
||
if (rangeWidget->varName == variableAsString)
|
||
{
|
||
delete rangeWidget;
|
||
this->rangeWidgets.remove(i);
|
||
|
||
// if no more range widgets left, remove the vertical spacer
|
||
if (this->rangeWidgets.size() == 0)
|
||
{
|
||
if (this->verticalSpacer)
|
||
{
|
||
_ui->scrollWidgetLayout->removeItem(this->verticalSpacer);
|
||
this->verticalSpacer = NULL;
|
||
}
|
||
}
|
||
|
||
// update the scroll area geometry
|
||
// so that it resizes if need be
|
||
_ui->rangeScrollArea->updateGeometry();
|
||
|
||
return true;
|
||
}
|
||
}
|
||
|
||
return false;
|
||
}
|
||
|
||
//-----------------------------------------------------------------------------
|
||
bool pqPlotVariablesDialog::pqInternal::addRangeToUI(pqPlotVariablesDialog::pqUI *_ui, QString variableAsString)
|
||
{
|
||
QString strippedVariableName = this->stripComponentSuffix(variableAsString);
|
||
int arrayIndex = this->componentArrayIndexFromSuffix(variableAsString);
|
||
VarRange * varRange = this->varRanges[strippedVariableName];
|
||
|
||
if (varRange != NULL)
|
||
{
|
||
pqRangeWidget * rangeWidget = new pqRangeWidget(variableAsString);
|
||
rangeWidget->build(_ui, varRange, arrayIndex);
|
||
|
||
this->rangeWidgets.append(rangeWidget);
|
||
}
|
||
else
|
||
{
|
||
qCritical() << "* ERROR * variable " << variableAsString << " has no valid range";
|
||
return false;
|
||
}
|
||
|
||
return true;
|
||
}
|
||
|
||
//-----------------------------------------------------------------------------
|
||
double pqPlotVariablesDialog::pqInternal::computeMagnitude(VarRange * vr, int k)
|
||
{
|
||
double magnitude = 0.0;
|
||
for (int i = 0; i < vr->numComponents; i++)
|
||
{
|
||
magnitude = magnitude + vr->ranges[i][k] * vr->ranges[i][k];
|
||
}
|
||
|
||
magnitude = sqrt(magnitude);
|
||
|
||
return magnitude;
|
||
}
|
||
//=============================================================================
|
||
pqPlotVariablesDialog::pqPlotVariablesDialog(QWidget *p,
|
||
Qt::WindowFlags f/*=0*/)
|
||
: QDialog(p, f)
|
||
{
|
||
pqSierraPlotToolsManager *manager = pqSierraPlotToolsManager::instance();
|
||
this->Server = manager->getActiveServer();
|
||
|
||
this->Internal = new pqPlotVariablesDialog::pqInternal();
|
||
|
||
this->ui = new pqPlotVariablesDialog::pqUI;
|
||
this->ui->setupUi(this);
|
||
|
||
// connect signals and slots to the list widget
|
||
QObject::connect(this->ui->okCancelButtonBox, SIGNAL(accepted(void)), this, SLOT(slotOk(void)));
|
||
QObject::connect(this->ui->okCancelButtonBox, SIGNAL(rejected(void)), this, SLOT(slotCancel(void)));
|
||
|
||
QObject::connect(this->ui->useParaViewGUIToSelectNodesCheckBox, SIGNAL(toggled(bool)), this,
|
||
SLOT(slotUseParaViewGUIToSelectNodesCheckBox(bool)));
|
||
|
||
// set up some parameters for the scroll area
|
||
// scroll area height should not be more than 60% of desktop main screen
|
||
this->ui->rangeScrollArea->setMaximumHeight(int(0.5 * QApplication::desktop()->availableGeometry().height()));
|
||
|
||
// main dialog height should not be more than a certain percentage of desktop main screen
|
||
|
||
//float deskTopHeight = QApplication::desktop()->availableGeometry().height();
|
||
|
||
pqPlotVariablesDialog * myDialog = this;
|
||
// myDialog->setMaximumHeight(0.1 * deskTopHeight);
|
||
|
||
myDialog->setMaximumHeight(555);
|
||
|
||
//QSizePolicy tmpSizePolicy = this->sizePolicy(); //If this doesn't do anything, why is it here?
|
||
}
|
||
|
||
//-----------------------------------------------------------------------------
|
||
pqPlotVariablesDialog::~pqPlotVariablesDialog()
|
||
{
|
||
delete this->ui;
|
||
delete this->Internal;
|
||
}
|
||
|
||
//-----------------------------------------------------------------------------
|
||
QSize pqPlotVariablesDialog::sizeHint() const
|
||
{
|
||
QSize dialogSizeHint = this->QDialog::sizeHint();
|
||
|
||
float deskTopHeight = QApplication::desktop()->availableGeometry().height();
|
||
|
||
dialogSizeHint.setHeight(int(0.1 * deskTopHeight));
|
||
|
||
return dialogSizeHint;
|
||
}
|
||
|
||
//-----------------------------------------------------------------------------
|
||
QString pqPlotVariablesDialog::stripComponentSuffix(QString variableAsString)
|
||
{
|
||
return this->Internal->stripComponentSuffix(variableAsString);
|
||
}
|
||
|
||
//-----------------------------------------------------------------------------
|
||
void pqPlotVariablesDialog::activateSelectionByNumberFrame()
|
||
{
|
||
if (this->Internal->getPlotter()->amIAbleToSelectByNumber())
|
||
{
|
||
this->ui->selectionByNumberFrame->show();
|
||
this->setupActivationForOKButton(true);
|
||
}
|
||
else
|
||
{
|
||
this->ui->selectionByNumberFrame->hide();
|
||
this->setupActivationForOKButton(false);
|
||
}
|
||
}
|
||
|
||
//-----------------------------------------------------------------------------
|
||
void pqPlotVariablesDialog::setNumberItemsLabel(QString value)
|
||
{
|
||
this->ui->numberItemsLabel->setText(value);
|
||
}
|
||
|
||
//-----------------------------------------------------------------------------
|
||
int pqPlotVariablesDialog::getPlotType()
|
||
{
|
||
return this->Internal->getPlotType();
|
||
}
|
||
|
||
//-----------------------------------------------------------------------------
|
||
void pqPlotVariablesDialog::setPlotType(int type)
|
||
{
|
||
this->Internal->setPlotType(type);
|
||
}
|
||
|
||
//-----------------------------------------------------------------------------
|
||
void pqPlotVariablesDialog::setPlotter(pqPlotter * thePlotter)
|
||
{
|
||
this->Internal->setPlotter(thePlotter);
|
||
|
||
this->Internal->updateHoverWithPlotter(this->ui);
|
||
}
|
||
|
||
//-----------------------------------------------------------------------------
|
||
pqPlotter * pqPlotVariablesDialog::getPlotter()
|
||
{
|
||
return this->Internal->getPlotter();
|
||
}
|
||
|
||
//-----------------------------------------------------------------------------
|
||
void pqPlotVariablesDialog::addVariable(QString varName)
|
||
{
|
||
this->Internal->addVariable(varName);
|
||
}
|
||
|
||
//-----------------------------------------------------------------------------
|
||
void pqPlotVariablesDialog::setFloatingPointPrecision(int precis)
|
||
{
|
||
pqPlotVariablesDialog::pqInternal::precision = precis;
|
||
|
||
// we set the pqRangeWidget::precision class variable here, because we want the concept of "precision"
|
||
// to be associated with the pqPlotVariablesDialog::pqInternal, and not have to propagate it down
|
||
// to a "lower level" class
|
||
pqRangeWidget::precision = pqPlotVariablesDialog::pqInternal::precision;
|
||
}
|
||
|
||
//-----------------------------------------------------------------------------
|
||
int pqPlotVariablesDialog::getFloatingPointPrecision()
|
||
{
|
||
return pqRangeWidget::precision;
|
||
}
|
||
|
||
//-----------------------------------------------------------------------------
|
||
void pqPlotVariablesDialog::allocSetRange(QString varName, int numComp, int numElems, double ** ranges)
|
||
{
|
||
VarRange * vr = this->Internal->varRanges[varName];
|
||
if (vr != NULL)
|
||
{
|
||
vr->numComponents = numComp;
|
||
vr->numElements = numElems;
|
||
|
||
vr->ranges = new double * [numComp];
|
||
for (int j = 0; j < numComp; j++)
|
||
{
|
||
vr->ranges[j] = new double[numElems];
|
||
for (int k = 0; k < numElems; k++)
|
||
{
|
||
vr->ranges[j][k] = ranges[j][k];
|
||
}
|
||
}
|
||
|
||
// compute the magnitude
|
||
vr->magnitudes = new double [numElems];
|
||
for (int k = 0; k < numElems; k++)
|
||
{
|
||
vr->magnitudes[k] = this->Internal->computeMagnitude(vr,k);
|
||
}
|
||
}
|
||
}
|
||
|
||
//-----------------------------------------------------------------------------
|
||
bool pqPlotVariablesDialog::getUseParaViewGUIToSelectNodesCheckBoxState()
|
||
{
|
||
return this->ui->useParaViewGUIToSelectNodesCheckBox->isChecked();
|
||
}
|
||
|
||
//-----------------------------------------------------------------------------
|
||
void pqPlotVariablesDialog::setEnableNumberItems(bool flag)
|
||
{
|
||
this->ui->numberItemsLabel->setEnabled(flag);
|
||
this->ui->numberItemsLineEdit->setEnabled(flag);
|
||
this->setupActivationForOKButton(flag);
|
||
}
|
||
|
||
//-----------------------------------------------------------------------------
|
||
void pqPlotVariablesDialog::setupActivationForOKButton(bool flag)
|
||
{
|
||
if (flag)
|
||
{
|
||
// Disable the OK button, until some range is entered in the numberItemsLineEdit box
|
||
QPushButton * okButton = this->ui->okCancelButtonBox->button(QDialogButtonBox::Ok);
|
||
okButton->setEnabled(false);
|
||
|
||
// connect a signal for when the user enters some data in numberItemsLineEdit box
|
||
connect(this->ui->numberItemsLineEdit, SIGNAL(textChanged(const QString & )), this, SLOT(slotTextChanged(const QString &)));
|
||
}
|
||
else
|
||
{
|
||
// Enable the OK button
|
||
QPushButton * okButton = this->ui->okCancelButtonBox->button(QDialogButtonBox::Ok);
|
||
okButton->setEnabled(true);
|
||
}
|
||
}
|
||
|
||
//-----------------------------------------------------------------------------
|
||
void pqPlotVariablesDialog::slotTextChanged(const QString & text)
|
||
{
|
||
QString nonWhite = this->Internal->util.removeAllWhiteSpace(text);
|
||
QPushButton * okButton = this->ui->okCancelButtonBox->button(QDialogButtonBox::Ok);
|
||
if (nonWhite.size() > 0)
|
||
{
|
||
okButton->setEnabled(true);
|
||
}
|
||
else
|
||
{
|
||
okButton->setEnabled(false);
|
||
}
|
||
}
|
||
|
||
//-----------------------------------------------------------------------------
|
||
QString pqPlotVariablesDialog::getNumberItemsLineEdit()
|
||
{
|
||
return this->ui->numberItemsLineEdit->text();
|
||
}
|
||
|
||
//-----------------------------------------------------------------------------
|
||
QList<int> pqPlotVariablesDialog::determineSelectedItemsList(bool & errFlag)
|
||
{
|
||
QList<int> retList;
|
||
|
||
QString lineEditText = this->Internal->removeAllWhiteSpace_andValidate(this->ui->numberItemsLineEdit->text(), errFlag);
|
||
|
||
if (errFlag)
|
||
{
|
||
return retList;
|
||
}
|
||
|
||
int parseIndex=0;
|
||
while (parseIndex != -1 && parseIndex < lineEditText.length())
|
||
{
|
||
QPair<int,int> range;
|
||
|
||
pqInternal::separators_enum sepType;
|
||
range = this->Internal->parseNumberRange(parseIndex, sepType, lineEditText);
|
||
|
||
if (range.first >= 0)
|
||
{
|
||
if (sepType == pqInternal::e_dashSep)
|
||
{
|
||
// if dash, find the range, if comma (or something else god forbid!) then don't do the range
|
||
int i;
|
||
for (i = range.first; i <= range.second; i++)
|
||
{
|
||
// only append unique values
|
||
if (! retList.contains(i))
|
||
{
|
||
retList.append(i);
|
||
}
|
||
}
|
||
}
|
||
else
|
||
{
|
||
// comma, so just put in the first value
|
||
retList.append(range.first);
|
||
}
|
||
}
|
||
else
|
||
{
|
||
// some sort of error, deal with it
|
||
qWarning() << "pqPlotVariablesDialog::determineSelectedItemsList: ERROR - range specification error";
|
||
errFlag = true;
|
||
return retList;
|
||
}
|
||
}
|
||
|
||
return retList;
|
||
}
|
||
|
||
//-----------------------------------------------------------------------------
|
||
void pqPlotVariablesDialog::slotUseParaViewGUIToSelectNodesCheckBox(bool /*checked*/)
|
||
{
|
||
emit this->useParaViewGUIToSelectNodesCheck();
|
||
}
|
||
|
||
//-----------------------------------------------------------------------------
|
||
void pqPlotVariablesDialog::slotOk(void)
|
||
{
|
||
// user clicked on OK button
|
||
emit this->okDismissed();
|
||
}
|
||
|
||
//-----------------------------------------------------------------------------
|
||
void pqPlotVariablesDialog::slotCancel(void)
|
||
{
|
||
// user clicked on OK button
|
||
emit this->cancelDismissed();
|
||
}
|
||
|
||
//-----------------------------------------------------------------------------
|
||
bool pqPlotVariablesDialog::areVariablesSelected()
|
||
{
|
||
return (this->Internal->listWidget->selectedItems().count() > 0);
|
||
}
|
||
|
||
//-----------------------------------------------------------------------------
|
||
QList<QListWidgetItem *> pqPlotVariablesDialog::getSelectedItems()
|
||
{
|
||
return this->Internal->listWidget->selectedItems();
|
||
}
|
||
|
||
//-----------------------------------------------------------------------------
|
||
QStringList pqPlotVariablesDialog::getVarsWithComponentSuffixes(vtkSMStringVectorProperty * stringVecProp)
|
||
{
|
||
QStringList retList;
|
||
|
||
unsigned int uNumElems = 0;
|
||
uNumElems = stringVecProp->GetNumberOfElements();
|
||
|
||
for (unsigned int i = 0; i < uNumElems; i += 2)
|
||
{
|
||
const char * elemPtr = stringVecProp->GetElement(i);
|
||
//const char * elemPtr_status = stringVecProp->GetElement(i+1);
|
||
|
||
QString elemAsQString(elemPtr);
|
||
VarRange * vr = this->Internal->varRanges[elemAsQString];
|
||
if (vr != NULL)
|
||
{
|
||
QStringList compList;
|
||
|
||
switch(vr->numComponents)
|
||
{
|
||
case 1:
|
||
compList.append(elemAsQString);
|
||
break;
|
||
|
||
case 3:
|
||
compList.append(elemAsQString + QString("_x"));
|
||
compList.append(elemAsQString + QString("_y"));
|
||
compList.append(elemAsQString + QString("_z"));
|
||
compList.append(elemAsQString + QString("_magnitude"));
|
||
break;
|
||
|
||
case 6:
|
||
compList.append(elemAsQString + QString("_xx"));
|
||
compList.append(elemAsQString + QString("_yy"));
|
||
compList.append(elemAsQString + QString("_zz"));
|
||
compList.append(elemAsQString + QString("_xy"));
|
||
compList.append(elemAsQString + QString("_yz"));
|
||
compList.append(elemAsQString + QString("_zx"));
|
||
compList.append(elemAsQString + QString("_magnitude"));
|
||
break;
|
||
|
||
default:
|
||
break;
|
||
}
|
||
|
||
retList.append(compList);
|
||
}
|
||
}
|
||
|
||
return retList;
|
||
}
|
||
|
||
//-----------------------------------------------------------------------------
|
||
QStringList pqPlotVariablesDialog::getSelectedItemsStringList()
|
||
{
|
||
QList<QListWidgetItem *> selectedItems = this->getSelectedItems();
|
||
QStringList retList;
|
||
|
||
QList<QListWidgetItem *>::iterator iter = selectedItems.begin();
|
||
while (iter != selectedItems.end())
|
||
{
|
||
QString variableAsString = (*iter)->text();
|
||
retList.append(variableAsString);
|
||
iter++;
|
||
}
|
||
|
||
return retList;
|
||
}
|
||
|
||
//-----------------------------------------------------------------------------
|
||
QListWidget * pqPlotVariablesDialog::getVariableList()
|
||
{
|
||
return this->Internal->listWidget;
|
||
}
|
||
|
||
//-----------------------------------------------------------------------------
|
||
void pqPlotVariablesDialog::setupVariablesList(QStringList varStrings)
|
||
{
|
||
QGridLayout * varListLayout = new QGridLayout(ui->pickVariableFrame);
|
||
this->Internal->listWidget = new QListWidget(ui->pickVariableFrame);
|
||
varListLayout->addWidget(this->Internal->listWidget);
|
||
|
||
this->Internal->listWidget->setSelectionMode(QAbstractItemView::MultiSelection);
|
||
|
||
QStringList::const_iterator constIterator;
|
||
for (constIterator = varStrings.constBegin(); constIterator != varStrings.constEnd(); ++constIterator)
|
||
{
|
||
QString theVarNameStr = (*constIterator);
|
||
this->Internal->listWidget->addItem(theVarNameStr);
|
||
this->Internal->variableSelectionStates[theVarNameStr] = false;
|
||
}
|
||
|
||
// connect signals and slots to the list widget
|
||
QObject::connect(this->Internal->listWidget, SIGNAL(itemSelectionChanged()), this, SLOT(slotItemSelectionChanged()));
|
||
}
|
||
|
||
//-----------------------------------------------------------------------------
|
||
bool pqPlotVariablesDialog::pqInternal::inSelection(const QString & itemStr, QList<QListWidgetItem *> & selectedItems)
|
||
{
|
||
QList<QListWidgetItem *>::iterator iter;
|
||
for (iter=selectedItems.begin(); iter != selectedItems.end(); iter++)
|
||
{
|
||
if ((*iter)->text() == itemStr)
|
||
{
|
||
return true;
|
||
}
|
||
}
|
||
|
||
return false;
|
||
}
|
||
|
||
//-----------------------------------------------------------------------------
|
||
void pqPlotVariablesDialog::slotItemSelectionChanged()
|
||
{
|
||
QList<QListWidgetItem *> selectedItems = this->Internal->listWidget->selectedItems();
|
||
|
||
// Find all deselected variables:
|
||
// first go through all the selection states. If a variable was selected,
|
||
// but is not in the current selection list, than that means it was
|
||
// delselected
|
||
QMap<QString, bool>::iterator statesIter = this->Internal->variableSelectionStates.begin();
|
||
for ( ; statesIter != this->Internal->variableSelectionStates.end(); statesIter++)
|
||
{
|
||
if (*statesIter == true && ! this->Internal->inSelection(statesIter.key(), selectedItems))
|
||
{
|
||
// deselection
|
||
emit this->variableDeselectionByName(statesIter.key());
|
||
|
||
// and set the selection state accordingly
|
||
this->Internal->variableSelectionStates[statesIter.key()] = false;
|
||
}
|
||
}
|
||
|
||
// Now find all selected variables (that were not selected in the first pass):
|
||
// first go through all the selection states. If a variable was selected,
|
||
// but is not in the current selection list, than that means it was
|
||
// delselected
|
||
statesIter = this->Internal->variableSelectionStates.begin();
|
||
for ( ; statesIter != this->Internal->variableSelectionStates.end(); statesIter++)
|
||
{
|
||
if (*statesIter == false && this->Internal->inSelection(statesIter.key(), selectedItems))
|
||
{
|
||
// new selection
|
||
emit this->variableSelectionByName(statesIter.key());
|
||
|
||
// and set the selection state accordingly
|
||
this->Internal->variableSelectionStates[statesIter.key()] = true;
|
||
}
|
||
}
|
||
|
||
//pqPlotVariablesDialog * myDialog = this;
|
||
|
||
//QSize dialogSize = myDialog->size();
|
||
//QSize maxSize = myDialog->maximumSize();
|
||
//QSizePolicy tmpSizePolicy = myDialog->sizePolicy();
|
||
//QSizePolicy::Policy verticalPolicy = sizePolicy.verticalPolicy();
|
||
}
|
||
|
||
//-----------------------------------------------------------------------------
|
||
bool pqPlotVariablesDialog::addRangeToUI(QString itemText)
|
||
{
|
||
|
||
// Remove the verticalSpacer (if it exists)
|
||
// because we always want to add it after the last range
|
||
if (this->Internal->verticalSpacer)
|
||
{
|
||
ui->scrollWidgetLayout->removeItem(this->Internal->verticalSpacer);
|
||
this->Internal->verticalSpacer = NULL;
|
||
}
|
||
|
||
bool flag = this->Internal->addRangeToUI(this->ui, itemText);
|
||
|
||
if (! flag)
|
||
{
|
||
return false;
|
||
}
|
||
|
||
// add in a vertical spacer
|
||
this->Internal->verticalSpacer = new QSpacerItem(20, 40, QSizePolicy::Minimum, QSizePolicy::Expanding);
|
||
this->ui->scrollWidgetLayout->addItem(this->Internal->verticalSpacer);
|
||
|
||
// update the scroll area geometry
|
||
// so that it resizes if need be
|
||
this->ui->rangeScrollArea->updateGeometry();
|
||
|
||
return true;
|
||
}
|
||
|
||
//-----------------------------------------------------------------------------
|
||
bool pqPlotVariablesDialog::removeRangeFromUI(QString itemText)
|
||
{
|
||
return this->Internal->removeRangeFromUI(this->ui, itemText);
|
||
}
|
||
|
||
//-----------------------------------------------------------------------------
|
||
void pqPlotVariablesDialog::setHeading(QString heading)
|
||
{
|
||
this->ui->variableVsWhatever->setText(heading);
|
||
}
|
||
|
||
//-----------------------------------------------------------------------------
|
||
void pqPlotVariablesDialog::setTimeRange(double min, double max)
|
||
{
|
||
QString str;
|
||
|
||
str = QString("%1").arg(min, 0, 'E');
|
||
this->ui->timeMinLineEdit->setText(str);
|
||
str = QString("%1").arg(max, 0, 'E');
|
||
this->ui->timeMaxLineEdit->setText(str);
|
||
}
|