# data file for the Fltk User Interface Designer (fluid)
version 1.0300 
i18n_type 1 
i18n_include "gettext.h" 
i18n_function _ 
header_name {.h} 
code_name {.cxx}
decl {\#include <config.h>} {private local
} 

decl {\#include <FL/Fl_Tooltip.H>} {private local
} 

decl {\#include <FL/Fl_Box.H>} {private local
} 

decl {\#include <FL/filename.H>} {private local
} 

decl {\#include <FL/Fl_File_Chooser.H>} {private local
} 

decl {\#include "main.h"} {private local
} 

decl {\#include "fl_digi.h"} {private local
} 

decl {\#include "dl_fldigi/dl_fldigi.h"} {private local
} 

decl {\#include "dl_fldigi/location.h"} {private local
} 

decl {\#include "dl_fldigi/flights.h"} {private local
} 

decl {\#include "dl_fldigi/hbtint.h"} {private local
} 

decl {\#include "soundconf.h"} {private local
} 

decl {\#include "soundconf.h"} {private local
} 

decl {\#include "globals.h"} {public local
} 

decl {\#include "modem.h"} {public local
} 

decl {\#include "configuration.h"} {public local
} 

decl {\#include "combo.h"} {public local
} 

decl {\#include "colorsfonts.h"} {private local
} 

decl {\#include "waterfall.h"} {private local
} 

decl {\#include "rigxml.h"} {private local
} 

decl {\#include "lookupcall.h"} {private local
} 

decl {\#include "icons.h"} {private local
} 

decl {\#include "Viewer.h"} {private local
} 

decl {\#include "pskrep.h"} {private global
} 

decl {\#include "flinput2.h"} {public local
} 

decl {\#include "flslider2.h"} {public local
} 

decl {\#include "flmisc.h"} {public local
} 

decl {\#include "logsupport.h"} {private local
} 

decl {\#include "notify.h"} {private local
} 

decl {\#include "debug.h"} {private local
} 

decl {\#include "status.h"} {private local
} 

decl {\#include "rx_extract.h"} {private local
} 

decl {extern void WefaxDestDirSet(Fl_File_Chooser *w, void *userdata);} {private local
} 

decl {extern void NvtxCatalogSet(Fl_File_Chooser *w, void *userdata);} {private local
} 

decl {\#if USE_HAMLIB
  \#include "hamlib.h"
\#endif} {private local
} 

decl {Fl_Double_Window *dlgConfig;} {public local
} 

decl {Mode_Browser* mode_browser;} {public local
} 

Function {set_qrzxml_buttons(Fl_Button* b)} {return_type void
} {
  code {Fl_Button* qrzbxml[] = { btnQRZXMLnotavailable, btnQRZcdrom, btnQRZsub,
                         btnHamcall,
                         btnCALLOOK, btnHamQTH};

for (size_t i = 0; i < sizeof(qrzbxml)/sizeof(*qrzbxml); i++)
	qrzbxml[i]->value(b == qrzbxml[i]);} {}
} 

Function {set_qrzweb_buttons(Fl_Button* b)} {return_type void
} {
  code {Fl_Button* qrzbweb[] = { btnQRZWEBnotavailable, btnQRZonline,
                              btnHAMCALLonline,
                              btnHamQTHonline };

for (size_t i = 0; i < sizeof(qrzbweb)/sizeof(*qrzbweb); i++)
	qrzbweb[i]->value(b == qrzbweb[i]);} {}
} 

Function {ConfigureDialog()} {open
} {
  code {static const char szShifts[]  = "23|85|160|170|182|200|240|350|425|600|_850|Custom";
static const char szBauds[]  = "45|45.45|50|56|75|100|110|150|200|300|600|1200";
static const char szSelBits[] = "5 (baudot)|7 (ascii)|8 (ascii)";
static const char szParity[]  = "none|even|odd|zero|one";
static const char szStopBits[] = "1|1.5|2";
static const char szOliviaTones[] = "2|4|8|16|32|64|128|256";
static const char szOliviaBandwidth[] = "125|250|500|1000|2000";
static const char szContestiaTones[] = "2|4|8|16|32|64|128|256";
static const char szContestiaBandwidth[] = "125|250|500|1000|2000";
static const char szBaudRates[] = "300|600|1200|2400|4800|9600|19200|38400|57600|115200|230400|460800";
static const char szProsigns[] = "~|%|&|+|=|{|}|<|>|[|]| ";} {}
  code {static const int flight_browser_columns[] = { 180, 160, 190 };} {}
  code {static const int payload_browser_columns[] = { 180, 350 };} {}
  Fl_Window {} {
    label {Fldigi configuration} open
    xywh {609 58 540 400} type Double color 45 selection_color 51 labelsize 18 align 80 non_modal visible
  } {
    Fl_Tabs tabsConfigure {open
      xywh {-5 0 596 372} color 50 selection_color 50
    } {
      Fl_Group tabOperator {
        label Operator
        callback {progdefaults.changed = true;} selected
        tooltip {Operator information} xywh {0 25 540 345} when 1
      } {
        Fl_Group {} {
          label Station open
          xywh {27 35 490 205} box ENGRAVED_FRAME align 21
        } {
          Fl_Input inpMyCallsign {
            label {Callsign:}
            callback {if (progdefaults.THORsecText.empty()) {
progdefaults.THORsecText = o->value();
progdefaults.THORsecText.append(" ");
txtTHORSecondary->value(progdefaults.THORsecText.c_str());
}
if (progdefaults.secText.empty()) {
progdefaults.secText = o->value();
progdefaults.secText.append(" ");
txtSecondary->value(progdefaults.secText.c_str());
}
progdefaults.myCall = o->value();
update_main_title();
notify_change_callsign();
progdefaults.changed = true;

dl_fldigi::changed(dl_fldigi::CH_UTHR_SETTINGS);
btnApplyConfig->activate();}
            tooltip {Operators callsign} xywh {132 64 110 24}
            code0 {inpMyCallsign->labelsize(FL_NORMAL_SIZE);}
            class Fl_Input2
          }
          Fl_Input inpMyName {
            label {Name:}
            callback {progdefaults.myName = o->value();
progdefaults.changed = true;
dl_fldigi::changed(dl_fldigi::CH_INFO);
btnApplyConfig->activate();}
            tooltip {Operators name} xywh {312 64 140 24}
            code0 {inpMyName->labelsize(FL_NORMAL_SIZE);}
            class Fl_Input2
          }
          Fl_Input inpMyQth {
            label {QTH:}
            callback {progdefaults.myQth = o->value();
progdefaults.changed = true;
dl_fldigi::changed(dl_fldigi::CH_INFO);
btnApplyConfig->activate();}
            tooltip {Operators QTH} xywh {132 98 320 24}
            code0 {inpMyQth->labelsize(FL_NORMAL_SIZE);}
            class Fl_Input2
          }
          Fl_Input inpMyLocator {
            label {Locator:}
            callback {progdefaults.myLocator = o->value();
progdefaults.changed = true;}
            tooltip {Maidenhead locator as in EM64qv} xywh {132 133 85 24}
            code0 {inpMyLocator->labelsize(FL_NORMAL_SIZE);}
            class Fl_Input2
          }
          Fl_Input inpMyAntenna {
            label {Antenna:}
            callback {progdefaults.myAntenna = o->value();
progdefaults.changed = true;
dl_fldigi::changed(dl_fldigi::CH_INFO);
btnApplyConfig->activate();}
            tooltip {Short description of antenna} xywh {132 167 320 24}
            code0 {inpMyAntenna->labelsize(FL_NORMAL_SIZE);}
            class Fl_Input2
          }
          Fl_Input MyRadio {
            label {Radio:}
            callback {progdefaults.myRadio = o->value();
progdefaults.changed = true;
dl_fldigi::changed(dl_fldigi::CH_INFO);
btnApplyConfig->activate();}
            xywh {132 200 320 25}
            code0 {o->value(progdefaults.myRadio.c_str());}
          }
        }
        Fl_Group grpNoise {
          label {Test Signal - Do NOT use with transmitter} open
          xywh {27 203 490 165} box ENGRAVED_FRAME align 21 hide
        } {
          Fl_Check_Button btnNoiseOn {
            label {Noise on}
            callback {progdefaults.noise = o->value();}
            xywh {65 241 70 15} down_box DOWN_BOX
            code0 {o->value(progdefaults.noise);}
          }
          Fl_Counter noiseDB {
            label dB
            callback {progdefaults.s2n = o->value();}
            xywh {62 279 89 21} type Simple align 4 minimum -18 maximum 60 step 1 value 20
            code0 {o->value(progdefaults.s2n);}
            class Fl_Counter2
          }
        }
      }
      Fl_Group tabUI {
        label UI open
        xywh {0 25 540 346} hide
      } {
        Fl_Tabs tabsUI {open
          xywh {0 25 540 346} selection_color 50
        } {
          Fl_Group tabBrowser {
            label Browser open
            xywh {0 50 540 320}
          } {
            Fl_Group {} {open
              xywh {24 59 496 300} box ENGRAVED_FRAME
            } {
              Fl_Spinner cntChannels {
                label {Channels, first channel starts at waterfall lower limit}
                callback {progdefaults.VIEWERchannels = (int)(o->value());
initViewer();}
                tooltip {Change \# of psk viewer channels} xywh {40 69 50 24} align 8 maximum 30 value 30
                code0 {o->minimum(5); o->maximum(30); o->step(1);}
                code1 {o->value(progdefaults.VIEWERchannels);}
                code2 {o->labelsize(FL_NORMAL_SIZE);}
                class Fl_Spinner2
              }
              Fl_Spinner cntTimeout {
                label {Inactivity timeout}
                callback {progdefaults.VIEWERtimeout = (int)(o->value());
progdefaults.changed = true;}
                tooltip {Clear channel text after
\# seconds of inactivity} xywh {40 105 50 24} align 8 value 10
                code0 {o->minimum(1); o->maximum(180); o->step(1);}
                code1 {o->value(progdefaults.VIEWERtimeout);}
                code2 {o->labelsize(FL_NORMAL_SIZE);}
                class Fl_Spinner2
              }
              Fl_Choice mnuViewerLabel {
                label {Channel label}
                callback {progdefaults.VIEWERlabeltype = o->value();
initViewer();
progdefaults.changed = true;} open
                tooltip {Appearance of label on each channel} xywh {40 145 150 24} down_box BORDER_BOX align 8
                code0 {mnuViewerLabel->add(_("None")); mnuViewerLabel->add(_("Audio frequency"));}
                code1 {mnuViewerLabel->add(_("Radio frequency")); mnuViewerLabel->add(_("Channel number"));}
                code3 {mnuViewerLabel->value(progdefaults.VIEWERlabeltype);}
              } {}
              Fl_Button btnViewerFont {
                label {Font...}
                callback {font_browser->fontNumber(progdefaults.ViewerFontnbr);
font_browser->fontSize(progdefaults.ViewerFontsize);
font_browser->fontColor(FL_FOREGROUND_COLOR);
font_browser->fontFilter(Font_Browser::FIXED_WIDTH);
font_browser->callback(cbViewerFontBrowser);
font_browser->show();}
                tooltip {select browser font} xywh {325 145 70 24}
              }
              Fl_Check_Button btnFixedIntervals {
                label {Fixed Intervals}
                callback {progdefaults.VIEWERfixed = o->value();
progdefaults.changed = true;
initViewer();}
                tooltip {Force channel spacing to even 100 Hz increments} xywh {230 131 165 20} down_box DOWN_BOX value 1 hide
                code0 {o->value(progdefaults.VIEWERfixed);}
              }
              Fl_Check_Button btnMarquee {
                label {Continuous scrolling}
                callback {progdefaults.VIEWERmarquee = o->value();
progdefaults.changed = true;
initViewer();}
                tooltip {ON - Marquee style
OFF - Clear & restart} xywh {40 183 165 20} down_box DOWN_BOX
                code0 {o->value(progdefaults.VIEWERmarquee);}
              }
              Fl_Check_Button btnAscend {
                label {Lowest freq on bottom of viewer}
                callback {progdefaults.VIEWERascend = o->value();
progdefaults.changed = true;
initViewer();}
                tooltip {Change positions of low to high channels} xywh {40 207 253 20} down_box DOWN_BOX
                code0 {o->value(progdefaults.VIEWERascend);}
              }
              Fl_Check_Button btnBrowserHistory {
                label {Play back history when active channel selected}
                callback {progdefaults.VIEWERhistory = o->value();
progdefaults.changed = true;}
                tooltip {Audio stream history decoded on selected signal} xywh {40 232 356 20} down_box DOWN_BOX
                code0 {o->value(progdefaults.VIEWERhistory);}
              }
              Fl_Group {} {
                label {Detection Level Colors} open
                xywh {42 265 219 60} box ENGRAVED_FRAME align 17
              } {
                Fl_Button bwsrSliderColor {
                  label Backgnd
                  callback {uchar r, g, b;
    r = progdefaults.bwsrSliderColor.R;
    g = progdefaults.bwsrSliderColor.G;
    b = progdefaults.bwsrSliderColor.B;

    if (fl_color_chooser("Slider Color", r, g, b) == 0)
        return;
    progdefaults.bwsrSliderColor.R = r;
    progdefaults.bwsrSliderColor.G = g;
    progdefaults.bwsrSliderColor.B = b;
    o->color(fl_rgb_color(r,g,b));
    o->redraw();
    sldrViewerSquelch->color(fl_rgb_color(r,g,b));
    sldrViewerSquelch->redraw();
    mvsquelch->color(fl_rgb_color(r,g,b));
    mvsquelch->redraw();
    
    progdefaults.changed = true;}
                  tooltip {Background color of signal viewer squelch control} xywh {65 288 80 24}
                  code0 {bwsrSliderColor->color(fl_rgb_color(progdefaults.bwsrSliderColor.R, progdefaults.bwsrSliderColor.G,progdefaults.bwsrSliderColor.B));}
                }
                Fl_Button bwsrSldrSelColor {
                  label Button
                  callback {uchar r, g, b;
    r = progdefaults.bwsrSldrSelColor.R;
    g = progdefaults.bwsrSldrSelColor.G;
    b = progdefaults.bwsrSldrSelColor.B;

    if (fl_color_chooser("Button Color", r, g, b) == 0)
        return;
    progdefaults.bwsrSldrSelColor.R = r;
    progdefaults.bwsrSldrSelColor.G = g;
    progdefaults.bwsrSldrSelColor.B = b;
    o->color(fl_rgb_color(r,g,b));
    o->redraw();
    sldrViewerSquelch->selection_color(fl_rgb_color(r,g,b));
    sldrViewerSquelch->redraw();
    mvsquelch->selection_color(fl_rgb_color(r,g,b));
    mvsquelch->redraw();
    
    progdefaults.changed = true;}
                  tooltip {Slider hilite color of signal viewer squelch control} xywh {157 288 80 24}
                  code0 {bwsrSldrSelColor->color(fl_rgb_color(progdefaults.bwsrSldrSelColor.R, progdefaults.bwsrSldrSelColor.G,progdefaults.bwsrSliderColor.B));}
                }
              }
            }
          }
          Fl_Group tabContest {
            label Contest open
            xywh {0 50 540 320} hide
          } {
            Fl_Group {} {
              label Exchanges open
              xywh {25 64 490 80} box ENGRAVED_FRAME align 21
            } {
              Fl_Box lblSend {
                label {Send:}
                xywh {57 99 55 20}
              }
              Fl_Input inpSend1 {
                label {Exchange Out}
                callback {progdefaults.myXchg=o->value();
progdefaults.changed = true;}
                tooltip {free form exchange} xywh {115 99 140 20} align 1
                code0 {o->value(progdefaults.myXchg.c_str());}
                code1 {inpSend1->labelsize(FL_NORMAL_SIZE);}
                class Fl_Input2
              }
              Fl_Check_Button btn599 {
                label {RST always 599}
                callback {progdefaults.fixed599 = o->value();
progdefaults.changed = true;}
                tooltip {Force RST in/out to 599} xywh {330 84 130 20} down_box DOWN_BOX
                code0 {o->value(progdefaults.fixed599);}
              }
              Fl_Check_Button btnCutNbrs {
                label {Send CW cut numbers}
                callback {progdefaults.cutnbrs=o->value();
progdefaults.changed = true;}
                tooltip {0 = T; 9 = N} xywh {330 114 180 20} down_box DOWN_BOX
                code0 {o->value(progdefaults.cutnbrs);}
              }
            }
            Fl_Group {} {
              label {Serial number} open
              xywh {25 154 490 65} box ENGRAVED_FRAME align 21
            } {
              Fl_Check_Button btnUseLeadingZeros {
                label {Use leading zeros}
                callback {progdefaults.UseLeadingZeros = o->value();
progdefaults.changed = true;}
                tooltip {Insert leading zeros into Xmtd serial number} xywh {46 180 154 20} down_box DOWN_BOX value 1
              }
              Fl_Value_Input nbrContestStart {
                label Start
                callback {progdefaults.ContestStart = (int)o->value();
progdefaults.changed = true;}
                tooltip {Starting number} xywh {241 180 45 20} align 1 maximum 10000 step 1
                code0 {o->value(progdefaults.ContestStart);}
                class Fl_Value_Input2
              }
              Fl_Value_Input nbrContestDigits {
                label Digits
                callback {progdefaults.ContestDigits = (int)o->value();
progdefaults.changed = true;}
                tooltip {Number of digits in serial number} xywh {323 179 45 20} align 1 minimum 1 maximum 5 step 1 value 3
                class Fl_Value_Input2
              }
              Fl_Button btnResetSerNbr {
                label Reset
                callback {cb_ResetSerNbr();}
                tooltip {Initialize the QSO logging fields} xywh {415 180 70 20}
              }
            }
            Fl_Group {} {
              label {Duplicate check, CALL plus} open
              xywh {25 229 490 130} box ENGRAVED_FRAME align 21
            } {
              Fl_Light_Button btnDupCheckOn {
                label {On/Off}
                callback {progdefaults.EnableDupCheck = o->value();
progdefaults.changed = true;}
                tooltip {Check for duplicates} xywh {35 259 74 20} selection_color 2
                code0 {o->value(progdefaults.EnableDupCheck);}
              }
              Fl_Check_Button btnDupBand {
                label Band
                callback {progdefaults.dupband = o->value();
progdefaults.changed = true;}
                tooltip {Bands must match} xywh {176 259 70 20} down_box DOWN_BOX
                code0 {o->value(progdefaults.dupband);}
              }
              Fl_Check_Button btnDupMode {
                label Mode
                callback {progdefaults.dupmode = o->value();
progdefaults.changed = true;}
                tooltip {Mode must match} xywh {296 259 70 20} down_box DOWN_BOX
                code0 {o->value(progdefaults.dupmode);}
              }
              Fl_Check_Button btnDupState {
                label State
                callback {progdefaults.dupstate = o->value();
progdefaults.changed = true;}
                tooltip {State must match} xywh {415 259 70 20} down_box DOWN_BOX
                code0 {o->value(progdefaults.dupstate);}
              }
              Fl_Check_Button btnDupXchg1 {
                label {Exchange In}
                callback {progdefaults.dupxchg1 = o->value();
progdefaults.changed = true;}
                tooltip {free form 1 must match} xywh {176 287 105 20} down_box DOWN_BOX
                code0 {o->value(progdefaults.dupxchg1);}
              }
              Fl_Check_Button btnDupTimeSpan {
                label {Time span over}
                callback {progdefaults.duptimespan=(int)o->value();
progdefaults.changed = true;}
                tooltip {QSO must not occur within a time period of} xywh {176 317 129 20} down_box DOWN_BOX
                code0 {o->value(progdefaults.duptimespan);}
              }
              Fl_Value_Input nbrTimeSpan {
                label minutes
                callback {progdefaults.timespan = (int)o->value();
progdefaults.changed = true;}
                tooltip {Enter time span in minutes} xywh {305 317 53 20} align 8 maximum 1440 step 1 value 120
                code0 {o->value(progdefaults.timespan);}
                class Fl_Value_Input2
              }
              Fl_Button btnDupColor {
                label {Dup Color}
                callback {fl_color_chooser("Dup Check", 
  progdefaults.dup_color.R, 
  progdefaults.dup_color.G, 
  progdefaults.dup_color.B);
o->color(
  fl_rgb_color(
    progdefaults.dup_color.R,
    progdefaults.dup_color.G,
    progdefaults.dup_color.B));
o->redraw();
progdefaults.changed = true;}
                tooltip {Left click to select dup color} xywh {35 286 90 22} box DOWN_BOX down_box DOWN_BOX color 7 selection_color 7
                code0 {o->color(fl_rgb_color(progdefaults.dup_color.R, progdefaults.dup_color.G, progdefaults.dup_color.B));}
                code1 {\#include <FL/Fl_Color_Chooser.H>}
              }
            }
          }
          Fl_Group tabUserInterface {
            label General open
            xywh {0 50 540 320} hide
          } {
            Fl_Group {} {open
              xywh {21 55 496 76} box ENGRAVED_FRAME
            } {
              Fl_Check_Button btnShowTooltips {
                label {Show tooltips}
                callback {progdefaults.tooltips = o->value();
Fl_Tooltip::enable(progdefaults.tooltips);
progdefaults.changed = true;}
                tooltip {Enable / disable tooltips} xywh {39 68 120 20} down_box DOWN_BOX value 1
                code0 {o->value(progdefaults.tooltips);}
              }
              Fl_Check_Button chkMenuIcons {
                label {Show menu icons}
                callback {progdefaults.menuicons = o->value();
toggle_icon_labels();
progdefaults.changed = true;}
                tooltip {Enable / disable icons on menus} xywh {174 68 150 20} down_box DOWN_BOX
                code0 {o->value(progdefaults.menuicons);}
              }
              Fl_Choice mnuScheme {
                label {UI scheme}
                callback {progdefaults.ui_scheme = o->text();
    Fl::scheme(progdefaults.ui_scheme.c_str());

    progdefaults.changed = true;} open
                tooltip {Change application look and feel} xywh {174 97 80 20} down_box BORDER_BOX align 8
                code0 {mnuScheme->add("base");}
                code1 {mnuScheme->add("gtk+");}
                code2 {mnuScheme->add("plastic");}
                code3 {mnuScheme->value(mnuScheme->find_item(progdefaults.ui_scheme.c_str()));}
              } {}
              Fl_Button bVisibleModes {
                label {Visible modes}
                callback {mode_browser->label(o->label());
mode_browser->callback(toggle_visible_modes);
mode_browser->show(&progdefaults.visible_modes);
progdefaults.changed = true;}
                tooltip {Select modes for menu access} xywh {39 97 110 20}
              }
              Fl_Choice mnuLang {
                label {UI language}
                callback {progdefaults.ui_language = o->value();
progdefaults.changed = true;} open
                tooltip {Changes take effect on next program startup} xywh {384 97 110 20} down_box BORDER_BOX align 5
              } {}
            }
            Fl_Group {} {open
              xywh {21 133 496 60} box ENGRAVED_FRAME align 21
            } {
              Fl_Check_Button btn_rx_lowercase {
                label {Print CW / RTTY / THROB / CONTESTIA in lowercase}
                callback {progdefaults.rx_lowercase = o->value();
progdefaults.changed = true;}
                xywh {44 150 389 20} down_box DOWN_BOX
                code0 {o->value(progdefaults.rx_lowercase);}
              }
            }
            Fl_Group {} {
              label {Exit prompts} open
              xywh {21 195 496 114} box ENGRAVED_FRAME align 21
            } {
              Fl_Check_Button btn_save_config_on_exit {
                label {Prompt to save Configuration}
                callback {progdefaults.SaveConfig = o->value();
progdefaults.changed = true;}
                xywh {56 261 233 20} down_box DOWN_BOX
                code0 {o->value(progdefaults.SaveConfig);}
              }
              Fl_Check_Button btn2_save_macros_on_exit {
                label {Prompt to save macro file}
                callback {btn_save_macros_on_exit->value(o->value());
progdefaults.SaveMacros = o->value();
progdefaults.changed = true;}
                tooltip {Write current macro set on program exit} xywh {56 287 233 20} down_box DOWN_BOX
                code0 {o->value(progdefaults.SaveMacros);}
              }
              Fl_Check_Button btn2NagMe {
                label {Prompt to save log}
                callback {btnNagMe->value(o->value());
progdefaults.NagMe=o->value();
progdefaults.changed = true;}
                tooltip {Bug me about saving log entries} xywh {298 261 166 20} down_box DOWN_BOX
                code0 {o->value(progdefaults.NagMe);}
              }
              Fl_Box {} {
                label {Exit prompts active only when File/Exit menu item selected.
Not active if window decoration close button pressed.}
                xywh {61 211 436 47} box BORDER_BOX align 20
              }
            }
            Fl_Group {} {
              label {Check for updates} open
              xywh {21 311 496 56} box ENGRAVED_FRAME align 21
            } {
              Fl_Check_Button btn_check_for_updates {
                label {Check for updates when online}
                callback {progdefaults.check_for_updates = o->value();
progdefaults.changed = true;}
                xywh {56 335 324 20} down_box DOWN_BOX
                code0 {o->value(progdefaults.check_for_updates);}
              }
            }
          }
          Fl_Group tabLogServer {
            label Logging open
            xywh {0 50 540 320} hide
          } {
            Fl_Group {} {
              label {Client/Server Logbook} open
              xywh {25 313 496 55} box ENGRAVED_FRAME align 21
            } {
              Fl_Input xmllogServerAddress {
                label {Address:}
                callback {progdefaults.xmllog_address = o->value();}
                tooltip {Enter URL address of server} xywh {122 334 100 24}
                code0 {o->value(progdefaults.xmllog_address.c_str());}
              }
              Fl_Input xmllogServerPort {
                label {Port:}
                callback {progdefaults.xmllog_port = o->value();}
                tooltip {Enter Port \# assigned to server} xywh {280 334 70 24}
                code0 {o->value(progdefaults.xmllog_port.c_str());}
              }
              Fl_Button btn_reconnect_log_server {
                label Reconnect
                callback {progdefaults.xml_logbook = true;
connect_to_log_server();}
                xywh {383 334 115 24}
              }
            }
            Fl_Group {} {
              label {QSO logging} open
              xywh {25 57 496 180} box ENGRAVED_FRAME align 21
            } {
              Fl_Check_Button btnNagMe {
                label {Prompt to save log on exit}
                callback {btn2NagMe->value(o->value());
progdefaults.NagMe=o->value();
progdefaults.changed = true;}
                tooltip {Bug me about saving log entries} xywh {42 79 236 20} down_box DOWN_BOX
                code0 {o->value(progdefaults.NagMe);}
              }
              Fl_Check_Button btnClearOnSave {
                label {Clear on save}
                callback {progdefaults.ClearOnSave=o->value();
progdefaults.changed = true;}
                tooltip {Clear log entries after saving or using macro <LOG>} xywh {42 104 236 20} down_box DOWN_BOX
                code0 {o->value(progdefaults.ClearOnSave);}
              }
              Fl_Check_Button btnCallUpperCase {
                label {Convert callsign to upper case}
                callback {progdefaults.calluppercase = o->value();
progdefaults.changed = true;}
                tooltip {Force callsign field to UPPERCASE} xywh {42 130 236 20} down_box DOWN_BOX
                code0 {o->value(progdefaults.calluppercase);}
              }
              Fl_Check_Button btnAutoFillQSO {
                label {Auto-fill Country and Azimuth}
                callback {progdefaults.autofill_qso_fields = o->value();
progdefaults.changed = true;}
                tooltip {Fill in Country / Azimuth using cty.dat information} xywh {42 155 236 20} down_box DOWN_BOX
                code0 {o->value(progdefaults.autofill_qso_fields);}
              }
              Fl_Check_Button btnDateTimeSort {
                label {Sort by Date/Time OFF}
                callback {progdefaults.sort_date_time_off = o->value();
progdefaults.changed = true;
reload_browser();}
                tooltip {Sort by date/time OFF - effects all ADIF/Cabrillo reports} xywh {295 79 190 20} down_box DOWN_BOX
                code0 {o->value(progdefaults.sort_date_time_off);}
              }
              Fl_Check_Button btndate_time_force {
                label {Date time ON == OFF}
                callback {progdefaults.force_date_time = o->value();
progdefaults.changed = true;}
                tooltip {Force date/time ON == date/time OFF} xywh {295 104 190 20} down_box DOWN_BOX
                code0 {o->value(progdefaults.force_date_time);}
              }
              Fl_Check_Button btnRSTindefault {
                label {Default RST in to 599}
                callback {progdefaults.RSTin_default = o->value();
progdefaults.changed = true;}
                tooltip {Clear log controls sets RST in to 599} xywh {295 129 186 20} down_box DOWN_BOX
                code0 {o->value(progdefaults.RSTin_default);}
              }
              Fl_Check_Button btnRSTdefault {
                label {Default RST out to 599}
                callback {progdefaults.RSTdefault = o->value();
progdefaults.changed = true;}
                tooltip {Clear log controls sets RST out to 599} xywh {295 155 184 20} down_box DOWN_BOX
                code0 {o->value(progdefaults.RSTdefault);}
              }
              Fl_Input txt_cty_dat_pathname {
                label {cty.dat pathname}
                callback {progdefaults.cty_dat_pathname = o->value();
progdefaults.changed = true;}
                tooltip {Enter full path-filename for cty.dat} xywh {162 178 346 24} when 1
                code0 {o->value(progdefaults.cty_dat_pathname.c_str());}
                code1 {\#include "dxcc.h"}
                class Fl_Input2
              }
              Fl_Button btn_select_cty_dat {
                label Browse
                callback {select_cty_dat_pathname();}
                tooltip {Locate cty.dat file} xywh {43 207 75 24}
              }
              Fl_Button btn_default_cty_dat {
                label Default
                callback {default_cty_dat_pathname();}
                tooltip {Restore cty.dat default folder} xywh {138 207 75 24}
              }
              Fl_Button btn_reload_cty_dat {
                label Reload
                callback {reload_cty_dat();}
                tooltip {Reload cty.dat} xywh {233 207 75 24}
              }
              Fl_Input inpMyPower {
                label {Transmit Power}
                callback {progdefaults.mytxpower = o->value();
progdefaults.changed = true;}
                tooltip {Tx power used for logbook entries} xywh {458 207 50 24}
                code0 {o->value(progdefaults.mytxpower.c_str());}
                code1 {o->labelsize(FL_NORMAL_SIZE);}
                class Fl_Input2
              }
            }
            Fl_Group {} {
              label {Rx Text Capture} open
              xywh {25 238 496 74} box ENGRAVED_FRAME align 21
            } {
              Fl_Check_Button btnRXClicks {
                label {Double-click to capture}
                callback {progdefaults.rxtext_clicks_qso_data = o->value();
progdefaults.changed = true;}
                tooltip {Enable if you cannot use the middle mouse button} xywh {48 285 191 20} down_box DOWN_BOX
                code0 {o->value(progdefaults.rxtext_clicks_qso_data);}
              }
              Fl_Check_Button btnRXTooltips {
                label {callsign tooltips in received text}
                callback {progdefaults.rxtext_tooltips = o->value();
progdefaults.changed = true;}
                tooltip {Popup info after a 2 second hover on a callsign} xywh {250 285 254 20} down_box DOWN_BOX
                code0 {o->value(progdefaults.rxtext_tooltips);}
              }
              Fl_Input inpNonword {
                label {Word delimiters}
                callback {progdefaults.nonwordchars = o->value();
progdefaults.changed = true;}
                tooltip {RX text QSO data entry is bounded by the non-word characters
defined here. Tab and newline are automatically included.} xywh {167 258 279 24} textfont 4
                code0 {o->value(progdefaults.nonwordchars.c_str());}
                code1 {o->labelsize(FL_NORMAL_SIZE);}
                class Fl_Input2
              }
            }
          }
          Fl_Group tabMBars {
            label Macros open
            xywh {0 50 540 320} hide
          } {
            Fl_Group {} {open
              xywh {18 250 496 40} box ENGRAVED_FRAME
            } {
              Fl_Check_Button btnMacroMouseWheel {
                label {Mouse wheel active on macro buttons}
                callback {progdefaults.macro_wheel = o->value();
progdefaults.changed = true;}
                tooltip {enable mouse wheel control of macro bar} xywh {28 259 296 20} down_box DOWN_BOX
                code0 {o->value(progdefaults.macro_wheel);}
              }
            }
            Fl_Group {} {
              label {Number and position of macro bars} open
              xywh {18 54 496 195} box ENGRAVED_FRAME align 21
            } {
              Fl_Round_Button btn_oneA {
                label {One bar (above waterfall)}
                callback {progdefaults.mbar2_pos = 0;
progdefaults.mbar1_pos = true;
progdefaults.changed = true;
set_macroLabels();
UI_select();}
                xywh {28 84 220 20} type Radio down_box ROUND_DOWN_BOX
              }
              Fl_Round_Button btn_oneB {
                label {One bar (below waterfall)}
                callback {progdefaults.mbar2_pos = 0;
progdefaults.mbar1_pos = false;
progdefaults.changed = true;
set_macroLabels();
UI_select();}
                xywh {28 114 220 20} type Radio down_box ROUND_DOWN_BOX
              }
              Fl_Round_Button btn_twoA {
                label {Two bars (scheme 1)}
                callback {progdefaults.mbar2_pos = 1;
progdefaults.mbar1_pos = true;
progdefaults.changed = true;
set_macroLabels();
UI_select();}
                xywh {28 144 220 20} type Radio down_box ROUND_DOWN_BOX
              }
              Fl_Round_Button btn_twoB {
                label {Two bars (scheme 2)}
                callback {progdefaults.mbar2_pos = 2;
progdefaults.mbar1_pos = true;
progdefaults.changed = true;
set_macroLabels();
UI_select();}
                xywh {258 144 219 20} type Radio down_box ROUND_DOWN_BOX
              }
              Fl_Round_Button btn_twoC {
                label {Two bars (scheme 3)}
                callback {progdefaults.mbar2_pos = 3;
progdefaults.mbar1_pos = true;
progdefaults.changed = true;
set_macroLabels();
UI_select();}
                xywh {28 174 220 20} type Radio down_box ROUND_DOWN_BOX
              }
              Fl_Round_Button btn_twoD {
                label {Two bars (scheme 4)}
                callback {progdefaults.mbar2_pos = 1;
progdefaults.mbar1_pos = false;
progdefaults.changed = true;
set_macroLabels();
UI_select();}
                xywh {258 174 220 20} type Radio down_box ROUND_DOWN_BOX
              }
              Fl_Round_Button btn_twoE {
                label {Two bars (scheme 5)}
                callback {progdefaults.mbar2_pos = 2;
progdefaults.mbar1_pos = false;
progdefaults.changed = true;
set_macroLabels();
UI_select();}
                xywh {28 204 220 20} type Radio down_box ROUND_DOWN_BOX
              }
              Fl_Round_Button btn_twoF {
                label {Two bars (scheme 6)}
                callback {progdefaults.mbar2_pos = 3;
progdefaults.mbar1_pos = false;
progdefaults.changed = true;
set_macroLabels();
UI_select();}
                xywh {258 204 220 20} type Radio down_box ROUND_DOWN_BOX
              }
            }
            Fl_Group {} {open
              xywh {18 292 496 76} box ENGRAVED_FRAME
            } {
              Fl_Check_Button btnUseLastMacro {
                label {Load last used macro file on startup}
                callback {progdefaults.UseLastMacro = o->value();
update_main_title();
progdefaults.changed = true;}
                tooltip {ON - use last set of macros
OFF - use default set} xywh {28 298 277 20} down_box DOWN_BOX
                code0 {o->value(progdefaults.UseLastMacro);}
              }
              Fl_Check_Button btnDisplayMacroFilename {
                label {Display macro filename on startup}
                callback {progdefaults.DisplayMacroFilename = o->value();
progdefaults.changed = true;}
                tooltip {The filename is written to the RX text area} xywh {28 320 277 20} down_box DOWN_BOX
                code0 {o->value(progdefaults.DisplayMacroFilename);}
              }
              Fl_Check_Button btn_save_macros_on_exit {
                label {Prompt to save macro file when closing}
                callback {btn2_save_macros_on_exit->value(o->value());
progdefaults.SaveMacros = o->value();
progdefaults.changed = true;}
                tooltip {Write current macro set on program exit} xywh {28 342 305 20} down_box DOWN_BOX
                code0 {o->value(progdefaults.SaveMacros);}
              }
            }
          }
          Fl_Group tabWF_UI {
            label {WF Ctrls} open
            xywh {0 50 540 320} hide
          } {
            Fl_Group {} {open
              xywh {23 71 496 253} box ENGRAVED_BOX
            } {
              Fl_Box {} {
                label {Enable check box to show each respective operator control}
                xywh {52 78 446 25} box FLAT_BOX align 16
              }
              Fl_Check_Button btnWF_UIrev {
                label Reverse
                callback {progdefaults.WF_UIrev = o->value();
progdefaults.changed = true;
WF_UI();}
                xywh {79 111 150 20} down_box DOWN_BOX value 1
                code0 {o->value(progdefaults.WF_UIrev);}
              }
              Fl_Check_Button btnWF_UIx1 {
                label {WF Magnification}
                callback {progdefaults.WF_UIx1 = o->value();
progdefaults.changed = true;
WF_UI();}
                xywh {298 111 162 20} down_box DOWN_BOX value 1
                code0 {o->value(progdefaults.WF_UIx1);}
              }
              Fl_Check_Button btnWF_UIwfcarrier {
                label {WF carrier}
                callback {progdefaults.WF_UIwfcarrier = o->value();
progdefaults.changed = true;
WF_UI();}
                xywh {79 142 150 20} down_box DOWN_BOX value 1
                code0 {o->value(progdefaults.WF_UIwfcarrier);}
              }
              Fl_Check_Button btnWF_UIwfshift {
                label {WF Shift Controls}
                callback {progdefaults.WF_UIwfshift = o->value();
progdefaults.changed = true;
WF_UI();}
                xywh {298 142 150 20} down_box DOWN_BOX value 1
                code0 {o->value(progdefaults.WF_UIwfshift);}
              }
              Fl_Check_Button btnWF_UIwfreflevel {
                label {WF ref level}
                callback {progdefaults.WF_UIwfreflevel = o->value();
progdefaults.changed = true;
WF_UI();}
                xywh {79 174 150 20} down_box DOWN_BOX value 1
                code0 {o->value(progdefaults.WF_UIwfreflevel);}
              }
              Fl_Check_Button btnWF_UIwfdrop {
                label {WF drop rate}
                callback {progdefaults.WF_UIwfdrop = o->value();
progdefaults.changed = true;
WF_UI();}
                xywh {298 174 150 20} down_box DOWN_BOX value 1
                code0 {o->value(progdefaults.WF_UIwfdrop);}
              }
              Fl_Check_Button btnWF_UIwfampspan {
                label {WF amp span}
                callback {progdefaults.WF_UIwfampspan = o->value();
progdefaults.changed = true;
WF_UI();}
                xywh {79 206 150 20} down_box DOWN_BOX value 1
                code0 {o->value(progdefaults.WF_UIwfampspan);}
              }
              Fl_Check_Button btnWF_UIwfstore {
                label {WF Store}
                callback {progdefaults.WF_UIwfstore = o->value();
progdefaults.changed = true;
WF_UI();}
                xywh {298 206 150 20} down_box DOWN_BOX value 1
                code0 {o->value(progdefaults.WF_UIwfstore);}
              }
              Fl_Check_Button btnWF_UIwfmode {
                label {WF mode}
                callback {progdefaults.WF_UIwfmode = o->value();
progdefaults.changed = true;
WF_UI();}
                xywh {79 238 150 20} down_box DOWN_BOX value 1
                code0 {o->value(progdefaults.WF_UIwfmode);}
              }
              Fl_Check_Button btnWF_UIqsy {
                label QSY
                callback {progdefaults.WF_UIqsy = o->value();
progdefaults.changed = true;
WF_UI();}
                xywh {298 238 150 20} down_box DOWN_BOX value 1
                code0 {o->value(progdefaults.WF_UIqsy);}
              }
              Fl_Check_Button btnWF_UIxmtlock {
                label {XMT lock}
                callback {progdefaults.WF_UIxmtlock = o->value();
progdefaults.changed = true;
WF_UI();}
                xywh {298 270 150 20} down_box DOWN_BOX value 1
                code0 {o->value(progdefaults.WF_UIxmtlock);}
              }
              Fl_Button btn_wf_enable_all {
                label {Enable all}
                callback {btnWF_UIrev->value(progdefaults.WF_UIrev = 1);
btnWF_UIwfcarrier->value(progdefaults.WF_UIwfcarrier = 1);
btnWF_UIwfreflevel->value(progdefaults.WF_UIwfreflevel = 1);
btnWF_UIwfampspan->value(progdefaults.WF_UIwfampspan = 1);
btnWF_UIwfmode->value(progdefaults.WF_UIwfmode = 1);

btnWF_UIx1->value(progdefaults.WF_UIx1 = 1);
btnWF_UIwfshift->value(progdefaults.WF_UIwfshift = 1);
btnWF_UIwfdrop->value(progdefaults.WF_UIwfdrop = 1);
btnWF_UIwfstore->value(progdefaults.WF_UIwfstore = 1);
btnWF_UIqsy->value(progdefaults.WF_UIqsy = 1);
btnWF_UIxmtlock->value(progdefaults.WF_UIxmtlock = 1);

progdefaults.changed = true;
WF_UI();}
                xywh {123 293 88 20}
              }
              Fl_Button btn_wf_disable_all {
                label {Disable all}
                callback {btnWF_UIrev->value(progdefaults.WF_UIrev = 0);
btnWF_UIwfcarrier->value(progdefaults.WF_UIwfcarrier = 0);
btnWF_UIwfreflevel->value(progdefaults.WF_UIwfreflevel = 0);
btnWF_UIwfampspan->value(progdefaults.WF_UIwfampspan = 0);
btnWF_UIwfmode->value(progdefaults.WF_UIwfmode = 0);

btnWF_UIx1->value(progdefaults.WF_UIx1 = 0);
btnWF_UIwfshift->value(progdefaults.WF_UIwfshift = 0);
btnWF_UIwfdrop->value(progdefaults.WF_UIwfdrop = 0);
btnWF_UIwfstore->value(progdefaults.WF_UIwfstore = 0);
btnWF_UIqsy->value(progdefaults.WF_UIqsy = 0);
btnWF_UIxmtlock->value(progdefaults.WF_UIxmtlock = 0);

progdefaults.changed = true;
WF_UI();}
                xywh {322 293 88 20}
              }
            }
          }
        }
      }
      Fl_Group tabWaterfall {
        label Waterfall open
        xywh {-2 25 563 347} hide
      } {
        Fl_Tabs tabsWaterfall {open
          xywh {-2 25 563 347} color 50 selection_color 50
        } {
          Fl_Group {} {
            label Display open
            xywh {0 48 540 320}
          } {
            Fl_Group {} {
              label {Colors and cursors} open
              xywh {24 54 496 190} box ENGRAVED_FRAME align 21
            } {
              Fl_Button WF_Palette {
                label aa
                callback {progdefaults.changed = true;}
                xywh {34 90 380 24} box DOWN_BOX color 0 labelsize 12 align 5
                code0 {\#include "colorbox.h"}
                code1 {o->label(progdefaults.PaletteName.c_str());}
                code2 {o->labelsize(FL_NORMAL_SIZE);}
                class colorbox
              }
              Fl_Button {btnColor[0]} {
                callback {selectColor(0);
progdefaults.changed = true;}
                tooltip {Change color} xywh {34 116 20 24}
              }
              Fl_Button {btnColor[1]} {
                callback {selectColor(1);
progdefaults.changed = true;}
                tooltip {Change color} xywh {79 116 20 24}
              }
              Fl_Button {btnColor[2]} {
                callback {selectColor(2);
progdefaults.changed = true;}
                tooltip {Change color} xywh {124 116 20 24}
              }
              Fl_Button {btnColor[3]} {
                callback {selectColor(3);
progdefaults.changed = true;}
                tooltip {Change color} xywh {169 116 20 24}
              }
              Fl_Button {btnColor[4]} {
                callback {selectColor(4);
progdefaults.changed = true;}
                tooltip {Change color} xywh {214 116 20 24}
              }
              Fl_Button {btnColor[5]} {
                callback {selectColor(5);
progdefaults.changed = true;}
                tooltip {Change color} xywh {259 116 20 24}
              }
              Fl_Button {btnColor[6]} {
                callback {selectColor(6);
progdefaults.changed = true;}
                tooltip {Change color} xywh {304 116 20 24}
              }
              Fl_Button {btnColor[7]} {
                callback {selectColor(7);
progdefaults.changed = true;}
                tooltip {Change color} xywh {349 116 20 24}
              }
              Fl_Button {btnColor[8]} {
                callback {selectColor(8);
progdefaults.changed = true;}
                tooltip {Change color} xywh {394 116 20 24}
              }
              Fl_Button btnLoadPalette {
                label {Load...}
                callback {loadPalette();
progdefaults.changed = true;}
                tooltip {Load a new palette} xywh {424 90 70 24}
                code0 {\#include "colorbox.h"}
              }
              Fl_Button btnSavePalette {
                label {Save...}
                callback {savePalette();}
                tooltip {Save this palette} xywh {424 116 70 24}
                code0 {\#include "colorbox.h"}
              }
              Fl_Group {} {
                label Bandwidth open
                xywh {33 144 113 96} box ENGRAVED_FRAME align 21
              } {
                Fl_Check_Button btnUseCursorLines {
                  label ON
                  callback {progdefaults.UseCursorLines = o->value();
if (o->value())
    btnCursorBWcolor->activate();
else
    btnCursorBWcolor->deactivate();
progdefaults.changed = true;}
                  tooltip {Show cursor with bandwidth lines} xywh {61 164 56 20} down_box DOWN_BOX
                  code0 {o->value(progdefaults.UseCursorLines);}
                }
                Fl_Button btnCursorBWcolor {
                  label Color
                  callback {if (fl_color_chooser("Cursor BW Lines",
  progdefaults.cursorLineRGBI.R, 
  progdefaults.cursorLineRGBI.G, 
  progdefaults.cursorLineRGBI.B) ) {
o->color(fl_rgb_color(progdefaults.cursorLineRGBI.R,progdefaults.cursorLineRGBI.G,progdefaults.cursorLineRGBI.B));
o->redraw();
progdefaults.changed = true;
}}
                  tooltip {Change color} xywh {61 187 20 20} color 3 align 8
                  code0 {\#include <FL/Fl_Color_Chooser.H>}
                  code1 {o->color(fl_rgb_color(progdefaults.cursorLineRGBI.R,progdefaults.cursorLineRGBI.G,progdefaults.cursorLineRGBI.B));}
                }
                Fl_Check_Button btnUseWideCursor {
                  label Wide
                  callback {progdefaults.UseWideCursor = o->value();
progdefaults.changed = true;}
                  tooltip {Show bandwidth tracks on waterfall} xywh {61 210 62 20} down_box DOWN_BOX
                  code0 {o->value(progdefaults.UseWideCursor);}
                }
              }
              Fl_Group {} {
                label {Center line} open
                xywh {157 144 113 96} box ENGRAVED_FRAME align 21
              } {
                Fl_Check_Button btnUseCursorCenterLine {
                  label ON
                  callback {progdefaults.UseCursorCenterLine = o->value();
progdefaults.changed = true;}
                  tooltip {Show cursor with center line} xywh {189 164 48 20} down_box DOWN_BOX
                  code0 {o->value(progdefaults.UseCursorCenterLine);}
                }
                Fl_Button btnCursorCenterLineColor {
                  label Color
                  callback {if (fl_color_chooser("Cursor Center Line",
  progdefaults.cursorCenterRGBI.R, 
  progdefaults.cursorCenterRGBI.G, 
  progdefaults.cursorCenterRGBI.B) ) {
o->color(fl_rgb_color(progdefaults.cursorCenterRGBI.R,progdefaults.cursorCenterRGBI.G,progdefaults.cursorCenterRGBI.B));
o->redraw();
progdefaults.changed = true;
}}
                  tooltip {Change color} xywh {189 187 20 20} color 7 align 8
                  code0 {o->color(fl_rgb_color(progdefaults.cursorCenterRGBI.R,progdefaults.cursorCenterRGBI.G,progdefaults.cursorCenterRGBI.B));}
                }
                Fl_Check_Button btnUseWideCenter {
                  label Wide
                  callback {progdefaults.UseWideCenter = o->value();
progdefaults.changed = true;}
                  tooltip {Show bandwidth tracks on waterfall} xywh {189 212 69 20} down_box DOWN_BOX
                  code0 {o->value(progdefaults.UseWideCenter);}
                }
              }
              Fl_Group {} {
                label {Signal tracks} open
                xywh {280 144 113 96} box ENGRAVED_FRAME align 21
              } {
                Fl_Check_Button btnUseBWTracks {
                  label ON
                  callback {progdefaults.UseBWTracks = o->value();
progdefaults.changed = true;}
                  tooltip {Show bandwidth tracks on waterfall} xywh {308 163 56 20} down_box DOWN_BOX
                  code0 {o->value(progdefaults.UseBWTracks);}
                }
                Fl_Button btnBwTracksColor {
                  label Color
                  callback {if (fl_color_chooser("Track Lines",
  progdefaults.bwTrackRGBI.R, 
  progdefaults.bwTrackRGBI.G, 
  progdefaults.bwTrackRGBI.B) ) {
o->color(fl_rgb_color(progdefaults.bwTrackRGBI.R,progdefaults.bwTrackRGBI.G,progdefaults.bwTrackRGBI.B));
o->redraw();
wf->redraw_marker();
progdefaults.changed = true;
}}
                  tooltip {Change color} xywh {308 186 20 20} color 1 align 8
                  code0 {o->color(fl_rgb_color(progdefaults.bwTrackRGBI.R,progdefaults.bwTrackRGBI.G,progdefaults.bwTrackRGBI.B));}
                }
                Fl_Check_Button btnUseWideTracks {
                  label Wide
                  callback {progdefaults.UseWideTracks = o->value();
progdefaults.changed = true;}
                  tooltip {Show bandwidth tracks on waterfall} xywh {308 210 74 20} down_box DOWN_BOX
                  code0 {o->value(progdefaults.UseWideTracks);}
                }
              }
              Fl_Group {} {
                label Notch open
                xywh {400 144 113 96} box ENGRAVED_FRAME align 21
              } {
                Fl_Button btnNotchColor {
                  label Color
                  callback {if (fl_color_chooser("Notch Indicator",
  progdefaults.notchRGBI.R, 
  progdefaults.notchRGBI.G, 
  progdefaults.notchRGBI.B) ) {
o->color(fl_rgb_color(progdefaults.notchRGBI.R,progdefaults.notchRGBI.G,progdefaults.notchRGBI.B));
o->redraw();
wf->redraw_marker();
progdefaults.changed = true;
}}
                  tooltip {Change color} xywh {428 186 20 20} color 1 align 8
                  code0 {o->color(fl_rgb_color(progdefaults.notchRGBI.R,progdefaults.notchRGBI.G,progdefaults.notchRGBI.B));}
                }
              }
            }
            Fl_Group {} {
              label {Frequency scale} open
              xywh {24 245 496 55} box ENGRAVED_FRAME align 21
            } {
              Fl_Check_Button chkShowAudioScale {
                label {Always show audio frequencies}
                callback {progdefaults.wf_audioscale = o->value();
progdefaults.changed = true;}
                tooltip {Audio or RF frequencies on waterfall scale} xywh {34 268 241 20} down_box DOWN_BOX
                code0 {o->value(progdefaults.wf_audioscale);}
              }
              Fl_Button btnWaterfallFont {
                label {Font...}
                callback {font_browser->fontNumber(progdefaults.WaterfallFontnbr);
font_browser->fontSize(progdefaults.WaterfallFontsize);
font_browser->fontColor(FL_FOREGROUND_COLOR);
font_browser->fontFilter(Font_Browser::ALL_TYPES);
font_browser->callback((Fl_Callback*)cbWaterfallFontBrowser);
font_browser->show();}
                tooltip {Select waterfall scale font} xywh {334 268 71 24}
              }
            }
            Fl_Group {} {
              label {Transmit signal} open
              xywh {24 301 496 65} box ENGRAVED_FRAME align 21
            } {
              Fl_Check_Button btnViewXmtSignal {
                label {Monitor transmitted signal}
                callback {progdefaults.viewXmtSignal=o->value();
progdefaults.changed = true;}
                tooltip {Show transmit signal on waterfall} xywh {34 327 208 20} down_box DOWN_BOX
                code0 {o->value(progdefaults.viewXmtSignal);}
              }
              Fl_Value_Slider valTxMonitorLevel {
                label {Signal level}
                callback {progdefaults.TxMonitorLevel = o->value();
progdefaults.changed = true;}
                tooltip {Set level for good viewing} xywh {292 327 203 20} type Horizontal align 1 step 0.05 value 0.5 textsize 14
                code0 {o->value(progdefaults.TxMonitorLevel);}
                code1 {o->labelsize(FL_NORMAL_SIZE); o->textsize(FL_NORMAL_SIZE);}
                class Fl_Value_Slider2
              }
            }
          }
          Fl_Group {} {
            label {FFT Processing} open
            xywh {0 50 540 320} hide
          } {
            Fl_Group {} {open
              xywh {27 71 490 135} box ENGRAVED_FRAME
            } {
              Fl_Counter cntLowFreqCutoff {
                label {Lower limit}
                callback {progdefaults.LowFreqCutoff=(int)(o->value());
progdefaults.changed = true;
setwfrange();}
                tooltip {Low frequency limit in Hz} xywh {72 81 70 20} type Simple align 8 minimum 0 maximum 500 step 50 value 300
                code0 {o->value(progdefaults.LowFreqCutoff);}
                code1 {o->labelsize(FL_NORMAL_SIZE);}
                class Fl_Counter2
              }
              Fl_Counter valLatency {
                label {FFT latency (scan merging)}
                callback {progdefaults.latency = (int)o->value();
progdefaults.changed = true;}
                tooltip {Latency increases frequency resolution,
decreases time resolution. 1 = no scan merging} xywh {72 111 70 21} type Simple align 8 minimum 1 maximum 8 step 1 value 4
                code0 {o->value(progdefaults.latency);}
                code1 {o->labelsize(FL_NORMAL_SIZE);}
                class Fl_Counter2
              }
              Fl_Check_Button btnWFaveraging {
                label {FFT averaging}
                callback {progdefaults.WFaveraging = o->value();
progdefaults.changed = true;}
                tooltip {Use averaging to decrease waterfall noise} xywh {72 142 120 20} down_box DOWN_BOX
                code0 {o->value(progdefaults.WFaveraging);}
              }
              Fl_Choice mnuFFTPrefilter {
                label {FFT prefilter window function}
                callback {progdefaults.wfPreFilter = o->value();
progdefaults.changed = true;} open
                tooltip {Select the type of FFT prefilter} xywh {72 172 120 25} down_box BORDER_BOX align 8
                code0 {mnuFFTPrefilter->add(_("Rectangular")); mnuFFTPrefilter->add("Blackman");}
                code1 {mnuFFTPrefilter->add("Hamming"); mnuFFTPrefilter->add("Hanning");}
                code2 {mnuFFTPrefilter->add(_("Triangular"));}
                code3 {mnuFFTPrefilter->value(progdefaults.wfPreFilter);}
              } {}
              Fl_Counter cntrWfwidth {
                label {Upper limit}
                callback {progdefaults.HighFreqCutoff = (int)o->value();
progdefaults.changed = true;
setwfrange();}
                tooltip {High frequency limit in Hz} xywh {295 81 95 21} type Simple align 8 minimum 2000 maximum 4000 step 100 value 3000
                code0 {o->value(progdefaults.HighFreqCutoff);}
                code1 {o->labelsize(FL_NORMAL_SIZE);}
                class Fl_Counter2
              }
            }
            Fl_Group {} {
              label {Changes take effect on next program startup} open
              tooltip {Show me more or less waterfall} xywh {27 221 490 80} box ENGRAVED_FRAME align 17
            } {
              Fl_Counter cntrWfheight {
                label {Waterfall height in pixels}
                callback {progdefaults.wfheight = (int)o->value();
progdefaults.changed = true;}
                tooltip {CPU usage increases with waterfall height} xywh {72 251 95 21} type Simple align 8 minimum 100 maximum 160 step 5 value 120
                code0 {o->value(progdefaults.wfheight);}
                code1 {o->labelsize(FL_NORMAL_SIZE);}
                class Fl_Counter2
              }
            }
          }
          Fl_Group {} {
            label Mouse open
            xywh {0 50 540 320} hide
          } {
            Fl_Group {} {open
              xywh {24 73 490 170} box ENGRAVED_FRAME
            } {
              Fl_Check_Button btnWaterfallHistoryDefault {
                label {Left or right click always replays audio history}
                callback {progdefaults.WaterfallHistoryDefault = o->value();
progdefaults.changed = true;}
                tooltip {Replay trackline audio} xywh {34 87 340 20} down_box DOWN_BOX
                code0 {o->value(progdefaults.WaterfallHistoryDefault);}
              }
              Fl_Check_Button btnWaterfallQSY {
                label {Dragging on the waterfall scale changes frequency}
                callback {progdefaults.WaterfallQSY = o->value();
progdefaults.changed = true;}
                tooltip {Enable drag cursor on waterfall scale} xywh {34 117 380 20} down_box DOWN_BOX
                code0 {o->value(progdefaults.WaterfallQSY);}
              }
              Fl_Check_Button btnWaterfallClickInsert {
                label {Insert text on single left click}
                callback {progdefaults.WaterfallClickInsert = o->value();
if (progdefaults.WaterfallClickInsert)
    inpWaterfallClickText->activate();
else
    inpWaterfallClickText->deactivate();
progdefaults.changed = true;}
                tooltip {Insert special text in Rx panel
when waterfall clicked} xywh {34 159 225 20} down_box DOWN_BOX
                code0 {o->value(progdefaults.WaterfallClickInsert);}
              }
              Fl_Input inpWaterfallClickText {
                callback {progdefaults.WaterfallClickText = o->value();
progdefaults.changed = true;}
                tooltip {The string <FREQ> is replaced with
the current modem and frequency} xywh {320 147 180 50} align 8
                class Fl_Input2
              }
            }
            Fl_Choice mnuWaterfallWheelAction {
              label {Wheel action}
              callback {progdefaults.WaterfallWheelAction = o->value();
progdefaults.changed = true;} open
              tooltip {Select how the mouse wheel
behaves inside the waterfall} xywh {34 207 150 22} down_box BORDER_BOX align 8
            } {}
          }
        }
      }
      Fl_Group tabModems {
        label Modems open
        xywh {-4 25 595 347} hide
      } {
        Fl_Tabs tabsModems {open
          xywh {-4 25 595 347} selection_color 50 align 9
        } {
          Fl_Group tabCW {
            label CW open
            xywh {0 50 540 320}
          } {
            Fl_Tabs tabsCW {open
              xywh {0 50 540 320} selection_color 50
            } {
              Fl_Group {} {
                label General open
                xywh {0 75 540 295} align 5
              } {
                Fl_Group {} {
                  label Receive open
                  xywh {5 85 530 130} box ENGRAVED_FRAME align 21
                } {
                  Fl_Value_Slider sldrCWbandwidth {
                    label {Filter bandwidth}
                    callback {progdefaults.CWbandwidth = (int)o->value();
progdefaults.changed = true;}
                    tooltip {CW dsp filter bandwidth} xywh {20 149 335 20} type Horizontal align 5 minimum 10 maximum 400 step 1 value 66 textsize 14
                    code0 {o->value(progdefaults.CWbandwidth);}
                    code1 {o->labelsize(FL_NORMAL_SIZE); o->textsize(FL_NORMAL_SIZE);}
                    class Fl_Value_Slider2
                  }
                  Fl_Value_Output valCWrcvWPM {
                    label {Rx WPM}
                    callback {progdefaults.changed = true;}
                    xywh {20 188 35 20} color 7 align 5
                  }
                  Fl_Progress prgsCWrcvWPM {
                    tooltip {Tracked CW speed in WPM} xywh {56 188 300 20} color 49 selection_color 15 align 0
                  }
                  Fl_Check_Button btnCWuseSOMdecoding {
                    label {SOM decoding}
                    callback {progdefaults.CWuseSOMdecoding = o->value();
progdefaults.changed = true;}
                    tooltip {Self Organizing Mapping} xywh {33 108 125 20} down_box DOWN_BOX value 1
                    code0 {o->value(progdefaults.CWuseSOMdecoding);}
                  }
                  Fl_Counter cntLower {
                    label Lower
                    callback {progdefaults.CWlower = o->value();
progdefaults.changed = true;}
                    tooltip {Detector low threshold} xywh {179 108 65 20} type Simple align 1 minimum 0.01 maximum 0.99 step 0.01 value 0.45
                    code0 {o->value(progdefaults.CWlower);}
                    code1 {o->labelsize(FL_NORMAL_SIZE);}
                    class Fl_Counter2
                  }
                  Fl_Counter cntUpper {
                    label Upper
                    callback {progdefaults.CWupper = o->value();
progdefaults.changed = true;}
                    tooltip {Detector high threshold} xywh {272 108 65 20} type Simple align 1 minimum 0.01 maximum 0.99 step 0.01 value 0.55
                    code0 {o->value(progdefaults.CWupper);}
                    code1 {o->labelsize(FL_NORMAL_SIZE);}
                    class Fl_Counter2
                  }
                  Fl_Check_Button btnCWmfilt {
                    label {Matched Filter}
                    callback {progdefaults.CWmfilt = o->value();
progdefaults.changed = true;}
                    tooltip {Matched Filter bandwidth} xywh {367 108 80 20} down_box DOWN_BOX value 1
                    code0 {o->value(progdefaults.CWmfilt);}
                  }
                  Fl_Check_Button btnCWuseFFTfilter {
                    label {FFT filter}
                    callback {progdefaults.CWuse_fft_filter = o->value();
progdefaults.changed = true;}
                    tooltip {FFT / FIR filter} xywh {367 134 125 20} down_box DOWN_BOX value 1
                    code0 {o->value(progdefaults.CWuse_fft_filter);}
                  }
                  Fl_Check_Button btnCWrcvTrack {
                    label Tracking
                    callback {progdefaults.CWtrack = o->value();
progdefaults.changed = true;}
                    tooltip {Automatic Rx speed tracking} xywh {367 160 80 20} down_box DOWN_BOX value 1
                    code0 {o->value(progdefaults.CWtrack);}
                  }
                  Fl_Counter cntCWrange {
                    label {Range, WPM}
                    callback {progdefaults.CWrange = (int)o->value();
progdefaults.changed = true;}
                    tooltip {Range +/- wpm} xywh {367 187 65 20} type Simple align 8 minimum 5 maximum 25 step 1 value 10
                    code0 {o->value(progdefaults.CWrange);}
                    code1 {o->labelsize(FL_NORMAL_SIZE);}
                    class Fl_Counter2
                  }
                }
                Fl_Group {} {
                  label Transmit open
                  xywh {5 215 530 150} box ENGRAVED_FRAME align 21
                } {
                  Fl_Value_Slider sldrCWxmtWPM {
                    label {TX WPM}
                    callback {progdefaults.CWspeed = (int)o->value();
cntCW_WPM->value(progdefaults.CWspeed);
progdefaults.changed = true;
sync_cw_parameters();}
                    tooltip {My transmit CW WPM} xywh {20 240 440 20} type Horizontal align 8 minimum 5 maximum 100 step 1 value 20 textsize 14
                    code0 {o->value(progdefaults.CWspeed);}
                    code1 {o->labelsize(FL_NORMAL_SIZE); o->textsize(FL_NORMAL_SIZE);}
                    class Fl_Value_Slider2
                  }
                  Fl_Counter cntCWdefWPM {
                    label Default
                    callback {progdefaults.defCWspeed = (int)o->value();
progdefaults.changed = true;}
                    tooltip {The default CW speed} xywh {61 281 64 20} type Simple align 1 minimum 5 maximum 200 step 1 value 18
                    code0 {o->value(progdefaults.defCWspeed);}
                    code1 {o->labelsize(FL_NORMAL_SIZE);}
                    class Fl_Counter2
                  }
                  Fl_Counter cntCWlowerlimit {
                    label {Lower limit}
                    callback {progdefaults.CWlowerlimit = (int)o->value();
progdefaults.changed = true;
sldrCWxmtWPM->minimum(progdefaults.CWlowerlimit);
sldrCWxmtWPM->value(progdefaults.CWspeed);
sldrCWxmtWPM->redraw();
cntCWupperlimit->minimum(progdefaults.CWlowerlimit+20);
cntCW_WPM->minimum(progdefaults.CWlowerlimit);}
                    tooltip {No slower than this} xywh {215 281 65 20} type Simple align 1 minimum 5 maximum 20 step 5 value 10
                    code0 {o->value(progdefaults.CWlowerlimit);}
                    code1 {o->labelsize(FL_NORMAL_SIZE);}
                  }
                  Fl_Counter cntCWupperlimit {
                    label {Upper limit}
                    callback {progdefaults.CWupperlimit = (int)o->value();
progdefaults.changed = true;
sldrCWxmtWPM->maximum(progdefaults.CWupperlimit);
sldrCWxmtWPM->value(progdefaults.CWspeed);
sldrCWxmtWPM->redraw();
cntCWlowerlimit->maximum(progdefaults.CWupperlimit-20);
cntCW_WPM->maximum(progdefaults.CWupperlimit);}
                    tooltip {No faster than this} xywh {371 281 65 20} type Simple align 1 minimum 25 maximum 200 step 5 value 100
                    code0 {o->value(progdefaults.CWupperlimit);}
                    code1 {o->labelsize(FL_NORMAL_SIZE);}
                  }
                  Fl_Value_Slider sldrCWfarnsworth {
                    label {F-WPM}
                    callback {progdefaults.CWfarnsworth = (int)o->value();
progdefaults.changed = true;}
                    tooltip {My transmit CW WPM} xywh {20 335 440 20} type Horizontal align 8 minimum 5 maximum 100 step 1 value 20 textsize 14
                    code0 {o->value(progdefaults.CWfarnsworth);}
                    code1 {o->labelsize(FL_NORMAL_SIZE); o->textsize(FL_NORMAL_SIZE);}
                    class Fl_Value_Slider2
                  }
                  Fl_Check_Button btnCWusefarnsworth {
                    label {Use Farnsworth timing}
                    callback {progdefaults.CWusefarnsworth=o->value();
progdefaults.changed = true;}
                    xywh {40 312 180 15} down_box DOWN_BOX
                    code0 {o->value(progdefaults.CWusefarnsworth);}
                  }
                }
              }
              Fl_Group {} {
                label {Timing and QSK} open
                xywh {0 75 540 295} align 5 hide
              } {
                Fl_Group {} {
                  label Timing open
                  xywh {5 85 530 120} box ENGRAVED_FRAME align 21
                } {
                  Fl_Counter cntCWweight {
                    label {Weight (%)}
                    callback {progdefaults.CWweight=(int)o->value();
progdefaults.changed = true;}
                    tooltip {Dot to dot-space ratio} xywh {15 114 65 20} type Simple align 8 minimum 20 maximum 80 step 1 value 50
                    code0 {o->value(progdefaults.CWweight);}
                    code1 {o->labelsize(FL_NORMAL_SIZE);}
                    class Fl_Counter2
                  }
                  Fl_Counter cntCWdash2dot {
                    label {Dash to dot ratio}
                    callback {progdefaults.CWdash2dot=o->value();
progdefaults.changed = true;}
                    tooltip {Dash to dot ratio} xywh {240 114 64 20} type Simple align 8 minimum 2.5 maximum 4 value 3
                    code0 {o->value(progdefaults.CWdash2dot);}
                    code1 {o->labelsize(FL_NORMAL_SIZE);}
                    class Fl_Counter2
                  }
                  Fl_Counter cntCWrisetime {
                    label {Edge timing}
                    callback {progdefaults.CWrisetime=o->value();
progdefaults.changed = true;}
                    tooltip {Leading and Trailing edge risetimes (msec)} xywh {240 145 65 20} type Simple align 8 minimum 0 maximum 15 value 4
                    code0 {o->value(progdefaults.CWrisetime);}
                    code1 {o->labelsize(FL_NORMAL_SIZE);}
                    class Fl_Counter2
                  }
                  Fl_Choice mnuQSKshape {
                    label {Edge shape}
                    callback {progdefaults.QSKshape = o->value();
progdefaults.changed = true;} open
                    tooltip {Raised cosine = Hanning} xywh {15 144 112 20} down_box BORDER_BOX align 8
                    code0 {o->add("Hanning|Blackman");}
                    code1 {o->value(progdefaults.QSKshape);}
                    code2 {o->labelsize(FL_NORMAL_SIZE);}
                  } {}
                  Fl_Check_Button btnCWnarrow {
                    label {Edge decreases pulse width}
                    callback {progdefaults.CWnarrow = o->value();
progdefaults.changed = true;}
                    tooltip {Weight decreases with increasing edge timing} xywh {15 175 225 15} down_box DOWN_BOX
                    code0 {o->value(progdefaults.CWnarrow);}
                  }
                }
                Fl_Group {} {
                  label QSK open
                  xywh {5 217 530 118} box ENGRAVED_FRAME align 21
                } {
                  Fl_Check_Button btnQSK {
                    label {QSK on right audio channel}
                    callback {progdefaults.QSK = o->value();
btnQSK2->value(o->value());
progdefaults.changed = true;
if (o->value()) {
  progdefaults.sig_on_right_channel = false;
  chkAudioStereoOut->value(0);
  progdefaults.PTTrightchannel = false;
  btnPTTrightchannel->value(0);
  if (progdefaults.mono_audio) {
    progdefaults.mono_audio = false;
    chkForceMono->value(0);
    resetSoundCard();
  }
}}
                    tooltip {Generate square wave signal on right channel} xywh {15 245 211 20} down_box DOWN_BOX
                    code0 {o->value(progdefaults.QSK);}
                  }
                  Fl_Counter cntPreTiming {
                    label {Pre-keydown timing (ms)}
                    callback {progdefaults.CWpre=o->value();
progdefaults.changed = true;}
                    tooltip {Msec pre-keydown (+ is earlier in time)} xywh {15 275 64 20} type Simple align 8 minimum 0 maximum 20 step 0.5
                    code0 {o->value(progdefaults.CWpre);}
                    code1 {o->labelsize(FL_NORMAL_SIZE);}
                    class Fl_Counter2
                  }
                  Fl_Counter cntPostTiming {
                    label {Post-keydown timing (ms)}
                    callback {progdefaults.CWpost=o->value();
progdefaults.changed = true;}
                    tooltip {Msec post-keydown (+ is earlier in time)} xywh {15 305 64 20} type Simple align 8 minimum -20 maximum 20 step 0.5
                    code0 {o->value(progdefaults.CWpre);}
                    code1 {o->labelsize(FL_NORMAL_SIZE);}
                    class Fl_Counter2
                  }
                  Fl_Check_Button btnQSKadjust {
                    label {Send continuously}
                    callback {progdefaults.QSKadjust = o->value();}
                    tooltip {Send a continuous stream of test characters} xywh {290 275 160 20} down_box DOWN_BOX
                    code0 {o->value(progdefaults.QSKadjust);}
                  }
                  Fl_Choice mnuTestChar {
                    label {Test char}
                    callback {progdefaults.TestChar = o->value();} open
                    tooltip {Test character for QSK adjustment} xywh {290 245 41 20} down_box BORDER_BOX align 8
                    code0 {extern char szTestChar[];}
                    code1 {o->add(szTestChar);}
                    code2 {o->value(progdefaults.TestChar);}
                  } {}
                }
              }
              Fl_Group {} {
                label Prosigns open
                xywh {0 75 540 295} align 5 hide
              } {
                Fl_Group {} {open
                  xywh {4 81 530 283} box ENGRAVED_FRAME
                } {
                  Fl_Check_Button btnCW_use_paren {
                    label {Use '(' paren not KN}
                    callback {progdefaults.CW_use_paren=o->value();
progdefaults.changed = true;}
                    xywh {235 236 68 15} down_box DOWN_BOX
                    code0 {o->value(progdefaults.CW_use_paren);}
                  }
                }
                Fl_Choice {mnu_prosign[0]} {
                  label {<BT>}
                  callback {int c = o->value();
for (int i = 0; i < 9; i++)
  if (mnu_prosign[i]->value() == c) {
    mnu_prosign[i]->value(11);
    progdefaults.CW_prosigns[i] = ' ';
  }
o->value(c);
char ps[] = "~%&+={}<>[] ";
progdefaults.CW_prosigns[0] = ps[c];
progdefaults.changed = true;} open
                  xywh {167 94 47 22} down_box BORDER_BOX
                  code0 {o->add(szProsigns);}
                  code1 {char s[2] = " "; s[0] = progdefaults.CW_prosigns[0];}
                  code2 {o->value(o->find_item(s));}
                } {}
                Fl_Choice {mnu_prosign[1]} {
                  label {<AA>}
                  callback {int c = o->value();
for (int i = 0; i < 9; i++)
  if (mnu_prosign[i]->value() == c) {
    mnu_prosign[i]->value(11);
    progdefaults.CW_prosigns[i] = ' ';
  }
o->value(c); 
char ps[] = "~%&+={}<>[] ";
progdefaults.CW_prosigns[1] = ps[c];
progdefaults.changed = true;} open
                  xywh {167 121 47 22} down_box BORDER_BOX
                  code0 {o->add(szProsigns);}
                  code1 {char s[2] = " "; s[0] = progdefaults.CW_prosigns[1];}
                  code2 {o->value(o->find_item(s));}
                } {}
                Fl_Choice {mnu_prosign[2]} {
                  label {<AS>}
                  callback {int c = o->value();
for (int i = 0; i < 9; i++)
  if (mnu_prosign[i]->value() == c) {
    mnu_prosign[i]->value(11);
    progdefaults.CW_prosigns[i] = ' ';
  }
o->value(c);
char ps[] = "~%&+={}<>[] ";
progdefaults.CW_prosigns[2] = ps[c];
progdefaults.changed = true;} open
                  xywh {167 149 47 22} down_box BORDER_BOX
                  code0 {o->add(szProsigns);}
                  code1 {char s[2] = " "; s[0] = progdefaults.CW_prosigns[2];}
                  code2 {o->value(o->find_item(s));}
                } {}
                Fl_Choice {mnu_prosign[3]} {
                  label {<AR>}
                  callback {int c = o->value();
for (int i = 0; i < 9; i++)
  if (mnu_prosign[i]->value() == c) {
    mnu_prosign[i]->value(11);
    progdefaults.CW_prosigns[i] = ' ';
  }
o->value(c);
char ps[] = "~%&+={}<>[] ";
progdefaults.CW_prosigns[3] = ps[c];
progdefaults.changed = true;} open
                  xywh {167 176 47 22} down_box BORDER_BOX
                  code0 {o->add(szProsigns);}
                  code1 {char s[2] = " "; s[0] = progdefaults.CW_prosigns[3];}
                  code2 {o->value(o->find_item(s));}
                } {}
                Fl_Choice {mnu_prosign[4]} {
                  label {<SK>}
                  callback {int c = o->value();
for (int i = 0; i < 9; i++)
  if (mnu_prosign[i]->value() == c) {
    mnu_prosign[i]->value(11);
    progdefaults.CW_prosigns[i] = ' ';
  }
o->value(c);
char ps[] = "~%&+={}<>[] ";
progdefaults.CW_prosigns[4] = ps[c];
progdefaults.changed = true;} open
                  xywh {167 204 47 22} down_box BORDER_BOX
                  code0 {o->add(szProsigns);}
                  code1 {char s[2] = " "; s[0] = progdefaults.CW_prosigns[4];}
                  code2 {o->value(o->find_item(s));}
                } {}
                Fl_Choice {mnu_prosign[5]} {
                  label {<KN>}
                  callback {int c = o->value();
for (int i = 0; i < 9; i++)
  if (mnu_prosign[i]->value() == c) {
    mnu_prosign[i]->value(11);
    progdefaults.CW_prosigns[i] = ' ';
  }
o->value(c);
char ps[] = "~%&+={}<>[] ";
progdefaults.CW_prosigns[5] = ps[c];
progdefaults.changed = true;} open
                  xywh {167 232 47 22} down_box BORDER_BOX
                  code0 {o->add(szProsigns);}
                  code1 {char s[2] = " "; s[0] = progdefaults.CW_prosigns[5];}
                  code2 {o->value(o->find_item(s));}
                } {}
                Fl_Choice {mnu_prosign[6]} {
                  label {<INT>}
                  callback {int c = o->value();
for (int i = 0; i < 9; i++)
  if (mnu_prosign[i]->value() == c) {
    mnu_prosign[i]->value(11);
    progdefaults.CW_prosigns[i] = ' ';
  }
o->value(c);
char ps[] = "~%&+={}<>[] ";
progdefaults.CW_prosigns[6] = ps[c];
progdefaults.changed = true;} open
                  xywh {167 259 47 22} down_box BORDER_BOX
                  code0 {o->add(szProsigns);}
                  code1 {char s[2] = " "; s[0] = progdefaults.CW_prosigns[6];}
                  code2 {o->value(o->find_item(s));}
                } {}
                Fl_Choice {mnu_prosign[7]} {
                  label {<HM>}
                  callback {int c = o->value();
for (int i = 0; i < 9; i++)
  if (mnu_prosign[i]->value() == c) {
    mnu_prosign[i]->value(11);
    progdefaults.CW_prosigns[i] = ' ';
  }
o->value(c);
char ps[] = "~%&+={}<>[] ";
progdefaults.CW_prosigns[7] = ps[c];
progdefaults.changed = true;} open
                  xywh {167 287 47 22} down_box BORDER_BOX
                  code0 {o->add(szProsigns);}
                  code1 {char s[2] = " "; s[0] = progdefaults.CW_prosigns[7];}
                  code2 {o->value(o->find_item(s));}
                } {}
                Fl_Choice {mnu_prosign[8]} {
                  label {<VE>}
                  callback {int c = o->value();
for (int i = 0; i < 9; i++)
  if (mnu_prosign[i]->value() == c) {
    mnu_prosign[i]->value(11);
    progdefaults.CW_prosigns[i] = ' ';
  }
o->value(c);
char ps[] = "~%&+={}<>[] ";
progdefaults.CW_prosigns[8] = ps[c];
progdefaults.changed = true;} open
                  xywh {167 315 47 22} down_box BORDER_BOX
                  code0 {o->add(szProsigns);}
                  code1 {char s[2] = " "; s[0] = progdefaults.CW_prosigns[8];}
                  code2 {o->value(o->find_item(s));}
                } {}
              }
            }
          }
          Fl_Group tabDomEX {
            label Dom
            xywh {0 50 540 320} hide
          } {
            Fl_Group {} {open
              xywh {30 60 490 180} box ENGRAVED_FRAME
            } {
              Fl_Input txtSecondary {
                label {Secondary Text}
                callback {progdefaults.secText = o->value();
progdefaults.changed = true;}
                tooltip {Text to send during keyboard idle times} xywh {40 87 360 40} type Multiline align 5 when 1
                code0 {txtSecondary->labelsize(FL_NORMAL_SIZE);}
                class Fl_Input2
              }
              Fl_Check_Button valDominoEX_FILTER {
                label Filtering
                callback {progdefaults.DOMINOEX_FILTER = o->value();
resetDOMEX();
progdefaults.changed = true;}
                tooltip {Use DSP filter before decoder} xywh {40 141 80 20} down_box DOWN_BOX value 1
                code0 {o->value(progdefaults.DOMINOEX_FILTER);}
              }
              Fl_Counter valDominoEX_BW {
                label {Filter bandwidth factor}
                callback {progdefaults.DOMINOEX_BW = o->value();
resetDOMEX();
progdefaults.changed = true;}
                tooltip {Filter bandwidth relative to signal width} xywh {156 141 63 20} type Simple align 8 minimum 1 maximum 5 value 1.5
                code0 {o->value(progdefaults.DOMINOEX_BW);}
                code1 {o->labelsize(FL_NORMAL_SIZE);}
                class Fl_Counter2
              }
              Fl_Counter valDominoEX_ADJ {
                label {Tone-spacing adjust}
                callback {progdefaults.DOMINOEX_ADJ = o->value();
resetDOMEX();
progdefaults.changed = true;}
                tooltip {Tone-spacing adjust} xywh {156 166 63 20} type Simple align 8 minimum -100 maximum 100
                code0 {o->value(progdefaults.DOMINOEX_ADJ);}
                code1 {o->labelsize(FL_NORMAL_SIZE);}
                class Fl_Counter2
              }
              Fl_Check_Button chkDominoEX_FEC {
                label FEC
                callback {progdefaults.DOMINOEX_FEC = o->value();
progdefaults.changed = true;}
                tooltip {Enable MultiPSK-compatible FEC} xywh {40 171 51 20} down_box DOWN_BOX
                code0 {o->value(progdefaults.DOMINOEX_FEC);}
              }
              Fl_Value_Slider valDomCWI {
                label {CWI threshold}
                callback {progdefaults.DomCWI = o->value();
progdefaults.changed = true;}
                tooltip {CWI detection and suppression} xywh {40 207 260 20} type Horizontal align 1 textsize 14
                code0 {o->value(progdefaults.DomCWI);}
                code1 {o->labelsize(FL_NORMAL_SIZE); o->textsize(FL_NORMAL_SIZE);}
                class Fl_Value_Slider2
              }
              Fl_Counter valDominoEX_PATHS {
                label {Paths (hidden)}
                callback {progdefaults.DOMINOEX_PATHS = (int)o->value();
progdefaults.changed = true;}
                xywh {364 194 63 20} type Simple minimum 4 maximum 8 step 1 value 5
                code0 {o->value(progdefaults.DOMINOEX_PATHS);}
                code1 {o->labelsize(FL_NORMAL_SIZE);}
                code2 {o->hide();}
                class Fl_Counter2
              }
            }
          }
          Fl_Group tabFeld {
            label Feld
            xywh {0 50 540 320} hide
          } {
            Fl_Group {} {open
              xywh {30 72 490 145} box ENGRAVED_FRAME
            } {
              Fl_Choice selHellFont {
                label {Transmit font}
                callback {progdefaults.feldfontnbr=o->value();
progdefaults.changed = true;} open
                tooltip {Select TX raster font} xywh {40 82 150 20} down_box BORDER_BOX align 8
                code0 {\#include "fontdef.h"}
                code1 {o->add(szFeldFonts);}
                code2 {o->value(progdefaults.feldfontnbr);}
              } {}
              Fl_Check_Button btnBlackboard {
                label {Reverse video}
                callback {progdefaults.HellBlackboard=o->value();
progdefaults.changed = true;}
                tooltip {Display RX in reverse video} xywh {325 82 125 20} down_box DOWN_BOX
                code0 {o->value(progdefaults.HellBlackboard);}
              }
              Fl_Spinner valHellXmtWidth {
                label {Transmit width}
                callback {progdefaults.HellXmtWidth=(int)o->value();
progdefaults.changed = true;}
                tooltip {\# of multiple scans / character line} xywh {40 112 40 20} align 8 maximum 3
                code0 {o->value(progdefaults.HellXmtWidth);}
                code1 {o->labelsize(FL_NORMAL_SIZE);}
                class Fl_Spinner2
              }
              Fl_Check_Button btnHellRcvWidth {
                label {Halve receive width}
                callback {progdefaults.HellRcvWidth=o->value();
progdefaults.changed = true;}
                tooltip {Compress Rx in time} xywh {325 112 155 20} down_box DOWN_BOX
                code0 {o->value(progdefaults.HellRcvWidth);}
              }
              Fl_Choice mnuHellPulse {
                label {Pulse shape}
                callback {progdefaults.HellPulseFast = o->value();
progdefaults.changed = true;} open
                tooltip {Raised cosine pulse shape factor} xywh {40 159 150 20} down_box BORDER_BOX align 5
                code0 {o->add(_("Slow (4 msec)"));}
                code1 {o->add(_("Fast (2 msec)"));}
                code2 {o->value(progdefaults.HellPulseFast);}
              } {}
              Fl_Value_Slider sldrHellBW {
                label {Receive filter bandwidth}
                callback {progdefaults.HELL_BW = sldrHellBW->value();}
                tooltip {Adjust the DSP bandwidth} xywh {231 159 246 20} type Horizontal align 5 minimum 10 maximum 2400 step 5 value 400 textsize 14
                code0 {o->value(progdefaults.HELL_BW);}
                code1 {o->labelsize(FL_NORMAL_SIZE); o->textsize(FL_NORMAL_SIZE);}
                class Fl_Value_Slider2
              }
              Fl_Check_Button btnFeldHellIdle {
                label {Transmit periods (.) when idle}
                callback {progdefaults.HellXmtIdle=o->value();
progdefaults.changed = true;}
                tooltip {Transmits a diddle dot when no keyboard activity} xywh {40 189 230 20} down_box DOWN_BOX value 1
                code0 {o->value(progdefaults.HellXmtIdle);}
              }
              Fl_Check_Button btnHellXmtWidth {
                label {2x Xmt Width (hidden)}
                callback {progdefaults.HellXmtWidth=o->value();
progdefaults.changed = true;}
                xywh {330 187 113 20} down_box DOWN_BOX
                code0 {o->value(progdefaults.HellXmtWidth);}
                code1 {o->hide();}
              }
            }
          }
          Fl_Group tabMT63 {
            label {MT-63}
            xywh {0 50 540 320} hide
          } {
            Fl_Group {} {open
              xywh {18 73 490 115} box ENGRAVED_FRAME align 21
            } {
              Fl_Check_Button btnmt63_interleave {
                label {64-bit (long) interleave}
                callback {if (o->value() == 1)
progdefaults.mt63_interleave = 64;
else
progdefaults.mt63_interleave = 32;
progdefaults.changed = true;}
                xywh {163 91 185 20} down_box DOWN_BOX value 1
                code0 {o->value(0);if (progdefaults.mt63_interleave == 64) o->value(1);}
              }
              Fl_Check_Button btnMT63_8bit {
                label {8-bit extended characters (UTF-8)}
                callback {progdefaults.mt63_8bit = o->value();
progdefaults.changed = true;}
                tooltip {Enable this for UTF-8 characters} xywh {163 121 205 20} down_box DOWN_BOX value 1
                code0 {o->value(progdefaults.mt63_8bit);}
              }
              Fl_Check_Button btnMT63_rx_integration {
                label {Long receive integration}
                callback {progdefaults.mt63_rx_integration = o->value();
progdefaults.changed = true;}
                tooltip {Enable for very weak signals} xywh {163 151 190 20} down_box DOWN_BOX value 1
                code0 {o->value(progdefaults.mt63_rx_integration);}
              }
            }
            Fl_Group {} {open
              xywh {19 189 490 131} box ENGRAVED_FRAME
            } {
              Fl_Check_Button btnMT63_usetones {
                label {Transmit lower start tone}
                callback {progdefaults.mt63_usetones = o->value();
if (!o->value()) {
    btnMT63_upper_lower->value(0);
    btnMT63_upper_lower->do_callback();
    btnMT63_upper_lower->deactivate();
}
else
    btnMT63_upper_lower->activate();
progdefaults.changed = true;}
                xywh {163 197 200 20} down_box DOWN_BOX
                code0 {o->value(progdefaults.mt63_usetones);}
              }
              Fl_Check_Button btnMT63_upper_lower {
                label {Transmit upper start tone}
                callback {progdefaults.mt63_twotones = o->value();
progdefaults.changed = true;}
                xywh {163 227 200 20} down_box DOWN_BOX
                code0 {o->value(progdefaults.mt63_twotones);}
                code1 {if (!btnMT63_usetones->value()) o->deactivate();}
              }
              Fl_Spinner MT63_tone_duration {
                label {Tone Duration (secs)}
                callback {progdefaults.mt63_tone_duration=(int)o->value();
progdefaults.changed = true;}
                xywh {163 253 40 20} align 8 maximum 10 value 4
                code0 {o->value(progdefaults.mt63_tone_duration);}
                code1 {o->labelsize(FL_NORMAL_SIZE);}
                class Fl_Spinner2
              }
              Fl_Check_Button btnMT63_at500 {
                label {Allow manual tuning}
                callback {progdefaults.mt63_at500 = !o->value();
progdefaults.changed = true;}
                xywh {163 282 200 20} down_box DOWN_BOX
                code0 {o->value(!progdefaults.mt63_at500);}
              }
            }
          }
          Fl_Group tabOlivia {
            label Olivia
            xywh {0 50 540 320} hide
          } {
            Fl_Group {} {open
              xywh {24 76 490 237} box ENGRAVED_FRAME
            } {
              Fl_Choice mnuOlivia_Bandwidth {
                label Bandwidth
                callback {progdefaults.oliviabw = o->value();
set_olivia_default_integ();
resetOLIVIA();
progdefaults.changed = true;} open
                tooltip {Select bandwidth} xywh {79 96 85 20} down_box BORDER_BOX align 8
                code0 {o->add(szOliviaBandwidth);}
                code1 {o->value(2);}
              } {}
              Fl_Choice mnuOlivia_Tones {
                label Tones
                callback {progdefaults.oliviatones = o->value();
set_olivia_default_integ();
resetOLIVIA();
progdefaults.changed = true;} open
                tooltip {Select number of tones} xywh {340 96 70 20} down_box BORDER_BOX align 8
                code0 {o->add(szOliviaTones);}
                code1 {o->value(2);}
              } {}
              Fl_Group {} {
                label {Receive synchronizer} open
                xywh {79 135 379 100} box ENGRAVED_FRAME align 21
              } {
                Fl_Counter cntOlivia_smargin {
                  label {Tune margin (tone frequency spacing)}
                  callback {progdefaults.oliviasmargin = (int)(o->value());
resetOLIVIA();
progdefaults.changed = true;}
                  tooltip {Change ONLY to experiment} xywh {99 166 70 20} type Simple align 8 minimum 2 maximum 128 step 1 value 8
                  code0 {o->labelsize(FL_NORMAL_SIZE);}
                  class Fl_Counter2
                }
                Fl_Counter cntOlivia_sinteg {
                  label {Integration period (FEC blocks)}
                  callback {progdefaults.oliviasinteg = (int)(o->value());
resetOLIVIA();
progdefaults.changed = true;}
                  tooltip {Change ONLY to experiment} xywh {99 196 70 20} type Simple align 8 minimum 2 maximum 128 step 1 value 4
                  code0 {o->labelsize(FL_NORMAL_SIZE);}
                  class Fl_Counter2
                }
              }
              Fl_Check_Button btnOlivia_8bit {
                label {8-bit extended characters (UTF-8)}
                callback {progdefaults.olivia8bit = o->value();
progdefaults.changed = true;}
                tooltip {Enable this for UTF-8 character transmission} xywh {79 257 265 20} down_box DOWN_BOX
              }
            }
          }
          Fl_Group tabContestia {
            label {Cont'}
            xywh {0 50 540 320} hide
          } {
            Fl_Group {} {open
              xywh {24 80 490 200} box ENGRAVED_FRAME
            } {
              Fl_Choice mnuContestia_Bandwidth {
                label Bandwidth
                callback {progdefaults.contestiabw = o->value();
set_contestia_default_integ();
resetOLIVIA();
progdefaults.changed = true;} open
                tooltip {Select bandwidth} xywh {79 100 85 20} down_box BORDER_BOX align 8
                code0 {o->add(szContestiaBandwidth);}
                code1 {o->value(2);}
              } {}
              Fl_Choice mnuContestia_Tones {
                label Tones
                callback {progdefaults.contestiatones = o->value();
set_contestia_default_integ();
resetCONTESTIA();
progdefaults.changed = true;} open
                tooltip {Select number of tones} xywh {340 100 70 20} down_box BORDER_BOX align 8
                code0 {o->add(szContestiaTones);}
                code1 {o->value(2);}
              } {}
              Fl_Group {} {
                label {Receive synchronizer} open
                xywh {79 139 379 100} box ENGRAVED_FRAME align 21
              } {
                Fl_Counter cntContestia_smargin {
                  label {Tune margin (tone frequency spacing)}
                  callback {progdefaults.contestiasmargin = (int)(o->value());
resetCONTESTIA();
progdefaults.changed = true;}
                  tooltip {Change ONLY to experiment} xywh {99 170 70 20} type Simple align 8 minimum 2 maximum 128 step 1 value 8
                  code0 {o->labelsize(FL_NORMAL_SIZE);}
                  class Fl_Counter2
                }
                Fl_Counter cntContestia_sinteg {
                  label {Integration period (FEC blocks)}
                  callback {progdefaults.contestiasinteg = (int)(o->value());
resetCONTESTIA();
progdefaults.changed = true;}
                  tooltip {Change ONLY to experiment} xywh {99 200 70 20} type Simple align 8 minimum 2 maximum 128 step 1 value 4
                  code0 {o->labelsize(FL_NORMAL_SIZE);}
                  class Fl_Counter2
                }
              }
              Fl_Check_Button btnContestia_8bit {
                label {8-bit extended characters}
                callback {progdefaults.contestia8bit = o->value();
progdefaults.changed = true;}
                tooltip {Enable this for Latin-1 accented characters} xywh {79 249 200 20} down_box DOWN_BOX hide
              }
            }
          }
          Fl_Group tabPSK {
            label PSK
            xywh {-4 50 544 322} hide
          } {
            Fl_Tabs tabsPSK {open
              xywh {-4 50 544 322} selection_color 50
            } {
              Fl_Group {} {
                label General open
                xywh {0 75 540 295} align 5
              } {
                Fl_Group {} {
                  label {AFC behavior} open
                  xywh {21 93 490 98} box ENGRAVED_FRAME align 21
                } {
                  Fl_Counter cntSearchRange {
                    label {Acquisition search range (Hz)}
                    callback {progdefaults.SearchRange = (int)o->value();
wf->redraw_marker();
progdefaults.changed = true;}
                    tooltip {Capture signals within this frequency range} xywh {31 125 75 20} type Simple align 8 minimum 10 maximum 500 step 10 value 200
                    code0 {o->value(progdefaults.SearchRange);}
                    code1 {o->labelsize(FL_NORMAL_SIZE);}
                    class Fl_Counter2
                  }
                  Fl_Counter cntACQsn {
                    label {Acquisition S/N (dB)}
                    callback {progdefaults.ACQsn = o->value();
progdefaults.changed = true;}
                    tooltip {Capture signals over this threshold} xywh {31 154 75 20} type Simple align 8 minimum 3 maximum 20 step 1 value 6
                    code0 {o->value(progdefaults.ACQsn);}
                    code1 {o->labelsize(FL_NORMAL_SIZE);}
                    class Fl_Counter2
                  }
                }
                Fl_Group {} {
                  label {S/N and IMD behavior} open
                  xywh {21 191 490 65} box ENGRAVED_FRAME align 21
                } {
                  Fl_Choice mnuPSKStatusTimeout {
                    label after
                    callback {progdefaults.StatusDim = o->value();
progdefaults.changed = true;} open
                    tooltip {Behavior of s/n imd} xywh {31 222 80 20} down_box BORDER_BOX align 8
                    code0 {o->add(_("Clear")); o->add(_("Dim"));}
                    code1 {o->value(progdefaults.StatusDim);}
                  } {}
                  Fl_Counter {} {
                    label seconds
                    callback {progdefaults.StatusTimeout = (int)(o->value());
progdefaults.changed = true;}
                    tooltip {Will occur after this time in seconds} xywh {172 222 75 20} type Simple align 8 minimum 0 maximum 30 step 1
                    code0 {o->value(progdefaults.StatusTimeout);}
                    code1 {o->labelsize(FL_NORMAL_SIZE);}
                    class Fl_Counter2
                  }
                }
                Fl_Group {} {
                  label {Multi-Channel Signal Processing} open
                  xywh {22 258 490 98} box ENGRAVED_FRAME align 21
                } {
                  Fl_Check_Button btnEnablePSKbrowsing {
                    label {Multi-channel detector}
                    callback {progdefaults.pskbrowser_on = o->value();
progdefaults.changed = true;}
                    xywh {32 315 180 20} down_box DOWN_BOX
                    code0 {o->value(progdefaults.pskbrowser_on);}
                  }
                  Fl_Box {} {
                    label {Disable on very slow CPUs of if signal browser is not used}
                    xywh {32 285 440 20} align 20
                  }
                }
              }
            }
          }
          Fl_Group tabRTTY {
            label RTTY
            xywh {0 50 540 320} hide
          } {
            Fl_Group {} {open
              xywh {26 63 490 300} box ENGRAVED_FRAME
            } {
              Fl_Choice selShift {
                label {Carrier shift}
                callback {progdefaults.rtty_shift = o->value();
if (progdefaults.rtty_shift == o->size() - 2) {
    progdefaults.rtty_shift = -1;
    selCustomShift->activate();
}
else
    selCustomShift->deactivate();
resetRTTY();
progdefaults.changed = true;} open
                tooltip {Select carrier shift} xywh {36 73 100 20} down_box BORDER_BOX align 8 when 1
                code0 {o->add(szShifts);}
              } {}
              Fl_Choice selBaud {
                label {Baud rate}
                callback {progdefaults.rtty_baud = o->value();
resetRTTY();
progdefaults.changed = true;} open
                tooltip {Select carrier baudrate} xywh {36 133 100 20} down_box BORDER_BOX align 8 when 1
                code0 {o->add(szBauds);}
              } {}
              Fl_Choice selBits {
                label {Bits per character}
                callback {progdefaults.rtty_bits = o->value();
selParity->do_callback();} open
                tooltip {Select \# bits / char} xywh {36 163 100 20} down_box BORDER_BOX align 8 when 1
                code0 {o->add(szSelBits);}
              } {}
              Fl_Choice selParity {
                label Parity
                callback {if (progdefaults.rtty_bits == 0)
  o->value(progdefaults.rtty_parity = RTTY_PARITY_NONE);
else
  progdefaults.rtty_parity = o->value();
resetRTTY();
progdefaults.changed = true;} open
                tooltip {Select parity} xywh {36 193 100 20} down_box BORDER_BOX align 8 when 1
                code0 {o->add(szParity);}
              } {}
              Fl_Choice selStopBits {
                label {Stop bits}
                callback {progdefaults.rtty_stop = o->value();
resetRTTY();
progdefaults.changed = true;} open
                tooltip {Select \# stop bits} xywh {36 223 100 20} down_box BORDER_BOX align 8 when 1
                code0 {o->add(szStopBits);}
              } {}
              Fl_Group {} {open
                xywh {280 69 230 70} box ENGRAVED_FRAME
              } {
                Fl_Check_Button btnAUTOCRLF {
                  label AutoCRLF
                  callback {progdefaults.rtty_autocrlf = o->value();
progdefaults.changed = true;}
                  tooltip {Add CRLF after page width characters} xywh {290 80 90 22} down_box DOWN_BOX
                  code0 {o->value(progdefaults.rtty_autocrlf);}
                }
                Fl_Check_Button btnCRCRLF {
                  label {CR-CR-LF}
                  callback {progdefaults.rtty_crcrlf = o->value();
progdefaults.changed = true;}
                  tooltip {Use "cr cr lf" for "cr lf"} xywh {410 80 90 22} down_box DOWN_BOX when 6
                  code0 {o->value(progdefaults.rtty_crcrlf);}
                }
                Fl_Counter cntrAUTOCRLF {
                  label characters
                  callback {progdefaults.rtty_autocount = (int)o->value();
progdefaults.changed = true;}
                  tooltip {Set page width} xywh {360 110 65 20} type Simple align 8 minimum 68 maximum 80 step 1 value 72
                  code0 {o->labelsize(FL_NORMAL_SIZE);}
                  class Fl_Counter2
                }
                Fl_Box {} {
                  label {after:}
                  xywh {290 110 60 20} align 20
                }
              }
              Fl_Group {} {
                label {Unshift On Space} open
                xywh {280 138 231 52} box ENGRAVED_FRAME align 21
              } {
                Fl_Check_Button chkUOSrx {
                  label RX
                  callback {progdefaults.UOSrx=o->value();
progdefaults.changed = true;}
                  tooltip {Revert to Unsifted char's on a space} xywh {329 156 63 26} down_box DOWN_BOX
                  code0 {o->value(progdefaults.UOSrx);}
                }
                Fl_Check_Button chkUOStx {
                  label TX
                  callback {progdefaults.UOStx=o->value();
progdefaults.changed = true;}
                  tooltip {Revert to Unsifted char's on a space} xywh {419 156 63 26} down_box DOWN_BOX
                  code0 {o->value(progdefaults.UOStx);}
                }
              }
              Fl_Group {} {
                label {Log RTTY frequency} open
                xywh {280 190 231 52} box ENGRAVED_FRAME align 21
              } {
                Fl_Check_Button chk_useMARKfreq {
                  label {Use MARK freq'}
                  callback {progdefaults.useMARKfreq=o->value();
progdefaults.changed = true;}
                  tooltip {Revert to Unsifted char's on a space} xywh {290 208 63 26} down_box DOWN_BOX
                  code0 {o->value(progdefaults.useMARKfreq);}
                }
                Fl_Button btnRTTY_mark_color {
                  label {track clr}
                  callback {if (fl_color_chooser("MARK freq track",
  progdefaults.rttymarkRGBI.R, 
  progdefaults.rttymarkRGBI.G, 
  progdefaults.rttymarkRGBI.B) ) {
o->color(fl_rgb_color(progdefaults.rttymarkRGBI.R,progdefaults.rttymarkRGBI.G,progdefaults.rttymarkRGBI.B));
o->redraw();
wf->redraw_marker();
progdefaults.changed = true;
}}
                  tooltip {Change color} xywh {424 211 18 18} color 2 align 8
                  code0 {o->color(fl_rgb_color(progdefaults.rttymarkRGBI.R,progdefaults.rttymarkRGBI.G,progdefaults.rttymarkRGBI.B));}
                }
              }
              Fl_Check_Button btnPreferXhairScope {
                label {Use cross hair scope}
                callback {progdefaults.PreferXhairScope=o->value();
progdefaults.changed = true;}
                tooltip {Default to cross hair digiscope} xywh {36 257 165 20} down_box DOWN_BOX
                code0 {o->value(progdefaults.PreferXhairScope);}
              }
              Fl_Check_Button chkPseudoFSK {
                label {Pseudo-FSK on right audio channel}
                callback {progdefaults.PseudoFSK = o->value();
chkPseudoFSK2->value(o->value());
progdefaults.changed = true;
if (o->value()) {
  progdefaults.sig_on_right_channel = false;
  chkAudioStereoOut->value(0);
  progdefaults.PTTrightchannel = false;
  btnPTTrightchannel->value(0);
  if (progdefaults.mono_audio) {
    progdefaults.mono_audio = false;
    chkForceMono->value(0);
    resetSoundCard();
  }
}}
                tooltip {Create square wave on right channel} xywh {36 287 270 20} down_box DOWN_BOX
                code0 {o->value(progdefaults.PseudoFSK);}
              }
              Fl_Choice mnuRTTYAFCSpeed {
                label {AFC speed}
                callback {progdefaults.rtty_afcspeed = o->value();
progdefaults.changed = true;} open
                tooltip {AFC tracking speed} xywh {329 257 80 20} down_box BORDER_BOX align 8
                code0 {o->add("Slow"); o->add("Normal"); o->add("Fast");}
                code1 {o->value(progdefaults.rtty_afcspeed);}
              } {}
              Fl_Check_Button chkXagc {
                label {X-agc (hidden)}
                callback {progdefaults.Xagc=o->value();
progdefaults.changed = true;}
                xywh {329 287 62 22} down_box DOWN_BOX
                code0 {o->value(progdefaults.Xagc);}
                code1 {o->hide();}
              }
              Fl_Value_Slider sldrRTTYbandwidth {
                label {Receive filter bandwidth}
                callback {progdefaults.RTTY_BW = o->value();
progdefaults.RTTY_BW_AUTO = false;
progdefaults.changed = true;}
                tooltip {Adjust the DSP bandwidth} xywh {85 325 300 20} type Horizontal align 5 minimum 5 maximum 1000 step 1 value 25 textsize 14
                code0 {o->value(progdefaults.RTTY_BW);}
                code1 {o->labelsize(FL_NORMAL_SIZE); o->textsize(FL_NORMAL_SIZE);}
                class Fl_Value_Slider2
              }
              Fl_Button RTTYbandwidthAuto {
                label Auto
                callback {progdefaults.RTTY_BW_AUTO = true;
resetRTTY();
progdefaults.changed = true;}
                xywh {390 325 65 20}
              }
              Fl_Counter selCustomShift {
                label {Custom shift}
                callback {progdefaults.rtty_custom_shift = o->value();
resetRTTY();
progdefaults.changed = true;}
                tooltip {Input carrier shift} xywh {36 103 100 20} align 8 minimum 10 maximum 1000 step 1 value 450
                code0 {o->lstep(10.0);}
                code1 {o->labelsize(FL_NORMAL_SIZE);}
                class Fl_Counter2
              }
            }
          }
          Fl_Group tabTHOR {
            label Thor
            xywh {0 50 540 320} hide
          } {
            Fl_Group {} {open
              xywh {26 78 490 170} box ENGRAVED_FRAME
            } {
              Fl_Input txtTHORSecondary {
                label {Secondary Text}
                callback {progdefaults.THORsecText = o->value();
progdefaults.changed = true;}
                tooltip {Text to send during keyboard idle times} xywh {36 105 360 40} type Multiline align 5 when 1
                code0 {txtTHORSecondary->labelsize(FL_NORMAL_SIZE);}
                class Fl_Input2
              }
              Fl_Check_Button valTHOR_FILTER {
                label Filtering
                callback {progdefaults.THOR_FILTER = o->value();
resetTHOR();
progdefaults.changed = true;}
                tooltip {Enable DSP prior to decoder} xywh {36 159 80 20} down_box DOWN_BOX value 1
                code0 {o->value(progdefaults.THOR_FILTER);}
              }
              Fl_Counter valTHOR_BW {
                label {Filter bandwidth factor}
                callback {progdefaults.THOR_BW = o->value();
resetTHOR();
progdefaults.changed = true;}
                tooltip {Filter bandwidth relative to signal width} xywh {177 159 63 20} type Simple align 8 minimum 1 maximum 2 value 1.5
                code0 {o->value(progdefaults.THOR_BW);}
                code1 {o->labelsize(FL_NORMAL_SIZE);}
                class Fl_Counter2
              }
              Fl_Value_Slider valThorCWI {
                label {CWI threshold}
                callback {progdefaults.ThorCWI = o->value();
progdefaults.changed = true;}
                tooltip {CWI detection and suppression} xywh {36 212 260 20} type Horizontal align 1 textsize 14
                code0 {o->value(progdefaults.ThorCWI);}
                code1 {o->labelsize(FL_NORMAL_SIZE); o->textsize(FL_NORMAL_SIZE);}
                class Fl_Value_Slider2
              }
              Fl_Counter valTHOR_PATHS {
                label {Paths (hidden)}
                callback {progdefaults.THOR_PATHS = (int)o->value();
progdefaults.changed = true;}
                xywh {374 211 75 21} type Simple align 1 minimum 4 maximum 8 step 1 value 5
                code0 {o->value(progdefaults.THOR_PATHS);}
                code1 {o->labelsize(FL_NORMAL_SIZE);}
                code2 {o->hide();}
                class Fl_Counter2
              }
            }
          }
          Fl_Group tabNavtex {
            label Navtex open
            xywh {0 50 540 320} hide
          } {
            Fl_Group {} {open
              xywh {6 60 527 300} box ENGRAVED_FRAME
            } {
              Fl_Check_Button btnNvtxAdifLog {
                label {Log Navtex messages to Adif file}
                callback {progdefaults.NVTX_AdifLog=o->value();
progdefaults.changed = true;}
                xywh {81 87 235 30} down_box DOWN_BOX
                code0 {o->value(progdefaults.NVTX_AdifLog);}
              }
              Fl_Output txtNvtxCatalog {
                label {Navtex stations file:}
                callback {progdefaults.NVTX_Catalog=o->value();
progdefaults.changed = true;}
                tooltip {Use Open to select descriptor file} xywh {81 145 270 22} color 52 align 5
                code0 {o->value(fl_filename_name(progdefaults.NVTX_Catalog.c_str()));}
              }
              Fl_Button btnSelectNvtxCatalog {
                label {Directory...}
                callback {Fl_File_Chooser *fc = new Fl_File_Chooser(".",NULL,Fl_File_Chooser::SINGLE,"Navtex stations file");
fc->callback(NvtxCatalogSet);
fc->show();}
                xywh {386 147 80 20}
              }
            }
          }
          Fl_Group tabWefax {
            label Wefax open
            xywh {0 50 540 320} hide
          } {
            Fl_Group {} {open
              xywh {2 63 534 300}
            } {
              Fl_Check_Button btnWefaxAdifLog {
                label {Log Wefax messages to Adif file}
                callback {progdefaults.WEFAX_AdifLog=o->value();
progdefaults.changed = true;}
                tooltip {Sent and received faxes are logged to Adif file.} xywh {94 137 235 30} down_box DOWN_BOX
                code0 {o->value(progdefaults.WEFAX_AdifLog);}
              }
              Fl_Check_Button btnWefaxEmbeddedGui {
                label {Embedded Wefax Gui}
                callback {progdefaults.WEFAX_EmbeddedGui=o->value();
progdefaults.changed = true;}
                tooltip {Display tx and rx in main fldigi window.
Change requires restart of fldigi} xywh {94 74 235 30} down_box DOWN_BOX
                code0 {o->value(progdefaults.WEFAX_EmbeddedGui);}
              }
              Fl_Input btnWefaxShift {
                label {Frequency shift (800 Hz)}
                callback {if( o->value() > 900 ) { o->value(900); return; }
if( o->value() < 750 ) { o->value(750); return; }
progdefaults.WEFAX_Shift=o->value();
progdefaults.changed = true;}
                tooltip {Default 800 Hz. Deutsche Wetterdienst 850Hz} xywh {94 177 80 20} type Int align 8
                code0 {o->value(progdefaults.WEFAX_Shift);}
                class Fl_Value_Input2
              }
              Fl_Input btnWefaxMaxRows {
                label {Received fax maximum rows number (5000)}
                callback {if(o->value() > 10000 ) { o->value(10000); return ; }
if(o->value() < 1000 ) { o->value(1000); return ; }
progdefaults.WEFAX_MaxRows=o->value();
progdefaults.changed = true;}
                tooltip {Maximum row number for a received fax image.} xywh {94 217 85 20} type Int align 8
                code0 {o->value(progdefaults.WEFAX_MaxRows);}
                class Fl_Value_Input2
              }
              Fl_Input btnWefaxSaveDir {
                label {Fax images destination directory}
                callback {progdefaults.wefax_save_dir=o->value();
progdefaults.changed = true;}
                xywh {94 267 310 20} align 5
                code0 {o->value(progdefaults.wefax_save_dir.c_str());}
              }
              Fl_Button btnSelectFaxDestDir {
                label {Directory...}
                callback {Fl_File_Chooser *fc = new Fl_File_Chooser(".",NULL,Fl_File_Chooser::DIRECTORY,"Input File");
fc->callback(WefaxDestDirSet);
fc->show();}
                xywh {424 267 80 20}
              }
              Fl_Check_Button btnWefaxHideTx {
                label {Hide Transmission window}
                callback {progdefaults.WEFAX_HideTx=o->value();
progdefaults.changed = true;}
                tooltip {Hide transmission window by default.} xywh {94 107 235 30} down_box DOWN_BOX
                code0 {o->value(progdefaults.WEFAX_HideTx);}
              }
              Fl_Check_Button btnWefaxSaveMonochrome {
                label {Save image as monochrome file}
                callback {progdefaults.WEFAX_SaveMonochrome=o->value();
progdefaults.changed = true;}
                tooltip {Save the fax image as a gray-level PNG file.} xywh {94 297 235 30} down_box DOWN_BOX
                code0 {o->value(progdefaults.WEFAX_SaveMonochrome);}
              }
            }
          }
        }
      }
      Fl_Group tabRig {
        label Rig
        tooltip {Transceiver control} xywh {0 23 540 345} hide
      } {
        Fl_Tabs tabsRig {open
          xywh {0 23 540 345} selection_color 50
        } {
          Fl_Group {} {
            label {Hardware PTT} open
            xywh {0 48 540 320}
          } {
            Fl_Group {} {open
              xywh {26 57 490 38} box ENGRAVED_FRAME
            } {
              Fl_Check_Button btnPTTrightchannel {
                label {PTT tone on right audio channel }
                callback {progdefaults.PTTrightchannel = o->value();
btnPTTrightchannel2->value(o->value());
if (o->value()) {
  progdefaults.QSK = false;
  btnQSK->value(0);
  progdefaults.PseudoFSK = false;
  chkPseudoFSK->value(0);
  progdefaults.sig_on_right_channel = false;
  chkAudioStereoOut->value(0);
  if (progdefaults.mono_audio) {
    progdefaults.mono_audio = false;
    chkForceMono->value(0);
    resetSoundCard();
  }
}
progdefaults.changed = true;}
                tooltip {Can be used in lieu of or in addition to other PTT types} xywh {45 66 250 20} down_box DOWN_BOX
                code0 {o->value(progdefaults.PTTrightchannel);}
              }
            }
            Fl_Group grpHWPTT {
              label {h/w ptt device-pin} open
              xywh {26 97 490 171} box ENGRAVED_FRAME align 21
            } {
              Fl_Input_Choice inpTTYdev {
                label {Device:}
                callback {btnInitHWPTT->labelcolor(FL_RED);
btnInitHWPTT->redraw();
progdefaults.changed = true;} open
                tooltip {Select serial port} xywh {99 151 160 22}
              } {}
              Fl_Round_Button btnRTSptt {
                label {Use RTS}
                callback {btnInitHWPTT->labelcolor(FL_RED);
btnInitHWPTT->redraw();
progdefaults.changed = true;}
                tooltip {RTS is PTT signal line} xywh {281 120 85 20} down_box DOWN_BOX
              }
              Fl_Round_Button btnRTSplusV {
                label {RTS = +V}
                callback {btnInitHWPTT->labelcolor(FL_RED);
btnInitHWPTT->redraw();
progdefaults.changed = true;}
                tooltip {Initial voltage on RTS} xywh {378 120 100 20} down_box DOWN_BOX
              }
              Fl_Round_Button btnDTRptt {
                label {Use DTR}
                callback {btnInitHWPTT->labelcolor(FL_RED);
btnInitHWPTT->redraw();
progdefaults.changed = true;}
                tooltip {DTR is PTT signal line} xywh {281 150 85 20} down_box DOWN_BOX
              }
              Fl_Round_Button btnDTRplusV {
                label {DTR = +V}
                callback {btnInitHWPTT->labelcolor(FL_RED);
btnInitHWPTT->redraw();
progdefaults.changed = true;}
                tooltip {Initial voltage on DTR} xywh {378 150 100 20} down_box DOWN_BOX
              }
              Fl_Button btnInitHWPTT {
                label Initialize
                callback {progdefaults.initInterface();
o->labelcolor(FL_FOREGROUND_COLOR);
progdefaults.changed = true;}
                tooltip {Initialize the H/W PTT interface} xywh {382 217 113 24}
              }
              Fl_Round_Button btnTTYptt {
                label {Use separate serial port PTT}
                callback {btnUsePPortPTT->value(false);
btnUseUHrouterPTT->value(false);

progdefaults.TTYptt = o->value();
progdefaults.UsePPortPTT = false;
progdefaults.UseUHrouterPTT = false;
btnInitHWPTT->labelcolor(FL_RED);
btnInitHWPTT->redraw();
progdefaults.changed = true;}
                xywh {45 121 220 20} down_box DOWN_BOX selection_color 1
              }
              Fl_Round_Button btnUsePPortPTT {
                label {Use parallel port PTT}
                callback {btnTTYptt->value(false);
btnUseUHrouterPTT->value(false);

progdefaults.TTYptt = false;
progdefaults.UsePPortPTT = o->value();
progdefaults.UseUHrouterPTT = false;
btnInitHWPTT->labelcolor(FL_RED);
btnInitHWPTT->redraw();
progdefaults.changed = true;}
                xywh {45 197 170 20} down_box DOWN_BOX selection_color 1
              }
              Fl_Round_Button btnUseUHrouterPTT {
                label {Use uHRouter PTT}
                callback {btnTTYptt->value(false);
btnUsePPortPTT->value(false);

progdefaults.TTYptt = false;
progdefaults.UsePPortPTT = false;
progdefaults.UseUHrouterPTT = o->value();
btnInitHWPTT->labelcolor(FL_RED);
btnInitHWPTT->redraw();
progdefaults.changed = true;}
                xywh {45 227 170 20} down_box DOWN_BOX selection_color 1
              }
            }
            Fl_Group grpPTTdelays {
              label {PTT delays valid for all CAT/PTT types} open
              xywh {26 270 490 91} box ENGRAVED_FRAME align 21
            } {
              Fl_Counter cntPTT_on_delay {
                label {Start of transmit PTT delay}
                callback {progdefaults.PTT_on_delay = o->value();
progdefaults.changed = true;}
                tooltip {Delay NN msec before starting audio} xywh {45 297 100 21} align 8 minimum 0 maximum 500 step 1
                code0 {o->value(progdefaults.PTT_on_delay);}
                code1 {o->lstep(10);}
              }
              Fl_Counter cntPTT_off_delay {
                label {PTT end of transmit delay}
                callback {progdefaults.PTT_off_delay = o->value();
progdefaults.changed = true;}
                tooltip {Delay NN msec before releasing PTT} xywh {45 327 100 21} align 8 minimum 0 maximum 500 step 1
                code0 {o->value(progdefaults.PTT_off_delay);}
                code1 {o->lstep(10);}
              }
            }
          }
          Fl_Group {} {
            label RigCAT open
            tooltip {Rig Control using xml spec file} xywh {0 48 540 320} hide
          } {
            Fl_Check_Button chkUSERIGCAT {
              label {Use RigCAT}
              callback {if (o->value() == 1) {
  chkUSEHAMLIB->value(0);
  chkUSEMEMMAP->value(0);
  chkUSEXMLRPC->value(0);
  progdefaults.chkUSEMEMMAPis = false;
  progdefaults.chkUSEHAMLIBis = false;
  progdefaults.chkUSERIGCATis = true;
  progdefaults.chkUSEXMLRPCis = false;
  } else {
  progdefaults.chkUSERIGCATis = false;
  }
btnInitRIGCAT->labelcolor(FL_RED);
btnInitRIGCAT->redraw();}
              tooltip {RigCAT used for rig control} xywh {215 60 110 20} down_box DOWN_BOX
            }
            Fl_Group grpRigCAT {open
              xywh {25 83 490 279} box ENGRAVED_FRAME
            } {
              Fl_Output txtXmlRigFilename {
                label {Rig description file:}
                tooltip {Use Open to select descriptor file} xywh {35 107 130 22} color 52 align 5
                code0 {o->value(fl_filename_name(progdefaults.XmlRigFilename.c_str()));}
              }
              Fl_Button btnSelectRigXmlFile {
                label {Open...}
                callback {btnInitRIGCAT->labelcolor(FL_RED);
btnInitRIGCAT->redraw_label();
selectRigXmlFilename();}
                tooltip {Select rig descriptor file} xywh {168 107 60 22}
              }
              Fl_Input_Choice inpXmlRigDevice {
                label {Device:}
                callback {btnInitRIGCAT->labelcolor(FL_RED);
btnInitRIGCAT->redraw_label();
btnRevertRIGCAT->activate();} open
                tooltip {Serial device} xywh {361 107 144 22}
                code0 {o->value(progdefaults.XmlRigDevice.c_str());}
              } {}
              Fl_Value_Input cntRigCatRetries {
                label Retries
                callback {btnInitRIGCAT->labelcolor(FL_RED);
btnInitRIGCAT->redraw_label();
btnRevertRIGCAT->activate();}
                tooltip {\# retries before giving up} xywh {50 150 60 22} align 5 maximum 1000 step 1
                code0 {o->value(progdefaults.RigCatRetries);}
                code1 {o->labelsize(FL_NORMAL_SIZE);}
                class Fl_Value_Input2
              }
              Fl_Value_Input cntRigCatTimeout {
                label {Retry interval (ms)}
                callback {btnInitRIGCAT->labelcolor(FL_RED);
btnInitRIGCAT->redraw_label();
btnRevertRIGCAT->activate();}
                tooltip {Time between retires in msec} xywh {168 150 60 22} align 5 maximum 10000 step 1
                code0 {o->value(progdefaults.RigCatTimeout);}
                code1 {o->labelsize(FL_NORMAL_SIZE);}
                class Fl_Value_Input2
              }
              Fl_Value_Input cntRigCatWait {
                label {Write delay (ms)}
                callback {btnInitRIGCAT->labelcolor(FL_RED);
btnInitRIGCAT->redraw_label();
btnRevertRIGCAT->activate();}
                xywh {50 190 60 22} align 5 maximum 10000 step 1
                code0 {o->value(progdefaults.RigCatWait);}
                code1 {o->labelsize(FL_NORMAL_SIZE);}
                class Fl_Value_Input2
              }
              Fl_Choice mnuXmlRigBaudrate {
                label {Baud rate:}
                callback {btnInitRIGCAT->labelcolor(FL_RED);
btnInitRIGCAT->redraw_label();
btnRevertRIGCAT->activate();} open
                tooltip {Pick baud rate from list} xywh {406 150 99 22} down_box BORDER_BOX
                code0 {o->add(szBaudRates);}
                code1 {o->value(progdefaults.XmlRigBaudrate);}
              } {}
              Fl_Counter valRigCatStopbits {
                label Stopbits
                callback {btnInitRIGCAT->labelcolor(FL_RED);
btnInitRIGCAT->redraw();
btnRevertRIGCAT->activate();}
                xywh {408 184 95 21} type Simple align 4 minimum 1 maximum 2 step 1 value 1
                code0 {o->value(progdefaults.RigCatStopbits);}
                code1 {o->labelsize(FL_NORMAL_SIZE);}
                class Fl_Counter2
              }
              Fl_Button btnInitRIGCAT {
                label Initialize
                callback {progdefaults.initInterface();
o->labelcolor(FL_FOREGROUND_COLOR);
progdefaults.changed = true;}
                tooltip {Initialize RigCAT interface} xywh {385 321 113 24}
              }
              Fl_Check_Button btnRigCatEcho {
                label {Commands are echoed}
                callback {btnInitRIGCAT->labelcolor(FL_RED);
btnInitRIGCAT->redraw_label();
progdefaults.changed = true;
btnRevertRIGCAT->activate();}
                tooltip {Rig or interface echos serial data} xywh {70 216 192 22} down_box DOWN_BOX
                code0 {o->value(progdefaults.RigCatECHO);}
              }
              Fl_Round_Button btnRigCatCMDptt {
                label {CAT command for PTT}
                callback {if (o->value()== 1) {
  btnRigCatRTSptt->value(0);
  btnRigCatDTRptt->value(0);
}
  
btnInitRIGCAT->labelcolor(FL_RED);
btnInitRIGCAT->redraw();
btnRevertRIGCAT->activate();}
                tooltip {PTT is a CAT command (not hardware)} xywh {276 217 207 20} down_box DOWN_BOX selection_color 1
                code0 {o->value(progdefaults.RigCatCMDptt);}
              }
              Fl_Round_Button btnRigCatRTSptt {
                label {Toggle RTS for PTT}
                callback {if (o->value() == 1) {
//  btnRigCatDTRptt->value(0);
  btnRigCatCMDptt->value(0);
}

btnInitRIGCAT->labelcolor(FL_RED);
btnInitRIGCAT->redraw_label();
btnRevertRIGCAT->activate();}
                tooltip {RTS is ptt line} xywh {70 250 160 20} down_box DOWN_BOX
                code0 {o->value(progdefaults.RigCatRTSptt);}
              }
              Fl_Round_Button btnRigCatDTRptt {
                label {Toggle DTR for PTT}
                callback {if (o->value() == 1) {
//  btnRigCatRTSptt->value(0);
  btnRigCatCMDptt->value(0);
}

btnInitRIGCAT->labelcolor(FL_RED);
btnInitRIGCAT->redraw_label();
btnRevertRIGCAT->activate();}
                tooltip {DTR is ptt line} xywh {276 250 160 20} down_box DOWN_BOX
                code0 {o->value(progdefaults.RigCatDTRptt);}
              }
              Fl_Check_Button btnRigCatRTSplus {
                label {RTS +12 v}
                callback {btnInitRIGCAT->labelcolor(FL_RED);
btnInitRIGCAT->redraw_label();
btnRevertRIGCAT->activate();}
                tooltip {Initial state of RTS} xywh {70 285 100 20} down_box DOWN_BOX
                code0 {o->value(progdefaults.RigCatRTSplus);}
              }
              Fl_Check_Button btnRigCatDTRplus {
                label {DTR +12 v}
                callback {btnInitRIGCAT->labelcolor(FL_RED);
btnInitRIGCAT->redraw_label();
btnRevertRIGCAT->activate();}
                tooltip {Initial state of DTR} xywh {276 285 100 20} down_box DOWN_BOX
                code0 {o->value(progdefaults.RigCatDTRplus);}
              }
              Fl_Check_Button chkRigCatRTSCTSflow {
                label {RTS/CTS flow control}
                callback {btnInitRIGCAT->labelcolor(FL_RED);
btnInitRIGCAT->redraw_label();
btnRevertRIGCAT->activate();}
                tooltip {Rig uses RTS/CTS handshake} xywh {70 320 170 20} down_box DOWN_BOX
                code0 {o->value(progdefaults.RigCatRTSCTSflow);}
              }
              Fl_Button btnRevertRIGCAT {
                label Revert
                callback {btnInitRIGCAT->labelcolor(FL_FOREGROUND_COLOR);
btnInitRIGCAT->redraw_label();
rigCAT_restore_defaults();}
                tooltip {Initialize hamlib interface} xywh {385 289 113 24} deactivate
                code0 {\#include "rigio.h"}
              }
              Fl_Check_Button chkRigCatVSP {
                label {VSP Enable}
                callback {btnInitRIGCAT->labelcolor(FL_RED);
btnInitRIGCAT->redraw_label();
btnRevertRIGCAT->activate();}
                tooltip {Virtual Serial Port Emulator - suppress WARNINGS} xywh {276 315 100 25} down_box DOWN_BOX
                code0 {o->value(progdefaults.RigCatVSP);}
              }
            }
          }
          Fl_Group tabHamlib {
            label Hamlib open
            xywh {0 48 540 320} hide
          } {
            Fl_Check_Button chkUSEHAMLIB {
              label {Use Hamlib}
              callback {progdefaults.chkUSEHAMLIBis = o->value();
if (o->value() == 1) {
  chkUSEMEMMAP->value(0);
  chkUSERIGCAT->value(0);
  chkUSEXMLRPC->value(0);
  progdefaults.chkUSEMEMMAPis = false;
  progdefaults.chkUSERIGCATis = false;
  progdefaults.chkUSEXMLRPCis = false;
}
  
btnInitHAMLIB->labelcolor(FL_RED);
btnInitHAMLIB->redraw();
progdefaults.changed = true;}
              tooltip {Hamlib used for rig control} xywh {207 55 100 20} down_box DOWN_BOX
            }
            Fl_Group grpHamlib {open
              xywh {17 78 490 277} box ENGRAVED_FRAME
            } {
              Fl_Box cboHamlibRig {
                label {Rig:}
                callback {btnInitHAMLIB->labelcolor(FL_RED);
btnInitHAMLIB->redraw_label();
btnRevertHAMLIB->activate();
\#if USE_HAMLIB
hamlib_get_defaults();
\#endif}
                tooltip {Select the rig by name} xywh {77 88 160 22} box DOWN_BOX color 7 align 4
                code0 {o->readonly();}
                code1 {cboHamlibRig->labelsize(FL_NORMAL_SIZE);}
                class Fl_ComboBox
              }
              Fl_Input_Choice inpRIGdev {
                label {Device:}
                callback {btnInitHAMLIB->labelcolor(FL_RED);
btnInitHAMLIB->redraw_label();
btnRevertHAMLIB->activate();} open
                tooltip {Serial port} xywh {352 88 144 22}
                code0 {o->value(progdefaults.HamRigDevice.c_str());}
              } {}
              Fl_Value_Input cntHamlibRetries {
                label Retries
                callback {btnInitHAMLIB->labelcolor(FL_RED);
btnInitHAMLIB->redraw_label();
btnRevertHAMLIB->activate();}
                tooltip {\# times to resend command before giving up} xywh {42 128 70 24} align 5 maximum 1000 step 1
                code0 {o->value(progdefaults.HamlibRetries);}
                code1 {o->labelsize(FL_NORMAL_SIZE);}
                class Fl_Value_Input2
              }
              Fl_Value_Input cntHamlibTimeout {
                label {Retry Interval (ms)}
                callback {btnInitHAMLIB->labelcolor(FL_RED);
btnInitHAMLIB->redraw_label();
btnRevertHAMLIB->activate();}
                tooltip {Msec's between retries} xywh {167 128 70 24} align 5 maximum 10000 step 1
                code0 {o->value(progdefaults.HamlibTimeout);}
                code1 {o->labelsize(FL_NORMAL_SIZE);}
                class Fl_Value_Input2
              }
              Fl_Value_Input cntHamlibWriteDelay {
                label {Write delay (ms)}
                callback {btnInitHAMLIB->labelcolor(FL_RED);
btnInitHAMLIB->redraw_label();
btnRevertHAMLIB->activate();}
                tooltip {Msec's between sequential commands} xywh {42 171 70 24} align 5 maximum 10000 step 1
                code0 {o->value(progdefaults.HamlibWriteDelay);}
                code1 {o->labelsize(FL_NORMAL_SIZE);}
                class Fl_Value_Input2
              }
              Fl_Value_Input cntHamlibWait {
                label {Post write delay (ms)}
                callback {btnInitHAMLIB->labelcolor(FL_RED);
btnInitHAMLIB->redraw_label();
btnRevertHAMLIB->activate();}
                tooltip {Wait interval (msecs) before reading response} xywh {168 171 70 24} align 5 maximum 10000 step 1
                code0 {o->value(progdefaults.HamlibWait);}
                code1 {o->labelsize(FL_NORMAL_SIZE);}
                class Fl_Value_Input2
              }
              Fl_Choice mnuBaudRate {
                label {Baud rate:}
                callback {btnInitHAMLIB->labelcolor(FL_RED);
btnInitHAMLIB->redraw_label();
btnRevertHAMLIB->activate();} open
                tooltip {Serial port baud rate} xywh {397 122 99 22} down_box BORDER_BOX
                code0 {o->add(szBaudRates);}
                code1 {o->value(progdefaults.HamRigBaudrate);}
              } {}
              Fl_Counter valHamRigStopbits {
                label Stopbits
                callback {progdefaults.HamRigStopbits = (int)o->value();
btnRevertHAMLIB->activate();
progdefaults.changed = true;}
                xywh {401 158 95 21} type Simple align 4 minimum 1 maximum 2 step 1 value 1
                code0 {o->value(progdefaults.HamRigStopbits);}
                code1 {o->labelsize(FL_NORMAL_SIZE);}
                class Fl_Counter2
              }
              Fl_Counter cntHamlibTimeout0 {
                label {Retry interval (ms)}
                callback {progdefaults.HamlibTimeout = (int)o->value();
btnInitHAMLIB->labelcolor(FL_RED);
btnInitHAMLIB->redraw_label();}
                tooltip {Msec's between retries} xywh {162 135 100 20} type Simple align 5 minimum 2 maximum 20000 step 1 value 10 hide
                code0 {o->value(progdefaults.HamlibTimeout);}
                class Fl_Counter2
              }
              Fl_Input inpHamlibConfig {
                label {Advanced configuration:}
                callback {btnInitHAMLIB->labelcolor(FL_RED);
btnInitHAMLIB->redraw_label();
btnRevertHAMLIB->activate();}
                tooltip {Optional configuration
in format: param=val ...} xywh {32 321 320 22} align 5
                code0 {inpHamlibConfig->value(progdefaults.HamConfig.c_str());}
                code1 {inpHamlibConfig->labelsize(FL_NORMAL_SIZE);}
                class Fl_Input2
              }
              Fl_Button btnInitHAMLIB {
                label Initialize
                callback {progdefaults.initInterface();
o->labelcolor(FL_FOREGROUND_COLOR);
btnRevertHAMLIB->deactivate();
progdefaults.changed = true;}
                tooltip {Initialize hamlib interface} xywh {383 320 113 24}
              }
              Fl_Choice mnuSideband {
                label {Sideband:} open
                tooltip {Force the rig sideband. Takes
effect when rig mode changes.} xywh {352 212 144 22} down_box BORDER_BOX align 5
              } {}
              Fl_Round_Button btnHamlibCMDptt {
                label {PTT via Hamlib command}
                callback {btnInitHAMLIB->labelcolor(FL_RED);
btnInitHAMLIB->redraw_label();
btnRevertHAMLIB->activate();}
                tooltip {PTT is a hamlib command} xywh {57 213 200 20} down_box DOWN_BOX selection_color 1
                code0 {o->value(progdefaults.HamlibCMDptt);}
              }
              Fl_Check_Button btnHamlibDTRplus {
                label {DTR +12}
                callback {btnInitHAMLIB->labelcolor(FL_RED);
btnInitHAMLIB->redraw_label();
btnRevertHAMLIB->activate();}
                tooltip {Initial state of DTR} xywh {57 238 90 20} down_box DOWN_BOX
                code0 {o->value(progdefaults.HamlibDTRplus);}
              }
              Fl_Check_Button chkHamlibRTSplus {
                label {RTS +12}
                callback {if (o->value() == 1)
  chkHamlibRTSCTSflow->value(0);
btnInitHAMLIB->labelcolor(FL_RED);
btnInitHAMLIB->redraw_label();
btnRevertHAMLIB->activate();}
                tooltip {Initial state of RTS} xywh {281 238 85 20} down_box DOWN_BOX
                code0 {o->value(progdefaults.HamlibRTSplus);}
              }
              Fl_Check_Button chkHamlibRTSCTSflow {
                label {RTS/CTS flow control}
                callback {if (o->value() == 1) {
  chkHamlibXONXOFFflow->value(0);
  chkHamlibRTSplus->deactivate();
} else
  chkHamlibRTSplus->activate();
btnInitHAMLIB->labelcolor(FL_RED);
btnInitHAMLIB->redraw_label();
btnRevertHAMLIB->activate();}
                tooltip {Rig requires RTS/CTS flow control} xywh {57 266 170 20} down_box DOWN_BOX
                code0 {o->value(progdefaults.HamlibRTSCTSflow);}
                code1 {if (o->value()) chkHamlibRTSplus->deactivate();}
              }
              Fl_Check_Button chkHamlibXONXOFFflow {
                label {XON/XOFF flow control}
                callback {if (o->value() == 1)
  chkHamlibRTSCTSflow->value(0);
btnInitHAMLIB->labelcolor(FL_RED);
btnInitHAMLIB->redraw_label();
btnRevertHAMLIB->activate();}
                tooltip {Rig requires Xon/Xoff flow control} xywh {281 266 185 20} down_box DOWN_BOX
                code0 {o->value(progdefaults.HamlibXONXOFFflow);}
              }
              Fl_Button btnRevertHAMLIB {
                label Revert
                callback {btnInitHAMLIB->labelcolor(FL_FOREGROUND_COLOR);
btnInitHAMLIB->redraw_label();
\#if USE_HAMLIB
hamlib_restore_defaults();
\#endif}
                tooltip {Initialize hamlib interface} xywh {383 289 113 24} deactivate
              }
            }
          }
          Fl_Group {} {
            label MemMap open
            xywh {0 48 540 320} hide
          } {
            Fl_Group grpMemmap {open
              xywh {22 66 490 185} box ENGRAVED_FRAME
            } {
              Fl_Output {} {
                xywh {177 85 190 58} type Multiline box BORDER_BOX color 50
                code0 {o->value(_("Control via Memory Mapped\\nshared variables\\ni.e.: Kachina program"));}
              }
              Fl_Check_Button chkUSEMEMMAP {
                label {Use Memmap}
                callback {progdefaults.chkUSEMEMMAPis = o->value();
if(o->value() == 1){
  chkUSEHAMLIB->value(0);
  chkUSERIGCAT->value(0);
  chkUSEXMLRPC->value(0);
  progdefaults.chkUSEHAMLIBis = false;
  progdefaults.chkUSERIGCATis = false;
  progdefaults.chkUSEXMLRPCis = false;
}
  
btnInitMEMMAP->labelcolor(FL_RED);
btnInitMEMMAP->redraw_label();
progdefaults.changed = true;}
                tooltip {Rig control via memory mapped Kachina} xywh {177 153 120 20} down_box DOWN_BOX
                code0 {o->value(progdefaults.chkUSEMEMMAPis);}
              }
              Fl_Round_Button btnMEMMAPptt {
                label {Use Memmap PTT}
                callback {progdefaults.MEMMAPptt=o->value();

btnInitMEMMAP->labelcolor(FL_RED);
btnInitMEMMAP->redraw_label();
progdefaults.changed = true;}
                xywh {177 183 150 20} down_box DOWN_BOX selection_color 1
              }
              Fl_Button btnInitMEMMAP {
                label Initialize
                callback {progdefaults.initInterface();
o->labelcolor(FL_FOREGROUND_COLOR);
progdefaults.changed = true;}
                tooltip {Initialize Memmap interface} xywh {214 213 113 24}
              }
            }
          }
          Fl_Group tabXMLRPC {
            label {XML-RPC} open
            xywh {0 48 540 320} hide
          } {
            Fl_Group grpXMLRPC {open
              xywh {23 61 490 160} box ENGRAVED_FRAME
            } {
              Fl_Output {} {
                xywh {178 80 190 58} type Multiline box BORDER_BOX color 50
                code0 {o->value(_("Rig control via external\\nprogram using xmlrpc\\nremote calls."));}
              }
              Fl_Check_Button chkUSEXMLRPC {
                label {Use XML-RPC program}
                callback {progdefaults.chkUSEXMLRPCis = o->value();
if(o->value() == 1){
  chkUSEHAMLIB->value(0);
  chkUSERIGCAT->value(0);
  chkUSEMEMMAP->value(0);
  progdefaults.chkUSEMEMMAPis = false;
  progdefaults.chkUSEHAMLIBis = false;
  progdefaults.chkUSERIGCATis = false;
}
  
btnInitXMLRPC->labelcolor(FL_RED);
btnInitXMLRPC->redraw_label();
progdefaults.changed = true;}
                tooltip Experimental xywh {178 148 183 20} down_box DOWN_BOX
              }
              Fl_Button btnInitXMLRPC {
                label Initialize
                callback {progdefaults.initInterface();
o->labelcolor(FL_FOREGROUND_COLOR);
progdefaults.changed = true;}
                tooltip {Initialize XML-RPC rig control} xywh {219 184 113 24}
              }
            }
          }
        }
      }
      Fl_Group tabSoundCard {
        label Audio open
        tooltip {Audio devices} xywh {0 25 540 345} hide
      } {
        Fl_Tabs tabsSoundCard {open
          xywh {0 25 540 345} selection_color 50
        } {
          Fl_Group tabAudio {
            label Devices open
            xywh {0 50 540 320}
          } {
            Fl_Group AudioOSS {open
              xywh {20 65 490 45} box ENGRAVED_FRAME
            } {
              Fl_Round_Button {btnAudioIO[0]} {
                label OSS
                callback {sound_update(SND_IDX_OSS);
progdefaults.changed = true;
resetSoundCard();}
                tooltip {Use OSS audio server} xywh {30 75 53 25} down_box DOWN_BOX selection_color 1
              }
              Fl_Input_Choice menuOSSDev {
                label {Device:}
                callback {scDevice[0] = scDevice[1] = progdefaults.OSSdevice = o->value();
resetSoundCard();
progdefaults.changed = true;} open
                tooltip {Select device} xywh {390 75 110 25}
                code0 {o->value(progdefaults.OSSdevice.c_str());}
              } {}
            }
            Fl_Group AudioPort {open
              xywh {20 110 490 80} box ENGRAVED_FRAME
            } {
              Fl_Round_Button {btnAudioIO[1]} {
                label PortAudio
                callback {sound_update(SND_IDX_PORT);
progdefaults.changed = true;
resetSoundCard();}
                tooltip {Use Port Audio server} xywh {30 138 95 25} down_box DOWN_BOX selection_color 1
              }
              Fl_Choice menuPortInDev {
                label {Capture:}
                callback {scDevice[0] = progdefaults.PortInDevice = o->text();
progdefaults.PortInIndex = reinterpret_cast<intptr_t>(o->mvalue()->user_data());
resetSoundCard();
progdefaults.changed = true;} open
                tooltip {Audio input device} xywh {230 120 270 25} down_box BORDER_BOX
              } {}
              Fl_Choice menuPortOutDev {
                label {Playback:}
                callback {scDevice[1] = progdefaults.PortOutDevice = o->text();
progdefaults.PortOutIndex = reinterpret_cast<intptr_t>(o->mvalue()->user_data());
resetSoundCard();
progdefaults.changed = true;} open
                tooltip {Audio output device} xywh {230 155 270 25} down_box BORDER_BOX
              } {}
            }
            Fl_Group AudioPulse {open
              xywh {20 190 490 45} box ENGRAVED_FRAME
            } {
              Fl_Round_Button {btnAudioIO[2]} {
                label PulseAudio
                callback {sound_update(SND_IDX_PULSE);
progdefaults.changed = true;
resetSoundCard();}
                tooltip {Use Pulse Audio server} xywh {30 201 100 25} down_box DOWN_BOX selection_color 1
              }
              Fl_Input inpPulseServer {
                label {Server string:}
                callback {scDevice[0] = scDevice[1] = progdefaults.PulseServer = o->value();
resetSoundCard();
progdefaults.changed = true;}
                tooltip {Leave this blank or refer to
http://www.pulseaudio.org/wiki/ServerStrings} xywh {275 201 225 25}
                code0 {o->value(progdefaults.PulseServer.c_str());}
                code1 {inpPulseServer->labelsize(FL_NORMAL_SIZE);}
                class Fl_Input2
              }
            }
            Fl_Group AudioNull {open
              xywh {20 235 490 45} box ENGRAVED_FRAME
            } {
              Fl_Round_Button {btnAudioIO[3]} {
                label {File I/O only}
                callback {sound_update(SND_IDX_NULL);
progdefaults.changed = true;
resetSoundCard();}
                tooltip {NO AUDIO DEVICE AVAILABLE (or testing)} xywh {31 245 100 25} down_box DOWN_BOX selection_color 1
              }
            }
          }
          Fl_Group tabAudioOpt {
            label Settings open
            xywh {0 50 540 320} hide
          } {
            Fl_Group grpAudioSampleRate {
              label {Sample rate} open
              xywh {23 65 490 90} box ENGRAVED_FRAME align 21
            } {
              Fl_Choice menuInSampleRate {
                label Capture
                callback {progdefaults.in_sample_rate = o->value() > 1 ? strtol(o->mvalue()->text, 0, 10) : o->value();
resetSoundCard();
progdefaults.changed = true;} open
                tooltip {Force a specific sample rate. Select "Native" if "Auto"
does not work well with your audio device.} xywh {33 94 100 20} down_box BORDER_BOX align 8
                code0 {//extern Fl_Menu_Item sample_rate_menu[];}
                code1 {//o->menu(sample_rate_menu);}
                code2 {o->clear_changed();}
              } {}
              Fl_Choice menuOutSampleRate {
                label Playback
                callback {progdefaults.out_sample_rate = o->value() > 1 ? strtol(o->mvalue()->text, 0, 10) : o->value();
resetSoundCard();
progdefaults.changed = true;} open
                xywh {33 124 100 20} down_box BORDER_BOX align 8
                code0 {//extern Fl_Menu_Item sample_rate_menu[];}
                code1 {//o->menu(sample_rate_menu);}
                code2 {o->clear_changed();}
                code3 {o->tooltip(menuInSampleRate->tooltip());}
              } {}
              Fl_Choice menuSampleConverter {
                label Converter
                callback {if (o->value() == FLDIGI_SRC_BEST)
    fl_alert2("The best quality SINC interpolator has very high CPU overhead");
progdefaults.sample_converter = sample_rate_converters[o->value()];
resetSoundCard();
progdefaults.changed = true;
o->tooltip(src_get_description(sample_rate_converters[o->value()]));} open
                tooltip {Set the type of resampler used of offset correction} xywh {287 94 216 20} down_box BORDER_BOX align 1
                code0 {\#include <FL/fl_ask.H>}
              } {}
            }
            Fl_Group {} {
              label Corrections open
              xywh {23 155 490 62} box ENGRAVED_FRAME align 21
            } {
              Fl_Spinner cntRxRateCorr {
                label {RX ppm}
                callback {progdefaults.RX_corr = (int)o->value();
progdefaults.changed = true;}
                tooltip {RX sound card correction} xywh {33 185 85 20} align 8
                code0 {o->step(1);}
                code1 {o->minimum(-50000);}
                code2 {o->maximum(50000);}
                code3 {o->labelsize(FL_NORMAL_SIZE);}
                class Fl_Spinner2
              }
              Fl_Spinner cntTxRateCorr {
                label {TX ppm}
                callback {progdefaults.TX_corr = (int)o->value();
progdefaults.changed = true;}
                tooltip {TX sound card correction} xywh {194 185 85 20} align 8
                code0 {o->step(1);}
                code1 {o->minimum(-50000);}
                code2 {o->maximum(50000);}
                code3 {o->labelsize(FL_NORMAL_SIZE);}
                class Fl_Spinner2
              }
              Fl_Spinner cntTxOffset {
                label {TX offset}
                callback {progdefaults.TxOffset = (int)o->value();
progdefaults.changed = true;}
                tooltip {Difference between Rx & Tx freq (rig offset)} xywh {356 185 85 20} align 8
                code0 {o->value(progdefaults.TxOffset);}
                code1 {o->step(1);}
                code2 {o->minimum(-50); o->maximum(50);}
                code3 {o->labelsize(FL_NORMAL_SIZE);}
                class Fl_Spinner2
              }
            }
          }
          Fl_Group tabMixer {
            label Mixer open
            xywh {0 50 540 320} hide
          } {
            Fl_Group {} {
              label {OSS mixer} open
              xywh {23 69 490 145} box ENGRAVED_FRAME align 21
            } {
              Fl_Check_Button btnMixer {
                label {Manage mixer}
                callback {enableMixer(o->value());
progdefaults.changed = true;}
                tooltip {Add mixer controls to main dialog} xywh {33 98 125 25} down_box DOWN_BOX
                code0 {extern void resetMixerControls();}
                code1 {o->value(progdefaults.EnableMixer);}
              }
              Fl_Input_Choice menuMix {
                label {Device:}
                callback {progdefaults.MXdevice = o->value();
enableMixer(false);
enableMixer(true);
progdefaults.changed = true;} open
                tooltip {Select Mixer device} xywh {179 141 110 25}
                code0 {o->value(progdefaults.MXdevice.c_str());}
              } {}
              Fl_Light_Button btnMicIn {
                label {Mic In}
                callback {if (o->value() == 1) {
    btnLineIn->value(0);
    progdefaults.LineIn = false;
    progdefaults.MicIn = true;
    setMixerInput(2);
} else {
    setMixerInput(0);
    progdefaults.MicIn = false;
}
progdefaults.changed = true;}
                tooltip {Use microphone input} xywh {299 102 74 25}
              }
              Fl_Light_Button btnLineIn {
                label {Line In}
                callback {if (o->value() == 1) {
    btnMicIn->value(0);
    progdefaults.LineIn = true;
    progdefaults.MicIn = false;
    setMixerInput(1);
} else {
    setMixerInput(0);
    progdefaults.LineIn = false;
}
progdefaults.changed = true;}
                tooltip {Use Line-In device} xywh {299 141 74 25} selection_color 3
                code0 {extern void setMixerInput(int);}
              }
              Fl_Value_Slider valPCMvolume {
                label PCM
                callback {setPCMvolume(o->value());
progdefaults.changed = true;}
                tooltip {Set the sound card PCM level} xywh {33 176 340 20} type Horizontal selection_color 15 align 8 value 0.8 textsize 14
                code0 {extern void setPCMvolume(double);}
                code1 {o->labelsize(FL_NORMAL_SIZE); o->textsize(FL_NORMAL_SIZE);}
                class Fl_Value_Slider2
              }
            }
          }
          Fl_Group tabAudioRightChannel {
            label {Right channel} open
            xywh {0 50 540 320} hide
          } {
            Fl_Check_Button chkForceMono {
              label {Mono audio output}
              callback {progdefaults.mono_audio = o->value();
progdefaults.changed = true;
if (o->value()) {
  progdefaults.QSK = false;
  btnQSK->value(0);
  btnQSK2->value(0);
  progdefaults.PseudoFSK = false;
  chkPseudoFSK->value(0);
  chkPseudoFSK2->value(0);
  progdefaults.PTTrightchannel = false;
  btnPTTrightchannel->value(0);
  btnPTTrightchannel2->value(0);  
  progdefaults.sig_on_right_channel = false;
  chkAudioStereoOut->value(0);
  progdefaults.ReverseAudio = false;
  chkReverseAudio->value(0);
}
resetSoundCard();}
              tooltip {Force output audio to single channel} xywh {112 63 280 20} down_box DOWN_BOX
              code0 {chkForceMono->value(progdefaults.mono_audio);}
            }
            Fl_Check_Button chkAudioStereoOut {
              label {Modem signal on left and right channels}
              callback {progdefaults.sig_on_right_channel = o->value();
progdefaults.changed = true;
if (o->value()) {
  progdefaults.QSK = false;
  btnQSK->value(0);
  btnQSK2->value(0);
  progdefaults.PseudoFSK = false;
  chkPseudoFSK->value(0);
  chkPseudoFSK2->value(0);
  progdefaults.PTTrightchannel = false;
  btnPTTrightchannel->value(0);
  btnPTTrightchannel2->value(0);  
  if (progdefaults.mono_audio) {
    progdefaults.mono_audio = false;
    chkForceMono->value(0);
    resetSoundCard();
  }
}}
              tooltip {Left and right channels both contain modem audio} xywh {112 95 280 20} down_box DOWN_BOX
              code0 {chkAudioStereoOut->value(progdefaults.sig_on_right_channel);}
            }
            Fl_Check_Button chkReverseAudio {
              label {Reverse Left/Right channels}
              callback {progdefaults.ReverseAudio = o->value();
progdefaults.changed = true;
  if (progdefaults.mono_audio) {
    progdefaults.mono_audio = false;
    chkForceMono->value(0);
    resetSoundCard();
  }}
              tooltip {Software reversal of left-right audio channels} xywh {112 127 270 20} down_box DOWN_BOX
              code0 {o->value(progdefaults.ReverseAudio);}
            }
            Fl_Group {} {
              label {...
These controls are on other tabs.
They are replicated here for convenience.
You may change the state from either location.
...} open
              xywh {39 165 454 187} box ENGRAVED_FRAME align 18
            } {
              Fl_Check_Button btnPTTrightchannel2 {
                label {PTT tone on right audio channel }
                callback {progdefaults.PTTrightchannel = o->value();
btnPTTrightchannel->value(o->value());
progdefaults.changed = true;
if (o->value()) {
  progdefaults.QSK = false;
  btnQSK->value(0);
  btnQSK2->value(0);
  progdefaults.PseudoFSK = false;
  chkPseudoFSK->value(0);
  chkPseudoFSK2->value(0);
  progdefaults.sig_on_right_channel = false;
  chkAudioStereoOut->value(0);
  if (progdefaults.mono_audio) {
    progdefaults.mono_audio = false;
    chkForceMono->value(0);
    resetSoundCard();
  }
}}
                tooltip {1000 Hz tone when PTT enabled
Can be used in lieu of or in addition to other PTT types} xywh {112 175 250 20} down_box DOWN_BOX
                code0 {o->value(progdefaults.PTTrightchannel);}
              }
              Fl_Check_Button btnQSK2 {
                label {CW QSK signal on right channel}
                callback {progdefaults.QSK = o->value();
btnQSK->value(o->value());
progdefaults.changed = true;
if (o->value()) {
  progdefaults.sig_on_right_channel = false;
  chkAudioStereoOut->value(0);
  progdefaults.PTTrightchannel = false;
  btnPTTrightchannel->value(0);
  btnPTTrightchannel2->value(0);
  if (progdefaults.mono_audio) {
    progdefaults.mono_audio = false;
    chkForceMono->value(0);
    resetSoundCard();
  }
}}
                tooltip {Generate 1000 Hz square wave signal on right channel} xywh {112 213 211 20} down_box DOWN_BOX
                code0 {o->value(progdefaults.QSK);}
              }
              Fl_Check_Button chkPseudoFSK2 {
                label {Pseudo-FSK on right audio channel}
                callback {progdefaults.PseudoFSK = o->value();
chkPseudoFSK->value(o->value());
progdefaults.changed = true;
if (o->value()) {
  progdefaults.sig_on_right_channel = false;
  chkAudioStereoOut->value(0);
  progdefaults.PTTrightchannel = false;
  btnPTTrightchannel->value(0);
  btnPTTrightchannel2->value(0);
  if (progdefaults.mono_audio) {
    progdefaults.mono_audio = false;
    chkForceMono->value(0);
    resetSoundCard();
  }
}}
                tooltip {Create 1000 Hz square wave on right channel} xywh {112 251 270 20} down_box DOWN_BOX
                code0 {o->value(progdefaults.PseudoFSK);}
              }
            }
          }
        }
      }
      Fl_Group tabID {
        label ID
        xywh {0 25 540 346} hide
      } {
        Fl_Group {} {
          label {Video Preamble ID} open
          xywh {22 35 490 103} box ENGRAVED_FRAME align 21
        } {
          Fl_Check_Button btnsendid {
            label {Transmit mode ID}
            callback {progdefaults.sendid=o->value();
progdefaults.changed = true;}
            tooltip {Waterfall video ID} xywh {32 58 150 20} down_box DOWN_BOX
          }
          Fl_Check_Button btnsendvideotext {
            label {Transmit video text}
            callback {progdefaults.sendtextid=o->value();
progdefaults.changed = true;}
            tooltip {Waterfall video text} xywh {32 83 155 20} down_box DOWN_BOX
            code0 {o->value(progdefaults.sendtextid);}
          }
          Fl_Input valVideotext {
            label {:}
            callback {progdefaults.strTextid = o->value();
progdefaults.changed = true;}
            tooltip {Limit to a few characters,
as in CQEM or IOTA etc.} xywh {199 83 161 20}
            code0 {o->value(progdefaults.strTextid.c_str());}
            code1 {valVideotext->labelsize(FL_NORMAL_SIZE);}
            class Fl_Input2
          }
          Fl_Check_Button chkID_SMALL {
            label {Use small font}
            callback {progdefaults.ID_SMALL=o->value();
progdefaults.changed = true;}
            tooltip {ON - small font
OFF - large font} xywh {32 109 120 20} down_box DOWN_BOX value 1
            code0 {o->value(progdefaults.ID_SMALL);}
          }
          Fl_Value_Slider sldrVideowidth {
            label {Chars/Row:}
            callback {progdefaults.videowidth = (int)o->value();
progdefaults.changed = true;}
            tooltip {Set the number of characters per row} xywh {260 109 100 20} type Horizontal align 4 minimum 1 maximum 8 step 1 value 4 textsize 14
            code0 {o->value(progdefaults.videowidth);}
            code2 {o->labelsize(FL_NORMAL_SIZE); o->textsize(FL_NORMAL_SIZE);}
            class Fl_Value_Slider2
          }
          Fl_Check_Button btn_vidlimit {
            label {500 Hz limit}
            callback {progdefaults.vidlimit=o->value();
progdefaults.changed = true;}
            xywh {369 85 110 15} down_box DOWN_BOX
            code0 {o->value(progdefaults.vidlimit);}
          }
          Fl_Check_Button btn_vidmodelimit {
            label {Mode width limit}
            callback {progdefaults.vidmodelimit=o->value();
progdefaults.changed=true;}
            xywh {369 111 110 15} down_box DOWN_BOX
            code0 {o->value(progdefaults.vidmodelimit);}
          }
          Fl_Button bVideoIDModes {
            label {Video ID modes}
            callback {mode_browser->label(o->label());
mode_browser->callback(0);
mode_browser->show(&progdefaults.videoid_modes);
progdefaults.changed = true;}
            xywh {240 58 120 20}
          }
        }
        Fl_Group sld {
          label {CW Postamble ID} open
          xywh {22 138 490 60} box ENGRAVED_FRAME align 21
        } {
          Fl_Check_Button btnCWID {
            label {Transmit callsign}
            callback {progdefaults.CWid = o->value();
progdefaults.changed = true;}
            tooltip {Send Callsign in CW at end of every transmission} xywh {32 165 140 20} down_box DOWN_BOX
            code0 {o->value(progdefaults.CWid);}
          }
          Fl_Value_Slider sldrCWIDwpm {
            label {Speed (WPM):}
            callback {progdefaults.CWIDwpm = (int)o->value();
progdefaults.changed = true;}
            tooltip {Send at this WPM} xywh {182 165 180 20} type Horizontal align 1 minimum 15 maximum 40 step 1 value 18 textsize 14
            code0 {o->value(progdefaults.CWIDwpm);}
            code1 {o->labelsize(FL_NORMAL_SIZE); o->textsize(FL_NORMAL_SIZE);}
            class Fl_Value_Slider2
          }
          Fl_Button bCWIDModes {
            label {CW ID modes}
            callback {mode_browser->label(o->label());
mode_browser->callback(0);
mode_browser->show(&progdefaults.cwid_modes);
progdefaults.changed = true;}
            xywh {382 165 120 20}
          }
        }
        Fl_Group {} {
          label {Reed-Solomon ID (Rx)} open
          xywh {22 198 295 167} box ENGRAVED_FRAME align 21
        } {
          Fl_Check_Button chkRSidWideSearch {
            label {Detector searches entire passband}
            callback {progdefaults.rsidWideSearch=o->value();
progdefaults.changed = true;}
            tooltip {ON - search over entire waterfall
OFF - limit search to +/- 200 Hz} xywh {32 247 270 20} down_box DOWN_BOX
            code0 {o->value(progdefaults.rsidWideSearch);}
          }
          Fl_Check_Button chkRSidMark {
            label {Mark previous frequency and mode}
            callback {progdefaults.rsid_mark = o->value();
progdefaults.changed = true;}
            tooltip {Insert RX text marker before
changing frequency and modem} xywh {32 270 270 20} down_box DOWN_BOX
            code0 {chkRSidMark->value(progdefaults.rsid_mark);}
          }
          Fl_Check_Button chkRSidAutoDisable {
            label {Reception disables detector}
            callback {progdefaults.rsid_auto_disable = o->value();
progdefaults.changed = true;}
            tooltip {Disable further detection when RSID is received} xywh {32 293 200 20} down_box DOWN_BOX
            code0 {if (progdefaults.rsid_notify_only) progdefaults.rsid_auto_disable = false;}
            code1 {chkRSidAutoDisable->value(progdefaults.rsid_auto_disable);}
            code2 {if (progdefaults.rsid_notify_only) chkRSidAutoDisable->deactivate();}
          }
          Fl_Check_Button chkRSidNotifyOnly {
            label {Notifications only}
            callback {progdefaults.rsid_notify_only = o->value();
notify_create_rsid_event(progdefaults.rsid_notify_only);
if (progdefaults.rsid_notify_only) {
    chkRSidAutoDisable->value(0);
    chkRSidAutoDisable->deactivate();
}
else
    chkRSidAutoDisable->activate();
progdefaults.changed = true;}
            tooltip {Check this to be notified when an RSID is received
without changing modem and frequency} xywh {32 317 155 20} down_box DOWN_BOX
            code0 {chkRSidNotifyOnly->value(progdefaults.rsid_notify_only);}
          }
          Fl_Button bRSIDRxModes {
            label {Receive modes}
            callback {mode_browser->label(o->label());
mode_browser->callback(0);
mode_browser->show(&progdefaults.rsid_rx_modes);
progdefaults.changed = true;}
            xywh {32 224 130 20}
          }
          Fl_Value_Slider sldrRSIDsquelch {
            label {Squelch open (sec)}
            callback {progdefaults.rsid_squelch = (int)o->value();
progdefaults.changed = true;}
            tooltip {Open squelch for nn sec if RSID detected} xywh {32 339 144 20} type Horizontal align 8 maximum 20 step 1 textsize 14
            code0 {o->value(progdefaults.rsid_squelch);}
            code2 {o->labelsize(FL_NORMAL_SIZE); o->textsize(FL_NORMAL_SIZE);}
            class Fl_Value_Slider2
          }
        }
        Fl_Group {} {
          label {Reed-Solomon ID (Tx)} open
          xywh {317 198 195 85} box ENGRAVED_FRAME align 21
        } {
          Fl_Button bRSIDTxModes {
            label {Transmit modes}
            callback {mode_browser->label(o->label());
mode_browser->callback(0);
mode_browser->show(&progdefaults.rsid_tx_modes);
progdefaults.changed = true;}
            xywh {345 222 130 20}
          }
          Fl_Check_Button btn_post_rsid {
            label {End of xmt ID}
            callback {progdefaults.rsid_post=o->value();
progdefaults.changed = true;}
            tooltip {Add RsID signal to end of transmission} xywh {345 256 70 15} down_box DOWN_BOX
            code0 {o->value(progdefaults.rsid_post);}
          }
        }
        Fl_Group {} {
          label {Pre-Signal Tone} open
          xywh {317 284 195 80} box ENGRAVED_FRAME align 21
        } {
          Fl_Counter val_pretone {
            label Seconds
            callback {progdefaults.pretone = o->value();
progdefaults.changed = true;}
            tooltip {Use for triggering amplifier carrier detect} xywh {340 310 140 21} minimum 0 maximum 10
            code0 {o->value(progdefaults.pretone);}
          }
        }
      }
      Fl_Group tabMisc {
        label Misc open
        xywh {0 25 540 345} hide
      } {
        Fl_Tabs tabsMisc {open
          xywh {0 25 540 345} selection_color 50
        } {
          Fl_Group tabCPUspeed {
            label CPU open
            xywh {0 50 540 320}
          } {
            Fl_Group {} {open
              xywh {25 75 490 51} box ENGRAVED_FRAME align 21
            } {
              Fl_Check_Button chkSlowCpu {
                label {Slow CPU (less than 700MHz)}
                callback {progdefaults.slowcpu = o->value();
progdefaults.changed = true;}
                tooltip {Enable if you're computer does not decode properly} xywh {171 90 225 20} down_box DOWN_BOX
                code0 {o->value(progdefaults.slowcpu);}
              }
            }
          }
          Fl_Group tabNBEMS {
            label NBEMS open
            xywh {0 50 540 320} hide
          } {
            Fl_Group {} {
              label {NBEMS data file interface} open
              xywh {26 65 490 75} box ENGRAVED_FRAME align 21
            } {
              Fl_Check_Button chkAutoExtract {
                label Enable
                callback {progdefaults.autoextract = o->value();
progdefaults.changed = true;}
                tooltip {Extract files for use with external "wrap / flmsg" program} xywh {46 100 75 20} down_box DOWN_BOX
                code0 {o->value(progdefaults.autoextract);}
              }
              Fl_Check_Button chk_open_wrap_folder {
                label {Open message folder}
                callback {progdefaults.open_nbems_folder = o->value();
progdefaults.changed = true;}
                tooltip {Opens NBEMS file folder upon successful capture} xywh {280 100 146 20} down_box DOWN_BOX
                code0 {o->value(progdefaults.open_nbems_folder);}
              }
            }
            Fl_Group {} {
              label {Reception of flmsg file} open
              xywh {26 141 490 95} box ENGRAVED_FRAME align 21
            } {
              Fl_Check_Button chk_open_flmsg {
                label {Open with flmsg}
                callback {progdefaults.open_flmsg = o->value();
progdefaults.changed = true;}
                tooltip {Open message with flmsg} xywh {46 168 136 20} down_box DOWN_BOX
                code0 {o->value(progdefaults.open_flmsg);}
              }
              Fl_Input txt_flmsg_pathname {
                label {flmsg:}
                callback {progdefaults.flmsg_pathname = o->value();
progdefaults.changed = true;}
                tooltip {Enter full path-filename for flmsg} xywh {78 199 330 24} when 1
                code0 {o->value(progdefaults.flmsg_pathname.c_str());}
                class Fl_Input2
              }
              Fl_Button btn_select_flmsg {
                label {Locate flmsg}
                callback {select_flmsg_pathname();}
                tooltip {Locate flmsg executable} xywh {411 199 100 24}
              }
              Fl_Check_Button chk_open_flmsg_print {
                label {Open in browser}
                callback {progdefaults.open_flmsg_print = o->value();
progdefaults.changed = true;}
                tooltip {Open file with default browser} xywh {280 168 136 20} down_box DOWN_BOX
                code0 {o->value(progdefaults.open_flmsg_print);}
              }
            }
          }
          Fl_Group tabPskmail {
            label Pskmail open
            xywh {0 50 540 320} align 5 hide
          } {
            Fl_Group {} {
              label {Mail Server Attributes} open
              xywh {26 58 490 174} box ENGRAVED_FRAME align 21
            } {
              Fl_Counter cntServerCarrier {
                label {Carrier frequency (Hz)}
                callback {progdefaults.ServerCarrier = (int)o->value();
wf->redraw_marker();
progdefaults.changed = true;}
                tooltip {Default listen / transmit frequency} xywh {77 86 80 20} type Simple align 8 minimum 500 maximum 2500 step 25 value 1500
                code0 {o->value(progdefaults.ServerCarrier);}
                code1 {o->labelsize(FL_NORMAL_SIZE);}
                class Fl_Counter2
              }
              Fl_Counter cntServerOffset {
                label {Search range (Hz)}
                callback {progdefaults.ServerOffset = (int)o->value();
wf->redraw_marker();
progdefaults.changed = true;}
                tooltip {Listen for signals within this range} xywh {77 123 80 20} type Simple align 8 minimum 10 maximum 500 step 10 value 100
                code0 {o->value(progdefaults.SearchRange);}
                code1 {o->labelsize(FL_NORMAL_SIZE);}
                class Fl_Counter2
              }
              Fl_Counter cntServerACQsn {
                label {Acquisition S/N (dB)}
                callback {progdefaults.ServerACQsn = o->value();
progdefaults.changed = true;}
                tooltip {Capture signals over this threshold} xywh {77 160 80 20} type Simple align 8 minimum 3 maximum 20 step 1 value 6
                code0 {o->value(progdefaults.ServerACQsn);}
                code1 {o->labelsize(FL_NORMAL_SIZE);}
                class Fl_Counter2
              }
              Fl_Counter cntServerAFCrange {
                label {AFC range (Hz)}
                callback {progdefaults.ServerAFCrange = (int)o->value();
wf->redraw_marker();
progdefaults.changed = true;}
                tooltip {Limit AFC movement to this range} xywh {77 197 80 20} type Simple align 8 minimum 10 maximum 500 step 10 value 25
                code0 {o->value(progdefaults.SearchRange);}
                code1 {o->labelsize(FL_NORMAL_SIZE);}
                class Fl_Counter2
              }
              Fl_Check_Button btnPSKmailSweetSpot {
                label {Reset to Carrier}
                callback {progdefaults.PSKmailSweetSpot = o->value();
progdefaults.changed = true;}
                tooltip {When no signal present} xywh {332 86 142 20} down_box DOWN_BOX value 1
                code0 {o->value(progdefaults.PSKmailSweetSpot);}
              }
            }
            Fl_Group {} {
              label General open
              xywh {26 234 490 131} box ENGRAVED_FRAME align 21
            } {
              Fl_Check_Button btn_arq_s2n_report {
                label {Report ARQ frames average S/N}
                callback {progdefaults.Pskmails2nreport=o->value();}
                xywh {51 259 250 20} down_box DOWN_BOX
                code0 {o->value(progdefaults.Pskmails2nreport);}
              }
            }
          }
          Fl_Group tabSpot {
            label Spotting open
            xywh {0 50 540 320} hide
          } {
            Fl_Group {} {
              label {PSK Reporter} open
              xywh {30 72 490 215} box ENGRAVED_FRAME align 21
            } {
              Fl_Check_Button btnPSKRepAuto {
                label {Automatically spot callsigns in decoded text}
                callback {progdefaults.pskrep_auto = o->value();
btnPSKRepInit->labelcolor(FL_RED);
btnPSKRepInit->redraw_label();
progdefaults.changed = true;}
                tooltip {Parse all incoming text} xywh {40 103 324 20} down_box DOWN_BOX
                code0 {btnPSKRepAuto->value(progdefaults.pskrep_auto);}
              }
              Fl_Check_Button btnPSKRepLog {
                label {Send reception report when logging a QSO}
                callback {progdefaults.pskrep_log = o->value();
btnPSKRepInit->labelcolor(FL_RED);
btnPSKRepInit->redraw_label();
progdefaults.changed = true;}
                tooltip {Send report only when QSO is logged} xywh {40 133 327 20} down_box DOWN_BOX
                code0 {btnPSKRepLog->value(progdefaults.pskrep_log);}
              }
              Fl_Check_Button btnPSKRepQRG {
                label {Report rig frequency (enable only if you have rig control!)}
                callback {progdefaults.pskrep_qrg = o->value();
progdefaults.changed = true;}
                tooltip {Include the transmit frequency} xywh {40 163 416 20} down_box DOWN_BOX
                code0 {btnPSKRepQRG->value(progdefaults.pskrep_qrg);}
              }
              Fl_Input inpPSKRepHost {
                label {Host:}
                callback {progdefaults.pskrep_host = o->value();
btnPSKRepInit->labelcolor(FL_RED);
btnPSKRepInit->redraw_label();
progdefaults.changed = true;}
                tooltip {To whom the connection is made} xywh {81 203 220 24} when 1
                code0 {inpPSKRepHost->value(progdefaults.pskrep_host.c_str());}
                code1 {inpPSKRepHost->labelsize(FL_NORMAL_SIZE);}
                class Fl_Input2
              }
              Fl_Input inpPSKRepPort {
                label {Port:}
                callback {progdefaults.pskrep_port = o->value();
btnPSKRepInit->labelcolor(FL_RED);
btnPSKRepInit->redraw_label();
progdefaults.changed = true;}
                tooltip {Using UDP port \#} xywh {450 203 60 24} when 1
                code0 {inpPSKRepPort->value(progdefaults.pskrep_port.c_str());}
                code1 {inpPSKRepPort->labelsize(FL_NORMAL_SIZE);}
                class Fl_Input2
              }
              Fl_Button btnPSKRepInit {
                label Initialize
                callback {pskrep_stop();
if (!pskrep_start()) {
    boxPSKRepMsg->copy_label(pskrep_error());
    progdefaults.usepskrep = false;
} else {
    boxPSKRepMsg->label(0);
    o->labelcolor(FL_FOREGROUND_COLOR);
    progdefaults.usepskrep = true;
}
progdefaults.changed = true;}
                tooltip {Initialize the socket client} xywh {430 248 80 24}
              }
              Fl_Box boxPSKRepMsg {
                label {<PSK Reporter error message>}
                xywh {40 232 300 48} labelfont 2
                code0 {boxPSKRepMsg->label(0);}
              }
            }
          }
          Fl_Group tabSweetSpot {
            label {Sweet Spot} open
            xywh {0 50 540 320} hide
          } {
            Fl_Group {} {open
              xywh {28 71 490 75} box ENGRAVED_FRAME align 21
            } {
              Fl_Value_Input valCWsweetspot {
                label CW
                callback {progdefaults.CWsweetspot=o->value();
progdefaults.changed = true;}
                tooltip {Default CW tracking point} xywh {65 82 65 20} minimum 200 maximum 4000 step 1 value 1000
                code0 {o->value(progdefaults.CWsweetspot);}
                code1 {o->labelsize(FL_NORMAL_SIZE);}
                class Fl_Value_Input2
              }
              Fl_Value_Input valRTTYsweetspot {
                label RTTY
                callback {progdefaults.RTTYsweetspot=o->value();
progdefaults.changed = true;}
                tooltip {Default RTTY tracking point} xywh {243 82 65 20} minimum 200 maximum 4000 step 1 value 1000
                code0 {o->value(progdefaults.RTTYsweetspot);}
                code1 {o->labelsize(FL_NORMAL_SIZE);}
                class Fl_Value_Input2
              }
              Fl_Value_Input valPSKsweetspot {
                label {PSK et al.}
                callback {progdefaults.PSKsweetspot=o->value();
progdefaults.changed = true;}
                tooltip {Default for all other modems} xywh {443 82 65 20} minimum 200 maximum 4000 step 1 value 1000
                code0 {o->value(progdefaults.PSKsweetspot);}
                code1 {o->labelsize(FL_NORMAL_SIZE);}
                class Fl_Value_Input2
              }
              Fl_Check_Button btnStartAtSweetSpot {
                label {Always start new modems at these frequencies}
                callback {progdefaults.StartAtSweetSpot = o->value();
progdefaults.changed = true;}
                tooltip {ON - start at default
OFF - keep current wf cursor position} xywh {38 112 348 20} down_box DOWN_BOX value 1
                code0 {o->value(progdefaults.StartAtSweetSpot);}
              }
            }
            Fl_Group {} {
              label {K3 A1A configuation} open
              xywh {28 151 490 60} box ENGRAVED_FRAME align 21
            } {
              Fl_Check_Button btnCWIsLSB {
                label {CW is LSB}
                callback {progdefaults.CWIsLSB=o->value();
progdefaults.changed=true;}
                tooltip {Select this for Elecraft K3
Other radios should not need it.} xywh {243 172 70 15} down_box DOWN_BOX
                code0 {o->value(progdefaults.CWIsLSB);}
              }
            }
          }
          Fl_Group tabText_IO {
            label {Text i/o} open
            xywh {0 50 540 320} hide
          } {
            Fl_Group grpTalker {
              label {Talker Socket (MS only)} open
              xywh {29 132 490 73} box ENGRAVED_FRAME align 21
            } {
              Fl_Light_Button btnConnectTalker {
                label Talker
                callback {if (o->value()) open_talker();
else close_talker();}
                xywh {55 152 74 20} selection_color 60
                code0 {extern void open_talker();}
                code1 {extern void close_talker();}
              }
              Fl_Box {} {
                label {Connect/disconnect to Talker socket server}
                xywh {134 152 345 20} align 20
              }
              Fl_Check_Button btn_auto_talk {
                label {Auto connect when fldigi opens (server must be up)}
                callback {progdefaults.auto_talk = o->value();}
                xywh {55 180 391 15} down_box DOWN_BOX
                code0 {o->value(progdefaults.auto_talk);}
              }
            }
            Fl_Group {} {
              label {Capture rx text to external file} open
              xywh {29 72 490 56} box ENGRAVED_FRAME align 21
            } {
              Fl_Check_Button chkRxStream {
                label {Enable rx text stream}
                callback {progdefaults.speak = o->value();
progdefaults.changed = true;}
                tooltip {Send rx text to file: textout.txt} xywh {55 99 175 20} down_box DOWN_BOX
                code0 {o->value(progdefaults.speak);}
              }
            }
          }
          Fl_Group tabDTMF {
            label DTMF open
            xywh {0 50 540 320} hide
          } {
            Fl_Check_Button chkDTMFdecode {
              label {Decode DTMF tones}
              callback {progdefaults.DTMFdecode = o->value();}
              tooltip {Send rx text to file: textout.txt} xywh {187 103 175 20} down_box DOWN_BOX
              code0 {o->value(progdefaults.DTMFdecode);}
            }
          }
          Fl_Group tabWX {
            label WX open
            xywh {0 50 540 320} hide
          } {
            Fl_Group {} {
              label {Weather query specification} open
              xywh {27 60 490 300} box ENGRAVED_FRAME align 21
            } {
              Fl_Input inpWXsta {
                label {METAR station ID code}
                callback {progdefaults.wx_sta = o->value();
progdefaults.changed = true;}
                tooltip {for example KMDQ for 
Huntsville-Madison Executive Airport, AL} xywh {92 92 43 24} align 8
                code0 {o->value(progdefaults.wx_sta.c_str());}
              }
              Fl_Check_Button btn_wx_full {
                label {Full report}
                callback {progdefaults.wx_full=o->value();
progdefaults.changed = true;}
                tooltip {Insert full METAR report} xywh {229 130 70 15} down_box DOWN_BOX
                code0 {o->value(progdefaults.wx_full);}
              }
              Fl_Check_Button btn_wx_station_name {
                label {METAR station location}
                callback {progdefaults.wx_station_name = o->value();
progdefaults.changed = true;}
                tooltip {Add geopolitical name of METAR station} xywh {229 158 70 15} down_box DOWN_BOX
                code0 {o->value(progdefaults.wx_station_name);}
              }
              Fl_Check_Button btn_wx_condx {
                label Conditions
                callback {progdefaults.wx_condx=o->value();
progdefaults.changed = true;}
                tooltip {current wx conditions} xywh {229 186 70 15} down_box DOWN_BOX
                code0 {o->value(progdefaults.wx_condx);}
              }
              Fl_Check_Button btn_wx_fahrenheit {
                label Fahrenheit
                callback {progdefaults.wx_fahrenheit=o->value();
progdefaults.changed = true;}
                tooltip {report Fahrenheit} xywh {227 214 70 15} down_box DOWN_BOX
                code0 {o->value(progdefaults.wx_fahrenheit);}
              }
              Fl_Check_Button btn_wx_celsius {
                label Celsius
                callback {progdefaults.wx_celsius=o->value();
progdefaults.changed = true;}
                tooltip {report Celsius} xywh {358 214 70 15} down_box DOWN_BOX
                code0 {o->value(progdefaults.wx_celsius);}
              }
              Fl_Check_Button btn_wx_mph {
                label {Miles / Hour}
                callback {progdefaults.wx_mph=o->value();
progdefaults.changed = true;}
                tooltip {report miles per hour} xywh {227 242 70 15} down_box DOWN_BOX
                code0 {o->value(progdefaults.wx_mph);}
              }
              Fl_Check_Button btn_wx_kph {
                label {kilometers / hour}
                callback {progdefaults.wx_kph=o->value();
progdefaults.changed = true;}
                tooltip {report kilometers per hour} xywh {358 242 70 15} down_box DOWN_BOX
                code0 {o->value(progdefaults.wx_kph);}
              }
              Fl_Check_Button btn_wx_inches {
                label {Inches Mg.}
                callback {progdefaults.wx_inches=o->value();
progdefaults.changed = true;}
                tooltip {report inches mercury} xywh {227 271 70 15} down_box DOWN_BOX
                code0 {o->value(progdefaults.wx_inches);}
              }
              Fl_Check_Button btn_wx_mbars {
                label mbars
                callback {progdefaults.wx_mbars=o->value();
progdefaults.changed = true;}
                tooltip {report millibars} xywh {358 271 70 15} down_box DOWN_BOX
                code0 {o->value(progdefaults.wx_mbars);}
              }
              Fl_Box {} {
                label Temperature
                xywh {67 212 156 19} align 20
              }
              Fl_Box {} {
                label {Wind speed/dir}
                xywh {67 240 156 19} align 20
              }
              Fl_Box {} {
                label {Barometric pressure}
                xywh {67 269 156 19} align 20
              }
              Fl_Button btn_metar_search {
                label {Search on  web}
                callback {get_METAR_station();}
                xywh {308 92 130 24}
                code0 {\#include "weather.h"}
              }
            }
          }
        }
      }
      Fl_Group tabQRZ {
        label Web open
        tooltip {Callsign database} xywh {0 25 540 345} hide
      } {
        Fl_Tabs {} {open
          xywh {0 25 540 345}
        } {
          Fl_Group {} {
            label {Call Lookup} open
            xywh {0 46 540 324}
          } {
            Fl_Group {} {
              label {Web Browser lookup} open
              xywh {27 52 490 122} box ENGRAVED_FRAME align 21
            } {
              Fl_Round_Button btnQRZWEBnotavailable {
                label None
                callback {set_qrzweb_buttons(o);
progdefaults.QRZWEB = QRZWEBNONE;
progdefaults.changed = true;}
                tooltip {Do not use callsign lookup via web browser} xywh {49 78 337 20} down_box DOWN_BOX value 1
                code0 {o->value(progdefaults.QRZWEB == QRZWEBNONE);}
              }
              Fl_Round_Button btnQRZonline {
                label {QRZ online via default Internet Browser}
                callback {set_qrzweb_buttons(o);
progdefaults.QRZWEB = QRZHTML;
progdefaults.changed = true;}
                tooltip {Visit QRZ web site} xywh {49 102 337 20} down_box DOWN_BOX
                code0 {o->value(progdefaults.QRZWEB == QRZHTML);}
              }
              Fl_Round_Button btnHAMCALLonline {
                label {HamCall online via default Internet Browser}
                callback {set_qrzweb_buttons(o);
progdefaults.QRZWEB = HAMCALLHTML;
progdefaults.changed = true;}
                tooltip {Visit Hamcall web site} xywh {49 126 337 20} down_box DOWN_BOX
                code0 {o->value(progdefaults.QRZWEB == HAMCALLHTML);}
              }
              Fl_Round_Button btnHamQTHonline {
                label {HamQTH via default Internet Browser}
                callback {set_qrzweb_buttons(o);
progdefaults.QRZWEB = HAMQTHHTML;
progdefaults.changed = true;}
                tooltip {Visit hamQTH web site} xywh {49 150 337 20} down_box DOWN_BOX
                code0 {o->value(progdefaults.QRZWEB == HAMQTHHTML);}
              }
            }
            Fl_Group {} {
              label {Data base lookup} open
              xywh {27 176 490 190} box ENGRAVED_FRAME align 21
            } {
              Fl_Round_Button btnQRZXMLnotavailable {
                label None
                callback {set_qrzxml_buttons(o);
progdefaults.QRZXML = QRZXMLNONE;
progdefaults.changed = true;}
                tooltip {Do not use callsign database} xywh {49 199 337 20} down_box DOWN_BOX value 1
                code0 {o->value(progdefaults.QRZXML == QRZXMLNONE);}
              }
              Fl_Round_Button btnQRZcdrom {
                label {QRZ cdrom}
                callback {set_qrzxml_buttons(o);
progdefaults.QRZXML = QRZCD;
progdefaults.changed = true;}
                tooltip {Use CD or hard drive CD image} xywh {49 227 70 20} down_box DOWN_BOX
                code0 {o->value(progdefaults.QRZXML == QRZCD);}
              }
              Fl_Round_Button btnQRZsub {
                label {QRZ.com}
                callback {set_qrzxml_buttons(o);
progdefaults.QRZXML = QRZNET;
progdefaults.changed = true;}
                tooltip {You need a paid QRZ online
subscription to access} xywh {49 255 125 20} down_box DOWN_BOX
                code0 {o->value(progdefaults.QRZXML == QRZNET);}
              }
              Fl_Round_Button btnHamcall {
                label {Hamcall.net}
                callback {set_qrzxml_buttons(o);
progdefaults.QRZXML = HAMCALLNET;
progdefaults.changed = true;}
                tooltip {You need a paid Hamcall online
subscription to access} xywh {49 281 125 20} down_box DOWN_BOX
                code0 {o->value(progdefaults.QRZXML == HAMCALLNET);}
              }
              Fl_Round_Button btnHamQTH {
                label {HamQTH.com (free service http://www.hamqth.com)}
                callback {set_qrzxml_buttons(o);
progdefaults.QRZXML = HAMQTH;
progdefaults.changed = true;}
                tooltip {Free service courtesy of OK} xywh {49 307 125 20} down_box DOWN_BOX
                code0 {o->value(progdefaults.QRZXML == HAMQTH);}
              }
              Fl_Round_Button btnCALLOOK {
                label {Callook.info lookup (free service US callsigns only)}
                callback {set_qrzxml_buttons(o);
progdefaults.QRZXML = CALLOOK;
progdefaults.changed = true;}
                tooltip {Visit Hamcall web site} xywh {49 334 125 20} down_box DOWN_BOX
                code0 {o->value(progdefaults.QRZXML == CALLOOK);}
              }
              Fl_Input txtQRZpathname {
                label {at:}
                callback {progdefaults.QRZpathname = o->value();
progdefaults.QRZchanged = true;
progdefaults.changed = true;}
                tooltip {ie: /home/dave/CALLBK/ or C:/CALLBK/
Leave blank to search for database} xywh {174 227 300 20}
                code0 {o->value(progdefaults.QRZpathname.c_str());}
                code1 {txtQRZpathname->labelsize(FL_NORMAL_SIZE);}
                class Fl_Input2
              }
              Fl_Input inpQRZusername {
                label {User name}
                callback {progdefaults.QRZusername = o->value();
progdefaults.changed = true;}
                tooltip {Your login name} xywh {257 255 150 20}
                code0 {o->value(progdefaults.QRZusername.c_str());}
                code1 {inpQRZusername->labelsize(FL_NORMAL_SIZE);}
                class Fl_Input2
              }
              Fl_Input inpQRZuserpassword {
                label Password
                callback {progdefaults.QRZuserpassword = o->value();
progdefaults.changed = true;}
                tooltip {Your login password} xywh {257 281 150 20}
                code0 {o->value(progdefaults.QRZuserpassword.c_str());}
                code1 {o->type(FL_SECRET_INPUT);}
                code2 {inpQRZuserpassword->labelsize(FL_NORMAL_SIZE);}
                class Fl_Input2
              }
              Fl_Button btnQRZpasswordShow {
                label Show
                callback {inpQRZuserpassword->type(inpQRZuserpassword->type() ^ FL_SECRET_INPUT);
inpQRZuserpassword->redraw();
o->label((inpQRZuserpassword->type() & FL_SECRET_INPUT) ? "Show" : "Hide");}
                tooltip {Show password in plain text} xywh {417 281 70 20}
              }
            }
          }
          Fl_Group {} {
            label eQSL open
            xywh {0 50 540 320} hide
          } {
            Fl_Input inpEQSL_id {
              label {User ID}
              callback {progdefaults.eqsl_id = o->value();
progdefaults.changed = true;}
              tooltip {Your login name} xywh {194 58 150 20}
              code0 {o->value(progdefaults.eqsl_id.c_str());}
              code1 {inpEQSL_id->labelsize(FL_NORMAL_SIZE);}
              class Fl_Input2
            }
            Fl_Input inpEQSL_pwd {
              label Password
              callback {progdefaults.eqsl_pwd = o->value();
progdefaults.changed = true;}
              tooltip {Your login password} xywh {194 85 150 20}
              code0 {o->value(progdefaults.eqsl_pwd.c_str());}
              code1 {o->type(FL_SECRET_INPUT);}
              code2 {inpEQSL_pwd->labelsize(FL_NORMAL_SIZE);}
              class Fl_Input2
            }
            Fl_Button btnEQSL_pwd_show {
              label Show
              callback {inpEQSL_pwd->type(inpEQSL_pwd->type() ^ FL_SECRET_INPUT);
inpEQSL_pwd->redraw();
o->label((inpEQSL_pwd->type() & FL_SECRET_INPUT) ? "Show" : "Hide");}
              tooltip {Show password in plain text} xywh {362 85 70 20}
            }
            Fl_Input inpEQSL_nick {
              label {QTH Nickname}
              callback {progdefaults.eqsl_nick = o->value();
progdefaults.changed = true;}
              tooltip {Your login name} xywh {194 114 150 20}
              code0 {o->value(progdefaults.eqsl_nick.c_str());}
              code1 {inpEQSL_nick->labelsize(FL_NORMAL_SIZE);}
              class Fl_Input2
            }
            Fl_Group {} {
              label Options open
              xywh {22 141 492 223} box ENGRAVED_FRAME align 21
            } {
              Fl_Check_Button btn_send_when_logged {
                label {send when logged (log button, <LOG>, <LNW>)}
                callback {progdefaults.eqsl_when_logged = o->value();
progdefaults.changed = true;}
                tooltip {automatic data upload} xywh {47 166 70 15} down_box DOWN_BOX
                code0 {o->value(progdefaults.eqsl_when_logged);}
              }
              Fl_Input txt_eqsl_default_message {
                label {Default message}
                callback {progdefaults.eqsl_default_message = o->value();
progdefaults.changed = true;}
                tooltip {default text to send with <LOG> etc} xywh {51 226 451 40} type Multiline align 5 when 1
                code0 {o->value(progdefaults.eqsl_default_message.c_str());}
                class Fl_Input2
              }
              Fl_Group {} {
                label {Text Tags (tags use {} delimiters)} open
                xywh {26 270 484 90} box THIN_DOWN_BOX align 21
              } {
                Fl_Box eqsl_txt1 {
                  label {{CALL} other ops call sign}
                  xywh {32 317 220 17} align 20
                }
                Fl_Box eqsl_txt2 {
                  label {{MODE} full mode / submode}
                  xywh {30 336 220 17} align 20
                }
                Fl_Box eqsl_txt3 {
                  label {{NAME} other ops name}
                  xywh {278 317 220 17} align 20
                }
                Fl_Box {} {
                  label {These tags can also be used in <EQSL:[message]>}
                  xywh {46 293 440 17}
                }
              }
              Fl_Check_Button btn_send_datetime_off {
                label {Use date/time off for log entry}
                callback {progdefaults.eqsl_datetime_off = o->value();
progdefaults.changed = true;}
                tooltip {default uses date/time on} xywh {48 188 70 15} down_box DOWN_BOX
                code0 {o->value(progdefaults.eqsl_datetime_off);}
              }
            }
          }
        }
      }
      Fl_Group tabDL {
        label {DL Client} open
        xywh {0 25 540 350} selection_color 48 hide
      } {
        Fl_Tabs tabsDL {open
          xywh {0 25 540 348}
        } {
          Fl_Group tabDLEnable {
            label Enable open
            xywh {0 50 540 320}
          } {
            Fl_Group {} {
              label habitat open
              xywh {5 59 530 76} box ENGRAVED_FRAME align 21
            } {
              Fl_Check_Button confdialog_dl_online {
                label Online
                callback {if (o->value())
{
    dl_fldigi::commit();
    btnApplyConfig->deactivate();
}

dl_fldigi::online(o->value());}
                xywh {15 90 70 25} down_box DOWN_BOX
              }
              Fl_Input {} {
                label {Couch URI}
                callback {progdefaults.habitat_uri = o->value();
progdefaults.changed = true;
dl_fldigi::changed(dl_fldigi::CH_UTHR_SETTINGS);
btnApplyConfig->activate();}
                tooltip {Address of the CouchDB server} xywh {165 80 360 20}
                code0 {o->value(progdefaults.habitat_uri.c_str());}
              }
              Fl_Input {} {
                label {Couch DB}
                callback {progdefaults.habitat_db = o->value();
progdefaults.changed = true;
dl_fldigi::changed(dl_fldigi::CH_UTHR_SETTINGS);
btnApplyConfig->activate();}
                tooltip {CouchDB database name} xywh {165 106 360 19}
                code0 {o->value(progdefaults.habitat_db.c_str());}
              }
            }
            Fl_Group {} {
              label {SSDV Image Configuration} open
              xywh {5 140 530 80} box ENGRAVED_FRAME align 21
            } {
              Fl_Input imagepacketurl {
                label {Packet Upload URL:}
                callback {progdefaults.ssdv_packet_url = o->value();
progdefaults.changed = true;}
                xywh {165 165 360 20}
                code0 {o->value(progdefaults.ssdv_packet_url.c_str());}
              }
              Fl_Check_Button imagesave {
                label {Save Images}
                callback {progdefaults.ssdv_save_image = o->value();
progdefaults.changed = true;}
                xywh {15 189 130 21} down_box DOWN_BOX
                code0 {o->value(progdefaults.ssdv_save_image);}
              }
              Fl_Input imagesavedir {
                label {Location:}
                callback {progdefaults.ssdv_save_dir = o->value();
progdefaults.changed = true;}
                xywh {235 190 290 20}
                code0 {o->value(progdefaults.ssdv_save_dir.c_str());}
              }
            }
            Fl_Group {} {
              label {Waterfall PNG Export} open
              xywh {5 225 530 55} box ENGRAVED_FRAME align 21
            } {
              Fl_Check_Button {} {
                label Enable
                callback {progdefaults.png_wfall = o->value();
progdefaults.changed = true;}
                xywh {15 250 80 20} down_box DOWN_BOX
                code0 {o->value(progdefaults.png_wfall);}
              }
              Fl_Input {} {
                label {Location:}
                callback {progdefaults.waterfall_png_location = o->value();
progdefaults.changed = true;}
                tooltip {Please use full path including filename} xywh {235 250 290 20}
                code0 {o->value(progdefaults.waterfall_png_location.c_str());}
              }
            }
            Fl_Group {} {
              label {Frequency Tracking} open
              xywh {5 284 530 76} box ENGRAVED_FRAME align 21
            } {
              Fl_Check_Button btnTrackFreq {
                label Enable
                callback {progdefaults.track_freq = o->value();
progdefaults.changed = true;}
                tooltip {Adjust the radio frequency to keep the signal inside the specified limits} xywh {15 317 125 25} down_box DOWN_BOX
                code0 {o->value(progdefaults.track_freq);}
              }
              Fl_Counter cntTrackFreqMin {
                label {Minimum Waterfall Frequency}
                callback {int i = o->value();
progdefaults.track_freq_min = i;
if(progdefaults.track_freq_max < i)
{
  progdefaults.track_freq_max = i;
  cntTrackFreqMax->value(i);
}
progdefaults.changed = true;}
                tooltip {Low frequency limit in Hz} xywh {145 308 105 20} align 8 minimum 0 maximum 4000 step 1 value 1000
                code0 {o->value(progdefaults.track_freq_min);}
                code1 {o->labelsize(FL_NORMAL_SIZE);}
                code2 {o->lstep(10.0);}
                class Fl_Counter2
              }
              Fl_Counter cntTrackFreqMax {
                label {Maximum Waterfall Frequency}
                callback {int i = o->value();
progdefaults.track_freq_max = i;
if(progdefaults.track_freq_min > i)
{
  progdefaults.track_freq_min = i;
  cntTrackFreqMin->value(i);
}
progdefaults.changed = true;}
                tooltip {High frequency limit in Hz} xywh {145 333 105 20} align 8 minimum 0 maximum 4000 step 1 value 2000
                code0 {o->value(progdefaults.track_freq_max);}
                code1 {o->labelsize(FL_NORMAL_SIZE);}
                code2 {o->lstep(10.0);}
                class Fl_Counter2
              }
            }
          }
          Fl_Group {} {
            label Location open
            xywh {0 50 540 317} hide
          } {
            Fl_Group {} {
              label {Listener Location} open
              xywh {5 60 530 300} box ENGRAVED_FRAME align 21
            } {
              Fl_Input {} {
                label Baud
                callback {progdefaults.gps_speed = o->value();
progdefaults.changed = true;
dl_fldigi::changed(dl_fldigi::CH_GPS_SETTINGS);
btnApplyConfig->activate();}
                xywh {115 225 150 25} type Int
                code0 {o->value(progdefaults.gps_speed);}
                class Fl_Value_Input
              }
              Fl_Button {} {
                label {Refresh Device List}
                callback {progdefaults.testCommPorts();}
                xywh {305 195 170 25}
              }
              Fl_Round_Button {} {
                label {Stationary Listener}
                callback {if (o->value())
{
    dl_fldigi::location::new_location_mode = dl_fldigi::location::LOC_STATIONARY;
    dl_fldigi::changed(dl_fldigi::CH_LOCATION_MODE);
    btnApplyConfig->activate();
}}
                xywh {45 80 190 25} type Radio down_box ROUND_DOWN_BOX
                code0 {o->value(!progdefaults.gps_start_enabled);}
              }
              Fl_Input stationary_lat {
                label Latitude
                callback {progdefaults.myLat = o->value();
progdefaults.changed = true;
dl_fldigi::changed(dl_fldigi::CH_STATIONARY_LOCATION);
btnApplyConfig->activate();}
                xywh {135 105 125 25} type Float
                code0 {o->value(progdefaults.myLat.c_str());}
              }
              Fl_Input stationary_lon {
                label Longitude
                callback {progdefaults.myLon = o->value();
progdefaults.changed = true;
dl_fldigi::changed(dl_fldigi::CH_STATIONARY_LOCATION);
btnApplyConfig->activate();}
                xywh {350 105 125 25} type Float
                code0 {o->value(progdefaults.myLon.c_str());}
              }
              Fl_Round_Button {} {
                label {Upload GPS Position}
                callback {if (o->value())
{
    dl_fldigi::location::new_location_mode = dl_fldigi::location::LOC_GPS;
    dl_fldigi::changed(dl_fldigi::CH_LOCATION_MODE);
    btnApplyConfig->activate();
}}
                xywh {45 165 190 25} type Radio down_box ROUND_DOWN_BOX
                code0 {o->value(progdefaults.gps_start_enabled);}
              }
              Fl_Input_Choice inpGPSdev {
                label Device
                callback {progdefaults.gps_device = o->value();
progdefaults.changed = true;
dl_fldigi::changed(dl_fldigi::CH_GPS_SETTINGS);
btnApplyConfig->activate();} open
                xywh {115 195 185 25}
              } {}
              Fl_Check_Button {} {
                label {Always enable GPS on startup}
                callback {progdefaults.gps_start_enabled = o->value();
progdefaults.changed = true;}
                xywh {235 165 240 25} down_box DOWN_BOX
                code0 {o->value(progdefaults.gps_start_enabled);}
              }
              Fl_Spinner {} {
                label Period
                callback {progdefaults.gps_period = o->value();
progdefaults.changed = true;
dl_fldigi::changed(dl_fldigi::CH_GPS_SETTINGS);
btnApplyConfig->activate();}
                xywh {345 225 45 25} box DOWN_BOX minimum 10 maximum 300
                code0 {o->value(progdefaults.gps_period);}
              }
              Fl_Group {} {
                label {Last GPS Position} open
                xywh {10 260 520 90} box ENGRAVED_BOX align 21
              } {
                Fl_Output gps_pos_lat {
                  label Lat
                  xywh {235 285 105 25}
                }
                Fl_Output gps_pos_altitude {
                  label Alt
                  xywh {95 315 105 25}
                }
                Fl_Output gps_pos_time {
                  label Time
                  xywh {95 285 105 25}
                }
                Fl_Output gps_pos_lon {
                  label Lon
                  xywh {380 285 105 25}
                }
                Fl_Button gps_pos_save {
                  label {Save as stationary location}
                  callback {stationary_lat->value(gps_pos_lat->value());
stationary_lon->value(gps_pos_lon->value());
stationary_alt->value(gps_pos_altitude->value());
stationary_lat->do_callback();
stationary_lon->do_callback();
stationary_alt->do_callback();}
                  xywh {235 315 250 25} deactivate
                }
              }
              Fl_Box {} {
                label {please enter lat/long as one number, in decimal degrees; altitude in metres}
                xywh {290 130 190 35} labelsize 10 align 128
              }
              Fl_Box {} {
                label {seconds between position updates}
                xywh {395 220 105 35} labelsize 10 align 128
              }
              Fl_Input stationary_alt {
                label Altitude
                callback {progdefaults.myAlt = o->value();
progdefaults.changed = true;
dl_fldigi::changed(dl_fldigi::CH_STATIONARY_LOCATION);
btnApplyConfig->activate();}
                xywh {135 135 125 25} type Float
                code0 {o->value(progdefaults.myAlt.c_str());}
              }
            }
          }
          Fl_Group tabDLFlights {
            label {Active flights list} open
            xywh {0 50 540 323}
          } {
            Fl_Browser flight_browser {
              callback {if (habFlight)
    habFlight->value(o->value() - 1);
payload_browser->deselect();

dl_fldigi::flights::select_flight(o->value() - 1);

/* Handle a double click and autoconfigure.
 * This payload is ready for configuring iff dl_fldigi.cxx
 * has activated the autoconfigure button. */
if (Fl::event_clicks() > 0 && payload_autoconfigure_a->active())
    dl_fldigi::flights::auto_configure();}
              xywh {5 60 530 225} type Hold
              code0 {o->column_widths(flight_browser_columns);}
            }
            Fl_Group {} {open
              xywh {5 290 530 75} box ENGRAVED_BOX align 21
            } {
              Fl_Button flight_docs_refresh_a {
                label {Refresh flights/payloads}
                callback {dl_fldigi::hbtint::uthr->flights();
dl_fldigi::hbtint::uthr->payloads();}
                xywh {122 330 295 25}
              }
              Fl_Choice flight_payload_list {
                label {Payload:} open
                xywh {75 300 145 25} down_box BORDER_BOX
              } {}
              Fl_Button payload_autoconfigure_a {
                label Autoconfigure
                callback {dl_fldigi::flights::auto_configure();}
                xywh {370 300 155 25}
              }
              Fl_Choice flight_payload_transmission_list {open
                xywh {225 300 140 25} down_box BORDER_BOX
              } {}
            }
          }
          Fl_Group tabDLPayloads {
            label {All payloads (testing)} open
            xywh {0 50 540 323} hide
          } {
            Fl_Browser payload_browser {
              callback {flight_browser->deselect();
if (habFlight)
    habFlight->value(-1);

dl_fldigi::flights::select_payload(o->value() - 1);

/* Handle a double click and autoconfigure.
 * This payload is ready for configuring iff dl_fldigi.cxx
 * has activated the autoconfigure button. */
if (Fl::event_clicks() > 0 && payload_autoconfigure_b->active())
    dl_fldigi::flights::auto_configure();}
              xywh {5 60 530 225} type Hold
              code0 {o->column_widths(payload_browser_columns);}
            }
            Fl_Group {} {open
              xywh {5 290 530 75} box ENGRAVED_BOX align 21
            } {
              Fl_Button flight_docs_refresh_b {
                label {Refresh flights/payloads}
                callback {dl_fldigi::hbtint::uthr->flights();
dl_fldigi::hbtint::uthr->payloads();}
                xywh {325 300 200 25}
              }
              Fl_Button payload_autoconfigure_b {
                label Autoconfigure
                callback {dl_fldigi::flights::auto_configure();}
                xywh {325 330 200 25}
              }
              Fl_Input payload_search_text {
                label {Search:}
                callback {dl_fldigi::flights::payload_search(false);}
                xywh {75 300 165 25} when 1
              }
              Fl_Choice payload_transmission_list {
                label {Mode:} open selected
                xywh {75 330 230 25} down_box BORDER_BOX
              } {}
              Fl_Button {} {
                label Next
                callback {dl_fldigi::flights::payload_search(true);}
                xywh {245 300 60 25}
              }
            }
          }
        }
      }
    }
    Fl_Button btnSaveConfig {
      label Save
      callback {progdefaults.saveDefaults();
dl_fldigi::commit();
btnApplyConfig->deactivate();}
      xywh {290 375 115 22}
    }
    Fl_Return_Button btnCloseConfig {
      label Close
      callback {closeDialog();
dl_fldigi::commit();
btnApplyConfig->deactivate();}
      xywh {405 375 115 22}
    }
    Fl_Button btnResetConfig {
      label {Restore defaults}
      callback {progdefaults.resetDefaults();
progdefaults.changed = false;}
      xywh {25 375 150 22}
    }
    Fl_Button btnApplyConfig {
      label {Apply (dl)}
      callback {dl_fldigi::commit();
btnApplyConfig->deactivate();}
      xywh {175 375 115 22} deactivate
    }
  }
} 

Function {openConfig()} {return_type void
} {
  code {if (!dlgConfig) createConfig();
progdefaults.loadDefaults();} {}
} 

Function {closeDialog()} {return_type void
} {
  code {if (dlgConfig) dlgConfig->hide();} {}
} 

Function {createConfig()} {return_type void
} {
  code {if (!dlgConfig) {
    dlgConfig = ConfigureDialog();
    dlgConfig->xclass(PACKAGE_NAME);
  }} {}
} 

decl {class Fl_File_Chooser ;} {public global
} 

Function {WefaxDestDirSet(Fl_File_Chooser *w, void *userdata)} {open return_type void
} {
  code {/* http://www.fltk.org/documentation.php/doc-1.1/Fl_File_Chooser.html */
if( ( w->value() != NULL ) && ( ! w->shown() ) ) {
	btnWefaxSaveDir->value( w->value() );
	btnWefaxSaveDir->redraw();
	cb_btnWefaxSaveDir( btnWefaxSaveDir, NULL );
}} {}
} 

Function {NvtxCatalogSet(Fl_File_Chooser *w, void *userdata)} {open return_type void
} {
  code {/* http://www.fltk.org/documentation.php/doc-1.1/Fl_File_Chooser.html */
if( ( w->value() != NULL ) && ( ! w->shown() ) ) {
	txtNvtxCatalog->value( w->value() );
	txtNvtxCatalog->redraw();
	cb_txtNvtxCatalog( txtNvtxCatalog, NULL );
}} {}
} 
