GNU Radio 3.7.2 C++ API
form_menus.h
Go to the documentation of this file.
1 /* -*- c++ -*- */
2 /*
3  * Copyright 2012 Free Software Foundation, Inc.
4  *
5  * This file is part of GNU Radio
6  *
7  * GNU Radio is free software; you can redistribute it and/or modify
8  * it under the terms of the GNU General Public License as published by
9  * the Free Software Foundation; either version 3, or (at your option)
10  * any later version.
11  *
12  * GNU Radio is distributed in the hope that it will be useful,
13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15  * GNU General Public License for more details.
16  *
17  * You should have received a copy of the GNU General Public License
18  * along with GNU Radio; see the file COPYING. If not, write to
19  * the Free Software Foundation, Inc., 51 Franklin Street,
20  * Boston, MA 02110-1301, USA.
21  */
22 
23 #ifndef FORM_MENUS_H
24 #define FORM_MENUS_H
25 
26 #include <stdexcept>
27 #include <vector>
28 #include <QtGui/QtGui>
29 #include <qwt_symbol.h>
30 #include <gnuradio/filter/firdes.h>
31 #include <gnuradio/qtgui/qtgui_types.h>
32 #include <gnuradio/qtgui/trigger_mode.h>
33 
34 class LineColorMenu: public QMenu
35 {
36  Q_OBJECT
37 
38 public:
39  LineColorMenu(int which, QWidget *parent)
40  : QMenu("Line Color", parent), d_which(which)
41  {
42  d_act.push_back(new QAction("Blue", this));
43  d_act.push_back(new QAction("Red", this));
44  d_act.push_back(new QAction("Green", this));
45  d_act.push_back(new QAction("Black", this));
46  d_act.push_back(new QAction("Cyan", this));
47  d_act.push_back(new QAction("Magenta", this));
48  d_act.push_back(new QAction("Yellow", this));
49  d_act.push_back(new QAction("Gray", this));
50  d_act.push_back(new QAction("Dark Red", this));
51  d_act.push_back(new QAction("Dark Green", this));
52  d_act.push_back(new QAction("Dark Blue", this));
53  d_act.push_back(new QAction("Dark Gray", this));
54 
55  connect(d_act[0], SIGNAL(triggered()), this, SLOT(getBlue()));
56  connect(d_act[1], SIGNAL(triggered()), this, SLOT(getRed()));
57  connect(d_act[2], SIGNAL(triggered()), this, SLOT(getGreen()));
58  connect(d_act[3], SIGNAL(triggered()), this, SLOT(getBlack()));
59  connect(d_act[4], SIGNAL(triggered()), this, SLOT(getCyan()));
60  connect(d_act[5], SIGNAL(triggered()), this, SLOT(getMagenta()));
61  connect(d_act[6], SIGNAL(triggered()), this, SLOT(getYellow()));
62  connect(d_act[7], SIGNAL(triggered()), this, SLOT(getGray()));
63  connect(d_act[8], SIGNAL(triggered()), this, SLOT(getDarkRed()));
64  connect(d_act[9], SIGNAL(triggered()), this, SLOT(getDarkGreen()));
65  connect(d_act[10], SIGNAL(triggered()), this, SLOT(getDarkBlue()));
66  connect(d_act[11], SIGNAL(triggered()), this, SLOT(getDarkGray()));
67 
68  QListIterator<QAction*> i(d_act);
69  while(i.hasNext()) {
70  QAction *a = i.next();
71  addAction(a);
72  }
73  }
74 
75  ~LineColorMenu()
76  {}
77 
78  int getNumActions() const
79  {
80  return d_act.size();
81  }
82 
83  QAction * getAction(int which)
84  {
85  if(which < d_act.size())
86  return d_act[which];
87  else
88  throw std::runtime_error("LineColorMenu::getAction: which out of range.\n");
89  }
90 
91 signals:
92  void whichTrigger(int which, const QString &name);
93 
94 public slots:
95  void getBlue() { emit whichTrigger(d_which, "blue"); }
96  void getRed() { emit whichTrigger(d_which, "red"); }
97  void getGreen() { emit whichTrigger(d_which, "green"); }
98  void getBlack() { emit whichTrigger(d_which, "black"); }
99  void getCyan() { emit whichTrigger(d_which, "cyan"); }
100  void getMagenta() { emit whichTrigger(d_which, "magenta"); }
101  void getYellow() { emit whichTrigger(d_which, "yellow"); }
102  void getGray() { emit whichTrigger(d_which, "gray"); }
103  void getDarkRed() { emit whichTrigger(d_which, "darkred"); }
104  void getDarkGreen() { emit whichTrigger(d_which, "darkgreen"); }
105  void getDarkBlue() { emit whichTrigger(d_which, "darkblue"); }
106  void getDarkGray() { emit whichTrigger(d_which, "darkgray"); }
107 
108 private:
109  QList<QAction *> d_act;
110  int d_which;
111 };
112 
113 
114 /********************************************************************/
115 
116 
117 class LineWidthMenu: public QMenu
118 {
119  Q_OBJECT
120 
121 public:
122  LineWidthMenu(int which, QWidget *parent)
123  : QMenu("Line Width", parent), d_which(which)
124  {
125  d_act.push_back(new QAction("1", this));
126  d_act.push_back(new QAction("2", this));
127  d_act.push_back(new QAction("3", this));
128  d_act.push_back(new QAction("4", this));
129  d_act.push_back(new QAction("5", this));
130  d_act.push_back(new QAction("6", this));
131  d_act.push_back(new QAction("7", this));
132  d_act.push_back(new QAction("8", this));
133  d_act.push_back(new QAction("9", this));
134  d_act.push_back(new QAction("10", this));
135 
136  connect(d_act[0], SIGNAL(triggered()), this, SLOT(getOne()));
137  connect(d_act[1], SIGNAL(triggered()), this, SLOT(getTwo()));
138  connect(d_act[2], SIGNAL(triggered()), this, SLOT(getThree()));
139  connect(d_act[3], SIGNAL(triggered()), this, SLOT(getFour()));
140  connect(d_act[4], SIGNAL(triggered()), this, SLOT(getFive()));
141  connect(d_act[5], SIGNAL(triggered()), this, SLOT(getSix()));
142  connect(d_act[6], SIGNAL(triggered()), this, SLOT(getSeven()));
143  connect(d_act[7], SIGNAL(triggered()), this, SLOT(getEight()));
144  connect(d_act[8], SIGNAL(triggered()), this, SLOT(getNine()));
145  connect(d_act[9], SIGNAL(triggered()), this, SLOT(getTen()));
146 
147  QListIterator<QAction*> i(d_act);
148  while(i.hasNext()) {
149  QAction *a = i.next();
150  addAction(a);
151  }
152  }
153 
154  ~LineWidthMenu()
155  {}
156 
157  int getNumActions() const
158  {
159  return d_act.size();
160  }
161 
162  QAction * getAction(int which)
163  {
164  if(which < d_act.size())
165  return d_act[which];
166  else
167  throw std::runtime_error("LineWidthMenu::getAction: which out of range.\n");
168  }
169 
170 signals:
171  void whichTrigger(int which, int width);
172 
173 public slots:
174  void getOne() { emit whichTrigger(d_which, 1); }
175  void getTwo() { emit whichTrigger(d_which, 2); }
176  void getThree() { emit whichTrigger(d_which, 3); }
177  void getFour() { emit whichTrigger(d_which, 4); }
178  void getFive() { emit whichTrigger(d_which, 5); }
179  void getSix() { emit whichTrigger(d_which, 6); }
180  void getSeven() { emit whichTrigger(d_which, 7); }
181  void getEight() { emit whichTrigger(d_which, 8); }
182  void getNine() { emit whichTrigger(d_which, 9); }
183  void getTen() { emit whichTrigger(d_which, 10); }
184 
185 private:
186  QList<QAction *> d_act;
187  int d_which;
188 };
189 
190 
191 /********************************************************************/
192 
193 
194 class LineStyleMenu: public QMenu
195 {
196  Q_OBJECT
197 
198 public:
199  LineStyleMenu(int which, QWidget *parent)
200  : QMenu("Line Style", parent), d_which(which)
201  {
202  d_act.push_back(new QAction("None", this));
203  d_act.push_back(new QAction("Solid", this));
204  d_act.push_back(new QAction("Dash", this));
205  d_act.push_back(new QAction("Dots", this));
206  d_act.push_back(new QAction("Dash-Dot", this));
207  d_act.push_back(new QAction("Dash-Dot-Dot", this));
208 
209  connect(d_act[0], SIGNAL(triggered()), this, SLOT(getNone()));
210  connect(d_act[1], SIGNAL(triggered()), this, SLOT(getSolid()));
211  connect(d_act[2], SIGNAL(triggered()), this, SLOT(getDash()));
212  connect(d_act[3], SIGNAL(triggered()), this, SLOT(getDots()));
213  connect(d_act[4], SIGNAL(triggered()), this, SLOT(getDashDot()));
214  connect(d_act[5], SIGNAL(triggered()), this, SLOT(getDashDotDot()));
215 
216  QListIterator<QAction*> i(d_act);
217  while(i.hasNext()) {
218  QAction *a = i.next();
219  addAction(a);
220  }
221  }
222 
223  ~LineStyleMenu()
224  {}
225 
226  int getNumActions() const
227  {
228  return d_act.size();
229  }
230 
231  QAction * getAction(int which)
232  {
233  if(which < d_act.size())
234  return d_act[which];
235  else
236  throw std::runtime_error("LineStyleMenu::getAction: which out of range.\n");
237  }
238 
239 signals:
240  void whichTrigger(int which, Qt::PenStyle);
241 
242 public slots:
243  void getNone() { emit whichTrigger(d_which, Qt::NoPen); }
244  void getSolid() { emit whichTrigger(d_which, Qt::SolidLine); }
245  void getDash() { emit whichTrigger(d_which, Qt::DashLine); }
246  void getDots() { emit whichTrigger(d_which, Qt::DotLine); }
247  void getDashDot() { emit whichTrigger(d_which, Qt::DashDotLine); }
248  void getDashDotDot() { emit whichTrigger(d_which, Qt::DashDotDotLine); }
249 
250 private:
251  QList<QAction *> d_act;
252  int d_which;
253 };
254 
255 
256 /********************************************************************/
257 
258 
259 class LineMarkerMenu: public QMenu
260 {
261  Q_OBJECT
262 
263 public:
264  LineMarkerMenu(int which, QWidget *parent)
265  : QMenu("Line Marker", parent), d_which(which)
266  {
267  d_act.push_back(new QAction("None", this));
268  d_act.push_back(new QAction("Circle", this));
269  d_act.push_back(new QAction("Rectangle", this));
270  d_act.push_back(new QAction("Diamond", this));
271  d_act.push_back(new QAction("Triangle", this));
272  d_act.push_back(new QAction("Down Triangle", this));
273  d_act.push_back(new QAction("Left Triangle", this));
274  d_act.push_back(new QAction("Right Triangle", this));
275  d_act.push_back(new QAction("Cross", this));
276  d_act.push_back(new QAction("X-Cross", this));
277  d_act.push_back(new QAction("Horiz. Line", this));
278  d_act.push_back(new QAction("Vert. Line", this));
279  d_act.push_back(new QAction("Star 1", this));
280  d_act.push_back(new QAction("Star 2", this));
281  d_act.push_back(new QAction("Hexagon", this));
282 
283  connect(d_act[0], SIGNAL(triggered()), this, SLOT(getNone()));
284  connect(d_act[1], SIGNAL(triggered()), this, SLOT(getCircle()));
285  connect(d_act[2], SIGNAL(triggered()), this, SLOT(getRect()));
286  connect(d_act[3], SIGNAL(triggered()), this, SLOT(getDiamond()));
287  connect(d_act[4], SIGNAL(triggered()), this, SLOT(getTriangle()));
288  connect(d_act[5], SIGNAL(triggered()), this, SLOT(getDTriangle()));
289  connect(d_act[6], SIGNAL(triggered()), this, SLOT(getLTriangle()));
290  connect(d_act[7], SIGNAL(triggered()), this, SLOT(getRTriangle()));
291  connect(d_act[8], SIGNAL(triggered()), this, SLOT(getCross()));
292  connect(d_act[9], SIGNAL(triggered()), this, SLOT(getXCross()));
293  connect(d_act[10], SIGNAL(triggered()), this, SLOT(getHLine()));
294  connect(d_act[11], SIGNAL(triggered()), this, SLOT(getVLine()));
295  connect(d_act[12], SIGNAL(triggered()), this, SLOT(getStar1()));
296  connect(d_act[13], SIGNAL(triggered()), this, SLOT(getStar2()));
297  connect(d_act[14], SIGNAL(triggered()), this, SLOT(getHexagon()));
298 
299  QListIterator<QAction*> i(d_act);
300  while(i.hasNext()) {
301  QAction *a = i.next();
302  addAction(a);
303  }
304  }
305 
306  ~LineMarkerMenu()
307  {}
308 
309  int getNumActions() const
310  {
311  return d_act.size();
312  }
313 
314  QAction * getAction(int which)
315  {
316  if(which < d_act.size())
317  return d_act[which];
318  else
319  throw std::runtime_error("LineMarkerMenu::getAction: which out of range.\n");
320  }
321 
322 signals:
323  void whichTrigger(int which, QwtSymbol::Style);
324 
325 public slots:
326  void getNone() { emit whichTrigger(d_which, QwtSymbol::NoSymbol); }
327  void getCircle() { emit whichTrigger(d_which, QwtSymbol::Ellipse); }
328  void getRect() { emit whichTrigger(d_which, QwtSymbol::Rect); }
329  void getDiamond() { emit whichTrigger(d_which, QwtSymbol::Diamond); }
330  void getTriangle() { emit whichTrigger(d_which, QwtSymbol::Triangle); }
331  void getDTriangle() { emit whichTrigger(d_which, QwtSymbol::DTriangle); }
332  void getLTriangle() { emit whichTrigger(d_which, QwtSymbol::LTriangle); }
333  void getRTriangle() { emit whichTrigger(d_which, QwtSymbol::RTriangle); }
334  void getCross() { emit whichTrigger(d_which, QwtSymbol::Cross); }
335  void getXCross() { emit whichTrigger(d_which, QwtSymbol::XCross); }
336  void getHLine() { emit whichTrigger(d_which, QwtSymbol::HLine); }
337  void getVLine() { emit whichTrigger(d_which, QwtSymbol::VLine); }
338  void getStar1() { emit whichTrigger(d_which, QwtSymbol::Star1); }
339  void getStar2() { emit whichTrigger(d_which, QwtSymbol::Star2); }
340  void getHexagon() { emit whichTrigger(d_which, QwtSymbol::Hexagon); }
341 
342 private:
343  QList<QAction *> d_act;
344  int d_which;
345 };
346 
347 
348 /********************************************************************/
349 
350 
351 class MarkerAlphaMenu: public QMenu
352 {
353  Q_OBJECT
354 
355 public:
356  MarkerAlphaMenu(int which, QWidget *parent)
357  : QMenu("Line Transparency", parent), d_which(which)
358  {
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));
364 
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()));
370 
371  QListIterator<QAction*> i(d_act);
372  while(i.hasNext()) {
373  QAction *a = i.next();
374  addAction(a);
375  }
376  }
377 
378  ~MarkerAlphaMenu()
379  {}
380 
381  int getNumActions() const
382  {
383  return d_act.size();
384  }
385 
386  QAction * getAction(int which)
387  {
388  if(which < d_act.size())
389  return d_act[which];
390  else
391  throw std::runtime_error("MarkerAlphaMenu::getAction: which out of range.\n");
392  }
393 
394 signals:
395  void whichTrigger(int which, int);
396 
397 public slots:
398  void getNone() { emit whichTrigger(d_which, 255); }
399  void getLow() { emit whichTrigger(d_which, 200); }
400  void getMedium() { emit whichTrigger(d_which, 125); }
401  void getHigh() { emit whichTrigger(d_which, 50); }
402  void getOff() { emit whichTrigger(d_which, 0); }
403 
404 private:
405  QList<QAction *> d_act;
406  int d_which;
407 };
408 
409 
410 /********************************************************************/
411 
412 
413 class LineTitleAction: public QAction
414 {
415  Q_OBJECT
416 
417 public:
418  LineTitleAction(int which, QWidget *parent)
419  : QAction("Line Title", parent), d_which(which)
420  {
421  d_diag = new QDialog(parent);
422  d_diag->setModal(true);
423 
424  d_text = new QLineEdit();
425 
426  QGridLayout *layout = new QGridLayout(d_diag);
427  QPushButton *btn_ok = new QPushButton(tr("OK"));
428  QPushButton *btn_cancel = new QPushButton(tr("Cancel"));
429 
430  layout->addWidget(d_text, 0, 0, 1, 2);
431  layout->addWidget(btn_ok, 1, 0);
432  layout->addWidget(btn_cancel, 1, 1);
433 
434  connect(btn_ok, SIGNAL(clicked()), this, SLOT(getText()));
435  connect(btn_cancel, SIGNAL(clicked()), d_diag, SLOT(close()));
436 
437  connect(this, SIGNAL(triggered()), this, SLOT(getTextDiag()));
438  }
439 
440  ~LineTitleAction()
441  {}
442 
443 signals:
444  void whichTrigger(int which, const QString &text);
445 
446 public slots:
447  void getTextDiag()
448  {
449  d_diag->exec();
450  }
451 
452 private slots:
453  void getText()
454  {
455  emit whichTrigger(d_which, d_text->text());
456  d_diag->accept();
457  }
458 
459 private:
460  int d_which;
461 
462  QDialog *d_diag;
463  QLineEdit *d_text;
464 };
465 
466 
467 /********************************************************************/
468 
469 
470 class OtherAction: public QAction
471 {
472  Q_OBJECT
473 
474 public:
475  OtherAction(QWidget *parent)
476  : QAction("Other", parent)
477  {
478  d_diag = new QDialog(parent);
479  d_diag->setWindowTitle("Other");
480  d_diag->setModal(true);
481 
482  d_text = new QLineEdit();
483 
484  QGridLayout *layout = new QGridLayout(d_diag);
485  QPushButton *btn_ok = new QPushButton(tr("OK"));
486  QPushButton *btn_cancel = new QPushButton(tr("Cancel"));
487 
488  layout->addWidget(d_text, 0, 0, 1, 2);
489  layout->addWidget(btn_ok, 1, 0);
490  layout->addWidget(btn_cancel, 1, 1);
491 
492  connect(btn_ok, SIGNAL(clicked()), this, SLOT(getText()));
493  connect(btn_cancel, SIGNAL(clicked()), d_diag, SLOT(close()));
494 
495  connect(this, SIGNAL(triggered()), this, SLOT(getTextDiag()));
496  }
497 
498  ~OtherAction()
499  {}
500 
501 signals:
502  void whichTrigger(const QString &text);
503 
504 public slots:
505  void getTextDiag()
506  {
507  d_diag->exec();
508  }
509 
510 private slots:
511  void getText()
512  {
513  emit whichTrigger(d_text->text());
514  d_diag->accept();
515  }
516 
517 private:
518  QDialog *d_diag;
519  QLineEdit *d_text;
520 };
521 
522 /********************************************************************/
523 
524 
525 class OtherDualAction: public QAction
526 {
527  Q_OBJECT
528 
529 public:
530  OtherDualAction(QString label0, QString label1, QWidget *parent)
531  : QAction("Other", parent)
532  {
533  d_diag = new QDialog(parent);
534  d_diag->setWindowTitle("Other");
535  d_diag->setModal(true);
536 
537  d_text0 = new QLineEdit();
538  d_text1 = new QLineEdit();
539 
540  QLabel *_label0 = new QLabel(label0);
541  QLabel *_label1 = new QLabel(label1);
542 
543  QGridLayout *layout = new QGridLayout(d_diag);
544  QPushButton *btn_ok = new QPushButton(tr("OK"));
545  QPushButton *btn_cancel = new QPushButton(tr("Cancel"));
546 
547  layout->addWidget(_label0, 0, 0, 1, 2);
548  layout->addWidget(_label1, 1, 0, 1, 2);
549 
550  layout->addWidget(d_text0, 0, 1, 1, 2);
551  layout->addWidget(d_text1, 1, 1, 1, 2);
552  layout->addWidget(btn_ok, 2, 0);
553  layout->addWidget(btn_cancel, 2, 1);
554 
555  connect(btn_ok, SIGNAL(clicked()), this, SLOT(getText()));
556  connect(btn_cancel, SIGNAL(clicked()), d_diag, SLOT(close()));
557 
558  connect(this, SIGNAL(triggered()), this, SLOT(getTextDiag()));
559  }
560 
561  ~OtherDualAction()
562  {}
563 
564 signals:
565  void whichTrigger(const QString &text0, const QString &text1);
566 
567 public slots:
568  void getTextDiag()
569  {
570  d_diag->exec();
571  }
572 
573 private slots:
574  void getText()
575  {
576  emit whichTrigger(d_text0->text(), d_text1->text());
577  d_diag->accept();
578  }
579 
580 private:
581  QDialog *d_diag;
582  QLineEdit *d_text0;
583  QLineEdit *d_text1;
584 };
585 
586 
587 /********************************************************************/
588 
589 
590 class FFTSizeMenu: public QMenu
591 {
592  Q_OBJECT
593 
594 public:
595  FFTSizeMenu(QWidget *parent)
596  : QMenu("FFT Size", parent)
597  {
598  d_act.push_back(new QAction("32", this));
599  d_act.push_back(new QAction("64", this));
600  d_act.push_back(new QAction("128", this));
601  d_act.push_back(new QAction("256", this));
602  d_act.push_back(new QAction("512", this));
603  d_act.push_back(new QAction("1024", this));
604  d_act.push_back(new QAction("2048", this));
605  d_act.push_back(new QAction("4096", this));
606  d_act.push_back(new QAction("8192", this));
607  d_act.push_back(new QAction("16384", this));
608  d_act.push_back(new QAction("32768", this));
609  d_act.push_back(new OtherAction(this));
610 
611  connect(d_act[0], SIGNAL(triggered()), this, SLOT(get05()));
612  connect(d_act[1], SIGNAL(triggered()), this, SLOT(get06()));
613  connect(d_act[2], SIGNAL(triggered()), this, SLOT(get07()));
614  connect(d_act[3], SIGNAL(triggered()), this, SLOT(get08()));
615  connect(d_act[4], SIGNAL(triggered()), this, SLOT(get09()));
616  connect(d_act[5], SIGNAL(triggered()), this, SLOT(get10()));
617  connect(d_act[6], SIGNAL(triggered()), this, SLOT(get11()));
618  connect(d_act[7], SIGNAL(triggered()), this, SLOT(get12()));
619  connect(d_act[8], SIGNAL(triggered()), this, SLOT(get13()));
620  connect(d_act[9], SIGNAL(triggered()), this, SLOT(get14()));
621  connect(d_act[10], SIGNAL(triggered()), this, SLOT(get15()));
622  connect(d_act[11], SIGNAL(whichTrigger(const QString&)),
623  this, SLOT(getOther(const QString&)));
624 
625  QListIterator<QAction*> i(d_act);
626  while(i.hasNext()) {
627  QAction *a = i.next();
628  addAction(a);
629  }
630  }
631 
632  ~FFTSizeMenu()
633  {}
634 
635  int getNumActions() const
636  {
637  return d_act.size();
638  }
639 
640  QAction * getAction(int which)
641  {
642  if(which < d_act.size())
643  return d_act[which];
644  else
645  throw std::runtime_error("FFTSizeMenu::getAction: which out of range.\n");
646  }
647 
648  signals:
649  void whichTrigger(int size);
650 
651  public slots:
652  void get05() { emit whichTrigger(32); }
653  void get06() { emit whichTrigger(64); }
654  void get07() { emit whichTrigger(128); }
655  void get08() { emit whichTrigger(256); }
656  void get09() { emit whichTrigger(512); }
657  void get10() { emit whichTrigger(1024); }
658  void get11() { emit whichTrigger(2048); }
659  void get12() { emit whichTrigger(4096); }
660  void get13() { emit whichTrigger(8192); }
661  void get14() { emit whichTrigger(16384); }
662  void get15() { emit whichTrigger(32768); }
663  void getOther(const QString &str)
664  {
665  int value = str.toInt();
666  emit whichTrigger(value);
667  }
668 
669 private:
670  QList<QAction *> d_act;
671  OtherAction *d_other;
672 };
673 
674 
675 /********************************************************************/
676 
677 
678 class FFTAverageMenu: public QMenu
679 {
680  Q_OBJECT
681 
682 public:
683  FFTAverageMenu(QWidget *parent)
684  : QMenu("FFT Average", parent)
685  {
686  d_act.push_back(new QAction("Off", this));
687  d_act.push_back(new QAction("High", this));
688  d_act.push_back(new QAction("Medium", this));
689  d_act.push_back(new QAction("Low", this));
690  d_act.push_back(new OtherAction(this));
691 
692  connect(d_act[0], SIGNAL(triggered()), this, SLOT(getOff()));
693  connect(d_act[1], SIGNAL(triggered()), this, SLOT(getHigh()));
694  connect(d_act[2], SIGNAL(triggered()), this, SLOT(getMedium()));
695  connect(d_act[3], SIGNAL(triggered()), this, SLOT(getLow()));
696  connect(d_act[4], SIGNAL(whichTrigger(const QString&)),
697  this, SLOT(getOther(const QString&)));
698 
699  QListIterator<QAction*> i(d_act);
700  while(i.hasNext()) {
701  QAction *a = i.next();
702  addAction(a);
703  }
704  }
705 
706  ~FFTAverageMenu()
707  {}
708 
709  int getNumActions() const
710  {
711  return d_act.size();
712  }
713 
714  QAction * getAction(int which)
715  {
716  if(which < d_act.size())
717  return d_act[which];
718  else
719  throw std::runtime_error("FFTSizeMenu::getAction: which out of range.\n");
720  }
721 
722  signals:
723  void whichTrigger(float alpha);
724 
725  public slots:
726  void getOff() { emit whichTrigger(1.0); }
727  void getHigh() { emit whichTrigger(0.05); }
728  void getMedium() { emit whichTrigger(0.1); }
729  void getLow() { emit whichTrigger(0.2); }
730  void getOther(const QString &str)
731  {
732  float value = str.toFloat();
733  emit whichTrigger(value);
734  }
735 
736 private:
737  QList<QAction *> d_act;
738  OtherAction *d_other;
739 };
740 
741 
742 /********************************************************************/
743 
744 
745 class FFTWindowMenu: public QMenu
746 {
747  Q_OBJECT
748 
749 public:
750  FFTWindowMenu(QWidget *parent)
751  : QMenu("FFT Window", parent)
752  {
753  d_act.push_back(new QAction("None", this));
754  d_act.push_back(new QAction("Hamming", this));
755  d_act.push_back(new QAction("Hann", this));
756  d_act.push_back(new QAction("Blackman", this));
757  d_act.push_back(new QAction("Blackman-harris", this));
758  d_act.push_back(new QAction("Rectangular", this));
759  d_act.push_back(new QAction("Kaiser", this));
760 
761  connect(d_act[0], SIGNAL(triggered()), this, SLOT(getNone()));
762  connect(d_act[1], SIGNAL(triggered()), this, SLOT(getHamming()));
763  connect(d_act[2], SIGNAL(triggered()), this, SLOT(getHann()));
764  connect(d_act[3], SIGNAL(triggered()), this, SLOT(getBlackman()));
765  connect(d_act[4], SIGNAL(triggered()), this, SLOT(getBlackmanharris()));
766  connect(d_act[5], SIGNAL(triggered()), this, SLOT(getRectangular()));
767  connect(d_act[6], SIGNAL(triggered()), this, SLOT(getKaiser()));
768 
769  QListIterator<QAction*> i(d_act);
770  while(i.hasNext()) {
771  QAction *a = i.next();
772  addAction(a);
773  }
774  }
775 
776  ~FFTWindowMenu()
777  {}
778 
779  int getNumActions() const
780  {
781  return d_act.size();
782  }
783 
784  QAction * getAction(int which)
785  {
786  if(which < d_act.size())
787  return d_act[which];
788  else
789  throw std::runtime_error("FFTWindowMenu::getAction: which out of range.\n");
790  }
791 
792 signals:
793  void whichTrigger(const gr::filter::firdes::win_type type);
794 
795 public slots:
796  void getNone() { emit whichTrigger(gr::filter::firdes::WIN_NONE); }
797  void getHamming() { emit whichTrigger(gr::filter::firdes::WIN_HAMMING); }
798  void getHann() { emit whichTrigger(gr::filter::firdes::WIN_HANN); }
799  void getBlackman() { emit whichTrigger(gr::filter::firdes::WIN_BLACKMAN); }
800  void getBlackmanharris() { emit whichTrigger(gr::filter::firdes::WIN_BLACKMAN_hARRIS); }
801  void getRectangular() { emit whichTrigger(gr::filter::firdes::WIN_RECTANGULAR); }
802  void getKaiser() { emit whichTrigger(gr::filter::firdes::WIN_KAISER); }
803 
804 private:
805  QList<QAction *> d_act;
806  int d_which;
807 };
808 
809 
810 /********************************************************************/
811 
812 
813 class NPointsMenu: public QAction
814 {
815  Q_OBJECT
816 
817 public:
818  NPointsMenu(QWidget *parent)
819  : QAction("Number of Points", parent)
820  {
821  d_diag = new QDialog(parent);
822  d_diag->setWindowTitle("Number of Points");
823  d_diag->setModal(true);
824 
825  d_text = new QLineEdit();
826 
827  QGridLayout *layout = new QGridLayout(d_diag);
828  QPushButton *btn_ok = new QPushButton(tr("OK"));
829  QPushButton *btn_cancel = new QPushButton(tr("Cancel"));
830 
831  layout->addWidget(d_text, 0, 0, 1, 2);
832  layout->addWidget(btn_ok, 1, 0);
833  layout->addWidget(btn_cancel, 1, 1);
834 
835  connect(btn_ok, SIGNAL(clicked()), this, SLOT(getText()));
836  connect(btn_cancel, SIGNAL(clicked()), d_diag, SLOT(close()));
837 
838  connect(this, SIGNAL(triggered()), this, SLOT(getTextDiag()));
839  }
840 
841  ~NPointsMenu()
842  {}
843 
844  void setDiagText(const int npts)
845  {
846  d_text->setText(QString().setNum(npts));
847  }
848 
849 signals:
850  void whichTrigger(const int npts);
851 
852 public slots:
853  void getTextDiag()
854  {
855  d_diag->show();
856  }
857 
858 private slots:
859  void getText()
860  {
861  emit whichTrigger(d_text->text().toInt());
862  d_diag->accept();
863  }
864 
865 private:
866  QDialog *d_diag;
867  QLineEdit *d_text;
868 };
869 
870 
871 /********************************************************************/
872 
873 
874 class ColorMapMenu: public QMenu
875 {
876  Q_OBJECT
877 
878 public:
879  ColorMapMenu(int which, QWidget *parent)
880  : QMenu("Color Map", parent), d_which(which)
881  {
882  d_act.push_back(new QAction("Multi-Color", this));
883  d_act.push_back(new QAction("White Hot", this));
884  d_act.push_back(new QAction("Black Hot", this));
885  d_act.push_back(new QAction("Incandescent", this));
886  d_act.push_back(new QAction("Other", this));
887  //d_act.push_back(new OtherDualAction("Min Intensity: ", "Max Intensity: ", this));
888 
889  connect(d_act[0], SIGNAL(triggered()), this, SLOT(getMultiColor()));
890  connect(d_act[1], SIGNAL(triggered()), this, SLOT(getWhiteHot()));
891  connect(d_act[2], SIGNAL(triggered()), this, SLOT(getBlackHot()));
892  connect(d_act[3], SIGNAL(triggered()), this, SLOT(getIncandescent()));
893  connect(d_act[4], SIGNAL(triggered()), this, SLOT(getOther()));
894 
895  QListIterator<QAction*> i(d_act);
896  while(i.hasNext()) {
897  QAction *a = i.next();
898  addAction(a);
899  }
900 
901  d_max_value = QColor("white");
902  d_min_value = QColor("white");
903  }
904 
905  ~ColorMapMenu()
906  {}
907 
908  int getNumActions() const
909  {
910  return d_act.size();
911  }
912 
913  QAction * getAction(int which)
914  {
915  if(which < d_act.size())
916  return d_act[which];
917  else
918  throw std::runtime_error("ColorMapMenu::getAction: which out of range.\n");
919  }
920 
921  signals:
922  void whichTrigger(int which, const int type,
923  const QColor &min_color=QColor(),
924  const QColor &max_color=QColor());
925 
926  public slots:
927  void getMultiColor() { emit whichTrigger(d_which, INTENSITY_COLOR_MAP_TYPE_MULTI_COLOR); }
928  void getWhiteHot() { emit whichTrigger(d_which, INTENSITY_COLOR_MAP_TYPE_WHITE_HOT); }
929  void getBlackHot() { emit whichTrigger(d_which, INTENSITY_COLOR_MAP_TYPE_BLACK_HOT); }
930  void getIncandescent() { emit whichTrigger(d_which, INTENSITY_COLOR_MAP_TYPE_INCANDESCENT); }
931  //void getOther(d_which, const QString &min_str, const QString &max_str)
932  void getOther()
933  {
934  QMessageBox::information(this, "Set low and high intensities",
935  "In the next windows, select the low and then the high intensity colors.",
936  QMessageBox::Ok);
937  d_min_value = QColorDialog::getColor(d_min_value, this);
938  d_max_value = QColorDialog::getColor(d_max_value, this);
939 
940  emit whichTrigger(d_which, INTENSITY_COLOR_MAP_TYPE_USER_DEFINED,
941  d_min_value, d_max_value);
942  }
943 
944 private:
945  QList<QAction *> d_act;
946  OtherDualAction *d_other;
947  QColor d_max_value, d_min_value;
948  int d_which;
949 };
950 
951 
952 /********************************************************************/
953 
954 
955 class TriggerModeMenu: public QMenu
956 {
957  Q_OBJECT
958 
959 public:
960  TriggerModeMenu(QWidget *parent)
961  : QMenu("Mode", parent)
962  {
963  d_grp = new QActionGroup(this);
964  d_act.push_back(new QAction("Free", this));
965  d_act.push_back(new QAction("Auto", this));
966  d_act.push_back(new QAction("Normal", this));
967  d_act.push_back(new QAction("Tag", this));
968 
969  connect(d_act[0], SIGNAL(triggered()), this, SLOT(getFree()));
970  connect(d_act[1], SIGNAL(triggered()), this, SLOT(getAuto()));
971  connect(d_act[2], SIGNAL(triggered()), this, SLOT(getNorm()));
972  connect(d_act[3], SIGNAL(triggered()), this, SLOT(getTag()));
973 
974  QListIterator<QAction*> i(d_act);
975  while(i.hasNext()) {
976  QAction *a = i.next();
977  a->setCheckable(true);
978  a->setActionGroup(d_grp);
979  addAction(a);
980  }
981  }
982 
983  ~TriggerModeMenu()
984  {}
985 
986  int getNumActions() const
987  {
988  return d_act.size();
989  }
990 
991  QAction * getAction(int which)
992  {
993  if(which < d_act.size())
994  return d_act[which];
995  else
996  throw std::runtime_error("TriggerModeMenu::getAction: which out of range.\n");
997  }
998 
999  QAction * getAction(gr::qtgui::trigger_mode mode)
1000  {
1001  switch(mode) {
1002  case gr::qtgui::TRIG_MODE_FREE:
1003  return d_act[0];
1004  break;
1005  case gr::qtgui::TRIG_MODE_AUTO:
1006  return d_act[1];
1007  break;
1008  case gr::qtgui::TRIG_MODE_NORM:
1009  return d_act[2];
1010  break;
1011  case gr::qtgui::TRIG_MODE_TAG:
1012  return d_act[3];
1013  break;
1014  default:
1015  throw std::runtime_error("TriggerModeMenu::getAction: unknown trigger mode.\n");
1016  }
1017  }
1018 
1019 signals:
1020  void whichTrigger(gr::qtgui::trigger_mode mode);
1021 
1022 public slots:
1023  void getFree() { emit whichTrigger(gr::qtgui::TRIG_MODE_FREE); }
1024  void getAuto() { emit whichTrigger(gr::qtgui::TRIG_MODE_AUTO); }
1025  void getNorm() { emit whichTrigger(gr::qtgui::TRIG_MODE_NORM); }
1026  void getTag() { emit whichTrigger(gr::qtgui::TRIG_MODE_TAG); }
1027 
1028 private:
1029  QList<QAction *> d_act;
1030  QActionGroup *d_grp;
1031 };
1032 
1033 
1034 /********************************************************************/
1035 
1036 
1037 class TriggerSlopeMenu: public QMenu
1038 {
1039  Q_OBJECT
1040 
1041 public:
1042  TriggerSlopeMenu(QWidget *parent)
1043  : QMenu("Slope", parent)
1044  {
1045  d_grp = new QActionGroup(this);
1046  d_act.push_back(new QAction("Positive", this));
1047  d_act.push_back(new QAction("Negative", this));
1048 
1049  connect(d_act[0], SIGNAL(triggered()), this, SLOT(getPos()));
1050  connect(d_act[1], SIGNAL(triggered()), this, SLOT(getNeg()));
1051 
1052  QListIterator<QAction*> i(d_act);
1053  while(i.hasNext()) {
1054  QAction *a = i.next();
1055  a->setCheckable(true);
1056  a->setActionGroup(d_grp);
1057  addAction(a);
1058  }
1059  }
1060 
1061  ~TriggerSlopeMenu()
1062  {}
1063 
1064  int getNumActions() const
1065  {
1066  return d_act.size();
1067  }
1068 
1069  QAction * getAction(int which)
1070  {
1071  if(which < d_act.size())
1072  return d_act[which];
1073  else
1074  throw std::runtime_error("TriggerSlopeMenu::getAction: which out of range.\n");
1075  }
1076 
1077  QAction * getAction(gr::qtgui::trigger_slope slope)
1078  {
1079  switch(slope) {
1080  case gr::qtgui::TRIG_SLOPE_POS:
1081  return d_act[0];
1082  break;
1083  case gr::qtgui::TRIG_SLOPE_NEG:
1084  return d_act[1];
1085  break;
1086  default:
1087  throw std::runtime_error("TriggerSlopeMenu::getAction: unknown trigger slope.\n");
1088  }
1089  }
1090 
1091 signals:
1092  void whichTrigger(gr::qtgui::trigger_slope slope);
1093 
1094 public slots:
1095  void getPos() { emit whichTrigger(gr::qtgui::TRIG_SLOPE_POS); }
1096  void getNeg() { emit whichTrigger(gr::qtgui::TRIG_SLOPE_NEG); }
1097 
1098 private:
1099  QList<QAction *> d_act;
1100  QActionGroup *d_grp;
1101 };
1102 
1103 
1104 /********************************************************************/
1105 
1106 
1107 class TriggerChannelMenu: public QMenu
1108 {
1109  Q_OBJECT
1110 
1111 public:
1112  TriggerChannelMenu(int nchans, QWidget *parent)
1113  : QMenu("Channel", parent)
1114  {
1115  d_grp = new QActionGroup(this);
1116  for(int i = 0; i < nchans; i++) {
1117  d_act.push_back(new QAction(QString().setNum(i), this));
1118  d_act[i]->setCheckable(true);
1119  d_act[i]->setActionGroup(d_grp);
1120 
1121  addAction(d_act[i]);
1122  connect(d_act[i], SIGNAL(triggered()), this, SLOT(getChannel()));
1123  }
1124  }
1125 
1126  ~TriggerChannelMenu()
1127  {}
1128 
1129  int getNumActions() const
1130  {
1131  return d_act.size();
1132  }
1133 
1134  QAction * getAction(int which)
1135  {
1136  if(which < d_act.size())
1137  return d_act[which];
1138  else
1139  throw std::runtime_error("TriggerChannelMenu::getAction: which out of range.\n");
1140  }
1141 
1142 
1143 signals:
1144  void whichTrigger(int n);
1145 
1146 public slots:
1147  void getChannel()
1148  {
1149  QAction *a = d_grp->checkedAction();
1150  int which = a->text().toInt();
1151  emit whichTrigger(which);
1152  }
1153 
1154 private:
1155  QList<QAction *> d_act;
1156  QActionGroup *d_grp;
1157 };
1158 
1159 
1160 /********************************************************************/
1161 
1162 
1163 class PopupMenu: public QAction
1164 {
1165  Q_OBJECT
1166 
1167 public:
1168  PopupMenu(QString desc, QWidget *parent)
1169  : QAction(desc, parent)
1170  {
1171  d_diag = new QDialog(parent);
1172  d_diag->setWindowTitle(desc);
1173  d_diag->setModal(true);
1174 
1175  d_text = new QLineEdit();
1176 
1177  QGridLayout *layout = new QGridLayout(d_diag);
1178  QPushButton *btn_ok = new QPushButton(tr("OK"));
1179  QPushButton *btn_cancel = new QPushButton(tr("Cancel"));
1180 
1181  layout->addWidget(d_text, 0, 0, 1, 2);
1182  layout->addWidget(btn_ok, 1, 0);
1183  layout->addWidget(btn_cancel, 1, 1);
1184 
1185  connect(btn_ok, SIGNAL(clicked()), this, SLOT(getText()));
1186  connect(btn_cancel, SIGNAL(clicked()), d_diag, SLOT(close()));
1187 
1188  connect(this, SIGNAL(triggered()), this, SLOT(getTextDiag()));
1189  }
1190 
1191  ~PopupMenu()
1192  {}
1193 
1194  void setText(QString s)
1195  {
1196  d_text->setText(s);
1197  }
1198 
1199 signals:
1200  void whichTrigger(const QString data);
1201 
1202 public slots:
1203  void getTextDiag()
1204  {
1205  d_diag->show();
1206  }
1207 
1208 private slots:
1209  void getText()
1210  {
1211  emit whichTrigger(d_text->text());
1212  d_diag->accept();
1213  }
1214 
1215 private:
1216  QDialog *d_diag;
1217  QLineEdit *d_text;
1218 };
1219 
1220 
1221 /********************************************************************/
1222 
1223 
1224 #endif /* FORM_MENUS_H */
LineColorMenu::getYellow
void getYellow()
Definition: form_menus.h:101
FFTWindowMenu::getAction
QAction * getAction(int which)
Definition: form_menus.h:784
OtherAction::OtherAction
OtherAction(QWidget *parent)
Definition: form_menus.h:475
LineColorMenu::getDarkRed
void getDarkRed()
Definition: form_menus.h:103
NPointsMenu::whichTrigger
void whichTrigger(const int npts)
LineMarkerMenu::whichTrigger
void whichTrigger(int which, QwtSymbol::Style)
TriggerModeMenu::getAction
QAction * getAction(int which)
Definition: form_menus.h:991
LineColorMenu::getDarkBlue
void getDarkBlue()
Definition: form_menus.h:105
gr::qtgui::TRIG_SLOPE_NEG
Definition: gr-qtgui/include/gnuradio/qtgui/trigger_mode.h:38
MarkerAlphaMenu::getLow
void getLow()
Definition: form_menus.h:399
gr::filter::firdes::WIN_HANN
Hann window; max attenuation 44 dB.
Definition: firdes.h:48
LineColorMenu::getBlue
void getBlue()
Definition: form_menus.h:95
TriggerChannelMenu::getAction
QAction * getAction(int which)
Definition: form_menus.h:1134
MarkerAlphaMenu::getAction
QAction * getAction(int which)
Definition: form_menus.h:386
LineWidthMenu::getEight
void getEight()
Definition: form_menus.h:181
TriggerModeMenu::TriggerModeMenu
TriggerModeMenu(QWidget *parent)
Definition: form_menus.h:960
TriggerModeMenu
Definition: form_menus.h:955
LineColorMenu::whichTrigger
void whichTrigger(int which, const QString &name)
gr::filter::firdes::WIN_HAMMING
Hamming window; max attenuation 53 dB.
Definition: firdes.h:47
OtherAction::~OtherAction
~OtherAction()
Definition: form_menus.h:498
LineWidthMenu::getNumActions
int getNumActions() const
Definition: form_menus.h:157
OtherDualAction::getTextDiag
void getTextDiag()
Definition: form_menus.h:568
LineStyleMenu::getDash
void getDash()
Definition: form_menus.h:245
LineMarkerMenu::getDiamond
void getDiamond()
Definition: form_menus.h:329
FFTSizeMenu::get05
void get05()
Definition: form_menus.h:652
TriggerSlopeMenu::getAction
QAction * getAction(gr::qtgui::trigger_slope slope)
Definition: form_menus.h:1077
PopupMenu
Definition: form_menus.h:1163
ColorMapMenu::getAction
QAction * getAction(int which)
Definition: form_menus.h:913
FFTWindowMenu::getNone
void getNone()
Definition: form_menus.h:796
LineWidthMenu::LineWidthMenu
LineWidthMenu(int which, QWidget *parent)
Definition: form_menus.h:122
PopupMenu::PopupMenu
PopupMenu(QString desc, QWidget *parent)
Definition: form_menus.h:1168
FFTSizeMenu::get13
void get13()
Definition: form_menus.h:660
LineWidthMenu::getOne
void getOne()
Definition: form_menus.h:174
FFTSizeMenu::getOther
void getOther(const QString &str)
Definition: form_menus.h:663
FFTWindowMenu::~FFTWindowMenu
~FFTWindowMenu()
Definition: form_menus.h:776
PopupMenu::~PopupMenu
~PopupMenu()
Definition: form_menus.h:1191
TriggerSlopeMenu::getPos
void getPos()
Definition: form_menus.h:1095
LineWidthMenu::getTen
void getTen()
Definition: form_menus.h:183
FFTSizeMenu::get10
void get10()
Definition: form_menus.h:657
LineColorMenu::getNumActions
int getNumActions() const
Definition: form_menus.h:78
TriggerSlopeMenu::TriggerSlopeMenu
TriggerSlopeMenu(QWidget *parent)
Definition: form_menus.h:1042
TriggerModeMenu::getNorm
void getNorm()
Definition: form_menus.h:1025
LineTitleAction
Definition: form_menus.h:413
FFTSizeMenu::get14
void get14()
Definition: form_menus.h:661
LineColorMenu::getBlack
void getBlack()
Definition: form_menus.h:98
TriggerModeMenu::getTag
void getTag()
Definition: form_menus.h:1026
gr::filter::firdes::WIN_RECTANGULAR
Basic rectangular window.
Definition: firdes.h:50
LineTitleAction::~LineTitleAction
~LineTitleAction()
Definition: form_menus.h:440
TriggerModeMenu::whichTrigger
void whichTrigger(gr::qtgui::trigger_mode mode)
NPointsMenu
Definition: form_menus.h:813
FFTSizeMenu::FFTSizeMenu
FFTSizeMenu(QWidget *parent)
Definition: form_menus.h:595
LineMarkerMenu::getNumActions
int getNumActions() const
Definition: form_menus.h:309
PopupMenu::whichTrigger
void whichTrigger(const QString data)
FFTSizeMenu::get08
void get08()
Definition: form_menus.h:655
LineMarkerMenu::getCircle
void getCircle()
Definition: form_menus.h:327
LineWidthMenu::getSix
void getSix()
Definition: form_menus.h:179
LineStyleMenu::~LineStyleMenu
~LineStyleMenu()
Definition: form_menus.h:223
TriggerChannelMenu::getNumActions
int getNumActions() const
Definition: form_menus.h:1129
TriggerSlopeMenu::getNumActions
int getNumActions() const
Definition: form_menus.h:1064
OtherAction
Definition: form_menus.h:470
LineStyleMenu::getDots
void getDots()
Definition: form_menus.h:246
TriggerSlopeMenu::getAction
QAction * getAction(int which)
Definition: form_menus.h:1069
FFTSizeMenu::getAction
QAction * getAction(int which)
Definition: form_menus.h:640
INTENSITY_COLOR_MAP_TYPE_BLACK_HOT
Definition: qtgui_types.h:142
LineColorMenu::getDarkGray
void getDarkGray()
Definition: form_menus.h:106
FFTWindowMenu::getHann
void getHann()
Definition: form_menus.h:798
qtgui_types.h
LineStyleMenu
Definition: form_menus.h:194
LineColorMenu::getGray
void getGray()
Definition: form_menus.h:102
gr::qtgui::TRIG_SLOPE_POS
Definition: gr-qtgui/include/gnuradio/qtgui/trigger_mode.h:37
gr::filter::firdes::WIN_KAISER
Kaiser window; max attenuation a function of beta, google it.
Definition: firdes.h:51
TriggerModeMenu::getFree
void getFree()
Definition: form_menus.h:1023
MarkerAlphaMenu
Definition: form_menus.h:351
LineStyleMenu::LineStyleMenu
LineStyleMenu(int which, QWidget *parent)
Definition: form_menus.h:199
TriggerModeMenu::getNumActions
int getNumActions() const
Definition: form_menus.h:986
TriggerSlopeMenu
Definition: form_menus.h:1037
LineColorMenu::getAction
QAction * getAction(int which)
Definition: form_menus.h:83
FFTAverageMenu
Definition: form_menus.h:678
LineMarkerMenu::getCross
void getCross()
Definition: form_menus.h:334
FFTSizeMenu::get06
void get06()
Definition: form_menus.h:653
LineColorMenu::getGreen
void getGreen()
Definition: form_menus.h:97
OtherDualAction
Definition: form_menus.h:525
NPointsMenu::~NPointsMenu
~NPointsMenu()
Definition: form_menus.h:841
OtherAction::getTextDiag
void getTextDiag()
Definition: form_menus.h:505
ColorMapMenu::getNumActions
int getNumActions() const
Definition: form_menus.h:908
gr::qtgui::TRIG_MODE_AUTO
Definition: gr-qtgui/include/gnuradio/qtgui/trigger_mode.h:31
LineWidthMenu::getNine
void getNine()
Definition: form_menus.h:182
trigger_mode.h
FFTWindowMenu::getBlackman
void getBlackman()
Definition: form_menus.h:799
MarkerAlphaMenu::~MarkerAlphaMenu
~MarkerAlphaMenu()
Definition: form_menus.h:378
TriggerChannelMenu::TriggerChannelMenu
TriggerChannelMenu(int nchans, QWidget *parent)
Definition: form_menus.h:1112
ColorMapMenu::getWhiteHot
void getWhiteHot()
Definition: form_menus.h:928
MarkerAlphaMenu::getNone
void getNone()
Definition: form_menus.h:398
FFTSizeMenu::get11
void get11()
Definition: form_menus.h:658
MarkerAlphaMenu::whichTrigger
void whichTrigger(int which, int)
INTENSITY_COLOR_MAP_TYPE_USER_DEFINED
Definition: qtgui_types.h:144
gr::filter::firdes::WIN_NONE
don't use a window
Definition: firdes.h:46
OtherDualAction::OtherDualAction
OtherDualAction(QString label0, QString label1, QWidget *parent)
Definition: form_menus.h:530
LineMarkerMenu::~LineMarkerMenu
~LineMarkerMenu()
Definition: form_menus.h:306
LineWidthMenu::~LineWidthMenu
~LineWidthMenu()
Definition: form_menus.h:154
TriggerModeMenu::getAction
QAction * getAction(gr::qtgui::trigger_mode mode)
Definition: form_menus.h:999
FFTAverageMenu::getOff
void getOff()
Definition: form_menus.h:726
FFTAverageMenu::getOther
void getOther(const QString &str)
Definition: form_menus.h:730
FFTSizeMenu::getNumActions
int getNumActions() const
Definition: form_menus.h:635
LineMarkerMenu::getVLine
void getVLine()
Definition: form_menus.h:337
FFTSizeMenu
Definition: form_menus.h:590
FFTAverageMenu::~FFTAverageMenu
~FFTAverageMenu()
Definition: form_menus.h:706
ColorMapMenu::~ColorMapMenu
~ColorMapMenu()
Definition: form_menus.h:905
FFTWindowMenu
Definition: form_menus.h:745
LineStyleMenu::whichTrigger
void whichTrigger(int which, Qt::PenStyle)
NPointsMenu::setDiagText
void setDiagText(const int npts)
Definition: form_menus.h:844
INTENSITY_COLOR_MAP_TYPE_WHITE_HOT
Definition: qtgui_types.h:141
gr::qtgui::TRIG_MODE_FREE
Definition: gr-qtgui/include/gnuradio/qtgui/trigger_mode.h:30
OtherDualAction::whichTrigger
void whichTrigger(const QString &text0, const QString &text1)
INTENSITY_COLOR_MAP_TYPE_INCANDESCENT
Definition: qtgui_types.h:143
gr::qtgui::trigger_slope
trigger_slope
Definition: gr-qtgui/include/gnuradio/qtgui/trigger_mode.h:36
gr::qtgui::trigger_mode
trigger_mode
Definition: gr-qtgui/include/gnuradio/qtgui/trigger_mode.h:29
FFTWindowMenu::getRectangular
void getRectangular()
Definition: form_menus.h:801
TriggerSlopeMenu::~TriggerSlopeMenu
~TriggerSlopeMenu()
Definition: form_menus.h:1061
OtherAction::whichTrigger
void whichTrigger(const QString &text)
FFTAverageMenu::getMedium
void getMedium()
Definition: form_menus.h:728
gr::qtgui::TRIG_MODE_TAG
Definition: gr-qtgui/include/gnuradio/qtgui/trigger_mode.h:33
PopupMenu::getTextDiag
void getTextDiag()
Definition: form_menus.h:1203
NPointsMenu::NPointsMenu
NPointsMenu(QWidget *parent)
Definition: form_menus.h:818
LineWidthMenu::getFour
void getFour()
Definition: form_menus.h:177
LineStyleMenu::getNone
void getNone()
Definition: form_menus.h:243
gr::filter::firdes::WIN_BLACKMAN
Blackman window; max attenuation 74 dB.
Definition: firdes.h:49
LineMarkerMenu::getTriangle
void getTriangle()
Definition: form_menus.h:330
TriggerChannelMenu::whichTrigger
void whichTrigger(int n)
ColorMapMenu::getOther
void getOther()
Definition: form_menus.h:932
TriggerChannelMenu::~TriggerChannelMenu
~TriggerChannelMenu()
Definition: form_menus.h:1126
LineMarkerMenu::LineMarkerMenu
LineMarkerMenu(int which, QWidget *parent)
Definition: form_menus.h:264
ColorMapMenu::whichTrigger
void whichTrigger(int which, const int type, const QColor &min_color=QColor(), const QColor &max_color=QColor())
FFTWindowMenu::getKaiser
void getKaiser()
Definition: form_menus.h:802
FFTAverageMenu::getNumActions
int getNumActions() const
Definition: form_menus.h:709
LineColorMenu::getCyan
void getCyan()
Definition: form_menus.h:99
LineTitleAction::whichTrigger
void whichTrigger(int which, const QString &text)
LineStyleMenu::getAction
QAction * getAction(int which)
Definition: form_menus.h:231
LineMarkerMenu::getNone
void getNone()
Definition: form_menus.h:326
MarkerAlphaMenu::getMedium
void getMedium()
Definition: form_menus.h:400
LineWidthMenu::getAction
QAction * getAction(int which)
Definition: form_menus.h:162
LineMarkerMenu::getXCross
void getXCross()
Definition: form_menus.h:335
FFTAverageMenu::getHigh
void getHigh()
Definition: form_menus.h:727
TriggerSlopeMenu::getNeg
void getNeg()
Definition: form_menus.h:1096
LineStyleMenu::getNumActions
int getNumActions() const
Definition: form_menus.h:226
FFTAverageMenu::whichTrigger
void whichTrigger(float alpha)
TriggerModeMenu::getAuto
void getAuto()
Definition: form_menus.h:1024
LineStyleMenu::getSolid
void getSolid()
Definition: form_menus.h:244
ColorMapMenu::getMultiColor
void getMultiColor()
Definition: form_menus.h:927
LineColorMenu::~LineColorMenu
~LineColorMenu()
Definition: form_menus.h:75
LineStyleMenu::getDashDot
void getDashDot()
Definition: form_menus.h:247
ColorMapMenu::getBlackHot
void getBlackHot()
Definition: form_menus.h:929
LineColorMenu::getRed
void getRed()
Definition: form_menus.h:96
FFTWindowMenu::FFTWindowMenu
FFTWindowMenu(QWidget *parent)
Definition: form_menus.h:750
LineStyleMenu::getDashDotDot
void getDashDotDot()
Definition: form_menus.h:248
LineMarkerMenu::getDTriangle
void getDTriangle()
Definition: form_menus.h:331
MarkerAlphaMenu::getNumActions
int getNumActions() const
Definition: form_menus.h:381
NPointsMenu::getTextDiag
void getTextDiag()
Definition: form_menus.h:853
MarkerAlphaMenu::MarkerAlphaMenu
MarkerAlphaMenu(int which, QWidget *parent)
Definition: form_menus.h:356
FFTWindowMenu::getHamming
void getHamming()
Definition: form_menus.h:797
LineWidthMenu::getSeven
void getSeven()
Definition: form_menus.h:180
FFTSizeMenu::get09
void get09()
Definition: form_menus.h:656
LineMarkerMenu::getRTriangle
void getRTriangle()
Definition: form_menus.h:333
ColorMapMenu::getIncandescent
void getIncandescent()
Definition: form_menus.h:930
LineWidthMenu
Definition: form_menus.h:117
FFTWindowMenu::getNumActions
int getNumActions() const
Definition: form_menus.h:779
LineMarkerMenu::getHLine
void getHLine()
Definition: form_menus.h:336
LineMarkerMenu::getStar2
void getStar2()
Definition: form_menus.h:339
LineWidthMenu::getFive
void getFive()
Definition: form_menus.h:178
OtherDualAction::~OtherDualAction
~OtherDualAction()
Definition: form_menus.h:561
LineMarkerMenu::getStar1
void getStar1()
Definition: form_menus.h:338
LineMarkerMenu
Definition: form_menus.h:259
LineColorMenu
Definition: form_menus.h:34
LineTitleAction::LineTitleAction
LineTitleAction(int which, QWidget *parent)
Definition: form_menus.h:418
FFTWindowMenu::getBlackmanharris
void getBlackmanharris()
Definition: form_menus.h:800
name
VOLK_API $kern pname $kern name
A function pointer to the dispatcher implementation.
LineMarkerMenu::getRect
void getRect()
Definition: form_menus.h:328
TriggerChannelMenu::getChannel
void getChannel()
Definition: form_menus.h:1147
LineWidthMenu::getThree
void getThree()
Definition: form_menus.h:176
LineColorMenu::getDarkGreen
void getDarkGreen()
Definition: form_menus.h:104
LineWidthMenu::getTwo
void getTwo()
Definition: form_menus.h:175
TriggerModeMenu::~TriggerModeMenu
~TriggerModeMenu()
Definition: form_menus.h:983
LineColorMenu::LineColorMenu
LineColorMenu(int which, QWidget *parent)
Definition: form_menus.h:39
FFTWindowMenu::whichTrigger
void whichTrigger(const gr::filter::firdes::win_type type)
PopupMenu::setText
void setText(QString s)
Definition: form_menus.h:1194
LineColorMenu::getMagenta
void getMagenta()
Definition: form_menus.h:100
MarkerAlphaMenu::getHigh
void getHigh()
Definition: form_menus.h:401
INTENSITY_COLOR_MAP_TYPE_MULTI_COLOR
Definition: qtgui_types.h:140
FFTSizeMenu::get07
void get07()
Definition: form_menus.h:654
gr::filter::firdes::WIN_BLACKMAN_hARRIS
Blackman-harris window.
Definition: firdes.h:52
gr::qtgui::TRIG_MODE_NORM
Definition: gr-qtgui/include/gnuradio/qtgui/trigger_mode.h:32
LineMarkerMenu::getLTriangle
void getLTriangle()
Definition: form_menus.h:332
ColorMapMenu
Definition: form_menus.h:874
FFTSizeMenu::get15
void get15()
Definition: form_menus.h:662
FFTSizeMenu::~FFTSizeMenu
~FFTSizeMenu()
Definition: form_menus.h:632
FFTSizeMenu::whichTrigger
void whichTrigger(int size)
MarkerAlphaMenu::getOff
void getOff()
Definition: form_menus.h:402
LineTitleAction::getTextDiag
void getTextDiag()
Definition: form_menus.h:447
TriggerChannelMenu
Definition: form_menus.h:1107
LineMarkerMenu::getAction
QAction * getAction(int which)
Definition: form_menus.h:314
gr::filter::firdes::win_type
win_type
Definition: firdes.h:45
FFTAverageMenu::getLow
void getLow()
Definition: form_menus.h:729
ColorMapMenu::ColorMapMenu
ColorMapMenu(int which, QWidget *parent)
Definition: form_menus.h:879
FFTAverageMenu::getAction
QAction * getAction(int which)
Definition: form_menus.h:714
TriggerSlopeMenu::whichTrigger
void whichTrigger(gr::qtgui::trigger_slope slope)
FFTAverageMenu::FFTAverageMenu
FFTAverageMenu(QWidget *parent)
Definition: form_menus.h:683
LineMarkerMenu::getHexagon
void getHexagon()
Definition: form_menus.h:340
FFTSizeMenu::get12
void get12()
Definition: form_menus.h:659
LineWidthMenu::whichTrigger
void whichTrigger(int which, int width)