14#include <QtGui/QDoubleValidator> 
   15#include <QtGui/QIntValidator> 
   21#include <QtWidgets/QtWidgets> 
   26#include <qwt_symbol.h> 
   34        : QMenu(
"Line Color", parent), d_which(which)
 
   36        d_grp = 
new QActionGroup(
this);
 
   38        d_act.push_back(
new QAction(
"Blue", 
this));
 
   39        d_act.push_back(
new QAction(
"Red", 
this));
 
   40        d_act.push_back(
new QAction(
"Green", 
this));
 
   41        d_act.push_back(
new QAction(
"Black", 
this));
 
   42        d_act.push_back(
new QAction(
"Cyan", 
this));
 
   43        d_act.push_back(
new QAction(
"Magenta", 
this));
 
   44        d_act.push_back(
new QAction(
"Yellow", 
this));
 
   45        d_act.push_back(
new QAction(
"Gray", 
this));
 
   46        d_act.push_back(
new QAction(
"Dark Red", 
this));
 
   47        d_act.push_back(
new QAction(
"Dark Green", 
this));
 
   48        d_act.push_back(
new QAction(
"Dark Blue", 
this));
 
   49        d_act.push_back(
new QAction(
"Dark Gray", 
this));
 
   51        connect(d_act[0], SIGNAL(triggered()), 
this, SLOT(
getBlue()));
 
   52        connect(d_act[1], SIGNAL(triggered()), 
this, SLOT(
getRed()));
 
   53        connect(d_act[2], SIGNAL(triggered()), 
this, SLOT(
getGreen()));
 
   54        connect(d_act[3], SIGNAL(triggered()), 
this, SLOT(
getBlack()));
 
   55        connect(d_act[4], SIGNAL(triggered()), 
this, SLOT(
getCyan()));
 
   56        connect(d_act[5], SIGNAL(triggered()), 
this, SLOT(
getMagenta()));
 
   57        connect(d_act[6], SIGNAL(triggered()), 
this, SLOT(
getYellow()));
 
   58        connect(d_act[7], SIGNAL(triggered()), 
this, SLOT(
getGray()));
 
   59        connect(d_act[8], SIGNAL(triggered()), 
this, SLOT(
getDarkRed()));
 
   60        connect(d_act[9], SIGNAL(triggered()), 
this, SLOT(
getDarkGreen()));
 
   61        connect(d_act[10], SIGNAL(triggered()), 
this, SLOT(
getDarkBlue()));
 
   62        connect(d_act[11], SIGNAL(triggered()), 
this, SLOT(
getDarkGray()));
 
   64        QListIterator<QAction*> i(d_act);
 
   66            QAction* a = i.next();
 
   67            a->setCheckable(
true);
 
   68            a->setActionGroup(d_grp);
 
 
   79        if (which < 
static_cast<unsigned int>(d_act.size()))
 
   82            throw std::runtime_error(
"LineColorMenu::getAction: which out of range.");
 
 
  104    QList<QAction*> d_act;
 
 
  118        : QMenu(
"Line Width", parent), d_which(which)
 
  120        d_grp = 
new QActionGroup(
this);
 
  122        d_act.push_back(
new QAction(
"1", 
this));
 
  123        d_act.push_back(
new QAction(
"2", 
this));
 
  124        d_act.push_back(
new QAction(
"3", 
this));
 
  125        d_act.push_back(
new QAction(
"4", 
this));
 
  126        d_act.push_back(
new QAction(
"5", 
this));
 
  127        d_act.push_back(
new QAction(
"6", 
this));
 
  128        d_act.push_back(
new QAction(
"7", 
this));
 
  129        d_act.push_back(
new QAction(
"8", 
this));
 
  130        d_act.push_back(
new QAction(
"9", 
this));
 
  131        d_act.push_back(
new QAction(
"10", 
this));
 
  133        connect(d_act[0], SIGNAL(triggered()), 
this, SLOT(
getOne()));
 
  134        connect(d_act[1], SIGNAL(triggered()), 
this, SLOT(
getTwo()));
 
  135        connect(d_act[2], SIGNAL(triggered()), 
this, SLOT(
getThree()));
 
  136        connect(d_act[3], SIGNAL(triggered()), 
this, SLOT(
getFour()));
 
  137        connect(d_act[4], SIGNAL(triggered()), 
this, SLOT(
getFive()));
 
  138        connect(d_act[5], SIGNAL(triggered()), 
this, SLOT(
getSix()));
 
  139        connect(d_act[6], SIGNAL(triggered()), 
this, SLOT(
getSeven()));
 
  140        connect(d_act[7], SIGNAL(triggered()), 
this, SLOT(
getEight()));
 
  141        connect(d_act[8], SIGNAL(triggered()), 
this, SLOT(
getNine()));
 
  142        connect(d_act[9], SIGNAL(triggered()), 
this, SLOT(
getTen()));
 
  144        QListIterator<QAction*> i(d_act);
 
  145        while (i.hasNext()) {
 
  146            QAction* a = i.next();
 
  147            a->setCheckable(
true);
 
  148            a->setActionGroup(d_grp);
 
 
  159        if (which < 
static_cast<unsigned int>(d_act.size()))
 
  162            throw std::runtime_error(
"LineWidthMenu::getAction: which out of range.");
 
 
  182    QList<QAction*> d_act;
 
 
  196        : QMenu(
"Line Style", parent), d_which(which)
 
  198        d_grp = 
new QActionGroup(
this);
 
  200        d_act.push_back(
new QAction(
"None", 
this));
 
  201        d_act.push_back(
new QAction(
"Solid", 
this));
 
  202        d_act.push_back(
new QAction(
"Dash", 
this));
 
  203        d_act.push_back(
new QAction(
"Dots", 
this));
 
  204        d_act.push_back(
new QAction(
"Dash-Dot", 
this));
 
  205        d_act.push_back(
new QAction(
"Dash-Dot-Dot", 
this));
 
  207        connect(d_act[0], SIGNAL(triggered()), 
this, SLOT(
getNone()));
 
  208        connect(d_act[1], SIGNAL(triggered()), 
this, SLOT(
getSolid()));
 
  209        connect(d_act[2], SIGNAL(triggered()), 
this, SLOT(
getDash()));
 
  210        connect(d_act[3], SIGNAL(triggered()), 
this, SLOT(
getDots()));
 
  211        connect(d_act[4], SIGNAL(triggered()), 
this, SLOT(
getDashDot()));
 
  212        connect(d_act[5], SIGNAL(triggered()), 
this, SLOT(
getDashDotDot()));
 
  214        QListIterator<QAction*> i(d_act);
 
  215        while (i.hasNext()) {
 
  216            QAction* a = i.next();
 
  217            a->setCheckable(
true);
 
  218            a->setActionGroup(d_grp);
 
 
  229        if (which < 
static_cast<unsigned int>(d_act.size()))
 
  232            throw std::runtime_error(
"LineStyleMenu::getAction: which out of range.");
 
 
  248    QList<QAction*> d_act;
 
 
  262        : QMenu(
"Line Marker", parent), d_which(which)
 
  264        d_grp = 
new QActionGroup(
this);
 
  266        d_act.push_back(
new QAction(
"None", 
this));
 
  267        d_act.push_back(
new QAction(
"Circle", 
this));
 
  268        d_act.push_back(
new QAction(
"Rectangle", 
this));
 
  269        d_act.push_back(
new QAction(
"Diamond", 
this));
 
  270        d_act.push_back(
new QAction(
"Triangle", 
this));
 
  271        d_act.push_back(
new QAction(
"Down Triangle", 
this));
 
  272        d_act.push_back(
new QAction(
"Left Triangle", 
this));
 
  273        d_act.push_back(
new QAction(
"Right Triangle", 
this));
 
  274        d_act.push_back(
new QAction(
"Cross", 
this));
 
  275        d_act.push_back(
new QAction(
"X-Cross", 
this));
 
  276        d_act.push_back(
new QAction(
"Horiz. Line", 
this));
 
  277        d_act.push_back(
new QAction(
"Vert. Line", 
this));
 
  278        d_act.push_back(
new QAction(
"Star 1", 
this));
 
  279        d_act.push_back(
new QAction(
"Star 2", 
this));
 
  280        d_act.push_back(
new QAction(
"Hexagon", 
this));
 
  282        connect(d_act[0], SIGNAL(triggered()), 
this, SLOT(
getNone()));
 
  283        connect(d_act[1], SIGNAL(triggered()), 
this, SLOT(
getCircle()));
 
  284        connect(d_act[2], SIGNAL(triggered()), 
this, SLOT(
getRect()));
 
  285        connect(d_act[3], SIGNAL(triggered()), 
this, SLOT(
getDiamond()));
 
  286        connect(d_act[4], SIGNAL(triggered()), 
this, SLOT(
getTriangle()));
 
  287        connect(d_act[5], SIGNAL(triggered()), 
this, SLOT(
getDTriangle()));
 
  288        connect(d_act[6], SIGNAL(triggered()), 
this, SLOT(
getLTriangle()));
 
  289        connect(d_act[7], SIGNAL(triggered()), 
this, SLOT(
getRTriangle()));
 
  290        connect(d_act[8], SIGNAL(triggered()), 
this, SLOT(
getCross()));
 
  291        connect(d_act[9], SIGNAL(triggered()), 
this, SLOT(
getXCross()));
 
  292        connect(d_act[10], SIGNAL(triggered()), 
this, SLOT(
getHLine()));
 
  293        connect(d_act[11], SIGNAL(triggered()), 
this, SLOT(
getVLine()));
 
  294        connect(d_act[12], SIGNAL(triggered()), 
this, SLOT(
getStar1()));
 
  295        connect(d_act[13], SIGNAL(triggered()), 
this, SLOT(
getStar2()));
 
  296        connect(d_act[14], SIGNAL(triggered()), 
this, SLOT(
getHexagon()));
 
  298        QListIterator<QAction*> i(d_act);
 
  299        while (i.hasNext()) {
 
  300            QAction* a = i.next();
 
  301            a->setCheckable(
true);
 
  302            a->setActionGroup(d_grp);
 
 
  313        if (which < 
static_cast<unsigned int>(d_act.size()))
 
  316            throw std::runtime_error(
"LineMarkerMenu::getAction: which out of range.");
 
 
  341    QList<QAction*> d_act;
 
 
  355        : QMenu(
"Line Transparency", parent), d_which(which)
 
  357        d_grp = 
new QActionGroup(
this);
 
  359        d_act.push_back(
new QAction(
"None", 
this));
 
  360        d_act.push_back(
new QAction(
"Low", 
this));
 
  361        d_act.push_back(
new QAction(
"Medium", 
this));
 
  362        d_act.push_back(
new QAction(
"High", 
this));
 
  363        d_act.push_back(
new QAction(
"Off", 
this));
 
  365        connect(d_act[0], SIGNAL(triggered()), 
this, SLOT(
getNone()));
 
  366        connect(d_act[1], SIGNAL(triggered()), 
this, SLOT(
getLow()));
 
  367        connect(d_act[2], SIGNAL(triggered()), 
this, SLOT(
getMedium()));
 
  368        connect(d_act[3], SIGNAL(triggered()), 
this, SLOT(
getHigh()));
 
  369        connect(d_act[4], SIGNAL(triggered()), 
this, SLOT(
getOff()));
 
  371        QListIterator<QAction*> i(d_act);
 
  372        while (i.hasNext()) {
 
  373            QAction* a = i.next();
 
  374            a->setCheckable(
true);
 
  375            a->setActionGroup(d_grp);
 
 
  386        if (which < 
static_cast<unsigned int>(d_act.size()))
 
  389            throw std::runtime_error(
"MarkerAlphaMenu::getAction: which out of range.");
 
 
  404    QList<QAction*> d_act;
 
 
  418        : QAction(
"Line Title", parent), d_which(which)
 
  420        d_diag = 
new QDialog(parent);
 
  421        d_diag->setModal(
true);
 
  423        d_text = 
new QLineEdit();
 
  425        QGridLayout* layout = 
new QGridLayout(d_diag);
 
  426        QPushButton* btn_ok = 
new QPushButton(tr(
"OK"));
 
  427        QPushButton* btn_cancel = 
new QPushButton(tr(
"Cancel"));
 
  429        layout->addWidget(d_text, 0, 0, 1, 2);
 
  430        layout->addWidget(btn_ok, 1, 0);
 
  431        layout->addWidget(btn_cancel, 1, 1);
 
  433        connect(btn_ok, SIGNAL(clicked()), 
this, SLOT(getText()));
 
  434        connect(btn_cancel, SIGNAL(clicked()), d_diag, SLOT(close()));
 
  436        connect(
this, SIGNAL(triggered()), 
this, SLOT(
getTextDiag()));
 
 
 
  471        : QMenu(menuTitle.c_str(), parent)
 
  473        d_grp = 
new QActionGroup(
this);
 
  480        d_act.push_back(
new QAction(
"Off", 
this));
 
  481        d_act.push_back(
new QAction(
"High", 
this));
 
  482        d_act.push_back(
new QAction(
"Medium", 
this));
 
  483        d_act.push_back(
new QAction(
"Low", 
this));
 
  485        d_grp = 
new QActionGroup(
this);
 
  486        for (
int t = 0; t < d_act.size(); t++) {
 
  487            d_act[t]->setCheckable(
true);
 
  488            d_act[t]->setActionGroup(d_grp);
 
  490        d_act[0]->setChecked(
true);
 
  492        connect(d_act[0], SIGNAL(triggered()), 
this, SLOT(
getOff()));
 
  493        connect(d_act[1], SIGNAL(triggered()), 
this, SLOT(
getHigh()));
 
  494        connect(d_act[2], SIGNAL(triggered()), 
this, SLOT(
getMedium()));
 
  495        connect(d_act[3], SIGNAL(triggered()), 
this, SLOT(
getLow()));
 
  497        QListIterator<QAction*> i(d_act);
 
  498        while (i.hasNext()) {
 
  499            QAction* a = i.next();
 
  500            a->setCheckable(
true);
 
  501            a->setActionGroup(d_grp);
 
 
  512        if (which < 
static_cast<unsigned int>(d_act.size()))
 
  515            throw std::runtime_error(
"AverageMenu::getAction: which out of range.");
 
 
  523        else if (avg == d_high)
 
  525        else if (avg == d_medium)
 
  527        else if (avg == d_low)
 
  529        return d_act[
static_cast<int>(which)];
 
 
  548        float value = str.toFloat();
 
 
  553    QList<QAction*> d_act;
 
  555    float d_off, d_high, d_medium, d_low;
 
 
  581        d_act.push_back(
new QAction(
"None", 
this));
 
  582        d_act.push_back(
new QAction(
"Hamming", 
this));
 
  583        d_act.push_back(
new QAction(
"Hann", 
this));
 
  584        d_act.push_back(
new QAction(
"Blackman", 
this));
 
  585        d_act.push_back(
new QAction(
"Blackman-harris", 
this));
 
  586        d_act.push_back(
new QAction(
"Rectangular", 
this));
 
  587        d_act.push_back(
new QAction(
"Kaiser", 
this));
 
  588        d_act.push_back(
new QAction(
"Flat-top", 
this));
 
  590        d_grp = 
new QActionGroup(
this);
 
  591        for (
int t = 0; t < d_act.size(); t++) {
 
  592            d_act[t]->setCheckable(
true);
 
  593            d_act[t]->setActionGroup(d_grp);
 
  596        connect(d_act[0], SIGNAL(triggered()), 
this, SLOT(
getNone()));
 
  597        connect(d_act[1], SIGNAL(triggered()), 
this, SLOT(
getHamming()));
 
  598        connect(d_act[2], SIGNAL(triggered()), 
this, SLOT(
getHann()));
 
  599        connect(d_act[3], SIGNAL(triggered()), 
this, SLOT(
getBlackman()));
 
  601        connect(d_act[5], SIGNAL(triggered()), 
this, SLOT(
getRectangular()));
 
  602        connect(d_act[6], SIGNAL(triggered()), 
this, SLOT(
getKaiser()));
 
  603        connect(d_act[7], SIGNAL(triggered()), 
this, SLOT(
getFlattop()));
 
  605        QListIterator<QAction*> i(d_act);
 
  606        while (i.hasNext()) {
 
  607            QAction* a = i.next();
 
 
  618        if (which < 
static_cast<unsigned int>(d_act.size()))
 
  621            throw std::runtime_error(
"FFTWindowMenu::getAction: which out of range.");
 
 
  627        switch (
static_cast<int>(type)) {
 
 
  670    QList<QAction*> d_act;
 
 
  683    NPointsMenu(QWidget* parent) : QAction(
"Number of Points", parent)
 
  685        d_diag = 
new QDialog(parent);
 
  686        d_diag->setWindowTitle(
"Number of Points");
 
  687        d_diag->setModal(
true);
 
  689        d_text = 
new QLineEdit();
 
  691        QGridLayout* layout = 
new QGridLayout(d_diag);
 
  692        QPushButton* btn_ok = 
new QPushButton(tr(
"OK"));
 
  693        QPushButton* btn_cancel = 
new QPushButton(tr(
"Cancel"));
 
  695        layout->addWidget(d_text, 0, 0, 1, 2);
 
  696        layout->addWidget(btn_ok, 1, 0);
 
  697        layout->addWidget(btn_cancel, 1, 1);
 
  699        connect(btn_ok, SIGNAL(clicked()), 
this, SLOT(getText()));
 
  700        connect(btn_cancel, SIGNAL(clicked()), d_diag, SLOT(close()));
 
  702        connect(
this, SIGNAL(triggered()), 
this, SLOT(
getTextDiag()));
 
 
  711    void setDiagText(
const int npts) { d_text->setText(QString().setNum(npts)); }
 
 
  737        : QMenu(
"Color Map", parent), d_which(which)
 
  739        d_grp = 
new QActionGroup(
this);
 
  741        d_act.push_back(
new QAction(
"Multi-Color", 
this));
 
  742        d_act.push_back(
new QAction(
"White Hot", 
this));
 
  743        d_act.push_back(
new QAction(
"Black Hot", 
this));
 
  744        d_act.push_back(
new QAction(
"Incandescent", 
this));
 
  745        d_act.push_back(
new QAction(
"Sunset", 
this));
 
  746        d_act.push_back(
new QAction(
"Cool", 
this));
 
  747        d_act.push_back(
new QAction(
"Other", 
this));
 
  751        connect(d_act[0], SIGNAL(triggered()), 
this, SLOT(
getMultiColor()));
 
  752        connect(d_act[1], SIGNAL(triggered()), 
this, SLOT(
getWhiteHot()));
 
  753        connect(d_act[2], SIGNAL(triggered()), 
this, SLOT(
getBlackHot()));
 
  755        connect(d_act[4], SIGNAL(triggered()), 
this, SLOT(
getSunset()));
 
  756        connect(d_act[5], SIGNAL(triggered()), 
this, SLOT(
getCool()));
 
  757        connect(d_act[6], SIGNAL(triggered()), 
this, SLOT(
getOther()));
 
  759        QListIterator<QAction*> i(d_act);
 
  760        while (i.hasNext()) {
 
  761            QAction* a = i.next();
 
  762            a->setCheckable(
true);
 
  763            a->setActionGroup(d_grp);
 
  767        d_max_value = QColor(
"white");
 
  768        d_min_value = QColor(
"white");
 
 
  777        if (which < 
static_cast<unsigned int>(d_act.size()))
 
  780            throw std::runtime_error(
"ColorMapMenu::getAction: which out of range.");
 
 
  786                      const QColor& min_color = QColor(),
 
  787                      const QColor& max_color = QColor());
 
  817        QMessageBox::information(
 
  819            "Set low and high intensities",
 
  820            "In the next windows, select the low and then the high intensity colors.",
 
  822        d_min_value = QColorDialog::getColor(d_min_value, 
this);
 
  823        d_max_value = QColorDialog::getColor(d_max_value, 
this);
 
 
  833    QList<QAction*> d_act;
 
  834    QColor d_max_value, d_min_value;
 
 
  849        d_grp = 
new QActionGroup(
this);
 
  850        d_act.push_back(
new QAction(
"Free", 
this));
 
  851        d_act.push_back(
new QAction(
"Auto", 
this));
 
  852        d_act.push_back(
new QAction(
"Normal", 
this));
 
  853        d_act.push_back(
new QAction(
"Tag", 
this));
 
  855        connect(d_act[0], SIGNAL(triggered()), 
this, SLOT(
getFree()));
 
  856        connect(d_act[1], SIGNAL(triggered()), 
this, SLOT(
getAuto()));
 
  857        connect(d_act[2], SIGNAL(triggered()), 
this, SLOT(
getNorm()));
 
  858        connect(d_act[3], SIGNAL(triggered()), 
this, SLOT(
getTag()));
 
  860        QListIterator<QAction*> i(d_act);
 
  861        while (i.hasNext()) {
 
  862            QAction* a = i.next();
 
  863            a->setCheckable(
true);
 
  864            a->setActionGroup(d_grp);
 
 
  875        if (which < 
static_cast<unsigned int>(d_act.size()))
 
  878            throw std::runtime_error(
"TriggerModeMenu::getAction: which out of range.");
 
 
  897            throw std::runtime_error(
"TriggerModeMenu::getAction: unknown trigger mode.");
 
 
  911    QList<QAction*> d_act;
 
 
  926        d_grp = 
new QActionGroup(
this);
 
  927        d_act.push_back(
new QAction(
"Positive", 
this));
 
  928        d_act.push_back(
new QAction(
"Negative", 
this));
 
  930        connect(d_act[0], SIGNAL(triggered()), 
this, SLOT(
getPos()));
 
  931        connect(d_act[1], SIGNAL(triggered()), 
this, SLOT(
getNeg()));
 
  933        QListIterator<QAction*> i(d_act);
 
  934        while (i.hasNext()) {
 
  935            QAction* a = i.next();
 
  936            a->setCheckable(
true);
 
  937            a->setActionGroup(d_grp);
 
 
  948        if (which < 
static_cast<unsigned int>(d_act.size()))
 
  951            throw std::runtime_error(
"TriggerSlopeMenu::getAction: which out of range.");
 
 
  964            throw std::runtime_error(
 
  965                "TriggerSlopeMenu::getAction: unknown trigger slope.");
 
 
  977    QList<QAction*> d_act;
 
 
  992        d_grp = 
new QActionGroup(
this);
 
  993        for (
int i = 0; i < nchans; i++) {
 
  994            d_act.push_back(
new QAction(QString().setNum(i), 
this));
 
  995            d_act[i]->setCheckable(
true);
 
  996            d_act[i]->setActionGroup(d_grp);
 
  999            connect(d_act[i], SIGNAL(triggered()), 
this, SLOT(
getChannel()));
 
 
 1009        if (which < 
static_cast<unsigned int>(d_act.size()))
 
 1010            return d_act[which];
 
 1012            throw std::runtime_error(
 
 1013                "TriggerChannelMenu::getAction: which out of range.");
 
 
 1023        QAction* a = d_grp->checkedAction();
 
 1024        int which = a->text().toInt();
 
 
 1029    QList<QAction*> d_act;
 
 1030    QActionGroup* d_grp;
 
 
 1044        d_grp = 
new QActionGroup(
this);
 
 1045        d_act.push_back(
new QAction(
"Horizontal", 
this));
 
 1046        d_act.push_back(
new QAction(
"Vertical", 
this));
 
 1047        d_act.push_back(
new QAction(
"None", 
this));
 
 1049        connect(d_act[0], SIGNAL(triggered()), 
this, SLOT(
getHoriz()));
 
 1050        connect(d_act[1], SIGNAL(triggered()), 
this, SLOT(
getVert()));
 
 1051        connect(d_act[2], SIGNAL(triggered()), 
this, SLOT(
getNone()));
 
 1053        QListIterator<QAction*> i(d_act);
 
 1054        while (i.hasNext()) {
 
 1055            QAction* a = i.next();
 
 1056            a->setCheckable(
true);
 
 1057            a->setActionGroup(d_grp);
 
 
 1068        if (which < 
static_cast<unsigned int>(d_act.size()))
 
 1069            return d_act[which];
 
 1071            throw std::runtime_error(
"NumberLayoutMenu::getAction: which out of range.");
 
 
 1087            throw std::runtime_error(
"NumberLayoutMenu::getAction: unknown layout type.");
 
 
 1100    QList<QAction*> d_act;
 
 1101    QActionGroup* d_grp;
 
 
 1114        : QMenu(
"Color Map", parent), d_which(which)
 
 1116        d_grp = 
new QActionGroup(
this);
 
 1118        d_act.push_back(
new QAction(
"Black", 
this));
 
 1119        d_act.push_back(
new QAction(
"Blue-Red", 
this));
 
 1120        d_act.push_back(
new QAction(
"White Hot", 
this));
 
 1121        d_act.push_back(
new QAction(
"Black Hot", 
this));
 
 1122        d_act.push_back(
new QAction(
"Black-Red", 
this));
 
 1123        d_act.push_back(
new QAction(
"Other", 
this));
 
 1125        connect(d_act[0], SIGNAL(triggered()), 
this, SLOT(
getBlack()));
 
 1126        connect(d_act[1], SIGNAL(triggered()), 
this, SLOT(
getBlueRed()));
 
 1127        connect(d_act[2], SIGNAL(triggered()), 
this, SLOT(
getWhiteHot()));
 
 1128        connect(d_act[3], SIGNAL(triggered()), 
this, SLOT(
getBlackHot()));
 
 1129        connect(d_act[4], SIGNAL(triggered()), 
this, SLOT(
getBlackRed()));
 
 1130        connect(d_act[5], SIGNAL(triggered()), 
this, SLOT(
getOther()));
 
 1132        QListIterator<QAction*> i(d_act);
 
 1133        while (i.hasNext()) {
 
 1134            QAction* a = i.next();
 
 1135            a->setCheckable(
true);
 
 1136            a->setActionGroup(d_grp);
 
 1140        d_max_value = QColor(
"black");
 
 1141        d_min_value = QColor(
"black");
 
 
 1150        if (which < 
static_cast<unsigned int>(d_act.size()))
 
 1151            return d_act[which];
 
 1153            throw std::runtime_error(
"ColorMapMenu::getAction: which out of range.");
 
 
 1158    whichTrigger(
unsigned int which, 
const QColor& min_color, 
const QColor& max_color);
 
 1168        QMessageBox::information(
 
 1170            "Set low and high intensities",
 
 1171            "In the next windows, select the low and then the high intensity colors.",
 
 1173        d_min_value = QColorDialog::getColor(d_min_value, 
this);
 
 1174        d_max_value = QColorDialog::getColor(d_max_value, 
this);
 
 
 1180    QActionGroup* d_grp;
 
 1181    QList<QAction*> d_act;
 
 1182    QColor d_max_value, d_min_value;
 
 
 1195    PopupMenu(QString desc, QWidget* parent) : QAction(desc, parent)
 
 1197        d_diag = 
new QDialog(parent);
 
 1198        d_diag->setWindowTitle(desc);
 
 1199        d_diag->setModal(
true);
 
 1201        d_text = 
new QLineEdit();
 
 1203        QGridLayout* layout = 
new QGridLayout(d_diag);
 
 1204        QPushButton* btn_ok = 
new QPushButton(tr(
"OK"));
 
 1205        QPushButton* btn_cancel = 
new QPushButton(tr(
"Cancel"));
 
 1207        layout->addWidget(d_text, 0, 0, 1, 2);
 
 1208        layout->addWidget(btn_ok, 1, 0);
 
 1209        layout->addWidget(btn_cancel, 1, 1);
 
 1211        connect(btn_ok, SIGNAL(clicked()), 
this, SLOT(getText()));
 
 1212        connect(btn_cancel, SIGNAL(clicked()), d_diag, SLOT(close()));
 
 1214        connect(
this, SIGNAL(triggered()), 
this, SLOT(
getTextDiag()));
 
 
 
 1249        : QAction(title, parent), d_which(which)
 
 1251        d_diag = 
new QDialog(parent);
 
 1252        d_diag->setWindowTitle(title);
 
 1253        d_diag->setModal(
true);
 
 1255        d_text = 
new QLineEdit();
 
 1257        QGridLayout* layout = 
new QGridLayout(d_diag);
 
 1258        QPushButton* btn_ok = 
new QPushButton(tr(
"OK"));
 
 1259        QPushButton* btn_cancel = 
new QPushButton(tr(
"Cancel"));
 
 1261        layout->addWidget(d_text, 0, 0, 1, 2);
 
 1262        layout->addWidget(btn_ok, 1, 0);
 
 1263        layout->addWidget(btn_cancel, 1, 1);
 
 1265        connect(btn_ok, SIGNAL(clicked()), 
this, SLOT(getText()));
 
 1266        connect(btn_cancel, SIGNAL(clicked()), d_diag, SLOT(close()));
 
 1268        connect(
this, SIGNAL(triggered()), 
this, SLOT(
getTextDiag()));
 
 
 1273    void setText(
float f) { d_text->setText(QString(
"%1").arg(f)); }
 
 
void whichTrigger(unsigned int which, float data)
~ItemFloatAct() override
Definition form_menus.h:1271
void getTextDiag()
Definition form_menus.h:1280
ItemFloatAct(unsigned int which, QString title, QWidget *parent)
Definition form_menus.h:1248
void setText(float f)
Definition form_menus.h:1273
void getTextDiag()
Definition form_menus.h:445
LineTitleAction(unsigned int which, QWidget *parent)
Definition form_menus.h:417
void whichTrigger(unsigned int which, const QString &text)
~LineTitleAction() override
Definition form_menus.h:439
win_type
Definition window.h:28
@ WIN_HANN
Hann window; max attenuation 44 dB.
Definition window.h:31
@ WIN_RECTANGULAR
Basic rectangular window; max attenuation 21 dB.
Definition window.h:34
@ WIN_BLACKMAN_hARRIS
Blackman-harris window; max attenuation 92 dB.
Definition window.h:36
@ WIN_KAISER
Kaiser window; max attenuation see window::max_attenuation.
Definition window.h:35
@ WIN_NONE
don't use a window
Definition window.h:29
@ WIN_BLACKMAN
Blackman window; max attenuation 74 dB.
Definition window.h:33
@ WIN_FLATTOP
flat top window; useful in FFTs; max attenuation 93 dB
Definition window.h:40
@ WIN_HAMMING
Hamming window; max attenuation 53 dB.
Definition window.h:30
@ INTENSITY_COLOR_MAP_TYPE_MULTI_COLOR
Definition qtgui_types.h:126
@ INTENSITY_COLOR_MAP_TYPE_USER_DEFINED
Definition qtgui_types.h:130
@ INTENSITY_COLOR_MAP_TYPE_WHITE_HOT
Definition qtgui_types.h:127
@ INTENSITY_COLOR_MAP_TYPE_SUNSET
Definition qtgui_types.h:131
@ INTENSITY_COLOR_MAP_TYPE_COOL
Definition qtgui_types.h:132
@ INTENSITY_COLOR_MAP_TYPE_BLACK_HOT
Definition qtgui_types.h:128
@ INTENSITY_COLOR_MAP_TYPE_INCANDESCENT
Definition qtgui_types.h:129
trigger_mode
Definition trigger_mode.h:17
@ TRIG_MODE_FREE
Definition trigger_mode.h:18
@ TRIG_MODE_NORM
Definition trigger_mode.h:20
@ TRIG_MODE_AUTO
Definition trigger_mode.h:19
@ TRIG_MODE_TAG
Definition trigger_mode.h:21
trigger_slope
Definition trigger_mode.h:24
@ TRIG_SLOPE_NEG
Definition trigger_mode.h:26
@ TRIG_SLOPE_POS
Definition trigger_mode.h:25
graph_t
Definition qtgui_types.h:119
@ NUM_GRAPH_VERT
Definition qtgui_types.h:122
@ NUM_GRAPH_NONE
Definition qtgui_types.h:120
@ NUM_GRAPH_HORIZ
Definition qtgui_types.h:121