← Back to branch summary

~ubuntu-branches/ubuntu/wily/flrig/wily

« back to all changes in this revision

Viewing changes to src/support/status.cxx

  • Committer: Package Import Robot
  • Author(s): Kamal Mostafa
  • Date: 2014-10-25 11:17:10 UTC
  • mfrom: (1.1.1)
  • Revision ID: package-import@ubuntu.com-20141025111710-n32skgya3l9u1brw
Tags: 1.3.17-1
http://bugs.debian.org/761839
* New upstream release (Closes: #761839)
* Debian Standards-Version: 3.9.6

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/support/status.cxx
 
1
// ----------------------------------------------------------------------------
 
2
// Copyright (C) 2014
 
3
//              David Freese, W1HKJ
 
4
//
 
5
// This file is part of flrig.
 
6
//
 
7
// flrig is free software; you can redistribute it and/or modify
 
8
// it under the terms of the GNU General Public License as published by
 
9
// the Free Software Foundation; either version 3 of the License, or
 
10
// (at your option) any later version.
 
11
//
 
12
// flrig is distributed in the hope that it will be useful,
 
13
// but WITHOUT ANY WARRANTY; without even the implied warranty of
 
14
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 
15
// GNU General Public License for more details.
 
16
//
 
17
// You should have received a copy of the GNU General Public License
 
18
// along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
19
// ----------------------------------------------------------------------------
 
20
 
 
21
#include <iostream>
 
22
#include <fstream>
 
23
#include <string>
 
24
 
 
25
#include <FL/Fl_Preferences.H>
 
26
#include <FL/Fl_Progress.H>
 
27
 
 
28
#include "status.h"
 
29
#include "util.h"
 
30
#include "rig.h"
 
31
#include "support.h"
 
32
#include "config.h"
 
33
#include "rigpanel.h"
 
34
#include "ui.h"
 
35
 
 
36
string last_xcvr_used = "none";
 
37
 
 
38
int current_ui_size = -1;
 
39
 
 
40
status progStatus = {
 
41
        50,                     // int mainX;
 
42
        50,                     // int mainY;
 
43
        735,            // int mainW;
 
44
        150,            // int mainH;
 
45
        small_ui,       // UISIZE, UIsize;
 
46
        false,          // UIchanged;
 
47
        0,                      // int rig_nbr;
 
48
        "NONE",         // string xcvr_serial_port;
 
49
        0,                      // int comm_baudrate;
 
50
        2,                      // int stopbits;
 
51
        2,                      // int comm_retries;
 
52
        5,                      // int comm_wait;
 
53
        50,                     // int comm_timeout;
 
54
        false,          // bool comm_echo;
 
55
        false,          // bool comm_catptt;
 
56
        false,          // bool comm_rtsptt;
 
57
        false,          // bool comm_dtrptt;
 
58
        false,          // bool comm_rtscts;
 
59
        false,          // bool comm_rtsplus;
 
60
        false,          // bool comm_dtrplus;
 
61
        200,            // int  serloop_timing;
 
62
        0,                      // int  byte_interval;
 
63
 
 
64
        "NONE",         // string aux_serial_port;
 
65
        false,          // bool aux_rts;
 
66
        false,          // bool aux_dtr;
 
67
 
 
68
        "NONE",         // string       sep_serial_port;
 
69
        false,          // bool sep_rtsptt;
 
70
        false,          // bool sep_dtrptt;
 
71
        false,          // bool sep_rtsplus;
 
72
        false,          // bool sep_dtrplus;
 
73
        0,                      // int  CIV;
 
74
        false,          // bool USBaudio;
 
75
 
 
76
        1,                      // bool poll_smeter;
 
77
        1,                      // bool poll_frequency;
 
78
        1,                      // bool poll_mode;
 
79
        1,                      // bool poll_bandwidth;
 
80
        0,                      // bool poll_volume;
 
81
        0,                      // bool poll_auto_notch;
 
82
        0,                      // bool poll_notch;
 
83
        0,                      // bool poll_ifshift;
 
84
        0,                      // bool poll_power_control;
 
85
        0,                      // bool poll_pre_att;
 
86
        0,                      // bool poll_micgain;
 
87
        0,                      // bool poll_squelch;
 
88
        0,                      // bool poll_rfgain;
 
89
        1,                      // bool poll_pout;
 
90
        1,                      // bool poll_swr;
 
91
        1,                      // bool poll_alc;
 
92
        0,                      // bool poll_split;
 
93
        0,                      // bool poll_noise;
 
94
        0,                      // bool poll_nr;
 
95
        4,                      // int  poll_all;
 
96
 
 
97
        -1,                     // int  iBW_A;
 
98
        1,                      // int  imode_A;
 
99
        7070000,        // long freq_A;
 
100
        -1,                     // int  iBW_B;
 
101
        1,                      // int  imode_B;
 
102
        7070000,        // long freq_B;
 
103
        false,          // bool use_rig_data;
 
104
        false,          // bool restore_rig_data;
 
105
 
 
106
        false,          // bool spkr_on;
 
107
        20,                     // int  volume;
 
108
        0,                      // int  power_level;
 
109
        10,                     // int  mic_gain;
 
110
        false,          // bool notch;
 
111
        0,                      // int  notch_val;
 
112
        false,          // bool shift;
 
113
        0,                      // int  shift_val;
 
114
        100,            // int  rfgain;
 
115
        10,                     // int  squelch;
 
116
 
 
117
        0,                      // int  schema;
 
118
        true,           // bool hrd_buttons
 
119
 
 
120
        0,                      // int  line_out;
 
121
        false,          // bool data_port;
 
122
        1,                      // int  agc_level;
 
123
        18,                     // int  cw_wpm;
 
124
        3.0,            // double  cw_weight;
 
125
        0,                      // int  cw_vol;
 
126
        0,                      // int  cw_spot;
 
127
        false,          // bool spot_onoff;
 
128
        700,            // int  cw_spot_tone;
 
129
        false,          // bool enable_keyer;
 
130
        false,          // bool break_in;
 
131
        15,                     // double       cw_qsk;
 
132
        200,            // double       cw_delay;
 
133
 
 
134
        false,          // int  vox_onoff;
 
135
        10,                     // int  vox_gain;
 
136
        10,                     // int  vox_anti;
 
137
        100,            // int  vox_hang; FT950 default
 
138
        true,           // bool vox_on_dataport;
 
139
        0,                      // int  compression;
 
140
        false,          // bool compON;
 
141
 
 
142
        0,                      // bool noise_reduction;
 
143
        0,                      // int  noise_reduction_val;
 
144
        0,                      // int  nb_level;
 
145
 
 
146
        false,          // bool noise;
 
147
        0,                      // int  attenuator
 
148
        0,                      // int  preamp;
 
149
        0,                      // int  auto_notch;
 
150
 
 
151
        0,                      // int  split;
 
152
 
 
153
        true,           // bool key_fldigi;
 
154
 
 
155
        5,                      // int rx_avg;
 
156
        5,                      // int rx_peak;
 
157
        5,                      // int pwr_avg;
 
158
        5,                      // int pwr_peak;
 
159
        4,                      // int pwr_scale ==> Autoselect
 
160
 
 
161
//tt550 controls
 
162
        80,                     // tt550_line_out;
 
163
        1,                      // tt550_agc_level;
 
164
 
 
165
        24,                     // tt550_cw_wpm;
 
166
        1.0,            // tt550_cw_weight;
 
167
        10,                     // tt550_cw_vol;
 
168
        10,                     // tt550_cw_spot;
 
169
        false,          // tt550_cw_spot_onoff;
 
170
        20,                     // tt550_cw_qsk;
 
171
        true,           // tt550_enable_keyer;
 
172
 
 
173
        false,          // tt550_vox_onoff;
 
174
        0,                      // tt550_vox_gain;
 
175
        0,                      // tt550_vox_anti;
 
176
        0,                      // tt550_vox_hang;
 
177
 
 
178
        0,                      // tt550_mon_vol;
 
179
        0,                      // tt550_squelch_level;
 
180
        0,                      // tt550_compression;
 
181
        1,                      // tt550_nb_level;
 
182
        false,          // tt550_bool compON;
 
183
        false,          // tt550_tuner_bypass;
 
184
 
 
185
        true,           // tt550_enable_xmtr;
 
186
        false,          // tt550_enable_tloop;
 
187
 
 
188
        true,           // tt550_use_line_in;
 
189
 
 
190
        14,                     // tt550_xmt_bw;
 
191
        false,          // tt550_use_xmt_bw;
 
192
        
 
193
        25,                     // tt550_AM_level;
 
194
        0,                      // tt550_encoder_step;
 
195
        1,                      // tt550_encoder_sensitivity;
 
196
        2000,           // tt550_keypad_timeout;
 
197
 
 
198
        0,                      // tt550_F1_func;
 
199
        0,                      // tt550_F2_func;
 
200
        0,                      // tt550_F3_func;
 
201
 
 
202
        0.0,            // vfo_adj;
 
203
        600,            // bfo_freq;
 
204
        0,                      // rit_freq;
 
205
        0,                      // xit_freq;
 
206
        1500,           // bpf_center;
 
207
        true,           // use_bpf_center;
 
208
 
 
209
        232,            // int   bg_red;
 
210
        255,            // int   bg_green;
 
211
        232,            // int   bg_blue;
 
212
 
 
213
        0,                      // int   fg_red;
 
214
        0,                      // int   fg_green;
 
215
        0,                      // int   fg_blue;
 
216
 
 
217
        148,            // int  swrRed;
 
218
        0,                      // int  swrGreen;
 
219
        148,            // int  swrBlue;
 
220
 
 
221
        180,            // int  pwrRed;
 
222
        0,                      // int  pwrGreen;
 
223
        0,                      // int  pwrBlue;
 
224
 
 
225
        0,                      // int  smeterRed;
 
226
        180,            // int  smeterGreen;
 
227
        0,                      //int   smeterBlue;
 
228
 
 
229
        255,            // int  peakRed;
 
230
        0,                      // int  peakGreen;
 
231
        0,                      // int  peakBlue;
 
232
 
 
233
        0,                      // int  fg_sys_red;
 
234
        0,                      // int  fg_sys_green;
 
235
        0,                      // int  fg_sys_blue;
 
236
 
 
237
        0xc0,           // int  bg_sys_red;
 
238
        0xc0,           // int  bg_sys_green;
 
239
        0xc0,           // int  bg_sys_blue;
 
240
 
 
241
        255,            // int  bg2_sys_red;
 
242
        255,            // int  bg2_sys_green;
 
243
        255,            // int  bg2_sys_blue;
 
244
 
 
245
        232,            // int          slider_red;
 
246
        255,            // int          slider_green;
 
247
        232,            // int          slider_blue;
 
248
 
 
249
        0,                      // int          slider_btn_red;
 
250
        0,                      // int          slider_btn_green;
 
251
        128,            // int          slider_btn_blue;
 
252
 
 
253
        255,            // int          lighted_btn_red;
 
254
        255,            // int          lighted_btn_green;
 
255
        0,                      // int          lighted_btn_blue;
 
256
 
 
257
        FL_COURIER,     // Fl_Font fontnbr;
 
258
 
 
259
        false,          // bool  tooltips;
 
260
 
 
261
        "gtk+",         // string ui_scheme
 
262
 
 
263
        "7362",         // string server_port
 
264
        "127.0.0.1",// string server_address
 
265
 
 
266
        "4001",         // string tcpip_port
 
267
        "127.0.0.1",// string tcpip_address
 
268
        50,                     // int tcpip_ping_delay
 
269
        10,                     // int tcpip_reconnect_after in seconds
 
270
        10,                     // int tcpip_drops_allowed;
 
271
 
 
272
        false,          // bool use_tcpip
 
273
 
 
274
        false,          // bool xcvr auto on
 
275
        false           // bool xcvr auto off
 
276
 
 
277
};
 
278
 
 
279
void status::saveLastState()
 
280
{
 
281
        last_xcvr_used = selrig->name_;
 
282
        Fl_Preferences xcvrpref(RigHomeDir.c_str(), "w1hkj.com", PACKAGE_TARNAME);
 
283
        xcvrpref.set("last_xcvr_used", last_xcvr_used.c_str());
 
284
 
 
285
        int mX = mainwindow->x();
 
286
        int mY = mainwindow->y();
 
287
        int mW = mainwindow->w();
 
288
        int mH = mainwindow->h();
 
289
 
 
290
        if (mX >= 0 && mX >= 0) {
 
291
                mainX = mX;
 
292
                mainY = mY;
 
293
                if (UIsize != small_ui) { mainW = mW; mainH = mH; }
 
294
        }
 
295
 
 
296
        Fl_Preferences spref(RigHomeDir.c_str(), "w1hkj.com", last_xcvr_used.c_str());
 
297
 
 
298
        spref.set("version", PACKAGE_VERSION);
 
299
 
 
300
        spref.set("mainx", mainX);
 
301
        spref.set("mainy", mainY);
 
302
        spref.set("mainw", mainW);
 
303
        spref.set("mainh", mainH);
 
304
 
 
305
        spref.set("uisize", UIsize);
 
306
 
 
307
        spref.set("xcvr_serial_port", xcvr_serial_port.c_str());
 
308
        spref.set("comm_baudrate", comm_baudrate);
 
309
        spref.set("comm_stopbits", stopbits);
 
310
        spref.set("comm_retries", comm_retries);
 
311
        spref.set("comm_wait", comm_wait);
 
312
        spref.set("comm_timeout", comm_timeout);
 
313
        spref.set("serloop_timing", serloop_timing);
 
314
        spref.set("byte_interval", byte_interval);
 
315
 
 
316
        spref.set("comm_echo", comm_echo);
 
317
        spref.set("ptt_via_cat", comm_catptt);
 
318
        spref.set("ptt_via_rts", comm_rtsptt);
 
319
        spref.set("ptt_via_dtr", comm_dtrptt);
 
320
        spref.set("rts_cts_flow", comm_rtscts);
 
321
        spref.set("rts_plus", comm_rtsplus);
 
322
        spref.set("dtr_plus", comm_dtrplus);
 
323
        spref.set("civadr", CIV);
 
324
        spref.set("usbaudio", USBaudio);
 
325
 
 
326
        spref.set("aux_serial_port", aux_serial_port.c_str());
 
327
        spref.set("aux_rts", aux_rts);
 
328
        spref.set("aux_dtr", aux_dtr);
 
329
 
 
330
        spref.set("sep_serial_port", sep_serial_port.c_str());
 
331
        spref.set("sep_rtsptt", sep_rtsptt);
 
332
        spref.set("sep_dtrptt", sep_dtrptt);
 
333
        spref.set("sep_rtsplus", sep_rtsplus);
 
334
        spref.set("set_dtrplus", sep_dtrplus);
 
335
 
 
336
        spref.set("key_fldigi", key_fldigi);
 
337
 
 
338
        spref.set("poll_smeter", poll_smeter);
 
339
        spref.set("poll_frequency", poll_frequency);
 
340
        spref.set("poll_mode", poll_mode);
 
341
        spref.set("poll_bandwidth", poll_bandwidth);
 
342
        spref.set("poll_volume", poll_volume);
 
343
        spref.set("poll_auto_notch", poll_auto_notch);
 
344
        spref.set("poll_notch", poll_notch);
 
345
        spref.set("poll_ifshift", poll_ifshift);
 
346
        spref.set("poll_power_control", poll_power_control);
 
347
        spref.set("poll_pre_att", poll_pre_att);
 
348
        spref.set("poll_micgain", poll_micgain);
 
349
        spref.set("poll_squelch", poll_squelch);
 
350
        spref.set("poll_rfgain", poll_rfgain);
 
351
        spref.set("poll_pout", poll_pout);
 
352
        spref.set("poll_swr", poll_swr);
 
353
        spref.set("poll_alc", poll_alc);
 
354
        spref.set("poll_split", poll_split);
 
355
        spref.set("poll_noise", poll_noise);
 
356
        spref.set("poll_nr", poll_nr);
 
357
        spref.set("poll_all", poll_all);
 
358
 
 
359
        spref.set("bw_A", iBW_A);
 
360
        spref.set("mode_A", imode_A);
 
361
        spref.set("freq_A", freq_A);
 
362
 
 
363
        spref.set("bw_B", iBW_B);
 
364
        spref.set("mode_B", imode_B);
 
365
        spref.set("freq_B", freq_B);
 
366
 
 
367
        spref.set("use_rig_data", use_rig_data);
 
368
        spref.set("restore_rig_data", restore_rig_data);
 
369
 
 
370
        spref.set("bool_spkr_on", spkr_on);
 
371
        spref.set("int_volume", volume);
 
372
        spref.set("dbl_power", power_level);
 
373
        spref.set("int_mic", mic_gain);
 
374
        spref.set("bool_notch", notch);
 
375
        spref.set("int_notch", notch_val);
 
376
        spref.set("bool_shift", shift);
 
377
        spref.set("int_shift", shift_val);
 
378
        spref.set("rfgain", rfgain);
 
379
        spref.set("squelch", squelch);
 
380
 
 
381
        spref.set("schema", schema);
 
382
 
 
383
        spref.set("rx_avg", rx_avg);
 
384
        spref.set("rx_peak", rx_peak);
 
385
        spref.set("pwr_avg", pwr_avg);
 
386
        spref.set("pwr_peak", pwr_peak);
 
387
        spref.set("pwr_scale", pwr_scale);
 
388
 
 
389
        if (rig_nbr == TT550) {
 
390
                spref.set("tt550_line_out", tt550_line_out);
 
391
                spref.set("tt550_agc_level", tt550_agc_level);
 
392
 
 
393
                spref.set("tt550_cw_wpm", tt550_cw_wpm);
 
394
                spref.set("tt550_cw_weight", tt550_cw_weight);
 
395
                spref.set("tt550_cw_vol", tt550_cw_vol);
 
396
                spref.set("tt550_cw_spot", tt550_cw_spot);
 
397
                spref.set("tt550_spot_onoff", tt550_spot_onoff);
 
398
                spref.set("tt550_cw_qsk", tt550_cw_qsk);
 
399
                spref.set("enable_keyer", enable_keyer);
 
400
                spref.set("break_in", break_in);
 
401
                spref.set("cw_delay", cw_delay);
 
402
 
 
403
                spref.set("tt550_vox_onoff", tt550_vox_onoff);
 
404
                spref.set("tt550_vox_gain", tt550_vox_gain);
 
405
                spref.set("tt550_vox_anti", tt550_vox_anti);
 
406
                spref.set("tt550_vox_hang", tt550_vox_hang);
 
407
 
 
408
                spref.set("tt550_mon_vol", tt550_mon_vol);
 
409
                spref.set("tt550_squelch_level", tt550_squelch_level);
 
410
                spref.set("tt550_compression", tt550_compression);
 
411
                spref.set("tt550_nb_level", tt550_nb_level);
 
412
                spref.set("tt550_compON", tt550_compON);
 
413
                spref.set("tt550_tuner_bypass", tt550_tuner_bypass);
 
414
                spref.set("tt550_enable_xmtr", tt550_enable_xmtr);
 
415
                spref.set("tt550_enable_tloop", tt550_enable_tloop);
 
416
 
 
417
                spref.set("tt550_xmt_bw", tt550_xmt_bw);
 
418
                spref.set("tt550_use_xmt_bw", tt550_use_xmt_bw);
 
419
 
 
420
                spref.set("tt550_AM_level", tt550_AM_level);
 
421
 
 
422
                spref.set("tt550_use_line_in", tt550_use_line_in);
 
423
 
 
424
                spref.set("tt550_encoder_step", tt550_encoder_step);
 
425
                spref.set("tt550_encoder_sensitivity", tt550_encoder_sensitivity);
 
426
                spref.set("tt550_keypad_timeout", tt550_keypad_timeout);
 
427
 
 
428
                spref.set("tt550_F1_func", tt550_F1_func);
 
429
                spref.set("tt550_F2_func", tt550_F2_func);
 
430
                spref.set("tt550_F3_func", tt550_F3_func);
 
431
 
 
432
        } else {
 
433
                spref.set("line_out", line_out);
 
434
                spref.set("data_port", data_port);
 
435
                spref.set("vox_on_dataport", vox_on_dataport);
 
436
                spref.set("agc_level", agc_level);
 
437
                spref.set("cw_wpm", cw_wpm);
 
438
                spref.set("cw_weight", cw_weight);
 
439
                spref.set("cw_vol", cw_vol);
 
440
                spref.set("cw_spot", cw_spot);
 
441
                spref.set("spot_onoff", spot_onoff);
 
442
                spref.set("cw_spot_tone", cw_spot_tone);
 
443
                spref.set("cw_qsk", cw_qsk);
 
444
                spref.set("enable_keyer", enable_keyer);
 
445
                spref.set("vox_onoff", vox_onoff);
 
446
                spref.set("vox_gain", vox_gain);
 
447
                spref.set("vox_anti", vox_anti);
 
448
                spref.set("vox_hang", vox_hang);
 
449
                spref.set("compression", compression);
 
450
                spref.set("compON", compON);
 
451
        }
 
452
 
 
453
        spref.set("noise_reduction", noise_reduction);
 
454
        spref.set("noise_red_val", noise_reduction_val);
 
455
        spref.set("nb_level", nb_level);
 
456
 
 
457
        spref.set("bool_noise", noise);
 
458
        spref.set("int_preamp", preamp);
 
459
        spref.set("int_att", attenuator);
 
460
 
 
461
        spref.set("vfo_adj", vfo_adj);
 
462
        spref.set("bfo_freq", bfo_freq);
 
463
        spref.set("rit_freq", rit_freq);
 
464
        spref.set("xit_freq", xit_freq);
 
465
        spref.set("bpf_center", bpf_center);
 
466
        spref.set("use_bpf_center", use_bpf_center);
 
467
 
 
468
        spref.set("fg_red", fg_red);
 
469
        spref.set("fg_green", fg_green);
 
470
        spref.set("fg_blue", fg_blue);
 
471
 
 
472
        spref.set("bg_red", bg_red);
 
473
        spref.set("bg_green", bg_green);
 
474
        spref.set("bg_blue", bg_blue);
 
475
 
 
476
        spref.set("smeter_red", smeterRed);
 
477
        spref.set("smeter_green", smeterGreen);
 
478
        spref.set("smeter_blue", smeterBlue);
 
479
 
 
480
        spref.set("power_red", pwrRed);
 
481
        spref.set("power_green", pwrGreen);
 
482
        spref.set("power_blue", pwrBlue);
 
483
 
 
484
        spref.set("swr_red", swrRed);
 
485
        spref.set("swr_green", swrGreen);
 
486
        spref.set("swr_blue", swrBlue);
 
487
 
 
488
        spref.set("peak_red", peakRed);
 
489
        spref.set("peak_green", peakGreen);
 
490
        spref.set("peak_blue", peakBlue);
 
491
 
 
492
        spref.set("fg_sys_red", fg_sys_red);
 
493
        spref.set("fg_sys_green", fg_sys_green);
 
494
        spref.set("fg_sys_blue", fg_sys_blue);
 
495
 
 
496
        spref.set("bg_sys_red", bg_sys_red);
 
497
        spref.set("bg_sys_green", bg_sys_green);
 
498
        spref.set("bg_sys_blue", bg_sys_blue);
 
499
 
 
500
        spref.set("bg2_sys_red", bg2_sys_red);
 
501
        spref.set("bg2_sys_green", bg2_sys_green);
 
502
        spref.set("bg2_sys_blue", bg2_sys_blue);
 
503
 
 
504
        spref.set("slider_red", slider_red);
 
505
        spref.set("slider_green", slider_green);
 
506
        spref.set("slider_blue", slider_blue);
 
507
 
 
508
        spref.set("slider_btn_red", slider_btn_red);
 
509
        spref.set("slider_btn_green", slider_btn_green);
 
510
        spref.set("slider_btn_blue", slider_btn_blue);
 
511
 
 
512
        spref.set("lighted_btn_red", lighted_btn_red);
 
513
        spref.set("lighted_btn_green", lighted_btn_green);
 
514
        spref.set("lighted_btn_blue", lighted_btn_blue);
 
515
 
 
516
        spref.set("fontnbr", fontnbr);
 
517
 
 
518
        spref.set("tooltips", tooltips);
 
519
 
 
520
        spref.set("ui_scheme", ui_scheme.c_str());
 
521
 
 
522
        spref.set("server_port", server_port.c_str());
 
523
        spref.set("server_addr", server_addr.c_str());
 
524
 
 
525
        spref.set("tcpip_port", tcpip_port.c_str());
 
526
        spref.set("tcpip_addr", tcpip_addr.c_str());
 
527
        spref.set("tcpip_ping_delay", tcpip_ping_delay);
 
528
        spref.set("tcpip_tcpip_reconnect_after", tcpip_reconnect_after);
 
529
        spref.set("tcpip_drops_allowed", tcpip_drops_allowed);
 
530
        spref.set("use_tcpip", use_tcpip);
 
531
 
 
532
        spref.set("xcvr_auto_on", xcvr_auto_on);
 
533
        spref.set("xcvr_auto_off", xcvr_auto_off);
 
534
 
 
535
        spref.set("hrd_buttons", hrd_buttons);
 
536
}
 
537
 
 
538
bool status::loadXcvrState(const char *xcvr)
 
539
{
 
540
        Fl_Preferences spref(RigHomeDir.c_str(), "w1hkj.com", xcvr);
 
541
 
 
542
        if (spref.entryExists("version")) {
 
543
 
 
544
                int i;
 
545
                char defbuffer[200];
 
546
 
 
547
                spref.get("mainx", mainX, mainX);
 
548
                spref.get("mainy", mainY, mainY);
 
549
                spref.get("mainw", mainW, mainW);
 
550
                spref.get("mainh", mainH, mainH);
 
551
                spref.get("uisize", UIsize, UIsize);
 
552
                if (current_ui_size != -1) {
 
553
                        UIsize = current_ui_size;
 
554
                }
 
555
                current_ui_size = UIsize;
 
556
                if (UIsize == wide_ui) {
 
557
                        if (mainW < WIDE_MAINW) mainW = WIDE_MAINW;
 
558
                }
 
559
                if (UIsize == touch_ui) {
 
560
                        if (mainW < TOUCH_MAINW) mainW = TOUCH_MAINW;
 
561
                }
 
562
 
 
563
                spref.get("xcvr_serial_port", defbuffer, "NONE", 199);
 
564
                xcvr_serial_port = defbuffer;
 
565
                if (xcvr_serial_port.find("tty") == 0) 
 
566
                        xcvr_serial_port.insert(0, "/dev/");
 
567
 
 
568
                rig_nbr = NONE;
 
569
                for (int i = NONE; i < LAST_RIG; i++)
 
570
                        if (strcmp(rigs[i]->name_, xcvr) == 0) {
 
571
                                rig_nbr = i;
 
572
                                break;
 
573
                        }
 
574
 
 
575
                spref.get("comm_baudrate", comm_baudrate, comm_baudrate);
 
576
                spref.get("comm_stopbits", stopbits, stopbits);
 
577
                spref.get("comm_retries", comm_retries, comm_retries);
 
578
                spref.get("comm_wait", comm_wait, comm_wait);
 
579
                spref.get("comm_timeout", comm_timeout, comm_timeout);
 
580
                spref.get("serloop_timing", serloop_timing, serloop_timing);
 
581
                if (serloop_timing < 10) serloop_timing = 10; // minimum loop delay of 10 msec
 
582
                spref.get("byte_interval", byte_interval, byte_interval);
 
583
 
 
584
                if (spref.get("comm_echo", i, i)) comm_echo = i;
 
585
                if (spref.get("ptt_via_cat", i, i)) comm_catptt = i;
 
586
                if (spref.get("ptt_via_rts", i, i)) comm_rtsptt = i;
 
587
                if (spref.get("ptt_via_dtr", i, i)) comm_dtrptt = i;
 
588
                if (spref.get("rts_cts_flow", i, i)) comm_rtscts = i;
 
589
                if (spref.get("rts_plus", i, i)) comm_rtsplus = i;
 
590
                if (spref.get("dtr_plus", i, i)) comm_dtrplus = i;
 
591
                spref.get("civadr", CIV, CIV);
 
592
                if (spref.get("usbaudio", i, i)) USBaudio = i;
 
593
 
 
594
                spref.get("aux_serial_port", defbuffer, "NONE", 199);
 
595
                aux_serial_port = defbuffer;
 
596
                if (spref.get("aux_rts", i, i)) aux_rts = i;
 
597
                if (spref.get("aux_dtr", i, i)) aux_dtr = i;
 
598
 
 
599
                spref.get("sep_serial_port", defbuffer, "NONE", 199);
 
600
                sep_serial_port = defbuffer;
 
601
                if (spref.get("sep_rtsptt", i, i)) sep_rtsptt = i;
 
602
                if (spref.get("sep_dtrptt", i, i)) sep_dtrptt = i;
 
603
                if (spref.get("sep_rtsplus", i, i)) sep_rtsplus = i;
 
604
                if (spref.get("sep_dtrplus", i, i)) sep_dtrplus = i;
 
605
 
 
606
                if (spref.get("key_fldigi", i, key_fldigi)) key_fldigi = i;
 
607
 
 
608
                spref.get("poll_smeter", poll_smeter, poll_smeter);
 
609
                spref.get("poll_frequency", poll_frequency, poll_frequency);
 
610
                spref.get("poll_mode", poll_mode, poll_mode);
 
611
                spref.get("poll_bandwidth", poll_bandwidth, poll_bandwidth);
 
612
                spref.get("poll_volume", poll_volume, poll_volume);
 
613
                spref.get("poll_auto_notch", poll_auto_notch, poll_auto_notch);
 
614
                spref.get("poll_notch", poll_notch, poll_notch);
 
615
                spref.get("poll_ifshift", poll_ifshift, poll_ifshift);
 
616
                spref.get("poll_power_control", poll_power_control, poll_power_control);
 
617
                spref.get("poll_pre_att", poll_pre_att, poll_pre_att);
 
618
                spref.get("poll_micgain", poll_micgain, poll_micgain);
 
619
                spref.get("poll_squelch", poll_squelch, poll_squelch);
 
620
                spref.get("poll_rfgain", poll_rfgain, poll_rfgain);
 
621
                spref.get("poll_pout", poll_pout, poll_pout);
 
622
                spref.get("poll_swr", poll_swr, poll_swr);
 
623
                spref.get("poll_alc", poll_alc, poll_alc);
 
624
                spref.get("poll_split", poll_split, poll_split);
 
625
                spref.get("poll_noise", poll_noise, poll_noise);
 
626
                spref.get("poll_nr", poll_nr, poll_nr);
 
627
                spref.get("poll_all", poll_all, poll_all);
 
628
 
 
629
                spref.get("bw_A", iBW_A, iBW_A);
 
630
                spref.get("mode_A", imode_A, imode_A);
 
631
                spref.get("freq_A", freq_A, freq_A);
 
632
 
 
633
                spref.get("bw_B", iBW_B, iBW_B);
 
634
                spref.get("mode_B", imode_B, imode_B);
 
635
                spref.get("freq_B", freq_B, freq_B);
 
636
        
 
637
                if (spref.get("use_rig_data", i, i)) use_rig_data = i;
 
638
                if (spref.get("restore_rig_data", i, i)) restore_rig_data = i;
 
639
 
 
640
                if (spref.get("bool_spkr_on", i, i)) spkr_on = i;
 
641
                spref.get("int_volume", volume, volume);
 
642
                spref.get("dbl_power", power_level, power_level);
 
643
                spref.get("int_mic", mic_gain, mic_gain);
 
644
                if (spref.get("bool_notch", i, i)) notch = i;
 
645
                spref.get("int_notch", notch_val, notch_val);
 
646
                if (spref.get("bool_shift", i, i)) shift = i;
 
647
                spref.get("int_shift", shift_val, shift_val);
 
648
                spref.get("rfgain", rfgain, rfgain);
 
649
                spref.get("squelch", squelch, squelch);
 
650
 
 
651
                spref.get("schema", schema, schema);
 
652
 
 
653
                spref.get("rx_avg", rx_avg, rx_avg);
 
654
                spref.get("rx_peak", rx_peak, rx_peak);
 
655
                spref.get("pwr_avg", pwr_avg, pwr_avg);
 
656
                spref.get("pwr_peak", pwr_peak, pwr_peak);
 
657
                spref.get("pwr_scale", pwr_scale, pwr_scale);
 
658
 
 
659
                if (rig_nbr == TT550) {
 
660
                        spref.get("tt550_line_out", tt550_line_out, tt550_line_out);
 
661
                        spref.get("tt550_agc_level", tt550_agc_level, tt550_agc_level);
 
662
 
 
663
                        spref.get("tt550_cw_wpm", tt550_cw_wpm, tt550_cw_wpm);
 
664
                        spref.get("tt550_cw_weight", tt550_cw_weight, tt550_cw_weight);
 
665
                        spref.get("tt550_cw_vol", tt550_cw_vol, tt550_cw_vol);
 
666
                        spref.get("tt550_cw_spot", tt550_cw_spot, tt550_cw_spot);
 
667
                        if (spref.get("tt550_spot_onoff", i, i)) tt550_spot_onoff = i;
 
668
                        spref.get("tt550_cw_qsk", tt550_cw_qsk, tt550_cw_qsk);
 
669
                        if (spref.get("tt550_enable_keyer", i, i)) tt550_enable_keyer = i;
 
670
                        if (spref.get("break_in", i, i)) break_in = i;
 
671
                        if (spref.get("vox_onoff", i, i)) vox_onoff = i;
 
672
 
 
673
                        if (spref.get("tt550_vox_onoff", i, i)) tt550_vox_onoff = i;
 
674
                        spref.get("tt550_vox_gain", tt550_vox_gain, tt550_vox_gain);
 
675
                        spref.get("tt550_vox_anti", tt550_vox_anti, tt550_vox_anti);
 
676
                        spref.get("tt550_vox_hang", tt550_vox_hang, tt550_vox_hang);
 
677
 
 
678
                        spref.get("tt550_mon_vol", tt550_mon_vol, tt550_mon_vol);
 
679
                        spref.get("tt550_squelch_level", tt550_squelch_level, tt550_squelch_level);
 
680
                        spref.get("tt550_compression", tt550_compression, tt550_compression);
 
681
                        spref.get("tt550_nb_level", tt550_nb_level, tt550_nb_level);
 
682
                        if (spref.get("tt550_compON", i, i)) tt550_compON = i;
 
683
                        if (spref.get("tt550_tuner_bypass", i, i)) tt550_tuner_bypass = i;
 
684
                        if (spref.get("tt550_enable_xmtr", i, i)) tt550_enable_xmtr = i;
 
685
                        if (spref.get("tt550_enable_tloop", i, i)) tt550_enable_tloop = i;
 
686
 
 
687
                        spref.get("tt550_xmt_bw", tt550_xmt_bw, tt550_xmt_bw);
 
688
                        if (spref.get("tt550_use_xmt_bw", i, i)) tt550_use_xmt_bw = i;
 
689
 
 
690
                        if (spref.get("tt550_use_line_in", i, i)) tt550_use_line_in = i;
 
691
 
 
692
                        spref.get("tt550_AM_level", tt550_AM_level, tt550_AM_level);
 
693
                        spref.get("tt550_encoder_step", tt550_encoder_step, tt550_encoder_step);
 
694
                        spref.get("tt550_encoder_sensitivity", tt550_encoder_sensitivity, tt550_encoder_sensitivity);
 
695
                        spref.get("tt550_keypad_timeout", tt550_keypad_timeout, tt550_keypad_timeout);
 
696
 
 
697
                        spref.get("tt550_F1_func", tt550_F1_func, tt550_F1_func);
 
698
                        spref.get("tt550_F2_func", tt550_F2_func, tt550_F2_func);
 
699
                        spref.get("tt550_F3_func", tt550_F3_func, tt550_F3_func);
 
700
 
 
701
                } 
 
702
                else {
 
703
                        spref.get("line_out", line_out, line_out);
 
704
                        spref.get("data_port", i, data_port); data_port = i;
 
705
                        spref.get("vox_on_dataport", i, vox_on_dataport); vox_on_dataport = i;
 
706
                        spref.get("agc_level", agc_level, agc_level);
 
707
                        spref.get("cw_wpm", cw_wpm, cw_wpm);
 
708
                        spref.get("cw_weight", cw_weight, cw_weight);
 
709
                        spref.get("cw_vol", cw_vol, cw_vol);
 
710
                        spref.get("cw_spot", cw_spot, cw_spot);
 
711
                        if (spref.get("spot_onoff", i, i)) spot_onoff = i;
 
712
                        spref.get("cw_spot_tone", cw_spot_tone, cw_spot_tone);
 
713
                        spref.get("cw_qsk", cw_qsk, cw_qsk);
 
714
                        if (spref.get("enable_keyer", i, i)) enable_keyer = i;
 
715
                        if (spref.get("vox_onoff", i, i)) vox_onoff = i;
 
716
                        spref.get("vox_gain", vox_gain, vox_gain);
 
717
                        spref.get("vox_anti", vox_anti, vox_anti);
 
718
                        spref.get("vox_hang", vox_hang, vox_hang);
 
719
                        spref.get("compression", compression, compression);
 
720
                        if (spref.get("compON", i, i)) compON = i;
 
721
                }
 
722
 
 
723
                if (spref.get("noise_reduction", i, i)) noise_reduction = i;
 
724
                spref.get("noise_red_val", noise_reduction_val, noise_reduction_val);
 
725
                spref.get("nb_level", nb_level, nb_level);
 
726
 
 
727
                if (spref.get("bool_noise", i, i)) noise = i;
 
728
                spref.get("int_preamp", preamp, preamp);
 
729
                spref.get("int_att", attenuator, attenuator);
 
730
 
 
731
                spref.get("vfo_adj", vfo_adj, vfo_adj);
 
732
                spref.get("bfo_freq", bfo_freq, bfo_freq);
 
733
                spref.get("rit_freq", rit_freq, rit_freq);
 
734
                spref.get("xit_freq", xit_freq, xit_freq);
 
735
                spref.get("bpf_center", bpf_center, bpf_center);
 
736
                spref.get("use_bpf_center", i, i); use_bpf_center = i;
 
737
 
 
738
                spref.get("fg_red", fg_red, fg_red);
 
739
                spref.get("fg_green", fg_green, fg_green);
 
740
                spref.get("fg_blue", fg_blue, fg_blue);
 
741
 
 
742
                spref.get("bg_red", bg_red, bg_red);
 
743
                spref.get("bg_green", bg_green, bg_green);
 
744
                spref.get("bg_blue", bg_blue, bg_blue);
 
745
 
 
746
                spref.get("smeter_red", smeterRed, smeterRed);
 
747
                spref.get("smeter_green", smeterGreen, smeterGreen);
 
748
                spref.get("smeter_blue", smeterBlue, smeterBlue);
 
749
 
 
750
                spref.get("power_red", pwrRed, pwrRed);
 
751
                spref.get("power_green", pwrGreen, pwrGreen);
 
752
                spref.get("power_blue", pwrBlue, pwrBlue);
 
753
 
 
754
                spref.get("swr_red", swrRed, swrRed);
 
755
                spref.get("swr_green", swrGreen, swrGreen);
 
756
                spref.get("swr_blue", swrBlue, swrBlue);
 
757
 
 
758
                spref.get("peak_red", peakRed, peakRed);
 
759
                spref.get("peak_green", peakGreen, peakGreen);
 
760
                spref.get("peak_blue", peakBlue, peakBlue);
 
761
 
 
762
                spref.get("fg_sys_red", fg_sys_red, fg_sys_red);
 
763
                spref.get("fg_sys_green", fg_sys_green, fg_sys_green);
 
764
                spref.get("fg_sys_blue", fg_sys_blue, fg_sys_blue);
 
765
 
 
766
                spref.get("bg_sys_red", bg_sys_red, bg_sys_red);
 
767
                spref.get("bg_sys_green", bg_sys_green, bg_sys_green);
 
768
                spref.get("bg_sys_blue", bg_sys_blue, bg_sys_blue);
 
769
 
 
770
                spref.get("bg2_sys_red", bg2_sys_red, bg2_sys_red);
 
771
                spref.get("bg2_sys_green", bg2_sys_green, bg2_sys_green);
 
772
                spref.get("bg2_sys_blue", bg2_sys_blue, bg2_sys_blue);
 
773
 
 
774
                spref.get("slider_red", slider_red, slider_red);
 
775
                spref.get("slider_green", slider_green, slider_green);
 
776
                spref.get("slider_blue", slider_blue, slider_blue);
 
777
 
 
778
                spref.get("slider_btn_red", slider_btn_red, slider_btn_red);
 
779
                spref.get("slider_btn_green", slider_btn_green, slider_btn_green);
 
780
                spref.get("slider_btn_blue", slider_btn_blue, slider_btn_blue);
 
781
 
 
782
                spref.get("lighted_btn_red", lighted_btn_red, lighted_btn_red);
 
783
                spref.get("lighted_btn_green", lighted_btn_green, lighted_btn_green);
 
784
                spref.get("lighted_btn_blue", lighted_btn_blue, lighted_btn_blue);
 
785
 
 
786
                i = (int)fontnbr;
 
787
                spref.get("fontnbr", i, i); fontnbr = (Fl_Font)i;
 
788
                i = 0;
 
789
                if (spref.get("tooltips", i, i)) tooltips = i;
 
790
 
 
791
                spref.get("ui_scheme", defbuffer, "gtk+", 199);
 
792
                ui_scheme = defbuffer;
 
793
 
 
794
                spref.get("server_port", defbuffer, "7362", 199);
 
795
                server_port = defbuffer;
 
796
                spref.get("server_addr", defbuffer, "127.0.0.1", 199);
 
797
                server_addr = defbuffer;
 
798
 
 
799
                spref.get("tcpip_port", defbuffer, "4001", 199);
 
800
                tcpip_port = defbuffer;
 
801
                spref.get("tcpip_addr", defbuffer, "127.0.0.1", 199);
 
802
                tcpip_addr = defbuffer;
 
803
                spref.get("tcpip_ping_delay", tcpip_ping_delay, tcpip_ping_delay);
 
804
                spref.get("tcpip_tcpip_reconnect_after", tcpip_reconnect_after, tcpip_reconnect_after);
 
805
                spref.get("tcpip_drops_allowed", tcpip_drops_allowed, tcpip_drops_allowed);
 
806
                if (spref.get("use_tcpip", i, i)) use_tcpip = i;
 
807
 
 
808
                if (spref.get("xcvr_auto_on", i, i)) xcvr_auto_on = i;
 
809
                if (spref.get("xcvr_auto_off", i, i)) xcvr_auto_off = i;
 
810
 
 
811
                if (spref.get("hrd_buttons", i, i)) hrd_buttons = i;
 
812
        }
 
813
 
 
814
        return true;
 
815
}
 
816
 
 
817
void status::loadLastState()
 
818
{
 
819
        Fl_Preferences xcvrpref(RigHomeDir.c_str(), "w1hkj.com", PACKAGE_TARNAME);
 
820
        if (xcvrpref.entryExists("last_xcvr_used")) {
 
821
                char defbuffer[200];
 
822
                xcvrpref.get("last_xcvr_used", defbuffer, "none", 199);
 
823
                last_xcvr_used = defbuffer;
 
824
        }
 
825
        loadXcvrState(last_xcvr_used.c_str());
 
826
}
 
827
 
 
828
void status::UI_laststate()
 
829
{
 
830
        Fl_Color bgclr = fl_rgb_color(bg_red, bg_green, bg_blue);
 
831
        Fl_Color fgclr = fl_rgb_color(fg_red, fg_green, fg_blue);
 
832
 
 
833
        Fl::background( bg_sys_red, bg_sys_green, bg_sys_blue);
 
834
        Fl::background2( bg2_sys_red, bg2_sys_green, bg2_sys_blue);
 
835
        Fl::foreground( fg_sys_red, fg_sys_green, fg_sys_blue);
 
836
 
 
837
        FreqDispA->SetONOFFCOLOR( fgclr, bgclr );
 
838
        FreqDispA->font(fontnbr);
 
839
        FreqDispB->SetONOFFCOLOR( fgclr, fl_color_average(bgclr, FL_BLACK, 0.87));
 
840
        FreqDispB->font(fontnbr);
 
841
 
 
842
        scaleSmeter->color(bgclr);
 
843
        scaleSmeter->labelcolor(fgclr);
 
844
        scalePower->color(bgclr);
 
845
        scalePower->labelcolor(fgclr);
 
846
        btnALC_SWR->color(bgclr);
 
847
        btnALC_SWR->labelcolor(fgclr);
 
848
 
 
849
        sldrFwdPwr->color(fl_rgb_color (pwrRed, pwrGreen, pwrBlue), bgclr);
 
850
        sldrFwdPwr->PeakColor(fl_rgb_color(peakRed, peakGreen, peakBlue));
 
851
 
 
852
        sldrRcvSignal->color(fl_rgb_color (smeterRed, smeterGreen, smeterBlue), bgclr);
 
853
        sldrRcvSignal->PeakColor(fl_rgb_color(peakRed, peakGreen, peakBlue));
 
854
 
 
855
        sldrALC->color(fl_rgb_color (swrRed, swrGreen, swrBlue), bgclr);
 
856
        sldrALC->PeakColor(fl_rgb_color(peakRed, peakGreen, peakBlue));
 
857
 
 
858
        sldrSWR->color(fl_rgb_color (swrRed, swrGreen, swrBlue), bgclr);
 
859
        sldrSWR->PeakColor(fl_rgb_color(peakRed, peakGreen, peakBlue));
 
860
 
 
861
        if (UIsize != small_ui)
 
862
                meter_fill_box->color(bgclr);
 
863
 
 
864
        grpMeters->color(bgclr);
 
865
        grpMeters->labelcolor(fgclr);
 
866
 
 
867
        Fl_Color btn_lt_color = fl_rgb_color(lighted_btn_red, lighted_btn_green, lighted_btn_blue);
 
868
        if (btnVol)                             btnVol->selection_color(btn_lt_color);
 
869
        if (btnNR)                              btnNR->selection_color(btn_lt_color);
 
870
        if (btnIFsh)                    btnIFsh->selection_color(btn_lt_color);
 
871
        if (btnNotch)                   btnNotch->selection_color(btn_lt_color);
 
872
        if (btnA)                               btnA->selection_color(btn_lt_color);
 
873
        if (btnB)                               btnB->selection_color(btn_lt_color);
 
874
        if (btnSplit)                   btnSplit->selection_color(btn_lt_color);
 
875
        if (btnAttenuator)              btnAttenuator->selection_color(btn_lt_color);
 
876
        if (btnPreamp)                  btnPreamp->selection_color(btn_lt_color);
 
877
        if (btnNOISE)                   btnNOISE->selection_color(btn_lt_color);
 
878
        if (btnAutoNotch)               btnAutoNotch->selection_color(btn_lt_color);
 
879
        if (btnTune)                    btnTune->selection_color(btn_lt_color);
 
880
        if (btnPTT)                             btnPTT->selection_color(btn_lt_color);
 
881
        if (btnAuxRTS)                  btnAuxRTS->selection_color(btn_lt_color);
 
882
        if (btnAuxDTR)                  btnAuxDTR->selection_color(btn_lt_color);
 
883
        if (btnSpot)                    btnSpot->selection_color(btn_lt_color);
 
884
        if (btn_vox)                    btn_vox->selection_color(btn_lt_color);
 
885
        if (btnCompON)                  btnCompON->selection_color(btn_lt_color);
 
886
        if (btnSpecial)                 btnSpecial->selection_color(btn_lt_color);
 
887
        if (btn_tt550_vox)              btn_tt550_vox->selection_color(btn_lt_color);
 
888
        if (btn_tt550_CompON)   btn_tt550_CompON->selection_color(btn_lt_color);
 
889
 
 
890
        Fl_Color bg_slider = fl_rgb_color(slider_red, slider_green, slider_blue);
 
891
        Fl_Color btn_slider = fl_rgb_color(slider_btn_red, slider_btn_green, slider_btn_blue);
 
892
        if (sldrVOLUME)                 sldrVOLUME->color(bg_slider);
 
893
        if (sldrVOLUME)                 sldrVOLUME->selection_color(btn_slider);
 
894
        if (sldrRFGAIN)                 sldrRFGAIN->color(bg_slider);
 
895
        if (sldrRFGAIN)                 sldrRFGAIN->selection_color(btn_slider);
 
896
        if (sldrSQUELCH)                sldrSQUELCH->color(bg_slider);
 
897
        if (sldrSQUELCH)                sldrSQUELCH->selection_color(btn_slider);
 
898
        if (sldrNR)                             sldrNR->color(bg_slider);
 
899
        if (sldrNR)                             sldrNR->selection_color(btn_slider);
 
900
        if (sldrIFSHIFT)                sldrIFSHIFT->color(bg_slider);
 
901
        if (sldrIFSHIFT)                sldrIFSHIFT->selection_color(btn_slider);
 
902
        if (sldrNOTCH)                  sldrNOTCH->color(bg_slider);
 
903
        if (sldrNOTCH)                  sldrNOTCH->selection_color(btn_slider);
 
904
        if (sldrMICGAIN)                sldrMICGAIN->color(bg_slider);
 
905
        if (sldrMICGAIN)                sldrMICGAIN->selection_color(btn_slider);
 
906
        if (sldrPOWER)                  sldrPOWER->color(bg_slider);
 
907
        if (sldrPOWER)                  sldrPOWER->selection_color(btn_slider);
 
908
 
 
909
        if (spnrPOWER)                  spnrPOWER->color(bg_slider);
 
910
        if (spnrPOWER)                  spnrPOWER->selection_color(btn_slider);
 
911
 
 
912
        if (spnrVOLUME)                 spnrVOLUME->color(bg_slider);
 
913
        if (spnrVOLUME)                 spnrVOLUME->selection_color(btn_slider);
 
914
 
 
915
        if (spnrRFGAIN)                 spnrRFGAIN->color(bg_slider);
 
916
        if (spnrRFGAIN)                 spnrRFGAIN->selection_color(btn_slider);
 
917
 
 
918
        if (spnrSQUELCH)                spnrSQUELCH->color(bg_slider);
 
919
        if (spnrSQUELCH)                spnrSQUELCH->selection_color(btn_slider);
 
920
 
 
921
        if (spnrNR)                             spnrNR->color(bg_slider);
 
922
        if (spnrNR)                             spnrNR->selection_color(btn_slider);
 
923
 
 
924
        if (spnrIFSHIFT)                spnrIFSHIFT->color(bg_slider);
 
925
        if (spnrIFSHIFT)                spnrIFSHIFT->selection_color(btn_slider);
 
926
 
 
927
        if (spnrNOTCH)                  spnrNOTCH->color(bg_slider);
 
928
        if (spnrNOTCH)                  spnrNOTCH->selection_color(btn_slider);
 
929
 
 
930
        if (spnrMICGAIN)                spnrMICGAIN->color(bg_slider);
 
931
        if (spnrMICGAIN)                spnrMICGAIN->selection_color(btn_slider);
 
932
 
 
933
        if (use_rig_data) mnuKeepData->set();
 
934
        else mnuKeepData->clear();
 
935
 
 
936
        if (restore_rig_data) mnuRestoreData->set();
 
937
        else mnuRestoreData->clear();
 
938
 
 
939
        Fl::scheme(ui_scheme.c_str());
 
940
}