flrig-2.0.04/ 0000775 0001750 0001750 00000000000 14511461606 007707 5 0000000 0000000 flrig-2.0.04/src/ 0000775 0001750 0001750 00000000000 14511461606 010476 5 0000000 0000000 flrig-2.0.04/src/support/ 0000775 0001750 0001750 00000000000 14511461606 012212 5 0000000 0000000 flrig-2.0.04/src/support/mingw.c 0000664 0001750 0001750 00000017205 14502041135 013413 0000000 0000000 // ----------------------------------------------------------------------------
// mingw.c
//
// The following routines were copied from git-1.6.1.2/compat/mingw.c:
// git_vsnprintf git_snprintf sleep mingw_getcwd mingw_getenv mingw_rename
//
// The uname routine was adapted from libgw32c 0.4.
//
// The rest:
// Copyright (C) 2009
// Stelios Bounanos, M0GLD
// ----------------------------------------------------------------------------
// Copyright (C) 2014
// David Freese, W1HKJ
//
// This file is part of flrig.
//
// flrig is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation; either version 3 of the License, or
// (at your option) any later version.
//
// flrig is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program. If not, see .
// ----------------------------------------------------------------------------
#include "config.h"
#include "compat.h"
#include
#include "util.h"
/* default mode for stdin, stdout and stderr */
unsigned int _CRT_fmode = _O_BINARY;
/******************************************************************************/
#if SNPRINTF_RETURNS_BOGUS
/*
* The size parameter specifies the available space, i.e. includes
* the trailing NUL byte; but Windows's vsnprintf expects the
* number of characters to write without the trailing NUL.
*/
#define SNPRINTF_SIZE_CORR 1
#undef vsnprintf
int git_vsnprintf(char *str, size_t maxsize, const char *format, va_list ap)
{
char *s;
int ret = -1;
if (maxsize > 0) {
ret = vsnprintf(str, maxsize-SNPRINTF_SIZE_CORR, format, ap);
if (ret == maxsize-1)
ret = -1;
/* Windows does not NUL-terminate if result fills buffer */
str[maxsize-1] = 0;
}
if (ret != -1)
return ret;
s = NULL;
if (maxsize < 128)
maxsize = 128;
while (ret == -1) {
maxsize *= 4;
str = (char *)realloc(s, maxsize);
if (! str)
break;
s = str;
ret = vsnprintf(str, maxsize-SNPRINTF_SIZE_CORR, format, ap);
if (ret == maxsize-1)
ret = -1;
}
free(s);
return ret;
}
int git_snprintf(char *str, size_t maxsize, const char *format, ...)
{
va_list ap;
int ret;
va_start(ap, format);
ret = git_vsnprintf(str, maxsize, format, ap);
va_end(ap);
return ret;
}
#endif /* SNPRINTF_RETURNS_BOGUS */
unsigned sleep(unsigned seconds)
{
Sleep(seconds*1000);
return 0;
}
#undef getcwd
char *mingw_getcwd(char *pointer, int len)
{
int i;
char *ret = getcwd(pointer, len);
if (!ret)
return ret;
for (i = 0; pointer[i]; i++)
if (pointer[i] == '\\')
pointer[i] = '/';
return ret;
}
#undef getenv
char *mingw_getenv(const char *name)
{
char *result = getenv(name);
if (!result && !strcmp(name, "TMPDIR")) {
/* on Windows it is TMP and TEMP */
result = getenv("TMP");
if (!result)
result = getenv("TEMP");
}
return result;
}
#undef rename
int mingw_rename(const char *pold, const char *pnew)
{
DWORD attrs;
/*
* Try native rename() first to get errno right.
* It is based on MoveFile(), which cannot overwrite existing files.
*/
if (!rename(pold, pnew))
return 0;
if (errno != EEXIST)
return -1;
if (MoveFileEx(pold, pnew, MOVEFILE_REPLACE_EXISTING))
return 0;
/* TODO: translate more errors */
if (GetLastError() == ERROR_ACCESS_DENIED &&
(attrs = GetFileAttributes(pnew)) != INVALID_FILE_ATTRIBUTES) {
if (attrs & FILE_ATTRIBUTE_DIRECTORY) {
errno = EISDIR;
return -1;
}
if ((attrs & FILE_ATTRIBUTE_READONLY) &&
SetFileAttributes(pnew, attrs & ~FILE_ATTRIBUTE_READONLY)) {
if (MoveFileEx(pold, pnew, MOVEFILE_REPLACE_EXISTING))
return 0;
/* revert file attributes on failure */
SetFileAttributes(pnew, attrs);
}
}
errno = EACCES;
return -1;
}
/******************************************************************************/
__attribute__((constructor))
static void wsa_init(void)
{
WSADATA wsa;
static int wsa_init_ = 0;
if (wsa_init_)
return;
if (WSAStartup(MAKEWORD(2, 2), &wsa)) {
fprintf(stderr, "unable to initialize winsock: error %d", WSAGetLastError());
exit(EXIT_FAILURE);
}
atexit((void(*)(void)) WSACleanup);
wsa_init_ = 1;
}
int socketpair(int family, int type, int protocol, int *sv)
{
struct sockaddr_in addr;
SOCKET sfd;
int err, len = sizeof(addr);
if (sv == NULL || family != AF_INET || type != SOCK_STREAM || protocol) {
WSASetLastError(WSAEINVAL);
return SOCKET_ERROR;
}
sv[0] = sv[1] = INVALID_SOCKET;
if ((sfd = socket(family, type, 0)) == INVALID_SOCKET)
return SOCKET_ERROR;
memset(&addr, 0, sizeof(addr));
addr.sin_family = family;
addr.sin_addr.s_addr = inet_addr("127.0.0.1");
addr.sin_port = 0; /* any port */
if ((err = bind(sfd, (const struct sockaddr*)&addr, sizeof(addr))) == SOCKET_ERROR) {
err = WSAGetLastError();
closesocket(sfd);
WSASetLastError(err);
return SOCKET_ERROR;
}
if ((err = getsockname(sfd, (struct sockaddr*)&addr, &len)) == SOCKET_ERROR) {
err = WSAGetLastError();
closesocket(sfd);
WSASetLastError(err);
return SOCKET_ERROR;
}
do {
if (listen(sfd, 1) == SOCKET_ERROR)
break;
if ((sv[0] = WSASocket(family, type, 0, NULL, 0, 0)) == INVALID_SOCKET)
break;
if (connect(sv[0], (const struct sockaddr*)&addr, sizeof(addr)) == SOCKET_ERROR)
break;
if ((sv[1] = accept(sfd, NULL, NULL)) == INVALID_SOCKET)
break;
closesocket(sfd);
return 0;
} while (0);
/* error */
err = WSAGetLastError();
closesocket(sfd);
closesocket(sv[0]);
closesocket(sv[1]);
WSASetLastError(err);
return SOCKET_ERROR;
}
/******************************************************************************/
int nanosleep(const struct timespec *req, struct timespec *rem)
{
if (unlikely(req->tv_nsec < 0 || req->tv_nsec < 0L || req->tv_nsec > 999999999L)) {
errno = EINVAL;
return -1;
}
Sleep(req->tv_sec * 1000 + req->tv_nsec / 1000000L);
if (unlikely(rem)) {
rem->tv_sec = 0;
rem->tv_nsec = 0L;
}
return 0;
}
/*
BOOL GetOsInfo(LPSTR OsName, LPSTR Release, LPSTR Version);
BOOL GetMachInfo(LPSTR MachineName, LPSTR ProcessorName);
int uname(struct utsname *name)
{
char processor[1024];
if (name == NULL) {
errno = EINVAL;
return -1;
}
if (gethostname(name->nodename, sizeof(name->nodename)) < 0) {
name->nodename[0] = '\0';
errno = ENOSYS;
return -1;
}
if (!GetOsInfo(name->sysname, name->release, name->version)) {
strncpy (name->sysname, "win32", sizeof (name->sysname));
strncpy (name->release, "unknown", sizeof (name->release));
strncpy (name->version, "unknown", sizeof (name->version));
}
// "windows32" is as yet the only universal windows description allowed
// by config.guess and config.sub
strncpy(name->sysname, "windows32", sizeof (name->sysname));
if (!GetMachInfo(name->machine, processor))
strncpy(name->machine, "i386", sizeof (name->machine));
return 0;
}
int getrusage(int who, struct rusage *usage)
{
FILETIME ct, et, kt, ut;
ULARGE_INTEGER uli;
if (who != RUSAGE_SELF) {
errno = EINVAL;
return -1;
}
if (!usage) {
errno = EFAULT;
return -1;
}
if (!GetProcessTimes(GetCurrentProcess(), &ct, &et, &kt, &ut)) {
errno = ENOENT;
return -1;
}
// FILETIMEs use 100-ns units
memcpy(&uli, &kt, sizeof(FILETIME));
usage->ru_stime.tv_sec = uli.QuadPart / 10000000L;
usage->ru_stime.tv_usec = uli.QuadPart % 10000000L;
memcpy(&uli, &ut, sizeof(FILETIME));
usage->ru_utime.tv_sec = uli.QuadPart / 10000000L;
usage->ru_utime.tv_usec = uli.QuadPart % 10000000L;
return 0;
}
*/
flrig-2.0.04/src/support/init_user_interface.cxx 0000664 0001750 0001750 00000222616 14505041060 016677 0000000 0000000 // ----------------------------------------------------------------------------
// Copyright (C) 2014-2011
// David Freese, W1HKJ
//
// This file is part of flrig.
//
// flrig is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation; either version 3 of the License, or
// (at your option) any later version.
//
// flrig is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program. If not, see .
// ----------------------------------------------------------------------------
#include "support.h"
#include "ptt.h"
#include "xmlrpc_rig.h"
extern bool testmode;
void TRACED(update_UI_PTT, void *d)
btnPTT->value(PTT);
if (!PTT) {
btnALC_IDD_SWR->hide();
scaleSmeter->show();
sldrRcvSignal->clear();
} else {
btnALC_IDD_SWR->show();
scaleSmeter->hide();
sldrFwdPwr->clear();
sldrALC->clear();
sldrSWR->clear();
}
}
void TRACED(adjust_small_ui)
int y = 0;
mainwindow->resize( mainwindow->x(), mainwindow->y(), SMALL_MAINW, SMALL_MAINH);
btnVol->hide();
sldrVOLUME->hide();
sldrRFGAIN->hide();
btnIFsh->hide();
btn_KX3_IFsh->hide();
sldrIFSHIFT->hide();
btnLOCK->hide();
btnCLRPBT->hide();
sldrINNER->hide();
btnCLRPBT->hide();
sldrOUTER->hide();
btnNotch->hide();
sldrNOTCH->hide();
sldrMICGAIN->hide();
btnPOWER->hide();
sldrPOWER->hide();
btnPOWER->hide();
sldrSQUELCH->hide();
btnNR->hide();
sldrNR->hide();
btnNOISE->hide();
btnAGC->hide();
sldrRFGAIN->redraw_label();
if (!selrig->has_power_out && !selrig->has_voltmeter) {
sm_grp1->resize(FreqDispA->x(), sm_grp1->y(), FreqDispA->w(), 40);
sm_grp1->color(fl_rgb_color(progStatus.bg_red, progStatus.bg_green, progStatus.bg_blue));
grpMeters->resize(sm_grp1->x()+ 2, sm_grp1->y() + 2, sm_grp1->w() - 4, sm_grp1->h() - 4);
scaleSmeter->resize(grpMeters->x(), grpMeters->y() + 6, grpMeters->w(), scaleSmeter->h());
sldrRcvSignal->resize(scaleSmeter->x() + 2, scaleSmeter->y() + scaleSmeter->h() + 6, scaleSmeter->w() - 4, sldrRcvSignal->h());
sldrALC->resize(sldrRcvSignal->x(), sldrRcvSignal->y(), sldrRcvSignal->w(), sldrRcvSignal->h());
sldrIDD->resize(sldrRcvSignal->x(), sldrRcvSignal->y(), sldrRcvSignal->w(), sldrRcvSignal->h());
sldrSWR->resize(sldrRcvSignal->x(), sldrRcvSignal->y(), sldrRcvSignal->w(), sldrRcvSignal->h());
grpMeters->redraw();
sm_grp1->redraw();
sldrRcvSignal->redraw();
sldrALC->redraw();
sldrIDD->redraw();
sldrSWR->redraw();
}
if (progStatus.schema == 1 && selrig->widgets[0].W != (Fl_Widget *)0) {
int i = 0;
while (selrig->widgets[i].W != NULL) {
if (selrig->widgets[i].w != 0)
selrig->widgets[i].W->resize(
selrig->widgets[i].x, selrig->widgets[i].y,
selrig->widgets[i].w, selrig->widgets[i].W->h() );
if (selrig->widgets[i].y > y) y = selrig->widgets[i].y;
selrig->widgets[i].W->show();
selrig->widgets[i].W->redraw();
i++;
}
if (selrig->has_data_port) {
sldrMICGAIN->label("");
sldrMICGAIN->redraw_label();
}
if (selrig->has_power_control) {
btnPOWER->resize( sldrPOWER->x() - 52, sldrPOWER->y(), 50, 18 );
btnPOWER->redraw();
btnPOWER->show();
}
if (mnuSchema) mnuSchema->set();
} else {
if (mnuSchema) mnuSchema->clear();
y = grpMeters->y() + grpMeters->h() - 18;
if (selrig->has_volume_control) {
y += 20;
btnVol->position( 2, y);
btnVol->show();
btnVol->redraw();
sldrVOLUME->resize( 54, y, 368, 18 );
sldrVOLUME->show();
sldrVOLUME->redraw();
}
if (selrig->has_rf_control) {
y += 20;
sldrRFGAIN->resize( 54, y, 368, 18 );
sldrRFGAIN->show();
sldrRFGAIN->redraw();
}
if (selrig->has_sql_control) {
y += 20;
sldrSQUELCH->resize( 54, y, 368, 18 );
sldrSQUELCH->show();
sldrSQUELCH->redraw();
}
if (selrig->has_noise_reduction_control) {
y += 20;
btnNR->position( 2, y);
btnNR->show();
btnNR->redraw();
sldrNR->resize( 54, y, 368, 18 );
sldrNR->show();
sldrNR->redraw();
if (xcvr_name == rig_TT599.name_) btnNR->deactivate();
}
if (selrig->has_pbt_controls) {
y += 20;
btnLOCK->position( 2, y);
if (selrig->name_ == rig_FLEX1500.name_)
btnLOCK->hide();
else
btnLOCK->show();
btnLOCK->redraw();
sldrINNER->resize( 54, y, 368, 18 );
sldrINNER->show();
sldrINNER->redraw();
y += 20;
btnCLRPBT->position( 2, y);
if (selrig->name_ == rig_FLEX1500.name_)
btnCLRPBT->hide();
else
btnCLRPBT->show();
btnCLRPBT->redraw();
sldrOUTER->resize( 54, y, 368, 18);
sldrOUTER->show();
sldrOUTER->redraw();
}
if (selrig->has_ifshift_control) {
y += 20;
if (xcvr_name == rig_KX3.name_) {
btn_KX3_IFsh->position( 2, y );
btn_KX3_IFsh->show();
btn_KX3_IFsh->redraw();
btnIFsh->hide();
btnIFsh->redraw();
} else {
btnIFsh->position( 2, y);
btnIFsh->show();
btnIFsh->redraw();
btn_KX3_IFsh->hide();
btn_KX3_IFsh->redraw();
}
sldrIFSHIFT->resize( 54, y, 368, 18 );
sldrIFSHIFT->show();
sldrIFSHIFT->redraw();
}
if (selrig->has_notch_control) {
y += 20;
btnNotch->position( 2, y);
btnNotch->show();
btnNotch->redraw();
sldrNOTCH->resize( 54, y, 368, 18 );
sldrNOTCH->show();
sldrNOTCH->redraw();
}
if (selrig->has_micgain_control) {
y += 20;
sldrMICGAIN->resize( 54, y, 368, 18 );
sldrMICGAIN->show();
sldrMICGAIN->redraw();
if (selrig->has_data_port) {
sldrMICGAIN->label("");
sldrMICGAIN->redraw_label();
btnDataPort->position( 2, y);
btnDataPort->show();
btnDataPort->redraw();
}
} else if (selrig->has_data_port) {
btnDataPort->position( 214, 105);
btnDataPort->show();
btnDataPort->redraw();
}
if (selrig->has_power_control) {
y += 20;
sldrPOWER->resize( 54, y, 368, 18 );
sldrPOWER->show();
sldrPOWER->redraw();
btnPOWER->resize( 2, y, 50, 18 );
btnPOWER->show();
}
}
y += 20;
btn_show_controls->position( btn_show_controls->x(), y );
btnAttenuator->position( btnAttenuator->x(), y);
btnAttenuator->redraw();
btnPreamp->position( btnPreamp->x(), y);
btnPreamp->redraw();
btnNOISE->position( btnNOISE->x(), y);
btnAutoNotch->position( btnAutoNotch->x(), y);
btnAutoNotch->redraw();
btnTune->position( btnTune->x(), y);
btnTune->redraw();
btn_tune_on_off->position( btn_tune_on_off->x(), y);
btn_tune_on_off->redraw();
cbo_preamp->resize( btnAttenuator->x(), btnAttenuator->y(), cbo_preamp->w(), btnAttenuator->h());
cbo_preamp->redraw();
if (selrig->has_noise_reduction) {
btnNOISE->show();
} else {
btnNOISE->hide();
}
btnNOISE->redraw();
if (selrig->has_agc_control) {
btnAGC->resize(btnAGC->x(), sldrRFGAIN->y(), btnAGC->w(), btnAGC->h());
btnAGC->show();
sldrRFGAIN->label("");
sldrRFGAIN->redraw_label();
} else {
btnAGC->hide();
sldrRFGAIN->label(_("RF"));
sldrRFGAIN->redraw_label();
}
if (xcvr_name == rig_FT1000MP.name_) {
y -= 20;
btnTune->position( btnTune->x(), y);
btnTune->redraw();
btn_tune_on_off->position( btn_tune_on_off->x(), y);
btn_tune_on_off->redraw();
btnAutoNotch->position( btnAutoNotch->x(), y);
btnAutoNotch->redraw();
btnPTT->position( btnPTT->x(), y);
btnPTT->redraw();
}
if (xcvr_name == rig_FT100D.name_ ||
xcvr_name == rig_FT767.name_ ||
xcvr_name == rig_FT817.name_ ||
xcvr_name == rig_FT817BB.name_ ||
xcvr_name == rig_FT818ND.name_ ||
xcvr_name == rig_FT847.name_ ||
xcvr_name == rig_FT857D.name_ ||
xcvr_name == rig_FT890.name_ ||
xcvr_name == rig_FT897D.name_ ||
xcvr_name == rig_FT920.name_ ) {
y -= 20;
btnPTT->position( mainwindow->w() - btnPTT->w() - btn_show_controls->w() - 10, y);
btnPTT->redraw();
btn_show_controls->position( btnPTT->x() + btnPTT->w() + 5, y );
btn_show_controls->redraw();
}
btnPTT->resize(btnPTT->x(), y, btnPTT->w(), 18);
btnPTT->redraw();
btn_show_controls->label("@-22->");
btn_show_controls->redraw_label();
y += 20;
btn_show_controls->show();
mainwindow->init_sizes();
mainwindow->size( mainwindow->w(), y);
if (progStatus.tooltips) {
Fl_Tooltip::enable(1);
if (mnuTooltips) mnuTooltips->set();
} else {
if (mnuTooltips) mnuTooltips->clear();
Fl_Tooltip::enable(0);
}
if (mnuVoltmeter) {
if (progStatus.display_voltmeter)
mnuVoltmeter->set();
else
mnuVoltmeter->clear();
}
if (mnuEmbedTabs) {
if (progStatus.embed_tabs) mnuEmbedTabs->set();
else mnuEmbedTabs->clear();
}
mainwindow->damage();
mainwindow->redraw();
}
void TRACED(adjust_xig_wide)
btnPreamp->show();
btnAttenuator->show();
btnNOISE->show();
btnAutoNotch->hide();
btnAGC->resize(btnAutoNotch->x(), btnAutoNotch->y(), btnAutoNotch->w(), btnAutoNotch->h());
btnAGC->show();
grp_row1b1b->add(btnAGC);
btnAswapB->show();
btnSplit->show();
btnPTT->show();
btnTune->show();
int xig_y = grp_row2->y() + grp_row2->h() / 4;
int xig_h = 5 * btnAGC->h() / 4;
Fl_Group *xig_group = new Fl_Group(
2, xig_y,
mainwindow->w() - 4, xig_h);
Fl_Group *xig_gp1 = new Fl_Group(
xig_group->x(), xig_group->y(),
(xig_group->w() - 4) / 3, xig_h);
btnVol->resize(
xig_gp1->x(), xig_y,
54, xig_gp1->h());
xig_gp1->add(btnVol);
sldrVOLUME->resize(
xig_gp1->x() + 54, xig_y,
xig_gp1->w() - 54, xig_h);
xig_gp1->add(sldrVOLUME);
btnVol->show();
sldrVOLUME->show();
xig_gp1->end();
xig_gp1->resizable(sldrVOLUME);
Fl_Group *xig_gp2 = new Fl_Group(
xig_gp1->x() + xig_gp1->w() + 2, xig_y,
xig_gp1->w(), xig_h);
btnPOWER->resize(
xig_gp2->x(), xig_y,
54, xig_h);
xig_gp2->add(btnPOWER);
sldrPOWER->resize(
xig_gp2->x() + 54, xig_y,
xig_gp2->w() - 54, xig_h);
xig_gp2->add(sldrPOWER);
btnPOWER->show();
sldrPOWER->show();
xig_gp2->end();
xig_gp2->resizable(sldrPOWER);
Fl_Group *xig_gp3 = new Fl_Group(
xig_gp2->x() + xig_gp2->w() + 2, xig_y,
xig_group->w() - 2 * xig_gp1->w() - 4, xig_h);
xig_gp3->add(sldrSQUELCH);
sldrSQUELCH->resize(
xig_gp3->x() + 54, xig_y,
xig_gp3->w() - 54, xig_h);
sldrSQUELCH->label("SQL");
sldrSQUELCH->redraw_label();
sldrSQUELCH->show();
xig_gp3->end();
xig_gp3->resizable(sldrSQUELCH);
xig_group->end();
grp_row2a->remove(sldrMICGAIN);
grp_row2a->resize(xig_group->x(), xig_group->y(), xig_group->w(), xig_group->h());
grp_row2a->hide();
grp_row2b->remove(btnIFsh);
grp_row2b->remove(btn_KX3_IFsh);
grp_row2b->remove(sldrIFSHIFT);
grp_row2b->resize(xig_group->x(), xig_group->y(), xig_group->w(), xig_group->h());
grp_row2b->hide();
grp_row2c->remove(sldrRFGAIN);
grp_row2c->resize(xig_group->x(), xig_group->y(), xig_group->w(), xig_group->h());
grp_row2c->hide();
grp_row2->resize(xig_group->x(), xig_group->y(), xig_group->w(), xig_group->h());
grp_row2->hide();
mainwindow->remove(grp_row2);
mainwindow->add(xig_group);
if (progStatus.tooltips) {
Fl_Tooltip::enable(1);
if (mnuTooltips) mnuTooltips->set();
} else {
if (mnuTooltips) mnuTooltips->clear();
Fl_Tooltip::enable(0);
}
if (mnuVoltmeter) {
if (progStatus.display_voltmeter)
mnuVoltmeter->set();
else
mnuVoltmeter->clear();
}
mainwindow->redraw();
return;
}
void TRACED(adjust_wide_ui)
mainwindow->resize(
progStatus.mainX, progStatus.mainY, progStatus.mainW, progStatus.mainH);
mainwindow->redraw();
btnVol->show();
sldrVOLUME->show();
sldrRFGAIN->show();
if (selrig->has_ifshift_control) {
if (xcvr_name != rig_KX3.name_)
btnIFsh->show();
else
btn_KX3_IFsh->show();
sldrIFSHIFT->show();
}
if (selrig->has_pbt_controls) {
if (selrig->name_ == rig_FLEX1500.name_) {
sldrINNER->minimum(-4000);
sldrINNER->maximum(4000);
sldrINNER->step(50);
sldrINNER->tooltip(_("Lower PBT control"));
sldrINNER->label(_("Lower"));
sldrINNER->align(FL_ALIGN_LEFT);
sldrINNER->value(progStatus.pbt_inner);
sldrOUTER->minimum(-4000);
sldrOUTER->maximum(4000);
sldrOUTER->step(50);
sldrOUTER->tooltip(_("Upper PBT control"));
sldrOUTER->label(_("Upper"));
sldrOUTER->align(FL_ALIGN_LEFT);
sldrOUTER->value(progStatus.pbt_outer);
btnLOCK->hide();
btnIFsh->hide();
btnCLRPBT->hide();
sldrINNER->show();
sldrOUTER->show();
} else {
btnLOCK->show();
btnLOCK->value(progStatus.pbt_lock);
btnCLRPBT->show();
sldrINNER->show();
sldrOUTER->show();
sldrINNER->value(progStatus.pbt_inner);
sldrINNER->redraw();
sldrOUTER->value(progStatus.pbt_outer);
sldrOUTER->redraw();
}
}
btnNotch->show();
sldrNOTCH->show();
sldrMICGAIN->show();
sldrPOWER->show();
btnPOWER->hide();
sldrSQUELCH->show();
btnNR->show();
sldrNR->show();
btnAGC->hide();
btnDataPort->hide();
sldrRFGAIN->redraw_label();
if (!selrig->has_micgain_control)
sldrMICGAIN->deactivate();
if (!selrig->has_noise_reduction)
btnNR->deactivate();
if (!selrig->has_noise_reduction_control)
sldrNR->deactivate();
if (xcvr_name == rig_TT550.name_) {
tabs550->show();
tabsGeneric->hide();
} else {
tabs550->hide();
if (selrig->has_agc_control) {
btnAGC->show();
sldrRFGAIN->label("");
sldrRFGAIN->redraw_label();
} else {
btnAGC->hide();
sldrRFGAIN->label(_("RF"));
sldrRFGAIN->redraw_label();
}
if (selrig->has_power_control) {
btnPOWER->resize(sldrPOWER->x() - 52, sldrPOWER->y(), 50, 18);
btnPOWER->show();
}
else {
sldrPOWER->deactivate();
}
}
if (progStatus.tooltips) {
Fl_Tooltip::enable(1);
if (mnuTooltips) mnuTooltips->set();
} else {
if (mnuTooltips) mnuTooltips->clear();
Fl_Tooltip::enable(0);
}
if (mnuVoltmeter) {
if (progStatus.display_voltmeter)
mnuVoltmeter->set();
else
mnuVoltmeter->clear();
}
mainwindow->redraw();
}
void TRACED(adjust_touch_ui)
mainwindow->resize( mainwindow->x(), mainwindow->y(), mainwindow->w(), TOUCH_MAINH);
mainwindow->redraw();
if (spnrPOWER) spnrPOWER->show();
if (sldrPOWER) sldrPOWER->show();
btnVol->show();
if (spnrVOLUME) spnrVOLUME->show();
if (sldrVOLUME) sldrVOLUME->show();
if (spnrRFGAIN) spnrRFGAIN->show();
if (sldrRFGAIN) sldrRFGAIN->show();
if (xcvr_name != rig_KX3.name_)
btnIFsh->show();
else
btn_KX3_IFsh->show();
if (spnrIFSHIFT) spnrIFSHIFT->show();
if (sldrIFSHIFT) sldrIFSHIFT->show();
btnNotch->show();
if (spnrNOTCH) spnrNOTCH->show();
if (sldrNOTCH) sldrNOTCH->show();
if (spnrMICGAIN) spnrMICGAIN->show();
if (sldrMICGAIN) sldrMICGAIN->show();
if (spnrSQUELCH) spnrSQUELCH->show();
if (sldrSQUELCH) sldrSQUELCH->show();
if (selrig->has_agc_control) {
btnAGC->show();
sldrRFGAIN->label("");
sldrRFGAIN->redraw_label();
} else {
btnAGC->hide();
sldrRFGAIN->label(_("RF"));
sldrRFGAIN->redraw_label();
}
btnNR->show();
if (spnrNR) spnrNR->show();
if (sldrNR) sldrNR->show();
if (xcvr_name == rig_TT550.name_) {
tabs550->show();
tabsGeneric->hide();
} else {
tabs550->hide();
tabsGeneric->remove(genericAux);
genericAux->hide();
btnAuxDTR->hide();
btnAuxRTS->hide();
btnDataPort->hide();
if (progStatus.aux_serial_port != "NONE") {
btnAuxRTS->show();
btnAuxDTR->show();
tabsGeneric->add(genericAux);
genericAux->show();
}
tabsGeneric->remove(genericRXB);
genericRXB->hide();
if (selrig->has_rit || selrig->has_xit || selrig->has_bfo) {
if (selrig->has_rit) cntRIT->show();
else cntRIT->hide();
if (selrig->has_xit) cntXIT->show();
else cntXIT->hide();
if (selrig->has_bfo) cntBFO->show();
else cntBFO->hide();
tabsGeneric->add(genericRXB);
genericRXB->show();
}
tabsGeneric->show();
}
if (progStatus.tooltips) {
Fl_Tooltip::enable(1);
if (mnuTooltips) mnuTooltips->set();
} else {
if (mnuTooltips) mnuTooltips->clear();
Fl_Tooltip::enable(0);
}
if (mnuVoltmeter) {
if (progStatus.display_voltmeter)
mnuVoltmeter->set();
else
mnuVoltmeter->clear();
}
mainwindow->init_sizes();
mainwindow->size_range(WIDE_MAINW, WIDE_MAINH, 0, WIDE_MAINH);
mainwindow->redraw();
}
void TRACED(adjust_control_positions)
sldrRcvSignal->activate();
sigbar_SMETER->activate();
sldrALC->activate();
sigbar_ALC->activate();
sldrIDD->activate();
sigbar_IDD->activate();
sldrSWR->activate();
sigbar_SWR->activate();
sldrVoltage->activate();
sigbar_VOLTS->activate();
sldrFwdPwr->activate();
sigbar_PWR->activate();
if (!selrig->has_smeter) {
sldrRcvSignal->deactivate();
sigbar_SMETER->deactivate();
}
if (!selrig->has_alc_control) {
sldrALC->deactivate();
sigbar_ALC->deactivate();
}
if (!selrig->has_idd_control) {
sldrIDD->deactivate();
sigbar_IDD->deactivate();
}
if (!selrig->has_swr_control) {
sldrSWR->deactivate();
sigbar_SWR->deactivate();
}
if (!selrig->has_voltmeter) {
sldrVoltage->deactivate();
sigbar_VOLTS->deactivate();
}
if (!selrig->has_power_out) {
sldrFwdPwr->deactivate();
sigbar_PWR->hide(); //deactivate();
scalePower->hide();
}
switch (progStatus.UIsize) {
case small_ui :
adjust_small_ui();
break;
case wide_ui :
if (xcvr_name == rig_XIG90.name_)
adjust_xig_wide();
else
adjust_wide_ui();
break;
case touch_ui :
default :
adjust_touch_ui();
break;
}
// change control labels / tooltips if necessary
int i = 0;
while (selrig->widgets[i].W != NULL) {
if (!selrig->widgets[i].label.empty()) {
selrig->widgets[i].W->label(selrig->widgets[i].label.c_str());
selrig->widgets[i].W->redraw_label();
}
if (!selrig->widgets[i].hint.empty()) {
selrig->widgets[i].W->tooltip(selrig->widgets[i].hint.c_str());
}
selrig->widgets[i].W->redraw();
i++;
}
FreqDispA->set_hrd(progStatus.hrd_buttons);
FreqDispB->set_hrd(progStatus.hrd_buttons);
if (selrig->name_ == rig_FT891.name_) {
// Default FT891 to only send slider updates to rig once slider
// is released. This avoids a condition where once slider is
// released, the slider value no longer tracks changes from
// controls on the rig.
progStatus.sliders_button = FL_WHEN_RELEASE;
chk_sliders_button->value(false);
}
set_sliders_when();
}
void TRACED(init_Generic_Tabs)
if (hidden_tabs) {
hidden_tabs->remove(tab_yaesu_bands);
hidden_tabs->remove(tab_ft991_bands);
hidden_tabs->remove(tab_FT8n_bands);
hidden_tabs->remove(tab_FT8n_CTCSS);
hidden_tabs->remove(tab_icom_bands);
hidden_tabs->remove(genericCW);
hidden_tabs->remove(genericQSK);
hidden_tabs->remove(genericVOX);
hidden_tabs->remove(genericSpeech);
hidden_tabs->remove(genericRx);
hidden_tabs->remove(genericMisc);
hidden_tabs->remove(genericAux);
hidden_tabs->remove(genericRXB);
hidden_tabs->remove(genericUser_1);
hidden_tabs->remove(genericUser_2);
hidden_tabs->remove(genericUser_3);
// hidden_tabs->remove(kx3_extras);
hidden_tabs->remove(tab7610);
hidden_tabs->add(tab_yaesu_bands);
hidden_tabs->add(tab_ft991_bands);
hidden_tabs->add(tab_FT8n_bands);
hidden_tabs->add(tab_FT8n_CTCSS);
hidden_tabs->add(tab_icom_bands);
hidden_tabs->add(genericCW);
hidden_tabs->add(genericQSK);
hidden_tabs->add(genericVOX);
hidden_tabs->add(genericSpeech);
hidden_tabs->add(genericRx);
hidden_tabs->add(genericMisc);
hidden_tabs->add(genericAux);
hidden_tabs->add(genericRXB);
hidden_tabs->add(genericUser_1);
hidden_tabs->add(genericUser_2);
hidden_tabs->add(genericUser_3);
// hidden_tabs->add(kx3_extras);
hidden_tabs->add(tab7610);
} else {
tabsGeneric->remove(tab_yaesu_bands);
tabsGeneric->remove(tab_ft991_bands);
tabsGeneric->remove(tab_FT8n_bands);
tabsGeneric->remove(tab_FT8n_CTCSS);
tabsGeneric->remove(tab_icom_bands);
tabsGeneric->remove(genericCW);
tabsGeneric->remove(genericQSK);
tabsGeneric->remove(genericVOX);
tabsGeneric->remove(genericSpeech);
tabsGeneric->remove(genericRx);
tabsGeneric->remove(genericMisc);
tabsGeneric->remove(genericAux);
tabsGeneric->remove(genericRXB);
tabsGeneric->remove(genericUser_1);
tabsGeneric->remove(genericUser_2);
tabsGeneric->remove(genericUser_3);
// tabsGeneric->remove(kx3_extras);
tabsGeneric->remove(tab7610);
}
if (selrig->has_band_selection) {
if (selrig->ICOMrig ||
selrig->name_ == rig_XIG90.name_ ||
selrig->name_ == rig_X6100.name_ ) {
tabsGeneric->add(tab_icom_bands);
tab_icom_bands->redraw();
tab_icom_bands->show();
} else if (selrig->name_ == rig_FT857D.name_ || selrig->name_ == rig_FT897D.name_) {
tabsGeneric->add(tab_FT8n_bands);
tabsGeneric->add(tab_FT8n_CTCSS);
tab_FT8n_bands->redraw();
tab_FT8n_CTCSS->redraw();
tab_FT8n_bands->show();
tab_FT8n_CTCSS->show();
} else if (selrig->name_ == rig_FT991A.name_) {
tabsGeneric->add(tab_ft991_bands);
tab_ft991_bands->redraw();
tab_ft991_bands->show();
} else {
tabsGeneric->add(tab_yaesu_bands);
tab_yaesu_bands->redraw();
tab_yaesu_bands->show();
}
}
if (selrig->has_cw_wpm ||
selrig->has_cw_weight ||
selrig->has_cw_keyer ||
selrig->has_cw_spot ||
selrig->has_cw_spot_tone ) {
if (selrig->has_cw_wpm) {
int min, max;
selrig->get_cw_wpm_min_max(min, max);
spnr_cw_wpm->minimum(min);
spnr_cw_wpm->maximum(max);
spnr_cw_wpm->value(progStatus.cw_wpm);
spnr_cw_wpm->show();
} else
spnr_cw_wpm->hide();
if (selrig->has_cw_weight) {
double min, max, step;
selrig->get_cw_weight_min_max_step( min, max, step );
spnr_cw_weight->minimum(min);
spnr_cw_weight->maximum(max);
spnr_cw_weight->step(step);
spnr_cw_weight->value(progStatus.cw_weight);
spnr_cw_weight->show();
} else
spnr_cw_weight->hide();
if (selrig->has_cw_keyer) {
btn_enable_keyer->show();
btn_enable_keyer->value(progStatus.enable_keyer);
selrig->enable_keyer();
}
else
btn_enable_keyer->hide();
if (selrig->has_cw_spot) {
btnSpot->value(progStatus.cw_spot);
selrig->set_cw_spot();
btnSpot->show();
} else
btnSpot->hide();
if (selrig->has_cw_spot_tone) {
spnr_cw_spot_tone->show();
int min, max, step;
selrig->get_cw_spot_tone_min_max_step(min, max, step);
spnr_cw_spot_tone->minimum(min);
spnr_cw_spot_tone->maximum(max);
spnr_cw_spot_tone->step(step);
spnr_cw_spot_tone->value(progStatus.cw_spot_tone);
selrig->set_cw_spot_tone();
} else
spnr_cw_spot_tone->hide();
tabsGeneric->add(genericCW);
genericCW->redraw();
genericCW->show();
}
if (selrig->has_cw_qsk) {
btnBreakIn->show();
spnr_cw_delay->show();
if (selrig->has_cw_qsk) {
double min, max, step;
selrig->get_cw_qsk_min_max_step(min, max, step);
spnr_cw_qsk->minimum(min);
spnr_cw_qsk->maximum(max);
spnr_cw_qsk->step(step);
spnr_cw_qsk->value(progStatus.cw_qsk);
spnr_cw_qsk->show();
} else
spnr_cw_qsk->hide();
tabsGeneric->add(genericQSK);
genericQSK->redraw();
genericQSK->show();
}
if (selrig->has_vox_onoff ||
selrig->has_vox_gain ||
selrig->has_vox_hang ||
selrig->has_vox_on_dataport) {
if (selrig->has_vox_onoff) {
btn_vox->value(progStatus.vox_onoff);
btn_vox->show();
selrig->set_vox_onoff();
} else
btn_vox->hide();
if (selrig->has_vox_gain) {
int min, max, step;
selrig->get_vox_gain_min_max_step(min, max, step);
spnr_vox_gain->minimum(min);
spnr_vox_gain->maximum(max);
spnr_vox_gain->step(step);
spnr_vox_gain->value(progStatus.vox_gain);
spnr_vox_gain->show();
selrig->set_vox_gain();
} else
spnr_vox_gain->hide();
if (selrig->has_vox_anti) {
int min, max, step;
selrig->get_vox_anti_min_max_step(min, max, step);
spnr_anti_vox->minimum(min);
spnr_anti_vox->maximum(max);
spnr_anti_vox->step(step);
spnr_anti_vox->value(progStatus.vox_anti);
spnr_anti_vox->show();
selrig->set_vox_anti();
} else
spnr_anti_vox->hide();
if (selrig->has_vox_hang) {
int min, max, step;
selrig->get_vox_hang_min_max_step(min, max, step);
spnr_vox_hang->minimum(min);
spnr_vox_hang->maximum(max);
spnr_vox_hang->step(step);
spnr_vox_hang->value(progStatus.vox_hang);
spnr_vox_hang->show();
selrig->set_vox_hang();
} else
spnr_vox_hang->hide();
if (selrig->has_vox_on_dataport) {
btn_vox_on_dataport->value(progStatus.vox_on_dataport);
btn_vox_on_dataport->show();
selrig->set_vox_on_dataport();
} else
btn_vox_on_dataport->hide();
tabsGeneric->add(genericVOX);
genericVOX->redraw();
genericVOX->show();
}
if (selrig->has_compON ||
selrig->has_compression ) {
if (selrig->has_compON) {
btnCompON->show();
btnCompON->value(progStatus.compON);
} else
btnCompON->hide();
if (selrig->has_compression) {
int min, max, step;
selrig->get_comp_min_max_step(min, max, step);
spnr_compression->minimum(min);
spnr_compression->maximum(max);
spnr_compression->step(step);
spnr_compression->show();
spnr_compression->value(progStatus.compression);
selrig->set_compression(progStatus.compON, progStatus.compression);
} else
spnr_compression->hide();
tabsGeneric->add(genericSpeech);
genericSpeech->redraw();
genericSpeech->show();
}
if (selrig->has_nb_level ||
selrig->has_bpf_center ||
selrig->has_vfo_adj ||
selrig->has_line_out ) {
if (selrig->has_nb_level)
sldr_nb_level->show();
else
sldr_nb_level->hide();
if (selrig->has_bpf_center) {
spnr_bpf_center->value(progStatus.bpf_center);
spnr_bpf_center->activate();
btn_use_bpf_center->activate();
spnr_bpf_center->show();
btn_use_bpf_center->show();
} else {
spnr_bpf_center->hide();
btn_use_bpf_center->hide();
}
if (selrig->has_vfo_adj) {
double min, max, step;
selrig->get_vfoadj_min_max_step(min, max, step);
spnr_vfo_adj->minimum(min);
spnr_vfo_adj->maximum(max);
spnr_vfo_adj->step(step);
progStatus.vfo_adj = selrig->getVfoAdj();
spnr_vfo_adj->value(progStatus.vfo_adj);
spnr_vfo_adj->activate();
spnr_vfo_adj->show();
} else
spnr_vfo_adj->hide();
if (selrig->has_line_out) {
spnr_line_out->activate();
spnr_line_out->show();
} else {
spnr_line_out->deactivate();
spnr_line_out->hide();
}
tabsGeneric->add(genericRx);
genericRx->redraw();
genericRx->show();
}
if (selrig->has_line_out ||
selrig->has_xcvr_auto_on_off ||
selrig->can_synch_clock ) {
btn_xcvr_auto_on->show();
btn_xcvr_auto_off->show();
if (selrig->has_xcvr_auto_on_off) {
btn_xcvr_auto_on->value(progStatus.xcvr_auto_on);
btn_xcvr_auto_off->value(progStatus.xcvr_auto_off);
btn_xcvr_auto_on->activate();
btn_xcvr_auto_off->activate();
} else {
btn_xcvr_auto_on->deactivate();
btn_xcvr_auto_off->deactivate();
}
if (selrig->can_synch_clock) {
btn_xcvr_synch_clock->show();
btn_xcvr_synch_gmt->show();
btn_xcvr_synch_now->show();
txt_xcvr_synch->show();
} else {
btn_xcvr_synch_clock->hide();
btn_xcvr_synch_gmt->hide();
btn_xcvr_synch_now->hide();
txt_xcvr_synch->hide();
}
btn_xcvr_synch_clock->redraw();
btn_xcvr_synch_gmt->redraw();
btn_xcvr_synch_now->redraw();
txt_xcvr_synch->redraw();
tabsGeneric->add(genericMisc);
genericMisc->redraw();
genericMisc->show();
}
tabsGeneric->remove(genericAux);
genericAux->hide();
btnAuxDTR->hide();
btnAuxRTS->hide();
btnDataPort->hide();
if (progStatus.aux_serial_port != "NONE") {
btnAuxRTS->show();
btnAuxDTR->show();
tabsGeneric->add(genericAux);
genericAux->show();
}
tabsGeneric->remove(genericRXB);
genericRXB->hide();
if (selrig->has_rit || selrig->has_xit || selrig->has_bfo) {
if (selrig->has_rit) cntRIT->show();
else cntRIT->hide();
if (selrig->has_xit) cntXIT->show();
else cntXIT->hide();
if (selrig->has_bfo) cntBFO->show();
else cntBFO->hide();
tabsGeneric->add(genericRXB);
genericRXB->show();
}
genericRXB->redraw();
// btnAuxDTR->hide();
// btnAuxRTS->hide();
// btnDataPort->hide();
tabsGeneric->add(genericUser_1);
genericUser_1->redraw();
genericUser_1->show();
tabsGeneric->add(genericUser_2);
genericUser_2->redraw();
genericUser_2->show();
tabsGeneric->add(genericUser_3);
genericUser_3->redraw();
genericUser_3->show();
if (selrig->name_ == rig_IC7610.name_) {
tabsGeneric->add(tab7610);
tab7610->redraw();
tab7610->show();
btnAttenuator->hide();
}
tabsGeneric->redraw();
tabsGeneric->show();
if (progStatus.UIsize != touch_ui)
tabs_dialog->init_sizes();
poll_frequency->activate(); poll_frequency->value(progStatus.poll_frequency);
poll_mode->activate(); poll_mode->value(progStatus.poll_mode);
poll_bandwidth->activate(); poll_bandwidth->value(progStatus.poll_bandwidth);
poll_smeter->activate(); poll_smeter->value(progStatus.poll_smeter);
poll_pout->activate(); poll_pout->value(progStatus.poll_pout);
poll_swr->activate(); poll_swr->value(progStatus.poll_swr);
poll_alc->activate(); poll_alc->value(progStatus.poll_alc);
poll_volume->activate(); poll_volume->value(progStatus.poll_volume);
poll_notch->activate(); poll_notch->value(progStatus.poll_notch);
poll_auto_notch->activate(); poll_auto_notch->value(progStatus.poll_auto_notch);
poll_ifshift->activate(); poll_ifshift->value(progStatus.poll_ifshift);
poll_power_control->activate(); poll_power_control->value(progStatus.poll_power_control);
poll_pre_att->activate(); poll_pre_att->value(progStatus.poll_pre_att);
poll_squelch->activate(); poll_squelch->value(progStatus.poll_squelch);
poll_micgain->activate(); poll_micgain->value(progStatus.poll_micgain);
poll_rfgain->activate(); poll_rfgain->value(progStatus.poll_rfgain);
poll_split->activate(); poll_split->value(progStatus.poll_split);
poll_noise->activate(); poll_noise->value(progStatus.poll_noise);
poll_nr->activate(); poll_nr->value(progStatus.poll_nr);
poll_compression->activate(); poll_compression->value(progStatus.poll_compression);
if (!selrig->has_bandwidth_control) {
poll_bandwidth->deactivate();
poll_bandwidth->value( progStatus.poll_bandwidth = 0 ); }
if (!selrig->has_smeter) {
poll_smeter->deactivate();
poll_smeter->value( progStatus.poll_smeter = 0 ); }
if (!selrig->has_power_out) {
poll_pout->deactivate();
poll_pout->value( progStatus.poll_pout = 0 ); }
if (!selrig->has_swr_control) {
poll_swr->deactivate();
poll_swr->value( progStatus.poll_swr = 0 ); }
if (!selrig->has_alc_control) {
poll_alc->deactivate();
poll_alc->value( progStatus.poll_alc = 0 ); }
if (!selrig->has_volume_control) {
poll_volume->deactivate();
poll_volume->value( progStatus.poll_volume = 0 ); }
if (!selrig->has_notch_control) {
poll_notch->deactivate();
poll_notch->value( progStatus.poll_notch = 0 ); }
if (!selrig->has_tune_control) {
poll_tuner->deactivate();
poll_tuner->value( progStatus.poll_tuner = 0 ); }
if (!selrig->has_cw_break_in) {
poll_break_in->deactivate();
poll_break_in->value( progStatus.poll_break_in = 0 ); }
if (!selrig->has_auto_notch ||
xcvr_name == rig_FT1000MP.name_ ) {
poll_auto_notch->deactivate();
poll_auto_notch->value( progStatus.poll_auto_notch = 0 ); }
if (!selrig->has_ifshift_control) {
poll_ifshift->deactivate();
poll_ifshift->value( progStatus.poll_ifshift = 0 ); }
if (!selrig->has_pbt_controls) {
poll_pbt->deactivate();
poll_pbt->value( progStatus.poll_pbt = 0 ); }
if (!selrig->has_power_control) {
poll_power_control->deactivate();
poll_power_control->value( progStatus.poll_power_control = 0 ); }
if (!selrig->has_preamp_control && !selrig->has_attenuator_control) {
poll_pre_att->deactivate();
poll_pre_att->value( progStatus.poll_pre_att = 0 ); }
if (!selrig->has_sql_control) {
poll_squelch->deactivate();
poll_squelch->value( progStatus.poll_squelch = 0 ); }
if (!selrig->has_micgain_control) {
poll_micgain->deactivate();
poll_micgain->value( progStatus.poll_micgain = 0 ); }
if (!selrig->has_rf_control) {
poll_rfgain->deactivate();
poll_rfgain->value( progStatus.poll_rfgain = 0 ); }
if (!selrig->has_split) {
poll_split->deactivate();
poll_split->value( progStatus.poll_split = 0 ); }
if (!selrig->has_noise_control) {
poll_noise->deactivate();
poll_noise->value( progStatus.poll_noise = 0 );}
if (!selrig->has_noise_reduction) {
poll_nr->deactivate();
poll_nr->value( progStatus.poll_nr = 0 );}
if (!selrig->has_compression) {
poll_compression->deactivate();
poll_compression->value( progStatus.poll_compression = 0 ); }
}
void TRACED(initTabs)
if (xcvr_name == rig_TT550.name_)
init_TT550_tabs();
else
init_Generic_Tabs();
}
void TRACED(init_rit)
if (!cntRIT) return;
if (selrig->has_rit) {
int min, max, step;
selrig->get_RIT_min_max_step(min, max, step);
cntRIT->minimum(min);
cntRIT->maximum(max);
cntRIT->step(step);
switch (progStatus.UIsize) {
case touch_ui :
cntRIT->activate();
break;
case small_ui :
case wide_ui :
default :
cntRIT->show();
}
cntRIT->value(progStatus.rit_freq);
} else {
switch (progStatus.UIsize) {
case touch_ui :
cntRIT->deactivate();
break;
case small_ui :
case wide_ui :
default :
cntRIT->hide();
}
}
}
void TRACED(init_xit)
if (!cntXIT) return;
if (selrig->has_xit) {
int min, max, step;
selrig->get_XIT_min_max_step(min, max, step);
cntXIT->minimum(min);
cntXIT->maximum(max);
cntXIT->step(step);
cntXIT->value(progStatus.xit_freq);
switch (progStatus.UIsize) {
case small_ui :
cntXIT->show();
break;
case wide_ui : case touch_ui : default :
cntXIT->activate();
}
} else {
switch (progStatus.UIsize) {
case small_ui :
cntXIT->hide();
case wide_ui : case touch_ui : default :
cntXIT->deactivate();
}
}
}
void TRACED(init_bfo)
if (!cntBFO) return;
if (selrig->has_bfo) {
int min, max, step;
selrig->get_BFO_min_max_step(min, max, step);
cntBFO->minimum(min);
cntBFO->maximum(max);
cntBFO->step(step);
cntBFO->value(progStatus.bfo_freq);
switch (progStatus.UIsize) {
case small_ui :
cntBFO->show();
break;
case wide_ui : case touch_ui : default :
cntBFO->activate();
}
} else {
switch (progStatus.UIsize) {
case small_ui :
cntBFO->hide();
break;
case wide_ui : case touch_ui : default :
cntBFO->deactivate();
}
}
}
static void cb_pbt(Fl_Counter *, void *)
{
selrig->set_pbt( opFilterInner->value(), opFilterOuter->value() );
}
void TRACED(init_dsp_controls)
if (selrig->has_dsp_controls) {
opDSP_lo->clear();
opDSP_hi->clear();
btnDSP->label(selrig->SL_label);
btnDSP->redraw_label();
try {
for (size_t i = 0; i < selrig->dsp_SL.size(); i++)
opDSP_lo->add(selrig->dsp_SL.at(i).c_str());
opDSP_lo->tooltip(selrig->SL_tooltip);
for (size_t i = 0; i < selrig->dsp_SH.size(); i++)
opDSP_hi->add(selrig->dsp_SH.at(i).c_str());
opDSP_hi->tooltip(selrig->SH_tooltip);
} catch (const std::exception& e) {
LOG_ERROR("%s", e.what());
}
if (vfo->iBW > 256) {
opDSP_lo->index(vfo->iBW & 0xFF);
opDSP_hi->index((vfo->iBW >> 8) & 0x7F);
btnDSP->show();
opDSP_hi->show();
opDSP_lo->hide();
opBW->hide();
opBW->index(0);
btnFILT->hide();
} else { //if ( (xcvr_name != rig_KX3.name_ )){
opDSP_lo->index(0);
opDSP_hi->index(0);
btnDSP->hide();
opDSP_lo->hide();
opDSP_hi->hide();
btnFILT->hide();
opBW->show();
}
} else if (selrig->has_FILTER) {
btnDSP->hide();
opDSP_lo->hide();
opDSP_hi->hide();
btnFILT->show();
opBW->resize(opDSP_lo->x(), opDSP_lo->y(), opDSP_lo->w(), opDSP_lo->h());
opBW->redraw();
opBW->show();
} else {
btnDSP->hide();
opDSP_lo->hide();
opDSP_hi->hide();
btnFILT->hide();
opBW->show();
if (selrig->name_ == rig_tci_sundx.name_ ||
selrig->name_ == rig_tci_sunpro.name_ ) {
opCENTER->clear();
for (int i = 0; i < tci_nbr_centers; i++)
opCENTER->add(TCI_centers[i].c_str());
opCENTER->show();
opCENTER->index(progStatus.tci_center);
if (progStatus.UIsize == small_ui) {
opFilterInner->resize(214, 103, 100, 18);
opFilterInner->redraw();
opFilterOuter->resize(320, 103, 100, 18);
opFilterOuter->redraw();
}
opFilterInner->callback((Fl_Callback*)cb_pbt);
opFilterInner->show();
opFilterOuter->callback((Fl_Callback*)cb_pbt);
opFilterOuter->show();
}
}
}
void TRACED(init_volume_control)
if (selrig->has_volume_control) {
int min, max, step;
selrig->get_vol_min_max_step(min, max, step);
if (spnrVOLUME) {
spnrVOLUME->minimum(min);
spnrVOLUME->maximum(max);
spnrVOLUME->step(step);
spnrVOLUME->redraw();
spnrVOLUME->activate();
}
if (sldrVOLUME) {
sldrVOLUME->minimum(min);
sldrVOLUME->maximum(max);
sldrVOLUME->step(step);
sldrVOLUME->redraw();
sldrVOLUME->activate();
}
switch (progStatus.UIsize) {
case small_ui :
btnVol->show();
if (sldrVOLUME) sldrVOLUME->show();
if (spnrVOLUME) spnrVOLUME->show();
break;
case wide_ui : case touch_ui : default :
btnVol->activate();
if (sldrVOLUME) sldrVOLUME->activate();
if (spnrVOLUME) spnrVOLUME->activate();
}
} else {
switch (progStatus.UIsize) {
case small_ui :
btnVol->hide();
if (sldrVOLUME) sldrVOLUME->hide();
if (spnrVOLUME) spnrVOLUME->hide();
break;
case wide_ui : case touch_ui : default :
btnVol->deactivate();
if (sldrVOLUME) sldrVOLUME->deactivate();
if (spnrVOLUME) spnrVOLUME->deactivate();
}
}
}
void TRACED(set_init_volume_control)
if (!selrig->has_volume_control)
return;
if (progStatus.use_rig_data) {
progStatus.volume = selrig->get_volume_control();
if (sldrVOLUME) sldrVOLUME->value(progStatus.volume);
if (sldrVOLUME) sldrVOLUME->activate();
btnVol->value(1);
if (spnrVOLUME) spnrVOLUME->value(progStatus.volume);
if (spnrVOLUME) spnrVOLUME->activate();
sldrVOLUME->activate();
} else {
if (sldrVOLUME) sldrVOLUME->value(progStatus.volume);
if (spnrVOLUME) spnrVOLUME->value(progStatus.volume);
if (progStatus.spkr_on == 0) {
btnVol->value(0);
if (sldrVOLUME) sldrVOLUME->deactivate();
if (spnrVOLUME) spnrVOLUME->deactivate();
selrig->set_volume_control(0);
} else {
btnVol->value(1);
if (sldrVOLUME) sldrVOLUME->activate();
if (spnrVOLUME) spnrVOLUME->activate();
selrig->set_volume_control(progStatus.volume);
}
}
}
void TRACED(init_rf_control)
if (selrig->has_rf_control) {
int min, max, step;
selrig->get_rf_min_max_step(min, max, step);
if (sldrRFGAIN) sldrRFGAIN->minimum(min);
if (sldrRFGAIN) sldrRFGAIN->maximum(max);
if (sldrRFGAIN) sldrRFGAIN->step(step);
if (sldrRFGAIN) sldrRFGAIN->redraw();
if (spnrRFGAIN) spnrRFGAIN->minimum(min);
if (spnrRFGAIN) spnrRFGAIN->maximum(max);
if (spnrRFGAIN) spnrRFGAIN->step(step);
if (spnrRFGAIN) spnrRFGAIN->redraw();
switch (progStatus.UIsize) {
case small_ui :
if (sldrRFGAIN) sldrRFGAIN->show();
if (spnrRFGAIN) spnrRFGAIN->show();
break;
case wide_ui : case touch_ui : default :
if (sldrRFGAIN) sldrRFGAIN->activate();
if (spnrRFGAIN) spnrRFGAIN->activate();
}
} else {
switch (progStatus.UIsize) {
case small_ui :
if (sldrRFGAIN) sldrRFGAIN->hide();
if (spnrRFGAIN) spnrRFGAIN->hide();
break;
case wide_ui : case touch_ui : default :
if (sldrRFGAIN) sldrRFGAIN->deactivate();
if (spnrRFGAIN) spnrRFGAIN->deactivate();
}
}
if (selrig->name_ == rig_ICF8101.name_) {
if (sldrRFGAIN) sldrRFGAIN->deactivate();
if (spnrRFGAIN) spnrRFGAIN->deactivate();
}
}
void TRACED(set_init_rf_gain)
if (!selrig->has_rf_control)
return;
if (progStatus.use_rig_data) {
progStatus.rfgain = selrig->get_rf_gain();
if (sldrRFGAIN) sldrRFGAIN->value(progStatus.rfgain);
if (spnrRFGAIN) spnrRFGAIN->value(progStatus.rfgain);
} else {
if (sldrRFGAIN) sldrRFGAIN->value(progStatus.rfgain);
if (spnrRFGAIN) spnrRFGAIN->value(progStatus.rfgain);
selrig->set_rf_gain(progStatus.rfgain);
}
}
void TRACED(init_sql_control)
if (selrig->has_sql_control) {
int min, max, step;
selrig->get_squelch_min_max_step(min, max, step);
if (sldrSQUELCH) sldrSQUELCH->minimum(min);
if (sldrSQUELCH) sldrSQUELCH->maximum(max);
if (sldrSQUELCH) sldrSQUELCH->step(step);
if (sldrSQUELCH) sldrSQUELCH->redraw();
if (spnrSQUELCH) spnrSQUELCH->minimum(min);
if (spnrSQUELCH) spnrSQUELCH->maximum(max);
if (spnrSQUELCH) spnrSQUELCH->step(step);
if (spnrSQUELCH) spnrSQUELCH->redraw();
switch (progStatus.UIsize) {
case small_ui :
if (sldrSQUELCH) sldrSQUELCH->show();
if (spnrSQUELCH) spnrSQUELCH->show();
break;
case wide_ui : case touch_ui : default:
if (sldrSQUELCH) sldrSQUELCH->activate();
if (spnrSQUELCH) spnrSQUELCH->activate();
}
} else {
switch (progStatus.UIsize) {
case small_ui :
if (sldrSQUELCH) sldrSQUELCH->hide();
if (spnrSQUELCH) spnrSQUELCH->hide();
break;
case wide_ui : case touch_ui : default :
if (sldrSQUELCH) sldrSQUELCH->deactivate();
if (spnrSQUELCH) spnrSQUELCH->deactivate();
}
}
}
void TRACED(set_init_sql_control)
if (!selrig->has_sql_control)
return;
if (progStatus.use_rig_data) {
progStatus.squelch = selrig->get_squelch();
if (sldrSQUELCH) sldrSQUELCH->value(progStatus.squelch);
if (spnrSQUELCH) spnrSQUELCH->value(progStatus.squelch);
} else {
if (sldrSQUELCH) sldrSQUELCH->value(progStatus.squelch);
if (spnrSQUELCH) spnrSQUELCH->value(progStatus.squelch);
selrig->set_squelch(progStatus.squelch);
}
}
void TRACED(set_init_noise_reduction_control)
if (!selrig->has_noise_reduction_control)
return;
if (progStatus.use_rig_data) {
progStatus.noise_reduction = selrig->get_noise_reduction();
progStatus.noise_reduction_val = selrig->get_noise_reduction_val();
btnNR->value(progStatus.noise_reduction);
if (sldrNR) sldrNR->value(progStatus.noise_reduction_val);
if (spnrNR) spnrNR->value(progStatus.noise_reduction_val);
if (selrig->name_ == rig_FT891.name_) {
// On the FT-891, the usual definitions of NB and NR buttons
// as defined in FLRIG are reversed. Relabel them to match
// what the user sees in the radio screens, and handle the
// mapping to appropriate cat controls in the FT891.xx class.
btnNR->label("NB");
btnNR->tooltip(_("Noise Blanker On/Off"));
}
} else {
btnNR->value(progStatus.noise_reduction);
if (sldrNR) sldrNR->value(progStatus.noise_reduction_val);
if (spnrNR) spnrNR->value(progStatus.noise_reduction_val);
selrig->set_noise_reduction(progStatus.noise_reduction);
selrig->set_noise_reduction_val(progStatus.noise_reduction_val);
}
}
void TRACED(init_noise_reduction_control)
if (selrig->has_noise_reduction_control) {
int min, max, step;
selrig->get_nr_min_max_step(min, max, step);
if (sldrNR) sldrNR->minimum(min);
if (sldrNR) sldrNR->maximum(max);
if (sldrNR) sldrNR->step(step);
if (sldrNR) sldrNR->redraw();
if (spnrNR) spnrNR->minimum(min);
if (spnrNR) spnrNR->maximum(max);
if (spnrNR) spnrNR->step(step);
if (spnrNR) spnrNR->redraw();
if (selrig->name_ == rig_FT891.name_) {
// On the FT-891, the usual definitions of NB and NR buttons
// as defined in FLRIG are reversed. Relabel them to match
// what the user sees in the radio screens, and handle the
// mapping to appropriate cat controls in the FT891.xx class.
sldrNR->tooltip(_("Adjust noise blanker"));
}
switch (progStatus.UIsize) {
case small_ui :
btnNR->show();
if (sldrNR) sldrNR->show();
if (spnrNR) spnrNR->show();
break;
case wide_ui : case touch_ui : default:
btnNR->show();
if (sldrNR) sldrNR->show();//activate();
if (spnrNR) spnrNR->show();//activate();
break;
}
} else {
switch (progStatus.UIsize) {
case small_ui :
btnNR->hide();
if (sldrNR) sldrNR->hide();
if (spnrNR) sldrNR->hide();
break;
case wide_ui : case touch_ui : default :
btnNR->hide();//deactivate();
if (sldrNR) sldrNR->hide();//deactivate();
if (spnrNR) spnrNR->hide();//deactivate();
break;
}
}
}
void TRACED(set_init_if_shift_control)
if (!selrig->has_ifshift_control)
return;
if (progStatus.use_rig_data) {
progStatus.shift = selrig->get_if_shift(progStatus.shift_val);
btnIFsh->value(progStatus.shift);
if (sldrIFSHIFT) sldrIFSHIFT->value(progStatus.shift_val);
if (spnrIFSHIFT) spnrIFSHIFT->value(progStatus.shift_val);
} else {
if (progStatus.shift) {
btnIFsh->value(1);
if (sldrIFSHIFT) sldrIFSHIFT->value(progStatus.shift_val);
if (spnrIFSHIFT) spnrIFSHIFT->value(progStatus.shift_val);
selrig->set_if_shift(progStatus.shift_val);
} else {
btnIFsh->value(0);
if (sldrIFSHIFT) sldrIFSHIFT->value(selrig->if_shift_mid);
if (spnrIFSHIFT) spnrIFSHIFT->value(selrig->if_shift_mid);
selrig->set_if_shift(selrig->if_shift_mid);
}
}
}
void TRACED(init_if_shift_control)
if (btnLOCK) btnLOCK->hide();
if (btnCLRPBT) btnCLRPBT->hide();
if (sldrINNER) sldrINNER->hide();
if (sldrOUTER) sldrOUTER->hide();
if (btnIFsh) btnIFsh->hide();
if (sldrIFSHIFT) sldrIFSHIFT->hide();
if (spnrIFSHIFT) spnrIFSHIFT->hide();
if (selrig->has_ifshift_control) {
if (xcvr_name != rig_KX3.name_)
btnIFsh->show();
else
btn_KX3_IFsh->show();
sldrIFSHIFT->show();
if (spnrIFSHIFT) spnrIFSHIFT->show();
int min, max, step;
selrig->get_if_min_max_step(min, max, step);
if (sldrIFSHIFT) sldrIFSHIFT->minimum(min);
if (sldrIFSHIFT) sldrIFSHIFT->maximum(max);
if (sldrIFSHIFT) sldrIFSHIFT->step(step);
if (sldrIFSHIFT) sldrIFSHIFT->redraw();
if (spnrIFSHIFT) spnrIFSHIFT->minimum(min);
if (spnrIFSHIFT) spnrIFSHIFT->maximum(max);
if (spnrIFSHIFT) spnrIFSHIFT->step(step);
if (spnrIFSHIFT) spnrIFSHIFT->redraw();
switch (progStatus.UIsize) {
case small_ui :
if (xcvr_name != rig_KX3.name_)
btnIFsh->show();
else
btn_KX3_IFsh->show();
if (sldrIFSHIFT) sldrIFSHIFT->show();
if (spnrIFSHIFT) spnrIFSHIFT->show();
break;
case wide_ui : case touch_ui : default :
if (xcvr_name != rig_KX3.name_) btnIFsh->activate();
if (sldrIFSHIFT) sldrIFSHIFT->activate();
if (spnrIFSHIFT) spnrIFSHIFT->activate();
break;
}
} else {
switch (progStatus.UIsize) {
case small_ui :
btnIFsh->hide();
if (sldrIFSHIFT) sldrIFSHIFT->hide();
if (spnrIFSHIFT) spnrIFSHIFT->hide();
break;
case wide_ui : case touch_ui : default :
btnIFsh->deactivate();
if (sldrIFSHIFT) sldrIFSHIFT->deactivate();
if (spnrIFSHIFT) spnrIFSHIFT->deactivate();
break;
}
}
if (selrig->has_pbt_controls) {
if (selrig->name_ == rig_FLEX1500.name_) {
sldrINNER->minimum(-4000);
sldrINNER->maximum(4000);
sldrINNER->step(50);
sldrINNER->tooltip(_("Lower PBT control"));
sldrINNER->label(_("Lower"));
sldrINNER->align(FL_ALIGN_LEFT);
sldrINNER->redraw_label();
sldrOUTER->minimum(-4000);
sldrOUTER->maximum(4000);
sldrOUTER->step(50);
sldrOUTER->tooltip(_("Upper PBT control"));
sldrOUTER->label(_("Upperer"));
sldrOUTER->align(FL_ALIGN_LEFT);
sldrOUTER->redraw_label();
btnLOCK->hide();
btnIFsh->hide();
btnCLRPBT->hide();
sldrINNER->show();
sldrOUTER->show();
} else {
btnLOCK->show();
btnLOCK->value(progStatus.pbt_lock);
btnCLRPBT->show();
sldrINNER->show();
sldrOUTER->show();
sldrINNER->value(progStatus.pbt_inner);
sldrINNER->redraw();
sldrOUTER->value(progStatus.pbt_outer);
sldrOUTER->redraw();
selrig->set_pbt_outer(progStatus.pbt_outer);
selrig->set_pbt_inner(progStatus.pbt_inner);
}
}
if (xcvr_name == rig_TS870S.name_) {
if (progStatus.imode_A == RIG_TS870S::tsCW ||
progStatus.imode_A == RIG_TS870S::tsCWR) {
btnIFsh->activate();
if (sldrIFSHIFT) sldrIFSHIFT->activate();
if (spnrIFSHIFT) spnrIFSHIFT->activate();
} else {
btnIFsh->deactivate();
if (sldrIFSHIFT) sldrIFSHIFT->deactivate();
if (spnrIFSHIFT) spnrIFSHIFT->deactivate();
}
}
}
void TRACED(init_notch_control)
if (selrig->has_notch_control) {
int min, max, step;
selrig->get_notch_min_max_step(min, max, step);
if (sldrNOTCH) sldrNOTCH->minimum(min);
if (sldrNOTCH) sldrNOTCH->maximum(max);
if (sldrNOTCH) sldrNOTCH->step(step);
if (sldrNOTCH) sldrNOTCH->redraw();
if (spnrNOTCH) spnrNOTCH->minimum(min);
if (spnrNOTCH) spnrNOTCH->maximum(max);
if (spnrNOTCH) spnrNOTCH->step(step);
if (spnrNOTCH) spnrNOTCH->redraw();
switch (progStatus.UIsize) {
case small_ui :
btnNotch->show();
if (sldrNOTCH) sldrNOTCH->show();
if (spnrNOTCH) spnrNOTCH->show();
break;
case wide_ui : case touch_ui : default :
btnNotch->activate();
if (sldrNOTCH) sldrNOTCH->activate();
if (spnrNOTCH) spnrNOTCH->activate();
break;
}
} else {
switch (progStatus.UIsize) {
case small_ui :
btnNotch->hide();
if (sldrNOTCH) sldrNOTCH->hide();
if (spnrNOTCH) spnrNOTCH->hide();
break;
case wide_ui : case touch_ui : default :
btnNotch->deactivate();
if (sldrNOTCH) sldrNOTCH->deactivate();
if (spnrNOTCH) spnrNOTCH->deactivate();
break;
}
}
}
void TRACED(set_init_notch_control)
if (selrig->has_notch_control) {
if (progStatus.use_rig_data) {
progStatus.notch = selrig->get_notch(progStatus.notch_val);
btnNotch->value(progStatus.notch);
if (sldrNOTCH) sldrNOTCH->value(progStatus.notch_val);
if (spnrNOTCH) spnrNOTCH->value(progStatus.notch_val);
} else {
btnNotch->value(progStatus.notch);
if (sldrNOTCH) sldrNOTCH->value(progStatus.notch_val);
if (spnrNOTCH) spnrNOTCH->value(progStatus.notch_val);
selrig->set_notch(progStatus.notch, progStatus.notch_val);
}
}
}
void TRACED(init_micgain_control)
if (selrig->has_micgain_control) {
int min = 0, max = 0, step = 0;
selrig->get_mic_min_max_step(min, max, step);
if (sldrMICGAIN) sldrMICGAIN->minimum(min);
if (sldrMICGAIN) sldrMICGAIN->maximum(max);
if (sldrMICGAIN) sldrMICGAIN->step(step);
if (spnrMICGAIN) spnrMICGAIN->minimum(min);
if (spnrMICGAIN) spnrMICGAIN->maximum(max);
if (spnrMICGAIN) spnrMICGAIN->step(step);
switch (progStatus.UIsize) {
case small_ui :
if (sldrMICGAIN) sldrMICGAIN->show();
if (spnrMICGAIN) spnrMICGAIN->show();
break;
case wide_ui : case touch_ui : default :
if (sldrMICGAIN) sldrMICGAIN->activate();
if (spnrMICGAIN) spnrMICGAIN->activate();
break;
}
} else {
if (sldrMICGAIN) sldrMICGAIN->deactivate();
if (spnrMICGAIN) spnrMICGAIN->deactivate();
}
switch (progStatus.UIsize) {
case small_ui :
if (sldrMICGAIN) sldrMICGAIN->hide();
if (spnrMICGAIN) spnrMICGAIN->hide();
break;
case wide_ui : case touch_ui : default :
if (sldrMICGAIN) sldrMICGAIN->deactivate();
if (spnrMICGAIN) spnrMICGAIN->deactivate();
}
}
void TRACED(set_init_micgain_control)
int min, max, step;
if (selrig->has_micgain_control) {
if (progStatus.use_rig_data)
progStatus.mic_gain = selrig->get_mic_gain();
else
selrig->set_mic_gain(progStatus.mic_gain);
selrig->get_mic_min_max_step(min, max, step);
if (sldrMICGAIN) {
sldrMICGAIN->minimum(min);
sldrMICGAIN->maximum(max);
sldrMICGAIN->step(step);
sldrMICGAIN->value(progStatus.mic_gain);
sldrMICGAIN->activate();
}
if (spnrMICGAIN) {
spnrMICGAIN->minimum(min);
spnrMICGAIN->maximum(max);
spnrMICGAIN->step(step);
spnrMICGAIN->value(progStatus.mic_gain);
spnrMICGAIN->activate();
}
} else {
if (sldrMICGAIN) sldrMICGAIN->deactivate();
if (spnrMICGAIN) sldrMICGAIN->deactivate();
}
}
void TRACED(init_power_control)
double min, max, step;
if (selrig->has_power_control) {
sldrPOWER->activate();
selrig->get_pc_min_max_step(min, max, step);
if (sldrPOWER) sldrPOWER->minimum(min);
if (sldrPOWER) sldrPOWER->maximum(max);
if (sldrPOWER) sldrPOWER->step(step);
if (sldrPOWER) sldrPOWER->value(progStatus.power_level);
if (sldrPOWER) sldrPOWER->show();
if (sldrPOWER) sldrPOWER->redraw();
if (spnrPOWER) spnrPOWER->minimum(min);
if (spnrPOWER) spnrPOWER->maximum(max);
if (spnrPOWER) spnrPOWER->step(step);
if (spnrPOWER) spnrPOWER->value(progStatus.power_level);
if (spnrPOWER) spnrPOWER->show();
if (spnrPOWER) spnrPOWER->redraw();
} else {
if (sldrPOWER) sldrPOWER->deactivate();
if (spnrPOWER) spnrPOWER->deactivate();
}
}
void TRACED(set_init_power_control)
if (selrig->has_power_control) {
if (progStatus.use_rig_data)
progStatus.power_level = selrig->get_power_control();
else
selrig->set_power_control(progStatus.power_level);
}
set_power_controlImage(progStatus.power_level);
}
void TRACED(init_attenuator_control)
if (selrig->has_attenuator_control) {
if (selrig->name_ == rig_FT891.name_) {
btnAttenuator->label("ATT");
btnAttenuator->redraw_label();
}
switch (progStatus.UIsize) {
case small_ui :
btnAttenuator->show();
break;
case wide_ui : case touch_ui : default :
btnAttenuator->activate();
}
} else {
switch (progStatus.UIsize) {
case small_ui :
btnAttenuator->hide();
break;
case wide_ui : case touch_ui : default :
btnAttenuator->deactivate();
}
}
}
void TRACED(set_init_attenuator_control)
if (selrig->has_attenuator_control) {
if (!progStatus.use_rig_data)
selrig->set_attenuator(progStatus.attenuator);
}
}
void TRACED(init_agc_control)
if (selrig->has_agc_control) {
btnAGC->show();
sldrRFGAIN->label("");
sldrRFGAIN->redraw_label();
} else {
btnAGC->hide();
sldrRFGAIN->label(_("RF"));
sldrRFGAIN->redraw_label();
}
}
void TRACED(init_preamp_control)
if (selrig->has_preamp_control) {
if (selrig->name_ == rig_FLEX1500.name_ ) {
btnAttenuator->hide();
btnPreamp->hide();
cbo_preamp->show();
return;
}
if (selrig->name_ == rig_FT891.name_) {
btnPreamp->label("IPO");
btnPreamp->redraw_label();
}
if (selrig->name_ == rig_PCR1000.name_) {
btnPreamp->label("AGC");
btnPreamp->redraw_label();
}
switch (progStatus.UIsize) {
case small_ui :
btnPreamp->show();
break;
case wide_ui : case touch_ui : default :
btnPreamp->activate();
}
if (xcvr_name == rig_IC9700.name_) {
btnPreamp->tooltip("\
Internal/External preamp\n\
P0/E0 off/off\n\
P1/E0 on/off\n\
P0/E1 off/on\n\
P1/E1 on/on");
btnPreamp->label("P0/E0");
btnPreamp->redraw_label();
}
else {
if (selrig->name_ == rig_PCR1000.name_) {
btnPreamp->tooltip("On/Off"); //Kludge necessary to get the tooltip verbiage for the PCR-1000 correct. Feel free to re-order the if-else statements
}
else
btnPreamp->tooltip("On/Off/Level");
}
} else {
switch (progStatus.UIsize) {
case small_ui :
btnPreamp->hide();
break;
case wide_ui : case touch_ui : default :
btnPreamp->deactivate();
}
}
}
void TRACED(set_init_preamp_control)
if (selrig->has_preamp_control) {
if (!progStatus.use_rig_data)
selrig->set_preamp(progStatus.preamp);
}
}
void TRACED(init_noise_control)
int min, max, step;
if (selrig->has_noise_control) {
if (xcvr_name == rig_TS990.name_) {
btnNOISE->label("AGC"); //Set TS990 AGC Label
btnNOISE->tooltip("TS990 AGC control");
btnNR->label("NR1"); //Set TS990 NR Button
btnNR->tooltip("TS990 noise reduction control");
}
if (selrig->name_ == rig_FT891.name_) {
// On the FT-891, the usual definitions of NB and NR buttons
// as defined in FLRIG are reversed. Relabel them to match
// what the user sees in the radio screens, and handle the
// mapping to appropriate cat controls in the FT891.xx class.
btnNOISE->label("DNR");
btnNOISE->tooltip(_("DSP Noise Reduction On/Off. See RX tab for DNR level."));
}
if (selrig->name_ == rig_PCR1000.name_) {
// The PCR-1000 has no Noise Blanker. This control is used to activate its UT-106 DSP
// Module, which has NR and Auto-Notch features.
btnNOISE->label("DSP");
btnNOISE->tooltip(_("DSP Noise Reduction On/Off. Set NR operation and level with NR section."));
}
btnNOISE->show();
btnNOISE->activate();
}
else {
btnNOISE->hide();
btnNOISE->deactivate();
}
if (selrig->has_nb_level) {
selrig->get_nb_min_max_step(min, max, step);
sldr_nb_level->minimum(min);
sldr_nb_level->maximum(max);
sldr_nb_level->step(step);
sldr_nb_level->value(progStatus.nb_level);
if (selrig->name_ == rig_FT891.name_) {
// On the FT-891, the usual definitions of NB and NR buttons
// as defined in FLRIG are reversed. Relabel them to match
// what the user sees in the radio screens, and handle the
// mapping to appropriate cat controls in the FT891.xx class.
sldr_nb_level->label("DNR level");
sldr_nb_level->tooltip(_("Adjust DSP Noise Reduction level"));
}
sldr_nb_level->activate();
sldr_nb_level->redraw();
} else
sldr_nb_level->deactivate();
}
void TRACED(init_split_control)
if (selrig->has_split || selrig->has_split_AB) {
btnSplit->show();
btnSplit->activate();
} else {
btnSplit->hide();
btnSplit->deactivate();
}
}
void TRACED(set_init_noise_control)
if (selrig->has_noise_control) {
if (progStatus.use_rig_data)
progStatus.noise = selrig->get_noise();
else
selrig->set_noise(progStatus.noise);
btnNOISE->value(progStatus.noise);
btnNOISE->show();
btnNOISE->activate();
} else {
btnNOISE->hide();
btnNOISE->deactivate();
}
}
void TRACED(init_tune_control)
if (selrig->has_tune_control) {
switch (progStatus.UIsize) {
case small_ui :
btnTune->show();
btn_tune_on_off->show();
break;
case wide_ui : case touch_ui : default :
btnTune->activate();
btn_tune_on_off->activate();
}
} else {
switch (progStatus.UIsize) {
case small_ui :
btnTune->hide();
btn_tune_on_off->hide();
break;
case wide_ui : case touch_ui : default :
btnTune->deactivate();
btn_tune_on_off->deactivate();
}
}
}
void TRACED(init_ptt_control)
if (selrig->has_ptt_control ||
progStatus.serial_dtrptt == PTT_BOTH || progStatus.serial_dtrptt == PTT_SET ||
progStatus.serial_rtsptt == PTT_BOTH || progStatus.serial_rtsptt == PTT_SET ||
progStatus.sep_dtrptt == PTT_BOTH || progStatus.sep_dtrptt == PTT_SET ||
progStatus.sep_rtsptt == PTT_BOTH || progStatus.sep_rtsptt == PTT_SET) {
btnPTT->activate();
} else {
btnPTT->deactivate();
}
}
void TRACED(init_auto_notch)
if (selrig->has_auto_notch) {
if (xcvr_name == rig_RAY152.name_) {
btnAutoNotch->label("AGC");
btnAutoNotch->tooltip("AGC on/off");
} else if (xcvr_name == rig_FT1000MP.name_) {
btnAutoNotch->label("Tuner");
btnAutoNotch->tooltip("Tuner on/off");
} else if (xcvr_name == rig_FT891.name_) {
btnAutoNotch->label("DNF");
btnAutoNotch->tooltip("DSP Auto notch filter on/off");
} else {
btnAutoNotch->label("AN");
btnAutoNotch->tooltip("Auto notch on/off");
}
switch (progStatus.UIsize) {
case small_ui :
btnAutoNotch->show();
break;
case wide_ui : case touch_ui : default :
btnAutoNotch->activate();
}
} else {
switch (progStatus.UIsize) {
case small_ui :
btnAutoNotch->hide();
break;
case wide_ui : case touch_ui : default :
btnAutoNotch->deactivate();
}
}
}
void TRACED(set_init_auto_notch)
if (selrig->has_auto_notch) {
if (progStatus.use_rig_data)
progStatus.auto_notch = selrig->get_auto_notch();
else
selrig->set_auto_notch(progStatus.auto_notch);
btnAutoNotch->value(progStatus.auto_notch);
}
}
void TRACED(init_swr_control)
if (selrig->has_swr_control)
btnALC_IDD_SWR->activate();
else {
btnALC_IDD_SWR->deactivate();
}
}
void TRACED(set_init_compression_control)
if (selrig->has_compON || selrig->has_compression) {
selrig->set_compression(progStatus.compON, progStatus.compression);
if (selrig->name_ == rig_FT891.name_) {
// On the FT-891, compression is called PRC, under function
// menu FUNCTION-1. Set the button to match for consistency.
btnCompON->label("PRC");
btnCompON->tooltip("Set speech processor for SSB modes on/off.");
}
}
}
void TRACED(set_init_break_in)
if (!selrig->has_cw_break_in) return;
selrig->get_break_in();
}
void TRACED(init_special_controls)
btnSpecial->show();
if (selrig->has_special)
btnSpecial->activate();
else
btnSpecial->deactivate();
}
void TRACED(init_external_tuner)
btn_ext_tuner->show();
if (selrig->has_ext_tuner)
btn_ext_tuner->activate();
else
btn_ext_tuner->deactivate();
}
void TRACED(init_CIV)
if (selrig->CIV) {
char hexstr[8];
snprintf(hexstr, sizeof(hexstr), "0x%02X", selrig->CIV);
txtCIV->value(hexstr);
txtCIV->activate();
btnCIVdefault->activate();
if (selrig->name_ == rig_IC7200.name_ ||
selrig->name_ == rig_IC7300.name_ ||
selrig->name_ == rig_IC7600.name_ ||
selrig->name_ == rig_IC7800.name_ ) {
btnUSBaudio->value(progStatus.USBaudio = true);
btnUSBaudio->activate();
} else
btnUSBaudio->deactivate();
} else {
txtCIV->value("");
txtCIV->deactivate();
btnCIVdefault->deactivate();
btnUSBaudio->value(false);
btnUSBaudio->deactivate();
}
}
void TRACED(init_TS990_special)
if (xcvr_name == rig_TS990.name_) { // Setup TS990 Mon Button
btnIFsh->label("MON");
btnIFsh->tooltip("\
Turn TX monitor on/off\n\
Slider controls TX monitor level");
}
}
void cb_bw_A(Fl_ComboBox *, void *)
{
int nubw = opBW_A->index();
guard_lock serial(&mutex_serial);
selrig->set_bwA( nubw );
vfoA.iBW = nubw;
// int timeout = 500; // msec
// while (timeout && (selrig->get_bwA() != nubw)) {
// MilliSleep(50);
// timeout -= 50;
// Fl::awake();
// }
}
void cb_bw_B(Fl_ComboBox *, void *)
{
int nubw = opBW_B->index();
guard_lock serial(&mutex_serial);
selrig->set_bwB( nubw );
vfoB.iBW = nubw;
// int timeout = 500; // msec
// while (timeout && (selrig->get_bwB() != nubw)) {
// MilliSleep(50);
// timeout -= 50;
// Fl::awake();
// }
}
void TRACED(init_elecraft_xcvrs)
if (!(xcvr_name == rig_K3.name_ ||
xcvr_name == rig_KX3.name_ ||
xcvr_name == rig_K4.name_ ) ) return;
if (xcvr_name == rig_K3.name_) {
btnB->hide();
btnA->hide();
btnAswapB->hide();
btn_KX3_swapAB->hide();
btn_K3_swapAB->show();
btn_K3_A2B->show();
opBW_A->hide();
opBW_B->hide();
opBW->show();
return;
}
if (xcvr_name == rig_KX3.name_ || xcvr_name == rig_K4.name_) {
btn_K3_swapAB->hide();
btn_K3_A2B->hide();
btn_KX3_swapAB->hide();
btn_KX3_A2B->hide();
labelMEMORY->hide();
btnB->show();
btnA->show();
btnAswapB->show();
opDSP_lo->hide();
opDSP_hi->hide();
btnDSP->hide();
btnFILT->hide();
opBW->hide();
if (progStatus.UIsize == small_ui) {
opBW_A->resize(opBW->x(), opBW->y() + opBW->h(), opBW->w(), opBW->h());
opBW_A->redraw();
opBW_B->resize(opMODE->x(), opBW_A->y(), opBW_A->w(), opBW_A->h());
opBW_B->redraw();
}
try {
selrig->bandwidths_ = selrig->bwtable(vfo->imode);
for (size_t i = 0; i < selrig->bandwidths_.size(); i++) {
opBW_A->add(selrig->bandwidths_.at(i).c_str());
opBW_B->add(selrig->bandwidths_.at(i).c_str());
}
opBW_A->index(vfoA.iBW);
opBW_B->index(vfoB.iBW);
} catch (const std::exception& e) {
LOG_ERROR("%s", e.what());
opBW_A->index(0);
opBW_B->index(0);
}
opBW_A->callback((Fl_Callback*)cb_bw_A);
opBW_B->callback((Fl_Callback*)cb_bw_B);
opBW_A->redraw(); opBW_A->show();
opBW_B->redraw(); opBW_B->show();
return;
}
}
void cb_sdr2_A(Fl_Light_Button * b, void *)
{
guard_lock A(&mutex_serial);
if (b->value()) {
selrig->selectB();
btnA->label("ch B");
btnA->redraw();
}
else {
selrig->selectA();
btnA->label("ch A");
btnA->redraw();
}
updateUI((void *)0);
}
void cb_sdr2_B(Fl_Light_Button * b, void *)
{
guard_lock B(&mutex_serial);
if (b->value()) {
btnB->label("Rx 2");
if (selrig->name_ == rig_tci_sundx.name_)
rig_tci_sundx.set_slice(1);
else
rig_tci_sunpro.set_slice(1);
}
else {
btnB->label("Rx 1");
if (selrig->name_ == rig_tci_sundx.name_)
rig_tci_sundx.set_slice(0);
else
rig_tci_sunpro.set_slice(0);
}
btnB->redraw_label();
updateUI((void *)0);
}
void TRACED(init_sdr2)
btnA->label("ch A");
btnA->redraw_label();
btnA->callback((Fl_Callback *)cb_sdr2_A);
btnB->label("Rx 0");
btnB->redraw_label();
btnB->callback((Fl_Callback *)cb_sdr2_B);
}
extern void read_menus();
void TRACED(initRig)
xcvr_online = false;
RigSerial->failed(0);
if (tabs_dialog && tabs_dialog->visible()) tabs_dialog->hide();
main_group->hide();
grpInitializing->size(mainwindow->w(), mainwindow->h() - grpInitializing->y());
grpInitializing->show();
grpInitializing->redraw();
mainwindow->damage();
mainwindow->redraw();
update_progress(0);
Fl::check();
sldrRcvSignal->aging(progStatus.rx_peak);
sldrRcvSignal->avg(progStatus.rx_avg);
sldrFwdPwr->aging(progStatus.pwr_peak);
sldrFwdPwr->avg(progStatus.pwr_avg);
sldrSWR->aging(progStatus.pwr_peak);
sldrSWR->avg(progStatus.pwr_avg);
sldrALC->aging(progStatus.pwr_peak);
sldrALC->avg(progStatus.pwr_avg);
sldrIDD->aging(progStatus.pwr_peak);
sldrIDD->avg(progStatus.pwr_avg);
sldrVoltage->aging(1);
sldrVoltage->avg(1);
sigbar_SMETER->aging(progStatus.rx_peak);
sigbar_SMETER->avg(progStatus.rx_avg);
sigbar_PWR->aging(progStatus.pwr_peak);
sigbar_PWR->avg(progStatus.pwr_avg);
sigbar_SWR->aging(progStatus.pwr_peak);
sigbar_SWR->avg(progStatus.pwr_avg);
sigbar_ALC->aging(progStatus.pwr_peak);
sigbar_ALC->avg(progStatus.pwr_avg);
sigbar_IDD->aging(progStatus.pwr_peak);
sigbar_IDD->avg(progStatus.pwr_avg);
sigbar_VOLTS->aging(1);
sigbar_VOLTS->avg(1);
if (selrig->has_voltmeter) {
sldrVoltage->show();
scaleVoltage->show();
sldrFwdPwr->hide();
scalePower->hide();
} else {
sldrVoltage->hide();
scaleVoltage->hide();
}
if (progStatus.use_tcpip) {
try {
connect_to_remote();
} catch (...) {
grpInitializing->hide();
main_group->show();
mainwindow->redraw();
return;
}
}
trace(1, "selrig->initialize()");
selrig->initialize();
// disable the serial thread
{
guard_lock gl_serial(&mutex_serial);
trace(1, "init_rig()");
// Xcvr Auto Power on as soon as possible
if (selrig->has_xcvr_auto_on_off && progStatus.xcvr_auto_on) {
progress->label("Auto Start");
progress->redraw_label();
update_progress(0);
selrig->set_xcvr_auto_on();
progress->label("Initializing");
progress->redraw_label();
update_progress(0);
}
init_special_controls();
init_external_tuner();
init_rit();
init_xit();
init_bfo();
init_dsp_controls();
init_volume_control();
init_rf_control();
init_sql_control();
init_noise_reduction_control();
init_if_shift_control();
init_notch_control();
init_micgain_control();
init_power_control();
init_attenuator_control();
init_agc_control();
init_preamp_control();
init_noise_control();
init_tune_control();
init_ptt_control();
init_auto_notch();
init_swr_control();
init_split_control();
if (selrig->name_ == rig_QCXP.name_) read_menus();
if (!testmode && xcvr_name != rig_null.name_) {
trace(1, "selrig->check()");
if (!selrig->check()) {
trace(1, "FAILED");
bypass_serial_thread_loop = true;
xcvr_online = false;
adjust_control_positions();
grpInitializing->hide();
main_group->show();
mainwindow->redraw();
show_controls();
box_xcvr_connect->color(FL_BACKGROUND2_COLOR);
box_xcvr_connect->redraw();
fl_alert2(_("\
Transceiver not responding!\n\n\
Check serial (COM) port connection\n\
Open menu Config/Setup/Transceiver\n\
Press 'Update' button, reselect port\n\
Check that Baud matches transceiver baud\n\n\
Press 'Init' button."));
return;
}
}
FreqDispA->set_precision(selrig->precision);
FreqDispA->set_ndigits(selrig->ndigits);
FreqDispB->set_precision(selrig->precision);
FreqDispB->set_ndigits(selrig->ndigits);
if (xcvr_name == rig_TT550.name_)
init_TT550();
else
init_generic_rig();
set_init_volume_control();
set_init_rf_gain();
set_init_sql_control();
set_init_noise_reduction_control();
set_init_if_shift_control();
set_init_micgain_control();
set_init_power_control();
set_init_attenuator_control();
set_init_preamp_control();
set_init_noise_control();
set_init_auto_notch();
set_init_notch_control();
set_init_compression_control();
set_init_break_in();
initTabs();
buildlist();
init_CIV();
selrig->post_initialize();
init_TS990_special();
init_elecraft_xcvrs();
if (selrig->name_ == rig_tci_sundx.name_ || selrig->name_ == rig_tci_sunpro.name_ )
init_sdr2();
if (selrig->has_power_control) {
if (progStatus.use_rig_data)
progStatus.power_level = selrig->get_power_control();
else
selrig->set_power_control(progStatus.power_level);
}
}
bypass_serial_thread_loop = false;
grpInitializing->hide();
grpInitializing->redraw();
adjust_control_positions();
if (selrig->name_ == rig_TS990.name_) // UI tab issue pending real fix
progStatus.show_tabs = false;
show_controls();
main_group->show();
main_group->redraw();
mainwindow->damage();
mainwindow->show();
mainwindow->redraw();
Fl::flush();
xcvr_online = true;
box_xcvr_connect->color(FL_GREEN);
box_xcvr_connect->redraw();
if (selrig->name_ == rig_FTdx101MP.name_ ||
selrig->name_ == rig_IC7851.name_ ) {
sldrVoltage->minimum (47); sldrVoltage->maximum (52);
sigbar_VOLTS->minimum (47); sigbar_VOLTS->maximum (52);
scaleVoltage->image(image_volts50);
mtr_VOLTS->image(image_volts50);
} else {
sldrVoltage->minimum (6); sldrVoltage->maximum (16);
sigbar_VOLTS->minimum (6); sigbar_VOLTS->maximum (16);
scaleVoltage->image(image_voltmeter);
mtr_VOLTS->image(image_voltmeter);
}
scaleVoltage->redraw_label();
mtr_VOLTS->redraw_label();
sldrIDD->maximum(25);
sldrIDD->minimum(0);
sigbar_IDD->maximum(25);
sigbar_IDD->minimum(0);
start_commands();
return;
}
void TRACED(init_title)
title = PACKAGE;
title += " ";
title.append(selrig->name_);
if (progStatus.xmlrpc_rig) title.append(" CLIENT");
mainwindow->label(title.c_str());
}
void TRACED(initConfigDialog)
rigbase *srig = (rigbase *)(selectRig->data());
xcvr_name = srig->name_;
LOG_INFO("picked %s", xcvr_name.c_str());
if (!progStatus.loadXcvrState(xcvr_name) ) {
selectCommPort->index(0);
mnuBaudrate->index( srig->serial_baudrate );
btnOneStopBit->value( srig->stopbits == 1 );
btnTwoStopBit->value( srig->stopbits == 2 );
cntRigCatRetries->value( srig->serial_retries );
cntRigCatTimeout->value( srig->serial_timeout );
cntPostWriteDelay->value( srig->serial_post_write_delay );
cntWriteDelay->value( srig->serial_write_delay );
query_interval->value( srig->serloop_timing );
lbox_catptt->index( srig->serial_catptt );
lbox_rtsptt->index( srig->serial_rtsptt );
lbox_dtrptt->index( srig->serial_dtrptt );
chkrtscts->value( srig->serial_rtscts );
btnrtsplus1->value( srig->serial_rtsplus );
btndtrplus1->value( srig->serial_dtrplus );
btnrtsplus2->value( srig->serial_rtsplus );
btndtrplus2->value( srig->serial_dtrplus );
if (srig->CIV) {
char hexstr[8];
snprintf(hexstr, sizeof(hexstr), "0x%02X", srig->CIV);
txtCIV->value(hexstr);
txtCIV->activate();
btnCIVdefault->activate();
if (xcvr_name == rig_IC7200.name_ ||
xcvr_name == rig_IC7300.name_ ||
xcvr_name == rig_IC7600.name_ ||
xcvr_name == rig_IC7800.name_) {
btnUSBaudio->value(progStatus.USBaudio = true);
btnUSBaudio->activate();
} else
btnUSBaudio->deactivate();
} else {
txtCIV->value("");
txtCIV->deactivate();
btnCIVdefault->deactivate();
btnUSBaudio->value(false);
btnUSBaudio->deactivate();
}
} else {
initStatusConfigDialog();
trace(1, progStatus.info().c_str());
}
}
void TRACED(initStatusConfigDialog)
if (progStatus.CIV) selrig->adjustCIV(progStatus.CIV);
selectRig->value(xcvr_name.c_str());
mnuBaudrate->index( progStatus.serial_baudrate );
selectCommPort->value( progStatus.xcvr_serial_port.c_str() );
selectAuxPort->value( progStatus.aux_serial_port.c_str() );
selectSepPTTPort->value( progStatus.sep_serial_port.c_str() );
btnOneStopBit->value( progStatus.stopbits == 1 );
btnTwoStopBit->value( progStatus.stopbits == 2 );
cntRigCatRetries->value( progStatus.serial_retries );
cntRigCatTimeout->value( progStatus.serial_timeout );
cntPostWriteDelay->value( progStatus.serial_post_write_delay );
query_interval->value( progStatus.serloop_timing );
cntWriteDelay->value( progStatus.serial_write_delay );
lbox_catptt->index( progStatus.serial_catptt );
lbox_rtsptt->index( progStatus.serial_rtsptt );
lbox_dtrptt->index( progStatus.serial_dtrptt );
chkrtscts->value( progStatus.serial_rtscts );
btnrtsplus1->value( progStatus.serial_rtsplus );
btndtrplus1->value( progStatus.serial_dtrplus );
btnrtsplus2->value( progStatus.serial_rtsplus );
btndtrplus2->value( progStatus.serial_dtrplus );
btnSepDTRplus->value(progStatus.sep_dtrplus);
lbox_sep_dtrptt->index(progStatus.sep_dtrptt);
btnSepRTSplus->value(progStatus.sep_rtsplus);
lbox_sep_rtsptt->index(progStatus.sep_rtsptt);
if (progStatus.use_tcpip) {
box_xcvr_connect->color(FL_BACKGROUND2_COLOR);
box_xcvr_connect->redraw();
} else if (progStatus.xcvr_serial_port == "xml_client") {
if (connect_to_client()) {
progStatus.xmlrpc_rig = true;
box_xcvr_connect->color(FL_GREEN);
box_xcvr_connect->redraw();
} else {
fl_alert2("Cannot connect to remote flrig");
LOG_WARN("Cannot connect to remote flrig");
progStatus.xmlrpc_rig = false;
exit(0);
}
} else {
if (startXcvrSerial()) {
selectCommPort->value(progStatus.xcvr_serial_port.c_str());
box_xcvr_connect->color(FL_GREEN);
box_xcvr_connect->redraw();
} else {
if (progStatus.xcvr_serial_port == "NONE") {
LOG_WARN("No comm port ... test mode");
} else if (!progStatus.xmlrpc_rig) {
fl_alert2("\
Cannot open %s!\n\n\
Check serial (COM) port connection\n\
Open menu Config/Setup/Transceiver\n\
Press 'Update' button, reselect port\n\n\
Press 'Init' button.", progStatus.xcvr_serial_port.c_str());
LOG_WARN("Cannot open %s", progStatus.xcvr_serial_port.c_str());
progStatus.xcvr_serial_port = "NONE";
selectCommPort->value(progStatus.xcvr_serial_port.c_str());
}
box_xcvr_connect->color(FL_BACKGROUND2_COLOR);
box_xcvr_connect->redraw();
}
if ( progStatus.aux_serial_port != "NONE") {
if (!startAuxSerial()) {
LOG_WARN("Cannot open %s", progStatus.aux_serial_port.c_str());
progStatus.aux_serial_port = "NONE";
selectAuxPort->value(progStatus.aux_serial_port.c_str());
}
}
if ( progStatus.sep_serial_port != "NONE") {
if (!startSepSerial()) {
LOG_WARN("Cannot open %s", progStatus.sep_serial_port.c_str());
progStatus.sep_serial_port = "NONE";
selectSepPTTPort->value(progStatus.sep_serial_port.c_str());
}
}
}
if (progStatus.cmedia_ptt)
open_cmedia(progStatus.cmedia_device);
init_title();
initRig();
if (progStatus.tmate2_connected)
tmate2_open();
}
void TRACED(initRigCombo)
selectRig->clear();
int i = 0;
while (rigs[i] != NULL) {
selectRig->add(rigs[i]->name_.c_str(), (void*)rigs[i]);
i++;
}
selectRig->sort();
selectRig->index(selectRig->find_index(szNORIG));
}
flrig-2.0.04/src/support/support.cxx 0000664 0001750 0001750 00000330767 14505111071 014401 0000000 0000000 // ----------------------------------------------------------------------------
// Copyright (C) 2014-2011
// David Freese, W1HKJ
//
// This file is part of flrig.
//
// flrig is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation; either version 3 of the License, or
// (at your option) any later version.
//
// flrig is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program. If not, see .
// ----------------------------------------------------------------------------
#include "config.h"
#include "compat.h" // Must precede all FL includes
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include "icons.h"
#include "support.h"
#include "debug.h"
#include "gettext.h"
#include "rig_io.h"
#include "dialogs.h"
#include "rigbase.h"
#include "ptt.h"
#include "socket_io.h"
#include "ui.h"
#include "tod_clock.h"
#include "rig.h"
#include "rigs.h"
#include "K3_ui.h"
#include "KX3_ui.h"
#include "K4_ui.h"
#include "rigpanel.h"
#include "tod_clock.h"
#include "trace.h"
#include "cwio.h"
#include "cwioUI.h"
#include "fsk.h"
#include "fskioUI.h"
#include "xml_server.h"
#include "gpio_ptt.h"
#include "cmedia.h"
#include "tmate2.h"
//void initTabs();
rigbase *selrig = rigs[0];
extern bool test;
void init_notch_control();
int freqval = 0;
XCVR_STATE vfoA = XCVR_STATE(14070000, 0, 0, UI);
XCVR_STATE vfoB = XCVR_STATE(7070000, 0, 0, UI);
XCVR_STATE *vfo = &vfoA;
//XCVR_STATE xmlvfo = XCVR_STATE(14070000, 0, 0, UI);
XCVR_STATE xcvr_vfoA, xcvr_vfoB;
enum {VOL, MIC, PWR, SQL, IFSH, NOTCH, RFGAIN, NR, NB };
std::queue srvc_reqs;
// Add alpha-tag to XCVR_STATE;
struct ATAG_XCVR_STATE {
unsigned long long freq;
int imode;
int iBW;
int src;
char alpha_tag[ATAGSIZE];
};
ATAG_XCVR_STATE oplist[LISTSIZE];
int numinlist = 0;
std::vector rigmodes_;
Cserial *RigSerial;
Cserial *AuxSerial;
Cserial *SepSerial;
bool using_buttons = false;
int meter_image = SWR_IMAGE;
bool xcvr_online = false;
// meter values passed to display functions
double smtrval = 0;
double pwrval = 0;
double swrval = 0;
double alcval = 0;
double iddval = 0;
double vmtrval = 0;
//======================================================================
// slider change processing
//======================================================================
int inhibit_nb_level = 0;
int inhibit_volume = 0;
int inhibit_pbt = 0;
int inhibit_shift = 0;
int inhibit_nr = 0;
int inhibit_notch = 0;
int inhibit_power = 0;
int inhibit_mic = 0;
int inhibit_rfgain = 0;
int inhibit_squelch = 0;
struct SLIDER {
enum {NOTCH, SHIFT, INNER, OUTER, LOCK, VOLUME, MIC, POWER, SQUELCH, RFGAIN, NB_LEVEL, NR, NR_VAL};
int fnc;
int val;
};
//======================================================================
// loop for serial i/o thread
// runs continuously until program is closed
// only accesses the serial port if it has been successfully opened
//======================================================================
bool bypass_serial_thread_loop = true;
bool run_serial_thread = true;
bool PTT = false;
int powerlevel = 0;
std::string printXCVR_STATE(XCVR_STATE data)
{
try {
std::stringstream str;
str << data.freq;
str << ", " << selrig->modes_.at(data.imode);
if (selrig->has_dsp_controls) {
std::vector& dsplo = selrig->lotable(data.imode);
std::vector& dsphi = selrig->hitable(data.imode);
if (data.iBW > 256) {
str << ", " << dsplo.at(data.iBW & 0x7F);
str << ", " << dsphi.at((data.iBW >> 8) & 0x7F);
}
} else {
std::vector& bwt = selrig->bwtable(data.imode);
str << ", " << bwt.at(data.iBW);
}
str << std::endl;
return str.str();
} catch (const std::exception& e) {
LOG_ERROR("%s", e.what());
}
return "";
}
std::string print_ab()
{
std::string s;
s.assign("VFO-A: ");
s.append(printXCVR_STATE(vfoA));
s.append("VFO-B: ");
s.append(printXCVR_STATE(vfoB));
return s;
}
const char *print(XCVR_STATE data)
{
static std::string prstr;
static char str[1024];
try {
std::vector& bwt = selrig->bwtable(data.imode);
std::vector& dsplo = selrig->lotable(data.imode);
std::vector& dsphi = selrig->hitable(data.imode);
str[0] = 0;
prstr.clear();
snprintf(
str, sizeof(str), "\
Data Source: %s\n\
freq ........... %llu\n\
mode ........... %d [%s]\n",
data.src == XML ? "XML" : data.src == UI ? "UI" :
data.src == SRVR ? "SRVR" : "RIG",
data.freq,
data.imode,
selrig->modes_.at(data.imode).c_str());
prstr.assign(str);
str[0] = 0;
if (selrig->has_FILTER) {
snprintf(str, sizeof(str), "\
filter ......... %s\n\
bwt index ...... %2d, [%s] [%s]\n",
selrig->FILT(selrig->get_FILT(data.imode)),
data.iBW,
(data.iBW > 256 && selrig->has_dsp_controls) ?
dsplo.at(data.iBW & 0x7F).c_str() : bwt.at(data.iBW).c_str(),
(data.iBW > 256 && selrig->has_dsp_controls) ?
dsphi.at((data.iBW >> 8) & 0x7F).c_str() : ""
);
} else {
snprintf(str, sizeof(str), "\
filter ......... %s\n\
bwt index ...... %2d, [%s]\n",
selrig->FILT(selrig->get_FILT(data.imode)),
data.iBW,
bwt.at(data.iBW).c_str() );
}
prstr.append(str);
str[0] = 0;
snprintf( str, sizeof(str), "\
split .......... %4d, power_control . %4.1f, volume_control %4d\n\
attenuator ..... %4d, preamp ........ %4d, rf gain ....... %4d\n\
if_shift ....... %4d, shift val ..... %4d\n\
auto notch ..... %4d, notch ......... %4d, notch value ... %4d\n\
noise .......... %4d, nr ............ %4d, nr val ........ %4d\n\
mic gain ....... %4d, agc level ..... %4d, squelch ....... %4d\n\
compression .... %4d, compON ........ %4d",
data.split,
data.power_control,
data.volume_control,
data.attenuator,
data.preamp,
data.rf_gain,
data.if_shift,
data.shift_val,
data.auto_notch,
data.notch,
data.notch_val,
data.noise,
data.nr,
data.nr_val,
data.mic_gain,
data.agc_level,
data.squelch,
data.compression,
data.compON
);
prstr.append(str);
return prstr.c_str();
} catch (const std::exception& e) {
LOG_ERROR("%s", e.what());
}
return "";
}
std::string print_all()
{
std::string s;
s.assign("\
=======================================================================\n");
s.append(print(vfoA)).append("\n");
s.append("\
-----------------------------------------------------------------------\n");
s.append(print(vfoB)).append("\n");
return s;
}
void read_info()
{
trace(1,"read_info()");
selrig->get_info();
}
void TRACED(update_vfoAorB, void *d)
trace(1,"update_vfoAorB()");
if (selrig->inuse == onB) {
vfoB.src = RIG;
vfoB.freq = selrig->get_vfoB();
vfoB.imode = selrig->get_modeB();
vfoB.iBW = selrig->get_bwB();
} else {
vfoA.src = RIG;
vfoA.freq = selrig->get_vfoA();
vfoA.imode = selrig->get_modeA();
vfoA.iBW = selrig->get_bwA();
}
updateUI((void*)0);
}
void read_vfo()
{
if (xcvr_name == rig_K3.name_) {
read_K3_vfo();
return;
}
// transceiver changed ?
trace(1,"read_vfo()");
unsigned long long freq;
static int current_vfo = onNIL;
int chkvfo = selrig->get_vfoAorB();
if (current_vfo != chkvfo) {
current_vfo = chkvfo;
Fl::awake(updateUI);
}
if (current_vfo == onNIL)
return;
if (selrig->has_get_info)
selrig->get_info();
if (selrig->inuse == onA) { // vfo-A
trace(2, "vfoA active", "get vfo A");
freq = selrig->get_vfoA();
if (freq != vfoA.freq) {
vfoA.freq = freq;
Fl::awake(setFreqDispA);
vfo = &vfoA;
}
if ( selrig->twovfos() ) {
trace(2, "vfoA active", "get vfo B");
freq = selrig->get_vfoB();
if (freq != vfoB.freq) {
vfoB.freq = freq;
Fl::awake(setFreqDispB);
}
}
} else { // vfo-B
trace(2, "vfoB active", "get vfo B");
freq = selrig->get_vfoB();
if (freq != vfoB.freq) {
vfoB.freq = freq;
Fl::awake(setFreqDispB);
vfo = &vfoB;
}
if ( selrig->twovfos() ) {
trace(2, "vfoB active", "get vfo A");
freq = selrig->get_vfoA();
if (freq != vfoA.freq) {
vfoA.freq = freq;
Fl::awake(setFreqDispA);
}
}
}
Fl::awake(updateTCI);
Fl::awake(updateFLEX1500);
}
void update_ifshift(void *d);
void TRACED(updateUI, void *)
setModeControl(NULL);
updateBandwidthControl(NULL);
highlight_vfo(NULL);
int min, max, step;
selrig->get_if_min_max_step(min, max, step);
if (sldrIFSHIFT) sldrIFSHIFT->minimum(min);
if (sldrIFSHIFT) sldrIFSHIFT->maximum(max);
if (sldrIFSHIFT) sldrIFSHIFT->step(step);
if (sldrIFSHIFT) sldrIFSHIFT->redraw();
if (spnrIFSHIFT) spnrIFSHIFT->minimum(min);
if (spnrIFSHIFT) spnrIFSHIFT->maximum(max);
if (spnrIFSHIFT) spnrIFSHIFT->step(step);
if (spnrIFSHIFT) spnrIFSHIFT->redraw();
update_ifshift((void *)0);
}
void TRACED(setModeControl, void *)
opMODE->index(vfo->imode);
opMODE->redraw();
selrig->bandwidths_ = selrig->bwtable(vfo->imode);
opBW->clear();
for (size_t i = 0; i < selrig->bandwidths_.size(); i++)
opBW->add(selrig->bandwidths_.at(i).c_str());
if (vfo->iBW != opBW->index())
opBW->index(vfo->iBW);
opBW->redraw();
opBW->show();
// enables/disables the IF shift control, depending on the mode.
// the IF Shift function, is ONLY valid in CW modes, with the 870S.
if (xcvr_name == rig_TS870S.name_) {
if (vfo->imode == RIG_TS870S::tsCW || vfo->imode == RIG_TS870S::tsCWR) {
btnIFsh->activate();
if (sldrIFSHIFT) sldrIFSHIFT->activate();
if (spnrIFSHIFT) spnrIFSHIFT->activate();
} else {
btnIFsh->deactivate();
if (sldrIFSHIFT) sldrIFSHIFT->deactivate();
if (spnrIFSHIFT) spnrIFSHIFT->deactivate();
}
}
}
void setFILTER(void *)
{
if (selrig->has_FILTER) {
if (selrig->inuse == onB)
btnFILT->label(selrig->FILT(vfoB.filter));
else
btnFILT->label(selrig->FILT(vfoA.filter));
btnFILT->redraw_label();
trace(3, "Filter", (selrig->inuse == onB ? "B" : "A"), btnFILT->label());
}
}
// mode and bandwidth
void read_mode()
{
if (xcvr_name == rig_K3.name_) {
read_K3_mode();
return;
}
int nu_mode;
if (selrig->inuse == onA) {
rig_trace(2, "read_mode", "vfoA active");
nu_mode = selrig->get_modeA();
char resp[50];
snprintf(resp, sizeof(resp), "read: %d", nu_mode);
rig_trace(1, resp);
if (nu_mode != opMODE->index()) {
vfoA.imode = vfo->imode = nu_mode;
selrig->adjust_bandwidth(vfo->imode);
Fl::awake(setModeControl);
vfoA.iBW = vfo->iBW = selrig->get_bwA();
Fl::awake(updateBandwidthControl);
}
Fl::awake(updateTCI);
Fl::awake(updateFLEX1500);
if (selrig->twovfos()) {
vfoB.imode = selrig->get_modeB();
vfoB.filter = selrig->get_FILT(vfoB.imode);
}
vfoA.filter = selrig->get_FILT(vfoA.imode);
Fl::awake(setFILTER);
} else {
rig_trace(2, "read_mode", "vfoB active");
nu_mode = selrig->get_modeB();
if (nu_mode != opMODE->index()) {
vfoB.imode = vfo->imode = nu_mode;
selrig->adjust_bandwidth(vfo->imode);
Fl::awake(setModeControl);
vfoB.iBW = vfo->iBW = selrig->get_bwB();
Fl::awake(updateBandwidthControl);
}
Fl::awake(updateTCI);
Fl::awake(updateFLEX1500);
if (selrig->twovfos()) {
vfoA.imode = selrig->get_modeA();
vfoA.filter = selrig->get_FILT(vfoA.imode);
}
vfoB.filter = selrig->get_FILT(vfoA.imode);
Fl::awake(setFILTER);
}
}
void TRACED(setBWControl, void *)
if (selrig->has_dsp_controls) {
if (vfo->iBW > 256) {
opBW->hide();
opDSP_hi->index((vfo->iBW >> 8) & 0x7F);
opDSP_lo->index(vfo->iBW & 0xFF);
if (opDSP_lo->visible()) {
opDSP_lo->redraw();
btnDSP->label(selrig->SL_label);
} else {
opDSP_hi->redraw();
btnDSP->label(selrig->SH_label);
}
btnDSP->redraw_label();
btnDSP->redraw();
btnDSP->show();
} else {
opDSP_lo->index(0);
opDSP_hi->index(0);
opDSP_lo->hide();
opDSP_hi->hide();
btnDSP->hide();
if (vfo->iBW != opBW->index())
opBW->index(vfo->iBW);
opBW->show();
opBW->redraw();
}
}
else {
opDSP_lo->hide();
opDSP_hi->hide();
btnDSP->hide();
opBW_A->hide();
opBW_B->hide();
if (vfo->iBW != opBW->index())
opBW->index(vfo->iBW);
opBW->show();
opBW->redraw();
}
}
void set_Kx_bandwidths(void *)
{
// std::cout << printXCVR_STATE(*vfo);
opBW_A->index(vfoA.iBW);
opBW_B->index(vfoB.iBW);
opBW_A->redraw();
opBW_B->redraw();
}
void TRACED(read_bandwidth)
if (xcvr_name == rig_K2.name_ || xcvr_name == rig_K3.name_ ) {
vfoA.iBW = vfo->iBW = selrig->get_bwA();//nu_BW;
Fl::awake(setBWControl);
vfoB.iBW = selrig->get_bwB();//nu_BW;
return;
}
if (xcvr_name == rig_KX3.name_ || xcvr_name == rig_K4.name_) {
vfoA.iBW = selrig->get_bwA();
vfoB.iBW = selrig->get_bwB();
Fl::awake(set_Kx_bandwidths);
return;
}
trace(1,"read_bandwidth()");
std::stringstream s;
if (selrig->inuse == onA) {
s << "get_bwA(): ";
vfoA.iBW = vfo->iBW = selrig->get_bwA();
} else {
s << "get_bwB(): ";
vfoB.iBW = vfo->iBW = selrig->get_bwB();
}
s << vfo->iBW;
trace(1, s.str().c_str());
Fl::awake(setBWControl);
Fl::awake(updateTCI);
Fl::awake(updateFLEX1500);
}
// read current signal level
void read_smeter()
{
if (!selrig->has_smeter) return;
int sig;
{
trace(1,"read_smeter()");
sig = selrig->get_smeter();
}
if (sig == -1) return;
smtrval = sig;
Fl::awake(updateSmeter);
}
void read_voltmeter()
{
if (!selrig->has_voltmeter) return;
double sig;
{
trace(1, "read voltage");
sig = selrig->get_voltmeter();
}
vmtrval = sig;
Fl::awake(updateVmeter);
}
int tunerval = 0;
void update_UI_TUNER(void *)
{
btn_tune_on_off->value(tunerval);
btn_tune_on_off->redraw();
}
void read_tuner()
{
if (!selrig->has_tune_control) return;
tunerval = selrig->get_tune();
if (tunerval != btn_tune_on_off->value()) {
std::stringstream s;
s << "tuner state: " << tunerval;
trace(1, s.str().c_str());
Fl::awake(update_UI_TUNER);
}
}
// read power out
void read_power_out()
{
if (!selrig->has_power_out) return;
int sig;
{
trace(1,"read_power_out()");
sig = selrig->get_power_out();
}
if (sig < 0) sig = 0;
pwrval = sig;
Fl::awake(updateFwdPwr);
}
// read swr
void read_swr()
{
if (!selrig->has_swr_control) return;
int sig;
{
trace(1,"read_swr()");
sig = selrig->get_swr();
}
if (sig < 0) sig = 0;
swrval = sig;
Fl::awake(updateSWR);
}
// alc
void read_alc()
{
if (!selrig->has_alc_control) {
return;
}
int sig;
{
trace(1,"read_alc()");
sig = selrig->get_alc();
}
if (sig < 0) sig = 0;
alcval = sig;
Fl::awake(updateALC);
}
// IDD
void read_idd()
{
if (!selrig->has_idd_control) {
return;
}
double sig;
{
trace(1,"read_idd()");
sig = selrig->get_idd();
}
if (sig < 0) sig = 0;
iddval = sig;
Fl::awake(updateIDD);
}
// notch
void update_auto_notch(void *d)
{
btnAutoNotch->value(progStatus.auto_notch);
}
void read_auto_notch()
{
int val;
if (!selrig->has_auto_notch) return;
{
trace(1,"read_auto_notch()");
val = selrig->get_auto_notch();
}
if (val != progStatus.auto_notch) {
progStatus.auto_notch = vfo->auto_notch = val;
Fl::awake(update_auto_notch, (void*)0);
}
}
// NOISE blanker
void update_noise(void *d)
{
btnNOISE->value(progStatus.noise);
btnNOISE->redraw();
sldr_nb_level->value(progStatus.nb_level);
sldr_nb_level->redraw();
}
void read_noise()
{
int on = 0, val = 0;
if (inhibit_nb_level > 0) {
inhibit_nb_level--;
return;
}
{
trace(1,"read_noise()");
on = selrig->get_noise();
val = selrig->get_nb_level();
}
if ((on != progStatus.noise) || (val != progStatus.nb_level)) {
vfo->noise = progStatus.noise = on;
vfo->nb_level = progStatus.nb_level = val;
Fl::awake(update_noise, (void*)0);
}
}
// compression
void update_compression(void *d)
{
if (btnCompON) btnCompON->value(progStatus.compON);
if (spnr_compression) spnr_compression->value(progStatus.compression);
}
void read_compression()
{
int on = progStatus.compON;
int val = progStatus.compression;
if (selrig->has_compression || selrig->has_compON) {
{
trace(1,"read_compression()");
selrig->get_compression( on, val );
}
if (on != progStatus.compON || val != progStatus.compression) {
vfo->compression = progStatus.compression = val;
vfo->compON = progStatus.compON = on;
Fl::awake(update_compression, (void*)0);
}
}
}
// preamp - attenuator
void update_preamp(void *d)
{
if (selrig->name_ == rig_FLEX1500.name_ ) {
cbo_preamp->index(progStatus.preamp);
cbo_preamp->redraw();
return;
}
btnPreamp->value(progStatus.preamp > 0 ? 1 : 0);
btnPreamp->label(selrig->PRE_label());
btnPreamp->redraw_label();
btnPreamp->redraw();
}
void update_attenuator(void *d)
{
if (selrig->name_ == rig_IC7610.name_) {
ic7610att->index(progStatus.index_ic7610att);
return;
}
btnAttenuator->value(progStatus.attenuator > 0 ? 1 : 0);
btnAttenuator->label(selrig->ATT_label());
btnAttenuator->redraw_label();
btnAttenuator->redraw();
}
void read_preamp()
{
int val;
if (selrig->has_preamp_control) {
trace(1,"read_preamp_att() 1");
val = selrig->get_preamp();
vfo->preamp = progStatus.preamp = val;
Fl::awake(update_preamp, (void*)0);
}
}
void read_att()
{
int val;
if (selrig->has_attenuator_control) {
trace(1,"read_preamp_att() 2");
val = selrig->get_attenuator();
vfo->attenuator = progStatus.attenuator = val;
Fl::awake(update_attenuator, (void*)0);
}
}
// split
void update_split(void *d)
{
if (xcvr_name == rig_FTdx1200.name_ ||
xcvr_name == rig_TS480SAT.name_ || xcvr_name == rig_TS480HX.name_ ||
xcvr_name == rig_TS590S.name_ || xcvr_name == rig_TS590SG.name_ ||
xcvr_name == rig_TS890S.name_ ||
xcvr_name == rig_TS2000.name_ || xcvr_name == rig_TS990.name_) {
switch (progStatus.split) {
case 0: btnSplit->value(0);
highlight_vfo(NULL);
break;
case 1: btnSplit->value(1);
highlight_vfo(NULL);
break;
case 2: btnSplit->value(1);
highlight_vfo(NULL);
break;
case 3: btnSplit->value(0);
highlight_vfo(NULL);
break;
}
} else
btnSplit->value(progStatus.split);
btnSplit->redraw();
}
void read_split()
{
int val = progStatus.split;
if (selrig->has_split) {
val = selrig->get_split();
vfo->split = progStatus.split = val;
Fl::awake(update_split, (void*)0);
std::ostringstream s;
s << "read_split() " << (val ? "ON" : "OFF");
trace(1, s.str().c_str());
} else {
vfo->split = progStatus.split;
}
}
// volume
void update_volume(void *d)
{
long *nr = (long *)d;
if (spnrVOLUME) {
spnrVOLUME->value(progStatus.volume);
spnrVOLUME->activate();
spnrVOLUME->redraw();
}
if (sldrVOLUME) {
sldrVOLUME->value(progStatus.volume); // Set slider to last known value
sldrVOLUME->activate(); // activate it
sldrVOLUME->redraw();
}
if (*nr) btnVol->value(1); // Button Lit
else btnVol->value(0); // Button Dark.
btnVol->redraw();
}
long nlzero = 0L;
long nlone = 1L;
void read_volume()
{
if (inhibit_volume > 0) {
inhibit_volume--;
return;
}
if (!selrig->has_volume_control) return;
int vol;
{
trace(1,"read_volume()");
vol = selrig->get_volume_control();
}
if (vol != progStatus.volume) {
if (vol <= 1 && !btnVol->value()) return;
progStatus.volume = vol;
if (vol <= 1 && btnVol->value())
Fl::awake(update_volume, (void*)&nlzero);
else
Fl::awake(update_volume, (void*)&nlone);
}
}
// ifshift
void update_ifshift(void *d)
{
btnIFsh->value(progStatus.shift);
btnIFsh->redraw();
if (sldrIFSHIFT) {
sldrIFSHIFT->value(progStatus.shift_val);
sldrIFSHIFT->redraw();
}
if (spnrIFSHIFT) {
spnrIFSHIFT->value(progStatus.shift_val);
spnrIFSHIFT->redraw();
}
}
void update_pbt(void *)
{
if (sldrINNER) {
sldrINNER->value(progStatus.pbt_inner);
sldrINNER->redraw();
}
if (sldrOUTER) {
sldrOUTER->value(progStatus.pbt_outer);
sldrOUTER->redraw();
}
}
void read_pbt()
{
progStatus.pbt_inner = selrig->get_pbt_inner();
progStatus.pbt_outer = selrig->get_pbt_outer();
Fl::awake(update_pbt, (void*)0);
}
void read_ifshift()
{
int on = 0;
int val = 0;
if (inhibit_shift > 0) {
inhibit_shift--;
return;
}
if (!selrig->has_ifshift_control) return;
trace(1,"read_if_shift()");
on = selrig->get_if_shift(val);
if (xcvr_name == rig_K3.name_ ||
xcvr_name == rig_KX3.name_ ||
xcvr_name == rig_K4.name_) {
vfo->shift_val = progStatus.shift_val = val;
Fl::awake(update_ifshift, (void*)0);
} else if ((on != progStatus.shift) || (val != progStatus.shift_val)) {
vfo->if_shift = progStatus.shift = on;
vfo->shift_val = progStatus.shift_val = val;
Fl::awake(update_ifshift, (void*)0);
}
}
// noise reduction
void update_nr(void *d)
{
btnNR->value(progStatus.noise_reduction);
btnNR->redraw();
if (sldrNR) {
sldrNR->value(progStatus.noise_reduction_val);
sldrNR->redraw();
}
if (spnrNR) {
spnrNR->value(progStatus.noise_reduction_val);
spnrNR->redraw();
}
}
void read_nr()
{
int on = 0;
int val = 0;
if (inhibit_nr > 0) {
inhibit_nr--;
return;
}
if (!selrig->has_noise_reduction) return;
{
trace(1,"read_nr()");
on = selrig->get_noise_reduction();
val = selrig->get_noise_reduction_val();
}
if ((on != progStatus.noise_reduction) || (val != progStatus.noise_reduction_val)) {
vfo->nr = progStatus.noise_reduction = on;
vfo->nr_val = progStatus.noise_reduction_val = val;
Fl::awake(update_nr, (void*)0);
}
}
// manual notch
void update_notch(void *d)
{
btnNotch->value(progStatus.notch);
btnNotch->redraw();
if (sldrNOTCH) {
sldrNOTCH->value(progStatus.notch_val);
sldrNOTCH->redraw();
}
if (spnrNOTCH) {
spnrNOTCH->value(progStatus.notch_val);
spnrNOTCH->redraw();
}
}
void read_notch()
{
if (!selrig->has_notch_control) return;
int on = progStatus.notch;
int val = progStatus.notch_val;
{
trace(1,"read_notch()");
on = selrig->get_notch(val);
}
if (on != progStatus.notch)
vfo->notch = progStatus.notch = on;
if (val != progStatus.notch_val)
vfo->notch_val = progStatus.notch_val = val;
Fl::awake(update_notch, (void*)0);
}
// power_control
void update_power_control(void *d)
{
double min, max, step;
if (selrig->has_power_control) {
selrig->get_pc_min_max_step(min, max, step);
if (sldrPOWER) {
sldrPOWER->minimum(min);
sldrPOWER->maximum(max);
sldrPOWER->step(step);
}
if (spnrPOWER) {
spnrPOWER->minimum(min);
spnrPOWER->maximum(max);
spnrPOWER->step(step);
}
}
if (sldrPOWER) {
sldrPOWER->value(progStatus.power_level);
sldrPOWER->redraw();
}
if (spnrPOWER) {
spnrPOWER->value(progStatus.power_level);
spnrPOWER->redraw();
}
}
void read_power_control()
{
if (inhibit_power > 0) {
inhibit_power--;
return;
}
if (!selrig->has_power_control) return;
trace(1,"read_power_control()");
vfo->power_control = progStatus.power_level = selrig->get_power_control();
Fl::awake(update_power_control, (void*)0);
}
// mic gain
void update_mic_gain(void *d)
{
if (sldrMICGAIN) {
sldrMICGAIN->value(progStatus.mic_gain);
sldrMICGAIN->redraw();
}
if (spnrMICGAIN) {
spnrMICGAIN->value(progStatus.mic_gain);
spnrMICGAIN->redraw();
}
}
void read_mic_gain()
{
int val;
if (inhibit_mic > 0) {
inhibit_mic--;
return;
}
if (!selrig->has_micgain_control) return;
{
trace(1,"read_mic_gain()");
val = selrig->get_mic_gain();
}
if (val != progStatus.mic_gain || val != vfo->mic_gain || (sldrMICGAIN && val != sldrMICGAIN->value())) {
vfo->mic_gain = progStatus.mic_gain = val;
Fl::awake(update_mic_gain, (void*)0);
}
}
void read_agc()
{
int val;
if (!selrig->has_agc_control) return;
trace(1,"read_agc()");
val = selrig->get_agc();
if (val != progStatus.agc_level) {
vfo->agc_level = progStatus.agc_level = val;
Fl::awake(setAGC);
}
}
// rf gain
void update_rfgain(void *d)
{
if (sldrRFGAIN) {
sldrRFGAIN->value(progStatus.rfgain);
sldrRFGAIN->redraw();
}
if (spnrRFGAIN) {
spnrRFGAIN->value(progStatus.rfgain);
spnrRFGAIN->redraw();
}
}
void read_rfgain()
{
int val;
if (inhibit_rfgain > 0) {
inhibit_rfgain--;
return;
}
if (selrig->has_rf_control) {
trace(1,"read_rfgain");
val = selrig->get_rf_gain();
if (val != progStatus.rfgain) {
progStatus.rfgain = val;
Fl::awake(update_rfgain, (void*)0);
}
}
read_agc();
}
// squelch
void update_squelch(void *d)
{
if (sldrSQUELCH) {
sldrSQUELCH->value(progStatus.squelch);
sldrSQUELCH->redraw();
}
if (spnrSQUELCH) {
spnrSQUELCH->value(progStatus.squelch);
spnrSQUELCH->redraw();
}
}
void read_squelch()
{
int val;
if (inhibit_squelch > 0) {
inhibit_squelch--;
return;
}
if (!selrig->has_sql_control) return;
{
trace(1,"read_squelch()");
val = selrig->get_squelch();
}
if (val != progStatus.squelch || val != vfo->squelch || (sldrSQUELCH && val != sldrSQUELCH->value())) {
vfo->squelch = progStatus.squelch = val;
Fl::awake(update_squelch, (void*)0);
}
}
void set_ptt(void *d)
{
if (d == (void*)0) {
btnPTT->value(0);
sldrSWR->hide();
sldrSWR->redraw();
sldrRcvSignal->show();
sldrRcvSignal->redraw();
btnALC_IDD_SWR->hide();
scaleSmeter->show();
} else {
btnPTT->value(1);
sldrRcvSignal->hide();
sldrRcvSignal->redraw();
scaleSmeter->hide();
sldrSWR->show();
sldrSWR->redraw();
if (selrig->name_ == rig_PowerSDR.name_) {
btnALC_IDD_SWR->image(meter_image == SWR_IMAGE ? image_swr : image_alc40db);
}
else {
btnALC_IDD_SWR->image(meter_image == SWR_IMAGE ? image_swr : image_alc);
}
btnALC_IDD_SWR->redraw();
btnALC_IDD_SWR->show();
}
}
void check_ptt()
{
if (selrig->name_ == rig_FT817.name_ ||
selrig->name_ == rig_FT817BB.name_ ||
selrig->name_ == rig_FT818ND.name_ ) {
return;
}
int chk = ptt_state();
if (chk != PTT) {
PTT = chk;
Fl::awake(set_ptt, (void *)PTT);
}
}
void check_break_in()
{
if (selrig->has_cw_break_in)
selrig->get_break_in();
}
//static bool resetrcv = true;
//static bool resetxmt = true;
// On early model Yaesu transceivers, the mode must be set before VFO,
// since mode changes can shift frequency.
//
// For example, might set freq to 7123.000, but then change mode from USB
// to DATA-U. This mode shift would change the VFO to 7123.700, instead
// of the desired 7123.000.
//
// Setting VFO after the mode change will prevent this type of frequency
// shifting.
void yaesu891UpdateA(XCVR_STATE * newVfo)
{
selrig->set_modeA(newVfo->imode);
selrig->set_vfoA(newVfo->freq);
selrig->set_bwA(newVfo->iBW);
selrig->get_modeA();
selrig->get_vfoA();
selrig->get_bwA();
}
void yaesu891UpdateB(XCVR_STATE * newVfo)
{
selrig->set_modeB(newVfo->imode);
selrig->set_vfoB(newVfo->freq);
selrig->set_bwB(newVfo->iBW);
selrig->get_modeB();
selrig->get_vfoB();
selrig->get_bwB();
}
void FTdx10_UpdateA(XCVR_STATE * newVfo)
{
selrig->set_modeA(newVfo->imode);
selrig->set_vfoA(newVfo->freq);
selrig->set_bwA(newVfo->iBW);
selrig->get_modeA();
selrig->get_vfoA();
selrig->get_bwA();
}
void FTdx10_UpdateB(XCVR_STATE * newVfo)
{
selrig->set_modeB(newVfo->imode);
selrig->set_vfoB(newVfo->freq);
selrig->set_bwB(newVfo->iBW);
selrig->get_modeB();
selrig->get_vfoB();
selrig->get_bwB();
}
void serviceQUE()
{
guard_lock que_lock(&mutex_srvc_reqs, "serviceQUE");
guard_lock serial(&mutex_serial, "1");
std::queue pending; // creates an empty queue
VFOQUEUE nuvals;
while (!srvc_reqs.empty()) {
{
nuvals = srvc_reqs.front();
srvc_reqs.pop();
}
if (nuvals.change == ON || nuvals.change == OFF) { // PTT processing
if (selrig->ICOMmainsub && selrig->inuse == onB) { // disallowed operation
Fl::awake(update_UI_PTT);
return;
}
PTT = (nuvals.change == ON);
if (nuvals.change == ON) trace(1,"ptt ON");
else trace(1,"ptt OFF");
rigPTT(PTT);
{
bool get = ptt_state();
int cnt = 0;
while ((get != PTT) && (cnt++ < 100)) {
MilliSleep(10);
get = ptt_state();
}
std::stringstream s;
s << "ptt returned " << get << " in " << cnt * 10 << " msec";
trace(1, s.str().c_str());
Fl::awake(update_UI_PTT);
}
continue;
}
if (PTT) {
if ((nuvals.vfo.iBW != 255) ||
(nuvals.vfo.imode != -1)) {
pending.push(nuvals);
continue; // while (!srvc_reqs.empty())
}
}
switch (nuvals.change) {
case vX:
if (selrig->inuse == onB)
serviceB(nuvals.vfo);
else
serviceA(nuvals.vfo);
break;
case vA:
serviceA(nuvals.vfo);
break;
case vB:
serviceB(nuvals.vfo);
break;
case sA: // select A
{
selrig->selectA();
vfo = &vfoA;
if (selrig->name_ == rig_FT891.name_) {
// Restore mode, then freq and bandwidth after select
yaesu891UpdateA(&vfoA);
}
if (selrig->name_ == rig_FTdx10.name_) {
FTdx10_UpdateA(&vfoA);
}
rig_trace(2, "case sA ", printXCVR_STATE(vfoA).c_str());
Fl::awake(updateUI);
}
break;
case sB: // select B
{
selrig->selectB();
vfo = &vfoB;
if (selrig->name_ == rig_FT891.name_) {
// Restore mode, then freq and bandwidth after select
yaesu891UpdateB(&vfoB);
}
if (selrig->name_ == rig_FTdx10.name_) {
FTdx10_UpdateB(&vfoB);
}
rig_trace(2, "case sB ", printXCVR_STATE(vfoB).c_str());
Fl::awake(updateUI);
}
break;
case sON: case sOFF:
{
int on = 0;
if (nuvals.change == sON) on = 1;
trace(1, (on ? "split ON" : "split OFF"));
rig_trace(2, "case sB ", printXCVR_STATE(vfoB).c_str());
if (selrig->can_split() || selrig->has_split_AB) {
selrig->set_split(on);
selrig->get_split();
progStatus.split = on;
Fl::awake(update_split, (void *)0);
if (selrig->ICOMmainsub) {
selrig->selectA();
vfo = &vfoA;
}
}
}
break;
case SWAP:
trace(1, "execute swapab()");
rig_trace(1, "execute swapab()");
execute_swapAB();
break;
case A2B:
trace(1, "execute A2B()");
rig_trace(1, "execute A2B()");
execute_A2B();
break;
case FA2FB:
trace(1, "execute FA2FB");
rig_trace(1, "execute FA2FB");
execute_FA2FB();
break;
case FB2FA:
trace(1, "execute FB2FA");
rig_trace(1, "execute FB2FA");
execute_FB2FA();
break;
default:
trace(2, "default ", printXCVR_STATE(nuvals.vfo).c_str());
if (selrig->inuse == onB) serviceB(nuvals.vfo);
else serviceA(nuvals.vfo);
break;
}
}
{
while (!srvc_reqs.empty()) {
pending.push(srvc_reqs.front());
srvc_reqs.pop();
}
while (!pending.empty()) {
srvc_reqs.push(pending.front());
pending.pop();
}
}
Fl::awake(updateUI);
}
void find_bandwidth(XCVR_STATE &nuvals)
{
if (nuvals.iBW == 255) return;
if (!selrig->has_bandwidth_control) {
nuvals.iBW = 255;
return;
}
if (nuvals.iBW > 65536) {
nuvals.iBW /= 256;
nuvals.iBW /= 256;
size_t i = 0;
int bwval = 0;
for (i = 0; i < selrig->bandwidths_.size(); i++) {
if ((bwval = atol(selrig->bandwidths_[i].c_str())) == nuvals.iBW)
break;
if (bwval > nuvals.iBW) {
i--;
break;
}
}
if (i < 0) i = 0;
if (i >= selrig->bandwidths_.size()) i = selrig->bandwidths_.size() - 1;
nuvals.iBW = i;
}
}
void serviceA(XCVR_STATE nuvals)
{
bool A_changed;
if (nuvals.freq == 0) nuvals.freq = vfoA.freq;
if (nuvals.imode == -1) nuvals.imode = vfoA.imode;
if (nuvals.iBW == 255) nuvals.iBW = vfoA.iBW;
if (selrig->inuse == onB) {
if (selrig->can_change_alt_vfo) {
trace(2, "B active, set alt vfo A", printXCVR_STATE(nuvals).c_str());
rig_trace(2, "B active, set alt vfo A", printXCVR_STATE(nuvals).c_str());
if (vfoA.imode != nuvals.imode) {
if (selrig->name_ == rig_FT891.name_) {
// Mode change on ft891 requires mode first, so set all values
yaesu891UpdateA(&nuvals);
vfoA = nuvals;
} else {
selrig->set_modeA(nuvals.imode);
selrig->get_modeA();
}
A_changed = true;
}
if (vfoA.iBW != nuvals.iBW) {
selrig->set_bwA(nuvals.iBW);
selrig->get_bwA();
A_changed = true;
}
if (vfoA.freq != nuvals.freq) {
selrig->set_vfoA(nuvals.freq);
selrig->get_vfoA();
A_changed = true;
}
vfoA = nuvals;
} else if (xcvr_name != rig_TT550.name_) {
trace(2, "B active, set vfo A", printXCVR_STATE(nuvals).c_str());
rig_trace(2, "B active, set vfo A", printXCVR_STATE(nuvals).c_str());
selrig->selectA();
if (vfoA.imode != nuvals.imode) {
selrig->set_modeA(nuvals.imode);
selrig->get_modeA();
A_changed = true;
Fl::awake(updateUI);
}
if (vfoA.iBW != nuvals.iBW) {
selrig->set_bwA(nuvals.iBW);
selrig->get_bwA();
A_changed = true;
}
if (vfoA.freq != nuvals.freq) {
selrig->set_vfoA(nuvals.freq);
selrig->get_vfoA();
A_changed = true;
}
selrig->selectB();
vfoA = nuvals;
}
if (A_changed) {
Fl::awake(setFreqDispA);
}
return;
}
trace(2, "service VFO A", printXCVR_STATE(nuvals).c_str());
if ((nuvals.imode != -1) ) {//&& (vfoA.imode != nuvals.imode)) {
if (selrig->name_ == rig_FT891.name_) {
// Mode change on ft891 can change frequency, so set all values
yaesu891UpdateA(&nuvals);
vfoA = nuvals;
set_bandwidth_control();
} else {
selrig->set_modeA(vfoA.imode = nuvals.imode);
selrig->get_modeA();
set_bandwidth_control();
}
}
if (vfoA.iBW != nuvals.iBW) {
selrig->set_bwA(vfoA.iBW = nuvals.iBW);
selrig->get_bwA();
A_changed = true;
}
if (vfoA.freq != nuvals.freq) {
trace(1, "change vfoA frequency");
selrig->set_vfoA(vfoA.freq = nuvals.freq);
selrig->get_vfoA();
A_changed = true;
}
vfo = &vfoA;
if (A_changed)
Fl::awake(setFreqDispA);
}
void serviceB(XCVR_STATE nuvals)
{
bool B_changed;
if (nuvals.freq == 0) nuvals.freq = vfoB.freq;
if (nuvals.imode == -1) nuvals.imode = vfoB.imode;
if (nuvals.iBW == 255) nuvals.iBW = vfoB.iBW;
if (selrig->inuse == onA) {
if (selrig->can_change_alt_vfo) {
trace(2, "A active, set alt vfo B", printXCVR_STATE(nuvals).c_str());
if (vfoB.imode != nuvals.imode) {
if (selrig->name_ == rig_FT891.name_) {
// Mode change on ft891 requires mode first, so set all values
yaesu891UpdateB(&nuvals);
vfoB = nuvals;
} else {
selrig->set_modeB(nuvals.imode);
selrig->get_modeB();
}
B_changed = true;
}
if (vfoB.iBW != nuvals.iBW) {
selrig->set_bwB(nuvals.iBW);
selrig->get_bwB();
B_changed = true;
}
if (vfoB.freq != nuvals.freq) {
selrig->set_vfoB(nuvals.freq);
selrig->get_vfoB();
B_changed = true;
}
vfoB = nuvals;
} else if (xcvr_name != rig_TT550.name_) {
trace(2, "A active, set vfo B", printXCVR_STATE(nuvals).c_str());
selrig->selectB();
if (vfoB.imode != nuvals.imode) {
selrig->set_modeB(nuvals.imode);
selrig->get_modeB();
B_changed = true;
}
if (vfoB.iBW != nuvals.iBW) {
selrig->set_bwB(nuvals.iBW);
selrig->get_bwB();
B_changed = true;
}
if (vfoB.freq != nuvals.freq) {
selrig->set_vfoB(nuvals.freq);
selrig->get_vfoB();
B_changed = true;
}
selrig->selectA();
vfoB = nuvals;
}
if (B_changed)
Fl::awake(setFreqDispB);
return;
}
trace(2, "service VFO B", printXCVR_STATE(nuvals).c_str());
if ((nuvals.imode != -1) && (vfoB.imode != nuvals.imode)) {
std::string m1, m2;
m1 = selrig->modes_[nuvals.imode];
m2 = selrig->modes_[vfoB.imode];
selrig->set_modeB(vfoB.imode = nuvals.imode);
selrig->get_modeB();
set_bandwidth_control();
vfoB.iBW = selrig->get_bwB();
}
if (vfoB.iBW != nuvals.iBW) {
selrig->set_bwB(vfoB.iBW = nuvals.iBW);
selrig->get_bwB();
B_changed = true;
}
if (vfoB.freq != nuvals.freq) {
selrig->set_vfoB(vfoB.freq = nuvals.freq);
selrig->get_vfoB();
B_changed = true;
}
vfo = &vfoB;
if (B_changed)
Fl::awake(setFreqDispB);
}
#define MAX_FAILURES 5
void serial_failed(void *)
{
bypass_serial_thread_loop = true;
RigSerial->ClosePort();
box_xcvr_connect->color(FL_BACKGROUND2_COLOR);
box_xcvr_connect->redraw();
fl_alert2(_("\
Transceiver not responding!\n\n\
Check serial (COM) port connection\n\
Open menu Config/Setup/Transceiver\n\
Press 'Update' button, reselect port\n\
Check that Baud matches transceiver baud\n\n\
Press 'Init' button."));
}
struct POLL_PAIR {
int *poll;
void (*pollfunc)();
std::string name;
};
POLL_PAIR RX_poll_group_1[] = {
{&progStatus.poll_smeter, read_smeter, "SMETER"},
{&progStatus.poll_frequency, read_vfo, "FREQ"},
{NULL, NULL, ""}
};
POLL_PAIR RX_poll_group_2[] = {
{&progStatus.poll_mode, read_mode, "MODE"},
{&progStatus.poll_bandwidth, read_bandwidth, "BW"},
// {&progStatus.poll_vfoAorB, read_vfoAorB, "A/B"},
{NULL, NULL, ""}
};
POLL_PAIR RX_poll_group_3[] = {
{&progStatus.poll_mode, read_voltmeter, "voltage"},
{&progStatus.poll_tuner, read_tuner, "tuner"},
{&progStatus.poll_volume, read_volume, "volume"},
{&progStatus.poll_auto_notch, read_auto_notch, "auto notch"},
{&progStatus.poll_notch, read_notch, "notch"},
{&progStatus.poll_ifshift, read_ifshift, "if shift"},
{&progStatus.poll_pbt, read_pbt, "pass band tunning"},
{&progStatus.poll_power_control, read_power_control, "power"},
{&progStatus.poll_pre_att, read_preamp, "preamp"},
{&progStatus.poll_pre_att, read_att, "atten"},
{&progStatus.poll_micgain, read_mic_gain, "mic gain"},
{&progStatus.poll_squelch, read_squelch, "squelch"},
{&progStatus.poll_rfgain, read_rfgain, "rfgain"},
{&progStatus.poll_split, read_split, "split"},
{&progStatus.poll_nr, read_nr, "noise reduction"},
{&progStatus.poll_noise, read_noise, "noise"},
{&progStatus.poll_compression, read_compression, "compression"},
{&progStatus.poll_break_in, check_break_in, "break-in"},
{NULL, NULL}
};
POLL_PAIR TX_poll_pairs[] = {
{&progStatus.poll_power_control, read_power_control, "power"},
{&progStatus.poll_pout, read_power_out, "pout"},
{&progStatus.poll_swr, read_swr, "swr"},
{&progStatus.poll_alc, read_alc, "alc"},
{&progStatus.poll_alc, read_idd, "idd"},
{&progStatus.poll_mode, read_voltmeter, "voltage"},
{&progStatus.poll_split, read_split, "split"},
{NULL, NULL, ""}
};
static int menu1 = 0, menu2 = 1;
static FILE *qcx_menus = (FILE *)0;
void read_menu()
{
if (menu1 == 0) return;
std::string menu_item;
if (menu1 < 8) {
menu_item = selrig->read_menu(menu1, menu2);
if (!menu_item.empty()) {
if (qcx_menus)
fprintf(qcx_menus, "%s\n", menu_item.c_str());
++menu2;
} else {
menu2 = 1;
++menu1;
}
return;
}
if (qcx_menus)
fclose(qcx_menus);
qcx_menus = 0;
}
void read_menus()
{
std::string qcx_menu_file;
qcx_menu_file.assign(RigHomeDir).append("qcx_menus.txt");
qcx_menus = fopen(qcx_menu_file.c_str(), "w");
menu1 = menu2 = 1;
}
void * serial_thread_loop(void *d)
{
POLL_PAIR *rx_poll_group_1 = &RX_poll_group_1[0];
POLL_PAIR *rx_poll_group_2 = &RX_poll_group_2[0];
POLL_PAIR *rx_poll_group_3 = &RX_poll_group_3[0];
POLL_PAIR *tx_polling = &TX_poll_pairs[0];
bool isRX = false;
for(;;) {
MilliSleep(progStatus.serloop_timing);
if (!run_serial_thread) {
break;
}
if (bypass_serial_thread_loop || disable_polling->value()) {
goto serial_bypass_loop;
}
if (RigSerial->failed() >= MAX_FAILURES) {
Fl::awake(serial_failed);
}
//send any freq/mode/bw changes in the queu
if (!srvc_reqs.empty()) {
serviceQUE();
}
if (progStatus.poll_ptt) {
guard_lock lk(&mutex_serial, "2");
check_ptt();
}
if (PTT ||
cwio_process == SEND ||
cwio_process == CALIBRATE ||
cwio_process == KEYDOWN ) {
if (isRX) {
isRX = false;
smtrval = 0;
Fl::awake(update_UI_PTT);
Fl::awake(updateSmeter);
}
if (progStatus.poll_frequency) {
guard_lock lk(&mutex_serial, "3");
read_vfo();
}
if ( tx_polling->poll != NULL && *(tx_polling->poll) ) {
guard_lock lk(&mutex_serial, "4");
(tx_polling->pollfunc)();
}
if ((++tx_polling)->poll == NULL)
tx_polling = &TX_poll_pairs[0];
} else {
if (!isRX) {
isRX = true;
Fl::awake(update_UI_PTT);
Fl::awake(zeroXmtMeters, 0);
}
while ( rx_poll_group_1->poll != NULL ) {
if ( *(rx_poll_group_1->poll) ) {
guard_lock lk(&mutex_serial, "5");
(rx_poll_group_1->pollfunc)();
++rx_poll_group_1;
break;
}
MilliSleep(1);
++rx_poll_group_1;
}
if ((rx_poll_group_1)->poll == NULL)
rx_poll_group_1 = &RX_poll_group_1[0];
while ( rx_poll_group_2->poll != NULL ) {
if ( *(rx_poll_group_2->poll) ) {
guard_lock lk(&mutex_serial, "6");
(rx_poll_group_2->pollfunc)();
++rx_poll_group_2;
break;
}
MilliSleep(1);
++rx_poll_group_2;
}
if ((rx_poll_group_2)->poll == NULL)
rx_poll_group_2 = &RX_poll_group_2[0];
while ( rx_poll_group_3->poll != NULL ) {
if ( *(rx_poll_group_3->poll) ) {
guard_lock lk(&mutex_serial, "7");
(rx_poll_group_3->pollfunc)();
++rx_poll_group_3;
break;
}
MilliSleep(1);
++rx_poll_group_3;
}
if ((rx_poll_group_3)->poll == NULL)
rx_poll_group_3 = &RX_poll_group_3[0];
if (menu1 < 9 && selrig->name_ == rig_QCXP.name_) {
guard_lock lk(&mutex_serial, "8");
read_menu();
}
}
serial_bypass_loop: ;
}
return NULL;
}
//=============================================================================
void setBW()
{
XCVR_STATE fm = *vfo;
fm.src = UI;
fm.iBW = opBW->index();
guard_lock que_lock( &mutex_srvc_reqs, "setBW" );
srvc_reqs.push( VFOQUEUE((selrig->inuse == onB ? vB : vA), fm));
}
void setDSP()
{
XCVR_STATE fm = *vfo;
fm.src = UI;
fm.iBW = ((opDSP_hi->index() << 8) | 0x8000) | (opDSP_lo->index() & 0xFF) ;
guard_lock que_lock( & mutex_srvc_reqs, "setDSP" );
srvc_reqs.push ( VFOQUEUE((selrig->inuse == onB ? vB : vA), fm));
}
void selectDSP()
{
if (btnDSP->label()[0] == selrig->SL_label[0]) {
btnDSP->label(selrig->SH_label);
btnDSP->redraw_label();
opDSP_lo->hide();
opDSP_hi->show();
opDSP_hi->redraw();
} else {
btnDSP->label(selrig->SL_label);
btnDSP->redraw_label();
opDSP_hi->hide();
opDSP_lo->show();
opDSP_lo->redraw();
}
}
void selectFILT()
{
guard_lock lock(&mutex_serial, "9");
btnFILT->label(selrig->nextFILT());
btnFILT->redraw_label();
}
void selectCENTER()
{
if (xcvr_name == rig_K2.name_ ||
xcvr_name == rig_K3.name_ ||
xcvr_name == rig_KX3.name_ ||
xcvr_name == rig_K4.name_) {
return;
}
if (btnCENTER->label()[0] == 'C') {
btnCENTER->label("W");
opBW->show();
opCENTER->hide();
} else {
btnCENTER->label("C");
opBW->hide();
opCENTER->index(progStatus.tci_center);
opCENTER->show();
}
opBW->redraw();
opCENTER->redraw();
btnCENTER->redraw_label();
}
static int lastTCI_bw = -1;
static int lastTCI_inner = -1;
static int lastTCI_outer = -1;
static int lastTCI_mode = -1;
void updateTCI(void *d)
{
if (!( selrig->name_ == rig_tci_sundx.name_ ||
selrig->name_ == rig_tci_sunpro.name_) )
return;
vfo->FilterInner = selrig->get_pbt_inner();
vfo->FilterOuter = selrig->get_pbt_outer();
if (lastTCI_mode != vfo->imode) {
lastTCI_mode = vfo->imode;
switch (vfo->imode) {
case TCI_AM: case TCI_SAM: case TCI_DSB: case TCI_NFM:
opFilterInner->minimum(-8000); opFilterInner->maximum(0);
opFilterOuter->minimum(0); opFilterOuter->maximum(8000);
break;
case TCI_LSB:
opFilterInner->minimum(-4000); opFilterInner->maximum(0);
opFilterOuter->minimum(-4000); opFilterOuter->maximum(0);
break;
case TCI_USB:
opFilterInner->minimum(0); opFilterInner->maximum(4000);
opFilterOuter->minimum(0); opFilterOuter->maximum(4000);
break;
default: case TCI_CW:
opFilterInner->minimum(-1000); opFilterInner->maximum(0);
opFilterOuter->minimum(0); opFilterOuter->maximum(1000);
break;
case TCI_DIGL: case TCI_DIGU:
opFilterInner->minimum(-4000); opFilterInner->maximum(0);
opFilterOuter->minimum(0); opFilterOuter->maximum(4000);
break;
case TCI_WFM:
opFilterInner->minimum(-9000); opFilterInner->maximum(0);
opFilterOuter->minimum(0); opFilterOuter->maximum(9000);
break;
case TCI_DRM:
opFilterInner->minimum(-5000); opFilterInner->maximum(0);
opFilterOuter->minimum(0); opFilterOuter->maximum(5000);
break;
}
updateBandwidthControl((void *)0);
}
if (lastTCI_bw != vfo->iBW) opBW->index(lastTCI_bw = vfo->iBW);
if (lastTCI_inner != vfo->FilterInner) opFilterInner->value(lastTCI_inner = vfo->FilterInner);
if (lastTCI_outer != vfo->FilterOuter) opFilterOuter->value(lastTCI_outer = vfo->FilterOuter);
std::string smode = opMODE->value();
if (smode == "USB" || smode == "LSB") {
btnCENTER->activate();
btnCENTER->redraw();
btnCENTER->show();
if (btnCENTER->label()[0] == 'C') {
opCENTER->index(progStatus.tci_center);
opCENTER->show();
opBW->hide();
} else {
opBW->show();
opCENTER->hide();
}
opBW->resize(opDSP_lo->x(), opDSP_lo->y(), opDSP_lo->w(), opDSP_lo->h());
opCENTER->resize(opDSP_lo->x(), opDSP_lo->y(), opDSP_lo->w(), opDSP_lo->h());
opCENTER->redraw();
opBW->redraw();
} else {
btnCENTER->label("W");
btnCENTER->redraw_label();
btnCENTER->deactivate();
btnCENTER->show();
opCENTER->hide();
if (vfo->iBW != opBW->index())
opBW->index(vfo->iBW);
opBW->resize(opDSP_lo->x(), opDSP_lo->y(), opDSP_lo->w(), opDSP_lo->h());
opBW->redraw();
opBW->show();
}
}
void updateFLEX1500(void *d)
{
if (!( selrig->name_ == rig_FLEX1500.name_) )
return;
btnCENTER->hide();
opCENTER->hide();
switch (vfo->imode) {
case RIG_FLEX1500::AM :
case RIG_FLEX1500::SAM :
case RIG_FLEX1500::DSB :
case RIG_FLEX1500::FM :
sldrINNER->minimum(-8000); sldrINNER->maximum(0); sldrINNER->step(10);
sldrOUTER->minimum(0); sldrOUTER->maximum(8000); sldrOUTER->step(10);
break;
case RIG_FLEX1500::LSB :
sldrINNER->minimum(-4000); sldrINNER->maximum(0); sldrINNER->step(10);
sldrOUTER->minimum(-4000); sldrOUTER->maximum(0); sldrOUTER->step(10);
break;
case RIG_FLEX1500::USB :
sldrINNER->minimum(0); sldrINNER->maximum(4000); sldrINNER->step(10);
sldrOUTER->minimum(0); sldrOUTER->maximum(4000); sldrOUTER->step(10);
break;
default: case RIG_FLEX1500::CWL :
sldrINNER->minimum(-1500); sldrINNER->maximum(0); sldrINNER->step(5);
sldrOUTER->minimum(-1500); sldrOUTER->maximum(0); sldrOUTER->step(5);
break;
case RIG_FLEX1500::CWU:
sldrINNER->minimum(0); sldrINNER->maximum(1500); sldrINNER->step(5);
sldrOUTER->minimum(0); sldrOUTER->maximum(1500); sldrOUTER->step(5);
break;
case RIG_FLEX1500::DIGL: case RIG_FLEX1500::DIGU:
sldrINNER->minimum(0); sldrINNER->maximum(1500); sldrINNER->step(10);
sldrOUTER->minimum(0); sldrOUTER->maximum(1500); sldrOUTER->step(10);
break;
case RIG_FLEX1500::DRM:
sldrINNER->minimum(-5000); sldrINNER->maximum(0); sldrINNER->step(10);
sldrOUTER->minimum(0); sldrOUTER->maximum(5000); sldrOUTER->step(10);
break;
}
std::string sBW = opBW->value();
if (sBW.find("Var") != std::string::npos) {
sldrINNER->activate();
sldrOUTER->activate();
} else {
sldrINNER->deactivate();
sldrOUTER->deactivate();
}
updateBandwidthControl((void *)0);
}
// set_bandwidth_control updates iBW and then posts the call for
// the UI thread to updateBandwidthControl
// changes to the UI cannot come from any thread other than the
// main FL thread! Doing otherwise can cause what appears to be
// random program crashes.
void set_bandwidth_control()
{
if (!selrig->has_bandwidth_control) return;
// if (selrig->name_ != rig_K3.name_) {
// vfo->iBW = selrig->def_bandwidth(vfo->imode);
// if (vfo->iBW < 256) {
// vfo->iBW = selrig->def_bandwidth(vfo->imode);
// }
// }
if (selrig->inuse == onB) {
vfoB.iBW = vfo->iBW = selrig->get_bwB();
} else {
vfoA.iBW = vfo->iBW = selrig->get_bwA();
}
Fl::awake(updateBandwidthControl);
}
void TRACED ( updateBandwidthControl, void *d )
if (//xcvr_name == rig_K3.name_ ||
xcvr_name == rig_KX3.name_
|| xcvr_name == rig_K4.name_
) {
return;
}
if (selrig->has_dsp_controls) {
if (vfo->iBW > 256) {
opDSP_lo->clear();
opDSP_hi->clear();
try {
for (size_t i = 0; i < selrig->dsp_SL.size(); i++)
opDSP_lo->add(selrig->dsp_SL.at(i).c_str());
for (size_t i = 0; i < selrig->dsp_SH.size(); i++)
opDSP_hi->add(selrig->dsp_SH.at(i).c_str());
} catch (const std::exception& e) {
LOG_ERROR("%s", e.what());
}
opBW->hide();
opDSP_lo->index(vfo->iBW & 0xFF);
opDSP_lo->hide();
opDSP_hi->index((vfo->iBW >> 8) & 0x7F);
btnDSP->label(selrig->SH_label);
opDSP_hi->show();
opDSP_hi->redraw();
btnDSP->show();
btnDSP->redraw();
btnFILT->hide();
} else {
opDSP_lo->hide();
opDSP_hi->hide();
btnDSP->hide();
btnFILT->hide();
// opBW->clear();
try {
if (vfo->iBW != opBW->index())
opBW->index(vfo->iBW);
} catch (const std::exception& e) {
LOG_ERROR("%s", e.what());
opBW->index(0);
}
opBW->redraw();
opBW->show();
}
}
else if (selrig->has_bandwidth_control) {
opDSP_lo->hide();
opDSP_hi->hide();
btnDSP->hide();
// opBW->clear();
try {
if (vfo->iBW != opBW->index())
opBW->index(vfo->iBW);
} catch (const std::exception& e) {
LOG_ERROR("%s", e.what());
opBW->index(0);
}
opBW->redraw();
if (selrig->has_FILTER) {
btnFILT->show();
btnFILT->label(
selrig->FILT(
selrig->inuse == onB ? vfoB.filter : vfoA.filter));
btnFILT->redraw_label();
opBW->resize(opDSP_lo->x(), opDSP_lo->y(), opDSP_lo->w(), opDSP_lo->h());
opBW->redraw();
} else {
opBW->show();
}
}
else { // no BW, no DSP controls
opBW->index(0);
opBW->hide();
btnFILT->hide();
opDSP_lo->index(0);
opDSP_hi->index(0);
btnDSP->hide();
opDSP_lo->hide();
opDSP_hi->hide();
}
// if (selrig->name_ == rig_FLEX1500.name_) {
// std::string sBW = opBW->value();
// if (sBW.find("Var") != std::string::npos) {
// sldrINNER->activate();
// sldrOUTER->activate();
// } else {
// sldrINNER->deactivate();
// sldrOUTER->deactivate();
// }
// sldrINNER->redraw();
// sldrOUTER->redraw();
// }
}
void setMode()
{
XCVR_STATE fm = *vfo;
fm.imode = opMODE->index();
fm.iBW = selrig->def_bandwidth(fm.imode);
fm.src = UI;
if (selrig->has_FILTER) {
fm.filter = selrig->get_FILT(fm.imode);
if (selrig->inuse == onB) fm.filter = selrig->get_FILT(fm.imode);
}
guard_lock que_lock( &mutex_srvc_reqs, "setMode" );
srvc_reqs.push(VFOQUEUE( (selrig->inuse == onB ? vB : vA), fm));
}
void sortList() {
if (!numinlist) return;
ATAG_XCVR_STATE temp;
for (int i = 0; i < numinlist - 1; i++)
for (int j = i + 1; j < numinlist; j++)
if (oplist[i].freq > oplist[j].freq) {
temp = oplist[i];
oplist[i] = oplist[j];
oplist[j] = temp;
}
}
void clearList() {
if (!numinlist) return;
for (int i = 0; i < LISTSIZE; i++) {
oplist[i].freq = 0;
oplist[i].imode = USB;
oplist[i].iBW = 0;
memset(oplist[i].alpha_tag, 0, ATAGSIZE);
}
FreqSelect->clear();
numinlist = 0;
inAlphaTag->value("");
}
void updateSelect() {
char szline[1000];
char szatag[ATAGSIZE];
int i;
FreqSelect->clear();
if (!numinlist) return;
sortList();
// stripe lines
int bg1, bg2, bg_clr;
bg1 = FL_WHITE; bg2 = FL_LIGHT2;
for (int n = 0; n < numinlist; n++) {
memset(szline, 0, sizeof(szline));
memset(szatag, 0, sizeof(szatag));
for (i = 0; i < ATAGSIZE; i++) {
szatag[i] = oplist[n].alpha_tag[i];
if (szatag[i] == '\n') szatag[i] = ' ';
}
bg_clr = (n % 2) ? bg1 : bg2;
snprintf(szline, sizeof(szline), "\
@F%d@S%d@B%d@r%.3f\t\
@F%d@S%d@B%d@.|\t\
@F%d@S%d@B%d@r%s\t\
@F%d@S%d@B%d@.|\t\
@F%d@S%d@B%d@r%s\t\
@F%d@S%d@B%d@.|\t\
@F%d@S%d@B%d@.%s",
progStatus.memfontnbr, progStatus.memfontsize, bg_clr, oplist[n].freq / 1000.0,
progStatus.memfontnbr, progStatus.memfontsize, bg_clr,
progStatus.memfontnbr, progStatus.memfontsize, bg_clr, selrig->get_bwname_(oplist[n].iBW, oplist[n].imode),
progStatus.memfontnbr, progStatus.memfontsize, bg_clr,
progStatus.memfontnbr, progStatus.memfontsize, bg_clr, selrig->get_modename_(oplist[n].imode),
progStatus.memfontnbr, progStatus.memfontsize, bg_clr,
progStatus.memfontnbr, progStatus.memfontsize, bg_clr, szatag );
FreqSelect->add (szline);
}
inAlphaTag->value("");
}
void addtoList(unsigned long long val, int imode, int iBW) {
if (numinlist < LISTSIZE) {
oplist[numinlist].imode = imode;
oplist[numinlist].freq = val;
oplist[numinlist].iBW = iBW;
memset(oplist[numinlist].alpha_tag, 0, ATAGSIZE);
numinlist++;
}
}
void readFile() {
std::ifstream iList(defFileName.c_str());
if (!iList) {
fl_message ("Could not open %s", defFileName.c_str());
return;
}
clearList();
int i = 0, mode, bw;
unsigned long long freq;
while (!iList.eof()) {
freq = 0ULL; mode = -1;
iList >> freq >> mode >> bw;
if (freq && (mode > -1)) {
oplist[i].freq = freq;
oplist[i].imode = mode;
oplist[i].iBW = (bw == -1 ? 0 : bw);
memset(oplist[i].alpha_tag, 0, ATAGSIZE);
i++;
}
}
iList.close();
numinlist = i;
updateSelect();
}
void readTagFile() {
std::ifstream iList(defFileName.c_str());
if (!iList) {
fl_message ("Could not open %s", defFileName.c_str());
return;
}
clearList();
int i = 0, mode, bw;
unsigned long long freq;
std::string atag;
char ca[ATAGSIZE + 60];
while (!iList.eof()) {
freq = 0ULL; mode = -1;
atag.clear();
memset(ca, 0, sizeof(ca));
iList >> freq >> mode >> bw;
iList.getline(ca, sizeof(ca) - 1);
atag = ca;
if (freq && (mode > -1)) {
oplist[i].freq = freq;
oplist[i].imode = mode;
oplist[i].iBW = (bw == -1 ? 0 : bw);
// trim leading, trailing spaces and double quotes
atag = lt_trim(atag);
snprintf(oplist[i].alpha_tag, ATAGSIZE, "%s", atag.c_str());
i++;
}
}
iList.close();
numinlist = i;
updateSelect();
}
void buildlist() {
std::string tmpFN, orgFN;
// check for new Memory-Alpha-Tag file
defFileName = RigHomeDir;
defFileName.append(selrig->name_);
defFileName.append(".mat");
FILE *fh = fopen(defFileName.c_str(), "r");
if (fh != NULL) {
fclose (fh);
readTagFile();
return;
}
// else only read original file to make new MAT file
orgFN = RigHomeDir;
orgFN.append(selrig->name_);
orgFN.append(".arv");
fh = fopen(orgFN.c_str(), "r");
if (fh != NULL) {
fclose (fh);
tmpFN = defFileName;
defFileName = orgFN;
readFile();
defFileName = tmpFN;
return;
}
clearList();
}
// flrig front panel changed
void movFreqA(Fl_Widget *, void *) {
guard_lock serial(&mutex_serial, "10");
if (!selrig->can_change_alt_vfo && selrig->inuse == onB) {
selrig->selectA();
vfoA.freq = FreqDispA->value();
selrig->set_vfoA(vfoA.freq);
selrig->selectB();
} else {
vfoA.freq = FreqDispA->value();
selrig->set_vfoA(vfoA.freq);
}
}
void movFreqB(Fl_Widget *, void *) {
guard_lock serial(&mutex_serial, "11");
if (!selrig->can_change_alt_vfo && selrig->inuse == onA) {
selrig->selectB();
vfoB.freq = FreqDispB->value();
selrig->set_vfoB(vfoB.freq);
selrig->selectA();
} else {
vfoB.freq = FreqDispB->value();
selrig->set_vfoB(vfoB.freq);
}
}
void execute_swapAB()
{
if (selrig->canswap()) {
selrig->swapAB();
if (selrig->ICOMmainsub) {
XCVR_STATE temp = vfoA;
vfoA = vfoB;
vfoB = temp;
selrig->selectA();
vfo = &vfoA;
} else if (selrig->ICOMrig) {
if (selrig->inuse == onB) {
selrig->selectA();
vfo = &vfoA;
} else {
selrig->selectB();
vfo = &vfoB;
}
} else if (selrig->name_ == rig_FT891.name_) {
// No need for extra select, as swapAB accomplishes this
if (selrig->inuse == onB) {
selrig->selectA();
vfo = &vfoA;
// Restore mode, then frequency and bandwidth after swap.
yaesu891UpdateA(&vfoA);
}
else {
selrig->selectB();
vfo = &vfoB;
// Restore mode, then frequency and bandwidth after swap.
yaesu891UpdateB(&vfoB);
}
} else if (selrig->name_ == rig_FTdx10.name_ ) {
XCVR_STATE temp = vfoB;
vfoB = vfoA;
vfoA = temp;
if (selrig->inuse == onB)
vfo = &vfoB;
else
vfo = &vfoA;
} else {
XCVR_STATE temp = vfoB;
vfoB = vfoA;
vfoA = temp;
if (selrig->inuse == onB) {
selrig->selectB();
vfo = &vfoB;
} else {
selrig->selectA();
vfo = &vfoA;
}
}
} else {
if (selrig->inuse == onB) {
XCVR_STATE vfotemp = vfoA;
selrig->selectA();
vfoA = vfoB;
selrig->set_modeA(vfoA.imode);
selrig->set_vfoA(vfoA.freq);
selrig->set_bwA(vfoA.iBW);
selrig->get_vfoA();
selrig->get_modeA();
selrig->get_bwA();
selrig->selectB();
vfoB = vfotemp;
selrig->set_modeB(vfoB.imode);
selrig->set_vfoB(vfoB.freq);
selrig->set_bwB(vfoB.iBW);
selrig->get_vfoB();
selrig->get_modeB();
selrig->get_bwB();
vfo = &vfoB;
} else {
XCVR_STATE vfotemp = vfoB;
selrig->selectB();
vfoB = vfoA;
selrig->set_modeB(vfoB.imode);
selrig->set_vfoB(vfoB.freq);
selrig->set_bwB(vfoB.iBW);
selrig->get_vfoB();
selrig->get_modeB();
selrig->get_bwB();
selrig->selectA();
vfoA = vfotemp;
selrig->set_modeA(vfoA.imode);
selrig->set_vfoA(vfoA.freq);
selrig->set_bwA(vfoA.iBW);
selrig->get_vfoA();
selrig->get_modeA();
selrig->get_bwA();
vfo = &vfoA;
}
}
Fl::awake(updateUI);
}
void cbAswapB()
{
guard_lock lock(&mutex_srvc_reqs, "cbAswapB");
if ((Fl::event_state() & FL_SHIFT) == FL_SHIFT) {
VFOQUEUE xcvr;
xcvr.change = FA2FB;
trace(1, "cb VfoA freq -> VfoB freq");
srvc_reqs.push(xcvr);
} else if ((Fl::event_state() & FL_CTRL) == FL_CTRL) {
VFOQUEUE xcvr;
xcvr.change = FB2FA;
trace(1, "cb VfoB freq -> VfoA freq");
srvc_reqs.push(xcvr);
} else {
if (Fl::event_button() == FL_RIGHT_MOUSE) {
VFOQUEUE xcvr;
xcvr.change = A2B;
trace(1, "cb Active->Inactive vfo");
srvc_reqs.push(xcvr);
} else {
guard_lock lock2(&mutex_serial, "12");
// execute_swapAB();
VFOQUEUE xcvr;
xcvr.change = SWAP;
trace(1, "cb SWAP");
srvc_reqs.push(xcvr);
}
}
}
void execute_A2B()
{
if (xcvr_name == rig_K3.name_) {
K3_A2B();
} else if (xcvr_name == rig_KX3.name_ || xcvr_name == rig_K4.name_) {
cb_KX3_A2B();
} else if (xcvr_name == rig_K2.name_) {
trace(1,"execute A2B() 1");
vfoB = vfoA;
selrig->set_vfoB(vfoB.freq);
selrig->get_vfoB();
FreqDispB->value(vfoB.freq);
}
if (selrig->ICOMmainsub) {
selrig->selectA();
selrig->A2B();
vfoB = vfoA;
vfo = &vfoA;
} else if (selrig->has_a2b) {
trace(1,"execute A2B() 2");
selrig->A2B();
if (selrig->inuse == onB) {
vfoA = vfoB;
FreqDispA->value(vfoA.freq);
} else {
vfoB = vfoA;
FreqDispB->value(vfoB.freq);
}
} else {
if (selrig->inuse == onB) {
vfoA = vfoB;
if (selrig->name_ == rig_FT891.name_) {
yaesu891UpdateA(&vfoA);
} else {
selrig->set_vfoA(vfoA.freq);
selrig->set_modeA(vfoA.imode);
selrig->set_bwA(vfoA.iBW);
selrig->get_vfoA();
selrig->get_modeA();
selrig->get_bwA();
}
FreqDispA->value(vfoA.freq);
} else {
vfoB = vfoA;
if (selrig->name_ == rig_FT891.name_) {
yaesu891UpdateB(&vfoB);
} else {
selrig->set_vfoB(vfoB.freq);
selrig->set_modeB(vfoB.imode);
selrig->set_bwB(vfoB.iBW);
selrig->get_vfoB();
selrig->get_modeB();
selrig->get_bwB();
}
FreqDispB->value(vfoB.freq);
}
}
Fl::awake(updateUI);
}
void execute_FA2FB()
{
vfoB.freq = vfoA.freq;
selrig->set_vfoB(vfoB.freq);
FreqDispB->value(vfoB.freq);
Fl::awake(updateUI);
}
void execute_FB2FA()
{
vfoA.freq = vfoB.freq;
selrig->set_vfoA(vfoA.freq);
FreqDispA->value(vfoA.freq);
Fl::awake(updateUI);
}
void highlight_vfo(void *d)
{
Fl_Color norm_fg = fl_rgb_color(progStatus.fg_red, progStatus.fg_green, progStatus.fg_blue);
Fl_Color norm_bg = fl_rgb_color(progStatus.bg_red, progStatus.bg_green, progStatus.bg_blue);
Fl_Color dim_bg = fl_color_average( norm_bg, FL_BLACK, 0.75);
FreqDispA->value(vfoA.freq);
FreqDispB->value(vfoB.freq);
if (selrig->inuse == onB) {
FreqDispA->SetCOLORS( norm_fg, dim_bg );
FreqDispB->SetCOLORS( norm_fg, norm_bg );
if (selrig->name_ == rig_tci_sundx.name_ || selrig->name_ == rig_tci_sunpro.name_) {
btnA->value(1);
} else {
btnA->value(0);
btnB->value(1);
}
FreqDispB->activate();
if (selrig->can_change_alt_vfo)
FreqDispA->activate();
else
FreqDispA->deactivate();
} else {
FreqDispA->SetCOLORS( norm_fg, norm_bg );
FreqDispB->SetCOLORS( norm_fg, dim_bg);
if (selrig->name_ == rig_tci_sundx.name_ || selrig->name_ == rig_tci_sunpro.name_) {
btnA->value(0);
} else {
btnA->value(1);
btnB->value(0);
}
FreqDispA->activate();
if (selrig->can_change_alt_vfo)
FreqDispB->activate();
else
FreqDispB->deactivate();
}
FreqDispA->redraw();
FreqDispB->redraw();
btnA->redraw();
btnB->redraw();
Fl::check();
}
void cb_set_split(int val)
{
progStatus.split = val;
VFOQUEUE xcvr_split;
if (val) xcvr_split.change = sON;
else xcvr_split.change = sOFF;
trace(1, (val ? "cb_set_split(ON)" : "cb_set_split(OFF)"));
srvc_reqs.push(xcvr_split);
}
void cb_selectA()
{
guard_lock que_lock( &mutex_srvc_reqs, "cb_selectA");
srvc_reqs.push (VFOQUEUE(sA, vfoA));
return;
}
void cb_selectB()
{
guard_lock que_lock( &mutex_srvc_reqs, "cb_selectB");
srvc_reqs.push (VFOQUEUE(sB, vfoB));
return;
}
void setLower()
{
}
void setUpper()
{
}
void selectFreq() {
int n = FreqSelect->value(); // This is the number of the selected line; not the line's value.
if (!n) return;
n--;
XCVR_STATE fm;
fm.freq = oplist[n].freq;
fm.imode = oplist[n].imode;
fm.iBW = oplist[n].iBW;
fm.src = UI;
if (selrig->inuse == onA) {
FreqDispA->value(fm.freq);
guard_lock que_lock(&mutex_srvc_reqs, "selectFreq on A");
srvc_reqs.push(VFOQUEUE(vA, fm));
} else {
FreqDispB->value(fm.freq);
guard_lock que_lock(&mutex_srvc_reqs, "selectFreq on B");
srvc_reqs.push(VFOQUEUE(vB, fm));
}
}
#include
void select_and_close()
{
int key = Fl::event_key();
int btn = Fl::event_button();
if (FreqSelect->value() <= 0) return;
if ((btn == FL_LEFT_MOUSE && Fl::event_clicks()) ||
btn == FL_RIGHT_MOUSE ||
key == FL_Enter ||
key == FL_Left) {
inAlphaTag->value(oplist[FreqSelect->value() - 1].alpha_tag);
selectFreq();
Fl::focus(FreqSelect);
return;
}
if (btn == FL_LEFT_MOUSE || key == FL_Up || key == FL_Down) {
inAlphaTag->value(oplist[FreqSelect->value() - 1].alpha_tag);
Fl::focus(FreqSelect);
return;
}
if (key == FL_Right) {
addFreq();
FreqSelect->select(1, 1);
inAlphaTag->value(oplist[0].alpha_tag);
Fl::focus(FreqSelect);
return;
}
if (key == FL_Delete) {
long n = FreqSelect->value();
delFreq();
FreqSelect->select(n, 1);
inAlphaTag->value(oplist[n-1].alpha_tag);
Fl::focus(FreqSelect);
return;
}
}
void delFreq() {
if (FreqSelect->value()) {
long n = FreqSelect->value() - 1;
for (int i = n; i < numinlist; i ++)
oplist[i] = oplist[i+1];
if (numinlist) {
oplist[numinlist - 1].imode = USB;
oplist[numinlist - 1].freq = 0;
oplist[numinlist - 1].iBW = 0;
memset(oplist[numinlist - 1].alpha_tag, 0, ATAGSIZE);
numinlist--;
}
updateSelect();
}
}
void addFreq() {
if (selrig->inuse == onB) {
unsigned long long freq = FreqDispB->value();
if (!freq) return;
int mode = opMODE->index();
int bw;
if (btnDSP->visible())
bw = ((opDSP_hi->index() << 8) | 0x8000) | (opDSP_lo->index() & 0xFF) ;
else if (opBW_B->visible())
bw = opBW_B->index();
else
bw = opBW->index();
for (int n = 0; n < numinlist; n++)
if (freq == oplist[n].freq && mode == oplist[n].imode) {
oplist[n].iBW = bw;
updateSelect(); // update list
return;
}
addtoList(freq, mode, bw);
updateSelect();
FreqDispB->visual_beep();
} else {
unsigned long long freq = FreqDispA->value();
if (!freq) return;
int mode = opMODE->index();
int bw;
if (btnDSP->visible())
bw = ((opDSP_hi->index() << 8) | 0x8000) | (opDSP_lo->index() & 0xFF) ;
else if (opBW_A->visible())
bw = opBW_A->index();
else
bw = opBW->index();
for (int n = 0; n < numinlist; n++)
if (freq == oplist[n].freq && mode == oplist[n].imode) {
oplist[n].iBW = bw;
updateSelect(); // update list
return;
}
addtoList(freq, mode, bw);
updateSelect();
FreqDispA->visual_beep();
}
}
void cbRIT()
{
trace(1, "cbRIT()");
if (selrig->has_rit && cntRIT) {
guard_lock serial_lock(&mutex_serial, "13");
selrig->setRit((int)cntRIT->value());
}
}
void cbXIT()
{
trace(1, "cbXIT()");
guard_lock serial_lock(&mutex_serial, "14");
selrig->setXit((int)cntXIT->value());
}
void cbBFO()
{
if (selrig->has_bfo) {
trace(1, "cbBFO()");
guard_lock serial_lock(&mutex_serial, "15");
selrig->setBfo((int)cntBFO->value());
}
}
void cbAttenuator()
{
trace(1, "cbAttenuator()");
{
guard_lock serial_lock(&mutex_serial, "16");
selrig->set_attenuator ( progStatus.attenuator = selrig->next_attenuator() );
if (xcvr_name == rig_K4.name_)
selrig->get_attenuator();
}
btnAttenuator->value( progStatus.attenuator > 0 ? 1 : 0);
btnAttenuator->label( selrig->ATT_label() );
btnAttenuator->redraw_label();
btnAttenuator->redraw();
return;
}
void setAttControl(void *d)
{
size_t val = reinterpret_cast(d);
btnAttenuator->value(val);
}
void cbPreamp()
{
trace(1, "cbPreamp()");
if (selrig->name_ == rig_FLEX1500.name_) {
selrig->set_preamp(progStatus.preamp = cbo_preamp->index());
return;
}
{
guard_lock serial_lock(&mutex_serial, "17");
selrig->set_preamp ( progStatus.preamp = selrig->next_preamp() );
if (xcvr_name == rig_K4.name_)
selrig->get_preamp();
}
btnPreamp->value( progStatus.preamp > 0 ? 1 : 0);
btnPreamp->label( selrig->PRE_label() );
btnPreamp->redraw_label();
btnPreamp->redraw();
return;
}
void setPreampControl(void *d)
{
size_t val = reinterpret_cast(d);
btnPreamp->value(val);
}
void cbAN()
{
guard_lock serial_lock(&mutex_serial, "18");
trace(1, "cbAN()");
progStatus.auto_notch = btnAutoNotch->value();
selrig->set_auto_notch(progStatus.auto_notch);
}
void cbbtnNotch()
{
if (!selrig->has_notch_control) return;
int val = 0, cnt = 0;
{
guard_lock serial_lock(&mutex_serial, "19");
progStatus.notch = btnNotch->value();
selrig->set_notch(progStatus.notch, progStatus.notch_val);
}
MilliSleep(progStatus.serial_post_write_delay);
while ((selrig->get_notch(val) != progStatus.notch) && (cnt++ < 10)) {
MilliSleep(progStatus.serial_post_write_delay);
Fl::awake();
}
}
void setNotch()
{
if (!selrig->has_notch_control) return;
trace(1, "setNotch()");
int ev = Fl::event();
if (ev == FL_LEAVE || ev == FL_ENTER) return;
guard_lock lock( &mutex_serial, "20");
if (sldrNOTCH) {
progStatus.notch_val = sldrNOTCH->value();
} else {
progStatus.notch_val = spnrNOTCH->value();
}
selrig->set_notch(progStatus.notch, progStatus.notch_val);
}
// called from xml_io thread
// xcvr updated in xml_io / xml_server code
// this only updates the dialog controls
void setNotchControl(void *d)
{
if (sldrNOTCH) sldrNOTCH->value(progStatus.notch_val);
if (spnrNOTCH) spnrNOTCH->value(progStatus.notch_val);
btnNotch->value(progStatus.notch);
}
void adjust_if_shift_control(void *d)
{
if (sldrIFSHIFT) sldrIFSHIFT->minimum(selrig->if_shift_min);
if (sldrIFSHIFT) sldrIFSHIFT->maximum(selrig->if_shift_max);
if (sldrIFSHIFT) sldrIFSHIFT->step(selrig->if_shift_step);
if (sldrIFSHIFT) sldrIFSHIFT->value(selrig->if_shift_mid);
if (sldrIFSHIFT) sldrIFSHIFT->redraw();
if (spnrIFSHIFT) spnrIFSHIFT->minimum(selrig->if_shift_min);
if (spnrIFSHIFT) spnrIFSHIFT->maximum(selrig->if_shift_max);
if (spnrIFSHIFT) spnrIFSHIFT->step(selrig->if_shift_step);
if (spnrIFSHIFT) spnrIFSHIFT->value(selrig->if_shift_mid);
if (spnrIFSHIFT) spnrIFSHIFT->redraw();
btnIFsh->value(0);
btnIFsh->redraw();
}
void setIFshiftButton(void *d)
{
bool b = (bool)d;
if (b && !btnIFsh->value()) {
btnIFsh->value(1);
}
else if (!b && btnIFsh->value()) {
btnIFsh->value(0);
if (sldrIFSHIFT) sldrIFSHIFT->value( selrig->if_shift_mid );
if (spnrIFSHIFT) spnrIFSHIFT->value( selrig->if_shift_mid );
}
}
void setIFshiftControl(void *d)
{
int val = *(reinterpret_cast(d));
if (sldrIFSHIFT) {
if (sldrIFSHIFT->value() != val)
sldrIFSHIFT->value(val);
}
if (spnrIFSHIFT) {
if (spnrIFSHIFT->value() != val)
spnrIFSHIFT->value(val);
}
btnIFsh->value( val != selrig->if_shift_mid );
}
void setIFshift()
{
trace(1, "setIFshift()");
int ev = Fl::event();
if (ev == FL_LEAVE || ev == FL_ENTER) return;
if (ev == FL_DRAG || ev == FL_PUSH) {
inhibit_shift = 1;
return;
}
int btn = 0, set = 0;
btn = btnIFsh->value();
progStatus.shift = btn;
if (sldrIFSHIFT) {
set = sldrIFSHIFT->value();
} else if (spnrIFSHIFT) {
set = spnrIFSHIFT->value();
}
progStatus.shift_val = set;
guard_lock lock(&mutex_serial, "21");
if (xcvr_name == rig_TS990.name_) {
if (progStatus.shift)
selrig->set_monitor(1);
else
selrig->set_monitor(0);
}
selrig->set_if_shift(progStatus.shift_val);
}
void cbIFsh()
{
guard_lock serial_lock(&mutex_serial, "22");
trace(1, "setIFsh()");
int btn, set, cnt = 0;
if (sldrIFSHIFT) {
set = sldrIFSHIFT->value();
btn = btnIFsh->value();
} else {
set = spnrIFSHIFT->value();
btn = btnIFsh->value();
}
if (btn == 0) set = 0;
selrig->set_if_shift(set);
MilliSleep(50);
int val, on;
on = selrig->get_if_shift(val);
while ((on != btn) && (cnt++ < 10)) {
MilliSleep(progStatus.serial_post_write_delay);
on = selrig->get_if_shift(val);
Fl::awake();
}
}
void setLOCK()
{
progStatus.pbt_lock = btnLOCK->value();
if (progStatus.pbt_lock) {
guard_lock serial_lock(&mutex_serial, "23");
progStatus.pbt_outer = progStatus.pbt_inner;
sldrOUTER->value(progStatus.pbt_outer);
selrig->set_pbt_outer(progStatus.pbt_outer);
sldrOUTER->redraw();
}
}
void setINNER()
{
if (selrig->name_ == rig_FLEX1500.name_) {
progStatus.pbt_inner = sldrINNER->value();
selrig->set_pbt( progStatus.pbt_inner, progStatus.pbt_outer);
return;
}
progStatus.pbt_inner = sldrINNER->value();
if (progStatus.pbt_lock) {
progStatus.pbt_outer = sldrOUTER->value();
sldrOUTER->value(progStatus.pbt_outer);
sldrOUTER->redraw();
}
int ev = Fl::event();
if (ev == FL_LEAVE || ev == FL_ENTER) return;
if (ev == FL_DRAG || ev == FL_PUSH) {
inhibit_pbt = 1;
return;
}
guard_lock lock(&mutex_serial, "24");
selrig->set_pbt_inner(progStatus.pbt_inner);
selrig->get_pbt_inner();
if (progStatus.pbt_lock) {
selrig->set_pbt_outer(progStatus.pbt_outer);
selrig->get_pbt_outer();
}
}
void setOUTER()
{
if (selrig->name_ == rig_FLEX1500.name_) {
progStatus.pbt_outer = sldrOUTER->value();
selrig->set_pbt( progStatus.pbt_inner, progStatus.pbt_outer);
return;
}
progStatus.pbt_outer = sldrOUTER->value();
if (progStatus.pbt_lock) {
progStatus.pbt_inner = progStatus.pbt_outer;
sldrINNER->value(progStatus.pbt_inner);
sldrINNER->redraw();
}
int ev = Fl::event();
if (ev == FL_LEAVE || ev == FL_ENTER) return;
if (ev == FL_DRAG || ev == FL_PUSH) {
inhibit_pbt = 1;
return;
}
guard_lock lock(&mutex_serial, "25");
selrig->set_pbt_outer(progStatus.pbt_outer);
selrig->get_pbt_outer();
if (progStatus.pbt_lock) {
selrig->set_pbt_inner(progStatus.pbt_inner);
selrig->get_pbt_inner();
}
}
void setCLRPBT()
{
if (selrig->name_ == rig_FLEX1500.name_)
return;
progStatus.pbt_inner = progStatus.pbt_outer = 0;
sldrOUTER->value(0);
sldrOUTER->redraw();
sldrINNER->value(0);
sldrINNER->redraw();
guard_lock lock(&mutex_serial, "26");
selrig->set_pbt_outer(progStatus.pbt_outer);
selrig->set_pbt_inner(progStatus.pbt_inner);
}
//----------------------------------------------------------------------
// these only apply to the IC7610
//----------------------------------------------------------------------
void digi_sel_on_off()
{
selrig->set_digi_sel(progStatus.digi_sel_on_off);
}
void set_ic7610_digi_sel_on_off(void *)
{
ic7610digi_sel_on_off->value(progStatus.digi_sel_on_off);
}
void digi_sel_val()
{
selrig->set_digi_val(progStatus.digi_sel_val);
}
void set_ic7610_digi_sel_val(void *)
{
ic7610_digi_sel_val->value(progStatus.digi_sel_val);
}
void dual_watch()
{
selrig->set_dual_watch(progStatus.dual_watch);
}
void set_ic7610_dual_watch(void *)
{
}
void index_att()
{
selrig->set_index_att(progStatus.index_ic7610att);
}
//void set_ic7610_index_att(void *)
//{
// ic7610att->index(progStatus.index_ic7610att);
//}
//----------------------------------------------------------------------
void cbEventLog()
{
debug::show();
}
void setVolume() // UI call
{
trace(1, "setVolume()");
int ev = Fl::event();
if (ev == FL_LEAVE || ev == FL_ENTER) return;
int set;
if (spnrVOLUME) set = spnrVOLUME->value();
else set = sldrVOLUME->value();
progStatus.volume = set;
if (btnVol->value() == 0) return;
guard_lock serial_lock(&mutex_serial, "27");
selrig->set_volume_control(progStatus.volume);
}
void setVolumeControl(void* d) // called by xml_server
{
trace(1, "setVolumeControl()");
if (sldrVOLUME) sldrVOLUME->value(progStatus.volume);
if (spnrVOLUME) spnrVOLUME->value(progStatus.volume);
}
void cbMute()
{
guard_lock serial_lock(&mutex_serial, "28");
trace(1, "cbMute()");
int set = 0, get, cnt = 0;
if (btnVol->value() == 0) {
if (spnrVOLUME) spnrVOLUME->deactivate();
if (sldrVOLUME) sldrVOLUME->deactivate();
} else {
if (spnrVOLUME) {
spnrVOLUME->activate();
set = spnrVOLUME->value();
}
if (sldrVOLUME) {
sldrVOLUME->activate();
set = sldrVOLUME->value();
}
}
selrig->set_volume_control(set);
MilliSleep(50);
get = selrig->get_volume_control();
while (get != set && cnt++ < 10) {
MilliSleep(progStatus.serial_post_write_delay);
get = selrig->get_volume_control();
Fl::awake();
}
progStatus.volume = set;
}
void setMicGain()
{
int ev = Fl::event();
if (ev == FL_LEAVE || ev == FL_ENTER) return;
if (ev == FL_DRAG || ev == FL_PUSH) {
inhibit_mic = 1;
return;
}
std::stringstream str;
str << "setMicGain(), ev=" << ev << ", inhibit_mic=" << inhibit_mic;
trace(1, str.str().c_str());
int set = 0;
if (sldrMICGAIN) set = sldrMICGAIN->value();
if (spnrMICGAIN) set = spnrMICGAIN->value();
progStatus.mic_gain = set;
guard_lock lock(&mutex_serial, "29");
selrig->set_mic_gain(set);
}
void setMicGainControl(void* d)
{
trace(1, "setMicGainControl()");
if (sldrMICGAIN) sldrMICGAIN->value(progStatus.mic_gain);
if (spnrMICGAIN) spnrMICGAIN->value(progStatus.mic_gain);
}
static int img = -1;
void set_power_controlImage(double pwr)
{
if ((progStatus.pwr_scale == 8 && pwr <= 5.0) || (progStatus.pwr_scale == 0)) {
if (img != 1) {
img = 1;
scalePower->image(image_p5);
sldrFwdPwr->maximum(5.0);
sldrFwdPwr->minimum(0.0);
scalePower->redraw();
mtr_PWR->image(image_p5);
mtr_PWR->redraw();
sigbar_PWR->maximum(5.0);
sigbar_PWR->minimum(0.0);
sigbar_PWR->redraw();
}
}
else if ((progStatus.pwr_scale == 8 && pwr <= 10.0) || (progStatus.pwr_scale == 1)) {
if (img != 2) {
img = 2;
scalePower->image(image_p10);
sldrFwdPwr->maximum(10.0);
sldrFwdPwr->minimum(0.0);
scalePower->redraw();
mtr_PWR->image(image_p10);
mtr_PWR->redraw();
sigbar_PWR->maximum(10.0);
sigbar_PWR->minimum(0.0);
sigbar_PWR->redraw();
}
}
else if ((progStatus.pwr_scale == 8 && pwr <= 15.0) || (progStatus.pwr_scale == 2)) {
if (img != 3) {
img = 3;
scalePower->image(image_p15);
sldrFwdPwr->maximum(16.666);
sldrFwdPwr->minimum(0.0);
scalePower->redraw();
mtr_PWR->image(image_p15);
mtr_PWR->redraw();
sigbar_PWR->maximum(16.666);
sigbar_PWR->minimum(0.0);
sigbar_PWR->redraw();
}
}
else if ((progStatus.pwr_scale == 8 && pwr <= 20.0) || (progStatus.pwr_scale == 3)) {
if (img != 4) {
img = 4;
scalePower->image(image_p20);
sldrFwdPwr->maximum(20.0);
sldrFwdPwr->minimum(0.0);
scalePower->redraw();
mtr_PWR->image(image_p20);
mtr_PWR->redraw();
sigbar_PWR->maximum(20.0);
sigbar_PWR->minimum(0.0);
sigbar_PWR->redraw();
}
}
else if ((progStatus.pwr_scale == 8 && pwr <= 25.0) || (progStatus.pwr_scale == 4)) {
if (img != 5) {
img = 5;
scalePower->image(image_p25);
sldrFwdPwr->maximum(25.0);
sldrFwdPwr->minimum(0.0);
scalePower->redraw();
mtr_PWR->image(image_p25);
mtr_PWR->redraw();
sigbar_PWR->maximum(25.0);
sigbar_PWR->minimum(0.0);
sigbar_PWR->redraw();
}
}
else if ((progStatus.pwr_scale == 8 && pwr <= 50.0) || (progStatus.pwr_scale == 5)) {
if (img != 6) {
img = 6;
scalePower->image(image_p50);
sldrFwdPwr->maximum(50.0);
sldrFwdPwr->minimum(0.0);
scalePower->redraw();
mtr_PWR->image(image_p50);
mtr_PWR->redraw();
sigbar_PWR->maximum(50.0);
sigbar_PWR->minimum(0.0);
sigbar_PWR->redraw();
}
}
else if ((progStatus.pwr_scale == 8 && pwr <= 100.0) || (progStatus.pwr_scale == 6)) {
if (img != 6) {
img = 6;
scalePower->image(image_p100);
sldrFwdPwr->maximum(100.0);
sldrFwdPwr->minimum(0.0);
scalePower->redraw();
mtr_PWR->image(image_p100);
mtr_PWR->redraw();
sigbar_PWR->maximum(100.0);
sigbar_PWR->minimum(0.0);
sigbar_PWR->redraw();
}
}
else if ((progStatus.pwr_scale == 8 && pwr > 100.0) || (progStatus.pwr_scale == 7)) {
if (img != 8) {
img = 8;
scalePower->image(image_p200);
sldrFwdPwr->maximum(200.0);
sldrFwdPwr->minimum(0.0);
scalePower->redraw();
mtr_PWR->image(image_p200);
mtr_PWR->redraw();
sigbar_PWR->maximum(200.0);
sigbar_PWR->minimum(0.0);
sigbar_PWR->redraw();
}
}
return;
}
void set_init_power_control();
void execute_setPower()
{
double set = 0;
if (spnrPOWER) set = progStatus.power_level = spnrPOWER->value();
if (sldrPOWER) set = progStatus.power_level = sldrPOWER->value();
double min, max, step;
selrig->get_pc_min_max_step(min, max, step);
if (xcvr_name == rig_K2.name_) {
if (spnrPOWER) spnrPOWER->minimum(min);
if (spnrPOWER) spnrPOWER->maximum(max);
if (spnrPOWER) spnrPOWER->step(step);
if (spnrPOWER) spnrPOWER->value(progStatus.power_level);
if (spnrPOWER) spnrPOWER->redraw();
if (sldrPOWER) sldrPOWER->minimum(min);
if (sldrPOWER) sldrPOWER->maximum(max);
if (sldrPOWER) sldrPOWER->step(step);
if (sldrPOWER) sldrPOWER->value(progStatus.power_level);
if (sldrPOWER) sldrPOWER->redraw();
}
if (progStatus.enable_power_limit && (set > progStatus.power_limit * max / 100)) {
set = progStatus.power_limit * max / 100;
if (spnrPOWER) spnrPOWER->value(set);
if (sldrPOWER) sldrPOWER->value(set);
}
guard_lock lock(&mutex_serial, "30");
selrig->set_power_control(set);
set_init_power_control();
}
void setPower()
{
int ev = Fl::event();
if (ev == FL_LEAVE || ev == FL_ENTER) return;
if (ev == FL_DRAG || ev == FL_PUSH) {
inhibit_power = 1;
return;
}
std::stringstream str;
str << "setPower(), ev=" << ev << ", inhibit_power=" << inhibit_power;
trace(1, str.str().c_str());
execute_setPower();
}
void cbTune()
{
guard_lock serial_lock(&mutex_serial, "31");
trace(1, "cbTune()");
selrig->tune_rig(2);
}
void cb_tune_on_off()
{
guard_lock serial_lock(&mutex_serial, "32");
trace(1, "cb_tune_on_off()");
selrig->tune_rig(btn_tune_on_off->value());
}
int chkptt()
{
if (progStatus.serial_catptt) {
return selrig->get_PTT();
} else if (progStatus.serial_dtrptt) {
return RigSerial->getPTT();
} else if (progStatus.serial_rtsptt) {
return RigSerial->getPTT();
} else if (SepSerial->IsOpen() && progStatus.sep_dtrptt) {
return SepSerial->getPTT();
} else if (SepSerial->IsOpen() && progStatus.sep_rtsptt) {
return SepSerial->getPTT();
} else if (progStatus.gpio_ptt) {
return get_gpio();
} else if (progStatus.cmedia_ptt) {
return get_cmedia();
}
return 0;
}
void doPTT(int on)
{
guard_lock serlck(&mutex_serial, "33");
// int chk = chkptt();
// if (chk == on) return;
PTT = on;
rigPTT(on);
btnPTT->value(on);
MilliSleep(progStatus.serial_post_write_delay);
for (int n = 0; n < 100; n++) {
if (on == chkptt()) break;
MilliSleep(progStatus.serial_post_write_delay);
Fl::awake();
}
return;
}
void setSQUELCH()
{
trace(1, "setSQUELCH()");
int ev = Fl::event();
if (ev == FL_LEAVE || ev == FL_ENTER) return;
if (ev == FL_DRAG || ev == FL_PUSH) {
inhibit_squelch = 1;
return;
}
int set = 0;
if (sldrSQUELCH) set = sldrSQUELCH->value();
if (spnrSQUELCH) set = spnrSQUELCH->value();
progStatus.squelch = set;
guard_lock lock(&mutex_serial, "34");
selrig->set_squelch(set);
}
int agcwas = 0;
void redrawAGC()
{
const char *lbl = selrig->agc_label();
int val = progStatus.agc_level;
if (!selrig->has_rf_control) {
sldrSQUELCH->label("");
sldrSQUELCH->redraw_label();
}
btnAGC->label(lbl);
btnAGC->redraw_label();
if (xcvr_name == rig_FT450D.name_) {
switch (val) {
case 0 : btnAGC->selection_color(FL_BACKGROUND_COLOR); // off
break;
case 1 : btnAGC->selection_color(FL_RED); // fast
break;
case 2 : btnAGC->selection_color(FL_YELLOW); // slow
break;
case 3 : btnAGC->selection_color(FL_GREEN); // auto
break;
}
btnAGC->redraw();
}
if (xcvr_name == rig_FT991A.name_) {
switch (val) {
case 0 : btnAGC->selection_color(FL_BACKGROUND_COLOR); // off
break;
case 1 : btnAGC->selection_color(FL_RED); // fast
break;
case 2 : btnAGC->selection_color(FL_YELLOW); // medium
break;
case 3 : btnAGC->selection_color(FL_GREEN); // slow
break;
case 4 : btnAGC->selection_color(FL_WHITE); // auto
}
btnAGC->redraw();
}
int rignbr = 0;
if (xcvr_name == rig_IC7200.name_) rignbr = 1;
if (xcvr_name == rig_IC7300.name_) rignbr = 2;
if (rignbr) {
if (val == 0) btnAGC->selection_color(FL_BACKGROUND_COLOR); // off
if (val == 1) btnAGC->selection_color(
rignbr == 1 ? FL_GREEN : FL_RED); // fast
if (val == 2) btnAGC->selection_color(
rignbr == 1 ? FL_RED : FL_YELLOW); // med / slow
if (val == 3) btnAGC->selection_color(FL_GREEN); // slow
btnAGC->value(val > 0);
} else {
if (val == 0)
btnAGC->value(0);
else
btnAGC->value(1);
}
if (agcwas != val) {
agcwas = val;
}
btnAGC->redraw();
}
void setAGC(void *)
{
if (!selrig->has_agc_control) return;
redrawAGC();
}
void cbAGC()
{
if (!selrig->has_agc_control) return;
guard_lock serial_lock(&mutex_serial, "35");
trace(1, "cbAGC()");
progStatus.agc_level = selrig->incr_agc();
redrawAGC();
}
void setRFGAIN()
{
trace(1, "setRFGAIN()");
int ev = Fl::event();
if (ev == FL_LEAVE || ev == FL_ENTER) return;
if (ev == FL_DRAG || ev == FL_PUSH) {
inhibit_rfgain = 1;
return;
}
int set = 0;
if (spnrRFGAIN) set = spnrRFGAIN->value();
if (sldrRFGAIN) set = sldrRFGAIN->value();
progStatus.rfgain = set;
guard_lock lock(&mutex_serial, "36");
selrig->set_rf_gain(set);
}
void setRFGAINControl(void* d)
{
trace(1, "setRFGAINControl()");
if (sldrRFGAIN) sldrRFGAIN->value(progStatus.rfgain);
if (spnrRFGAIN) spnrRFGAIN->value(progStatus.rfgain);
}
void updateIDD(void *)
{
sigbar_IDD->value(iddval);
sigbar_IDD->redraw();
if (meter_image != IDD_IMAGE) return;
sldrRcvSignal->hide();
sldrSWR->hide();
sldrALC->hide();
sldrIDD->show();
sldrIDD->value(iddval);
sldrIDD->redraw();
}
void updateALC(void *)
{
sigbar_ALC->value(alcval);
sigbar_ALC->redraw();
if (meter_image != ALC_IMAGE) return;
sldrRcvSignal->hide();
sldrSWR->hide();
sldrIDD->hide();
sldrALC->show();
sldrALC->value(alcval);
sldrALC->redraw();
}
void updateSWR(void *)
{
sigbar_SWR->value(swrval);
sigbar_SWR->redraw();
if (meter_image != SWR_IMAGE) return;
if (selrig->has_swr_control) {
sldrRcvSignal->hide();
sldrALC->hide();
sldrIDD->hide();
sldrSWR->show();
}
sldrSWR->value(swrval);
sldrSWR->redraw();
}
void updateFwdPwr(void *)
{
double power = pwrval;
power /= selrig->power_scale();
if (selrig->has_power_control)
set_power_controlImage(power);
if (selrig->has_power_out) {
sldrVoltage->hide();
scaleVoltage->hide();
sldrFwdPwr->show();
scalePower->show();
sldrFwdPwr->value(power);
sldrFwdPwr->redraw();
sigbar_PWR->value(power);
sigbar_PWR->redraw();
}
}
void updateSquelch(void *d)
{
if (sldrSQUELCH) sldrSQUELCH->value(reinterpret_cast(d));
if (sldrSQUELCH) sldrSQUELCH->redraw();
if (spnrSQUELCH) spnrSQUELCH->value(reinterpret_cast(d));
if (spnrSQUELCH) spnrSQUELCH->redraw();
}
void updateRFgain(void *d)
{
if (spnrRFGAIN) {
spnrRFGAIN->value(reinterpret_cast(d));
spnrRFGAIN->redraw();
}
if (sldrRFGAIN) {
sldrRFGAIN->value(reinterpret_cast(d));
sldrRFGAIN->redraw();
}
}
void zeroXmtMeters(void *d)
{
pwrval = 0; updateFwdPwr();
alcval = 0; updateALC();
swrval = 0; updateSWR();
iddval = 0; updateIDD();
sldrFwdPwr->clear();
sldrALC->clear();
sldrSWR->clear();
sigbar_IDD->value(0);
sigbar_IDD->redraw();
sldrIDD->value(0);
sldrIDD->redraw();
}
void setFreqDispA(void *d)
{
FreqDispA->value(vfoA.freq);
FreqDispA->redraw();
}
void setFreqDispB(void *d)
{
FreqDispB->value(vfoB.freq);
FreqDispB->redraw();
}
void updateSmeter(void *)
{
if (!sldrRcvSignal->visible()) {
sldrRcvSignal->show();
sldrFwdPwr->hide();
sldrALC->hide();
sldrSWR->hide();
}
sldrRcvSignal->value(smtrval);
sldrRcvSignal->redraw();
sigbar_SMETER->value(smtrval);
sigbar_SMETER->redraw();
}
void updateVmeter(void *)
{
if (!progStatus.display_voltmeter || !selrig->has_voltmeter) {
sldrVoltage->hide();
scaleVoltage->hide();
if (selrig->has_power_out) {
sldrFwdPwr->show();
scalePower->show();
}
} else {
if (PTT) {
if (selrig->has_power_out) {
sldrVoltage->hide();
scaleVoltage->hide();
sldrFwdPwr->show();
scalePower->show();
}
} else {
if (selrig->has_power_out) {
sldrFwdPwr->hide();
scalePower->hide();
sldrVoltage->show();
scaleVoltage->show();
}
}
}
if (vmtrval == -1) return;
sldrVoltage->value(vmtrval);
sldrVoltage->redraw();
sigbar_VOLTS->value(vmtrval);
sigbar_VOLTS->redraw();
}
void TRACED(saveFreqList)
std::string atag;
if (!numinlist) return;
rotate_log(defFileName);
std::ofstream oList(defFileName.c_str());
if (!oList) {
fl_message ("Could not write to %s", defFileName.c_str());
return;
}
for (int i = 0; i < numinlist; i++) {
atag = oplist[i].alpha_tag;
oList << oplist[i].freq << " " << oplist[i].imode << " " << oplist[i].iBW << " \"" << atag.c_str() << "\"" << std::endl;
}
oList.close();
}
void TRACED(setPTT, void *d)
size_t set = reinterpret_cast(d);
size_t chk = 0;
guard_lock serlck(&mutex_serial, "37");
chk = chkptt();
rigPTT(set);
MilliSleep(50);
for (int n = 0; n < 100; n++) {
chk = chkptt();
if (set == chk) break;
MilliSleep(progStatus.serial_post_write_delay);
}
return;
}
void update_progress(int val)
{
progress->value(val);
Fl::check();
}
void TRACED(send_st_ex_command, std::string command)
std::string cmd = "";
if (command.find("x") != std::string::npos) { // hex std::strings
size_t p = 0;
unsigned int val;
while (( p = command.find("x", p)) != std::string::npos) {
sscanf(&command[p+1], "%x", &val);
cmd += (unsigned char) val;
p += 3;
}
} else
cmd = command;
sendCommand(cmd, 0);
}
#include "timeops.h"
void synchronize( void *) {
time_t now;
time(&now);
struct tm *tm_time;
static char sztm[20];
if (progStatus.sync_gmt) {
tm_time = gmtime(&now);
strftime(sztm, sizeof(sztm), "%H:%M:%S Z", tm_time);
} else {
tm_time = localtime(&now);
strftime(sztm, sizeof(sztm), "%H:%M:%S", tm_time);
}
if (strncmp(&sztm[6], "00", 2) == 0) {
guard_lock serial_lock(&mutex_serial, "38");
static char szdate[20];
strftime(szdate, sizeof(szdate), "%Y%m%d", tm_time);
selrig->sync_clock(sztm);
selrig->sync_date(szdate);
txt_xcvr_synch->value("--SYNC'D--");
return;
}
txt_xcvr_synch->value(sztm);
Fl::repeat_timeout(0.05, synchronize);
}
void TRACED(synchronize_now)
Fl::remove_timeout(synchronize);
Fl::add_timeout(0, synchronize);
}
void TRACED(start_commands)
if (!progStatus.cmd_on_start1.empty()) send_st_ex_command(progStatus.cmd_on_start1);
if (!progStatus.cmd_on_start2.empty()) send_st_ex_command(progStatus.cmd_on_start2);
if (!progStatus.cmd_on_start3.empty()) send_st_ex_command(progStatus.cmd_on_start3);
if (!progStatus.cmd_on_start4.empty()) send_st_ex_command(progStatus.cmd_on_start4);
if (progStatus.sync_clock && selrig->can_synch_clock)
Fl::add_timeout(0, synchronize);
}
void TRACED(exit_commands)
if (!progStatus.cmd_on_exit1.empty()) send_st_ex_command(progStatus.cmd_on_exit1);
if (!progStatus.cmd_on_exit2.empty()) send_st_ex_command(progStatus.cmd_on_exit2);
if (!progStatus.cmd_on_exit3.empty()) send_st_ex_command(progStatus.cmd_on_exit3);
if (!progStatus.cmd_on_exit4.empty()) send_st_ex_command(progStatus.cmd_on_exit4);
}
void TRACED(close_UI)
{
guard_lock serial_lock(&mutex_serial, "39");
trace(1, "close_UI()");
run_serial_thread = false;
}
pthread_join(*serial_thread, NULL);
// xcvr auto off
if (selrig->has_xcvr_auto_on_off && progStatus.xcvr_auto_off)
selrig->set_xcvr_auto_off();
// close down the serial port
RigSerial->ClosePort();
debug::stop();
Fl_Double_Window *widgets[] = {
dlgDisplayConfig,
dlgXcvrConfig,
dlgMemoryDialog,
meters_dialog,
tracewindow,
cwio_keyer_dialog,
cwio_editor,
cwio_configure,
cwlog_viewer,
FSK_keyer_dialog,
FSK_editor,
FSK_configure,
meter_filters,
meter_scale_dialog,
tabs_dialog,
mainwindow };
for (size_t n = 0; n < sizeof(widgets) / sizeof(*widgets); n++) {
if (widgets[n]) widgets[n]->hide();
}
}
void TRACED(closeRig)
trace(1, "closeRig()");
if (selrig->io_class == TCI) {
restore_xcvr_vals();
selrig->shutdown();
}
else if (xcvr_online) {
restore_xcvr_vals();
selrig->shutdown();
}
xcvr_online = false;
}
void TRACED(cbExit)
main_group->hide();
main_group->redraw();
grpInitializing->size(mainwindow->w(), mainwindow->h() - grpInitializing->y());
grpInitializing->show();
grpInitializing->redraw();
progress->label("Closing");
progress->redraw_label();
progress->position(grpInitializing->w()/4, grpInitializing->y() + grpInitializing->h()/2);
update_progress(0);
progStatus.freq_A = vfoA.freq;
progStatus.imode_A = vfoA.imode;
progStatus.iBW_A = vfoA.iBW;
progStatus.freq_B = vfoB.freq;
progStatus.imode_B = vfoB.imode;
progStatus.iBW_B = vfoB.iBW;
if (selrig->has_FILTER)
progStatus.filters = selrig->get_FILTERS();
progStatus.spkr_on = btnVol->value();
saveFreqList();
cwlog_close();
if (spnrPOWER) progStatus.power_level = spnrPOWER->value();
if (spnrVOLUME) progStatus.volume = spnrVOLUME->value();
if (spnrRFGAIN) progStatus.rfgain = spnrRFGAIN->value();
if (spnrMICGAIN) progStatus.mic_gain = spnrMICGAIN->value();
if (spnrNOTCH) progStatus.notch_val = spnrNOTCH->value();
if (spnrIFSHIFT) progStatus.shift_val = spnrIFSHIFT->value();
if (spnrNR) progStatus.noise_reduction_val = spnrNR->value();
if (sldrPOWER) progStatus.power_level = sldrPOWER->value();
if (sldrVOLUME) progStatus.volume = sldrVOLUME->value();
if (sldrRFGAIN) progStatus.rfgain = sldrRFGAIN->value();
if (sldrMICGAIN) progStatus.mic_gain = sldrMICGAIN->value();
if (sldrNOTCH) progStatus.notch_val = sldrNOTCH->value();
if (sldrIFSHIFT) progStatus.shift_val = sldrIFSHIFT->value();
if (sldrNR) progStatus.noise_reduction_val = sldrNR->value();
progStatus.notch = btnNotch->value();
progStatus.shift = btnIFsh->value();
progStatus.noise_reduction = btnNR->value();
progStatus.noise = btnNOISE->value();
progStatus.attenuator = btnAttenuator->value();
progStatus.preamp = btnPreamp->value();
progStatus.auto_notch = btnAutoNotch->value();
progStatus.bandwidths = selrig->get_BANDWIDTHS();
progStatus.saveLastState();
closeRig();
stop_cwio_thread();
exit_server();
close_UI();
}
void cbALC_IDD_SWR()
{
switch (meter_image) {
case ALC_IMAGE:
if (selrig->has_idd_control) {
btnALC_IDD_SWR->image(image_idd25);
meter_image = IDD_IMAGE;
sldrIDD->show();
{
guard_lock serial_lock(&mutex_serial, "40");
trace(1, "cbALC_IDD_SWR() 2");
selrig->select_idd();
}
break;
}
case IDD_IMAGE:
if (selrig->has_swr_control) {
btnALC_IDD_SWR->image(image_swr);
meter_image = SWR_IMAGE;
sldrSWR->show();
{
guard_lock serial_lock(&mutex_serial, "41");
trace(1, "cbALC_IDD_SWR() 2");
selrig->select_swr();
}
break;
}
case SWR_IMAGE:
default:
if (selrig->has_alc_control) {
if (selrig->name_ == rig_PowerSDR.name_) {
btnALC_IDD_SWR->image(image_alc40db);
}
else {
btnALC_IDD_SWR->image(image_alc);
}
meter_image = ALC_IMAGE;
sldrALC->show();
{
guard_lock serial_lock(&mutex_serial, "42");
trace(1, "cbALC_IDD_SWR() 1");
selrig->select_alc();
}
}
}
btnALC_IDD_SWR->redraw();
}
// trim leading and trailing whitspace and double quote
const std::string lt_trim(const std::string& pstring, const std::string& pWhitespace)
{
size_t beginStr, endStr, range;
beginStr = pstring.find_first_not_of(pWhitespace);
if (beginStr == std::string::npos) return ""; // no content
endStr = pstring.find_last_not_of(pWhitespace);
range = endStr - beginStr + 1;
return pstring.substr(beginStr, range);
}
void editAlphaTag()
{
int indx;
std::string atag;
if (FreqSelect->value() < 1) {
inAlphaTag->value("");
return; // no memory selected
}
indx = FreqSelect->value() - 1;
atag = inAlphaTag->value();
// delete leading, trailing spaces
atag = lt_trim(atag);
memset(oplist[indx].alpha_tag, 0, ATAGSIZE);
snprintf(oplist[indx].alpha_tag, ATAGSIZE, "%s", atag.c_str());
// update browser list
updateSelect();
FreqSelect->value(indx + 1);
inAlphaTag->value(oplist[indx].alpha_tag);
}
//----------------------------------------------------------------------
// button label and label state changes
// Note that an additional level of service request is made to insure
// that the main thread is actually changing the widget
// noise reduction
static std::string nr_label_;
static bool nr_state_;
void do_nr_label(void *)
{
btnNR->value(nr_state_ ? 1 : 0);
btnNR->label(nr_label_.c_str());
btnNR->redraw_label();
}
void nr_label(const char *l, int on)
{
nr_label_ = l;
nr_state_ = on;
progStatus.noise_reduction = on;
Fl::awake(do_nr_label);
}
// noise blanker
static std::string nb_label_;
static bool nb_state_;
void do_nb_label(void *)
{
btnNOISE->value(nb_state_ ? 1 : 0);
btnNOISE->label(nb_label_.c_str());
btnNOISE->redraw_label();
}
void nb_label(const char * l, int on)
{
nb_label_ = l;
nb_state_ = on;
progStatus.noise = on;
Fl::awake(do_nb_label);
}
// break-in label
static std::string bkin_label_;
void do_bkin_label(void *)
{
btnBreakIn->label(bkin_label_.c_str());
btnBreakIn->redraw_label();
}
void break_in_label(const char *l)
{
bkin_label_ = l;
Fl::awake(do_bkin_label);
}
// autonotch label
static std::string auto_notch_label_;
static bool auto_notch_state_;
void do_auto_notch_label(void *)
{
btnAutoNotch->value(auto_notch_state_ ? 1 : 0);
btnAutoNotch->label(auto_notch_label_.c_str());
btnAutoNotch->redraw_label();
}
void auto_notch_label(const char * l, int on)
{
auto_notch_label_ = l;
auto_notch_state_ = on;
progStatus.auto_notch = on;
Fl::awake(do_auto_notch_label);
}
void cbAuxPort()
{
AuxSerial->setRTS(progStatus.aux_rts);
AuxSerial->setDTR(progStatus.aux_dtr);
}
void cb_agc_level()
{
guard_lock serial_lock(&mutex_serial, "43");
trace(1, "cb_agc_level()");
selrig->set_agc_level();
}
void cb_cw_wpm()
{
guard_lock serial_lock(&mutex_serial, "44");
trace(1, "cb_cw_wpm()");
selrig->set_cw_wpm();
}
void cb_cw_vol()
{
guard_lock serial_lock(&mutex_serial, "45");
trace(1, "cb_cw_vol()");
selrig->set_cw_vol();
}
void cb_cw_spot()
{
int ret;
guard_lock serial_lock(&mutex_serial, "46");
trace(1, "cb_cw_spot()");
ret = selrig->set_cw_spot();
if (!ret) btnSpot->value(0);
}
void cb_cw_spot_tone()
{
guard_lock serial_lock(&mutex_serial, "47");
trace(1, "cb_cw_spot_tone()");
selrig->set_cw_spot_tone();
}
void cb_vox_gain()
{
guard_lock serial_lock(&mutex_serial, "48");
trace(1, "cb_vox_gain()");
selrig->set_vox_gain();
}
void cb_vox_anti()
{
guard_lock serial_lock(&mutex_serial, "49");
trace(1, "cb_vox_anti()");
selrig->set_vox_anti();
}
void cb_vox_hang()
{
guard_lock serial_lock(&mutex_serial, "50");
trace(1, "cb_vox_hang()");
selrig->set_vox_hang();
}
void cb_vox_onoff()
{
guard_lock serial_lock(&mutex_serial, "51");
trace(1, "cb_vox_onoff()");
selrig->set_vox_onoff();
}
void cb_vox_on_dataport()
{
guard_lock serial_lock(&mutex_serial, "52");
trace(1, "cb_dataport()");
selrig->set_vox_on_dataport();
}
void cb_compression()
{
guard_lock serial_lock(&mutex_serial, "53");
trace(1, "cb_compression");
selrig->set_compression(progStatus.compON, progStatus.compression);
}
void cb_auto_notch()
{
progStatus.auto_notch = btnAutoNotch->value();
guard_lock serial_lock(&mutex_serial, "54");
trace(1, "cb_autonotch()");
selrig->set_auto_notch(progStatus.auto_notch);
}
void cb_vfo_adj()
{
if (xcvr_name == rig_TT550.name_)
progStatus.vfo_adj = spnr_tt550_vfo_adj->value();
else
progStatus.vfo_adj = spnr_vfo_adj->value();
guard_lock serial_lock(&mutex_serial, "55");
trace(1, "cb_vfo_adj()");
selrig->setVfoAdj(progStatus.vfo_adj);
}
void cb_line_out()
{
}
void cb_bpf_center()
{
guard_lock serial_lock(&mutex_serial, "56");
trace(1, "cb_bpf_center()");
selrig->set_if_shift(selrig->pbt);
}
void cb_special()
{
guard_lock serial_lock(&mutex_serial, "57");
trace(1, "cb_special()");
selrig->set_special(btnSpecial->value());
}
void cbNoise()
{
guard_lock serial_lock(&mutex_serial, "58");
trace(1, "cbNoise()");
int btn, get, cnt = 0;
btn = progStatus.noise = btnNOISE->value();
selrig->set_noise(btn);
MilliSleep(50);
get = selrig->get_noise();
while ((get != btn) && (cnt++ < 10)) {
MilliSleep(progStatus.serial_post_write_delay);
get = selrig->get_noise();
Fl::awake();
}
}
void cb_nb_level()
{
if (!selrig->has_nb_level) return;
int set = 0;
trace(1, "cb_nb_level()");
int ev = Fl::event();
if (ev == FL_LEAVE || ev == FL_ENTER) return;
if (ev == FL_DRAG || ev == FL_PUSH) {
inhibit_nb_level = 1;
return;
}
set = sldr_nb_level->value();
guard_lock lock(&mutex_serial, "59");
selrig->set_nb_level(set);
}
void cbNR()
{
if (!selrig->has_noise_reduction_control) return;
guard_lock serial_lock(&mutex_serial, "60");
trace(1, "cbNR()");
int btn = 0, set = 0, get, cnt = 0;
if (sldrNR) {
set = sldrNR->value();
btn = btnNR->value();
}
if (spnrNR) {
set = spnrNR->value();
btn = btnNR->value();
}
if (xcvr_name == rig_TS2000.name_) {
if (btn != -1) { // pia
if (selrig->noise_reduction_level() == 0) {
selrig->set_noise_reduction(1);
selrig->set_noise_reduction_val(selrig->nrval1());
progStatus.noise_reduction = 1;
progStatus.noise_reduction_val = selrig->nrval1();
} else if (selrig->currmode() != RIG_TS2000::FM &&
selrig->noise_reduction_level() == 1) {
selrig->set_noise_reduction(2);
selrig->set_noise_reduction_val(selrig->nrval2());
progStatus.noise_reduction = 2;
progStatus.noise_reduction_val = selrig->nrval2();
} else
selrig->set_noise_reduction(0);
} else {
progStatus.noise_reduction_val = set;
selrig->set_noise_reduction_val(set);
}
} else { // not TS2000
progStatus.noise_reduction = btn;
selrig->set_noise_reduction(btn);
MilliSleep(50);
get = selrig->get_noise_reduction();
while ((get != btn) && (cnt++ < 10)) {
MilliSleep(progStatus.serial_post_write_delay);
get = selrig->get_noise_reduction();
Fl::awake();
}
progStatus.noise_reduction_val = set;
selrig->set_noise_reduction_val(set);
MilliSleep(50);
get = selrig->get_noise_reduction_val();
cnt = 0;
while ((get != set) && (cnt++ < 10)) {
MilliSleep(progStatus.serial_post_write_delay);
get = selrig->get_noise_reduction_val();
Fl::awake();
}
}
}
void setNR()
{
if (!selrig->has_noise_reduction_control) return;
trace(1, "setNR()");
int btn = 0, set = 0;
int ev = Fl::event();
if (ev == FL_LEAVE || ev == FL_ENTER) return;
if (ev == FL_DRAG || ev == FL_PUSH) {
inhibit_nr = 1;
return;
}
if (xcvr_name == rig_TS2000.name_ ||
xcvr_name == rig_TS590S.name_ ||
xcvr_name == rig_TS590SG.name_ ||
xcvr_name == rig_TS890S.name_ ||
xcvr_name == rig_TS990.name_) {
if (sldrNR) {
set = sldrNR->value();
btn = -1;
}
if (spnrNR) {
set = spnrNR->value();
btn = -1;
}
} else {
if (sldrNR) {
set = sldrNR->value();
btn = btnNR->value();
}
if (spnrNR) {
set = spnrNR->value();
btn = btnNR->value();
}
}
guard_lock lock(&mutex_serial, "61");
selrig->set_noise_reduction_val(set);
selrig->set_noise_reduction(btn);
}
void cb_spot()
{
guard_lock serial_lock(&mutex_serial, "62");
trace(1, "cb_spot()");
selrig->set_cw_spot();
}
void cb_enable_keyer()
{
guard_lock serial_lock(&mutex_serial, "63");
trace(1, "cb_enable_keyer()");
selrig->enable_keyer();
}
void cb_set_break_in()
{
guard_lock serial_lock(&mutex_serial, "64");
trace(1, "cb_set_break_in()");
selrig->set_break_in();
}
void cb_cw_weight()
{
guard_lock serial_lock(&mutex_serial, "65");
trace(1, "cb_cw_weight()");
selrig->set_cw_weight();
}
void cb_cw_qsk()
{
guard_lock serial_lock(&mutex_serial, "66");
trace(1, "cb_cw_qsk()");
selrig->set_cw_qsk();
}
void cb_cw_delay()
{
guard_lock serial_lock(&mutex_serial, "67");
trace(1, "cb_cw_delay()");
selrig->set_cw_delay();
}
void set_band_label(int band)
{
switch (band) {
case 1:
break;
case 2:
break;
case 3:
break;
case 4:
break;
case 5:
break;
case 6:
break;
case 7:
break;
case 8:
break;
case 9:
break;
case 10:
break;
case 11:
break;
case 12:
break;
case 13:
break;
}
}
void set_band(int band)
{
switch (band) {
case 1: progStatus.f160 = vfo->freq;
progStatus.m160 = vfo->imode;
progStatus.txT_160 = choice_FT8n_tTONE->value();
progStatus.rxT_160 = choice_FT8n_rTONE->value();
progStatus.offset_160 = FMoffset->index();
progStatus.oF_160 = FMoff_freq->value();
break; // 160 meters
case 2: progStatus.f80 = vfo->freq;
progStatus.m80 = vfo->imode;
progStatus.txT_80 = choice_FT8n_tTONE->value();
progStatus.rxT_80 = choice_FT8n_rTONE->value();
progStatus.offset_80 = FMoffset->index();
progStatus.oF_80 = FMoff_freq->value();
break; // 80 meters
case 3: progStatus.f40 = vfo->freq;
progStatus.m40 = vfo->imode;
progStatus.txT_40 = choice_FT8n_tTONE->value();
progStatus.rxT_40 = choice_FT8n_rTONE->value();
progStatus.offset_40 = FMoffset->index();
progStatus.oF_40 = FMoff_freq->value();
break; // 40 meters
case 4: progStatus.f30 = vfo->freq;
progStatus.m30 = vfo->imode;
progStatus.txT_30 = choice_FT8n_tTONE->value();
progStatus.rxT_30 = choice_FT8n_rTONE->value();
progStatus.offset_30 = FMoffset->index();
progStatus.oF_30 = FMoff_freq->value();
break; // 30 meters
case 5: progStatus.f20 = vfo->freq;
progStatus.m20 = vfo->imode;
progStatus.txT_20 = choice_FT8n_tTONE->value();
progStatus.rxT_20 = choice_FT8n_rTONE->value();
progStatus.offset_20 = FMoffset->index();
progStatus.oF_20 = FMoff_freq->value();
break; // 20 meters
case 6: progStatus.f17 = vfo->freq;
progStatus.m17 = vfo->imode;
progStatus.txT_17 = choice_FT8n_tTONE->value();
progStatus.rxT_17 = choice_FT8n_rTONE->value();
progStatus.offset_17 = FMoffset->index();
progStatus.oF_17 = FMoff_freq->value();
break; // 17 meters
case 7: progStatus.f15 = vfo->freq;
progStatus.m15 = vfo->imode;
progStatus.txT_15 = choice_FT8n_tTONE->value();
progStatus.rxT_15 = choice_FT8n_rTONE->value();
progStatus.offset_15 = FMoffset->index();
progStatus.oF_15 = FMoff_freq->value();
break; // 15 meters
case 8: progStatus.f12 = vfo->freq;
progStatus.m12 = vfo->imode;
progStatus.txT_12 = choice_FT8n_tTONE->value();
progStatus.rxT_12 = choice_FT8n_rTONE->value();
progStatus.offset_12 = FMoffset->index();
progStatus.oF_12 = FMoff_freq->value();
break; // 12 meters
case 9: progStatus.f10 = vfo->freq;
progStatus.m10 = vfo->imode;
progStatus.txT_10 = choice_FT8n_tTONE->value();
progStatus.rxT_10 = choice_FT8n_rTONE->value();
progStatus.offset_10 = FMoffset->index();
progStatus.oF_10 = FMoff_freq->value();
break; // 10 meters
case 10:progStatus.f6 = vfo->freq;
progStatus.m6 = vfo->imode;
progStatus.txT_6 = choice_FT8n_tTONE->value();
progStatus.rxT_6 = choice_FT8n_rTONE->value();
progStatus.offset_6 = FMoffset->index();
progStatus.oF_6 = FMoff_freq->value();
break; // 6 meters
case 11:progStatus.f2 = vfo->freq;
progStatus.m2 = vfo->imode;
progStatus.txT_2 = choice_FT8n_tTONE->value();
progStatus.rxT_2 = choice_FT8n_rTONE->value();
progStatus.offset_2 = FMoffset->index();
progStatus.oF_2 = FMoff_freq->value();
break; // 2 meters
case 12:progStatus.f70 = vfo->freq;
progStatus.m70 = vfo->imode;
progStatus.txT_70 = choice_FT8n_tTONE->value();
progStatus.rxT_70 = choice_FT8n_rTONE->value();
progStatus.offset_70 = FMoffset->index();
progStatus.oF_70 = FMoff_freq->value();
break; // 70 cent'
case 13:progStatus.f12G = vfo->freq;
progStatus.m12G = vfo->imode;
progStatus.txT_12G = choice_FT8n_tTONE->value();
progStatus.rxT_12G = choice_FT8n_rTONE->value();
progStatus.offset_12G = FMoffset->index();
progStatus.oF_12G = FMoff_freq->value();
break; // 1.2 GHz cent'
}
}
void updateCTCSS(int band)
{
switch (band) {
case 1: choice_FT8n_tTONE->value(progStatus.txT_160);
choice_FT8n_rTONE->value(progStatus.txT_160);
FMoffset->index(progStatus.offset_160);
FMoff_freq->value(progStatus.oF_160 );
break; // 160 meters
case 2: choice_FT8n_tTONE->value(progStatus.txT_80);
choice_FT8n_rTONE->value(progStatus.txT_80);
FMoffset->index(progStatus.offset_80);
FMoff_freq->value(progStatus.oF_80 );
break; // 80 meters
case 3: choice_FT8n_tTONE->value(progStatus.txT_40);
choice_FT8n_rTONE->value(progStatus.txT_40);
FMoffset->index(progStatus.offset_40);
FMoff_freq->value(progStatus.oF_40 );
break; // 40 meters
case 4: choice_FT8n_tTONE->value(progStatus.txT_30);
choice_FT8n_rTONE->value(progStatus.txT_30);
FMoffset->index(progStatus.offset_30);
FMoff_freq->value(progStatus.oF_30 );
break; // 30 meters
case 5: choice_FT8n_tTONE->value(progStatus.txT_20);
choice_FT8n_rTONE->value(progStatus.txT_20);
FMoffset->index(progStatus.offset_20);
FMoff_freq->value(progStatus.oF_20 );
break; // 20 meters
case 6: choice_FT8n_tTONE->value(progStatus.txT_17);
choice_FT8n_rTONE->value(progStatus.txT_17);
FMoffset->index(progStatus.offset_17);
FMoff_freq->value(progStatus.oF_17 );
break; // 17 meters
case 7: choice_FT8n_tTONE->value(progStatus.txT_15);
choice_FT8n_rTONE->value(progStatus.txT_15);
FMoffset->index(progStatus.offset_15);
FMoff_freq->value(progStatus.oF_15 );
break; // 15 meters
case 8: choice_FT8n_tTONE->value(progStatus.txT_12);
choice_FT8n_rTONE->value(progStatus.txT_12);
FMoffset->index(progStatus.offset_12);
FMoff_freq->value(progStatus.oF_12 );
break; // 12 meters
case 9: choice_FT8n_tTONE->value(progStatus.txT_10);
choice_FT8n_rTONE->value(progStatus.txT_10);
FMoffset->index(progStatus.offset_10);
FMoff_freq->value(progStatus.oF_10 );
break; // 10 meters
case 10:choice_FT8n_tTONE->value(progStatus.txT_6);
choice_FT8n_rTONE->value(progStatus.txT_6);
FMoffset->index(progStatus.offset_6);
FMoff_freq->value(progStatus.oF_6 );
break; // 6 meters
case 11:choice_FT8n_tTONE->value(progStatus.txT_2);
choice_FT8n_rTONE->value(progStatus.txT_2);
FMoffset->index(progStatus.offset_2);
FMoff_freq->value(progStatus.oF_2 );
break; // 2 meters
case 12:choice_FT8n_tTONE->value(progStatus.txT_70);
choice_FT8n_rTONE->value(progStatus.txT_70);
FMoffset->index(progStatus.offset_70);
FMoff_freq->value(progStatus.oF_70 );
progStatus.m70 = vfo->imode;
break; // 70 cent'
}
}
void cbBandSelect(int band)
{
guard_lock gl_serial(&mutex_serial, "68");
if (xcvr_name == rig_FT857D.name_ || xcvr_name == rig_FT897D.name_ ) {
if (Fl::event_button() == FL_LEFT_MOUSE) {
selrig->set_band_selection(band);
updateCTCSS(band);
if (band > 8) { // 10, 6, 2, 70, 1.2G
int tTONE = PL_tones[choice_FT8n_tTONE->value()];
int rTONE = PL_tones[choice_FT8n_rTONE->value()];
selrig->set_tones(tTONE, rTONE);
selrig->set_offset(FMoffset->index(), FMoff_freq->value());
}
} else if (Fl::event_button() == FL_RIGHT_MOUSE)
set_band(band);
return;
}
if (Fl::event_button() == FL_RIGHT_MOUSE) {
selrig->rTONE = choice_rTONE->value();
selrig->tTONE = choice_tTONE->value();
selrig->set_band_selection(band);
return;
}
selrig->get_band_selection(band);
// get freqmdbw
if (selrig->inuse == onA) {
vfoA.freq = selrig->get_vfoA();
if (selrig->has_mode_control)
vfoA.imode = selrig->get_modeA();
if (selrig->has_bandwidth_control) {
selrig->adjust_bandwidth(vfoA.imode);
vfoA.iBW = selrig->get_bwA();
}
vfo = &vfoA;
} else {
vfoB.freq = selrig->get_vfoB();
if (selrig->has_mode_control)
vfoB.imode = selrig->get_modeB();
if (selrig->has_bandwidth_control) {
selrig->adjust_bandwidth(vfoB.imode);
vfoB.iBW = selrig->get_bwB();
}
vfo = &vfoB;
}
// local display freqmdbw
if (selrig->has_mode_control) {
setModeControl(NULL);
}
if (selrig->has_bandwidth_control) {
set_bandwidth_control();
updateBandwidthControl();
}
if (selrig->inuse == onA) { FreqDispA->value(vfo->freq); FreqDispA->redraw(); }
else { FreqDispB->value(vfo->freq); FreqDispB->redraw(); }
if (selrig->CIV && (selrig->name_ != rig_IC7200.name_)) {
choice_tTONE->value(selrig->tTONE);
choice_tTONE->redraw();
choice_rTONE->value(selrig->rTONE);
choice_rTONE->redraw();
}
}
void enable_yaesu_bandselect(int btn_num, bool enable)
{
switch (btn_num) {
case 1:
case 9:
break;
case 10: // 6m
if (enable) btn_yaesu_select_10->show();
else btn_yaesu_select_10->hide();
break;
case 11: // GEN
if (enable) btn_yaesu_select_11->show();
else btn_yaesu_select_11->hide();
break;
case 13:
if (enable) op_yaesu_select60->show();
else op_yaesu_select60->hide();
break;
default:
break;
}
}
flrig-2.0.04/src/support/timeops.cxx 0000664 0001750 0001750 00000010555 14504050363 014340 0000000 0000000 // ----------------------------------------------------------------------------
// timeops.cxx
//
// Copyright (C) 2017
// David Freese, W1HKJ
//
// This file is part of flrig.
//
// fldigi is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation; either version 3 of the License, or
// (at your option) any later version.
//
// fldigi is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program. If not, see .
// ----------------------------------------------------------------------------
#include "config.h"
#include
#include
#include
#include "timeops.h"
struct timespec operator+(const struct timespec &t0, const double &t)
{
struct timespec r;
r.tv_sec = t0.tv_sec + static_cast(t);
r.tv_nsec = t0.tv_nsec + static_cast((t - static_cast(t)) * 1e9);
if (r.tv_nsec > 1000000000) {
r.tv_nsec -= 1000000000;
r.tv_sec++;
}
return r;
}
struct timespec operator-(const struct timespec &t0, const struct timespec &t1)
{
struct timespec r = t0;
if (r.tv_nsec < t1.tv_nsec) {
--r.tv_sec;
r.tv_nsec += 1000000000L;
}
r.tv_sec -= t1.tv_sec;
r.tv_nsec -= t1.tv_nsec;
return r;
}
struct timespec& operator-=(struct timespec &t0, const struct timespec &t1)
{
if (t0.tv_nsec < t1.tv_nsec) {
--t0.tv_sec;
t0.tv_nsec += 1000000000L;
}
t0.tv_sec -= t1.tv_sec;
t0.tv_nsec -= t1.tv_nsec;
return t0;
}
bool operator>(const struct timespec &t0, const struct timespec &t1)
{
if (t0.tv_sec == t1.tv_sec)
return t0.tv_nsec > t1.tv_nsec;
else if (t0.tv_sec > t1.tv_sec)
return true;
else
return false;
}
bool operator==(const struct timespec &t0, const struct timespec &t1)
{
return t0.tv_sec == t1.tv_sec && t0.tv_nsec == t1.tv_nsec;
}
struct timeval operator+(const struct timeval &t0, const double &t)
{
struct timeval r;
r.tv_sec = t0.tv_sec + static_cast(t);
r.tv_usec = t0.tv_usec + static_cast((t - static_cast(t)) * 1e9);
if (r.tv_usec > 1000000) {
r.tv_usec -= 1000000;
r.tv_sec++;
}
return r;
}
struct timeval operator-(const struct timeval &t0, const struct timeval &t1)
{
struct timeval r = t0;
if (r.tv_usec < t1.tv_usec) {
--r.tv_sec;
r.tv_usec += 1000000;
}
r.tv_sec -= t1.tv_sec;
r.tv_usec -= t1.tv_usec;
return r;
}
struct timeval& operator-=(struct timeval &t0, const struct timeval &t1)
{
if (t0.tv_usec < t1.tv_usec) {
--t0.tv_sec;
t0.tv_usec += 1000000L;
}
t0.tv_sec -= t1.tv_sec;
t0.tv_usec -= t1.tv_usec;
return t0;
}
bool operator>(const struct timeval &t0, const struct timeval &t1)
{
if (t0.tv_sec == t1.tv_sec)
return t0.tv_usec > t1.tv_usec;
else if (t0.tv_sec > t1.tv_sec)
return true;
else
return false;
}
bool operator==(const struct timeval &t0, const struct timeval &t1)
{
return t0.tv_sec == t1.tv_sec && t0.tv_usec == t1.tv_usec;
}
#ifndef HAVE_GMTIME_R
#include
#include "threads.h"
static pthread_mutex_t gmtime_r_mutex = PTHREAD_MUTEX_INITIALIZER;
struct tm *gmtime_r(const time_t *_Time, struct tm *_Tm)
{
pthread_mutex_lock (&gmtime_r_mutex);
struct tm *p = gmtime(_Time);
if (p && _Tm) memcpy (_Tm, p, sizeof (struct tm));
pthread_mutex_unlock (&gmtime_r_mutex);
return p;
}
static pthread_mutex_t gmtime_local_mutex = PTHREAD_MUTEX_INITIALIZER;
struct tm *localtime_r(const time_t *_Time,struct tm *_Tm)
{
pthread_mutex_lock (&gmtime_local_mutex);
struct tm *p = localtime(_Time);
if (p && _Tm) memcpy (_Tm, p, sizeof (struct tm));
pthread_mutex_unlock (&gmtime_local_mutex);
return p;
}
#endif
flrig-2.0.04/src/support/util.cxx 0000664 0001750 0001750 00000015256 14504050363 013640 0000000 0000000 // ----------------------------------------------------------------------------
// Copyright (C) 2014
// David Freese, W1HKJ
//
// This file is part of flrig.
//
// flrig is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation; either version 3 of the License, or
// (at your option) any later version.
//
// flrig is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program. If not, see .
// ----------------------------------------------------------------------------
#include "config.h"
#include "compat.h"
#include
#include
#include
#include
#include "timeops.h"
#include "util.h"
/* Return the smallest power of 2 not less than n */
uint32_t ceil2(uint32_t n)
{
--n;
n |= n >> 1;
n |= n >> 2;
n |= n >> 4;
n |= n >> 8;
n |= n >> 16;
return n + 1;
}
/* Return the largest power of 2 not greater than n */
uint32_t floor2(uint32_t n)
{
n |= n >> 1;
n |= n >> 2;
n |= n >> 4;
n |= n >> 8;
n |= n >> 16;
return n - (n >> 1);
}
#include
unsigned long ver2int(const char* version)
{
unsigned long v;
char* p;
v = (unsigned long)(strtod(version, &p) * 1e7 + 0.5);
while (*p)
v += *p++;
return v;
}
/*
#if !HAVE_STRCASESTR
# include
// from git 1.6.1.2 compat/strcasestr.c
char *strcasestr(const char *haystack, const char *needle)
{
int nlen = strlen(needle);
int hlen = strlen(haystack) - nlen + 1;
int i;
for (i = 0; i < hlen; i++) {
int j;
for (j = 0; j < nlen; j++) {
unsigned char c1 = haystack[i+j];
unsigned char c2 = needle[j];
if (toupper(c1) != toupper(c2))
goto next;
}
return (char *) haystack + i;
next: ;
}
return NULL;
}
#endif // !HAVE_STRCASESTR
*/
#if !HAVE_STRLCPY
// from git 1.6.1.2 compat/strcasestr.c
size_t strlcpy(char *dest, const char *src, size_t size)
{
size_t ret = strlen(src);
if (size) {
size_t len = (ret >= size) ? size - 1 : ret;
memcpy(dest, src, len);
dest[len] = '\0';
}
return ret;
}
#endif // !HAVE_STRLCPY
#ifdef __WIN32__
int set_cloexec(int fd, unsigned char v) { return 0; }
#else
# include
# include
int set_cloexec(int fd, unsigned char v)
{
int f = fcntl(fd, F_GETFD);
return f == -1 ? f : fcntl(fd, F_SETFD, (v ? f | FD_CLOEXEC : f & ~FD_CLOEXEC));
}
#endif // __WIN32__
int set_nonblock(int fd, unsigned char v)
{
#ifndef __WIN32__
int f = fcntl(fd, F_GETFL);
return f == -1 ? f : fcntl(fd, F_SETFL, (v ? f | O_NONBLOCK : f & ~O_NONBLOCK));
#else // __WIN32__
u_long v_ = (u_long)v;
errno = 0;
if (ioctlsocket(fd, FIONBIO, &v_) == SOCKET_ERROR) {
errno = WSAGetLastError();
return -1;
}
else
return 0;
#endif // __WIN32__
}
#ifndef __WIN32__
# include
# include
# include
# include
#endif
int set_nodelay(int fd, unsigned char v)
{
int val = v;
return setsockopt(fd, IPPROTO_TCP, TCP_NODELAY, (const char*)&val, sizeof(val));
}
#ifdef __WIN32__
# include
int get_bufsize(int fd, int dir, int* len)
{
int optlen = sizeof(*len);
#else
int get_bufsize(int fd, int dir, int* len)
{
socklen_t optlen = sizeof(*len);
#endif
return getsockopt(fd, SOL_SOCKET, (dir == 0 ? SO_RCVBUF : SO_SNDBUF),
(char*)len, &optlen);
}
int set_bufsize(int fd, int dir, int len)
{
return setsockopt(fd, SOL_SOCKET, (dir == 0 ? SO_RCVBUF : SO_SNDBUF),
(const char*)&len, sizeof(len));
}
#ifndef __WIN32__
#include
#include
#ifndef NSIG
# define NSIG 64
#endif
static size_t nsig = 0;
static struct sigaction* sigact = 0;
static pthread_mutex_t sigmutex = PTHREAD_MUTEX_INITIALIZER;
#endif
void save_signals(void)
{
#ifndef __WIN32__
pthread_mutex_lock(&sigmutex);
if (!sigact)
sigact = new struct sigaction[NSIG];
for (nsig = 1; nsig <= NSIG; nsig++)
if (sigaction(nsig, NULL, &sigact[nsig-1]) == -1)
break;
pthread_mutex_unlock(&sigmutex);
#endif
}
void restore_signals(void)
{
#ifndef __WIN32__
pthread_mutex_lock(&sigmutex);
for (size_t i = 1; i <= nsig; i++)
sigaction(i, &sigact[i-1], NULL);
delete [] sigact;
sigact = 0;
nsig = 0;
pthread_mutex_unlock(&sigmutex);
#endif
}
uint32_t simple_hash_data(const unsigned char* buf, size_t len, uint32_t code)
{
for (size_t i = 0; i < len; i++)
code = ((code << 4) | (code >> (32 - 4))) ^ (uint32_t)buf[i];
return code;
}
uint32_t simple_hash_str(const unsigned char* str, uint32_t code)
{
while (*str)
code = ((code << 4) | (code >> (32 - 4))) ^ (uint32_t)*str++;
return code;
}
#include
#include
static const char hexsym[] = "0123456789ABCDEF";
static std::vector* hexbuf;
const char* str2hex(const unsigned char* str, size_t len)
{
if (unlikely(len == 0))
return "";
if (unlikely(!hexbuf)) {
hexbuf = new std::vector;
hexbuf->reserve(192);
}
if (unlikely(hexbuf->size() < len * 3))
hexbuf->resize(len * 3);
char* p = &(*hexbuf)[0];
size_t i;
for (i = 0; i < len; i++) {
*p++ = hexsym[str[i] >> 4];
*p++ = hexsym[str[i] & 0xF];
*p++ = ' ';
}
*(p - 1) = '\0';
return &(*hexbuf)[0];
}
const char* str2hex(const char* str, size_t len)
{
return str2hex((const unsigned char*)str, len ? len : strlen(str));
}
static std::vector* binbuf;
const char* uint2bin(unsigned u, size_t len)
{
if (unlikely(len == 0))
len = sizeof(u) * CHAR_BIT;
if (unlikely(!binbuf)) {
binbuf = new std::vector;
binbuf->reserve(sizeof(u) * CHAR_BIT);
}
if (unlikely(binbuf->size() < len + 1))
binbuf->resize(len + 1);
for (size_t i = 0; i < len; i++) {
(*binbuf)[len - i - 1] = '0' + (u & 1);
u >>= 1;
}
(*binbuf)[len] = '\0';
return &(*binbuf)[0];
}
void MilliSleep(long msecs)
{
struct timespec tv;
tv.tv_sec = msecs / 1000;
tv.tv_nsec = (msecs - tv.tv_sec * 1000) * 1000000L;
nanosleep(&tv, NULL);
}
// return current tick time in seconds
double fsk_now()
{
static struct timeval t1;
gettimeofday(&t1, NULL);
return t1.tv_sec + t1.tv_usec / 1e6;
}
// sub millisecond accurate sleep function
// sleep_time in seconds
int accu_sleep (double sleep_time)
{
struct timespec tv;
double end_at = fsk_now() + sleep_time;
double delay = sleep_time - 0.005;
tv.tv_sec = (time_t) delay;
tv.tv_nsec = (long) ((delay - tv.tv_sec) * 1e+9);
int rval = 0;
while (1) {
rval = nanosleep (&tv, &tv);
if (rval == 0)
break;
else if (errno == EINTR)
continue;
else
return rval;
}
while (fsk_now() < end_at);
return 0;
}
flrig-2.0.04/src/support/debug.cxx 0000664 0001750 0001750 00000013100 14504050363 013733 0000000 0000000 // ----------------------------------------------------------------------------
// debug.cxx
//
// Copyright (C) 2014
// Stelios Bounanos, M0GLD
// David Freese, W1HKJ
//
// This file is part of fldigi.
//
// fldigi is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation; either version 3 of the License, or
// (at your option) any later version.
//
// fldigi is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program. If not, see .
// ----------------------------------------------------------------------------
#include "config.h"
#include "compat.h" // Must precede all FL includes
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include "debug.h"
#include "icons.h"
#include "gettext.h"
#include "rig.h"
#include "tod_clock.h"
#include "threads.h"
#include "support.h"
#include "trace.h"
#define MAX_LINES 65536
pthread_mutex_t debug_mutex = PTHREAD_MUTEX_INITIALIZER;
static FILE* wfile;
static FILE* rfile;
static int rfd;
static bool tty;
static Fl_Double_Window* window = (Fl_Double_Window *)0;
static Fl_Browser* btext = (Fl_Browser *)0;
static std::string buffer;
debug* debug::inst = 0;
debug::level_e debug::level = debug::ERROR_LEVEL;
//debug::level_e debug::level = debug::INFO_LEVEL;
uint32_t debug::mask = ~0u;
const char* prefix[] = { _("Quiet"), _("Error"), _("Warning"), _("Info"), _("Debug") };
static void slider_cb(Fl_Widget* w, void*);
static void clear_cb(Fl_Widget *w, void*);
void debug::start(const char* filename)
{
if (debug::inst)
return;
inst = new debug(filename);
window = new Fl_Double_Window(600, 256, _("Event log"));
int pad = 2;
Fl_Slider* slider = new Fl_Slider(pad, pad, 128, 20, prefix[level]);
slider->tooltip(_("Change log level"));
slider->align(FL_ALIGN_RIGHT);
slider->type(FL_HOR_NICE_SLIDER);
slider->range(0.0, LOG_NLEVELS - 1);
slider->step(1.0);
slider->value(level);
slider->callback(slider_cb);
Fl_Button* clearbtn = new Fl_Button(window->w() - 60, pad, 60, 20, "clear");
clearbtn->callback(clear_cb);
btext = new Fl_Browser(pad, slider->h()+pad, window->w()-2*pad, window->h()-slider->h()-2*pad, 0);
window->resizable(btext);
buffer.clear();
window->end();
}
void debug::stop(void)
{
guard_lock dlock(&debug_mutex);
delete inst;
inst = 0;
btext = 0;
if (window) {
delete window;
window = 0;
}
}
static char fmt[1024];
static char sztemp[8096];
static std::string estr = "";
void debug::log(level_e level, const char* func, const char* srcf, int line, const char* format, ...)
{
if (!inst) return;
if (level > debug::level) return;
snprintf(fmt, sizeof(fmt), "%c: %s: %s\n", *prefix[level], func, format);
va_list args;
va_start(args, format);
vsnprintf(sztemp, sizeof(sztemp), fmt, args);
// guard_lock dlock(&debug_mutex);
estr.append(sztemp);
if (progStatus.debugtrace) trace(1, sztemp);
fprintf(wfile, "[%s] %s", ztime(), sztemp);
va_end(args);
fflush(wfile);
Fl::awake(sync_text, 0);
}
void debug::slog(level_e level, const char* func, const char* srcf, int line, const char* format, ...)
{
if (!inst) return;
if (level > debug::level) return;
snprintf(fmt, sizeof(fmt), "%c:%s\n", *prefix[level], format);
va_list args;
va_start(args, format);
vsnprintf(sztemp, sizeof(sztemp), fmt, args);
// guard_lock dlock(&debug_mutex);
estr.append(sztemp);
if (progStatus.debugtrace) trace(1, sztemp);
fprintf(wfile, "[%s] %s", ztime(), sztemp);
va_end(args);
fflush(wfile);
Fl::awake(sync_text, 0);
}
void debug::elog(const char* func, const char* srcf, int line, const char* text)
{
log(ERROR_LEVEL, func, srcf, line, "%s: %s", text, strerror(errno));
}
void debug::show(void)
{
window->show();
}
void debug::sync_text(void* arg)
{
if (!window) return;
if (!window->visible()) return;
guard_lock dlock(&debug_mutex);
if (inst == 0 || btext == 0) return;
size_t p0 = 0, p1 = estr.find('\n');
std::string insrt;
while (p1 != std::string::npos) {
insrt = estr.substr(p0, p1-p0);
btext->insert(1, insrt.c_str());
buffer.append(insrt.append("\n"));
p0 = p1 + 1;
p1 = estr.find('\n', p0);
}
estr = "";
}
debug::debug(const char* filename)
{
if ((wfile = fopen(filename, "w")) == NULL)
throw strerror(errno);
setvbuf(wfile, (char*)NULL, _IOLBF, 0);
set_cloexec(fileno(wfile), 1);
if ((rfile = fopen(filename, "r")) == NULL)
throw strerror(errno);
rfd = fileno(rfile);
set_cloexec(rfd, 1);
#ifndef __WIN32__
int f;
if ((f = fcntl(rfd, F_GETFL)) == -1)
throw strerror(errno);
if (fcntl(rfd, F_SETFL, f | O_NONBLOCK) == -1)
throw strerror(errno);
#endif
tty = isatty(fileno(stderr));
}
debug::~debug()
{
if (window) {
delete window;
window = 0;
}
fclose(wfile);
fclose(rfile);
}
static void slider_cb(Fl_Widget* w, void*)
{
debug::level = (debug::level_e)((Fl_Slider*)w)->value();
w->label(prefix[debug::level]);
w->parent()->redraw();
}
static void clear_cb(Fl_Widget* w, void*)
{
if (!btext) return;
btext->clear();
buffer.clear();
}
flrig-2.0.04/src/support/socket.cxx 0000664 0001750 0001750 00000044730 14504050363 014152 0000000 0000000 // ----------------------------------------------------------------------------
// socket.cxx
//
// Copyright (C) 2008-2009
// Stelios Bounanos, M0GLD
// ----------------------------------------------------------------------------
// Copyright (C) 2014
// David Freese, W1HKJ
//
// This file is part of flrig
//
// flrig is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation; either version 3 of the License, or
// (at your option) any later version.
//
// flrig is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program. If not, see .
// ----------------------------------------------------------------------------
#include "config.h"
#include
#ifndef __MINGW32__
# include
# include
# include
# include
# include
# include
#else
# include "compat.h"
#endif
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include "debug.h"
#include "socket.h"
#if HAVE_GETADDRINFO && !defined(AI_NUMERICSERV)
# define AI_NUMERICSERV 0
#endif
//
// utility functions
//
#if HAVE_GETADDRINFO
static void copy_addrinfo(struct addrinfo** info, const struct addrinfo* src)
{
struct addrinfo* p = *info;
for (const struct addrinfo* rp = src; rp; rp = rp->ai_next) {
if (p) {
p->ai_next = new struct addrinfo;
p = p->ai_next;
}
else {
p = new struct addrinfo;
if (!*info)
*info = p;
}
p->ai_flags = rp->ai_flags;
p->ai_family = rp->ai_family;
p->ai_socktype = rp->ai_socktype;
p->ai_protocol = rp->ai_protocol;
p->ai_addrlen = rp->ai_addrlen;
if (rp->ai_addr) {
p->ai_addr = reinterpret_cast(new struct sockaddr_storage);
memcpy(p->ai_addr, rp->ai_addr, rp->ai_addrlen);
}
else
p->ai_addr = NULL;
if (rp->ai_canonname)
p->ai_canonname = strdup(rp->ai_canonname);
else
p->ai_canonname = NULL;
p->ai_next = NULL;
}
}
static void free_addrinfo(struct addrinfo* ai)
{
for (struct addrinfo *next, *p = ai; p; p = next) {
next = p->ai_next;
delete reinterpret_cast(p->ai_addr);
free(p->ai_canonname);
delete p;
}
}
#else
static void copy_charpp(char*** dst, const char* const* src)
{
if (src == NULL) {
*dst = NULL;
return;
}
size_t n = 0;
for (const char* const* s = src; *s; s++)
n++;
*dst = new char*[n+1];
for (size_t i = 0; i < n; i++)
(*dst)[i] = strdup(src[i]);
(*dst)[n] = NULL;
}
static void copy_hostent(struct hostent* dst, const struct hostent* src)
{
if (src->h_name)
dst->h_name = strdup(src->h_name);
else
dst->h_name = NULL;
copy_charpp(&dst->h_aliases, src->h_aliases);
dst->h_length = src->h_length;
if (src->h_addr_list) {
size_t n = 0;
for (const char* const* p = src->h_addr_list; *p; p++)
n++;
dst->h_addr_list = new char*[n+1];
for (size_t i = 0; i < n; i++) {
dst->h_addr_list[i] = new char[src->h_length];
memcpy(dst->h_addr_list[i], src->h_addr_list[i], src->h_length);
}
dst->h_addr_list[n] = NULL;
}
else
dst->h_addr_list = NULL;
}
static void copy_servent(struct servent* dst, const struct servent* src)
{
if (src->s_name)
dst->s_name = strdup(src->s_name);
else
dst->s_name = NULL;
copy_charpp(&dst->s_aliases, src->s_aliases);
dst->s_port = src->s_port;
if (src->s_proto)
dst->s_proto = strdup(src->s_proto);
else
dst->s_proto = NULL;
}
static void free_charpp(char** pp)
{
if (!pp)
return;
for (char** p = pp; *p; p++)
free(*p);
delete [] pp;
}
static void free_hostent(struct hostent* hp)
{
free(const_cast(hp->h_name));
free_charpp(hp->h_aliases);
if (hp->h_addr_list) {
for (char** p = hp->h_addr_list; *p; p++)
delete [] *p;
delete [] hp->h_addr_list;
}
}
static void free_servent(struct servent* sp)
{
free(const_cast(sp->s_name));
free_charpp(sp->s_aliases);
free(sp->s_proto);
}
#endif // HAVE_GETADDRINFO
//
// Address class
//
Address::Address(const char* host, int port, const char* proto_name)
: node(host), copied(false)
{
#if HAVE_GETADDRINFO
info = NULL;
#else
memset(&host_entry, 0, sizeof(host_entry));
memset(&service_entry, 0, sizeof(service_entry));
#endif
if (node.empty() && port == 0)
return;
std::ostringstream s;
s << port;
service = s.str();
lookup(proto_name);
}
Address::Address(const char* host, const char* port_name, const char* proto_name)
: node(host), service(port_name), copied(false)
{
#if HAVE_GETADDRINFO
info = NULL;
#else
memset(&host_entry, 0, sizeof(host_entry));
memset(&service_entry, 0, sizeof(service_entry));
#endif
lookup(proto_name);
}
Address::Address(const Address& addr)
{
#if HAVE_GETADDRINFO
info = NULL;
#else
memset(&host_entry, 0, sizeof(host_entry));
memset(&service_entry, 0, sizeof(service_entry));
#endif
*this = addr;
}
Address::~Address()
{
#if HAVE_GETADDRINFO
if (info) {
if (!copied)
freeaddrinfo(info);
else
free_addrinfo(info);
}
#else
free_hostent(&host_entry);
free_servent(&service_entry);
#endif
}
Address& Address::operator=(const Address& rhs)
{
if (this == &rhs)
return *this;
node = rhs.node;
service = rhs.service;
#if HAVE_GETADDRINFO
if (info) {
if (!copied)
freeaddrinfo(info);
else
free_addrinfo(info);
}
copy_addrinfo(&info, rhs.info);
#else
free_hostent(&host_entry);
free_servent(&service_entry);
copy_hostent(&host_entry, &rhs.host_entry);
copy_servent(&service_entry, &rhs.service_entry);
addr.ai_protocol = rhs.addr.ai_protocol;
addr.ai_socktype = rhs.addr.ai_socktype;
#endif
copied = true;
return *this;
}
void Address::lookup(const char* proto_name)
{
int proto;
if (!strcasecmp(proto_name, "tcp"))
proto = IPPROTO_TCP;
else if (!strcasecmp(proto_name, "udp"))
proto = IPPROTO_UDP;
else {
throw SocketException("Bad protocol name");
}
#if HAVE_GETADDRINFO
struct addrinfo hints;
memset(&hints, 0, sizeof(hints));
# ifdef AI_ADDRCONFIG
hints.ai_flags = AI_PASSIVE;
# endif
hints.ai_family = AF_UNSPEC;
hints.ai_socktype = (proto == IPPROTO_TCP ? SOCK_STREAM : SOCK_DGRAM);
if (service.find_first_not_of("0123456789") == std::string::npos)
hints.ai_flags |= AI_NUMERICSERV;
int r;
if ((r = getaddrinfo(node.empty() ? NULL : node.c_str(), service.c_str(), &hints, &info)) < 0) {
std::string errstr = "getaddrinfo: ";
errstr.append(node).append(" : ").append(service);
throw SocketException(r, errstr.c_str());
}
#else // use gethostbyname etc.
memset(&host_entry, 0, sizeof(host_entry));
memset(&service_entry, 0, sizeof(service_entry));
if (node.empty())
node = "0.0.0.0";
struct hostent* hp;
if ((hp = gethostbyname(node.c_str())) == NULL) {
#ifdef __WIN32__
std::string errstr = "gethostbyname: ";
errstr.append(node).append(" not found");
throw SocketException(0, errstr.c_str());
#else
throw SocketException(hstrerror(HOST_NOT_FOUND));
#endif
}
copy_hostent(&host_entry, hp);
int port;
struct servent* sp;
if ((sp = getservbyname(service.c_str(), NULL)) == NULL) {
// if a service name std::string could not be looked up by name, it must be numeric
if (service.find_first_not_of("0123456789") != std::string::npos) {
throw SocketException("Unknown service name");
}
port = htons(atoi(service.c_str()));
sp = getservbyport(port, NULL);
}
if (!sp)
service_entry.s_port = port;
else
copy_servent(&service_entry, sp);
memset(&addr, 0, sizeof(addr));
addr.ai_protocol = proto;
addr.ai_socktype = (proto == IPPROTO_TCP ? SOCK_STREAM : SOCK_DGRAM);
#endif
}
///
/// Returns the number of addresses available for
/// the node and service
///
size_t Address::size(void) const
{
size_t n = 0;
#if HAVE_GETADDRINFO
if (!info)
return 0;
for (struct addrinfo* p = info; p; p = p->ai_next)
n++;
#else
if (!host_entry.h_addr_list)
return 0;
for (char** p = host_entry.h_addr_list; *p; p++)
n++;
#endif
return n;
}
///
/// Returns an address from the list of those available
/// for the node and service
///
const addr_info_t* Address::get(size_t n) const
{
#if HAVE_GETADDRINFO
if (!info)
return NULL;
struct addrinfo* p = info;
for (size_t i = 0; i < n; i++)
p = p->ai_next;
LOG_DEBUG("Found address %s", get_str(p).c_str());
return p;
#else
if (!host_entry.h_addr_list)
return NULL;
memset(&saddr, 0, sizeof(saddr));
saddr.sin_family = AF_INET;
saddr.sin_addr = *(struct in_addr*)host_entry.h_addr_list[n];
saddr.sin_port = service_entry.s_port;
addr.ai_family = saddr.sin_family;
addr.ai_addrlen = sizeof(saddr);
addr.ai_addr = (struct sockaddr*)&saddr;
LOG_DEBUG("Found address %s", get_str(&addr).c_str());
return &addr;
#endif
}
///
/// Returns the std::string representation of an address
///
std::string Address::get_str(const addr_info_t* addr)
{
if (!addr)
return "";
#if HAVE_GETADDRINFO
char host[NI_MAXHOST], port[NI_MAXSERV];
memset(host, 0, sizeof(host));
if (getnameinfo(addr->ai_addr, sizeof(struct sockaddr_storage),
host, sizeof(host), port, sizeof(port),
NI_NUMERICHOST | NI_NUMERICSERV) == 0)
return std::string("[").append(host).append("]:").append(port);
else
return "";
#else
char* host, port[8];
host = inet_ntoa(((struct sockaddr_in*)addr->ai_addr)->sin_addr);
snprintf(port, sizeof(port), "%u", htons(((struct sockaddr_in*)addr->ai_addr)->sin_port));
return std::string("[").append(host).append("]:").append(port);
#endif
}
//
// Socket class
//
/// Constructs a Socket object and associates the address addr with it.
/// This address will be used by subsequent calls to the bind() or connect()
/// methods
///
/// @param addr An Address object
///
Socket::Socket(const Address& addr)
{
buffer = new char[BUFSIZ];
memset(&timeout, 0, sizeof(timeout));
anum = 0;
autoclose = true;
open(addr);
set_nonblocking(false);
}
/// Constructs a Socket object from a file descriptor
///
/// @param fd A file descriptor
///
Socket::Socket(int fd)
: sockfd(fd)
{
buffer = new char[BUFSIZ];
anum = 0;
memset(&timeout, 0, sizeof(timeout));
if (sockfd == -1)
return;
#ifndef __MINGW32__
int r = fcntl(sockfd, F_GETFL);
if (r == -1)
throw SocketException(errno, "fcntl");
nonblocking = r & O_NONBLOCK;
#else
set_nonblocking(false);
#endif
autoclose = true;
}
///
/// Constructs a Socket object by copying another instance
///
Socket::Socket(const Socket& s)
: sockfd(s.sockfd), address(s.address), anum(s.anum),
nonblocking(s.nonblocking), autoclose(true)
{
buffer = new char[BUFSIZ];
ainfo = address.get(anum);
memcpy(&timeout, &s.timeout, sizeof(timeout));
s.set_autoclose(false);
}
Socket::~Socket()
{
delete [] buffer;
if (autoclose)
close();
}
Socket& Socket::operator=(const Socket& rhs)
{
if (this == &rhs)
return *this;
sockfd = rhs.sockfd;
address = rhs.address;
anum = rhs.anum;
ainfo = address.get(anum);
memcpy(&timeout, &rhs.timeout, sizeof(timeout));
nonblocking = rhs.nonblocking;
autoclose = rhs.autoclose;
rhs.set_autoclose(false);
return *this;
}
///
/// Associates the Socket with an address
///
/// This address will be used by subsequent calls to the bind() or connect
/// methods.
///
/// @params addr An address object
///
void Socket::open(const Address& addr)
{
address = addr;
size_t n = address.size();
for (anum = 0; anum < n; anum++) {
ainfo = address.get(anum);
LOG_DEBUG("Trying %s", address.get_str(ainfo).c_str());
if ((sockfd = socket(ainfo->ai_family, ainfo->ai_socktype, ainfo->ai_protocol)) != -1)
break;
}
if (sockfd == -1)
throw SocketException(errno, "socket");
set_close_on_exec(true);
}
///
/// Shuts down the socket
///
void Socket::close(void)
{
::close(sockfd);
sockfd = -1;
}
///
/// Waits for the socket file descriptor to become ready for I/O
///
/// @params dir Specifies the I/O direction. 0 is input, 1 is output.
///
/// @return True if the file descriptor became ready within the timeout
/// period, false otherwise. @see Socket::set_timeout
bool Socket::wait(int dir)
{
fd_set fdset;
FD_ZERO(&fdset);
FD_SET((unsigned)sockfd, &fdset);
struct timeval t = { timeout.tv_sec, timeout.tv_usec };
int r;
if (dir == 0)
r = select(sockfd + 1, &fdset, NULL, NULL, &t);
else if (dir == 1)
r = select(sockfd + 1, NULL, &fdset, NULL, &t);
else
throw SocketException(EINVAL, "Socket::wait");
if (r == -1)
throw SocketException(errno, "select");
return r;
}
///
/// Binds the socket to the address associated with the object
/// @see Socket::open
///
void Socket::bind(void)
{
int r = 1;
if (setsockopt(sockfd, SOL_SOCKET, SO_REUSEADDR, (const char*)&r, sizeof(r)) == -1)
perror("setsockopt SO_REUSEADDR");
if (::bind(sockfd, ainfo->ai_addr, ainfo->ai_addrlen) == -1)
throw SocketException(errno, "bind");
}
///
/// Calls listen(2) on the socket file desriptor
///
/// The socket must already have been bound to an address via a call to the bind
/// method.
///
/// @params backlog The maximum number of pending connections (default SOMAXCONN)
///
void Socket::listen(int backlog)
{
if (::listen(sockfd, backlog) == -1)
throw SocketException(errno, "listen");
}
///
/// Accepts a connection
///
/// The socket must already have been bound to an address via a call to the bind
/// method.
///
/// @return A Socket instance for the accepted connection
///
Socket Socket::accept(void)
{
listen();
// wait for fd to become readable
if (nonblocking && (timeout.tv_sec > 0 || timeout.tv_usec > 0))
if (!wait(0))
throw SocketException(ETIMEDOUT, "select");
int r;
if ((r = ::accept(sockfd, NULL, 0)) == -1)
throw SocketException(errno, "accept");
set_close_on_exec(true, r);
return Socket(r);
}
///
/// Accepts a single connection and then closes the listening socket
/// @see Socket::accept
///
/// @return A Socket instance for the accepted connection
///
Socket Socket::accept1(void)
{
bind();
Socket s = accept();
close();
s.set_close_on_exec(true);
return s;
}
///
/// Connects the socket to the address that is associated with the object
///
void Socket::connect(void)
{
LOG_DEBUG("Connecting to %s", address.get_str(ainfo).c_str());
if (::connect(sockfd, ainfo->ai_addr, ainfo->ai_addrlen) == -1)
throw SocketException(errno, "connect");
}
///
/// Connects the socket to an address
///
/// @param addr The address to connect to
///
void Socket::connect(const Address& addr)
{
close();
open(addr);
connect();
}
///
/// Sends a buffer
///
/// @param buf
/// @param len
///
/// @return The amount of data that was sent. This may be less than len
/// if the socket is non-blocking.
///
#include
size_t Socket::send(const void* buf, size_t len)
{
// if we have a nonblocking socket and a nonzero timeout,
// wait for fd to become writeable
if (nonblocking && (timeout.tv_sec > 0 || timeout.tv_usec > 0))
if (!wait(1))
return 0;
ssize_t r = ::send(sockfd, (const char*)buf, len, 0);
if (r == 0) {
shutdown(sockfd, SHUT_WR);
} else if (r == -1) {
if (errno != EAGAIN)
throw SocketException(errno, "send");
r = 0;
}
return r;
}
///
/// Sends a std::string
///
/// @param buf
///
/// @return The amount of data that was sent. This may be less than len
/// if the socket is non-blocking.
///
size_t Socket::send(const std::string buf) //const std::string& buf)
{
return send(buf.data(), buf.length());
}
///
/// Receives data into a buffer
///
/// @arg buf
/// @arg len The maximum number of bytes to write to buf.
///
/// @return The amount of data that was received. This may be less than len
/// if the socket is non-blocking.
size_t Socket::recv(void* buf, size_t len)
{
// if we have a nonblocking socket and a nonzero timeout,
// wait for fd to become writeable
if (nonblocking && (timeout.tv_sec > 0 || timeout.tv_usec > 0))
if (!wait(0)) {
return 0;
}
ssize_t r = ::recv(sockfd, (char*)buf, len, 0);
if (r == 0) {
shutdown(sockfd, SHUT_RD);
} else if (r == -1) {
if (errno != EAGAIN)
throw SocketException(errno, "recv");
r = 0;
}
return r;
}
///
/// Receives all available data and appends it to a std::string.
///
/// @arg buf
///
/// @return The amount of data that was received.
///
size_t Socket::recv(std::string& buf)
{
size_t n = 0;
ssize_t r;
while ((r = recv(buffer, BUFSIZ)) > 0) {
buf.reserve(buf.length() + r);
buf.append(buffer, r);
n += r;
}
return n;
}
///
/// Retrieves the socket's receive or send buffer size
///
/// @param dir Specifies the I/O direction. 0 is input, 1 is output.
///
int Socket::get_bufsize(int dir)
{
int len;
if (::get_bufsize(sockfd, dir, &len) == -1)
throw SocketException(errno, "get_bufsize");
return len;
}
///
/// Sets the socket's receive or send buffer size
///
/// @param dir Specifies the I/O direction. 0 is input, 1 is output.
/// @param len Specifies the new buffer size
///
void Socket::set_bufsize(int dir, int len)
{
if (::set_bufsize(sockfd, dir, len) == -1)
throw SocketException(errno, "set_bufsize");
}
///
/// Sets the socket's blocking mode
///
/// @param v If true, the socket is set to non-blocking
///
void Socket::set_nonblocking(bool v)
{
if (set_nonblock(sockfd, v) == -1)
throw SocketException(errno, "set_nonblock");
nonblocking = v;
}
///
/// Enables the use of Nagle's algorithm for the socket
///
/// @param v If true, Nagle's algorithm is disabled.
///
void Socket::set_nodelay(bool v)
{
if (::set_nodelay(sockfd, v) == -1)
throw SocketException(errno, "set_nodelay");
}
///
/// Sets the timeout associated with non-blocking operations
///
/// @param t
///
void Socket::set_timeout(const struct timeval& t)
{
timeout.tv_sec = t.tv_sec;
timeout.tv_usec = t.tv_usec;
}
void Socket::set_timeout(double t)
{
timeout.tv_sec = (time_t)floor(t);
timeout.tv_usec = (size_t)((t - timeout.tv_sec) * 1e6);
}
///
/// Sets the socket's autoclose mode.
///
/// If autoclose is disabled, the socket file descriptor will not be closed when
/// the Socket object is destructed.
///
/// @param v If true, the socket will be closed by the destructor
///
void Socket::set_autoclose(bool v) const
{
autoclose = v;
}
///
/// Sets the socket's close-on-exec flag
///
void Socket::set_close_on_exec(bool v, int fd)
{
if (fd == -1)
fd = sockfd;
if (set_cloexec(fd, v) == -1)
throw SocketException(errno, "set_cloexec");
}
///
/// Returns the Socket's file descriptor.
///
/// The descriptor should only be used for reading and writing.
///
/// @return the socket file descriptor
///
int Socket::fd(void)
{
return sockfd;
}
flrig-2.0.04/src/support/read_rig.cxx 0000664 0001750 0001750 00000012702 14504050363 014430 0000000 0000000 // ----------------------------------------------------------------------------
// Copyright (C) 2014-2011
// David Freese, W1HKJ
//
// This file is part of flrig.
//
// flrig is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation; either version 3 of the License, or
// (at your option) any later version.
//
// flrig is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program. If not, see .
// ----------------------------------------------------------------------------
#include "support.h"
void TRACED(enable_xcvr_ui)
if (selrig->has_mode_control)
btnRestoreMode->activate();
else
btnRestoreMode->deactivate();
if (selrig->has_bandwidth_control)
btnRestoreBandwidth->activate();
else
btnRestoreBandwidth->deactivate();
if (selrig->has_preamp_control || selrig->has_attenuator_control)
btnRestorePreAtt->show();
else
btnRestorePreAtt->hide();
if (selrig->has_auto_notch)
btnRestoreAutoNotch->show();
else
btnRestoreAutoNotch->hide();
if (selrig->has_split)
btnRestoreSplit->show();
else
btnRestoreSplit->hide();
if (selrig->has_power_control)
btnRestorePowerControl->show();
else
btnRestorePowerControl->hide();
if (selrig->has_volume_control)
btnRestoreVolume->show();
else
btnRestoreVolume->hide();
if (selrig->has_ifshift_control)
btnRestoreIFshift->show();
else
btnRestoreIFshift->hide();
if (selrig->has_notch_control)
btnRestoreNotch->show();
else
btnRestoreNotch->hide();
if (selrig->has_noise_control)
btnRestoreNoise->show();
else
btnRestoreNoise->hide();
if (selrig->has_noise_reduction_control)
btnRestoreNR->show();
else
btnRestoreNR->hide();
if (selrig->has_micgain_control)
btnRestoreMicGain->show();
else
btnRestoreMicGain->hide();
if (selrig->has_sql_control)
btnRestoreSquelch->show();
else
btnRestoreSquelch->hide();
if (selrig->has_rf_control)
btnRestoreRfGain->show();
else
btnRestoreRfGain->hide();
if (selrig->has_compON)
btnRestoreCompOnOff->show();
else
btnRestoreCompOnOff->hide();
if (selrig->has_compression)
btnRestoreCompLevel->show();
else
btnRestoreCompLevel->hide();
}
void TRACED(vfo_startup_data, XCVR_STATE &xcvrvfo)
if (selrig->has_preamp_control)
xcvrvfo.preamp = selrig->get_preamp();
if (selrig->has_attenuator_control)
xcvrvfo.attenuator = selrig->get_attenuator();
if (selrig->has_auto_notch)
xcvrvfo.auto_notch = selrig->get_auto_notch();
if (selrig->has_split)
xcvrvfo.split = selrig->get_split();
update_progress(progress->value() + 4);
if (selrig->has_power_control)
xcvrvfo.power_control = selrig->get_power_control();
if (selrig->has_volume_control)
xcvrvfo.volume_control = selrig->get_volume_control();
if (selrig->has_ifshift_control)
selrig->get_if_shift(xcvrvfo.if_shift);
if (selrig->has_notch_control)
xcvrvfo.notch = selrig->get_notch(xcvrvfo.notch_val);
update_progress(progress->value() + 4);
if (selrig->has_noise_control)
xcvrvfo.noise = selrig->get_noise();
if (selrig->has_noise_reduction_control) {
xcvrvfo.nr = selrig->get_noise_reduction();
xcvrvfo.nr_val = selrig->get_noise_reduction_val();
}
if (selrig->has_micgain_control)
xcvrvfo.mic_gain = selrig->get_mic_gain();
if (selrig->has_sql_control)
xcvrvfo.squelch = selrig->get_squelch();
if (selrig->has_rf_control)
xcvrvfo.rf_gain = selrig->get_rf_gain();
if (selrig->has_compression)
selrig->get_compression (xcvrvfo.compON, xcvrvfo.compression);
update_progress(progress->value() + 4);
}
void TRACED(vfoA_startup_data)
update_progress(progress->value() + 4);
if (selrig->has_get_info)
selrig->get_info();
xcvr_vfoA.freq = selrig->get_vfoA();
xcvr_vfoA.imode = selrig->get_modeA();
xcvr_vfoA.iBW = selrig->get_bwA();
xcvr_vfoA.filter = selrig->get_FILT(xcvr_vfoA.imode);
update_progress(progress->value() + 10);
vfo_startup_data(xcvr_vfoA);
rig_trace(2, "Xcvr vfo A:\n", print(xcvr_vfoA));
}
void TRACED(vfoB_startup_data)
update_progress(progress->value() + 4);
if (selrig->has_get_info)
selrig->get_info();
xcvr_vfoB.freq = selrig->get_vfoB();
xcvr_vfoB.imode = selrig->get_modeB();
xcvr_vfoB.iBW = selrig->get_bwB();
xcvr_vfoB.filter = selrig->get_FILT(xcvr_vfoB.imode);
update_progress(progress->value() + 4);
vfo_startup_data(xcvr_vfoB);
rig_trace(2, "Xcvr vfo B:\n", print(xcvr_vfoB));
}
void TRACED(rig_startup_data)
update_progress(0);
enable_xcvr_ui();
// The FT-891 loses width WDH on A/B changes. It also starts
// with VFOA active, so no selectA() before reading VFOA values.
if (selrig->name_ == rig_FT891.name_) {
vfoA_startup_data();
selrig->selectB(); // first select call
vfoB_startup_data();
// Restore VFOA mode, then freq and bandwidth
selrig->selectA(); // second select call
yaesu891UpdateA(&xcvr_vfoA);
} else {
selrig->selectB(); // first select call to FT897D
vfoB_startup_data();
selrig->selectA(); // second select call
vfoA_startup_data();
}
if (selrig->has_agc_control) {
progStatus.agc_level = selrig->get_agc();
redrawAGC();
}
if (selrig->has_FILTER)
selrig->set_FILTERS(progStatus.filters);
selrig->set_BANDWIDTHS(progStatus.bandwidths);
}
flrig-2.0.04/src/support/TT550_support.cxx 0000664 0001750 0001750 00000014516 14504050363 015236 0000000 0000000 // ----------------------------------------------------------------------------
// Copyright (C) 2014-2011
// David Freese, W1HKJ
//
// This file is part of flrig.
//
// flrig is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation; either version 3 of the License, or
// (at your option) any later version.
//
// flrig is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program. If not, see .
// ----------------------------------------------------------------------------
#include "config.h"
#include "compat.h" // Must precede all FL includes
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include "icons.h"
#include "support.h"
#include "debug.h"
#include "gettext.h"
#include "rig_io.h"
#include "dialogs.h"
#include "rigbase.h"
#include "ptt.h"
#include "socket_io.h"
#include "ui.h"
#include "tod_clock.h"
#include "rig.h"
#include "rigs.h"
#include "K3_ui.h"
#include "KX3_ui.h"
#include "rigpanel.h"
#include "tod_clock.h"
#include "trace.h"
#include "cwio.h"
#include "fsk.h"
#include "fskioUI.h"
#include "xml_server.h"
#include "gpio_ptt.h"
#include "cmedia.h"
#include "tmate2.h"
void init_TT550_tabs()
{
spnr_tt550_line_out->value(progStatus.tt550_line_out);
cbo_tt550_agc_level->index(progStatus.tt550_agc_level);
spnr_tt550_cw_wpm->value(progStatus.tt550_cw_wpm);
spnr_tt550_cw_vol->value(progStatus.tt550_cw_vol);
spnr_tt550_cw_spot->value(progStatus.tt550_cw_spot);
spnr_tt550_cw_weight->value(progStatus.tt550_cw_weight);
spnr_tt550_cw_qsk->value(progStatus.tt550_cw_qsk);
btn_tt550_enable_keyer->value(progStatus.tt550_enable_keyer);
btn_tt550_vox->value(progStatus.tt550_vox_onoff);
spnr_tt550_vox_gain->value(progStatus.tt550_vox_gain);
spnr_tt550_anti_vox->value(progStatus.tt550_vox_anti);
spnr_tt550_vox_hang->value(progStatus.tt550_vox_hang);
btn_tt550_CompON->value(progStatus.tt550_compON);
spnr_tt550_compression->value(progStatus.tt550_compression);
spnr_tt550_mon_vol->value(progStatus.tt550_mon_vol);
btn_tt550_enable_xmtr->value(progStatus.tt550_enable_xmtr);
btn_tt550_enable_tloop->value(progStatus.tt550_enable_tloop);
btn_tt550_tuner_bypass->value(progStatus.tt550_tuner_bypass);
btn_tt550_use_xmt_bw->value(progStatus.tt550_use_xmt_bw);
sel_tt550_encoder_step->value(progStatus.tt550_encoder_step);
spnr_tt550_encoder_sensitivity->value(progStatus.tt550_encoder_sensitivity);
sel_tt550_F1_func->value(progStatus.tt550_F1_func);
sel_tt550_F2_func->value(progStatus.tt550_F2_func);
sel_tt550_F3_func->value(progStatus.tt550_F3_func);
progStatus.use_rig_data = false;
op_tt550_XmtBW->clear();
try {
for (size_t i = 0; i < TT550_xmt_widths.size(); i++) {
op_tt550_XmtBW->add(TT550_xmt_widths.at(i).c_str());
}
} catch (const std::exception& e) {
LOG_ERROR("%s", e.what());
}
op_tt550_XmtBW->activate();
op_tt550_XmtBW->index(progStatus.tt550_xmt_bw);
poll_smeter->activate(); poll_smeter->value(progStatus.poll_smeter);
poll_pout->activate(); poll_pout->value(progStatus.poll_pout);
poll_swr->activate(); poll_swr->value(progStatus.poll_swr);
poll_alc->activate(); poll_alc->value(progStatus.poll_alc);
poll_frequency->deactivate(); poll_frequency->value(0);
poll_mode->deactivate(); poll_mode->value(0);
poll_bandwidth->deactivate(); poll_bandwidth->value(0);
poll_volume->deactivate(); poll_volume->value(0);
poll_notch->deactivate(); poll_notch->value(0);
poll_auto_notch->deactivate(); poll_auto_notch->value(0);
poll_ifshift->deactivate(); poll_ifshift->value(0);
poll_power_control->deactivate(); poll_power_control->value(0);
poll_pre_att->deactivate(); poll_pre_att->value(0);
poll_squelch->deactivate(); poll_squelch->value(0);
poll_micgain->deactivate(); poll_micgain->value(0);
poll_rfgain->deactivate(); poll_rfgain->value(0);
poll_split->deactivate(); poll_split->value(0);
poll_nr->deactivate(); poll_nr->value(0);
poll_noise->deactivate(); poll_noise->value(0);
poll_all->deactivate(); poll_all->value(0);
if (progStatus.tt550_at11_inline) {
tt550_AT_inline->value(1);
tt550_AT_inline->label("Inline");
tt550_AT_inline->redraw_label();
selrig->at11_autotune();
} else {
tt550_AT_inline->value(0);
tt550_AT_inline->label("Bypassed");
tt550_AT_inline->redraw_label();
selrig->at11_bypass();
}
if (progStatus.tt550_at11_hiZ) {
selrig->at11_hiZ();
tt550_AT_Z->value(1);
} else{
selrig->at11_loZ();
tt550_AT_Z->value(0);
}
}
void init_TT550()
{
selrig->selectA();
vfoB.freq = progStatus.freq_B;
vfoB.imode = progStatus.imode_B;
vfoB.iBW = progStatus.iBW_B;
FreqDispB->value(vfoB.freq);
selrig->set_vfoB(vfoB.freq);
selrig->set_modeB(vfoB.imode);
selrig->set_bwB(vfoB.iBW);
vfoA.freq = progStatus.freq_A;
vfoA.imode = progStatus.imode_A;
vfoA.iBW = progStatus.iBW_A;
FreqDispA->value( vfoA.freq );
selrig->set_vfoA(vfoA.freq);
selrig->set_modeA(vfoA.imode);
vfo = &vfoA;
if (vfoA.iBW == -1) vfoA.iBW = selrig->def_bandwidth(vfoA.imode);
selrig->set_bwA(vfoA.iBW);
rigmodes_.clear();
opMODE->clear();
try {
for (size_t i = 0; i < selrig->modes_.size(); i++) {
rigmodes_.push_back(selrig->modes_.at(i).c_str());
opMODE->add(selrig->modes_.at(i).c_str());
}
} catch (const std::exception& e) {
LOG_ERROR("%s", e.what());
}
opMODE->activate();
opMODE->index(vfoA.imode);
opBW->show();
opBW->clear();
try {
for (size_t i = 0; i < selrig->bandwidths_.size(); i++) {
opBW->add(selrig->bandwidths_.at(i).c_str());
}
} catch (const std::exception& e) {
LOG_ERROR("%s", e.what());
}
opBW->activate();
opBW->index(vfoA.iBW);
spnr_tt550_vfo_adj->value(progStatus.vfo_adj);
btnPreamp->label("Spot");
btnPreamp->value(progStatus.tt550_spot_onoff);
switch (progStatus.UIsize) {
case small_ui :
btnPreamp->show();
break;
case wide_ui : case touch_ui : default :
btnPreamp->activate();
}
}
flrig-2.0.04/src/support/rig_io.cxx 0000664 0001750 0001750 00000025161 14505023143 014124 0000000 0000000 // ----------------------------------------------------------------------------
// Copyright (C) 2014
// David Freese, W1HKJ
//
// This file is part of flrig.
//
// flrig is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation; either version 3 of the License, or
// (at your option) any later version.
//
// flrig is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program. If not, see .
// ----------------------------------------------------------------------------
#include
#include
#include
#include
#include
#include "rig.h"
#include "support.h"
#include "util.h"
#include "debug.h"
#include "status.h"
#include "rigbase.h"
#include "rig_io.h"
#include "icons.h"
#include "tod_clock.h"
#include "socket_io.h"
#include "xmlrpc_rig.h"
extern bool test;
const char *nuline = "\n";
static int iBaudRates[] = { 300, 600, 1200, 2400, 4800, 9600,
19200, 38400, 57600, 115200, 230400, 460800 };
const char *szBaudRates[] = { "300", "600", "1200", "2400", "4800", "9600",
"19200", "38400", "57600", "115200", "230400", "460800", NULL };
int BaudRate(int n)
{
if (n > (int)sizeof(iBaudRates)) return 1200;
return (iBaudRates[n]);
}
bool startXcvrSerial()
{
if (progStatus.xcvr_serial_port == "NONE" ||
progStatus.xcvr_serial_port == "xml_client") {
return true;
}
debug::level_e level = debug::level;
debug::level = debug::DEBUG_LEVEL;
bypass_serial_thread_loop = true;
// setup commands for serial port
RigSerial->Device(progStatus.xcvr_serial_port);
RigSerial->Baud(BaudRate(progStatus.serial_baudrate));
RigSerial->Stopbits(progStatus.stopbits);
RigSerial->Retries(progStatus.serial_retries);
RigSerial->Timeout(progStatus.serial_timeout);
RigSerial->RTSptt(progStatus.serial_rtsptt);
RigSerial->DTRptt(progStatus.serial_dtrptt);
RigSerial->RTSCTS(progStatus.serial_rtscts);
RigSerial->RTS(progStatus.serial_rtsplus);
RigSerial->DTR(progStatus.serial_dtrplus);
if (!RigSerial->OpenPort()) {
LOG_ERROR("Cannot access %s", progStatus.xcvr_serial_port.c_str());
return false;
} else {
LOG_DEBUG("\n\
Serial port:\n\
Port : %s\n\
Baud : %d\n\
Stopbits : %d\n\
Retries : %d\n\
Timeout : %d\n\
Loop : %d\n\
RTSCTS : %d\n\
CATptt : %d\n\
RTSptt : %d\n\
DTRptt : %d\n\
RTS+ : %d\n\
DTR+ : %d\n",
progStatus.xcvr_serial_port.c_str(),
progStatus.serial_baudrate,
progStatus.stopbits,
progStatus.serial_retries,
progStatus.serial_timeout,
progStatus.serloop_timing,
progStatus.serial_rtscts,
progStatus.serial_catptt,
progStatus.serial_rtsptt,
progStatus.serial_dtrptt,
progStatus.serial_rtsplus,
progStatus.serial_dtrplus );
}
RigSerial->FlushBuffer();
debug::level = level;
return true;
}
bool startAuxSerial()
{
AuxSerial->Device(progStatus.aux_serial_port);
AuxSerial->Baud(BaudRate(progStatus.serial_baudrate));
AuxSerial->Stopbits(progStatus.stopbits);
AuxSerial->Retries(progStatus.serial_retries);
AuxSerial->Timeout(progStatus.serial_timeout);
if (!AuxSerial->OpenPort()) {
LOG_ERROR("Cannot access %s", progStatus.aux_serial_port.c_str());
return false;
}
return true;
}
bool startSepSerial()
{
SepSerial->Device(progStatus.sep_serial_port);
SepSerial->Baud(BaudRate(progStatus.serial_baudrate));
SepSerial->RTSCTS(false);
SepSerial->RTS(progStatus.sep_rtsplus);
SepSerial->RTSptt(progStatus.sep_rtsptt);
SepSerial->DTR(progStatus.sep_dtrplus);
SepSerial->DTRptt(progStatus.sep_dtrptt);
if (!SepSerial->OpenPort()) {
LOG_ERROR("Cannot access %s", progStatus.sep_serial_port.c_str());
return false;
}
return true;
}
// TODO: Review for thread safety.
// Tried adding mutex, but deadlocks startup
// progress dialog:
// guard_lock reply_lock(&mutex_replystr);
//
void assignReplyStr(std::string val)
{
selrig->replystr = val;
}
std::string respstr;
#define RXBUFFSIZE 100
int readResponse(std::string req1, std::string req2)
{
int numread = 0;
respstr.clear();
if (progStatus.use_tcpip)
numread = read_from_remote(respstr);
else {
numread = RigSerial->ReadBuffer(respstr, RXBUFFSIZE, req1, req2);
}
//std::cout << "readResponse:" << std::endl;
//std::cout << "req1: " << str2hex(req1.c_str(), req1.length()) << ", req2: " << str2hex(req2.c_str(), req2.length()) << std::endl;
//std::cout << "resp: " << numread << ", " << str2hex(respstr.c_str(), respstr.length()) << std::endl;
LOG_DEBUG("rsp:%3d, %s", numread, str2hex(respstr.c_str(), respstr.length()));
return numread;
}
int sendCommand (std::string s, int nread, int wait)
{
int numwrite = (int)s.size();
// TODO: Review for thread safety
//
// Clear command before sending, to keep the logs sensical. Otherwise it looks like
// reply was from this command, when it really was from a previous command.
assignReplyStr("");
if (progStatus.xmlrpc_rig) {
respstr = xml_cat_string(s);
//std::cout << "respstr: " << respstr << std::endl;
return respstr.length();
}
if (tci_running()) {
tci_send(s);
return 0;
}
if (progStatus.use_tcpip) {
readResponse();
send_to_remote(s);
int timeout =
progStatus.tcpip_ping_delay + nread * 2;
while (timeout > 0) {
if (timeout > 10) MilliSleep(10);
else MilliSleep(timeout);
timeout -= 10;
Fl::awake();
}
if (nread == 0) return 0;
return readResponse();
}
if (RigSerial->IsOpen() == false) {
LOG_DEBUG("Serial Port not open, cmd:%3d, %s",
(int)s.length(), str2hex(s.data(), s.length()));
return 0;
}
LOG_DEBUG("cmd:%3d, %s", (int)s.length(), str2hex(s.data(), s.length()));
RigSerial->FlushBuffer();
RigSerial->WriteBuffer(s.c_str(), numwrite);
int timeout = wait;
while (timeout > 0) {
if (timeout > 10) MilliSleep(10);
else MilliSleep(timeout);
timeout -= 10;
Fl::awake();
}
if (nread == 0) return 0;
return readResponse();
}
static int waitcount = 0;
static bool timeout_alert = false;
static char sztimeout_alert[200];
static void show_timeout(void *)
{
fl_alert2("%s", sztimeout_alert);
}
bool waitCommand(
std::string command,
int nread,
std::string info,
int msec,
char term,
int how,
int level )
{
guard_lock reply_lock(&mutex_replystr);
int numwrite = (int)command.length();
if (nread == 0)
LOG_DEBUG("cmd:%3d, %s", numwrite, how == ASC ? command.c_str() : str2hex(command.data(), numwrite));
if (progStatus.xmlrpc_rig) {
respstr = xml_cat_string(command);
return respstr.length();
}
if (progStatus.use_tcpip) {
send_to_remote(command);
if (nread == 0) return 0;
} else {
if (RigSerial->IsOpen() == false) {
LOG_DEBUG("cmd: %s", how == ASC ? command.c_str() : str2hex(command.data(), command.length()));
waitcount = 0;
return 0;
}
RigSerial->FlushBuffer();
// replystr.clear();
RigSerial->WriteBuffer(command.c_str(), numwrite);
if (nread == 0) {
waitcount = 0;
return 0;
}
}
int tod_start = zmsec();
// minimimum time to wait for a response
int timeout = (int)((nread * 2)*11000.0/RigSerial->Baud()
+ progStatus.use_tcpip ? progStatus.tcpip_ping_delay : 0);
while (timeout > 0) {
if (timeout > 10) MilliSleep(10);
else MilliSleep(timeout);
timeout -= 10;
Fl::awake();
}
// additional wait for xcvr processing
std::string returned = "";
static char sztemp[100];
int waited = 0;
while (waited < msec) {
if (readResponse())
returned.append(respstr);
if ( ((int)returned.length() >= nread) ||
(returned.find(term) != std::string::npos) ) {
assignReplyStr(returned);
waited = zmsec() - tod_start;
snprintf(sztemp, sizeof(sztemp), "%s rcvd in %d msec", info.c_str(), waited);
showresp(level, how, sztemp, command, returned);
waitcount = 0;
RigSerial->failed(-1);
return true;
}
waited += 10;
MilliSleep(10);
Fl::awake();
}
waitcount++;
assignReplyStr(returned);
waited = zmsec() - tod_start;
snprintf(sztemp, sizeof(sztemp), "%s TIMED OUT in %d ms", command.c_str(), waited);
showresp(ERR, how, sztemp, command, returned);
if (waitcount > 4 && !timeout_alert) {
timeout_alert = true;
snprintf(sztimeout_alert, sizeof(sztimeout_alert),
"Serial i/o failure\n%s TIMED OUT in %d ms",
command.c_str(), waited);
RigSerial->failed(1);
Fl::awake(show_timeout);
}
return false;
}
int waitResponse(int timeout)
{
int n = 0;
if (!progStatus.xmlrpc_rig && !progStatus.use_tcpip && !RigSerial->IsOpen())
return 0;
MilliSleep(10);
if (!(n = readResponse(";", "\0xFD"))) {
while (timeout > 0) {
if (timeout > 10) MilliSleep(10);
else MilliSleep(timeout);
timeout -= 10;
Fl::awake();
}
}
return n;
}
void showresp(int level, int how, std::string s, std::string tx, std::string rx)
{
time_t now;
time(&now);
struct tm *local = localtime(&now);
char sztm[20];
strftime(sztm, sizeof(sztm), "%H:%M:%S", local);
std::string s1 = how == HEX ? str2hex(tx.c_str(), tx.length()) : tx;
std::string s2 = how == HEX ? str2hex(rx.c_str(), rx.length()) : rx;
if (how == ASC) {
size_t p;
while((p = s1.find('\r')) != std::string::npos)
s1.replace(p, 1, "");
while((p = s1.find('\n')) != std::string::npos)
s1.replace(p, 1, "");
while((p = s2.find('\r')) != std::string::npos)
s2.replace(p, 1, "");
while((p = s2.find('\n')) != std::string::npos)
s2.replace(p, 1, "");
}
switch (level) {
case QUIET:
SLOG_QUIET("%s: %10s\ncmd %s\nans %s", sztm, s.c_str(), s1.c_str(), s2.c_str());
break;
case ERR:
SLOG_ERROR("%s: %10s\ncmd %s\nans %s", sztm, s.c_str(), s1.c_str(), s2.c_str());
break;
case INFO:
SLOG_INFO("%s: %10s\ncmd %s\nans %s", sztm, s.c_str(), s1.c_str(), s2.c_str());
break;
case DEBUG:
SLOG_DEBUG("%s: %10s\ncmd %s\nans %s", sztm, s.c_str(), s1.c_str(), s2.c_str());
break;
case WARN:
default:
SLOG_WARN("%s: %10s\ncmd %s\nans %s", sztm, s.c_str(), s1.c_str(), s2.c_str());
break;
}
}
std::string to_hex(std::string fm)
{
static std::string to;
to.clear();
char szHEX[8];
for (size_t n = 0; n < fm.length(); n++) {
snprintf(szHEX, sizeof(szHEX), "x%02X ", (fm[n] & 0xFF));
to.append(szHEX);
}
to.erase(to.length() - 1);
return to;
}
std::string fm_hex(std::string fm)
{
static std::string to;
to.clear();
if (fm.find("x") != std::string::npos) {
size_t p = 0;
unsigned int val;
while (( p = fm.find("x", p)) != std::string::npos) {
sscanf(&fm[p+1], "%X", &val);
to += (unsigned char) val;
p += 3;
}
}
return to;
}
flrig-2.0.04/src/support/restore_rig.cxx 0000664 0001750 0001750 00000007516 14504050363 015207 0000000 0000000 // ----------------------------------------------------------------------------
// Copyright (C) 2014-2011
// David Freese, W1HKJ
//
// This file is part of flrig.
//
// flrig is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation; either version 3 of the License, or
// (at your option) any later version.
//
// flrig is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program. If not, see .
// ----------------------------------------------------------------------------
#include "support.h"
void TRACED(restore_rig_vals_, XCVR_STATE &xcvrvfo)
if (progStatus.restore_pre_att) {
selrig->set_attenuator(xcvrvfo.attenuator);
selrig->set_preamp(xcvrvfo.preamp);
}
update_progress(progress->value() + 5);
if (progStatus.restore_auto_notch)
selrig->set_auto_notch(xcvrvfo.auto_notch);
if (progStatus.restore_split)
selrig->set_split(xcvrvfo.split);
update_progress(progress->value() + 5);
if (progStatus.restore_power_control)
selrig->set_power_control(xcvrvfo.power_control);
if (progStatus.restore_volume)
selrig->set_volume_control(xcvrvfo.volume_control);
update_progress(progress->value() + 5);
if (progStatus.restore_if_shift)
selrig->set_if_shift(xcvrvfo.if_shift);
update_progress(progress->value() + 5);
if (progStatus.restore_notch)
selrig->set_notch(xcvrvfo.notch, xcvrvfo.notch_val);
if (progStatus.restore_noise)
selrig->set_noise(xcvrvfo.noise);
update_progress(progress->value() + 5);
if (progStatus.restore_nr) {
selrig->set_noise_reduction(xcvrvfo.nr);
selrig->set_noise_reduction_val(xcvrvfo.nr_val);
}
update_progress(progress->value() + 5);
if (progStatus.restore_mic_gain)
selrig->set_mic_gain(xcvrvfo.mic_gain);
update_progress(progress->value() + 5);
if (progStatus.restore_squelch)
selrig->set_squelch(xcvrvfo.squelch);
update_progress(progress->value() + 5);
if (progStatus.restore_rf_gain)
selrig->set_rf_gain(xcvrvfo.rf_gain);
update_progress(progress->value() + 5);
if (progStatus.restore_comp_on_off && progStatus.restore_comp_level)
selrig->set_compression(xcvrvfo.compON, xcvrvfo.compression);
else if (progStatus.restore_comp_on_off)
selrig->set_compression(xcvrvfo.compON, progStatus.compression);
else if (progStatus.restore_comp_level)
selrig->set_compression(progStatus.compON, xcvrvfo.compression);
update_progress(progress->value() + 5);
}
void TRACED(restore_xcvr_vals)
if (progStatus.start_stop_trace) ss_trace(true);
update_progress(0);
guard_lock serial_lock(&mutex_serial, "restore_xcvr_vals");
trace(1, "restore_xcvr_vals()");
if (selrig->inuse == onA) {
selrig->selectB();
}
if (progStatus.restore_mode) {
selrig->set_modeB(xcvr_vfoB.imode);
selrig->set_FILT(xcvr_vfoB.filter);
}
if (progStatus.restore_frequency)
selrig->set_vfoB(xcvr_vfoB.freq);
if (progStatus.restore_bandwidth)
selrig->set_bwB(xcvr_vfoB.iBW);
restore_rig_vals_(xcvr_vfoB);
trace(2, "Restored xcvr B:\n", print(xcvr_vfoB));
selrig->selectA();
if (progStatus.restore_mode) {
selrig->set_modeA(xcvr_vfoA.imode);
selrig->set_FILT(xcvr_vfoA.filter);
}
if (progStatus.restore_frequency)
selrig->set_vfoA(xcvr_vfoA.freq);
if (progStatus.restore_bandwidth) {
if (selrig->name_ == rig_K3.name_) {
selrig->set_bwA(xcvr_vfoA.iBW);
selrig->set_bwB(xcvr_vfoB.iBW);
} else
selrig->set_bwA(xcvr_vfoA.iBW);
}
restore_rig_vals_(xcvr_vfoA);
trace(2, "Restored xcvr A:\n", print(xcvr_vfoA));
if (progStatus.start_stop_trace) ss_trace(false);
exit_commands();
}
flrig-2.0.04/src/support/tod_clock.cxx 0000664 0001750 0001750 00000003422 14504050363 014614 0000000 0000000 // =====================================================================
//
// TOD_clock.cxx
//
// Copyright (C) 2017
// Dave Freese, W1HKJ
//
// This file is part of flrig
//
// Fldigi is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//
// Fldigi is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with fldigi. If not, see .
// =====================================================================
#include "config.h"
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include "util.h"
#include "debug.h"
//#include "status.h"
#include "icons.h"
#include "tod_clock.h"
#include "timeops.h"
size_t zmsec()
{
static struct timeval tv;
gettimeofday(&tv, NULL);
return (tv.tv_sec * 1000L + (tv.tv_usec / 1000L));
}
size_t zusec()
{
static struct timeval tv;
gettimeofday(&tv, NULL);
return (tv.tv_sec * 1000000L + tv.tv_usec);
}
char *ztime()
{
static char exttime[13];
static struct tm tim;
static struct timeval tv;
gettimeofday(&tv, NULL);
time_t tval = tv.tv_sec;
gmtime_r(&tval, &tim);
snprintf(exttime, sizeof(exttime),
"%02d:%02d:%02d.%03d",
tim.tm_hour, tim.tm_min, tim.tm_sec, (int)(tv.tv_usec / 1000L) );
return exttime;
}
flrig-2.0.04/src/support/threads.cxx 0000664 0001750 0001750 00000006317 14504050363 014313 0000000 0000000 // ----------------------------------------------------------------------------
// threads.cxx
//
// Copyright (C) 2014
// Stelios Bounanos, M0GLD
// David Freese, W1HKJ
//
// This file is part of fldigi.
//
// fldigi is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation; either version 3 of the License, or
// (at your option) any later version.
//
// fldigi is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program. If not, see .
// ----------------------------------------------------------------------------
#include
#include
#include "threads.h"
#include "support.h"
/// This ensures that a mutex is always unlocked when leaving a function or block.
extern pthread_mutex_t mutex_replystr;
extern pthread_mutex_t command_mutex;
extern pthread_mutex_t mutex_vfoque;
extern pthread_mutex_t mutex_serial;
extern pthread_mutex_t debug_mutex;
extern pthread_mutex_t mutex_rcv_socket;
extern pthread_mutex_t mutex_ptt;
extern pthread_mutex_t mutex_srvc_reqs;
extern pthread_mutex_t mutex_trace;
// Change to 1 to observe guard lock/unlock processing on stdout
//#define DEBUG_GUARD_LOCK 0
//guard_lock::guard_lock(pthread_mutex_t* m, int h) : mutex(m), how(h) {
//char szlock[100];
// pthread_mutex_lock(mutex);
// snprintf(szlock, sizeof(szlock), "lock %s : %d", name(mutex), how);
// how = h
// if (how >= 100)
// trace(1, szlock);
// if (how != 0 && DEBUG_GUARD_LOCK)
// printf("%s", szlock);
//}
//guard_lock::~guard_lock(void) {
//char szunlock[100];
// snprintf(szunlock, sizeof(szunlock), "unlock %s : %d\n", name(mutex), how);
// if (how >= 100)
// trace(1, szunlock);
// if (how != 0 && DEBUG_GUARD_LOCK)
// printf("%s", szunlock);
// pthread_mutex_unlock(mutex);
//}
guard_lock::guard_lock(pthread_mutex_t* m, std::string h) : mutex(m) {
pthread_mutex_lock(mutex);
if (!h.empty()) {
how = h;
std::string szlock;
szlock.assign("lock ").append(name(mutex)).append(" : ").append(how);
start_time = zmsec();
// trace(1, szlock.c_str());
lock_trace(1, szlock.c_str());
}
}
guard_lock::~guard_lock(void) {
if (!how.empty()) {
char szlock[200];
snprintf(szlock, sizeof(szlock), "%s, %s locked for %lu msec", how.c_str(), name(mutex), zmsec() - start_time);
lock_trace(1, szlock);
}
pthread_mutex_unlock(mutex);
}
const char * guard_lock::name(pthread_mutex_t *m) {
if (m == &mutex_replystr) return "mutex_replystr";
if (m == &command_mutex) return "command_mutex";
if (m == &mutex_replystr) return "mutex_replystr";
if (m == &mutex_vfoque) return "mutex_vfoque";
if (m == &mutex_serial) return "mutex_serial";
if (m == &debug_mutex) return "debug_mutex";
if (m == &mutex_rcv_socket) return "mutex_rcv_socket";
if (m == &mutex_ptt) return "mutex_ptt";
if (m == &mutex_srvc_reqs) return "mutex_service_requests";
if (m == &mutex_trace) return "mutex_trace";
return "";
}
flrig-2.0.04/src/support/trace.cxx 0000664 0001750 0001750 00000023152 14505023115 013747 0000000 0000000 // ----------------------------------------------------------------------------
// Copyright (C) 2014
// David Freese, W1HKJ
//
// This file is part of flrig.
//
// flrig is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation; either version 3 of the License, or
// (at your option) any later version.
//
// flrig is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program. If not, see .
// ----------------------------------------------------------------------------
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include "icons.h"
#include "support.h"
#include "debug.h"
#include "gettext.h"
#include "rig_io.h"
#include "dialogs.h"
#include "rigbase.h"
#include "ptt.h"
#include "socket_io.h"
#include "ui.h"
#include "tod_clock.h"
#include "trace.h"
#include "rig.h"
#include "rigs.h"
#include "K3_ui.h"
#include "KX3_ui.h"
#include "rigpanel.h"
#include "tod_clock.h"
Fl_Double_Window* tracewindow = (Fl_Double_Window *)0;
Fl_Text_Display* tracedisplay = (Fl_Text_Display *)0;
Fl_Text_Buffer* tracebuffer = (Fl_Text_Buffer*)0;
Fl_Button* btn_cleartrace = (Fl_Button*)0;
Fl_Light_Button* btn_pausetrace = (Fl_Light_Button*)0;
std::string tracestring;
bool stdout_trace = false;//true;
bool pausetrace = false;
static void cb_pausetrace(Fl_Light_Button *o, void *)
{
pausetrace = o->value();
}
static void cb_cleartrace(Fl_Button *, void *)
{
guard_lock tt(&mutex_trace);
tracedisplay->buffer()->text("");
tracestring.clear();
}
void make_trace_window() {
tracewindow = new Fl_Double_Window(600, 300, _("Trace log"));
tracedisplay = new Fl_Text_Display(0, 0, 600, 270);
tracebuffer = new Fl_Text_Buffer;
tracedisplay->buffer(tracebuffer);
tracedisplay->textfont(FL_SCREEN);
tracedisplay->wrap_mode(Fl_Text_Display::WRAP_NONE, 100);
btn_pausetrace = new Fl_Light_Button(430, 275, 80, 20, _("Pause"));
btn_pausetrace->callback((Fl_Callback *)cb_pausetrace);
btn_cleartrace = new Fl_Button(515, 275, 80, 20, _("Clear"));
btn_cleartrace->callback((Fl_Callback *)cb_cleartrace);
tracewindow->resizable(tracedisplay);
}
static void write_trace_file(std::string s)
{
std::string trace_fname = RigHomeDir;
trace_fname.append("trace.txt");
std::fstream tfile(trace_fname.c_str(), std::ios::app);
if (tfile)
tfile << s;
tfile.close();
}
static void update_tracetext(void *)
{
guard_lock tt(&mutex_trace);
if (tracewindow->visible()) {
if (!pausetrace) {
if (tracedisplay->buffer()->length() > 100000)
tracedisplay->buffer()->text("");
tracedisplay->insert(tracestring.c_str());
}
}
tracestring.clear();
}
void write_tracetext()
{
if (stdout_trace) {
std::cout << tracestring;
if (tracestring.find('\n') == std::string::npos) std::cout << std::endl;
std::cout.flush();
}
Fl::awake(update_tracetext);
}
void trace(int n, ...) // all args of type const char *
{
if (!progStatus.trace) return;
if (!tracewindow) make_trace_window();
if (!n) return;
std::stringstream s;
va_list vl;
va_start(vl, n);
s << ztime() << " : " << va_arg(vl, const char *);
for (int i = 1; i < n; i++)
s << " " << va_arg(vl, const char *);
va_end(vl);
s << "\n";
write_trace_file(s.str());
guard_lock tt(&mutex_trace);
tracestring.append(s.str());
write_tracetext();
}
#include "XmlRpc.h"
void xml_trace(int n, ...) // all args of type const char *
{
if (!progStatus.xmltrace) return;
if (!tracewindow) make_trace_window();
if (!n) return;
std::stringstream s;
va_list vl;
va_start(vl, n);
s << ztime();
#ifdef HAS_XMLRPC_CLIENT_ID
s << " [" << XmlRpc::client_id << "]";
#endif
s << " : " << va_arg(vl, const char *);
for (int i = 1; i < n; i++)
s << " " << va_arg(vl, const char *);
va_end(vl);
s << "\n";
write_trace_file(s.str());
guard_lock tt(&mutex_trace);
tracestring.append(s.str());
write_tracetext();
}
void rig_trace(int n, ...) // all args of type const char *
{
if (!progStatus.rigtrace) return;
if (!n) return;
if (!tracewindow) make_trace_window();
std::stringstream s;
va_list vl;
va_start(vl, n);
s << ztime() << " : " << va_arg(vl, const char *);
for (int i = 1; i < n; i++)
s << " " << va_arg(vl, const char *);
va_end(vl);
s << "\n";
write_trace_file(s.str());
guard_lock tt(&mutex_trace);
tracestring.append(s.str());
write_tracetext();
}
void set_trace(int n, ...) // all args of type const char *
{
if (!progStatus.settrace) return;
if (!tracewindow) make_trace_window();
if (!n) return;
std::stringstream s;
va_list vl;
va_start(vl, n);
s << ztime() << " : " << va_arg(vl, const char *);
for (int i = 1; i < n; i++)
s << " " << va_arg(vl, const char *);
va_end(vl);
s << "\n";
write_trace_file(s.str());
guard_lock tt(&mutex_trace);
tracestring.append(s.str());
write_tracetext();
}
void get_trace(int n, ...) // all args of type const char *
{
if (!progStatus.gettrace) return;
if (!tracewindow) make_trace_window();
if (!n) return;
std::stringstream s;
va_list vl;
va_start(vl, n);
s << ztime() << " : " << va_arg(vl, const char *);
for (int i = 1; i < n; i++)
s << " " << va_arg(vl, const char *);
va_end(vl);
s << "\n";
write_trace_file(s.str());
guard_lock tt(&mutex_trace);
tracestring.append(s.str());
write_tracetext();
}
void rpc_trace(int n, ...) // all args of type const char *
{
if (!n) return;
std::stringstream s;
va_list vl;
va_start(vl, n);
s << ztime() << " : " << va_arg(vl, const char *);
for (int i = 1; i < n; i++)
s << " " << va_arg(vl, const char *);
va_end(vl);
std::string str = s.str();
size_t p = str.find("\r\n");
while (p != std::string::npos) {
str.replace(p, 2, "\n");
p = str.find("\r\n");
}
p = str.find("\r");
while (p != std::string::npos) {
str.replace(p, 1, "\n");
p = str.find("\r");
}
p = str.find("\t");
while (p != std::string::npos) {
str.erase(p, 1);
p = str.find("\t");
}
int indent = 0;
p = str.find("<");
while (p != std::string::npos) {
if (str[p+1] != '/') {
str.insert(p, "\n");
str.insert(p+1, indent, ' ');
indent += 2;
} else {
str.insert(p, "\n");
indent -= 2;
str.insert(p+1, indent, ' ');
}
if (indent < 0) indent = 0;
p = str.find(">", p);
p = str.find("<", p);
}
p = str.find("\n\n");
while (p != std::string::npos) {
str.erase(p,1);
p = str.find("\n\n");
}
if (str[str.length()-1] != '\n') str += '\n';
if (!tracewindow) make_trace_window();
if (!progStatus.rpctrace) return;
if (!n) return;
write_trace_file(s.str());
guard_lock tt(&mutex_trace);
tracestring.append(s.str());
write_tracetext();
}
void ser_trace(int n, ...) // all args of type const char *
{
if (!progStatus.serialtrace) return;
if (!tracewindow) make_trace_window();
if (!n) return;
std::stringstream s;
va_list vl;
va_start(vl, n);
s << ztime() << " : " << va_arg(vl, const char *);
for (int i = 1; i < n; i++)
s << " " << va_arg(vl, const char *);
va_end(vl);
s << "\n";
write_trace_file(s.str());
guard_lock tt(&mutex_trace);
tracestring.append(s.str());
write_tracetext();
}
void deb_trace(int n, ...) // all args of type const char *
{
if (!n) return;
if (!tracewindow) make_trace_window();
std::stringstream s;
va_list vl;
va_start(vl, n);
s << ztime() << " : " << va_arg(vl, const char *);
for (int i = 1; i < n; i++)
s << " " << va_arg(vl, const char *);
va_end(vl);
std::string str = s.str();
size_t p = str.find("\r\n");
while (p != std::string::npos) {
str.replace(p, 2, "\n");
p = str.find("\r\n");
}
p = str.find("\r");
while (p != std::string::npos) {
str.replace(p, 1, "\n");
p = str.find("\r");
}
p = str.find("\t");
while (p != std::string::npos) {
str.erase(p, 1);
p = str.find("\t");
}
int indent = 0;
p = str.find("<");
while (p != std::string::npos) {
if (str[p+1] != '/') {
str.insert(p, "\n");
str.insert(p+1, indent, ' ');
indent += 2;
} else {
str.insert(p, "\n");
indent -= 2;
str.insert(p+1, indent, ' ');
}
if (indent < 0) indent = 0;
p = str.find(">", p);
p = str.find("<", p);
}
p = str.find("\n\n");
while (p != std::string::npos) {
str.erase(p,1);
p = str.find("\n\n");
}
if (str[str.length()-1] != '\n') str += '\n';
write_trace_file(s.str());
guard_lock tt(&mutex_trace);
tracestring.append(s.str());
write_tracetext();
}
void tci_trace(int n, ...) // all args of type const char *
{
// if (!progStatus.tcitrace) return;
if (!n) return;
if (!tracewindow) make_trace_window();
std::stringstream s;
va_list vl;
va_start(vl, n);
s << ztime() << " : " << va_arg(vl, const char *);
for (int i = 1; i < n; i++)
s << " " << va_arg(vl, const char *);
va_end(vl);
s << "\n";
write_trace_file(s.str());
guard_lock tt(&mutex_trace);
tracestring.append(s.str());
write_tracetext();
}
bool activate_lock_trace = false;
void lock_trace(int n, ...) // all args of type const char *
{
if (!n || !activate_lock_trace) return;
if (!tracewindow) make_trace_window();
std::stringstream s;
va_list vl;
va_start(vl, n);
s << ztime() << " : " << va_arg(vl, const char *);
for (int i = 1; i < n; i++)
s << " " << va_arg(vl, const char *);
va_end(vl);
s << "\n";
write_trace_file(s.str());
guard_lock tt(&mutex_trace);
tracestring.append(s.str());
write_tracetext();
}
flrig-2.0.04/src/support/dialogs.cxx 0000664 0001750 0001750 00000165401 14504050363 014303 0000000 0000000 // ----------------------------------------------------------------------------
// Copyright (C) 2014
// David Freese, W1HKJ
//
// This file is part of flrig.
//
// flrig is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation; either version 3 of the License, or
// (at your option) any later version.
//
// flrig is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program. If not, see .
// ----------------------------------------------------------------------------
#include "config.h"
#include "compat.h" // Must precede all FL includes
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#ifndef __WIN32__
#include
#include
#include
#include
#include
#endif
#include "dialogs.h"
#include "rigs.h"
#include "util.h"
#include "debug.h"
#include "serial.h"
#include "support.h"
#include "rigpanel.h"
#include "rigbase.h"
#include "font_browser.h"
#include "ui.h"
#include "status.h"
#include "rig.h"
#include "socket_io.h"
#include "rigpanel.h"
#include "gettext.h"
#include "cwioUI.h"
#include "fskioUI.h"
Fl_Double_Window *dlgDisplayConfig = NULL;
Fl_Double_Window *dlgXcvrConfig = NULL;
Fl_Double_Window *dlgMemoryDialog = NULL;
Fl_Double_Window *dlgControls = NULL;
Font_Browser *fntbrowser = NULL;
Fl_Color flrig_def_color(int);
//======================================================================
// test comm ports
//======================================================================
void clear_combos()
{
selectCommPort->clear();
selectAuxPort->clear();
selectSepPTTPort->clear();
selectCommPort->add("NONE");
selectCommPort->add("xml_client");
selectAuxPort->add("NONE");
selectSepPTTPort->add("NONE");
select_cwioPORT->add("NONE");
select_fskioPORT->add("NONE");
}
void add_combos(char *port)
{
if (progStatus.serialtrace) {
static char sztr[100];
snprintf(sztr, sizeof(sztr), "Discovered %s", port);
ser_trace(1, sztr);
}
selectCommPort->add(port);
selectAuxPort->add(port);
selectSepPTTPort->add(port);
select_cwioPORT->add(port);
select_fskioPORT->add(port);
}
void set_combo_value()
{
selectCommPort->value(progStatus.xcvr_serial_port.c_str());
selectAuxPort->value(progStatus.aux_serial_port.c_str());
selectSepPTTPort->value(progStatus.sep_serial_port.c_str());
select_cwioPORT->value(progStatus.cwioPORT.c_str());
select_fskioPORT->value(progStatus.FSK_PORT.c_str());
}
//======================================================================
// WIN32 init_port_combos
//======================================================================
#ifdef __WIN32__
static bool open_serial(const char* dev)
{
bool ret = false;
HANDLE fd = CreateFile(dev, GENERIC_READ | GENERIC_WRITE, 0, 0, OPEN_EXISTING, 0, 0);
if (fd != INVALID_HANDLE_VALUE) {
CloseHandle(fd);
ret = true;
}
return ret;
}
# define TTY_MAX 255
void init_port_combos()
{
clear_combos();
char ttyname[21];
const char tty_fmt[] = "//./COM%u";
for (unsigned j = 0; j < TTY_MAX; j++) {
snprintf(ttyname, sizeof(ttyname), tty_fmt, j);
if (!open_serial(ttyname))
continue;
snprintf(ttyname, sizeof(ttyname), "COM%u", j);
LOG_WARN("Found serial port %s", ttyname);
add_combos(ttyname);
}
set_combo_value();
}
#endif //__WIN32__
//======================================================================
// Linux init_port_combos
//======================================================================
#ifdef __linux__
#ifndef PATH_MAX
# define PATH_MAX 1024
#endif
# define TTY_MAX 8
void init_port_combos()
{
struct stat st;
char ttyname[PATH_MAX + 1];
bool ret = false;
DIR* sys = NULL;
char cwd[PATH_MAX] = { '.', '\0' };
clear_combos();
LOG_QUIET("%s","Search for serial ports");
glob_t gbuf;
glob("/dev/pts/*", 0, NULL, &gbuf);
for (size_t j = 0; j < gbuf.gl_pathc; j++) {
if ( !(stat(gbuf.gl_pathv[j], &st) == 0 && S_ISCHR(st.st_mode)) ||
strstr(gbuf.gl_pathv[j], "modem") )
continue;
LOG_QUIET("Found virtual serial port %s", gbuf.gl_pathv[j]);
add_combos(gbuf.gl_pathv[j]);
}
globfree(&gbuf);
glob("/dev/serial/by-id/*", 0, NULL, &gbuf);
for (size_t j = 0; j < gbuf.gl_pathc; j++) {
if ( !(stat(gbuf.gl_pathv[j], &st) == 0 && S_ISCHR(st.st_mode)) ||
strstr(gbuf.gl_pathv[j], "modem") )
continue;
LOG_QUIET("Found serial port %s", gbuf.gl_pathv[j]);
add_combos(gbuf.gl_pathv[j]);
}
globfree(&gbuf);
glob("/dev/tty*", 0, NULL, &gbuf);
for (size_t j = 0; j < gbuf.gl_pathc; j++) {
if ( !(stat(gbuf.gl_pathv[j], &st) == 0 && S_ISCHR(st.st_mode)) ||
strstr(gbuf.gl_pathv[j], "modem") )
continue;
LOG_QUIET("Found serial port %s", gbuf.gl_pathv[j]);
add_combos(gbuf.gl_pathv[j]);
}
globfree(&gbuf);
glob("/dev/tnt*", 0, NULL, &gbuf);
for (size_t j = 0; j < gbuf.gl_pathc; j++) {
if ( !(stat(gbuf.gl_pathv[j], &st) == 0 && S_ISCHR(st.st_mode)) ||
strstr(gbuf.gl_pathv[j], "modem") )
continue;
LOG_QUIET("Found serial port %s", gbuf.gl_pathv[j]);
add_combos(gbuf.gl_pathv[j]);
}
globfree(&gbuf);
if (getcwd(cwd, sizeof(cwd)) == NULL) goto out;
if (chdir("/sys/class/tty") == -1) goto check_cuse;
if ((sys = opendir(".")) == NULL) goto check_cuse;
ssize_t len;
struct dirent* dp;
LOG_QUIET("%s", "Searching /sys/class/tty/");
while ((dp = readdir(sys))) {
# ifdef _DIRENT_HAVE_D_TYPE
if (dp->d_type != DT_LNK)
continue;
# endif
if ((len = readlink(dp->d_name, ttyname, sizeof(ttyname)-1)) == -1)
continue;
ttyname[len] = '\0';
if (!strstr(ttyname, "/devices/virtual/")) {
snprintf(ttyname, sizeof(ttyname), "/dev/%s", dp->d_name);
if (stat(ttyname, &st) == -1 || !S_ISCHR(st.st_mode))
continue;
LOG_QUIET("Found serial port %s", ttyname);
add_combos(ttyname);
ret = true;
}
}
check_cuse:
if (sys) {
closedir(sys);
sys = NULL;
}
if (chdir("/sys/class/cuse") == -1) goto out;
if ((sys = opendir(".")) == NULL) goto out;
LOG_QUIET("%s", "Searching /sys/class/cuse/");
while ((dp = readdir(sys))) {
# ifdef _DIRENT_HAVE_D_TYPE
if (dp->d_type != DT_LNK)
continue;
# endif
if ((len = readlink(dp->d_name, ttyname, sizeof(ttyname)-1)) == -1)
continue;
ttyname[len] = '\0';
if (strstr(ttyname, "/devices/virtual/") && !strncmp(dp->d_name, "mhuxd", 5)) {
char *name = strdup(dp->d_name);
if(!name)
continue;
char *p = strchr(name, '!');
if(p)
*p = '/';
snprintf(ttyname, sizeof(ttyname), "/dev/%s", name);
free(name);
if (stat(ttyname, &st) == -1 || !S_ISCHR(st.st_mode))
continue;
LOG_QUIET("Found serial port %s", ttyname);
add_combos(ttyname);
ret = true;
}
}
out:
std::string tty_virtual = HomeDir;
tty_virtual.append("vdev");
LOG_QUIET("Searching %s", tty_virtual.c_str());
tty_virtual.append("/ttyS%u");
for (unsigned j = 0; j < TTY_MAX; j++) {
snprintf(ttyname, sizeof(ttyname), tty_virtual.c_str(), j);
if ( !(stat(ttyname, &st) == 0 && S_ISCHR(st.st_mode)) )
continue;
LOG_QUIET("Found serial port %s", ttyname);
add_combos(ttyname);
}
if (sys) closedir(sys);
if (chdir(cwd) == -1) return;
if (ret) { // do we need to fall back to the probe code below?
set_combo_value();
return;
}
const char* tty_fmt[] = {
"/dev/ttyS%u",
"/dev/ttyUSB%u",
"/dev/usb/ttyUSB%u"
};
LOG_QUIET("%s", "Serial port discovery via 'stat'");
for (size_t i = 0; i < sizeof(tty_fmt)/sizeof(*tty_fmt); i++) {
for (unsigned j = 0; j < TTY_MAX; j++) {
snprintf(ttyname, sizeof(ttyname), tty_fmt[i], j);
if ( !(stat(ttyname, &st) == 0 && S_ISCHR(st.st_mode)) )
continue;
LOG_WARN("Found serial port %s", ttyname);
add_combos(ttyname);
}
}
set_combo_value();
}
#endif // __linux__
//======================================================================
// APPLE init_port_combos
//======================================================================
#ifdef __APPLE__
#ifndef PATH_MAX
# define PATH_MAX 1024
#endif
void init_port_combos()
{
std::string pname;
const char* tty_fmt[] = {
"/dev/cu.*",
"/dev/tty.*"
};
struct stat st;
clear_combos();
glob_t gbuf;
bool is_serial;
clear_combos();
for (size_t i = 0; i < sizeof(tty_fmt)/sizeof(*tty_fmt); i++) {
glob(tty_fmt[i], 0, NULL, &gbuf);
for (size_t j = 0; j < gbuf.gl_pathc; j++) {
int ret1 = !stat(gbuf.gl_pathv[j], &st);
int ret2 = S_ISCHR(st.st_mode);
if (ret1) {
LOG_INFO("Serial port %s", gbuf.gl_pathv[j]);
LOG_INFO(" device mode: %X", st.st_mode);
LOG_INFO(" char device? %s", ret2 ? "Y" : "N");
} else
LOG_INFO("%s does not return stat query", gbuf.gl_pathv[j]);
if ( (ret1 && ret2 ) || strstr(gbuf.gl_pathv[j], "modem") )
add_combos (gbuf.gl_pathv[j]);
}
globfree(&gbuf);
}
set_combo_value();
}
#endif //__APPLE__
//======================================================================
//======================================================================
// FreeBSD init_port_combos
//======================================================================
#ifdef __FreeBSD__
#ifndef PATH_MAX
# define PATH_MAX 1024
#endif
# define TTY_MAX 8
void init_port_combos()
{
int retval;
struct stat st;
char ttyname[PATH_MAX + 1];
const char* tty_fmt[] = {
"/dev/ttyd%u"
};
clear_combos();
for (size_t i = 0; i < sizeof(tty_fmt)/sizeof(*tty_fmt); i++) {
for (unsigned j = 0; j < TTY_MAX; j++) {
snprintf(ttyname, sizeof(ttyname), tty_fmt[i], j);
if ( !(stat(ttyname, &st) == 0 && S_ISCHR(st.st_mode)) )
continue;
LOG_WARN("Found serial port %s", ttyname);
add_combos(ttyname);
}
}
}
#endif //__FreeBSD__
//======================================================================
//======================================================================
// OpenBSD init_port_combos
//======================================================================
#ifdef __OpenBSD__
#ifndef PATH_MAX
# define PATH_MAX 1024
#endif
# define TTY_MAX 8
void init_port_combos()
{
int retval;
struct stat st;
char ttyname[PATH_MAX + 1];
const char* tty_fmt[] = {
"/dev/ttyd%u",
"/dev/ttyU%u",
}
clear_combos();
for (size_t i = 0; i < sizeof(tty_fmt)/sizeof(*tty_fmt); i++) {
for (unsigned j = 0; j < TTY_MAX; j++) {
snprintf(ttyname, sizeof(ttyname), tty_fmt[i], j);
if ( !(stat(ttyname, &st) == 0 && S_ISCHR(st.st_mode)) )
continue;
LOG_WARN("Found serial port %s", ttyname);
add_combos(ttyname);
}
}
}
#endif //__OpenBSD__
//======================================================================
void cbCIVdefault()
{
char hexstr[8];
rigbase *srig = (rigbase *)(selectRig->data());
xcvr_name = srig->name_;
LOG_INFO("picked %s", xcvr_name.c_str());
snprintf(hexstr, sizeof(hexstr), "0x%02X", srig->defaultCIV);
txtCIV->value(hexstr);
progStatus.CIV = srig->defaultCIV;
srig->adjustCIV(progStatus.CIV);
}
void cbCIV()
{
int picked = selectRig->index();
int adr = 0;
rigbase *srig = rigs[picked];
sscanf(txtCIV->value(), "0x%2X", &adr);
progStatus.CIV = adr;
srig->adjustCIV(progStatus.CIV);
}
void cbUSBaudio()
{
progStatus.USBaudio = btnUSBaudio->value();
}
void configXcvr()
{
selectCommPort->value(progStatus.xcvr_serial_port.c_str());
selectAuxPort->value(progStatus.aux_serial_port.c_str());
selectSepPTTPort->value(progStatus.sep_serial_port.c_str());
if (selrig->CIV) {
char hexstr[8];
snprintf(hexstr, sizeof(hexstr), "0x%02X", selrig->CIV);
txtCIV->value(hexstr);
txtCIV->activate();
btnCIVdefault->activate();
if (xcvr_name == rig_IC7200.name_ ||
xcvr_name == rig_IC7300.name_ ||
xcvr_name == rig_IC7600.name_ ) {
btnUSBaudio->value(progStatus.USBaudio);
btnUSBaudio->activate();
} else
btnUSBaudio->deactivate();
} else {
txtCIV->value("");
txtCIV->deactivate();
btnCIVdefault->deactivate();
btnUSBaudio->value(0);
btnUSBaudio->deactivate();
}
select_tab(_("Xcvr"));
}
void open_poll_tab()
{
select_tab(_("Poll"));
}
void open_trace_tab()
{
select_tab(_("Trace"));
}
void open_commands_tab()
{
select_tab(_("Commands"));
}
void open_restore_tab()
{
select_tab(_("Restore"));
}
void open_send_command_tab()
{
select_tab(_("Send"));
}
void open_tcpip_tab()
{
select_tab(_("TCPIP & TCI"));
}
void open_cmedia_tab()
{
select_tab(_("PTT-Cmedia"));
}
void open_tmate2_tab()
{
select_tab(_("TMATE-2"));
}
void open_ptt_tab()
{
select_tab(_("PTT-Generic"));
}
void open_gpio_tab()
{
select_tab(_("PTT-GPIO"));
}
void open_other_tab()
{
select_tab(_("Other"));
}
void open_server_tab()
{
select_tab(_("Server"));
}
void open_client_tab()
{
select_tab(_("Client"));
}
void createXcvrDialog()
{
dlgXcvrConfig = XcvrDialog();
init_port_combos();
mnuBaudrate->clear();
for (int i = 0; szBaudRates[i] != NULL; i++)
mnuBaudrate->add(szBaudRates[i]);
cbo_tt550_agc_level->add("slow");
cbo_tt550_agc_level->add("med");
cbo_tt550_agc_level->add("fast");
cbo_tt550_agc_level->index(progStatus.tt550_agc_level);
cbo_tt550_nb_level->add("NONE");
cbo_tt550_nb_level->add("1");
cbo_tt550_nb_level->add("2");
cbo_tt550_nb_level->add("3");
cbo_tt550_nb_level->add("4");
cbo_tt550_nb_level->add("5");
cbo_tt550_nb_level->add("6");
cbo_tt550_nb_level->add("7");
cbo_tt550_nb_level->index(progStatus.tt550_nb_level);
initRigCombo();
}
// Frequency display font / colors
Fl_Font selfont;
void cbFreqControlFontBrowser(Fl_Widget*, void*) {
selfont = fntbrowser->fontNumber();
lblTest->labelfont(selfont);
dlgDisplayConfig->redraw();
fntbrowser->hide();
}
void cbPrefFont()
{
fntbrowser->fontNumber(progStatus.fontnbr);
// fntbrowser->fontFilter(Font_Browser::FIXED_WIDTH);
// fntbrowser->fontFilter(Font_Browser::ALL_TYPES);
fntbrowser->callback(cbFreqControlFontBrowser);
fntbrowser->show();
}
uchar fg_red, fg_green, fg_blue;
uchar bg_red, bg_green, bg_blue;
uchar smeterRed, smeterGreen, smeterBlue;
uchar peakRed, peakGreen, peakBlue;
uchar pwrRed, pwrGreen, pwrBlue;
uchar swrRed, swrGreen, swrBlue;
uchar voltRed, voltGreen, voltBlue;
Fl_Color bgclr;
Fl_Color fgclr;
Fl_Color fgsys;
static uchar fg_sys_red, fg_sys_green, fg_sys_blue;
Fl_Color bgsys;
static uchar bg_sys_red, bg_sys_green, bg_sys_blue;
Fl_Color bg2sys;
static uchar bg2_sys_red, bg2_sys_green, bg2_sys_blue;
Fl_Color bg_slider;
static uchar bg_slider_red, bg_slider_green, bg_slider_blue;
Fl_Color btn_slider;
static uchar btn_slider_red, btn_slider_green, btn_slider_blue;
Fl_Color btn_lt_color;
static uchar btn_lt_color_red, btn_lt_color_green, btn_lt_color_blue;
Fl_Color tab_color;
static uchar tab_red, tab_green, tab_blue;
void cb_lighted_button()
{
uchar r = btn_lt_color_red, g = btn_lt_color_green, b = btn_lt_color_blue;
if (fl_color_chooser("Foreground color", r, g, b)) {
btn_lt_color_red = r; btn_lt_color_green = g; btn_lt_color_blue = b;
btn_lt_color = fl_rgb_color(r, g, b);
btn_lighted->selection_color(btn_lt_color);
btn_lighted->value(1);
btn_lighted->redraw();
}
}
void cb_lighted_default()
{
btn_lt_color = flrig_def_color(FL_YELLOW);
btn_lt_color_red = ((btn_lt_color >> 24) & 0xFF);
btn_lt_color_green = ((btn_lt_color >> 16) & 0xFF);
btn_lt_color_blue = ((btn_lt_color >> 8) & 0xFF);
btn_lighted->selection_color(btn_lt_color);
btn_lighted->value(1);
btn_lighted->redraw();
}
void cb_change_hrd_button()
{
progStatus.hrd_buttons = !progStatus.hrd_buttons;
FreqDispA->set_hrd(progStatus.hrd_buttons);
FreqDispB->set_hrd(progStatus.hrd_buttons);
}
void set_sliders_when()
{
if (sldrSQUELCH)
sldrSQUELCH->when(progStatus.sliders_button);
if (sldrMICGAIN)
sldrMICGAIN->when(progStatus.sliders_button);
if (sldrIFSHIFT)
sldrIFSHIFT->when(progStatus.sliders_button);
if (sldrNR)
sldrNR->when(progStatus.sliders_button);
if (sldrNOTCH)
sldrNOTCH->when(progStatus.sliders_button);
if (sldrRFGAIN)
sldrRFGAIN->when(progStatus.sliders_button);
if (sldrINNER)
sldrINNER->when(progStatus.sliders_button);
if (sldrOUTER)
sldrOUTER->when(progStatus.sliders_button);
if (sldrPOWER)
sldrPOWER->when(progStatus.sliders_button);
if (sldrVOLUME)
sldrVOLUME->when(progStatus.sliders_button);
if (ic7610_digi_sel_val)
ic7610_digi_sel_val->when(progStatus.sliders_button);
if (sldr_nb_level)
sldr_nb_level->when(progStatus.sliders_button);
}
void cb_change_sliders_button()
{
if (progStatus.sliders_button == FL_WHEN_CHANGED)
progStatus.sliders_button = FL_WHEN_RELEASE;
else
progStatus.sliders_button = FL_WHEN_CHANGED;
set_sliders_when();
}
void cb_slider_defaults()
{
bg_slider_red = 232;
bg_slider_green = 255;
bg_slider_blue = 232;
btn_slider_red = 0;
btn_slider_green = 0;
btn_slider_blue = 128;
bg_slider = fl_rgb_color( 232, 255, 232);
btn_slider = fl_rgb_color( 0, 0, 128);
sldrColors->color(bg_slider);
sldrColors->selection_color(btn_slider);
sldrColors->redraw();
}
void cb_slider_background()
{
uchar r = bg_slider_red, g = bg_slider_green, b = bg_slider_blue;
if (fl_color_chooser("Foreground color", r, g, b)) {
bg_slider_red = r; bg_slider_green = g; bg_slider_blue = b;
bg_slider = fl_rgb_color(r, g, b);
sldrColors->color(bg_slider);
sldrColors->selection_color(btn_slider);
sldrColors->redraw();
}
}
void cb_slider_select()
{
uchar r = btn_slider_red, g = btn_slider_green, b = btn_slider_blue;
if (fl_color_chooser("Foreground color", r, g, b)) {
btn_slider_red = r; btn_slider_green = g; btn_slider_blue = b;
btn_slider = fl_rgb_color(r, g, b);
sldrColors->color(bg_slider);
sldrColors->selection_color(btn_slider);
sldrColors->redraw();
}
}
void cb_sys_defaults()
{
bgsys = flrig_def_color(FL_BACKGROUND_COLOR);
bg_sys_red = ((bgsys >> 24) & 0xFF);
bg_sys_green = ((bgsys >> 16) & 0xFF);
bg_sys_blue = ((bgsys >> 8) & 0xFF);
bg2sys = flrig_def_color(FL_BACKGROUND2_COLOR);
bg2_sys_red = ((bg2sys) >> 24 & 0xFF);
bg2_sys_green = ((bg2sys) >> 16 & 0xFF);
bg2_sys_blue = ((bg2sys) >> 8 & 0xFF);
fgsys = flrig_def_color(FL_FOREGROUND_COLOR);
fg_sys_red = (fgsys >> 24) & 0xFF;
fg_sys_green = (fgsys >> 16) & 0xFF;
fg_sys_blue = (fgsys >> 8) & 0xFF;
Fl::background(bg_sys_red, bg_sys_green, bg_sys_blue);
Fl::background2(bg2_sys_red, bg2_sys_green, bg2_sys_blue);
Fl::foreground(fg_sys_red, fg_sys_green, fg_sys_blue);
dlgDisplayConfig->redraw();
mainwindow->redraw();
}
void cb_sys_foreground()
{
uchar r = fg_sys_red, g = fg_sys_green, b = fg_sys_blue;
if (fl_color_chooser("Foreground color", r, g, b)) {
fg_sys_red = r; fg_sys_green = g; fg_sys_blue = b;
fgsys = fl_rgb_color(r, g, b);
Fl::foreground(r, g, b);
dlgDisplayConfig->redraw();
mainwindow->redraw();
}
}
void cb_sys_background()
{
uchar r = bg_sys_red, g = bg_sys_green, b = bg_sys_blue;
if (fl_color_chooser("Background color", r, g, b)) {
bg_sys_red = r; bg_sys_green = g; bg_sys_blue = b;
bgsys = fl_rgb_color(r, g, b);
Fl::background(r, g, b);
dlgDisplayConfig->redraw();
mainwindow->redraw();
}
}
void cb_sys_background2()
{
uchar r = bg2_sys_red, g = bg2_sys_green, b = bg2_sys_blue;
if (fl_color_chooser("Background2 color", r, g, b)) {
bg2_sys_red = r; bg2_sys_green = g; bg2_sys_blue = b;
bg2sys = fl_rgb_color(r, g, b);
Fl::background2(r, g, b);
dlgDisplayConfig->redraw();
mainwindow->redraw();
}
}
void cbBacklightColor()
{
uchar r = bg_red, g = bg_green, b = bg_blue;
if (fl_color_chooser("Background color", r, g, b)) {
bg_red = r; bg_green = g; bg_blue = b;
bgclr = fl_rgb_color(r, g, b);
lblTest->color(bgclr);
sldrRcvSignalColor->color( fl_rgb_color (smeterRed, smeterGreen, smeterBlue), bgclr );
sldrPWRcolor->color(fl_rgb_color (pwrRed, pwrGreen, pwrBlue), bgclr);
sldrSWRcolor->color(fl_rgb_color (swrRed, swrGreen, swrBlue), bgclr);
sldrVoltcolor->color(fl_rgb_color (voltRed, voltGreen, voltBlue), bgclr);
scaleSmeterColor->color(bgclr);
scalePWRcolor->color(bgclr);
scaleSWRcolor->color(bgclr);
scaleVoltcolor->color(bgclr);
grpMeterColor->color(bgclr);
dlgDisplayConfig->redraw();
}
}
void cbPrefForeground()
{
uchar r = fg_red, g = fg_green, b = fg_blue;
if (fl_color_chooser("Foreground color", r, g, b)) {
fg_red = r; fg_green = g; fg_blue = b;
fgclr = fl_rgb_color(r, g, b);
lblTest->labelcolor(fgclr);
scaleSmeterColor->labelcolor(fgclr);
scalePWRcolor->labelcolor(fgclr);
scaleSWRcolor->labelcolor(fgclr);
scaleVoltcolor->labelcolor(fgclr);
grpMeterColor->labelcolor(fgclr);
dlgDisplayConfig->redraw();
}
}
void default_meters()
{
Fl_Color c;
bg_red = 232; bg_green = 255; bg_blue = 232;
bgclr = fl_rgb_color( bg_red, bg_green, bg_blue);
lblTest->color(bgclr);
sldrRcvSignalColor->color( fl_rgb_color (smeterRed, smeterGreen, smeterBlue), bgclr );
sldrPWRcolor->color(fl_rgb_color (pwrRed, pwrGreen, pwrBlue), bgclr);
sldrSWRcolor->color(fl_rgb_color (swrRed, swrGreen, swrBlue), bgclr);
scaleSmeterColor->color(bgclr);
scalePWRcolor->color(bgclr);
scaleSWRcolor->color(bgclr);
scaleVoltcolor->color(bgclr);
grpMeterColor->color(bgclr);
fg_red = 0; fg_green = 0; fg_blue = 0;
fgclr = (Fl_Color)0;
lblTest->labelcolor(fgclr);
scaleSmeterColor->labelcolor(fgclr);
scalePWRcolor->labelcolor(fgclr);
scaleSWRcolor->labelcolor(fgclr);
scaleVoltcolor->labelcolor(fgclr);
grpMeterColor->labelcolor(fgclr);
smeterRed = 0; smeterGreen = 180; smeterBlue = 0;
c = fl_rgb_color (smeterRed, smeterGreen, smeterBlue);
sldrRcvSignalColor->color(c, bgclr );
peakRed = 255; peakGreen = 0; peakBlue = 0;
c = fl_rgb_color( peakRed, peakGreen, peakBlue );
sldrRcvSignalColor->PeakColor(c);
sldrPWRcolor->PeakColor(c);
sldrSWRcolor->PeakColor(c);
sldrVoltcolor->PeakColor(bgclr);
pwrRed = 180; pwrGreen = 0; pwrBlue = 0;
c = fl_rgb_color( pwrRed, pwrGreen, pwrBlue );
sldrPWRcolor->color(c, bgclr);
swrRed = 148; swrGreen = 0; swrBlue = 148;
c = fl_rgb_color(swrRed, swrGreen, swrBlue);
sldrSWRcolor->color(c, bgclr);
voltRed = 0; voltGreen = 0; voltBlue = 128;
voltRed = 0; voltGreen = 0; voltBlue = 255;
c = fl_rgb_color(voltRed, voltGreen, voltBlue);
sldrVoltcolor->color(c, bgclr);
dlgDisplayConfig->redraw();
}
void cbSMeterColor()
{
uchar r = smeterRed, g = smeterGreen, b = smeterBlue;
if (fl_color_chooser("S Meter color", r, g, b)) {
smeterRed = r; smeterGreen = g; smeterBlue = b;
sldrRcvSignalColor->color(
fl_rgb_color (r, g, b),
bgclr );
dlgDisplayConfig->redraw();
}
}
void cbPeakMeterColor()
{
uchar r = peakRed, g = peakGreen, b = peakBlue;
if (fl_color_chooser("Peak value color", r, g, b)) {
peakRed = r; peakGreen = g; peakBlue = b;
sldrRcvSignalColor->PeakColor(fl_rgb_color (r, g, b));
sldrPWRcolor->PeakColor(fl_rgb_color (r, g, b));
sldrSWRcolor->PeakColor(fl_rgb_color (r, g, b));
dlgDisplayConfig->redraw();
}
}
void cbPwrMeterColor()
{
uchar r = pwrRed, g = pwrGreen, b = pwrBlue;
if (fl_color_chooser("Power meter color", r, g, b)) {
pwrRed = r; pwrGreen = g; pwrBlue = b;
sldrPWRcolor->color(
fl_rgb_color (r, g, b),
bgclr );
dlgDisplayConfig->redraw();
}
}
void cbSWRMeterColor()
{
uchar r = swrRed, g = swrGreen, b = swrBlue;
if (fl_color_chooser("SWR meter color", r, g, b)) {
swrRed = r; swrGreen = g; swrBlue = b;
sldrSWRcolor->color(
fl_rgb_color (swrRed, swrGreen, swrBlue),
bgclr );
dlgDisplayConfig->redraw();
}
}
void cbVoltMeterColor()
{
uchar r = voltRed, g = voltGreen, b = voltBlue;
if (fl_color_chooser("Volt meter color", r, g, b)) {
voltRed = r; voltGreen = g; voltBlue = b;
sldrVoltcolor->color(
fl_rgb_color (voltRed, voltGreen, voltBlue),
bgclr );
dlgDisplayConfig->redraw();
}
}
void cb_tab_defaults()
{
tab_red = 230;
tab_green = 230;
tab_blue = 230;
tab_color = fl_rgb_color( tab_red, tab_green, tab_blue);
btn_tab_color->color(tab_color);
btn_tab_color->redraw();
if (tabsGeneric) {
tabsGeneric->selection_color(tab_color);
tabsGeneric->redraw();
}
if (tabs550) {
tabs550->selection_color(tab_color);
tabs550->redraw();
}
if (tabCmds) {
tabCmds->selection_color(tab_color);
tabCmds->redraw();
}
}
void cb_tab_colors()
{
uchar r = tab_red, g = tab_green, b = tab_blue;
if (fl_color_chooser("TAB color", r, g, b)) {
tab_red = r; tab_green = g; tab_blue = b;
tab_color = fl_rgb_color(r, g, b);
btn_tab_color->color(tab_color);
btn_tab_color->redraw();
if (tabsGeneric) {
tabsGeneric->selection_color(tab_color);
tabsGeneric->redraw();
}
if (tabs550) {
tabs550->selection_color(tab_color);
tabs550->redraw();
}
if (tabCmds) {
tabCmds->selection_color(tab_color);
tabCmds->redraw();
}
}
}
void setColors()
{
progStatus.swrRed = swrRed;
progStatus.swrGreen = swrGreen;
progStatus.swrBlue = swrBlue;
progStatus.pwrRed = pwrRed;
progStatus.pwrGreen = pwrGreen;
progStatus.pwrBlue = pwrBlue;
progStatus.smeterRed = smeterRed;
progStatus.smeterGreen = smeterGreen;
progStatus.smeterBlue = smeterBlue;
progStatus.peakRed = peakRed;
progStatus.peakGreen = peakGreen;
progStatus.peakBlue = peakBlue;
progStatus.voltRed = voltRed;
progStatus.voltGreen = voltGreen;
progStatus.voltBlue = voltBlue;
progStatus.fg_red = fg_red;
progStatus.fg_green = fg_green;
progStatus.fg_blue = fg_blue;
progStatus.bg_red = bg_red;
progStatus.bg_green = bg_green;
progStatus.bg_blue = bg_blue;
progStatus.fontnbr = selfont;
FreqDispA->font(selfont);
FreqDispB->font(selfont);
progStatus.fg_sys_red = fg_sys_red;
progStatus.fg_sys_green = fg_sys_green;
progStatus.fg_sys_blue = fg_sys_blue;
progStatus.bg_sys_red = bg_sys_red;
progStatus.bg_sys_green = bg_sys_green;
progStatus.bg_sys_blue = bg_sys_blue;
progStatus.bg2_sys_red = bg2_sys_red;
progStatus.bg2_sys_green = bg2_sys_green;
progStatus.bg2_sys_blue = bg2_sys_blue;
progStatus.slider_red = bg_slider_red;
progStatus.slider_green = bg_slider_green;
progStatus.slider_blue = bg_slider_blue;
progStatus.slider_btn_red = btn_slider_red;
progStatus.slider_btn_green = btn_slider_green;
progStatus.slider_btn_blue = btn_slider_blue;
progStatus.lighted_btn_red = btn_lt_color_red;
progStatus.lighted_btn_green = btn_lt_color_green;
progStatus.lighted_btn_blue = btn_lt_color_blue;
progStatus.tab_red = tab_red;
progStatus.tab_green = tab_green;
progStatus.tab_blue = tab_blue;
if (selrig->inuse == onB) {
FreqDispB->SetCOLORS( fl_rgb_color(fg_red, fg_green, fg_blue), bgclr);
FreqDispA->SetCOLORS(
fl_rgb_color(fg_red, fg_green, fg_blue),
fl_color_average(bgclr, FL_BLACK, 0.87));
} else {
FreqDispA->SetCOLORS( fl_rgb_color(fg_red, fg_green, fg_blue), bgclr);
FreqDispB->SetCOLORS(
fl_rgb_color(fg_red, fg_green, fg_blue),
fl_color_average(bgclr, FL_BLACK, 0.87));
}
grpMeters->color(bgclr);
meter_fill_box->color(bgclr);
scaleSmeter->color(bgclr);
scaleSmeter->labelcolor(fgclr);
mtr_SMETER->color(bgclr);
mtr_SMETER->labelcolor(fgclr);
scalePower->color(bgclr);
scalePower->labelcolor(fgclr);
mtr_PWR->color(bgclr);
mtr_PWR->labelcolor(fgclr);
scaleVoltage->color(bgclr);
scaleVoltage->labelcolor(fgclr);
scaleVoltage->redraw();
mtr_VOLTS->color(bgclr);
mtr_VOLTS->labelcolor(fgclr);
btnALC_IDD_SWR->color(bgclr);
btnALC_IDD_SWR->labelcolor(fgclr);
btnALC_IDD_SWR->redraw();
mtr_SWR->color(bgclr);
mtr_SWR->labelcolor(fgclr);
sldrFwdPwr->color(fl_rgb_color (pwrRed, pwrGreen, pwrBlue), bgclr);
sldrFwdPwr->PeakColor(fl_rgb_color(peakRed, peakGreen, peakBlue));
sldrVoltage->color(fl_rgb_color (voltRed, voltGreen, voltBlue), bgclr);
sldrVoltage->PeakColor(bgclr);//fl_rgb_color (voltRed, voltGreen, voltBlue));
sldrVoltage->redraw();
sldrRcvSignal->color(fl_rgb_color (smeterRed, smeterGreen, smeterBlue), bgclr);
sldrRcvSignal->PeakColor(fl_rgb_color(peakRed, peakGreen, peakBlue));
sldrALC->color(fl_rgb_color (swrRed, swrGreen, swrBlue), bgclr);
sldrALC->PeakColor(fl_rgb_color(peakRed, peakGreen, peakBlue));
sldrIDD->color(fl_rgb_color (swrRed, swrGreen, swrBlue), bgclr);
sldrIDD->PeakColor(fl_rgb_color(peakRed, peakGreen, peakBlue));
mtr_ALC->color(bgclr);
mtr_ALC->labelcolor(fgclr);
sldrIDD->color(fl_rgb_color (swrRed, swrGreen, swrBlue), bgclr);
sldrIDD->PeakColor(fl_rgb_color(peakRed, peakGreen, peakBlue));
mtr_IDD->color(bgclr);
mtr_IDD->labelcolor(fgclr);
sldrSWR->color(fl_rgb_color (swrRed, swrGreen, swrBlue), bgclr);
sldrSWR->PeakColor(fl_rgb_color(peakRed, peakGreen, peakBlue));
grpMeters->redraw();
if (btnVol) btnVol->selection_color(btn_lt_color);
if (btnNR) btnNR->selection_color(btn_lt_color);
if (btnIFsh) btnIFsh->selection_color(btn_lt_color);
if (btnNotch) btnNotch->selection_color(btn_lt_color);
if (btnA) btnA->selection_color(btn_lt_color);
if (btnB) btnB->selection_color(btn_lt_color);
if (btnSplit) btnSplit->selection_color(btn_lt_color);
if (btnAttenuator) btnAttenuator->selection_color(btn_lt_color);
if (btnPreamp) btnPreamp->selection_color(btn_lt_color);
if (btnNOISE) btnNOISE->selection_color(btn_lt_color);
if (btnAutoNotch) btnAutoNotch->selection_color(btn_lt_color);
if (btnTune) btnTune->selection_color(btn_lt_color);
if (btn_tune_on_off) btn_tune_on_off->selection_color(btn_lt_color);
if (btnPTT) btnPTT->selection_color(btn_lt_color);
if (btnLOCK) btnLOCK->selection_color(btn_lt_color);
if (btnAuxRTS) btnAuxRTS->selection_color(btn_lt_color);
if (btnAuxDTR) btnAuxDTR->selection_color(btn_lt_color);
if (btnSpot) btnSpot->selection_color(btn_lt_color);
if (btn_vox) btn_vox->selection_color(btn_lt_color);
if (btnCompON) btnCompON->selection_color(btn_lt_color);
if (btnPOWER) btnPOWER->selection_color(btn_lt_color);
if (btn_tt550_vox) btn_tt550_vox->selection_color(btn_lt_color);
if (btn_tt550_CompON) btn_tt550_CompON->selection_color(btn_lt_color);
if (sldrVOLUME) sldrVOLUME->color(bg_slider);
if (sldrVOLUME) sldrVOLUME->selection_color(btn_slider);
if (sldrRFGAIN) sldrRFGAIN->color(bg_slider);
if (sldrRFGAIN) sldrRFGAIN->selection_color(btn_slider);
if (sldrSQUELCH) sldrSQUELCH->color(bg_slider);
if (sldrSQUELCH) sldrSQUELCH->selection_color(btn_slider);
if (sldrNR) sldrNR->color(bg_slider);
if (sldrNR) sldrNR->selection_color(btn_slider);
if (sldrIFSHIFT) sldrIFSHIFT->color(bg_slider);
if (sldrIFSHIFT) sldrIFSHIFT->selection_color(btn_slider);
if (sldrINNER) sldrINNER->color(bg_slider);
if (sldrINNER) sldrINNER->selection_color(btn_slider);
if (sldrOUTER) sldrOUTER->color(bg_slider);
if (sldrOUTER) sldrOUTER->selection_color(btn_slider);
if (sldrNOTCH) sldrNOTCH->color(bg_slider);
if (sldrNOTCH) sldrNOTCH->selection_color(btn_slider);
if (sldrMICGAIN) sldrMICGAIN->color(bg_slider);
if (sldrMICGAIN) sldrMICGAIN->selection_color(btn_slider);
if (sldrPOWER) sldrPOWER->color(bg_slider);
if (sldrPOWER) sldrPOWER->selection_color(btn_slider);
if (spnrPOWER) spnrPOWER->color(bg_slider);
if (spnrVOLUME) spnrVOLUME->color(bg_slider);
mainwindow->redraw();
}
void cb_reset_display_dialog()
{
cb_sys_defaults();
cb_lighted_default();
cb_slider_defaults();
default_meters();
setColors();
}
void cbOkDisplayDialog()
{
setColors();
dlgDisplayConfig->hide();
}
void cbCancelDisplayDialog()
{
dlgDisplayConfig->hide();
}
void setDisplayColors()
{
if (dlgDisplayConfig == NULL)
return;
swrRed = progStatus.swrRed;
swrGreen = progStatus.swrGreen;
swrBlue = progStatus.swrBlue;
pwrRed = progStatus.pwrRed;
pwrGreen = progStatus.pwrGreen;
pwrBlue = progStatus.pwrBlue;
smeterRed = progStatus.smeterRed;
smeterGreen = progStatus.smeterGreen;
smeterBlue = progStatus.smeterBlue;
peakRed = progStatus.peakRed;
peakGreen = progStatus.peakGreen;
peakBlue = progStatus.peakBlue;
voltRed = progStatus.voltRed;
voltGreen = progStatus.voltGreen;
voltBlue = progStatus.voltBlue;
fg_red = progStatus.fg_red;
fg_green = progStatus.fg_green;
fg_blue = progStatus.fg_blue;
bg_red = progStatus.bg_red;
bg_green = progStatus.bg_green;
bg_blue = progStatus.bg_blue;
bgclr = fl_rgb_color(bg_red, bg_green, bg_blue);
fgclr = fl_rgb_color(fg_red, fg_green, fg_blue);
fg_sys_red = progStatus.fg_sys_red;
fg_sys_green = progStatus.fg_sys_green;
fg_sys_blue = progStatus.fg_sys_blue;
bg_sys_red = progStatus.bg_sys_red;
bg_sys_green = progStatus.bg_sys_green;
bg_sys_blue = progStatus.bg_sys_blue;
bg2_sys_red = progStatus.bg2_sys_red;
bg2_sys_green = progStatus.bg2_sys_green;
bg2_sys_blue = progStatus.bg2_sys_blue;
bg_slider_red = progStatus.slider_red;
bg_slider_green = progStatus.slider_green;
bg_slider_blue = progStatus.slider_blue;
btn_slider_red = progStatus.slider_btn_red;
btn_slider_green = progStatus.slider_btn_green;
btn_slider_blue = progStatus.slider_btn_blue;
tab_red = progStatus.tab_red;
tab_green = progStatus.tab_green;
tab_blue = progStatus.tab_blue;
sldrColors->color(fl_rgb_color(bg_slider_red, bg_slider_green, bg_slider_blue));
sldrColors->selection_color(fl_rgb_color(btn_slider_red, btn_slider_green, btn_slider_blue));
btn_lt_color_red = progStatus.lighted_btn_red;
btn_lt_color_green = progStatus.lighted_btn_green;
btn_lt_color_blue = progStatus.lighted_btn_blue;
lblTest->labelcolor(fl_rgb_color(fg_red, fg_green, fg_blue));
lblTest->color(bgclr);
scaleSmeterColor->color(bgclr);
scaleSmeterColor->labelcolor(fgclr);
scalePWRcolor->color(bgclr);
scalePWRcolor->labelcolor(fgclr);
scaleSWRcolor->color(bgclr);
scaleSWRcolor->labelcolor(fgclr);
scaleVoltcolor->color(bgclr);
scaleVoltcolor->labelcolor(fgclr);
grpMeterColor->color(bgclr);
grpMeterColor->labelcolor(fgclr);
sldrRcvSignalColor->color(
fl_rgb_color (smeterRed, smeterGreen, smeterBlue),
bgclr );
sldrPWRcolor->color(
fl_rgb_color (pwrRed, pwrGreen, pwrBlue),
bgclr );
sldrSWRcolor->color(
fl_rgb_color (swrRed, swrGreen, swrBlue),
bgclr );
sldrVoltcolor->color(
fl_rgb_color (voltRed, voltGreen, voltBlue),
bgclr );
sldrRcvSignalColor->minimum(0);
sldrRcvSignalColor->maximum(100);
sldrRcvSignalColor->value(45);
sldrPWRcolor->minimum(0);
sldrPWRcolor->maximum(100);
sldrPWRcolor->value(80);
sldrSWRcolor->minimum(0);
sldrSWRcolor->maximum(100);
sldrSWRcolor->value(25);
sldrVoltcolor->minimum(0);
sldrVoltcolor->maximum(100);
sldrVoltcolor->value(55);
btn_lt_color = fl_rgb_color( btn_lt_color_red, btn_lt_color_green, btn_lt_color_blue);
btn_slider = fl_rgb_color( btn_slider_red, btn_slider_green, btn_slider_blue);
bg_slider = fl_rgb_color(bg_slider_red, bg_slider_green, bg_slider_blue);
btn_lighted->value(1);
btn_lighted->selection_color(btn_lt_color);
sldrColors->color(bg_slider);
sldrColors->selection_color(btn_slider);
mnuScheme->value(mnuScheme->find_item(progStatus.ui_scheme.c_str()));
dlgDisplayConfig->show();
}
void cbCloseMemory()
{
dlgMemoryDialog->hide();
}
void openMemoryDialog()
{
if (dlgMemoryDialog == NULL)
return;
dlgMemoryDialog->show();
}
void show_controls()
{
Fl_Widget * vtab = (Fl_Widget *)0;
if (tabsGeneric && !progStatus.visible_tab.empty()) {
Fl_Widget * const *vtabs = tabsGeneric->array();
int ntabs = tabsGeneric->children();
for (int n = 0; n < ntabs; n++) {
if (progStatus.visible_tab == vtabs[n]->label()) {
vtab = vtabs[n];
}
vtabs[n]->redraw();
}
}
switch (progStatus.UIsize) {
case touch_ui : {
if (selrig->name_ == rig_TT550.name_) {
tabs550->show();
tabsGeneric->hide();
tabs550->redraw();
} else {
tabs550->hide();
tabsGeneric->show();
tabsGeneric->redraw();
}
mainwindow->redraw();
break;
}
case wide_ui : {
if (selrig->name_ == rig_TT550.name_) {
tabsGeneric->hide();
tabs550->show();
tabs550->redraw();
} else {
tabs550->hide();
tabsGeneric->show();
tabsGeneric->redraw();
}
if (progStatus.embed_tabs) { // embedded
int X = mainwindow->x(),
Y = mainwindow->y(),
W = mainwindow->w(),
H = mainwindow->h();
if ((progStatus.show_tabs && !progStatus.first_use) ||
(!progStatus.show_tabs && progStatus.first_use)) {
H = WIDE_MAINH + WIDE_MENUH;
mainwindow->resize( X, Y, W, H );
mainwindow->size_range(WIDE_MAINW, H, 0, H);
tabs->hide();
progStatus.show_tabs = false;
mainwindow->redraw();
} else {
H = WIDE_MENUH + WIDE_MAINH + WIDE_TABSH;
mainwindow->resize( X, Y, W, H);
mainwindow->size_range(WIDE_MAINW, H, 0, H);
tabs->add(grpTABS);
grpTABS->resize(
tabs->x(), tabs->y(),
tabs->w(), tabs->h());
grpTABS->show();
tabs->show();
progStatus.show_tabs = true;
mainwindow->redraw();
}
} else {
if ((progStatus.show_tabs && !progStatus.first_use) || (!progStatus.show_tabs && progStatus.first_use)) {
tabs_dialog->hide();
progStatus.show_tabs = false;
} else if ((!progStatus.show_tabs && !progStatus.first_use) || (progStatus.show_tabs && progStatus.first_use)) {
static int X, Y, W, H, dH;
X = mainwindow->x();
Y = mainwindow->y();
W = mainwindow->w();
H = WIDE_MAINH + WIDE_MENUH;
dH = mainwindow->decorated_h();
tabs_dialog->resize( X, Y + dH, W, tabs_dialog->h() );
grpTABS->resize(0, 0, W, tabs_dialog->h());
tabs_dialog->add(grpTABS);
tabs_dialog->show();
tabs_dialog->redraw();
progStatus.show_tabs = true;
mainwindow->resize( X, Y, W, H);
mainwindow->size_range(WIDE_MAINW, H, 0, H);
mainwindow->redraw();
}
}
break;
}
case small_ui : {
if (selrig->name_ == rig_TT550.name_) {
tabsGeneric->hide();
tabs550->show();
tabs550->redraw();
break;
} else {
tabs550->hide();
tabsGeneric->show();
tabsGeneric->redraw();
}
if (progStatus.embed_tabs) { // embedded
static int X = mainwindow->x(),
Y = mainwindow->y(),
W = mainwindow->w(),
H = mainwindow->h();
if ((progStatus.show_tabs && !progStatus.first_use) || (!progStatus.show_tabs && progStatus.first_use)) {
tabs_dialog->add(grpTABS);
grpTABS->resize(tabs_dialog->x(), tabs_dialog->y(), tabs_dialog->w(), tabs_dialog->h());
mainwindow->resize(mainwindow->x(), mainwindow->y(), W, H);
progStatus.show_tabs = false;
} else if (!progStatus.show_tabs && !progStatus.first_use) {
X = mainwindow->x();
Y = mainwindow->y();
W = mainwindow->w();
H = mainwindow->h();
mainwindow->resize(X, Y, W, H + grpTABS->h());
grpTABS->resize(0, H, W, grpTABS->h());
mainwindow->add(grpTABS);
grpTABS->show();
progStatus.show_tabs = true;
} else if (progStatus.show_tabs && progStatus.first_use) {
X = mainwindow->x();
Y = mainwindow->y();
W = mainwindow->w();
H = mainwindow->h();
mainwindow->resize(X, Y, W, H + grpTABS->h());
grpTABS->resize(0, H, W, grpTABS->h());
mainwindow->add(grpTABS);
grpTABS->show();
grpTABS->redraw();
mainwindow->redraw();
progStatus.show_tabs = true;
}
} else {
if ((progStatus.show_tabs && !progStatus.first_use) || (!progStatus.show_tabs && progStatus.first_use)) {
tabs_dialog->hide();
progStatus.show_tabs = false;
} else if ((!progStatus.show_tabs && !progStatus.first_use) || (progStatus.show_tabs && progStatus.first_use)) {
static int X, Y, W, dH;
X = mainwindow->x(); //progStatus.mainX;
Y = mainwindow->y(); //progStatus.mainY;
W = mainwindow->w(); //progStatus.mainW;
dH = mainwindow->decorated_h();
tabs_dialog->resize( X, Y + dH, W, tabs_dialog->h() );
grpTABS->resize(0, 0, W, tabs_dialog->h());
if (vtab != (Fl_Widget *)0) tabsGeneric->value(vtab);
tabs_dialog->add(grpTABS);
tabs_dialog->show();
tabs_dialog->redraw();
progStatus.show_tabs = true;
}
}
break;
}
default :
break;
}
if (tabsGeneric) {
if (vtab != (Fl_Widget *)0)
tabsGeneric->value(vtab);
else
progStatus.visible_tab = (tabsGeneric->value())->label();
}
progStatus.first_use = false;
}
// a replica of the default color map used by Fltk
static unsigned flrig_cmap[256] = {
0x00000000,
0xff000000,
0x00ff0000,
0xffff0000,
0x0000ff00,
0xff00ff00,
0x00ffff00,
0xffffff00,
0x55555500,
0xc6717100,
0x71c67100,
0x8e8e3800,
0x7171c600,
0x8e388e00,
0x388e8e00,
0x00008000,
0xa8a89800,
0xe8e8d800,
0x68685800,
0x98a8a800,
0xd8e8e800,
0x58686800,
0x9c9ca800,
0xdcdce800,
0x5c5c6800,
0x9ca89c00,
0xdce8dc00,
0x5c685c00,
0x90909000,
0xc0c0c000,
0x50505000,
0xa0a0a000,
0x00000000,
0x0d0d0d00,
0x1a1a1a00,
0x26262600,
0x31313100,
0x3d3d3d00,
0x48484800,
0x55555500,
0x5f5f5f00,
0x6a6a6a00,
0x75757500,
0x80808000,
0x8a8a8a00,
0x95959500,
0xa0a0a000,
0xaaaaaa00,
0xb5b5b500,
0xc0c0c000,
0xcbcbcb00,
0xd5d5d500,
0xe0e0e000,
0xeaeaea00,
0xf5f5f500,
0xffffff00,
0x00000000,
0x00240000,
0x00480000,
0x006d0000,
0x00910000,
0x00b60000,
0x00da0000,
0x00ff0000,
0x3f000000,
0x3f240000,
0x3f480000,
0x3f6d0000,
0x3f910000,
0x3fb60000,
0x3fda0000,
0x3fff0000,
0x7f000000,
0x7f240000,
0x7f480000,
0x7f6d0000,
0x7f910000,
0x7fb60000,
0x7fda0000,
0x7fff0000,
0xbf000000,
0xbf240000,
0xbf480000,
0xbf6d0000,
0xbf910000,
0xbfb60000,
0xbfda0000,
0xbfff0000,
0xff000000,
0xff240000,
0xff480000,
0xff6d0000,
0xff910000,
0xffb60000,
0xffda0000,
0xffff0000,
0x00003f00,
0x00243f00,
0x00483f00,
0x006d3f00,
0x00913f00,
0x00b63f00,
0x00da3f00,
0x00ff3f00,
0x3f003f00,
0x3f243f00,
0x3f483f00,
0x3f6d3f00,
0x3f913f00,
0x3fb63f00,
0x3fda3f00,
0x3fff3f00,
0x7f003f00,
0x7f243f00,
0x7f483f00,
0x7f6d3f00,
0x7f913f00,
0x7fb63f00,
0x7fda3f00,
0x7fff3f00,
0xbf003f00,
0xbf243f00,
0xbf483f00,
0xbf6d3f00,
0xbf913f00,
0xbfb63f00,
0xbfda3f00,
0xbfff3f00,
0xff003f00,
0xff243f00,
0xff483f00,
0xff6d3f00,
0xff913f00,
0xffb63f00,
0xffda3f00,
0xffff3f00,
0x00007f00,
0x00247f00,
0x00487f00,
0x006d7f00,
0x00917f00,
0x00b67f00,
0x00da7f00,
0x00ff7f00,
0x3f007f00,
0x3f247f00,
0x3f487f00,
0x3f6d7f00,
0x3f917f00,
0x3fb67f00,
0x3fda7f00,
0x3fff7f00,
0x7f007f00,
0x7f247f00,
0x7f487f00,
0x7f6d7f00,
0x7f917f00,
0x7fb67f00,
0x7fda7f00,
0x7fff7f00,
0xbf007f00,
0xbf247f00,
0xbf487f00,
0xbf6d7f00,
0xbf917f00,
0xbfb67f00,
0xbfda7f00,
0xbfff7f00,
0xff007f00,
0xff247f00,
0xff487f00,
0xff6d7f00,
0xff917f00,
0xffb67f00,
0xffda7f00,
0xffff7f00,
0x0000bf00,
0x0024bf00,
0x0048bf00,
0x006dbf00,
0x0091bf00,
0x00b6bf00,
0x00dabf00,
0x00ffbf00,
0x3f00bf00,
0x3f24bf00,
0x3f48bf00,
0x3f6dbf00,
0x3f91bf00,
0x3fb6bf00,
0x3fdabf00,
0x3fffbf00,
0x7f00bf00,
0x7f24bf00,
0x7f48bf00,
0x7f6dbf00,
0x7f91bf00,
0x7fb6bf00,
0x7fdabf00,
0x7fffbf00,
0xbf00bf00,
0xbf24bf00,
0xbf48bf00,
0xbf6dbf00,
0xbf91bf00,
0xbfb6bf00,
0xbfdabf00,
0xbfffbf00,
0xff00bf00,
0xff24bf00,
0xff48bf00,
0xff6dbf00,
0xff91bf00,
0xffb6bf00,
0xffdabf00,
0xffffbf00,
0x0000ff00,
0x0024ff00,
0x0048ff00,
0x006dff00,
0x0091ff00,
0x00b6ff00,
0x00daff00,
0x00ffff00,
0x3f00ff00,
0x3f24ff00,
0x3f48ff00,
0x3f6dff00,
0x3f91ff00,
0x3fb6ff00,
0x3fdaff00,
0x3fffff00,
0x7f00ff00,
0x7f24ff00,
0x7f48ff00,
0x7f6dff00,
0x7f91ff00,
0x7fb6ff00,
0x7fdaff00,
0x7fffff00,
0xbf00ff00,
0xbf24ff00,
0xbf48ff00,
0xbf6dff00,
0xbf91ff00,
0xbfb6ff00,
0xbfdaff00,
0xbfffff00,
0xff00ff00,
0xff24ff00,
0xff48ff00,
0xff6dff00,
0xff91ff00,
0xffb6ff00,
0xffdaff00,
0xffffff00
};
Fl_Color flrig_def_color(int n)
{
if ( n > 255 ) n = 255;
if (n < 0) n = 0;
return (Fl_Color)flrig_cmap[n];
}
extern std::string print_all();
void cb_send_command(std::string command, Fl_Output *resp)
{
if (command == "PRINT") {
fl_alert2("%s", print_all().c_str());
#ifndef __WIN32__
std::cout << print_all();
#endif
return;
}
if (command.empty()) return;
bool usehex = false;
std::string cmd = "";
if (command.find("x") != std::string::npos) { // hex std::strings
size_t p = 0;
usehex = true;
unsigned int val;
while (( p = command.find("x", p)) != std::string::npos) {
sscanf(&command[p+1], "%x", &val);
cmd += (unsigned char) val;
p += 3;
}
} else
cmd = command;
if (resp) {
resp->value("");
resp->redraw();
}
// lock out polling loops until done
guard_lock lock1(&mutex_srvc_reqs);
guard_lock lock2(&mutex_serial);
sendCommand(cmd);
set_trace(2, "command: ", command.c_str());
waitResponse(200);
std::string retstr = usehex ?
str2hex(respstr.c_str(), respstr.length()) :
respstr;
set_trace(2, "response: ", retstr.c_str());
if (resp) {
resp->value(retstr.c_str());
resp->redraw();
}
}
// =====================================================================
// logbook support code
// =====================================================================
bool cwlog_editing = false;
int cwlog_edit_nbr = 0;
bool cwlog_changed = false;
bool cwlog_is_open = false;
void cwlog_set_edit(bool on)
{
cwlog_editing = on;
if (on) {
btn_cwlog_edit_entry->label("Delete");
btn_cwlog_edit_entry->redraw_label();
btn_cwlog_clear_qso->label("Cancel");
btn_cwlog_clear_qso->redraw_label();
} else {
btn_cwlog_edit_entry->label("Edit");
btn_cwlog_edit_entry->redraw_label();
btn_cwlog_clear_qso->label("Clear");
btn_cwlog_clear_qso->redraw_label();
}
}
bool cwlog_compare( int &dir, int fld, std::string &s1, std::string &s2) {
size_t p1 = 0, p2 = 0;
for (int n = 0; n < fld; n++) {
p1 = s1.find('\t', p1 + 1);
p2 = s2.find('\t', p2 + 1);
}
if (dir == 1) return (s2.substr(p2) < s1.substr(p1));
return (s2.substr(p2) > s1.substr(p1));
}
bool cwlog_freq_compare( int &dir, int fld, std::string &s1, std::string &s2) {
size_t p1 = 0, p2 = 0;
for (int n = 0; n < fld; n++) {
p1 = s1.find('\t', p1 + 1);
p2 = s2.find('\t', p2 + 1);
}
float f1 = atof(s1.substr(p1).c_str());
float f2 = atof(s2.substr(p2).c_str());
if (dir == 1) return (f2 < f1);
return (f2 > f1);
}
static int dtdir = 1;
static int dtpos = 0;
void cwlog_sort_by_datetime() {
if (cwlog_editing) return;
size_t nbr = brwsr_cwlog_entries->size();
if (nbr == 0) return;
std::string entries[nbr];
for (size_t n = 0; n < nbr; n++) entries[n] = brwsr_cwlog_entries->text(n+1);
std::string temp;
if (nbr > 1) {
for (size_t n = 0; n < nbr - 1; n++) {
for (size_t j = n + 1; j < nbr; j++) {
if (cwlog_compare (dtdir, dtpos, entries[n], entries[j])) {
temp = entries[j];
entries[j] = entries[n];
entries[n] = temp;
}
}
}
}
brwsr_cwlog_entries->clear();
for (size_t i = 0; i < nbr; i++)
brwsr_cwlog_entries->add(entries[i].c_str());
brwsr_cwlog_entries->redraw();
if (dtdir == 1) dtdir = -1;
else dtdir = 1;
}
static int freqdir = 1;
static int freqpos = 2;
void cwlog_sort_by_freq() {
if (cwlog_editing) return;
size_t nbr = brwsr_cwlog_entries->size();
if (nbr == 0) return;
std::string entries[nbr];
for (size_t n = 0; n < nbr; n++) entries[n] = brwsr_cwlog_entries->text(n+1);
std::string temp;
if (nbr > 1) {
for (size_t n = 0; n < nbr - 1; n++) {
for (size_t j = n + 1; j < nbr; j++) {
if (cwlog_freq_compare (freqdir, freqpos, entries[n], entries[j])) {
temp = entries[j];
entries[j] = entries[n];
entries[n] = temp;
}
}
}
}
brwsr_cwlog_entries->clear();
for (size_t i = 0; i < nbr; i++)
brwsr_cwlog_entries->add(entries[i].c_str());
brwsr_cwlog_entries->redraw();
if (freqdir == 1) freqdir = -1;
else freqdir = 1;
}
static int calldir = 1;
static int callpos = 3;
void cwlog_sort_by_call() {
if (cwlog_editing) return;
size_t nbr = brwsr_cwlog_entries->size();
if (nbr == 0) return;
std::string entries[nbr];
for (size_t n = 0; n < nbr; n++) entries[n] = brwsr_cwlog_entries->text(n+1);
std::string temp;
if (nbr > 1) {
for (size_t n = 0; n < nbr - 1; n++) {
for (size_t j = n + 1; j < nbr; j++) {
if (cwlog_compare (calldir, callpos, entries[n], entries[j])) {
temp = entries[j];
entries[j] = entries[n];
entries[n] = temp;
}
}
}
}
brwsr_cwlog_entries->clear();
for (size_t i = 0; i < nbr; i++)
brwsr_cwlog_entries->add(entries[i].c_str());
brwsr_cwlog_entries->redraw();
if (calldir == 1) calldir = -1;
else calldir = 1;
}
static int nbrdir = 1;
static int nbrpos = 7;
void cwlog_sort_by_nbr() {
if (cwlog_editing) return;
size_t nbr = brwsr_cwlog_entries->size();
if (nbr == 0) return;
std::string entries[nbr];
for (size_t n = 0; n < nbr; n++) entries[n] = brwsr_cwlog_entries->text(n+1);
std::string temp;
if (nbr > 1) {
for (size_t n = 0; n < nbr - 2; n++) {
for (size_t j = n + 1; j < nbr - 1; j++) {
if (cwlog_compare (nbrdir, nbrpos, entries[n], entries[j])) {
temp = entries[j];
entries[j] = entries[n];
entries[n] = temp;
}
}
}
}
brwsr_cwlog_entries->clear();
for (size_t i = 0; i < nbr; i++)
brwsr_cwlog_entries->add(entries[i].c_str());
brwsr_cwlog_entries->redraw();
if (nbrdir == 1) nbrdir = -1;
else nbrdir = 1;
}
void cwlog_clear_qso()
{
cw_qso_date->value("");
cw_qso_time->value("");
cw_freq->value("");
cw_op_call->value("");
cw_op_name->value("");
cw_rst_in->value("");
cw_rst_out->value("");
cw_xchg_in->value("");
if (cwlog_editing)
cwlog_set_edit(false);
}
void cwlog_save_qso()
{
char line[256];
if (cwlog_editing) {
snprintf(line, sizeof(line),
"%s\t%s\t%s\t%s\t%s\t%s\t%s\t%05d\t%s",
cw_qso_date->value(),
cw_qso_time->value(),
cw_freq->value(),
cw_op_call->value(),
cw_op_name->value(),
cw_rst_in->value(),
cw_rst_out->value(),
(int)cw_log_nbr->value(),
cw_xchg_in->value());
brwsr_cwlog_entries->insert(cwlog_edit_nbr, line);
brwsr_cwlog_entries->remove(cwlog_edit_nbr + 1);
brwsr_cwlog_entries->select(cwlog_edit_nbr);
cwlog_set_edit(false);
} else {
snprintf(line, sizeof(line),
"%s\t%s\t%s\t%s\t%s\t%s\t%s\t%05d\t%s",
cw_qso_date->value(),
cw_qso_time->value(),
cw_freq->value(),
cw_op_call->value(),
cw_op_name->value(),
cw_rst_in->value(),
cw_rst_out->value(),
(int)cw_log_nbr->value(),
cw_xchg_in->value());
brwsr_cwlog_entries->add(line);
}
cwlog_changed = true;
}
void cwlog_delete_entry()
{
brwsr_cwlog_entries->remove(cwlog_edit_nbr);
brwsr_cwlog_entries->select(cwlog_edit_nbr, false);
brwsr_cwlog_entries->redraw();
cwlog_clear_qso();
cwlog_changed = true;
}
void cwlog_edit_entry()
{
if (cwlog_editing) {
cwlog_delete_entry();
return;
}
cwlog_edit_nbr = brwsr_cwlog_entries->value();
if (!cwlog_edit_nbr) return;
cwlog_clear_qso();
size_t ptr = 0;
std::string entry = brwsr_cwlog_entries->text(cwlog_edit_nbr);
ptr = entry.find('\t');
cw_qso_date->value(entry.substr(0, ptr).c_str());
entry.erase(0, ptr+1);
ptr = entry.find('\t');
cw_qso_time->value(entry.substr(0,ptr).c_str());
entry.erase(0, ptr+1);
ptr = entry.find('\t');
cw_freq->value(entry.substr(0,ptr).c_str());
entry.erase(0, ptr+1);
ptr = entry.find('\t');
cw_op_call->value(entry.substr(0,ptr).c_str());
entry.erase(0, ptr+1);
ptr = entry.find('\t');
cw_op_name->value(entry.substr(0,ptr).c_str());
entry.erase(0, ptr+1);
ptr = entry.find('\t');
cw_rst_in->value(entry.substr(0,ptr).c_str());
entry.erase(0, ptr+1);
ptr = entry.find('\t');
cw_rst_out->value(entry.substr(0,ptr).c_str());
entry.erase(0, ptr+1);
ptr = entry.find('\t');
cw_log_nbr->value(atoi(entry.substr(0,ptr).c_str()));
entry.erase(0, ptr+1);
ptr = entry.find('\t');
cw_xchg_in->value(entry.substr(0,ptr).c_str());
entry.erase(0, ptr+1);
cwlog_set_edit(true);
}
void cwlog_view()
{
if (!cwlog_viewer) {
cwlog_viewer = new_cwlogbook_dialog();
if (!progStatus.cw_log_name.empty()) {
txt_cwlog_file->value(progStatus.cw_log_name.c_str());
cwlog_load();
} else
cwlog_open();
}
cwlog_viewer->show();
}
void cwlog_save()
{
if (progStatus.cw_log_name.empty())
return;
std::ofstream oLog(progStatus.cw_log_name.c_str());
if (!oLog) {
fl_message ("Could not write to %s", progStatus.cw_log_name.c_str());
return;
}
size_t n = brwsr_cwlog_entries->size();
std::string oline;
for (size_t i = 1; i <= n; i++) {
oline = brwsr_cwlog_entries->text(i);
if (oline.empty()) continue;
oLog << oline << std::endl;
}
oLog.close();
cwlog_changed = false;
}
void cwlog_load()
{
std::ifstream iLog(progStatus.cw_log_name.c_str());
if (!iLog) return;
brwsr_cwlog_entries->clear();
char line[256];
std::string sline;
while (!iLog.eof()) {
memset(line, 0, 256);
iLog.getline(line, 256);
sline = line;
if (!sline.empty())
brwsr_cwlog_entries->add(sline.c_str());
}
iLog.close();
brwsr_cwlog_entries->redraw();
cwlog_is_open = true;
}
void cwlog_save_as()
{
// Create and post the local native file chooser
Fl_Native_File_Chooser fnfc;
fnfc.title("Save As log file");
fnfc.type(Fl_Native_File_Chooser::BROWSE_SAVE_FILE);
fnfc.options(Fl_Native_File_Chooser::SAVEAS_CONFIRM);
fnfc.filter("CW Log\t*.txt");
// default directory to use
fnfc.directory(RigHomeDir.c_str());
fnfc.preset_file(progStatus.cw_log_name.c_str());
// Show native chooser
switch ( fnfc.show() ) {
case -1:
fl_message ("ERROR: %s", fnfc.errmsg());
return; // ERROR
case 1:
return; // CANCEL
default:
progStatus.cw_log_name = fnfc.filename();
txt_cwlog_file->value(progStatus.cw_log_name.c_str());
}
cwlog_save();
}
void cwlog_open()
{
if (cwlog_is_open && cwlog_changed)
cwlog_save();
// Create and post the local native file chooser
Fl_Native_File_Chooser fnfc;
fnfc.title("Select log file");
fnfc.type(Fl_Native_File_Chooser::BROWSE_FILE);
fnfc.filter("CW Log\t*.txt");
// default directory to use
fnfc.directory(RigHomeDir.c_str());
// Show native chooser
switch ( fnfc.show() ) {
case -1:
fl_message ("ERROR: %s", fnfc.errmsg());
return; // ERROR
case 1:
return; // CANCEL
default:
progStatus.cw_log_name = fnfc.filename();
txt_cwlog_file->value(progStatus.cw_log_name.c_str());
txt_cwlog_file->redraw();
cwlog_load();
}
}
void cwlog_new()
{
if (cwlog_is_open && cwlog_changed)
cwlog_save();
brwsr_cwlog_entries->clear();
brwsr_cwlog_entries->redraw();
progStatus.cw_log_name.clear();
txt_cwlog_file->value(progStatus.cw_log_name.c_str());
txt_cwlog_file->redraw();
Fl_Native_File_Chooser fnfc;
fnfc.title("Create new log file");
fnfc.type(Fl_Native_File_Chooser::BROWSE_SAVE_FILE);
fnfc.options(Fl_Native_File_Chooser::SAVEAS_CONFIRM);
fnfc.filter("CW Log\t*.txt");
// default directory to use
fnfc.directory(RigHomeDir.c_str());
fnfc.preset_file("cwlog.txt");
// Show native chooser
switch ( fnfc.show() ) {
case -1:
fl_message ("ERROR: %s", fnfc.errmsg());
return; // ERROR
case 1:
return; // CANCEL
default:
progStatus.cw_log_name = fnfc.filename();
txt_cwlog_file->value(progStatus.cw_log_name.c_str());
}
}
void cwlog_close()
{
if (cwlog_is_open && cwlog_changed)
cwlog_save();
}
void cwlog_export_adif()
{
// Create and post the local native file chooser
Fl_Native_File_Chooser fnfc;
fnfc.title("Export to ADIF file");
fnfc.type(Fl_Native_File_Chooser::BROWSE_SAVE_FILE);
fnfc.options(Fl_Native_File_Chooser::SAVEAS_CONFIRM);
fnfc.filter("ADIF Log\t*.{adi,adif}");
// default directory to use
fnfc.directory(RigHomeDir.c_str());
// Show native chooser
switch ( fnfc.show() ) {
case -1:
fl_message ("ERROR: %s", fnfc.errmsg());
return; // ERROR
case 1:
return; // CANCEL
default:
break;
}
std::string export_fname = fnfc.filename();
std::ofstream oExport(export_fname.c_str());
if (!oExport) {
fl_message ("Could not write to %s", export_fname.c_str());
return;
}
std::string logline,
cw_qso_date, cw_qso_time,
cw_freq,
cw_op_call,
cw_op_name,
cw_rst_in, cw_rst_out,
cw_log_nbr,
qso_notes;
size_t ptr = std::string::npos;
size_t n = brwsr_cwlog_entries->size();
for (size_t i = 1; i <= n; i++) {
logline = brwsr_cwlog_entries->text(i);
if (logline.empty()) continue;
ptr = logline.find('\t');
cw_qso_date = logline.substr(0, ptr);
logline.erase(0, ptr+1);
ptr = logline.find('\t');
cw_qso_time = logline.substr(0, ptr);
logline.erase(0, ptr+1);
ptr = logline.find('\t');
cw_freq = logline.substr(0, ptr);
logline.erase(0, ptr+1);
ptr = logline.find('\t');
cw_op_call = logline.substr(0, ptr);
logline.erase(0, ptr+1);
ptr = logline.find('\t');
cw_op_name = logline.substr(0, ptr);
logline.erase(0, ptr+1);
ptr = logline.find('\t');
cw_rst_in = logline.substr(0, ptr);
logline.erase(0, ptr+1);
ptr = logline.find('\t');
cw_rst_out = logline.substr(0, ptr);
logline.erase(0, ptr+1);
ptr = logline.find('\t');
cw_log_nbr = logline.substr(0, ptr);
logline.erase(0, ptr+1);
qso_notes = logline;
oExport << "" << cw_qso_date
<< "" << cw_qso_time
<< "" << cw_freq
<< "CW"
<< "" << cw_op_call
<< "" << cw_op_name
<< "" << cw_rst_in
<< "" << cw_rst_out
<< "" << cw_log_nbr
<< "" << qso_notes
<< "" << std::endl;
}
oExport.close();
}
std::string cwlog_adif_extract( std::string FIELD, std::string line)
{
size_t p1, p2;
p1 = line.find(FIELD);
if (p1 != std::string::npos) {
p1 = line.find(">", p1);
if (p1 != std::string::npos) {
p1++;
p2 = line.find("<", p1);
if (p2 != std::string::npos)
return line.substr(p1, p2 - p1);
}
}
return "";
}
void cwlog_import_adif()
{
std::string import_fname;
Fl_Native_File_Chooser fnfc;
fnfc.title("Import from ADIF file");
fnfc.type(Fl_Native_File_Chooser::BROWSE_FILE);
fnfc.filter("ADIF Log\t*.{adi,adif}");
// default directory to use
fnfc.directory(RigHomeDir.c_str());
// Show native chooser
switch ( fnfc.show() ) {
case -1:
fl_message ("ERROR: %s", fnfc.errmsg());
return; // ERROR
case 1:
return; // CANCEL
default:
break;
}
import_fname = fnfc.filename();
std::ifstream iImport(import_fname.c_str());
if (!iImport) return;
// current log
size_t n = brwsr_cwlog_entries->size();
size_t p;
std::string fulllog;
std::string teststr;
for (size_t i = 1; i <= n; i++) {
fulllog.append(brwsr_cwlog_entries->text(i)).append("\n");
}
char buff[512];
std::string line, ldate, ltime, lfreq, lcall, lname, lrst_in, lrst_out, lnbr, lnotes, lbrwsr;
while (!iImport.eof()) {
iImport.getline(buff, 512);
line = buff;
if (cwlog_adif_extract("MODE", line) == "CW") {
ldate = cwlog_adif_extract("QSO_DATE", line);
ltime = cwlog_adif_extract("TIME_ON", line).substr(0,4);
lfreq = cwlog_adif_extract("FREQ", line);
lcall = cwlog_adif_extract("CALL", line);
lname = cwlog_adif_extract("NAME", line);
lrst_in = cwlog_adif_extract("RST_RCVD", line);
lrst_out = cwlog_adif_extract("RST_SENT", line);
lnbr = cwlog_adif_extract("STX", line);
lnotes = cwlog_adif_extract("NOTES", line);
lbrwsr.assign(ldate).append("\t");
lbrwsr.append(ltime).append("\t");
lbrwsr.append(lfreq).append("\t");
lbrwsr.append(lcall).append("\t");
teststr = lbrwsr;
lbrwsr.append(lname).append("\t");
lbrwsr.append(lrst_in).append("\t");
lbrwsr.append(lrst_out).append("\t");
lbrwsr.append(lnbr).append("\t");
lbrwsr.append(lnotes);
p = lbrwsr.find("\n");
if (p != std::string::npos)
lbrwsr.erase(p);
if (fulllog.find(teststr) == std::string::npos &&
!ldate.empty() &&
!ltime.empty()) {
fulllog.append(lbrwsr).append("\n");
brwsr_cwlog_entries->add(lbrwsr.c_str());
}
}
}
cwlog_changed = true;
iImport.close();
}
flrig-2.0.04/src/support/socket_io.cxx 0000664 0001750 0001750 00000015007 14504050363 014634 0000000 0000000 // socket_io.cxx
//
// Author: Dave Freese, W1HKJ
// Stelios Bounanos, M0GLD
//
// ----------------------------------------------------------------------------
// Copyright (C) 2014
// David Freese, W1HKJ
//
// This file is part of flrig
//
// flrig is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation; either version 3 of the License, or
// (at your option) any later version.
//
// flrig is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program. If not, see .
// ----------------------------------------------------------------------------
#include "config.h"
#include "compat.h" // Must precede all FL includes
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include "status.h"
#include "debug.h"
#include "util.h"
#include "gettext.h"
#include "rigpanel.h"
#include "socket_io.h"
#include "socket.h"
#include "support.h"
#ifdef WIN32
# include
#else
# include
#endif
Socket *tcpip = (Socket *)0;
Address *remote_addr = (Address *)0;
static bool exit_socket_loop = false;
static std::string rxbuffer;
pthread_t *rcv_socket_thread = 0;
pthread_mutex_t mutex_rcv_socket = PTHREAD_MUTEX_INITIALIZER;
void *rcv_socket_loop(void *)
{
for (;;) {
MilliSleep(500);//5);
{
guard_lock socket_lock(&mutex_rcv_socket);
if (exit_socket_loop) break;
if (tcpip && tcpip->fd() != -1) {
try {
tcpip->recv(rxbuffer);
box_tcpip_connect->color(FL_GREEN);
box_tcpip_connect->redraw();
box_xcvr_connect->color(FL_GREEN);
box_xcvr_connect->redraw();
tcpip_menu_box->color(FL_GREEN);
tcpip_menu_box->redraw();
} catch (const SocketException& e) {
LOG_ERROR("Error %d, %s", e.error(), e.what());
box_tcpip_connect->color(FL_YELLOW);
box_tcpip_connect->redraw();
box_xcvr_connect->color(FL_YELLOW);
box_xcvr_connect->redraw();
tcpip_menu_box->color(FL_YELLOW);
tcpip_menu_box->redraw();
}
}
} // end guard_lock
}
exit_socket_loop = false;
return NULL;
}
void connect_to_remote()
{
try {
if (remote_addr) delete remote_addr;
remote_addr = new Address(progStatus.tcpip_addr.c_str(), progStatus.tcpip_port.c_str());
LOG_QUIET("Created new remote_addr @ %p", remote_addr);
if (!tcpip) {
guard_lock socket_lock(&mutex_rcv_socket);
tcpip = new Socket(*remote_addr);
LOG_QUIET("Created new socket @ %p", tcpip);
tcpip->set_timeout(0.001);
tcpip->connect();
tcpip->set_nonblocking(true);
LOG_QUIET("Connected to %d", tcpip->fd());
tcpip_box->show();
box_tcpip_connect->color(FL_GREEN);
box_tcpip_connect->redraw();
box_xcvr_connect->color(FL_GREEN);
box_xcvr_connect->redraw();
tcpip_menu_box->color(FL_GREEN);
tcpip_menu_box->redraw();
}
if (tcpip->fd() == -1) {
try {
tcpip->connect(*remote_addr);
tcpip->set_nonblocking(true);
LOG_QUIET("Connected to %d", tcpip->fd());
tcpip_box->show();
box_tcpip_connect->color(FL_GREEN);
box_tcpip_connect->redraw();
box_xcvr_connect->color(FL_GREEN);
box_xcvr_connect->redraw();
tcpip_menu_box->color(FL_GREEN);
tcpip_menu_box->redraw();
} catch (const SocketException & e) {
LOG_ERROR("Error: %d, %s", e.error(), e.what());
delete remote_addr;
remote_addr = 0;
delete tcpip;
tcpip = 0;
box_tcpip_connect->color(FL_LIGHT1);
box_tcpip_connect->redraw();
box_xcvr_connect->color(FL_LIGHT1);
box_xcvr_connect->redraw();
tcpip_menu_box->color(FL_LIGHT1);
tcpip_menu_box->redraw();
throw e;
}
}
if (!rcv_socket_thread) {
rcv_socket_thread = new pthread_t;
if (pthread_create(rcv_socket_thread, NULL, rcv_socket_loop, NULL)) {
perror("pthread_create");
exit(EXIT_FAILURE);
}
LOG_QUIET("%s", "Socket receive thread started");
}
}
catch (const SocketException& e) {
LOG_ERROR("Error: %d, %s", e.error(), e.what());
delete remote_addr;
remote_addr = 0;
LOG_ERROR("Deleted remote address");
delete tcpip;
tcpip = 0;
LOG_ERROR("Deleted tcpip socket");
throw e;
}
return;
}
void disconnect_from_remote()
{
if (!tcpip || tcpip->fd() == -1) return;
tcpip->close();
delete tcpip;
tcpip = 0;
LOG_QUIET("%s", "Deleted tcpip socket instance");
delete remote_addr;
remote_addr = 0;
LOG_QUIET("%s", "Deleted socket address instance");
exit_socket_loop = true;
pthread_join(*rcv_socket_thread, NULL);
rcv_socket_thread = NULL;
LOG_QUIET("%s", "Exited from socket read thread");
box_tcpip_connect->color(FL_LIGHT1);
box_tcpip_connect->redraw();
box_xcvr_connect->color(FL_LIGHT1);
box_xcvr_connect->redraw();
tcpip_menu_box->color(FL_LIGHT1);
tcpip_menu_box->redraw();
}
int retry_after = 0;
int drop_count = 0;
void send_to_remote(std::string cmd_string)
{
if (retry_after > 0) {
retry_after -= progStatus.serloop_timing;
if (retry_after < 0) retry_after = 0;
return;
}
if (!tcpip || tcpip->fd() == -1) {
try {
connect_to_remote();
} catch (...) {
LOG_QUIET("Retry connect in %d seconds", progStatus.tcpip_reconnect_after);
retry_after = 1000 * progStatus.tcpip_reconnect_after;
return;
}
}
try {
tcpip->send(cmd_string);
LOG_WARN("send to remote: %s", cmd_string.c_str());
drop_count = 0;
} catch (const SocketException& e) {
LOG_ERROR("Error: %d, %s", e.error(), e.what());
drop_count++;
if (drop_count == progStatus.tcpip_drops_allowed) {
disconnect_from_remote();
drop_count = 0;
}
}
return;
}
int read_from_remote(std::string &str)
{
if (!tcpip || tcpip->fd() == -1) return 0;
{ guard_lock socket_lock(&mutex_rcv_socket);
str = rxbuffer;
rxbuffer.clear();
}
char szc[200];
snprintf(szc, sizeof(szc), "read_from_remote() : %s", str.c_str());
LOG_WARN("%s", szc);
return (int)str.length();
}
flrig-2.0.04/src/support/status.cxx 0000664 0001750 0001750 00000255425 14505023152 014207 0000000 0000000 // ----------------------------------------------------------------------------
// Copyright (C) 2014
// David Freese, W1HKJ
//
// This file is part of flrig.
//
// flrig is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation; either version 3 of the License, or
// (at your option) any later version.
//
// flrig is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program. If not, see .
// ----------------------------------------------------------------------------
#include
#include
#include
#include
#include
#include
#include
#include "dialogs.h"
#include "status.h"
#include "util.h"
#include "rig.h"
#include "rigs.h"
#include "support.h"
#include "config.h"
#include "rigpanel.h"
#include "ui.h"
#include "debug.h"
std::string xcvr_name = rig_null.name_;
int current_ui_size = -1;
status progStatus = {
50, // int mainX;
50, // int mainY;
800, // int mainW;
150, // int mainH;
small_ui, // UISIZE, UIsize;
false, // UIchanged;
20, // int memX;
20, // int memY;
600, // int memW;
164, // int memH;
785, // int metersX;
50, // int metersy;
false, // bool meters_dialog_visible;
20, // int ddX;
20, // int ddY;
"NONE", // std::string xcvr_serial_port;
0, // int serial_baudrate;
2, // int stopbits;
2, // int serial_retries;
0, // int serial_write_delay;
0, // int serial_post_write_delay
50, // int serial_timeout;
0, // bool serial_catptt;
0, // bool serial_rtsptt;
0, // bool serial_dtrptt;
false, // bool serial_rtscts;
false, // bool serial_rtsplus;
false, // bool serial_dtrplus;
500, // int serloop_timing;
"NONE", // std::string aux_serial_port;
false, // bool aux_SCU_17;
false, // bool aux_rts;
false, // bool aux_dtr;
"12345", // std::string xmlport;
"NONE", // std::string sep_serial_port;
0, // bool sep_rtsptt;
0, // bool sep_dtrptt;
false, // bool sep_rtsplus;
false, // bool sep_dtrplus;
false, // bool sep_SCU_17;
"NONE", // std::string cmedia_device
"GPIO-3", // std::string cmedia_gpio_line
0, // bool cmedia_ptt
"NONE", // std::string tmate2_devide
"5000", // std::string tmate2_freq_step
false, // bool tmate2_connected
false, // bool disable_CW_ptt;
0, // int CIV;
false, // bool USBaudio;
1, // bool poll_smeter;
1, // bool poll_frequency;
1, // bool poll_mode;
1, // bool poll_bandwidth;
1, // bool poll_volume;
1, // bool poll_auto_notch;
1, // bool poll_notch;
1, // bool poll_ifshift;
1, // bool poll_pbt;
1, // bool poll_power_control;
1, // bool poll_pre_att;
1, // bool poll_micgain;
1, // bool poll_squelch;
1, // bool poll_rfgain;
1, // bool poll_pout;
1, // bool poll_swr;
1, // bool poll_alc;
1, // bool poll_split;
1, // bool poll_noise;
1, // bool poll_nr;
// 0, // int poll_vfoAorB;
1, // poll_meters;
1, // poll_ops;
1, // poll_compression;
1, // poll_tuner;
1, // poll_ptt;
4, // poll_break_in;
4, // int poll_all;
-1, // int iBW_A;
1, // int imode_A;
14070000, // unsigned long long freq_A;
-1, // int iBW_B;
1, // int imode_B;
7070000, // unsigned long long freq_B;
"", // std::string filters;
"", // std::string bandwidths;
true, // bool use_rig_data;
false, // bool spkr_on;
20, // int volume;
0, // double power_level;
100, // double power_limit;
false, // bool enable_power_limit
10, // int mic_gain;
false, // bool notch;
0, // int notch_val;
false, // bool shift;
0, // int shift_val;
0, // bool pbt_lock;
0, // int pbt_inner;
0, // int pbt_outer;
100, // int rfgain;
10, // int squelch;
0, // int schema;
0, // int embed_tabs;
0, // int show_tabs;
true, // bool first_use; true only during program start
"", // std::string visible_tab;
true, // bool hrd_buttons
FL_WHEN_CHANGED, // int sliders_button
0, // int line_out;
false, // bool data_port;
1, // int agc_level;
18, // int cw_wpm;
3.0, // double cw_weight;
0, // int cw_vol;
0, // int cw_spot;
false, // bool spot_onoff;
700, // int cw_spot_tone;
false, // bool enable_keyer;
0, // int break_in;
15, // double cw_qsk;
200, // double cw_delay;
false, // int vox_onoff;
10, // int vox_gain;
10, // int vox_anti;
100, // int vox_hang; FT950 default
true, // bool vox_on_dataport;
0, // int compression;
false, // bool compON;
0, // bool noise_reduction;
0, // int noise_reduction_val;
0, // int nb_level;
false, // bool noise;
0, // int attenuator
0, // int preamp;
0, // int auto_notch;
0, // int split;
0, // int no_txqsy
1, // int rx_avg;
4, // int rx_peak;
1, // int pwr_avg;
4, // int pwr_peak;
4, // int pwr_scale ==> Autoselect
1, // bool sync_clock
1, // bool sync_gmt
// ic7610 special controls
false, // bool digi_sel_on_off;
0, // int digi_sel_val;
6, // int ic7610att;
0, // bool dual_watch;
//ft950 reversed RF gain values
false, // bool ft950_rg_reverse
true, // bool restore_frequency;
true, // bool restore_mode;
true, // bool restore_bandwidth;
true, // bool restore_volume;
true, // bool restore_mic_gain;
true, // bool restore_rf_gain;
true, // bool restore_power_control;
true, // bool restore_if_shift;
true, // bool restore_notch;
true, // bool restore_auto_notch;
true, // bool restore_noise;
true, // bool restore_squelch;
true, // bool restore_split;
true, // bool restore_pre_att;
true, // bool restore_nr;
true, // bool restore_comp_on_off;
true, // bool restore_comp_level;
//tt550 controls
80, // tt550_line_out;
1, // tt550_agc_level;
24, // tt550_cw_wpm;
1.0, // tt550_cw_weight;
10, // tt550_cw_vol;
10, // tt550_cw_spot;
false, // tt550_cw_spot_onoff;
20, // tt550_cw_qsk;
false, // tt550_enable_keyer;
false, // tt550_vox_onoff;
0, // tt550_vox_gain;
0, // tt550_vox_anti;
0, // tt550_vox_hang;
0, // tt550_mon_vol;
0, // tt550_squelch_level;
0, // tt550_compression;
1, // tt550_nb_level;
false, // tt550_bool compON;
false, // tt550_tuner_bypass;
true, // tt550_enable_xmtr;
false, // tt550_enable_tloop;
true, // tt550_use_line_in;
14, // tt550_xmt_bw;
false, // tt550_use_xmt_bw;
25, // tt550_AM_level;
0, // tt550_encoder_step;
1, // tt550_encoder_sensitivity;
2000, // tt550_keypad_timeout;
0, // tt550_F1_func;
0, // tt550_F2_func;
0, // tt550_F3_func;
5, // tt550_Nsamples;
true, // tt550_at11_inline;
true, // tt550_at11_hiZ;
// =========================
0.0, // vfo_adj;
600, // bfo_freq;
0, // rit_freq;
0, // xit_freq;
1500, // bpf_center;
true, // use_bpf_center;
// =========================
// IC706MKIIG filters
false, // bool use706filters
"EMPTY", // std::string ssb_cw_wide;
"NORMAL", // std::string ssb_cw_normal;
"EMPTY", // std::string ssb_cw_narrow;
// optional filter std::strings
// "EMPTY", "NARR", "NORM", "WIDE", "MED",
// "FL-101", "FL-232", "FL-100", "FL-223", "FL-103"
// =========================
"cmd 1", // std::string label1;
"", // std::string command1;
"", // std::string shftcmd1;
"cmd 2", // std::string label2;
"", // std::string command2;
"", // std::string shftcmd2;
"cmd 3", // std::string label3;
"", // std::string command3;
"", // std::string shftcmd3;
"cmd 4", // std::string label4;
"", // std::string command4;
"", // std::string shftcmd4;
"cmd 5", // std::string label5;
"", // std::string command5;
"", // std::string shftcmd5;
"cmd 6", // std::string label6;
"", // std::string command6;
"", // std::string shftcmd6;
"cmd 7", // std::string label7;
"", // std::string command7;
"", // std::string shftcmd7;
"cmd 8", // std::string label8;
"", // std::string command8;
"", // std::string shftcmd8;
"cmd 9", // std::string label9;
"", // std::string command9;
"", // std::string shftcmd9;
"cmd 10", // std::string label10;
"", // std::string command10;
"", // std::string shftcmd10;
"cmd 11", // std::string label11;
"", // std::string command11;
"", // std::string shftcmd11;
"cmd 12", // std::string label12;
"", // std::string command12;
"", // std::string shftcmd12;
"cmd 13", // std::string label13;
"", // std::string command13;
"", // std::string shftcmd13;
"cmd 14", // std::string label14;
"", // std::string command14;
"", // std::string shftcmd14;
"cmd 15", // std::string label15;
"", // std::string command15;
"", // std::string shftcmd15;
"cmd 16", // std::string label16;
"", // std::string command16;
"", // std::string shftcmd16;
"cmd 17", // std::string label17;
"", // std::string command17;
"", // std::string shftcmd17;
"cmd 18", // std::string label18;
"", // std::string command18;
"", // std::string shftcmd18;
"cmd 19", // std::string label19;
"", // std::string command19;
"", // std::string shftcmd19;
"cmd 20", // std::string label20;
"", // std::string command20;
"", // std::string shftcmd20;
"cmd 21", // std::string label21;
"", // std::string command21;
"", // std::string shftcmd21;
"cmd 22", // std::string label22;
"", // std::string command22;
"", // std::string shftcmd22;
"cmd 23", // std::string label23;
"", // std::string command23;
"", // std::string shftcmd23;
"cmd 24", // std::string label24;
"", // std::string command24;
"", // std::string shftcmd24;
"1", // std::string label_on_start1;
"", // std::string cmd_on_start1;
"2", // std::string label_on_start2;
"", // std::string cmd_on_start2;
"3", // std::string label_on_start3;
"", // std::string cmd_on_start3;
"4", // std::string label_on_start4;
"", // std::string cmd_on_start4;
"1", // std::string label_on_exit1;
"", // std::string cmd_on_exit1;
"2", // std::string label_on_exit2;
"", // std::string cmd_on_exit2;
"3", // std::string label_on_exit3;
"", // std::string cmd_on_exit3;
"4", // std::string label_on_exit4;
"", // std::string cmd_on_exit4;
// =========================
232, // int bg_red;
255, // int bg_green;
232, // int bg_blue;
0, // int fg_red;
0, // int fg_green;
0, // int fg_blue;
148, // int swrRed;
0, // int swrGreen;
148, // int swrBlue;
180, // int pwrRed;
0, // int pwrGreen;
0, // int pwrBlue;
0, // int smeterRed;
180, // int smeterGreen;
0, //int smeterBlue;
255, // int peakRed;
0, // int peakGreen;
0, // int peakBlue;
0, // int voltRed;
0, // int voltGreen;
255, // int voltBlue;
0, // int display_voltmeter;
0, // int fg_sys_red;
0, // int fg_sys_green;
0, // int fg_sys_blue;
0xc0, // int bg_sys_red;
0xc0, // int bg_sys_green;
0xc0, // int bg_sys_blue;
255, // int bg2_sys_red;
255, // int bg2_sys_green;
255, // int bg2_sys_blue;
232, // int slider_red;
255, // int slider_green;
232, // int slider_blue;
0, // int slider_btn_red;
0, // int slider_btn_green;
128, // int slider_btn_blue;
255, // int lighted_btn_red;
255, // int lighted_btn_green;
0, // int lighted_btn_blue;
230, // int tab_red;
230, // int tab_green;
230, // int tab_blue;
FL_COURIER, // Fl_Font fontnbr;
false, // bool tooltips;
"base", // std::string ui_scheme
// "7362", // std::string server_port
// "127.0.0.1",// std::string server_address
"127.0.0.1", // std::string xmlrig_addr;
"12345", // std::string xmlrig_port;
false, // bool xmlrpg_rig;
"4001", // std::string tcpip_port
"127.0.0.1",// std::string tcpip_address
50, // int tcpip_ping_delay
10, // int tcpip_reconnect_after in seconds
10, // int tcpip_drops_allowed;
false, // bool use_tcpip
"40001", // std::string tci_port
"127.0.0.1",// std::string tci address
10, // int tci_center;
false, // bool xcvr auto on
false, // bool xcvr auto off
false, // bool external_tuner
false, // bool trace;
false, // bool rigtrace;
false, // bool gettrace;
false, // bool settrace;
false, // bool debugtrace;
false, // bool xmltrace;
false, // bool rpctrace;
false, // bool serialtrace;
false, // bool tcitrace;
false, // bool start_stop_trace;
0, // int rpc_level;
// bands; defaults for FT857 / FT897 / Xiegu-G90
// frequency, mode, txCTCSS, rxCTCSS, offset, offset_freq;
1805000L, 0, 0, 0, 0, 600, // f160
3580000L, 0, 0, 0, 0, 600, // f80 meters
7070000L, 0, 0, 0, 0, 600, // f40 meters
10140000L, 0, 0, 0, 0, 600, // f30 meters
14070000L, 0, 0, 0, 0, 600, // f20 meters
18100000L, 0, 0, 0, 0, 600, // f17 meters
21070000L, 0, 0, 0, 0, 600, // f15 meters
24920000L, 0, 0, 0, 0, 600, // f12 meters
28070000L, 0, 0, 0, 0, 600, // f10 meters
50070000L, 0, 0, 0, 0, 600, // f6 meters
144070000L, 0, 0, 0, 0, 600, // f2 meters
432100000L, 0, 0, 0, 0, 600, // f70 cent'
1210000000L, 0, 0, 0, 0, 600, // f12G
15000000L, 0, 0, 0, 0, 600, // general
// memory management
4, // Fl_Font memfontnbr;
14, // int memfontsize;
// gpio parameters
false, // bool gpio_ptt;
0, // int enable_gpio;
0, // int gpio_on;
0, // int gpio_pulse_width;
// KXPA 100 presence
// 0, // int kxpa on line = 1
// cwio parameters
20, // int cwioWPM;
2, // int cwioKEYLINE; 1 == RTS, 2 == DTR
0, // int cwioSHARED; 0 = NONE, 1 = CAT, 2 = AUX, 3 = SEP, 4 = CWIO
0, // int cwioPTT; 1 - use PTT, 0 - use Brea-in
0, // int cwioCONNECTED; 1 - connected state; 0 - unconnected state
0, // int cwioINVERTED; 1 - DTR/RTS (-) keying;
0, // double cwio_comp;
0, // double cwio_keycorr;
"", // std::string cwioPORT;
{
"","","","","","",
"","","","","","" // std::string cwio_msgs[12];
},
{
"m2","m2","m3","m4","m4","m6",
"m7","m8","m9","m10","m11","m12" // std::string cwio_labels[12];
},
"=", // std::string BT;
"~", // std::string AA;
"<", // std::string AS;
">", // std::string AR;
"%", // std::string KN;
"+", // std::string SK;
"&", // std::string INT;
"{", // std::string HM;
"}", // std::string VE;
// FSK_ parameters
1, // int FSK_KEYLINE; 1 == RTS, 2 == DTR
0, // int FSK_SHARED; 0 = NONE, 1 = CAT, 2 = AUX, 3 = SEP
0, // int FSK_PTT; 1 - use PTT, 0 - use Brea-in
0, // int FSK_CONNECTED; 1 - connected state; 0 - unconnected state
0, // int FSK_INVERTED; reverse keying;
1, // int FSK_STOPBITS; 1 - 1.5; 0 - 2
8, // int fsk_idles
"", // std::string FSK_PORT;
{
"","","","","","",
"","","","","","" // std::string FSK_msgs[12];
},
{
"m2","m2","m3","m4","m4","m6",
"m7","m8","m9","m10","m11","m12" // std::string FSK_labels[12];
},
// CW logbook parameters
"", // std::string cw_log_name;
0, // int cw_log_cut_numbers;
0, // int cw_log_leading_zeros;
1, // int cw_log_dupcheck;
0, // int cw_log_nbr;
// RTTY logbook parameters
"", // std::string fsk_log_name;
0, // int fsk_log_cut_numbers;
0, // int fsk_log_leading_zeros;
1, // int fsk_log_dupcheck;
0, // int fsk_log_nbr
};
void status::saveLastState()
{
xcvr_name = selrig->name_;
Fl_Preferences xcvrpref(RigHomeDir.c_str(), "w1hkj.com", PACKAGE_TARNAME);
xcvrpref.set("xcvr_name", xcvr_name.c_str());
int mX = mainwindow->x();
int mY = mainwindow->y();
int mW = mainwindow->w();
int mH = mainwindow->h();
if (dlgMemoryDialog) {
memX = dlgMemoryDialog->x();
memY = dlgMemoryDialog->y();
memW = dlgMemoryDialog->w();
memH = dlgMemoryDialog->h();
}
if (meters_dialog)
{
metersX = meters_dialog->x();
metersY = meters_dialog->y();
}
mainX = mX;
mainY = mY;
if (UIsize == wide_ui) {
if (mW < WIDE_MAINW)
mW = WIDE_MAINW;
mH = WIDE_MAINH;
}
mainW = mW;
mainH = mH;
if (tabsGeneric)
visible_tab = (tabsGeneric->value())->label();
Fl_Preferences spref(RigHomeDir.c_str(), "w1hkj.com", xcvr_name.c_str());
spref.set("version", PACKAGE_VERSION);
spref.set("mainx", mainX);
spref.set("mainy", mainY);
spref.set("mainw", mainW);
spref.set("mainh", mainH);
spref.set("uisize", UIsize);
spref.set("memx", memX);
spref.set("memy", memY);
spref.set("memw", memW);
spref.set("memh", memH);
spref.set("metersx", metersX);
spref.set("metersy", metersY);
spref.set("meters_dialog_visible", meters_dialog->shown());
spref.set("ddx", ddX);
spref.set("ddy", ddY);
spref.set("xcvr_serial_port", xcvr_serial_port.c_str());
spref.set("serial_baudrate", serial_baudrate);
spref.set("serial_stopbits", stopbits);
spref.set("serial_retries", serial_retries);
spref.set("serial_write_delay", serial_write_delay);
spref.set("serial_post_write_delay", serial_post_write_delay);
spref.set("serial_timeout", serial_timeout);
spref.set("serloop_timing", serloop_timing);
spref.set("ptt_via_cat", serial_catptt);
spref.set("ptt_via_rts", serial_rtsptt);
spref.set("ptt_via_dtr", serial_dtrptt);
spref.set("rts_cts_flow", serial_rtscts);
spref.set("rts_plus", serial_rtsplus);
spref.set("dtr_plus", serial_dtrplus);
spref.set("disable_CW_ptt", disable_CW_ptt);
spref.set("civadr", CIV);
spref.set("usbaudio", USBaudio);
spref.set("aux_serial_port", aux_serial_port.c_str());
spref.set("aux_rts", aux_rts);
spref.set("aux_dtr", aux_dtr);
spref.set("sep_serial_port", sep_serial_port.c_str());
spref.set("sep_rtsptt", sep_rtsptt);
spref.set("sep_dtrptt", sep_dtrptt);
spref.set("sep_rtsplus", sep_rtsplus);
spref.set("set_dtrplus", sep_dtrplus);
spref.set("xmlport", xmlport.c_str());
spref.set("cmedia_device", cmedia_device.c_str());
spref.set("cmedia_gpio_line", cmedia_gpio_line.c_str());
spref.set("cmedia_ptt", cmedia_ptt);
spref.set("tmate2_device", tmate2_device.c_str());
spref.set("tmate2_freq_step", tmate2_freq_step.c_str());
spref.set("tmate2_connected", tmate2_connected);
spref.set("poll_smeter", poll_smeter);
spref.set("poll_frequency", poll_frequency);
spref.set("poll_mode", poll_mode);
spref.set("poll_bandwidth", poll_bandwidth);
spref.set("poll_volume", poll_volume);
spref.set("poll_auto_notch", poll_auto_notch);
spref.set("poll_notch", poll_notch);
spref.set("poll_ifshift", poll_ifshift);
spref.set("poll_pbt", poll_pbt);
spref.set("poll_power_control", poll_power_control);
spref.set("poll_pre_att", poll_pre_att);
spref.set("poll_micgain", poll_micgain);
spref.set("poll_squelch", poll_squelch);
spref.set("poll_rfgain", poll_rfgain);
spref.set("poll_pout", poll_pout);
spref.set("poll_swr", poll_swr);
spref.set("poll_alc", poll_alc);
spref.set("poll_split", poll_split);
spref.set("poll_noise", poll_noise);
spref.set("poll_nr", poll_nr);
spref.set("poll_compression", poll_compression);
spref.set("poll_tuner", poll_tuner);
spref.set("poll_ptt", poll_ptt);
spref.set("poll_break_in", poll_break_in);
spref.set("poll_all", poll_all);
spref.set("bw_A", iBW_A);
spref.set("mode_A", imode_A);
int freq_A_lower, freq_A_upper;
freq_A_upper = freq_A / 1000000000;
freq_A_lower = freq_A - freq_A_upper * 1000000000;
spref.set("freq_A_u", freq_A_upper);
spref.set("freq_A_l", freq_A_lower);
spref.set("bw_B", iBW_B);
spref.set("mode_B", imode_B);
int freq_B_lower, freq_B_upper;
freq_B_upper = freq_B / 1000000000;
freq_B_lower = freq_B - freq_B_upper * 1000000000;
spref.set("freq_B_u", freq_B_upper);
spref.set("freq_B_l", freq_B_lower);
spref.set("filters", filters.c_str());
spref.set("bandwidths", bandwidths.c_str());
spref.set("use_rig_data", use_rig_data);
// spref.set("restore_rig_data", restore_rig_data);
spref.set("restore_frequency", restore_frequency);
spref.set("restore_mode", restore_mode);
spref.set("restore_bandwidth", restore_bandwidth);
spref.set("restore_volume", restore_volume);
spref.set("restore_mic_gain", restore_mic_gain);
spref.set("restore_rf_gain", restore_rf_gain);
spref.set("restore_power_control", restore_power_control);
spref.set("restore_if_shift", restore_if_shift);
spref.set("restore_notch", restore_notch);
spref.set("restore_auto_notch", restore_auto_notch);
spref.set("restore_noise", restore_noise);
spref.set("restore_squelch", restore_squelch);
spref.set("restore_split", restore_split);
spref.set("restore_pre_att", restore_pre_att);
spref.set("restore_nr", restore_nr);
spref.set("restore_comp_on_off", restore_comp_on_off);
spref.set("restore_comp_level", restore_comp_level);
spref.set("bool_spkr_on", spkr_on);
spref.set("int_volume", volume);
spref.set("dbl_power", power_level);
spref.set("power_limit", power_limit);
spref.set("enable_power_limit", enable_power_limit);
spref.set("int_mic", mic_gain);
spref.set("bool_notch", notch);
spref.set("int_notch", notch_val);
spref.set("bool_shift", shift);
spref.set("int_shift", shift_val);
spref.set("pbt_lock", pbt_lock);
spref.set("pbt_inner", pbt_inner);
spref.set("pbt_outer", pbt_outer);
spref.set("rfgain", rfgain);
spref.set("squelch", squelch);
spref.set("no_txqsy", no_txqsy);
spref.set("schema", schema);
spref.set("embed_tabs", embed_tabs);
if (!embed_tabs && tabs_dialog)
show_tabs = tabs_dialog->visible();
spref.set("show_tabs", show_tabs);
spref.set("visible_tab", visible_tab.c_str());
spref.set("rx_avg", rx_avg);
spref.set("rx_peak", rx_peak);
spref.set("pwr_avg", pwr_avg);
spref.set("pwr_peak", pwr_peak);
spref.set("pwr_scale", pwr_scale);
spref.set("sync_clock", sync_clock);
spref.set("sync_gmt", sync_gmt);
spref.set("digi_sel_on_off", digi_sel_on_off);
spref.set("digi_sel_val", digi_sel_val);
spref.set("dual_watch", dual_watch);
spref.set("ic7610att", index_ic7610att);
spref.set("ft950_rg_reverse", ft950_rg_reverse);
if (selrig->name_ == rig_TT550.name_) {
spref.set("tt550_line_out", tt550_line_out);
spref.set("tt550_agc_level", tt550_agc_level);
spref.set("tt550_cw_wpm", tt550_cw_wpm);
spref.set("tt550_cw_weight", tt550_cw_weight);
spref.set("tt550_cw_vol", tt550_cw_vol);
spref.set("tt550_cw_spot", tt550_cw_spot);
spref.set("tt550_spot_onoff", tt550_spot_onoff);
spref.set("tt550_cw_qsk", tt550_cw_qsk);
spref.set("tt550_enable_keyer", tt550_enable_keyer);
spref.set("cw_delay", cw_delay);
spref.set("tt550_vox_onoff", tt550_vox_onoff);
spref.set("tt550_vox_gain", tt550_vox_gain);
spref.set("tt550_vox_anti", tt550_vox_anti);
spref.set("tt550_vox_hang", tt550_vox_hang);
spref.set("tt550_mon_vol", tt550_mon_vol);
spref.set("tt550_squelch_level", tt550_squelch_level);
spref.set("tt550_compression", tt550_compression);
spref.set("tt550_nb_level", tt550_nb_level);
spref.set("tt550_compON", tt550_compON);
spref.set("tt550_tuner_bypass", tt550_tuner_bypass);
spref.set("tt550_enable_xmtr", tt550_enable_xmtr);
spref.set("tt550_enable_tloop", tt550_enable_tloop);
spref.set("tt550_xmt_bw", tt550_xmt_bw);
spref.set("tt550_use_xmt_bw", tt550_use_xmt_bw);
spref.set("tt550_AM_level", tt550_AM_level);
spref.set("tt550_use_line_in", tt550_use_line_in);
spref.set("tt550_encoder_step", tt550_encoder_step);
spref.set("tt550_encoder_sensitivity", tt550_encoder_sensitivity);
spref.set("tt550_keypad_timeout", tt550_keypad_timeout);
spref.set("tt550_F1_func", tt550_F1_func);
spref.set("tt550_F2_func", tt550_F2_func);
spref.set("tt550_F3_func", tt550_F3_func);
spref.set("tt550_Nsamples", tt550_Nsamples);
spref.set("tt550_at11_inline", tt550_at11_inline);
spref.set("tt550_at11_hiZ", tt550_at11_hiZ);
} else {
spref.set("line_out", line_out);
spref.set("data_port", data_port);
spref.set("vox_on_dataport", vox_on_dataport);
spref.set("agc_level", agc_level);
spref.set("cw_wpm", cw_wpm);
spref.set("cw_weight", cw_weight);
spref.set("cw_vol", cw_vol);
spref.set("cw_spot", cw_spot);
spref.set("spot_onoff", spot_onoff);
spref.set("cw_spot_tone", cw_spot_tone);
spref.set("cw_qsk", cw_qsk);
spref.set("cw_delay", cw_delay);
spref.set("enable_keyer", enable_keyer);
spref.set("break_in", break_in);
spref.set("vox_onoff", vox_onoff);
spref.set("vox_gain", vox_gain);
spref.set("vox_anti", vox_anti);
spref.set("vox_hang", vox_hang);
spref.set("compression", compression);
spref.set("compON", compON);
}
spref.set("noise_reduction", noise_reduction);
spref.set("noise_red_val", noise_reduction_val);
spref.set("nb_level", nb_level);
spref.set("bool_noise", noise);
spref.set("int_preamp", preamp);
spref.set("int_att", attenuator);
spref.set("vfo_adj", vfo_adj);
spref.set("bfo_freq", bfo_freq);
spref.set("rit_freq", rit_freq);
spref.set("xit_freq", xit_freq);
spref.set("bpf_center", bpf_center);
spref.set("use_bpf_center", use_bpf_center);
if (selrig->name_ == IC706MKIIGname_) {
spref.set("use706filters", use706filters);
spref.set("Set_IC706MKIIG_filter_names", "");
spref.set("IC706MKIIG_filter_names_1", \
"EMPTY,NARR,NORM,WIDE,MED" );
spref.set("IC706MKIIG_filter_names_2", \
"FL-101,FL-232,FL-100,FL-223,FL-103" );
spref.set("ssb_cw_wide", ssb_cw_wide.c_str());
spref.set("ssb_cw_normal", ssb_cw_normal.c_str());
spref.set("ssb_cw_narrow", ssb_cw_narrow.c_str());
selrig->initialize();
}
spref.set("label1", label1.c_str());
spref.set("command1", command1.c_str());
spref.set("shftcmd1", shftcmd1.c_str());
spref.set("label2", label2.c_str());
spref.set("command2", command2.c_str());
spref.set("shftcmd2", shftcmd2.c_str());
spref.set("label3", label3.c_str());
spref.set("command3", command3.c_str());
spref.set("shftcmd3", shftcmd3.c_str());
spref.set("label4", label4.c_str());
spref.set("command4", command4.c_str());
spref.set("shftcmd4", shftcmd4.c_str());
spref.set("label5", label5.c_str());
spref.set("command5", command5.c_str());
spref.set("shftcmd5", shftcmd5.c_str());
spref.set("label6", label6.c_str());
spref.set("command6", command6.c_str());
spref.set("shftcmd6", shftcmd6.c_str());
spref.set("label7", label7.c_str());
spref.set("command7", command7.c_str());
spref.set("shftcmd7", shftcmd7.c_str());
spref.set("label8", label8.c_str());
spref.set("command8", command8.c_str());
spref.set("shftcmd8", shftcmd8.c_str());
spref.set("label9", label9.c_str());
spref.set("command9", command9.c_str());
spref.set("shftcmd9", shftcmd9.c_str());
spref.set("label10", label10.c_str());
spref.set("command10", command10.c_str());
spref.set("shftcmd10", shftcmd10.c_str());
spref.set("label11", label11.c_str());
spref.set("command11", command11.c_str());
spref.set("shftcmd11", shftcmd11.c_str());
spref.set("label12", label12.c_str());
spref.set("command12", command12.c_str());
spref.set("shftcmd12", shftcmd12.c_str());
spref.set("label13", label13.c_str());
spref.set("command13", command13.c_str());
spref.set("shftcmd13", shftcmd13.c_str());
spref.set("label14", label14.c_str());
spref.set("command14", command14.c_str());
spref.set("shftcmd14", shftcmd14.c_str());
spref.set("label15", label15.c_str());
spref.set("command15", command15.c_str());
spref.set("shftcmd15", shftcmd15.c_str());
spref.set("label16", label16.c_str());
spref.set("command16", command16.c_str());
spref.set("shftcmd16", shftcmd16.c_str());
spref.set("label17", label17.c_str());
spref.set("command17", command17.c_str());
spref.set("shftcmd17", shftcmd17.c_str());
spref.set("label18", label18.c_str());
spref.set("command18", command18.c_str());
spref.set("shftcmd18", shftcmd18.c_str());
spref.set("label19", label19.c_str());
spref.set("command19", command19.c_str());
spref.set("shftcmd19", shftcmd19.c_str());
spref.set("label20", label20.c_str());
spref.set("command20", command20.c_str());
spref.set("shftcmd20", shftcmd20.c_str());
spref.set("label21", label21.c_str());
spref.set("command21", command21.c_str());
spref.set("shftcmd21", shftcmd21.c_str());
spref.set("label22", label22.c_str());
spref.set("command22", command22.c_str());
spref.set("shftcmd22", shftcmd22.c_str());
spref.set("label23", label23.c_str());
spref.set("command23", command23.c_str());
spref.set("shftcmd23", shftcmd23.c_str());
spref.set("label24", label24.c_str());
spref.set("command24", command24.c_str());
spref.set("shftcmd24", shftcmd24.c_str());
spref.set("st_label1", label_on_start1.c_str());
spref.set("st_cmd1", cmd_on_start1.c_str());
spref.set("st_label2", label_on_start2.c_str());
spref.set("st_cmd2", cmd_on_start2.c_str());
spref.set("st_label3", label_on_start3.c_str());
spref.set("st_cmd3", cmd_on_start3.c_str());
spref.set("st_label4", label_on_start4.c_str());
spref.set("st_cmd4", cmd_on_start4.c_str());
spref.set("ex_label1", label_on_exit1.c_str());
spref.set("ex_cmd1", cmd_on_exit1.c_str());
spref.set("ex_label2", label_on_exit2.c_str());
spref.set("ex_cmd2", cmd_on_exit2.c_str());
spref.set("ex_label3", label_on_exit3.c_str());
spref.set("ex_cmd3", cmd_on_exit3.c_str());
spref.set("ex_label4", label_on_exit4.c_str());
spref.set("ex_cmd4", cmd_on_exit4.c_str());
spref.set("fg_red", fg_red);
spref.set("fg_green", fg_green);
spref.set("fg_blue", fg_blue);
spref.set("bg_red", bg_red);
spref.set("bg_green", bg_green);
spref.set("bg_blue", bg_blue);
spref.set("smeter_red", smeterRed);
spref.set("smeter_green", smeterGreen);
spref.set("smeter_blue", smeterBlue);
spref.set("power_red", pwrRed);
spref.set("power_green", pwrGreen);
spref.set("power_blue", pwrBlue);
spref.set("swr_red", swrRed);
spref.set("swr_green", swrGreen);
spref.set("swr_blue", swrBlue);
spref.set("peak_red", peakRed);
spref.set("peak_green", peakGreen);
spref.set("peak_blue", peakBlue);
spref.set("volt_red", voltRed);
spref.set("volt_green", voltGreen);
spref.set("volt_blue", voltBlue);
spref.set("display_voltmeter", display_voltmeter);
spref.set("fg_sys_red", fg_sys_red);
spref.set("fg_sys_green", fg_sys_green);
spref.set("fg_sys_blue", fg_sys_blue);
spref.set("bg_sys_red", bg_sys_red);
spref.set("bg_sys_green", bg_sys_green);
spref.set("bg_sys_blue", bg_sys_blue);
spref.set("bg2_sys_red", bg2_sys_red);
spref.set("bg2_sys_green", bg2_sys_green);
spref.set("bg2_sys_blue", bg2_sys_blue);
spref.set("slider_red", slider_red);
spref.set("slider_green", slider_green);
spref.set("slider_blue", slider_blue);
spref.set("slider_btn_red", slider_btn_red);
spref.set("slider_btn_green", slider_btn_green);
spref.set("slider_btn_blue", slider_btn_blue);
spref.set("lighted_btn_red", lighted_btn_red);
spref.set("lighted_btn_green", lighted_btn_green);
spref.set("lighted_btn_blue", lighted_btn_blue);
spref.set("tab_red", tab_red);
spref.set("tab_green", tab_green);
spref.set("tab_blue", tab_blue);
spref.set("fontnbr", fontnbr);
spref.set("tooltips", tooltips);
spref.set("ui_scheme", ui_scheme.c_str());
// spref.set("server_port", server_port.c_str());
// spref.set("server_addr", server_addr.c_str());
spref.set("xmlrig_port", xmlrig_port.c_str());
spref.set("xmlrig_addr", xmlrig_addr.c_str());
spref.set("tcpip_port", tcpip_port.c_str());
spref.set("tcpip_addr", tcpip_addr.c_str());
spref.set("tcpip_ping_delay", tcpip_ping_delay);
spref.set("tcpip_tcpip_reconnect_after", tcpip_reconnect_after);
spref.set("tcpip_drops_allowed", tcpip_drops_allowed);
spref.set("use_tcpip", use_tcpip);
spref.set("tci_port", tci_port.c_str());
spref.set("tci_addr", tci_addr.c_str());
spref.set("tci_center", tci_center);
spref.set("xcvr_auto_on", xcvr_auto_on);
spref.set("xcvr_auto_off", xcvr_auto_off);
spref.set("external_tuner", external_tuner);
spref.set("trace", trace);
spref.set("rigtrace", rigtrace);
spref.set("gettrace", gettrace);
spref.set("settrace", settrace);
spref.set("debugtrace", debugtrace);
spref.set("xmltrace", xmltrace);
spref.set("rpctrace", rpctrace);
spref.set("serialtrace", serialtrace);
spref.set("startstoptrace", start_stop_trace);
spref.set("tcitrace", tcitrace);
spref.set("rpc_level", rpc_level);
spref.set("f160", f160); spref.set("m160", m160);
spref.set("txT160", txT_160); spref.set("rxT160", rxT_160);
spref.set("offset_160", offset_160); spref.set("oF_160", oF_160);
spref.set("f80", f80); spref.set("m80", m80);
spref.set("txT80", txT_80); spref.set("rxT80", rxT_80);
spref.set("offset_80", offset_80); spref.set("oF_80", oF_80);
spref.set("f40", f40); spref.set("m40", m40);
spref.set("txT40", txT_40); spref.set("rxT40", rxT_40);
spref.set("offset_40", offset_40); spref.set("oF_40", oF_40);
spref.set("f30", f30); spref.set("m30", m30);
spref.set("txT30", txT_30); spref.set("rxT30", rxT_30);
spref.set("offset_30", offset_30); spref.set("oF_30", oF_30);
spref.set("f20", f20); spref.set("m20", m20);
spref.set("txT20", txT_20); spref.set("rxT20", rxT_20);
spref.set("offset_20", offset_20); spref.set("oF_20", oF_20);
spref.set("f17", f17); spref.set("m17", m17);
spref.set("txT17", txT_17); spref.set("rxT17", rxT_17);
spref.set("offset_17", offset_17); spref.set("oF_17", oF_17);
spref.set("f15", f15); spref.set("m15", m15);
spref.set("txT15", txT_15); spref.set("rxT15", rxT_15);
spref.set("offset_15", offset_15); spref.set("oF_15", oF_15);
spref.set("f12", f12); spref.set("m12", m12);
spref.set("txT12", txT_12); spref.set("rxT12", rxT_12);
spref.set("offset_12", offset_12); spref.set("oF_12", oF_12);
spref.set("f10", f10); spref.set("m10", m10);
spref.set("txT10", txT_10); spref.set("rxT10", rxT_10);
spref.set("offset_10", offset_10); spref.set("oF_10", oF_10);
spref.set("f6", f6); spref.set("m6", m6);
spref.set("txT6", txT_6); spref.set("rxT_6", rxT_6);
spref.set("offset_6", offset_6); spref.set("oF_6", oF_6);
spref.set("f2", f2); spref.set("m2", m2);
spref.set("txT2", txT_2); spref.set("rxT2", rxT_2);
spref.set("offset_2", offset_2); spref.set("oF_2", oF_2);
spref.set("f70", f70); spref.set("m70", m70);
spref.set("txT70", txT_70); spref.set("rxT70", rxT_70);
spref.set("offset_70", offset_70); spref.set("oF_70", oF_70);
spref.set("f12G", f12G); spref.set("m12G", m12G);
spref.set("txT12G", txT_12G); spref.set("rxT12G", rxT_12G);
spref.set("offset_12G", offset_12G); spref.set("oF_12G", oF_12G);
spref.set("fgen", fgen); spref.set("mgen", mgen);
spref.set("txTgen", txT_gen); spref.set("rxTgen", rxT_gen);
spref.set("offset_gen", offset_gen); spref.set("oF_gen", oF_gen);
spref.set("hrd_buttons", hrd_buttons);
spref.set("sliders_button", sliders_button);
spref.set("memfontnbr", memfontnbr);
spref.set("memfontsize", memfontsize);
spref.set("gpio_ptt", gpio_ptt);
spref.set("enable_gpio", enable_gpio);
spref.set("gpio_on", gpio_on);
spref.set("gpio_pulse_width", gpio_pulse_width);
// spref.set("kxpa", kxpa);
spref.set("cwioWPM", cwioWPM);
spref.set("cwio_comp", cwio_comp);
spref.set("cwio_keycorr", cwio_keycorr);
spref.set("cwioKEYLINE", cwioKEYLINE);
spref.set("cwioSHARED", cwioSHARED);
spref.set("cwioPTT", cwioPTT);
spref.set("cwioCONNECTED", cwioCONNECTED);
spref.set("cwioINVERTED", cwioINVERTED);
spref.set("cwioPORT", cwioPORT.c_str());
char setbuff[20];
for (int n = 0; n < 12; n++) {
snprintf(setbuff, sizeof(setbuff), "cwiolabel[%d]", n);
spref.set(setbuff, cwio_labels[n].c_str());
snprintf(setbuff, sizeof(setbuff), "cwiomessage[%d]", n);
spref.set(setbuff, cwio_msgs[n].c_str());
}
spref.set("BT", BT.c_str());
spref.set("AA", AA.c_str());
spref.set("AS", AS.c_str());
spref.set("AR", AR.c_str());
spref.set("KN", KN.c_str());
spref.set("SK", SK.c_str());
spref.set("INT", INT.c_str());
spref.set("HM", HM.c_str());
spref.set("VE", VE.c_str());
spref.set("FSK_KEYLINE", FSK_KEYLINE);
spref.set("FSK_SHARED", FSK_SHARED);
spref.set("FSK_PTT", FSK_PTT);
spref.set("FSK_CONNECTED", FSK_CONNECTED);
spref.set("FSK_INVERTED", FSK_INVERTED);
spref.set("FSK_STOPBITS", FSK_STOPBITS);
spref.set("FSK_IDLES", fsk_idles);
spref.set("FSK_PORT", FSK_PORT.c_str());
for (int n = 0; n < 12; n++) {
snprintf(setbuff, sizeof(setbuff), "fskiolabel[%d]", n);
spref.set(setbuff, FSK_labels[n].c_str());
snprintf(setbuff, sizeof(setbuff), "fskiomessage[%d]", n);
spref.set(setbuff, FSK_msgs[n].c_str());
}
// CW logbook parameters
spref.set("CW_LOG_NAME", cw_log_name.c_str());
spref.set("CW_CUT_NUMBERS", cw_log_cut_numbers);
spref.set("CW_LEADING_ZEROS", cw_log_leading_zeros);
spref.set("CW_DUPCHECK", cw_log_dupcheck);
spref.set("CW_LOG_NBR", cw_log_nbr);
// FSK logbook parameters
spref.set("FSK_LOG_NAME", fsk_log_name.c_str());
spref.set("FSK_CUT_NUMBERS", fsk_log_cut_numbers);
spref.set("FSK_LEADING_ZEROS", fsk_log_leading_zeros);
spref.set("FSK_DUPCHECK", fsk_log_dupcheck);
spref.set("FSK_LOG_NBR", fsk_log_nbr);
}
bool status::loadXcvrState(std::string xcvr)
{
Fl_Preferences spref(RigHomeDir.c_str(), "w1hkj.com", xcvr.c_str());
if (spref.entryExists("version")) {
int i;
char defbuffer[MAX_DEFBUFFER_SIZE];
spref.get("mainx", mainX, mainX);
spref.get("mainy", mainY, mainY);
spref.get("mainw", mainW, mainW);
spref.get("mainh", mainH, mainH);
spref.get("uisize", UIsize, UIsize);
if (UIsize == wide_ui) {
if (mainW < WIDE_MAINW)
mainW = WIDE_MAINW;
mainH = WIDE_MAINH;
}
spref.get("memx", memX, memX);
spref.get("memy", memY, memY);
spref.get("memw", memW, memW);
spref.get("memh", memH, memH);
spref.get("metersx", metersX, metersX);
spref.get("metersy", metersY, metersY);
spref.get("meters_dialog_visible", i, i); meters_dialog_visible = i;
spref.get("ddX", ddX, ddX);
spref.get("ddY", ddY, ddY);
if (current_ui_size != -1) {
UIsize = current_ui_size;
}
current_ui_size = UIsize;
if (UIsize == small_ui) {
mainW = SMALL_MAINW;
}
if (UIsize == touch_ui) {
if (mainW < TOUCH_MAINW) mainW = TOUCH_MAINW;
}
spref.get("xcvr_serial_port", defbuffer, "NONE", MAX_DEFBUFFER_SIZE);
xcvr_serial_port = defbuffer;
if (xcvr_serial_port.find("tty") == 0)
xcvr_serial_port.insert(0, "/dev/");
i = 0;
selrig = rigs[i];
while (rigs[i] != NULL) {
if (xcvr == rigs[i]->name_) {
selrig = rigs[i];
break;
}
i++;
}
{
int testbaud = -1;
spref.get("serial_baudrate", testbaud, testbaud);
if (testbaud > -1) {
spref.get("serial_baudrate", serial_baudrate, serial_baudrate);
spref.get("serial_stopbits", stopbits, stopbits);
spref.get("serial_retries", serial_retries, serial_retries);
spref.get("serial_write_delay", serial_write_delay, serial_write_delay);
spref.get("serial_post_write_delay", serial_post_write_delay, serial_post_write_delay);
spref.get("serial_timeout", serial_timeout, serial_timeout);
}
}
spref.get("serloop_timing", serloop_timing, serloop_timing);
if (serloop_timing < 10) serloop_timing = 10; // minimum loop delay of 10 msec
if (spref.get("ptt_via_cat", i, i)) serial_catptt = i;
if (spref.get("ptt_via_rts", i, i)) serial_rtsptt = i;
if (spref.get("ptt_via_dtr", i, i)) serial_dtrptt = i;
if (spref.get("rts_cts_flow", i, i)) serial_rtscts = i;
if (spref.get("rts_plus", i, i)) serial_rtsplus = i;
if (spref.get("dtr_plus", i, i)) serial_dtrplus = i;
if (spref.get("disable_CW_ptt", i, i)) disable_CW_ptt = i;
spref.get("civadr", CIV, CIV);
if (spref.get("usbaudio", i, i)) USBaudio = i;
spref.get("aux_serial_port", defbuffer, "NONE", MAX_DEFBUFFER_SIZE);
aux_serial_port = defbuffer;
if (spref.get("aux_rts", i, i)) aux_rts = i;
if (spref.get("aux_dtr", i, i)) aux_dtr = i;
spref.get("sep_serial_port", defbuffer, "NONE", MAX_DEFBUFFER_SIZE);
sep_serial_port = defbuffer;
if (spref.get("sep_rtsptt", i, i)) sep_rtsptt = i;
if (spref.get("sep_dtrptt", i, i)) sep_dtrptt = i;
if (spref.get("sep_rtsplus", i, i)) sep_rtsplus = i;
if (spref.get("sep_dtrplus", i, i)) sep_dtrplus = i;
spref.get("xmlport", defbuffer, "12345", MAX_DEFBUFFER_SIZE);
xmlport = defbuffer;
::xmlport = atoi(xmlport.c_str());
spref.get("cmedia_device", defbuffer, "NONE", MAX_DEFBUFFER_SIZE);
cmedia_device = defbuffer;
spref.get("cmedia_gpio_line", defbuffer, "GPIO-3", MAX_DEFBUFFER_SIZE);
cmedia_gpio_line = defbuffer;
spref.get("cmedia_ptt", i, cmedia_ptt); cmedia_ptt = i;
spref.get("tmate2_device", defbuffer, "NONE", MAX_DEFBUFFER_SIZE);
tmate2_device = defbuffer;
spref.get("tmate2_freq_step", defbuffer, "5000", MAX_DEFBUFFER_SIZE);
tmate2_freq_step = defbuffer;
spref.get("tmate2_connected", i, tmate2_connected); tmate2_connected = i;
spref.get("poll_smeter", poll_smeter, poll_smeter);
spref.get("poll_frequency", poll_frequency, poll_frequency);
spref.get("poll_mode", poll_mode, poll_mode);
spref.get("poll_bandwidth", poll_bandwidth, poll_bandwidth);
spref.get("poll_volume", poll_volume, poll_volume);
spref.get("poll_auto_notch", poll_auto_notch, poll_auto_notch);
spref.get("poll_notch", poll_notch, poll_notch);
spref.get("poll_ifshift", poll_ifshift, poll_ifshift);
spref.get("poll_power_control", poll_power_control, poll_power_control);
spref.get("poll_pbt", poll_pbt, poll_pbt);
spref.get("poll_pre_att", poll_pre_att, poll_pre_att);
spref.get("poll_micgain", poll_micgain, poll_micgain);
spref.get("poll_squelch", poll_squelch, poll_squelch);
spref.get("poll_rfgain", poll_rfgain, poll_rfgain);
spref.get("poll_pout", poll_pout, poll_pout);
spref.get("poll_swr", poll_swr, poll_swr);
spref.get("poll_alc", poll_alc, poll_alc);
spref.get("poll_split", poll_split, poll_split);
spref.get("poll_noise", poll_noise, poll_noise);
spref.get("poll_nr", poll_nr, poll_nr);
spref.get("poll_compression", poll_compression, poll_compression);
spref.get("poll_tuner", poll_tuner, poll_tuner);
spref.get("poll_ptt", poll_ptt, poll_ptt);
spref.get("poll_break_in", poll_break_in, poll_break_in);
spref.get("poll_all", poll_all, poll_all);
spref.get("bw_A", iBW_A, iBW_A);
spref.get("mode_A", imode_A, imode_A);
int freq_A_upper = 0;
int freq_A_lower = 14070000;
spref.get("freq_A_u", freq_A_upper, freq_A_upper);
spref.get("freq_A_l", freq_A_lower, freq_A_lower);
freq_A = (unsigned long long)freq_A_upper * 1000000000 + freq_A_lower;
spref.get("bw_B", iBW_B, iBW_B);
spref.get("mode_B", imode_B, imode_B);
int freq_B_upper = 0;
int freq_B_lower = 14070000;
spref.get("freq_B_u", freq_B_upper, freq_B_upper);
spref.get("freq_B_l", freq_B_lower, freq_B_lower);
freq_B = (unsigned long long)freq_B_upper * 1000000000 + freq_B_lower;
spref.get("filters", defbuffer, "", MAX_DEFBUFFER_SIZE);
filters = defbuffer;
spref.get("bandwidths", defbuffer, "", MAX_DEFBUFFER_SIZE);
bandwidths = defbuffer;
if (spref.get("use_rig_data", i, i)) use_rig_data = i;
// if (spref.get("restore_rig_data", i, i)) restore_rig_data = i;
if (spref.get("restore_frequency", i, i)) restore_frequency = i;
if (spref.get("restore_mode", i, i)) restore_mode = i;
if (spref.get("restore_bandwidth", i, i)) restore_bandwidth = i;
if (spref.get("restore_volume", i, i)) restore_volume = i;
if (spref.get("restore_mic_gain", i, i)) restore_mic_gain = i;
if (spref.get("restore_rf_gain", i, i)) restore_rf_gain = i;
if (spref.get("restore_power_control", i, i)) restore_power_control = i;
if (spref.get("restore_if_shift", i, i)) restore_if_shift = i;
if (spref.get("restore_notch", i, i)) restore_notch = i;
if (spref.get("restore_auto_notch", i, i)) restore_auto_notch = i;
if (spref.get("restore_noise", i, i)) restore_noise = i;
if (spref.get("restore_squelch", i, i)) restore_squelch = i;
if (spref.get("restore_split", i, i)) restore_split = i;
if (spref.get("restore_pre_att", i, i)) restore_pre_att = i;
if (spref.get("restore_nr", i, i)) restore_nr = i;
if (spref.get("restore_comp_on_off", i, i)) restore_comp_on_off = i;
if (spref.get("restore_comp_level", i, i)) restore_comp_level = i;
if (spref.get("bool_spkr_on", i, i)) spkr_on = i;
spref.get("int_volume", volume, volume);
spref.get("dbl_power", power_level, power_level);
spref.get("power_limit", power_limit, power_limit);
if (spref.get("enable_power_limit", i, i)) enable_power_limit = i;
spref.get("int_mic", mic_gain, mic_gain);
if (spref.get("bool_notch", i, i)) notch = i;
spref.get("int_notch", notch_val, notch_val);
if (spref.get("bool_shift", i, i)) shift = i;
spref.get("int_shift", shift_val, shift_val);
if (spref.get("pbt_lock", i, pbt_lock)) pbt_lock = i;
if (spref.get("pbt_inner", i, pbt_inner)) pbt_inner = i;
if (spref.get("pbt_outer", i, pbt_outer)) pbt_outer = i;
spref.get("rfgain", rfgain, rfgain);
spref.get("squelch", squelch, squelch);
spref.get("no_txqsy", no_txqsy, no_txqsy);
spref.get("schema", schema, schema);
spref.get("embed_tabs", embed_tabs, embed_tabs);
spref.get("show_tabs", show_tabs, show_tabs);
spref.get("visible_tab", defbuffer, visible_tab.c_str(), MAX_DEFBUFFER_SIZE);
visible_tab = defbuffer;
spref.get("rx_avg", rx_avg, rx_avg);
spref.get("rx_peak", rx_peak, rx_peak);
spref.get("pwr_avg", pwr_avg, pwr_avg);
spref.get("pwr_peak", pwr_peak, pwr_peak);
spref.get("pwr_scale", pwr_scale, pwr_scale);
if (spref.get("sync_clock", i, sync_clock)) sync_clock = i;
if (spref.get("sync_gmt", i, sync_gmt)) sync_gmt = i;
if (spref.get("digi_sel_on_off", i, i)) digi_sel_on_off = i;
spref.get("digi_sel_val", digi_sel_val, digi_sel_val);
if (spref.get("dual_watch", i, i)) dual_watch = i;
spref.get("ic7610att", index_ic7610att, index_ic7610att);
if (spref.get("ft950_rg_reverse", i, i)) ft950_rg_reverse = i;
if (selrig->name_ == rig_TT550.name_) {
spref.get("tt550_line_out", tt550_line_out, tt550_line_out);
spref.get("tt550_agc_level", tt550_agc_level, tt550_agc_level);
spref.get("tt550_cw_wpm", tt550_cw_wpm, tt550_cw_wpm);
spref.get("tt550_cw_weight", tt550_cw_weight, tt550_cw_weight);
spref.get("tt550_cw_vol", tt550_cw_vol, tt550_cw_vol);
spref.get("tt550_cw_spot", tt550_cw_spot, tt550_cw_spot);
if (spref.get("tt550_spot_onoff", i, i)) tt550_spot_onoff = i;
spref.get("tt550_cw_qsk", tt550_cw_qsk, tt550_cw_qsk);
if (spref.get("tt550_enable_keyer", i, i)) tt550_enable_keyer = i;
if (spref.get("break_in", i, i)) break_in = i;
if (spref.get("vox_onoff", i, i)) vox_onoff = i;
if (spref.get("tt550_vox_onoff", i, i)) tt550_vox_onoff = i;
spref.get("tt550_vox_gain", tt550_vox_gain, tt550_vox_gain);
spref.get("tt550_vox_anti", tt550_vox_anti, tt550_vox_anti);
spref.get("tt550_vox_hang", tt550_vox_hang, tt550_vox_hang);
spref.get("tt550_mon_vol", tt550_mon_vol, tt550_mon_vol);
spref.get("tt550_squelch_level", tt550_squelch_level, tt550_squelch_level);
spref.get("tt550_compression", tt550_compression, tt550_compression);
spref.get("tt550_nb_level", tt550_nb_level, tt550_nb_level);
if (spref.get("tt550_compON", i, i)) tt550_compON = i;
if (spref.get("tt550_tuner_bypass", i, i)) tt550_tuner_bypass = i;
if (spref.get("tt550_enable_xmtr", i, i)) tt550_enable_xmtr = i;
if (spref.get("tt550_enable_tloop", i, i)) tt550_enable_tloop = i;
spref.get("tt550_xmt_bw", tt550_xmt_bw, tt550_xmt_bw);
if (spref.get("tt550_use_xmt_bw", i, i)) tt550_use_xmt_bw = i;
if (spref.get("tt550_use_line_in", i, i)) tt550_use_line_in = i;
spref.get("tt550_AM_level", tt550_AM_level, tt550_AM_level);
spref.get("tt550_encoder_step", tt550_encoder_step, tt550_encoder_step);
spref.get("tt550_encoder_sensitivity", tt550_encoder_sensitivity, tt550_encoder_sensitivity);
spref.get("tt550_keypad_timeout", tt550_keypad_timeout, tt550_keypad_timeout);
spref.get("tt550_F1_func", tt550_F1_func, tt550_F1_func);
spref.get("tt550_F2_func", tt550_F2_func, tt550_F2_func);
spref.get("tt550_F3_func", tt550_F3_func, tt550_F3_func);
spref.get("tt550_Nsamples", tt550_Nsamples, tt550_Nsamples);
spref.get("tt550_at11_inline", i, tt550_at11_inline); tt550_at11_inline = i;
spref.get("tt550_at11_hiZ", i, tt550_at11_hiZ); tt550_at11_hiZ = i;
}
else {
spref.get("line_out", line_out, line_out);
spref.get("data_port", i, data_port); data_port = i;
spref.get("vox_on_dataport", i, vox_on_dataport); vox_on_dataport = i;
spref.get("agc_level", agc_level, agc_level);
spref.get("cw_wpm", cw_wpm, cw_wpm);
spref.get("cw_weight", cw_weight, cw_weight);
spref.get("cw_vol", cw_vol, cw_vol);
spref.get("cw_spot", cw_spot, cw_spot);
if (spref.get("spot_onoff", i, i)) spot_onoff = i;
spref.get("cw_spot_tone", cw_spot_tone, cw_spot_tone);
spref.get("cw_qsk", cw_qsk, cw_qsk);
spref.get("(cw_delay", cw_delay, cw_delay);
if (spref.get("enable_keyer", i, i)) enable_keyer = i;
if (spref.get("break_in", break_in, break_in));
if (spref.get("vox_onoff", i, i)) vox_onoff = i;
spref.get("vox_gain", vox_gain, vox_gain);
spref.get("vox_anti", vox_anti, vox_anti);
spref.get("vox_hang", vox_hang, vox_hang);
spref.get("compression", compression, compression);
if (spref.get("compON", i, i)) compON = i;
}
if (spref.get("noise_reduction", i, i)) noise_reduction = i;
spref.get("noise_red_val", noise_reduction_val, noise_reduction_val);
if (spref.get("bool_noise", i, i)) noise = i;
spref.get("nb_level", nb_level, nb_level);
spref.get("int_preamp", preamp, preamp);
spref.get("int_att", attenuator, attenuator);
spref.get("compression", compression, compression);
if (spref.get("compON", i, i)) compON = i;
spref.get("vfo_adj", vfo_adj, vfo_adj);
spref.get("bfo_freq", bfo_freq, bfo_freq);
spref.get("rit_freq", rit_freq, rit_freq);
spref.get("xit_freq", xit_freq, xit_freq);
spref.get("bpf_center", bpf_center, bpf_center);
spref.get("use_bpf_center", i, i); use_bpf_center = i;
if (spref.get("use706filters", i, i)) use706filters = i;
spref.get("ssb_cw_wide", defbuffer, ssb_cw_wide.c_str(), MAX_DEFBUFFER_SIZE);
ssb_cw_wide = defbuffer;
spref.get("ssb_cw_normal", defbuffer, ssb_cw_normal.c_str(), MAX_DEFBUFFER_SIZE);
ssb_cw_normal = defbuffer;
spref.get("ssb_cw_narrow", defbuffer, ssb_cw_narrow.c_str(), MAX_DEFBUFFER_SIZE);
ssb_cw_narrow = defbuffer;
spref.get("label1", defbuffer, label1.c_str(), MAX_DEFBUFFER_SIZE);
label1 = defbuffer;
spref.get("command1", defbuffer, command1.c_str(), MAX_DEFBUFFER_SIZE);
command1 = defbuffer;
spref.get("shftcmd1", defbuffer, shftcmd1.c_str(), MAX_DEFBUFFER_SIZE);
shftcmd1 = defbuffer;
spref.get("label2", defbuffer, label2.c_str(), MAX_DEFBUFFER_SIZE);
label2 = defbuffer;
spref.get("command2", defbuffer, command2.c_str(), MAX_DEFBUFFER_SIZE);
command2 = defbuffer;
spref.get("shftcmd2", defbuffer, shftcmd2.c_str(), MAX_DEFBUFFER_SIZE);
shftcmd2 = defbuffer;
spref.get("label3", defbuffer, label3.c_str(), MAX_DEFBUFFER_SIZE);
label3 = defbuffer;
spref.get("command3", defbuffer, command3.c_str(), MAX_DEFBUFFER_SIZE);
command3 = defbuffer;
spref.get("shftcmd3", defbuffer, shftcmd3.c_str(), MAX_DEFBUFFER_SIZE);
shftcmd3 = defbuffer;
spref.get("label4", defbuffer, label4.c_str(), MAX_DEFBUFFER_SIZE);
label4 = defbuffer;
spref.get("command4", defbuffer, command4.c_str(), MAX_DEFBUFFER_SIZE);
command4 = defbuffer;
spref.get("shftcmd4", defbuffer, shftcmd4.c_str(), MAX_DEFBUFFER_SIZE);
shftcmd4 = defbuffer;
spref.get("label5", defbuffer, label5.c_str(), MAX_DEFBUFFER_SIZE);
label5 = defbuffer;
spref.get("command5", defbuffer, command5.c_str(), MAX_DEFBUFFER_SIZE);
command5 = defbuffer;
spref.get("shftcmd5", defbuffer, shftcmd5.c_str(), MAX_DEFBUFFER_SIZE);
shftcmd5 = defbuffer;
spref.get("label6", defbuffer, label6.c_str(), MAX_DEFBUFFER_SIZE);
label6 = defbuffer;
spref.get("command6", defbuffer, command6.c_str(), MAX_DEFBUFFER_SIZE);
command6 = defbuffer;
spref.get("shftcmd6", defbuffer, shftcmd6.c_str(), MAX_DEFBUFFER_SIZE);
shftcmd6 = defbuffer;
spref.get("label7", defbuffer, label7.c_str(), MAX_DEFBUFFER_SIZE);
label7 = defbuffer;
spref.get("command7", defbuffer, command7.c_str(), MAX_DEFBUFFER_SIZE);
command7 = defbuffer;
spref.get("shftcmd7", defbuffer, shftcmd7.c_str(), MAX_DEFBUFFER_SIZE);
shftcmd7 = defbuffer;
spref.get("label8", defbuffer, label8.c_str(), MAX_DEFBUFFER_SIZE);
label8 = defbuffer;
spref.get("command8", defbuffer, command8.c_str(), MAX_DEFBUFFER_SIZE);
command8 = defbuffer;
spref.get("shftcmd8", defbuffer, shftcmd8.c_str(), MAX_DEFBUFFER_SIZE);
shftcmd8 = defbuffer;
spref.get("label9", defbuffer, label9.c_str(), MAX_DEFBUFFER_SIZE);
label9 = defbuffer;
spref.get("command9", defbuffer, command9.c_str(), MAX_DEFBUFFER_SIZE);
command9 = defbuffer;
spref.get("shftcmd9", defbuffer, shftcmd9.c_str(), MAX_DEFBUFFER_SIZE);
shftcmd9 = defbuffer;
spref.get("label10", defbuffer, label10.c_str(), MAX_DEFBUFFER_SIZE);
label10 = defbuffer;
spref.get("command10", defbuffer, command10.c_str(), MAX_DEFBUFFER_SIZE);
command10 = defbuffer;
spref.get("shftcmd10", defbuffer, shftcmd10.c_str(), MAX_DEFBUFFER_SIZE);
shftcmd10 = defbuffer;
spref.get("label11", defbuffer, label11.c_str(), MAX_DEFBUFFER_SIZE);
label11 = defbuffer;
spref.get("command11", defbuffer, command11.c_str(), MAX_DEFBUFFER_SIZE);
command11 = defbuffer;
spref.get("shftcmd11", defbuffer, shftcmd11.c_str(), MAX_DEFBUFFER_SIZE);
shftcmd11 = defbuffer;
spref.get("label12", defbuffer, label12.c_str(), MAX_DEFBUFFER_SIZE);
label12 = defbuffer;
spref.get("command12", defbuffer, command12.c_str(), MAX_DEFBUFFER_SIZE);
command12 = defbuffer;
spref.get("shftcmd12", defbuffer, shftcmd12.c_str(), MAX_DEFBUFFER_SIZE);
shftcmd12 = defbuffer;
spref.get("label13", defbuffer, label13.c_str(), MAX_DEFBUFFER_SIZE);
label13 = defbuffer;
spref.get("command13", defbuffer, command13.c_str(), MAX_DEFBUFFER_SIZE);
command13 = defbuffer;
spref.get("shftcmd13", defbuffer, shftcmd13.c_str(), MAX_DEFBUFFER_SIZE);
shftcmd13 = defbuffer;
spref.get("label14", defbuffer, label14.c_str(), MAX_DEFBUFFER_SIZE);
label14 = defbuffer;
spref.get("command14", defbuffer, command14.c_str(), MAX_DEFBUFFER_SIZE);
command14 = defbuffer;
spref.get("shftcmd14", defbuffer, shftcmd14.c_str(), MAX_DEFBUFFER_SIZE);
shftcmd14 = defbuffer;
spref.get("label15", defbuffer, label15.c_str(), MAX_DEFBUFFER_SIZE);
label15 = defbuffer;
spref.get("command15", defbuffer, command15.c_str(), MAX_DEFBUFFER_SIZE);
command15 = defbuffer;
spref.get("shftcmd15", defbuffer, shftcmd15.c_str(), MAX_DEFBUFFER_SIZE);
shftcmd15 = defbuffer;
spref.get("label16", defbuffer, label16.c_str(), MAX_DEFBUFFER_SIZE);
label16 = defbuffer;
spref.get("command16", defbuffer, command16.c_str(), MAX_DEFBUFFER_SIZE);
command16 = defbuffer;
spref.get("shftcmd16", defbuffer, shftcmd16.c_str(), MAX_DEFBUFFER_SIZE);
shftcmd16 = defbuffer;
spref.get("label17", defbuffer, label17.c_str(), MAX_DEFBUFFER_SIZE);
label17 = defbuffer;
spref.get("command17", defbuffer, command17.c_str(), MAX_DEFBUFFER_SIZE);
command17 = defbuffer;
spref.get("shftcmd17", defbuffer, shftcmd17.c_str(), MAX_DEFBUFFER_SIZE);
shftcmd17 = defbuffer;
spref.get("label18", defbuffer, label18.c_str(), MAX_DEFBUFFER_SIZE);
label18 = defbuffer;
spref.get("command18", defbuffer, command18.c_str(), MAX_DEFBUFFER_SIZE);
command18 = defbuffer;
spref.get("shftcmd18", defbuffer, shftcmd18.c_str(), MAX_DEFBUFFER_SIZE);
shftcmd18 = defbuffer;
spref.get("label19", defbuffer, label19.c_str(), MAX_DEFBUFFER_SIZE);
label19 = defbuffer;
spref.get("command19", defbuffer, command19.c_str(), MAX_DEFBUFFER_SIZE);
command19 = defbuffer;
spref.get("shftcmd19", defbuffer, shftcmd11.c_str(), MAX_DEFBUFFER_SIZE);
shftcmd19 = defbuffer;
spref.get("label20", defbuffer, label20.c_str(), MAX_DEFBUFFER_SIZE);
label20 = defbuffer;
spref.get("command20", defbuffer, command20.c_str(), MAX_DEFBUFFER_SIZE);
command20 = defbuffer;
spref.get("shftcmd20", defbuffer, shftcmd20.c_str(), MAX_DEFBUFFER_SIZE);
shftcmd20 = defbuffer;
spref.get("label21", defbuffer, label21.c_str(), MAX_DEFBUFFER_SIZE);
label21 = defbuffer;
spref.get("command21", defbuffer, command21.c_str(), MAX_DEFBUFFER_SIZE);
command21 = defbuffer;
spref.get("shftcmd21", defbuffer, shftcmd21.c_str(), MAX_DEFBUFFER_SIZE);
shftcmd21 = defbuffer;
spref.get("label22", defbuffer, label22.c_str(), MAX_DEFBUFFER_SIZE);
label22 = defbuffer;
spref.get("command22", defbuffer, command22.c_str(), MAX_DEFBUFFER_SIZE);
command22 = defbuffer;
spref.get("shftcmd22", defbuffer, shftcmd22.c_str(), MAX_DEFBUFFER_SIZE);
shftcmd22 = defbuffer;
spref.get("label23", defbuffer, label23.c_str(), MAX_DEFBUFFER_SIZE);
label23 = defbuffer;
spref.get("command23", defbuffer, command23.c_str(), MAX_DEFBUFFER_SIZE);
command23 = defbuffer;
spref.get("shftcmd23", defbuffer, shftcmd23.c_str(), MAX_DEFBUFFER_SIZE);
shftcmd23 = defbuffer;
spref.get("label24", defbuffer, label24.c_str(), MAX_DEFBUFFER_SIZE);
label24 = defbuffer;
spref.get("command24", defbuffer, command24.c_str(), MAX_DEFBUFFER_SIZE);
command24 = defbuffer;
spref.get("shftcmd24", defbuffer, shftcmd24.c_str(), MAX_DEFBUFFER_SIZE);
shftcmd24 = defbuffer;
spref.get("st_label1", defbuffer, label_on_start1.c_str(), MAX_DEFBUFFER_SIZE);
label_on_start1 = defbuffer;
spref.get("st_cmd1", defbuffer, cmd_on_start1.c_str(), MAX_DEFBUFFER_SIZE);
cmd_on_start1 = defbuffer;
spref.get("st_label2", defbuffer, label_on_start2.c_str(), MAX_DEFBUFFER_SIZE);
label_on_start2 = defbuffer;
spref.get("st_cmd2", defbuffer, cmd_on_start2.c_str(), MAX_DEFBUFFER_SIZE);
cmd_on_start2 = defbuffer;
spref.get("st_label3", defbuffer, label_on_start3.c_str(), MAX_DEFBUFFER_SIZE);
label_on_start3 = defbuffer;
spref.get("st_cmd3", defbuffer, cmd_on_start3.c_str(), MAX_DEFBUFFER_SIZE);
cmd_on_start3 = defbuffer;
spref.get("st_label4", defbuffer, label_on_start4.c_str(), MAX_DEFBUFFER_SIZE);
label_on_start4 = defbuffer;
spref.get("st_cmd4", defbuffer, cmd_on_start4.c_str(), MAX_DEFBUFFER_SIZE);
cmd_on_start4 = defbuffer;
spref.get("ex_label1", defbuffer, label_on_exit1.c_str(), MAX_DEFBUFFER_SIZE);
label_on_exit1 = defbuffer;
spref.get("ex_cmd1", defbuffer, cmd_on_exit1.c_str(), MAX_DEFBUFFER_SIZE);
cmd_on_exit1 = defbuffer;
spref.get("ex_label2", defbuffer, label_on_exit2.c_str(), MAX_DEFBUFFER_SIZE);
label_on_exit2 = defbuffer;
spref.get("ex_cmd2", defbuffer, cmd_on_exit2.c_str(), MAX_DEFBUFFER_SIZE);
cmd_on_exit2 = defbuffer;
spref.get("ex_label3", defbuffer, label_on_exit3.c_str(), MAX_DEFBUFFER_SIZE);
label_on_exit3 = defbuffer;
spref.get("ex_cmd3", defbuffer, cmd_on_exit3.c_str(), MAX_DEFBUFFER_SIZE);
cmd_on_exit3 = defbuffer;
spref.get("ex_label4", defbuffer, label_on_exit4.c_str(), MAX_DEFBUFFER_SIZE);
label_on_exit4 = defbuffer;
spref.get("ex_cmd4", defbuffer, cmd_on_exit4.c_str(), MAX_DEFBUFFER_SIZE);
cmd_on_exit4 = defbuffer;
spref.get("fg_red", fg_red, fg_red);
spref.get("fg_green", fg_green, fg_green);
spref.get("fg_blue", fg_blue, fg_blue);
spref.get("bg_red", bg_red, bg_red);
spref.get("bg_green", bg_green, bg_green);
spref.get("bg_blue", bg_blue, bg_blue);
spref.get("smeter_red", smeterRed, smeterRed);
spref.get("smeter_green", smeterGreen, smeterGreen);
spref.get("smeter_blue", smeterBlue, smeterBlue);
spref.get("power_red", pwrRed, pwrRed);
spref.get("power_green", pwrGreen, pwrGreen);
spref.get("power_blue", pwrBlue, pwrBlue);
spref.get("swr_red", swrRed, swrRed);
spref.get("swr_green", swrGreen, swrGreen);
spref.get("swr_blue", swrBlue, swrBlue);
spref.get("peak_red", peakRed, peakRed);
spref.get("peak_green", peakGreen, peakGreen);
spref.get("peak_blue", peakBlue, peakBlue);
spref.get("volt_red", voltRed, voltRed);
spref.get("volt_green", voltGreen, voltGreen);
spref.get("volt_blue", voltBlue, voltBlue);
spref.get("display_voltmeter", display_voltmeter, display_voltmeter);
spref.get("fg_sys_red", fg_sys_red, fg_sys_red);
spref.get("fg_sys_green", fg_sys_green, fg_sys_green);
spref.get("fg_sys_blue", fg_sys_blue, fg_sys_blue);
spref.get("bg_sys_red", bg_sys_red, bg_sys_red);
spref.get("bg_sys_green", bg_sys_green, bg_sys_green);
spref.get("bg_sys_blue", bg_sys_blue, bg_sys_blue);
spref.get("bg2_sys_red", bg2_sys_red, bg2_sys_red);
spref.get("bg2_sys_green", bg2_sys_green, bg2_sys_green);
spref.get("bg2_sys_blue", bg2_sys_blue, bg2_sys_blue);
spref.get("slider_red", slider_red, slider_red);
spref.get("slider_green", slider_green, slider_green);
spref.get("slider_blue", slider_blue, slider_blue);
spref.get("slider_btn_red", slider_btn_red, slider_btn_red);
spref.get("slider_btn_green", slider_btn_green, slider_btn_green);
spref.get("slider_btn_blue", slider_btn_blue, slider_btn_blue);
spref.get("lighted_btn_red", lighted_btn_red, lighted_btn_red);
spref.get("lighted_btn_green", lighted_btn_green, lighted_btn_green);
spref.get("lighted_btn_blue", lighted_btn_blue, lighted_btn_blue);
spref.get("tab_red", tab_red, tab_red);
spref.get("tab_green", tab_green, tab_green);
spref.get("tab_blue", tab_blue, tab_blue);
i = (int)fontnbr;
spref.get("fontnbr", i, i); fontnbr = (Fl_Font)i;
i = 0;
if (spref.get("tooltips", i, i)) tooltips = i;
spref.get("ui_scheme", defbuffer, "gtk+", MAX_DEFBUFFER_SIZE);
ui_scheme = defbuffer;
// spref.get("server_port", defbuffer, "7362", MAX_DEFBUFFER_SIZE);
// server_port = defbuffer;
// spref.get("server_addr", defbuffer, "127.0.0.1", MAX_DEFBUFFER_SIZE);
// server_addr = defbuffer;
spref.get("xmlrig_port", defbuffer, "12345", MAX_DEFBUFFER_SIZE);
xmlrig_port = defbuffer;
spref.get("xmlrig_addr", defbuffer, "127.0.0.1", MAX_DEFBUFFER_SIZE);
xmlrig_addr = defbuffer;
spref.get("tcpip_port", defbuffer, "4001", MAX_DEFBUFFER_SIZE);
tcpip_port = defbuffer;
spref.get("tcpip_addr", defbuffer, "127.0.0.1", MAX_DEFBUFFER_SIZE);
tcpip_addr = defbuffer;
spref.get("tcpip_ping_delay", tcpip_ping_delay, tcpip_ping_delay);
spref.get("tcpip_tcpip_reconnect_after", tcpip_reconnect_after, tcpip_reconnect_after);
spref.get("tcpip_drops_allowed", tcpip_drops_allowed, tcpip_drops_allowed);
if (spref.get("use_tcpip", i, i)) use_tcpip = i;
spref.get("tci_port", defbuffer, "40001", MAX_DEFBUFFER_SIZE);
tci_port = defbuffer;
spref.get("tci_addr", defbuffer, "127.0.0.1", MAX_DEFBUFFER_SIZE);
tci_addr = defbuffer;
spref.get("tci_center", tci_center, tci_center);
if (spref.get("xcvr_auto_on", i, i)) xcvr_auto_on = i;
if (spref.get("xcvr_auto_off", i, i)) xcvr_auto_off = i;
if (spref.get("external_tuner", i,i)) external_tuner = i;
if (spref.get("trace", i, trace)) trace = i;
if (spref.get("rigtrace", i, rigtrace)) rigtrace = i;
if (spref.get("gettrace", i, gettrace)) gettrace = i;
if (spref.get("settrace", i, settrace)) settrace = i;
if (spref.get("debugtrace", i, debugtrace)) debugtrace = i;
if (spref.get("xmltrace", i, xmltrace)) xmltrace = i;
if (spref.get("serialtrace", i, serialtrace)) serialtrace = i;
if (spref.get("startstoptrace", i, start_stop_trace)) start_stop_trace = i;
if (spref.get("rpctrace", i, rpctrace)) rpctrace = i;
if (spref.get("tcitrace", i, tcitrace)) tcitrace = i;
#ifndef NDEBUG
trace = true;
rigtrace = true;
settrace = true;
debugtrace = true;
xmltrace = true;
rpctrace = true;
serialtrace = true;
gettrace = true;
tcitrace = true;
#endif
spref.get("rpc_level", rpc_level, rpc_level);
spref.get("f160", f160, f160); spref.get("m160", m160, m160);
spref.get("txT160", txT_160, txT_160); spref.get("rxT160", rxT_160, rxT_160);
spref.get("offset_160", offset_160, offset_160); spref.get("oF_160", oF_160, oF_160);
spref.get("f80", f80, f80); spref.get("m80", m80, m80);
spref.get("txT80", txT_80, txT_80); spref.get("rxT80", rxT_80, rxT_80);
spref.get("offset_80", offset_80, offset_80); spref.get("oF_80", oF_80, oF_80);
spref.get("f40", f40, f40); spref.get("m40", m40, m40);
spref.get("txT40", txT_40, txT_40); spref.get("rxT40", rxT_40, rxT_40);
spref.get("offset_40", offset_40, offset_40); spref.get("oF_40", oF_40, oF_40);
spref.get("f30", f30, f30); spref.get("m30", m30, m30);
spref.get("txT30", txT_30, txT_30); spref.get("rxT30", rxT_30, rxT_30);
spref.get("offset_30", offset_30, offset_30); spref.get("oF_30", oF_30, oF_30);
spref.get("f20", f20, f20); spref.get("m20", m20, m20);
spref.get("txT20", txT_20, txT_20); spref.get("rxT20", rxT_20, rxT_20);
spref.get("offset_20", offset_20, offset_20); spref.get("oF_20", oF_20, oF_20);
spref.get("f17", f17, f17); spref.get("m17", m17, m17);
spref.get("txT17", txT_17, txT_17); spref.get("rxT17", rxT_17, rxT_17);
spref.get("offset_17", offset_17, offset_17); spref.get("oF_17", oF_17, oF_17);
spref.get("f15", f15, f15); spref.get("m15", m15, m15);
spref.get("txT15", txT_15, txT_15); spref.get("rxT15", rxT_15, rxT_15);
spref.get("offset_15", offset_15, offset_15); spref.get("oF_15", oF_15, oF_15);
spref.get("f12", f12, f12); spref.get("m12", m12, m12);
spref.get("txT12", txT_12, txT_12); spref.get("rxT12", rxT_12, rxT_12);
spref.get("offset_12", offset_12, offset_12); spref.get("oF_12", oF_12, oF_12);
spref.get("f10", f10, f10); spref.get("m10", m10, m10);
spref.get("txT10", txT_10, txT_10); spref.get("rxT10", rxT_10, rxT_10);
spref.get("offset_10", offset_10, offset_10); spref.get("oF_10", oF_10, oF_10);
spref.get("f6", f6, f6); spref.get("m6", m6, m6);
spref.get("txT6", txT_6, txT_6); spref.get("rxT6", rxT_6, rxT_6);
spref.get("offset_6", offset_6, offset_6); spref.get("oF_6", oF_6, oF_6);
spref.get("f2", f2, f2); spref.get("m2", m2, m2);
spref.get("txT2", txT_2, txT_2); spref.get("rxT2", rxT_2, rxT_2);
spref.get("offset_2", offset_2, offset_2); spref.get("oF_2", oF_2, oF_2);
spref.get("f70", f70, f70); spref.get("m70", m70, m70);
spref.get("txT70", txT_70, txT_70); spref.get("rxT70", rxT_70, rxT_70);
spref.get("offset_70", offset_70, offset_70); spref.get("oF_70", oF_70, oF_70);
spref.get("f12G", f12G, f12G); spref.get("m12G", m12G, m12G);
spref.get("txT12G", txT_12G, txT_12G); spref.get("rxT12G", rxT_12G, rxT_12G);
spref.get("offset_12G", offset_12G, offset_12G); spref.get("oF_12G", oF_12G, oF_12G);
spref.get("fgen", fgen, fgen); spref.get("mgen", mgen, mgen);
spref.get("txTgen", txT_gen, txT_gen); spref.get("rxTgen", rxT_gen, rxT_gen);
spref.get("offset_gen", offset_gen, offset_gen); spref.get("oF_gen", oF_gen, oF_gen);
if (spref.get("hrd_buttons", i, i)) hrd_buttons = i;
spref.get("sliders_button", sliders_button, sliders_button);
spref.get("memfontnbr", memfontnbr, memfontnbr);
spref.get("memfontsize", memfontsize, memfontsize);
if (spref.get("gpio_ptt", i, i)) gpio_ptt = i;
spref.get("enable_gpio", enable_gpio, enable_gpio);
spref.get("gpio_on", gpio_on, gpio_on);
spref.get("gpio_pulse_width", gpio_pulse_width, gpio_pulse_width);
// spref.get("kxpa", kxpa, kxpa);
spref.get("cwioWPM", cwioWPM, cwioWPM);
spref.get("cwio_comp", cwio_comp, cwio_comp);
spref.get("cwio_keycorr", cwio_keycorr, cwio_keycorr);
spref.get("cwioKEYLINE", cwioKEYLINE, cwioKEYLINE);
spref.get("cwioSHARED", cwioSHARED, cwioSHARED);
spref.get("cwioPTT", cwioPTT, cwioPTT);
spref.get("cwioCONNECTED", cwioCONNECTED, cwioCONNECTED);
spref.get("cwioINVERTED", cwioINVERTED, cwioINVERTED);
spref.get("cwioPORT", defbuffer, "NONE", MAX_DEFBUFFER_SIZE);
cwioPORT = defbuffer;
char getbuff[20];
for (int n = 0; n < 12; n++) {
snprintf(getbuff, sizeof(getbuff), "cwiolabel[%d]", n);
spref.get(getbuff, defbuffer, "", MAX_DEFBUFFER_SIZE);
cwio_labels[n] = defbuffer;
snprintf(getbuff, sizeof(getbuff), "cwiomessage[%d]", n);
spref.get(getbuff, defbuffer, "", MAX_DEFBUFFER_SIZE);
cwio_msgs[n] = defbuffer;
}
spref.get("BT", defbuffer, BT.c_str(), MAX_DEFBUFFER_SIZE);
BT = defbuffer;
spref.get("AA", defbuffer, AA.c_str(), MAX_DEFBUFFER_SIZE);
AA = defbuffer;
spref.get("AS", defbuffer, AS.c_str(), MAX_DEFBUFFER_SIZE);
AS = defbuffer;
spref.get("AR", defbuffer, AR.c_str(), MAX_DEFBUFFER_SIZE);
AR = defbuffer;
spref.get("KN", defbuffer, KN.c_str(), MAX_DEFBUFFER_SIZE);
KN = defbuffer;
spref.get("SK", defbuffer, SK.c_str(), MAX_DEFBUFFER_SIZE);
SK = defbuffer;
spref.get("INT", defbuffer, INT.c_str(), MAX_DEFBUFFER_SIZE);
INT = defbuffer;
spref.get("HM", defbuffer, HM.c_str(), MAX_DEFBUFFER_SIZE);
HM = defbuffer;
spref.get("VE", defbuffer, VE.c_str(), MAX_DEFBUFFER_SIZE);
VE = defbuffer;
spref.get("FSK_KEYLINE", FSK_KEYLINE, FSK_KEYLINE);
spref.get("FSK_SHARED", FSK_SHARED, FSK_SHARED);
spref.get("FSK_PTT", FSK_PTT, FSK_PTT);
spref.get("FSK_CONNECTED", FSK_CONNECTED, FSK_CONNECTED);
spref.get("FSK_INVERTED", FSK_INVERTED, FSK_INVERTED);
spref.get("FSK_STOPBITS", FSK_STOPBITS, FSK_STOPBITS);
spref.get("FSK_IDLES", fsk_idles, fsk_idles);
spref.get("FSK_PORT", defbuffer, "NONE", MAX_DEFBUFFER_SIZE);
FSK_PORT = defbuffer;
// CW logbook parameters
spref.get("CW_LOG_NAME", defbuffer, "", MAX_DEFBUFFER_SIZE);
cw_log_name = defbuffer;
spref.get("CW_CUT_NUMBERS", cw_log_cut_numbers, cw_log_cut_numbers);
spref.get("CW_LEADING_ZEROS", cw_log_leading_zeros, cw_log_leading_zeros);
spref.get("CW_DUPCHECK", cw_log_dupcheck, cw_log_dupcheck);
spref.get("CW_LOG_NBR", cw_log_nbr, cw_log_nbr);
// FSK logbook parameters
spref.get("FSK_LOG_NAME", defbuffer, "", MAX_DEFBUFFER_SIZE);
fsk_log_name = defbuffer;
spref.get("FSK_CUT_NUMBERS",fsk_log_cut_numbers, fsk_log_cut_numbers);
spref.get("FSK_LEADING_ZEROS", fsk_log_leading_zeros, fsk_log_leading_zeros);
spref.get("FSK_DUPCHECK", fsk_log_dupcheck, fsk_log_dupcheck);
spref.get("FSK_LOG_NBR", fsk_log_nbr, fsk_log_nbr);
for (int n = 0; n < 12; n++) {
snprintf(getbuff, sizeof(getbuff), "fskiolabel[%d]", n);
spref.get(getbuff, defbuffer, "", MAX_DEFBUFFER_SIZE);
FSK_labels[n] = defbuffer;
snprintf(getbuff, sizeof(getbuff), "fskiomessage[%d]", n);
spref.get(getbuff, defbuffer, "", MAX_DEFBUFFER_SIZE);
FSK_msgs[n] = defbuffer;
}
return true;
}
return false;
}
void status::loadLastState()
{
Fl_Preferences xcvrpref(RigHomeDir.c_str(), "w1hkj.com", PACKAGE_TARNAME);
if (xcvrpref.entryExists("xcvr_name")) {
char defbuffer[MAX_DEFBUFFER_SIZE];
xcvrpref.get("xcvr_name", defbuffer, "NONE", MAX_DEFBUFFER_SIZE);
xcvr_name = defbuffer;
// for backward compatability
} else if (xcvrpref.entryExists("last_xcvr_used")) {
char defbuffer[MAX_DEFBUFFER_SIZE];
xcvrpref.get("last_xcvr_used", defbuffer, "NONE", MAX_DEFBUFFER_SIZE);
xcvr_name = defbuffer;
}
// xcvrpref.get("xml_port", xmlport, xmlport);
loadXcvrState(xcvr_name);
}
void status::UI_laststate()
{
Fl_Color bgclr = fl_rgb_color(bg_red, bg_green, bg_blue);
Fl_Color fgclr = fl_rgb_color(fg_red, fg_green, fg_blue);
Fl::background( bg_sys_red, bg_sys_green, bg_sys_blue);
Fl::background2( bg2_sys_red, bg2_sys_green, bg2_sys_blue);
Fl::foreground( fg_sys_red, fg_sys_green, fg_sys_blue);
FreqDispA->SetCOLORS( fgclr, bgclr );
FreqDispA->font(fontnbr);
FreqDispB->SetCOLORS( fgclr, fl_color_average(bgclr, FL_BLACK, 0.87));
FreqDispB->font(fontnbr);
scaleSmeter->color(bgclr);
scaleSmeter->labelcolor(fgclr);
scalePower->color(bgclr);
scalePower->labelcolor(fgclr);
btnALC_IDD_SWR->color(bgclr);
btnALC_IDD_SWR->labelcolor(fgclr);
sldrFwdPwr->color(fl_rgb_color (pwrRed, pwrGreen, pwrBlue), bgclr);
sldrFwdPwr->PeakColor(fl_rgb_color(peakRed, peakGreen, peakBlue));
sldrRcvSignal->color(fl_rgb_color (smeterRed, smeterGreen, smeterBlue), bgclr);
sldrRcvSignal->PeakColor(fl_rgb_color(peakRed, peakGreen, peakBlue));
sldrALC->color(fl_rgb_color (swrRed, swrGreen, swrBlue), bgclr);
sldrALC->PeakColor(fl_rgb_color(peakRed, peakGreen, peakBlue));
sldrSWR->color(fl_rgb_color (swrRed, swrGreen, swrBlue), bgclr);
sldrSWR->PeakColor(fl_rgb_color(peakRed, peakGreen, peakBlue));
sldrIDD->color(fl_rgb_color (swrRed, swrGreen, swrBlue), bgclr);
sldrIDD->PeakColor(fl_rgb_color (peakRed, peakGreen, peakBlue));
sldrVoltage->color(fl_rgb_color (voltRed, voltGreen, voltBlue), bgclr);
sldrVoltage->PeakColor(bgclr);
scaleVoltage->color(bgclr);
scaleVoltage->labelcolor(fgclr);
mtr_SMETER->color(bgclr);
mtr_SMETER->labelcolor(fgclr);
sigbar_SMETER->color(fl_rgb_color (smeterRed, smeterGreen, smeterBlue), bgclr);
sigbar_SMETER->PeakColor(fl_rgb_color(peakRed, peakGreen, peakBlue));
mtr_PWR->color(bgclr);
mtr_PWR->labelcolor(fgclr);
sigbar_PWR->color(fl_rgb_color (pwrRed, pwrGreen, pwrBlue), bgclr);
sigbar_PWR->PeakColor(fl_rgb_color(peakRed, peakGreen, peakBlue));
mtr_SWR->color(bgclr);
mtr_SWR->labelcolor(fgclr);
sigbar_SWR->color(fl_rgb_color (swrRed, swrGreen, swrBlue), bgclr);
sigbar_SWR->PeakColor(fl_rgb_color(peakRed, peakGreen, peakBlue));
mtr_ALC->color(bgclr);
mtr_ALC->labelcolor(fgclr);
sigbar_ALC->color(fl_rgb_color (swrRed, swrGreen, swrBlue), bgclr);
sigbar_ALC->PeakColor(fl_rgb_color(peakRed, peakGreen, peakBlue));
mtr_VOLTS->color(bgclr);
mtr_VOLTS->labelcolor(fgclr);
sigbar_VOLTS->color(fl_rgb_color (voltRed, voltGreen, voltBlue), bgclr);
sigbar_VOLTS->PeakColor(bgclr);
// set scale for both voltage display
sldrVoltage->minimum (6); sldrVoltage->maximum (16);
sigbar_VOLTS->minimum (6); sigbar_VOLTS->maximum (16);
if (UIsize != small_ui)
meter_fill_box->color(bgclr);
grpMeters->color(bgclr);
grpMeters->labelcolor(fgclr);
Fl_Color btn_lt_color = fl_rgb_color(lighted_btn_red, lighted_btn_green, lighted_btn_blue);
if (btnVol) btnVol->selection_color(btn_lt_color);
if (btnNR) btnNR->selection_color(btn_lt_color);
if (btnIFsh) btnIFsh->selection_color(btn_lt_color);
if (btnNotch) btnNotch->selection_color(btn_lt_color);
if (btnA) btnA->selection_color(btn_lt_color);
if (btnB) btnB->selection_color(btn_lt_color);
if (btnSplit) btnSplit->selection_color(btn_lt_color);
if (btnAttenuator) btnAttenuator->selection_color(btn_lt_color);
if (btnPreamp) btnPreamp->selection_color(btn_lt_color);
if (btnNOISE) btnNOISE->selection_color(btn_lt_color);
if (btnAutoNotch) btnAutoNotch->selection_color(btn_lt_color);
if (btnTune) btnTune->selection_color(btn_lt_color);
if (btn_tune_on_off) btn_tune_on_off->selection_color(btn_lt_color);
if (btnPTT) btnPTT->selection_color(btn_lt_color);
if (btnLOCK) btnLOCK->selection_color(btn_lt_color);
if (btnAuxRTS) btnAuxRTS->selection_color(btn_lt_color);
if (btnAuxDTR) btnAuxDTR->selection_color(btn_lt_color);
if (btnSpot) btnSpot->selection_color(btn_lt_color);
if (btn_vox) btn_vox->selection_color(btn_lt_color);
if (btnCompON) btnCompON->selection_color(btn_lt_color);
if (btnSpecial) btnSpecial->selection_color(btn_lt_color);
if (btn_tt550_vox) btn_tt550_vox->selection_color(btn_lt_color);
if (btn_tt550_CompON) btn_tt550_CompON->selection_color(btn_lt_color);
if (btnAGC) btnAGC->selection_color(btn_lt_color);
if (btnPOWER) btnPOWER->selection_color(btn_lt_color);
Fl_Color bg_slider = fl_rgb_color(slider_red, slider_green, slider_blue);
Fl_Color btn_slider = fl_rgb_color(slider_btn_red, slider_btn_green, slider_btn_blue);
if (sldrVOLUME) sldrVOLUME->color(bg_slider);
if (sldrVOLUME) sldrVOLUME->selection_color(btn_slider);
if (sldrRFGAIN) sldrRFGAIN->color(bg_slider);
if (sldrRFGAIN) sldrRFGAIN->selection_color(btn_slider);
if (sldrSQUELCH) sldrSQUELCH->color(bg_slider);
if (sldrSQUELCH) sldrSQUELCH->selection_color(btn_slider);
if (sldrNR) sldrNR->color(bg_slider);
if (sldrNR) sldrNR->selection_color(btn_slider);
if (sldrIFSHIFT) sldrIFSHIFT->color(bg_slider);
if (sldrIFSHIFT) sldrIFSHIFT->selection_color(btn_slider);
if (sldrINNER) sldrINNER->color(bg_slider);
if (sldrINNER) sldrINNER->selection_color(btn_slider);
if (sldrOUTER) sldrOUTER->color(bg_slider);
if (sldrOUTER) sldrOUTER->selection_color(btn_slider);
if (sldrNOTCH) sldrNOTCH->color(bg_slider);
if (sldrNOTCH) sldrNOTCH->selection_color(btn_slider);
if (sldrMICGAIN) sldrMICGAIN->color(bg_slider);
if (sldrMICGAIN) sldrMICGAIN->selection_color(btn_slider);
if (sldrPOWER) sldrPOWER->color(bg_slider);
if (sldrPOWER) sldrPOWER->selection_color(btn_slider);
if (ic7610_digi_sel_val) {
ic7610_digi_sel_val->color(bg_slider);
ic7610_digi_sel_val->selection_color(btn_slider);
}
if (sldr_nb_level) {
sldr_nb_level->color(bg_slider);
sldr_nb_level->selection_color(btn_slider);
}
if (spnrPOWER) spnrPOWER->color(bg_slider);
if (spnrPOWER) spnrPOWER->selection_color(btn_slider);
if (spnrVOLUME) spnrVOLUME->color(bg_slider);
if (spnrVOLUME) spnrVOLUME->selection_color(btn_slider);
if (spnrRFGAIN) spnrRFGAIN->color(bg_slider);
if (spnrRFGAIN) spnrRFGAIN->selection_color(btn_slider);
if (spnrSQUELCH) spnrSQUELCH->color(bg_slider);
if (spnrSQUELCH) spnrSQUELCH->selection_color(btn_slider);
if (spnrNR) spnrNR->color(bg_slider);
if (spnrNR) spnrNR->selection_color(btn_slider);
if (spnrIFSHIFT) spnrIFSHIFT->color(bg_slider);
if (spnrIFSHIFT) spnrIFSHIFT->selection_color(btn_slider);
if (spnrNOTCH) spnrNOTCH->color(bg_slider);
if (spnrNOTCH) spnrNOTCH->selection_color(btn_slider);
if (spnrMICGAIN) spnrMICGAIN->color(bg_slider);
if (spnrMICGAIN) spnrMICGAIN->selection_color(btn_slider);
btnUser1->label(label1.c_str()); btnUser1->redraw_label();
btnUser2->label(label2.c_str()); btnUser2->redraw_label();
btnUser3->label(label3.c_str()); btnUser3->redraw_label();
btnUser4->label(label4.c_str()); btnUser4->redraw_label();
btnUser5->label(label5.c_str()); btnUser5->redraw_label();
btnUser6->label(label6.c_str()); btnUser6->redraw_label();
btnUser7->label(label7.c_str()); btnUser7->redraw_label();
btnUser8->label(label8.c_str()); btnUser8->redraw_label();
btnUser9->label(label9.c_str()); btnUser9->redraw_label();
btnUser10->label(label10.c_str()); btnUser10->redraw_label();
btnUser11->label(label11.c_str()); btnUser11->redraw_label();
btnUser12->label(label12.c_str()); btnUser12->redraw_label();
btnUser13->label(label13.c_str()); btnUser13->redraw_label();
btnUser14->label(label14.c_str()); btnUser14->redraw_label();
btnUser15->label(label15.c_str()); btnUser15->redraw_label();
btnUser16->label(label16.c_str()); btnUser16->redraw_label();
btnUser17->label(label17.c_str()); btnUser17->redraw_label();
btnUser18->label(label18.c_str()); btnUser18->redraw_label();
btnUser19->label(label19.c_str()); btnUser19->redraw_label();
btnUser20->label(label20.c_str()); btnUser20->redraw_label();
btnUser21->label(label21.c_str()); btnUser21->redraw_label();
btnUser22->label(label22.c_str()); btnUser22->redraw_label();
btnUser23->label(label23.c_str()); btnUser23->redraw_label();
btnUser24->label(label24.c_str()); btnUser24->redraw_label();
Fl::scheme(ui_scheme.c_str());
}
std::string status::info()
{
std::stringstream info;
static std::string retinfo;
info << "status::info()\n============== Prefs File Contents =============\n\n";
info << "xcvr_serial_port : " << xcvr_serial_port << "\n";
info << "baudrate : " << serial_baudrate << "\n";
info << "stopbits : " << stopbits << "\n";
info << "retries : " << serial_retries << "\n";
info << "write_delay : " << serial_write_delay << "\n";
info << "post_write_delay : " << serial_post_write_delay << "\n";
info << "timeout : " << serial_timeout << "\n";
info << "query interval: : " << serloop_timing << "\n";
info << "\n";
info << "ptt_via_cat : " << serial_catptt << "\n";
info << "ptt_via_rts : " << serial_rtsptt << "\n";
info << "ptt_via_dtr : " << serial_dtrptt << "\n";
info << "rts_cts_flow : " << serial_rtscts << "\n";
info << "rts_plus : " << serial_rtsplus << "\n";
info << "dtr_plus : " << serial_dtrplus << "\n";
info << "civadr : " << CIV << "\n";
info << "usbaudio : " << USBaudio << "\n";
info << "\n";
info << "aux_serial_port : " << aux_serial_port.c_str() << "\n";
info << "aux_rts : " << aux_rts << "\n";
info << "aux_dtr : " << aux_dtr << "\n";
info << "\n";
info << "sep_serial_port : " << sep_serial_port.c_str() << "\n";
info << "sep_rtsptt : " << sep_rtsptt << "\n";
info << "sep_dtrptt : " << sep_dtrptt << "\n";
info << "sep_rtsplus : " << sep_rtsplus << "\n";
info << "set_dtrplus : " << sep_dtrplus << "\n";
info << "\n";
info << "poll_smeter : " << poll_smeter << "\n";
info << "poll_frequency : " << poll_frequency << "\n";
info << "poll_mode : " << poll_mode << "\n";
info << "poll_bandwidth : " << poll_bandwidth << "\n";
info << "poll_volume : " << poll_volume << "\n";
info << "poll_auto_notch : " << poll_auto_notch << "\n";
info << "poll_notch : " << poll_notch << "\n";
info << "poll_ifshift : " << poll_ifshift << "\n";
info << "poll_power_control : " << poll_power_control << "\n";
info << "poll_pbt : " << poll_pbt << "\n";
info << "poll_pre_att : " << poll_pre_att << "\n";
info << "poll_micgain : " << poll_micgain << "\n";
info << "poll_squelch : " << poll_squelch << "\n";
info << "poll_rfgain : " << poll_rfgain << "\n";
info << "poll_pout : " << poll_pout << "\n";
info << "poll_swr : " << poll_swr << "\n";
info << "poll_alc : " << poll_alc << "\n";
info << "poll_split : " << poll_split << "\n";
info << "poll_noise : " << poll_noise << "\n";
info << "poll_nr : " << poll_nr << "\n";
info << "poll_ptt : " << poll_ptt << "\n";
info << "poll_break_in : " << poll_break_in << "\n";
info << "poll_all : " << poll_all << "\n";
info << "\n";
info << "freq_A : " << freq_A << "\n";
info << "mode_A : " << imode_A << "\n";
info << "bw_A : " << iBW_A << "\n";
info << "\n";
info << "freq_B : " << freq_B << "\n";
info << "mode_B : " << imode_B << "\n";
info << "bw_B : " << iBW_B << "\n";
info << "\n";
info << "filters : " << filters << "\n";
info << "\n";
info << "use_rig_data : " << use_rig_data << "\n";
// info << "restore_rig_data : " << restore_rig_data << "\n";
info << "\n";
info << "bool_spkr_on : " << spkr_on << "\n";
info << "int_volume : " << volume << "\n";
info << "dbl_power : " << power_level << "\n";
info << "dbl_power_limit % : " << power_limit << "\n";
info << "enable power limit: " << enable_power_limit << "\n";
info << "int_mic : " << mic_gain << "\n";
info << "bool_notch : " << notch << "\n";
info << "int_notch : " << notch_val << "\n";
info << "bool_shift : " << shift << "\n";
info << "int_shift : " << shift_val << "\n";
info << "rfgain : " << rfgain << "\n";
info << "squelch : " << squelch << "\n";
info << "\n";
info << "schema : " << schema << "\n";
info << "\n";
info << "rx_avg : " << rx_avg << "\n";
info << "rx_peak : " << rx_peak << "\n";
info << "pwr_avg : " << pwr_avg << "\n";
info << "pwr_peak : " << pwr_peak << "\n";
info << "pwr_scale : " << pwr_scale << "\n";
info << "\n";
info << "line_out : " << line_out << "\n";
info << "data_port : " << data_port << "\n";
info << "vox_on_dataport : " << vox_on_dataport << "\n";
info << "agc_level : " << agc_level << "\n";
info << "cw_wpm : " << cw_wpm << "\n";
info << "cw_weight : " << cw_weight << "\n";
info << "cw_vol : " << cw_vol << "\n";
info << "cw_spot : " << cw_spot << "\n";
info << "spot_onoff : " << spot_onoff << "\n";
info << "cw_spot_tone : " << cw_spot_tone << "\n";
info << "cw_qsk : " << cw_qsk << "\n";
info << "(cw_delay : " << cw_delay << "\n";
info << "enable_keyer : " << enable_keyer << "\n";
info << "break_in : " << break_in << "\n";
info << "vox_onoff : " << vox_onoff << "\n";
info << "vox_gain : " << vox_gain << "\n";
info << "vox_anti : " << vox_anti << "\n";
info << "vox_hang : " << vox_hang << "\n";
info << "compression : " << compression << "\n";
info << "compON : " << compON << "\n";
info << "\n";
info << "label 1 : " << label1 << "\n";
info << "command 1 : " << command1 << "\n";
info << "label 2 : " << label1 << "\n";
info << "command 2 : " << command1 << "\n";
info << "label 3 : " << label1 << "\n";
info << "command 3 : " << command1 << "\n";
info << "label 4 : " << label1 << "\n";
info << "command 4 : " << command1 << "\n";
info << "label 5 : " << label1 << "\n";
info << "command 5 : " << command1 << "\n";
info << "label 6 : " << label1 << "\n";
info << "command 6 : " << command1 << "\n";
info << "label 7 : " << label1 << "\n";
info << "command 7 : " << command1 << "\n";
info << "label 8 : " << label1 << "\n";
info << "command 8 : " << command1 << "\n";
info << "label 9 : " << label9 << "\n";
info << "command 9 : " << command9 << "\n";
info << "label 10 : " << label10 << "\n";
info << "command 10 : " << command10 << "\n";
info << "label 11 : " << label11 << "\n";
info << "command 11 : " << command11 << "\n";
info << "label 12 : " << label12 << "\n";
info << "command 12 : " << command12 << "\n";
info << "label 13 : " << label13 << "\n";
info << "command 13 : " << command13 << "\n";
info << "label 14 : " << label14 << "\n";
info << "command 14 : " << command14 << "\n";
info << "label 15 : " << label15 << "\n";
info << "command 15 : " << command15 << "\n";
info << "label 16 : " << label16 << "\n";
info << "command 16 : " << command16 << "\n";
info << "label 17 : " << label17 << "\n";
info << "command 17 : " << command17 << "\n";
info << "label 18 : " << label18 << "\n";
info << "command 18 : " << command18 << "\n";
info << "label 19 : " << label19 << "\n";
info << "command 19 : " << command19 << "\n";
info << "label 20 : " << label20 << "\n";
info << "command 20 : " << command20 << "\n";
info << "label 21 : " << label21 << "\n";
info << "command 21 : " << command21 << "\n";
info << "label 22 : " << label22 << "\n";
info << "command 22 : " << command22 << "\n";
info << "label 23 : " << label23 << "\n";
info << "command 23 : " << command23 << "\n";
info << "label 24 : " << label24 << "\n";
info << "command 24 : " << command24 << "\n";
info << "BT : " << BT << "\n";
info << "AA : " << AA << "\n";
info << "AS : " << AS << "\n";
info << "AR : " << AR << "\n";
info << "KN : " << KN << "\n";
info << "SK : " << SK << "\n";
info << "INT : " << INT << "\n";
info << "HM : " << HM << "\n";
info << "VE : " << VE << "\n";
return retinfo = info.str();
}
static bool strace;
static bool srigtrace;
static bool ssettrace;
static bool sgettrace;
static bool sstrace;
static bool stcitrace;
void ss_trace(bool on)
{
if (on) {
strace = progStatus.trace;
srigtrace = progStatus.rigtrace;
ssettrace = progStatus.settrace;
sgettrace = progStatus.gettrace;
sstrace = progStatus.serialtrace;
stcitrace = progStatus.tcitrace;
progStatus.trace =
progStatus.rigtrace =
progStatus.settrace =
progStatus.serialtrace =
progStatus.gettrace =
progStatus.tcitrace = true;
} else {
progStatus.trace = strace;
progStatus.rigtrace = srigtrace;
progStatus.settrace = ssettrace;
progStatus.gettrace = sgettrace;
progStatus.serialtrace = sstrace;
progStatus.tcitrace = stcitrace;
}
}
flrig-2.0.04/src/support/serial.cxx 0000664 0001750 0001750 00000101116 14505023143 014126 0000000 0000000 // ----------------------------------------------------------------------------
// Copyright (C) 2014
// David Freese, W1HKJ
//
// This file is part of flrig.
//
// flrig is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation; either version 3 of the License, or
// (at your option) any later version.
//
// flrig is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program. If not, see .
// ----------------------------------------------------------------------------
#include
#include
#include
#include "debug.h"
#include "rig.h"
#include "serial.h"
#include "status.h"
#include "trace.h"
#include "tod_clock.h"
LOG_FILE_SOURCE(debug::LOG_RIGCONTROL);
char traceinfo[1000];
bool SERIALDEBUG = false;
bool check_hex(const void *s, size_t len)
{
unsigned char *str = (unsigned char *)s;
for (size_t n = 0; n < len; n++) {
if (str[n] == '\r' || str[n] == '\n') continue;
if (str[n] < 0x20) return true;
if (str[n] > 0x7F) return true;
}
return false;
}
#ifndef __WIN32__
#include
#include
#include
#include
#include
#include
#include
#include
Cserial::Cserial() {
device = "/dev/ttyS0";
baud = 1200;
timeout = 100; //msec
retries = 5;
rts =
dtr =
rtsptt =
dtrptt =
rtscts =
serptt = false;
state = 0;
stopbits = 2;
fd = -1;
failed_ = 0;
}
Cserial::~Cserial() {
ClosePort();
}
///////////////////////////////////////////////////////
// Function name : Cserial::OpenPort
// Description : Opens the port specified by strPortName
// Return type : bool
// Argument : c_std::string strPortName
///////////////////////////////////////////////////////
bool Cserial::CheckPort(std::string dev) {
int testfd = open( dev.c_str(), O_RDWR | O_NOCTTY | O_NDELAY);
if (testfd < 0) {
snprintf(traceinfo, sizeof(traceinfo), "%s checkPort() FAILED", dev.c_str());
ser_trace(1, traceinfo);
return false;
}
close(fd);
return true;
}
void Cserial::set_attributes()
{
// save current port settings
tcflush (fd, TCIFLUSH);
// tcgetattr (fd, &oldtio);
// newtio = oldtio;
// ioctl(fd, TIOCMGET, &state);
// origstate = state;
// 8 data bits
newtio.c_cflag &= ~CSIZE;
newtio.c_cflag |= CS8;
// enable receiver, set local mode
newtio.c_cflag |= (CLOCAL | CREAD);
// no parity
newtio.c_cflag &= ~PARENB;
if (stopbits == 1)
// 1 stop bit
newtio.c_cflag &= ~CSTOPB;
else
// 2 stop bit
newtio.c_cflag |= CSTOPB;
if (rtscts)
// h/w handshake
newtio.c_cflag |= CRTSCTS;
else
// no h/w handshake
newtio.c_cflag &= ~CRTSCTS;
// raw input
newtio.c_lflag &= ~(ICANON | ECHO | ECHOE | ISIG);
// raw output
newtio.c_oflag &= ~OPOST;
// software flow control disabled
newtio.c_iflag &= ~IXON;
// do not translate CR to NL
newtio.c_iflag &= ~ICRNL;
switch(baud) {
case 300:
speed = B300;
timeout = 1024;
break;
case 1200:
speed = B1200;
timeout = 1024;
break;
case 2400:
speed = B2400;
timeout = 1024;
break;
case 4800:
speed = B4800;
timeout = 512;
break;
default:
case 9600:
speed = B9600;
timeout = 256;
break;
case 19200:
speed = B19200;
timeout = 128;
break;
case 38400:
speed = B38400;
timeout = 64;
break;
case 57600:
speed = B57600;
timeout = 32;
break;
case 115200:
speed = B115200;
timeout = 16;
break;
}
timeout = progStatus.serial_timeout;
cfsetispeed(&newtio, speed);
cfsetospeed(&newtio, speed);
tcsetattr (fd, TCSANOW, &newtio);
if (dtr)
state |= TIOCM_DTR; // set the DTR bit
else
state &= ~TIOCM_DTR; // clear the DTR bit
if (rtscts == false) { // rts OK for ptt if RTSCTS not used
if (rts)
state |= TIOCM_RTS; // set the RTS bit
else
state &= ~TIOCM_RTS; // clear the RTS bit
}
ioctl(fd, TIOCMSET, &state);
}
///////////////////////////////////////////////////////
// Function name : Cserial::OpenPort
// Description : Opens the port specified by strPortName
// Return type : bool
// Argument : c_std::string strPortName
///////////////////////////////////////////////////////
bool Cserial::OpenPort() {
if (IsOpen()) ClosePort();
if ((fd = open( device.c_str(), O_RDWR | O_NOCTTY )) < 0) { // | O_NDELAY )) < 0) {
snprintf(traceinfo, sizeof(traceinfo), "%s OpenPort() FAILED", device.c_str());
ser_trace(1, traceinfo);
return false;
}
if (progStatus.serialtrace || SERIALDEBUG) {
snprintf(traceinfo, sizeof(traceinfo),"%s opened: fd = %d", device.c_str(), fd);
ser_trace(1, traceinfo);
}
MilliSleep(5); // K0OG
tcflush (fd, TCIFLUSH);
tcgetattr (fd, &oldtio);
newtio = oldtio;
ioctl(fd, TIOCMGET, &state);
origstate = state;
set_attributes();
FlushBuffer();
failed_ = 0;
return true;
}
///////////////////////////////////////////////////////
// Function name : Cserial::setPTT
// Return type : void
///////////////////////////////////////////////////////
bool Cserial::RTSptt(){
return serptt;
}
bool Cserial::DTRptt(){
return serptt;
}
bool Cserial::getPTT() {
return serptt;
}
void Cserial::SetPTT(bool ON)
{
if (fd < 0) {
if (progStatus.serialtrace || SERIALDEBUG) {
snprintf(traceinfo, sizeof(traceinfo), "SetPTT(...) fd < 0");
ser_trace(1, traceinfo);
}
LOG_ERROR("ptt fd < 0");
return;
}
if (dtrptt || rtsptt) {
ioctl(fd, TIOCMGET, &state);
if (ON) { // ptt enabled
if (dtrptt && dtr) state &= ~TIOCM_DTR; // toggle low
if (dtrptt && !dtr) state |= TIOCM_DTR; // toggle high
if (!rtscts) {
if (rtsptt && rts) state &= ~TIOCM_RTS; // toggle low
if (rtsptt && !rts) state |= TIOCM_RTS; // toggle high
}
} else { // ptt disabled
if (dtrptt && dtr) state |= TIOCM_DTR; // toggle high
if (dtrptt && !dtr) state &= ~TIOCM_DTR; // toggle low
if (!rtscts) {
if (rtsptt && rts) state |= TIOCM_RTS; // toggle high
if (rtsptt && !rts) state &= ~TIOCM_RTS; // toggle low
}
}
LOG_INFO("PTT %d, DTRptt %d, DTR %d, RTSptt %d, RTS %d, RTSCTS %d, state %2X",
ON, dtrptt, dtr, rtsptt, rts, rtscts, state);
if (progStatus.serialtrace || SERIALDEBUG) {
snprintf(traceinfo, sizeof(traceinfo),"PTT %d, DTRptt %d, DTR %d, RTSptt %d, RTS %d, RTSCTS %d, state %2X",
ON, dtrptt, dtr, rtsptt, rts, rtscts, state);
ser_trace(1, traceinfo);
}
ioctl(fd, TIOCMSET, &state);
}
serptt = ON;
}
void Cserial::setRTS(bool b)
{
if (fd < 0) {
return;
}
ioctl(fd, TIOCMGET, &state);
if (b == true)
state |= TIOCM_RTS; // toggle high
else
state &= ~TIOCM_RTS; // toggle low
if (ioctl(fd, TIOCMSET, &state) == -1) {
char errstr[50];
snprintf(errstr, sizeof(errstr), "set RTS ioctl error: %d", errno);
LOG_ERROR("%s", errstr);
ser_trace(1, errstr);
}
}
void Cserial::setDTR(bool b)
{
if (fd < 0)
return;
ioctl(fd, TIOCMGET, &state);
if (b == true)
state |= TIOCM_DTR; // toggle high
else
state &= ~TIOCM_DTR; // toggle low
if (ioctl(fd, TIOCMSET, &state) == -1) {
char errstr[50];
snprintf(errstr, sizeof(errstr), "set DTR ioctl error: %d", errno);
LOG_ERROR("%s", errstr);
ser_trace(1, errstr);
}
}
///////////////////////////////////////////////////////
// Function name : Cserial::ClosePort
// Description : Closes the Port
// Return type : void
///////////////////////////////////////////////////////
void Cserial::ClosePort()
{
char msg[50];
snprintf(msg, sizeof(msg),"ClosePort(): fd = %d", fd);
ser_trace(1, msg);
if (fd < 0) return;
int myfd = fd;
fd = -1;
// Some serial drivers force RTS and DTR high immediately upon
// opening the port, so our origstate will indicate those bits
// high (though the lines weren't actually high before we opened).
// But then when we "restore" RTS and DTR from origstate here
// it can result in PTT activation upon program exit! To avoid
// this possibility, we ignore the apparentl initial settings, and
// instead force RTS and DTR low before closing the port. (Just
// omitting the ioctl(TIOCMSET) would also resolve the problem).
// Kamal Mostafa
// origstate &= ~(TIOCM_RTS|TIOCM_DTR);
// ioctl(myfd, TIOCMSET, &origstate);
// tcsetattr (myfd, TCSANOW, &oldtio);
close(myfd);
ser_trace(1,"serial port closed");
fd = -1;
failed_ = false;
return;
}
bool Cserial::IOselect ()
{
fd_set rfds;
struct timeval tv;
int retval;
FD_ZERO (&rfds);
FD_SET (fd, &rfds);
tv.tv_sec = timeout/1000;
tv.tv_usec = (timeout % 1000) * 1000;
retval = select (FD_SETSIZE, &rfds, (fd_set *)0, (fd_set *)0, &tv);
if (retval <= 0) { // no response from serial port or error returned
return false;
}
return true;
}
///////////////////////////////////////////////////////
// Function name : Cserial::ls dx
// Description : Reads upto nchars from the selected port
// Return type : # characters received
// Argument : pointer to buffer; # chars to read; std::string terminator
///////////////////////////////////////////////////////
int Cserial::ReadBuffer (std::string &buf, int nchars, std::string find1, std::string find2)
{
if (fd < 0) {
ser_trace(1, "ReadBuffer(...) fd < 0");
return 0;
}
bool hex = false;
fd_set rfds;
FD_ZERO (&rfds);
FD_SET (fd, &rfds);
bool timedout = false,
echo = false;
int bytes = 0;
size_t retval = 0,
maxchars = nchars + bytes_written,
tnow = 0,
start = 0;
buf.clear();
start = tnow = zusec();
while (1) {
memset(uctemp, 0, sizeof(uctemp));
ioctl( fd, FIONREAD, &bytes);
if (bytes) {
if ( (retval = read (fd, uctemp, bytes)) > 0) {
for (size_t nc = 0; nc < retval && nc < sizeof(uctemp); nc++) {
buf += uctemp[nc];
}
}
}
if (!find1.empty() && buf.find(find1) == (buf.length() - find1.length())) break;
if (!find2.empty() && buf.find(find2) == (buf.length() - find2.length())) break;
timedout = ( (zusec() - tnow) > (size_t)(progStatus.serial_timeout * 1000));
// test for icom echo
if ((buf.length() >= (size_t)nchars) && ((buf[3] & 0xFF) == 0xE0))
echo = true;
if (buf.length() >= (echo ? maxchars : (size_t)nchars)) break;
if (timedout) break;
MilliSleep(1);
}
if (echo)
buf = buf.substr(bytes_written);
if (buf.length() > (size_t)nchars) buf.erase(nchars);
size_t readtime = zusec() - start;
memset(traceinfo, 0, sizeof(traceinfo));
hex = check_hex(buf.c_str(), buf.length());
snprintf(traceinfo, sizeof(traceinfo),
"ReadBuffer [%f msec]: %s",
readtime / 1000.0,
(hex ? str2hex(buf.c_str(), buf.length()) : buf.c_str()));
LOG_DEBUG("%s", traceinfo);
if (progStatus.serialtrace)
ser_trace(1, traceinfo);
if (timedout) {
memset(traceinfo, 0, sizeof(traceinfo));
snprintf(traceinfo, sizeof(traceinfo),
"ReadBuffer FAILED [%f msec] wanted %d chars, read %lu chars",
(zusec() - start) / 1000.0,
nchars,
buf.length());
LOG_ERROR("%s", traceinfo);
if (progStatus.serialtrace)
ser_trace(1, traceinfo);
}
return buf.length();
}
///////////////////////////////////////////////////////
// Function name : Cserial::WriteBuffer
// Description : Writes a character buffer to the selected port
// Return type : ssize_t (signed long) - number of bytes written or -1 for failure
// Arguments : binary command string in character buffer; number of bytes to write
///////////////////////////////////////////////////////
int Cserial::WriteBuffer(const char *buff, int n)
{
if (fd < 0) {
ser_trace(1, "WriteBuffer(...) fd < 0");
return 0;
}
std::string sw = std::string(buff, (std::size_t) n);
if (progStatus.serialtrace || SERIALDEBUG) {
size_t p = sw.rfind("\r\n");
if (p == (sw.length() - 2) ) {
sw.replace(p, 2, "");
ser_trace(2, "WriteBuffer: ", sw.c_str());
} else {
bool hex = check_hex(sw.c_str(), sw.length());
ser_trace(2, "WriteBuffer: ", (hex ? str2hex(sw.c_str(), sw.length()) : sw.c_str()));
}
}
FlushBuffer();
int ret = write (fd, buff, n);
bytes_written = n;
if (progStatus.serial_post_write_delay)
MilliSleep(progStatus.serial_post_write_delay);
return ret;
}
///////////////////////////////////////////////////////
// Function name : Cserial::WriteByte
// Description : Writes a Byte to the selected port
// Return type : bool
// Argument : BYTE by
///////////////////////////////////////////////////////
bool Cserial::WriteByte(char by)
{
if (fd < 0) return false;
static char buff[2];
buff[0] = by; buff[1] = 0;
return (write(fd, buff, 1) == 1);
}
///////////////////////////////////////////////////////
// Function name : Cserial::FlushBuffer
// Description : flushes the pending rx chars
// Return type : void
///////////////////////////////////////////////////////
void Cserial::FlushBuffer()
{
if (fd < 0)
return;
tcflush (fd, TCIFLUSH);
}
//=============================================================================
// WIN32 serial implementation
//=============================================================================
#else // __WIN32__
///////////////////////////////////////////////////////
// Function name : Cserial::CheckPort
// Description : Checks the port specified by strPortName
// Return type : bool
// Argument : c_std::string strPortName
///////////////////////////////////////////////////////
bool Cserial::CheckPort(std::string dev) {
static HANDLE hTest;
std::string COMportname = "//./";
COMportname.append(dev);
hTest = CreateFile(COMportname.c_str(),
GENERIC_READ | GENERIC_WRITE,
0,
0,
OPEN_EXISTING,
0,
0);
if(hTest == INVALID_HANDLE_VALUE) return false;
CloseHandle(hTest);
return true;
}
///////////////////////////////////////////////////////
// Function name : Cserial::OpenPort
// Description : Opens the port specified by strPortName
// Return type : bool
// Argument : Cstd::string strPortName
///////////////////////////////////////////////////////
bool Cserial::OpenPort()
{
if (device.empty()) return false;
if (IsOpen()) ClosePort();
std::string COMportname = "//./";
COMportname.append(device);
hComm = CreateFile(COMportname.c_str(),
GENERIC_READ | GENERIC_WRITE,
0,
0,
OPEN_EXISTING,
0,
0);
if (hComm == INVALID_HANDLE_VALUE) {
snprintf(traceinfo, sizeof(traceinfo),
"INVALID_HANDLE_VALUE: Open Comm port %s ; hComm = %llu\n",
COMportname.c_str(),
(unsigned long long)hComm);
LOG_ERROR("%s", traceinfo);
if (progStatus.serialtrace) ser_trace(1, traceinfo);
return false;
}
if (progStatus.serialtrace || SERIALDEBUG) {
snprintf(traceinfo, sizeof(traceinfo),
"Open Comm port %s ; hComm = %llu\n",
COMportname.c_str(),
(unsigned long long)hComm);
LOG_INFO("%s", traceinfo);
ser_trace(1, traceinfo);
}
ConfigurePort( baud, 8, false, NOPARITY, stopbits);
MilliSleep(5); // K0OG
FlushBuffer();
failed_ = false;
return true;
}
///////////////////////////////////////////////////////
// Function name : Cserial::ClosePort
// Description : Closes the Port
// Return type : void
///////////////////////////////////////////////////////
void Cserial::ClosePort()
{
if (hComm != INVALID_HANDLE_VALUE) {
bPortReady = SetCommTimeouts (hComm, &CommTimeoutsSaved);
CloseHandle(hComm);
}
hComm = INVALID_HANDLE_VALUE;
failed_ = false;
return;
}
bool Cserial::IsOpen()
{
if (hComm == INVALID_HANDLE_VALUE) return false;
return true;
}
///////////////////////////////////////////////////////
// Function name : Cserial::GetBytesRead
// Description :
// Return type : DWORD
///////////////////////////////////////////////////////
DWORD Cserial::GetBytesRead()
{
return nBytesRead;
}
///////////////////////////////////////////////////////
// Function name : Cserial::GetBytesWritten
// Description : returns total number of bytes written to port
// Return type : DWORD
///////////////////////////////////////////////////////
DWORD Cserial::GetBytesWritten()
{
return nBytesWritten;
}
///////////////////////////////////////////////////////
// Function name : Cserial::ReadByte
// Description : Reads a byte from the selected port
// Return type : bool
// Argument : BYTE& by
///////////////////////////////////////////////////////
bool Cserial::ReadByte(char & by)
{
static BYTE byResByte[1024];
static DWORD dwBytesTxD=0;
if (hComm == INVALID_HANDLE_VALUE) return false;
if (ReadFile (hComm, &byResByte[0], 1, &dwBytesTxD, 0)) {
if (dwBytesTxD == 1) {
by = (UCHAR)byResByte[0];
return true;
}
}
by = 0;
return false;
}
int Cserial::ReadBuffer (std::string &buf, int nchars, std::string find1, std::string find2)
{
if (hComm == INVALID_HANDLE_VALUE) {
snprintf(traceinfo, sizeof(traceinfo), "ReadBuffer, invalid handle\n");
LOG_ERROR("%s", traceinfo);
if (progStatus.serialtrace || SERIALDEBUG)
ser_trace(1, traceinfo);
return 0;
}
BOOL hex = false;
std::string s1, s2;
if (find1.length())
hex = hex || check_hex(find1.c_str(), find1.length());
if (find2.length())
hex = hex || check_hex(find2.c_str(), find2.length());
if (hex) {
s1 = str2hex(find1.c_str(), find1.length());
s2 = str2hex(find2.c_str(), find2.length());
} else {
s1 = find1;
size_t p = s1.find("\r\n");
if (p != std::string::npos) s1.replace(p,2,"");
p = s1.find('\r');
if (p != std::string::npos) s1.replace(p,1,"");
p = s1.find('\n');
if (p != std::string::npos) s1.replace(p,1,"");
s2 = find2;
p = s2.find("\r\n");
if (p != std::string::npos) s2.replace(p,2,"");
p = s2.find('\r');
if (p != std::string::npos) s2.replace(p,1,"");
p = s2.find('\n');
if (p != std::string::npos) s2.replace(p,1,"");
}
// bool find_two = (!find1.empty() && !find2.empty());
// bool find_one = (!find1.empty() && find2.empty());
// if (find_two)
// snprintf(traceinfo, sizeof(traceinfo), "ReadBuffer: %s | %s", s1.c_str(), s2.c_str());
// else if (find_one)
// snprintf(traceinfo, sizeof(traceinfo), "ReadBuffer XXX: %s", s1.c_str());
// else
// snprintf(traceinfo, sizeof(traceinfo), "ReadBuffer: %d chars", nchars);
// LOG_DEBUG("%s", traceinfo);
// if (progStatus.serialtrace)
// ser_trace(1, traceinfo);
memset(traceinfo, 0, sizeof(traceinfo));
long unsigned int thisread = 0;
size_t maxchars = nchars + nBytesWritten;
double start = zusec();
bool echo = false;
bool retval = false;
std::string sbuf;
sbuf.clear();
while ( (zusec() - start) < (progStatus.serial_timeout * 1000.0) ) {
memset(uctemp, 0, sizeof(uctemp));
if ( (retval = ReadFile (hComm, uctemp, maxchars, &thisread, NULL)) ) {
for (size_t n = 0; n < thisread && n < sizeof(uctemp); n++) {
sbuf += uctemp[n];
}
}
// test for icom echo
if ((sbuf.length() >= (size_t)nchars) && ((sbuf[3] & 0xFF) == 0xE0))
echo = true;
if (sbuf.length() >= (echo ? maxchars : (size_t)nchars)) break;
if (!find1.empty() && sbuf.find(find1) == (sbuf.length() - find1.length())) break;
if (!find2.empty() && sbuf.find(find2) == (sbuf.length() - find2.length())) break;
if (!thisread || !retval) MilliSleep(1);
}
double readtime = (zusec() - start) / 1000.0;
snprintf(traceinfo, sizeof(traceinfo),
"ReadBuffer [%0.2f msec] (%u): %s",
readtime, sbuf.length(),
(hex ? str2hex(buf.c_str(), buf.length()) : sbuf.c_str()));
if (progStatus.serialtrace)
ser_trace(2, "1:", traceinfo);
if (echo)
sbuf = sbuf.substr(nBytesWritten);
if (sbuf.length() > (size_t)nchars) sbuf.erase(nchars);
buf = sbuf;
int nread = (int)buf.length();
// snprintf(traceinfo, sizeof(traceinfo),
// "ReadBuffer [%0.2f msec] (%d): %s",
// readtime, nread,
// (hex ? str2hex(buf.c_str(), buf.length()) : buf.c_str()));
// LOG_DEBUG("%s", traceinfo);
// if (progStatus.serialtrace)
// ser_trace(1, traceinfo);
if (nread >= nchars) return nread;
snprintf(traceinfo, sizeof(traceinfo),
"ReadBuffer FAILED [%0.2f msec], read %d bytes",
readtime, nread);
LOG_ERROR("%s", traceinfo);
if (progStatus.serialtrace)
ser_trace(2, "2:", traceinfo);
return nread;
}
void Cserial::FlushBuffer()
{
#define TX_CLEAR 0x0004L
#define RX_CLEAR 0x0008L
if (hComm == INVALID_HANDLE_VALUE) return;
PurgeComm(hComm, RX_CLEAR);
}
///////////////////////////////////////////////////////
// Function name : Cserial::WriteByte
// Description : Writes a Byte to teh selected port
// Return type : bool
// Argument : BYTE by
///////////////////////////////////////////////////////
bool Cserial::WriteByte(char by)
{
if (hComm == INVALID_HANDLE_VALUE) return false;
nBytesWritten = 0;
if (WriteFile(hComm,&by,1,&nBytesWritten,NULL)==0) return false;
return true;
}
///////////////////////////////////////////////////////
// Function name : Cserial::WriteBuffer
// Description : Writes a character buffer to the selected port
// Return type : ssize_t (signed long) - number of bytes written or -1 for failure
// Arguments : binary command string in character buffer; number of bytes to write
///////////////////////////////////////////////////////
int Cserial::WriteBuffer(const char *buff, int n)
{
if (hComm == INVALID_HANDLE_VALUE) return 0;
if (progStatus.serialtrace || SERIALDEBUG) {
std::string sw = std::string(buff, (std::size_t) n);
size_t p = sw.rfind("\r\n");
if (p == (sw.length() - 2) ) {
sw.replace(p, 2, "");
ser_trace(2, "WriteBuffer: ", sw.c_str());
} else {
bool hex = check_hex(sw.c_str(), sw.length());
ser_trace(2, "WriteBuffer: ", (hex ? str2hex(sw.c_str(), sw.length()) : sw.c_str()));
}
}
FlushBuffer();
WriteFile (hComm, buff, n, &nBytesWritten, NULL);
if (progStatus.serial_post_write_delay)
MilliSleep(progStatus.serial_post_write_delay);
return nBytesWritten;
}
///////////////////////////////////////////////////////
// Function name : Cserial::SetCommunicationTimeouts
// Description : Sets the timeout for the selected port
// Return type : bool
// Argument : DWORD ReadIntervalTimeout
// Argument : DWORD ReadTotalTimeoutMultiplier
// Argument : DWORD ReadTotalTimeoutConstant
// Argument : DWORD WriteTotalTimeoutMultiplier
// Argument : DWORD WriteTotalTimeoutConstant
///////////////////////////////////////////////////////
bool Cserial::SetCommunicationTimeouts(
DWORD ReadIntervalTimeout,
DWORD ReadTotalTimeoutMultiplier,
DWORD ReadTotalTimeoutConstant,
DWORD WriteTotalTimeoutMultiplier,
DWORD WriteTotalTimeoutConstant
)
{
if((bPortReady = GetCommTimeouts (hComm, &CommTimeoutsSaved)) == 0) {
return false;
}
CommTimeouts.ReadIntervalTimeout = ReadIntervalTimeout;
CommTimeouts.ReadTotalTimeoutMultiplier = ReadTotalTimeoutMultiplier;
CommTimeouts.ReadTotalTimeoutConstant = ReadTotalTimeoutConstant;
CommTimeouts.WriteTotalTimeoutConstant = WriteTotalTimeoutConstant;
CommTimeouts.WriteTotalTimeoutMultiplier = WriteTotalTimeoutMultiplier;
bPortReady = SetCommTimeouts (hComm, &CommTimeouts);
snprintf(traceinfo, sizeof(traceinfo), "\n\
============ COMM TIMEOUTS ================\n\
Saved Read Interval Timeout............... %ld\n\
Saved Read Total Timeout Multiplier....... %ld\n\
Saved Read Total Timeout Constant Timeout. %ld\n\
Saved Write Total Timeout Constant........ %ld\n\
Saved Write Total Timeout Multiplier...... %ld\n\
===================================================\n\
Set Read Interval Timeout................. %ld\n\
Set Read Total Timeout Multiplier......... %ld\n\
Set Read Total Timeout Constant Timeout... %ld\n\
Set Write Total Timeout Constant.......... %ld\n\
Set Write Total Timeout Multiplier........ %ld\n\
===================================================",
CommTimeoutsSaved.ReadIntervalTimeout,
CommTimeoutsSaved.ReadTotalTimeoutMultiplier,
CommTimeoutsSaved.ReadTotalTimeoutConstant,
CommTimeoutsSaved.WriteTotalTimeoutConstant,
CommTimeoutsSaved.WriteTotalTimeoutMultiplier,
CommTimeouts.ReadIntervalTimeout,
CommTimeouts.ReadTotalTimeoutMultiplier,
CommTimeouts.ReadTotalTimeoutConstant,
CommTimeouts.WriteTotalTimeoutConstant,
CommTimeouts.WriteTotalTimeoutMultiplier);
LOG_INFO("%s", traceinfo);
if (progStatus.serialtrace) ser_trace(1, traceinfo);
if (bPortReady == 0) {
CloseHandle(hComm);
return false;
}
return true;
}
/*
* Remarks
*
* WriteTotalTimeoutMultiplier
*
* The multiplier used to calculate the total time-out period for write
* operations, in milliseconds. For each write operation, this value is
* multiplied by the number of bytes to be written.
*
* WriteTotalTimeoutConstant
*
* A constant used to calculate the total time-out period for write operations,
* in milliseconds. For each write operation, this value is added to the product
* of the WriteTotalTimeoutMultiplier member and the number of bytes to be
* written.
*
* A value of zero for both the WriteTotalTimeoutMultiplier and
* WriteTotalTimeoutConstant members indicates that total time-outs are not
* used for write operations.
*
*
* If an application sets ReadIntervalTimeout and ReadTotalTimeoutMultiplier to
* MAXDWORD and sets ReadTotalTimeoutConstant to a value greater than zero and
* less than MAXDWORD, one of the following occurs when the ReadFile function
* is called:
*
* If there are any bytes in the input buffer, ReadFile returns immediately
* with the bytes in the buffer.
*
* If there are no bytes in the input buffer, ReadFile waits until a byte
* arrives and then returns immediately.
*
* *********************************************************************
*
* If no bytes arrive within the time specified by ReadTotalTimeoutConstant,
* ReadFile times out.
*
* ReadIntervalTimeout
*
* The maximum time allowed to elapse between the arrival of two bytes on the
* communications line, in milliseconds. During a ReadFile operation, the time
* period begins when the first byte is received. If the interval between the
* arrival of any two bytes exceeds this amount, the ReadFile operation is
* completed and any buffered data is returned. A value of zero indicates that
* interval time-outs are not used.
*
* A value of MAXDWORD, combined with zero values for both the
* ReadTotalTimeoutConstant and ReadTotalTimeoutMultiplier members, specifies
* that the read operation is to return immediately with the bytes that have
* already been received, even if no bytes have been received.
*
* ReadTotalTimeoutMultiplier
*
* The multiplier used to calculate the total time-out period for read
* operations, in milliseconds. For each read operation, this value is
* multiplied by the requested number of bytes to be read.
*
* ReadTotalTimeoutConstant
*
* A constant used to calculate the total time-out period for read operations,
* in milliseconds. For each read operation, this value is added to the product
* of the ReadTotalTimeoutMultiplier member and the requested number of bytes.
*
* A value of zero for both the ReadTotalTimeoutMultiplier and
* ReadTotalTimeoutConstant members indicates that total time-outs are not
* used for read operations.
*
*/
bool Cserial::SetCommTimeout() {
return SetCommunicationTimeouts (
// Read Interval Timeout
MAXDWORD,
// Read Total Timeout Multiplier
MAXDWORD,
// Read Total Timeout Constant
1, // progStatus.serial_timeout ? progStatus.serial_timeout : 5,
// Write Total Timeout Constant
0,
// Write Total Timeout Multiplier
0
);
}
///////////////////////////////////////////////////////
// Function name : ConfigurePort
// Description : Configures the Port
// Return type : bool
// Argument : DWORD BaudRate
// Argument : BYTE ByteSize
// Argument : DWORD fParity
// Argument : BYTE Parity
// Argument : BYTE StopBits
///////////////////////////////////////////////////////
bool Cserial::ConfigurePort(
DWORD BaudRate,
BYTE ByteSize,
DWORD dwParity,
BYTE Parity,
BYTE StopBits)
{
if (hComm == INVALID_HANDLE_VALUE) return false;
// memset(dcb, 0, sizeof(dcb));
dcb.DCBlength = sizeof(dcb);
if((bPortReady = GetCommState(hComm, &dcb)) == 0) {
LOG_ERROR("GetCommState Error on %s", device.c_str());
if (progStatus.serialtrace || SERIALDEBUG) {
snprintf(traceinfo, sizeof(traceinfo), "GetCommState Error on %s\n", device.c_str());
ser_trace(1, traceinfo);
}
CloseHandle(hComm);
return false;
}
dcb.DCBlength = sizeof (dcb);
dcb.BaudRate = BaudRate;
dcb.ByteSize = ByteSize;
dcb.Parity = Parity ;
if (dcb.StopBits) // corrects a driver malfunction in the Yaesu SCU-17
dcb.StopBits = (StopBits == 1 ? ONESTOPBIT : TWOSTOPBITS);
dcb.fBinary = true;
dcb.fDsrSensitivity = false;
dcb.fParity = false;
dcb.fOutX = false;
dcb.fInX = false;
dcb.fNull = false;
dcb.fAbortOnError = false;
dcb.fOutxCtsFlow = false;
dcb.fOutxDsrFlow = false;
dcb.fErrorChar = false;
//PortDCB.fTXContinueOnXoff = TRUE; // XOFF continues Tx
if (dtr)
dcb.fDtrControl = DTR_CONTROL_ENABLE;
else
dcb.fDtrControl = DTR_CONTROL_DISABLE;
dcb.fDsrSensitivity = false;
if (rtscts) dcb.fRtsControl = RTS_CONTROL_ENABLE;
else {
if (rts)
dcb.fRtsControl = RTS_CONTROL_ENABLE;
else
dcb.fRtsControl = RTS_CONTROL_DISABLE;
}
if (progStatus.serialtrace || SERIALDEBUG) {
ser_trace(1, traceinfo);
}
bPortReady = SetCommState(hComm, &dcb);
snprintf(traceinfo, sizeof(traceinfo), "\
\n\
Set Comm State:\n\
DCB.DCBlength %d\n\
DCB.Baudrate %d\n\
DCB.ByteSize %d\n\
DCB.Parity %d\n\
DCB.StopBits %d\n\
DCB.Binary %d\n\
DCB.fDtrControl %d\n\
DCB.fRtsControl %d\n\
DCB.fDsrSensitivity %d\n\
DCB.fParity %d\n\
DCB.fOutX %d\n\
DCB.fInX %d\n\
DCB.fNull %d\n\
DCB.XonChar %d\n\
DCB.XoffChar %d\n\
DCB.fAbortOnError %d\n\
DCB.fOutxCtsFlow %d\n\
DCB.fOutxDsrFlow %d\n",
(int)dcb.DCBlength,
(int)dcb.BaudRate,
(int)dcb.ByteSize,
(int)dcb.Parity,
(int)dcb.StopBits,
(int)dcb.fBinary,
(int)dcb.fDtrControl,
(int)dcb.fRtsControl,
(int)dcb.fDsrSensitivity,
(int)dcb.fParity,
(int)dcb.fOutX,
(int)dcb.fInX,
(int)dcb.fNull,
(int)dcb.XonChar,
(int)dcb.XoffChar,
(int)dcb.fAbortOnError,
(int)dcb.fOutxCtsFlow,
(int)dcb.fOutxDsrFlow);
LOG_INFO("%s", traceinfo);
if (progStatus.serialtrace) ser_trace(1, traceinfo);
if (bPortReady == 0) {
long err = GetLastError();
snprintf(traceinfo, sizeof(traceinfo),
"SetCommState handle %llu, returned %d, error = %d\n",
(unsigned long long)hComm, bPortReady, (int)err);
LOG_ERROR("%s", traceinfo);
ser_trace(1, traceinfo);
CloseHandle(hComm);
return false;
}
return SetCommTimeout();
}
///////////////////////////////////////////////////////
// Function name : Cserial::setPTT
// Return type : void
///////////////////////////////////////////////////////
bool Cserial::RTSptt(){
return rtsptt;
}
bool Cserial::DTRptt(){
return dtrptt;
}
bool Cserial::getPTT() {
return serptt;
}
void Cserial::SetPTT(bool ON)
{
if (hComm == INVALID_HANDLE_VALUE) {
if (progStatus.serialtrace || SERIALDEBUG) {
snprintf(traceinfo, sizeof(traceinfo), "SetPTT failed, invalid handle\n");
ser_trace(1, traceinfo);
}
return;
}
if ( !(dtrptt || rtsptt) )
return;
if (ON) {
if (dtrptt && dtr)
dcb.fDtrControl = DTR_CONTROL_DISABLE;
if (dtrptt && !dtr)
dcb.fDtrControl = DTR_CONTROL_ENABLE;
if (!rtscts) {
if (rtsptt && rts)
dcb.fRtsControl = RTS_CONTROL_DISABLE;
if (rtsptt && !rts)
dcb.fRtsControl = RTS_CONTROL_ENABLE;
}
} else {
if (dtrptt && dtr)
dcb.fDtrControl = DTR_CONTROL_ENABLE;
if (dtrptt && !dtr)
dcb.fDtrControl = DTR_CONTROL_DISABLE;
if (!rtscts) {
if (rtsptt && rts)
dcb.fRtsControl = RTS_CONTROL_ENABLE;
if (rtsptt && !rts)
dcb.fRtsControl = RTS_CONTROL_DISABLE;
}
}
LOG_ERROR("PTT %d, DTRptt %d, DTR %d, RTSptt %d, RTS %d, RTSCTS %d, %2x %2x",
ON, dtrptt, dtr, rtsptt, rts, rtscts,
static_cast(dcb.fDtrControl),
static_cast(dcb.fRtsControl) );
if (progStatus.serialtrace || SERIALDEBUG) {
snprintf(traceinfo, sizeof(traceinfo), "\
PTT %d, DTRptt %d, DTR %d, RTSptt %d, RTS %d, RTSCTS %d, DtrControl %2x, RtsControl %2x\n",
ON, dtrptt, dtr, rtsptt, rts, rtscts,
static_cast(dcb.fDtrControl),
static_cast(dcb.fRtsControl) );
ser_trace(1, traceinfo);
}
serptt = ON;
SetCommState(hComm, &dcb);
}
void Cserial::setDTR(bool b)
{
if(hComm == INVALID_HANDLE_VALUE) {
LOG_PERROR("Invalid handle");
return;
}
if (b) EscapeCommFunction(hComm, SETDTR);
else EscapeCommFunction(hComm, CLRDTR);
}
void Cserial::setRTS(bool b)
{
if(hComm == INVALID_HANDLE_VALUE) {
LOG_PERROR("Invalid handle");
return;
}
if (b) EscapeCommFunction(hComm, SETRTS);
else EscapeCommFunction(hComm, CLRRTS);
}
Cserial::Cserial() {
rts =
dtr =
rtsptt =
dtrptt =
rtscts =
serptt = false;
baud = CBR_9600;
stopbits = 2;
hComm = INVALID_HANDLE_VALUE;
}
Cserial::Cserial( std::string portname) {
device = portname;
Cserial();
}
Cserial::~Cserial() {
ClosePort();
}
#endif
flrig-2.0.04/src/support/ptt.cxx 0000664 0001750 0001750 00000007471 14504050363 013472 0000000 0000000 // ----------------------------------------------------------------------------
// Copyright (C) 2014
// David Freese, W1HKJ
//
// This file is part of flrig.
//
// flrig is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation; either version 3 of the License, or
// (at your option) any later version.
//
// flrig is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program. If not, see .
// ----------------------------------------------------------------------------
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include "threads.h"
#include "ptt.h"
#include "debug.h"
#include "rig_io.h"
#include "rig.h"
#include "support.h"
#include "gpio_ptt.h"
#include "cmedia.h"
// used for transceivers with a single vfo, called only by rigPTT
static XCVR_STATE fake_vfo;
static void showfreq(void *)
{
FreqDispA->value(vfoA.freq);
}
static void fake_split(int on)
{
if (on) {
fake_vfo = vfoA;
vfoA.freq = vfoB.freq;
selrig->set_vfoA(vfoA.freq);
Fl::awake(showfreq);
} else {
vfoA = fake_vfo;
selrig->set_vfoA(vfoA.freq);
Fl::awake(showfreq);
}
}
// add fake rit to this function and to set_vfoA ??
extern void xmlrpc_ptt(int);
void rigPTT(bool on)
{
if (progStatus.xmlrpc_rig) {
xmlrpc_ptt(on);
return;
}
if (!on && progStatus.split && !selrig->can_split())
fake_split(on);
std::string smode = "";
try {
smode = selrig->modes_[vfo->imode];
} catch (const std::exception& e) {
std::cout << e.what() << '\n';
}
if ((smode.find("CW") != std::string::npos) && progStatus.disable_CW_ptt)
return;
if (progStatus.serial_catptt == PTT_BOTH || progStatus.serial_catptt == PTT_SET) selrig->set_PTT_control(on);
else if (progStatus.serial_dtrptt == PTT_BOTH || progStatus.serial_dtrptt == PTT_SET) RigSerial->SetPTT(on);
else if (progStatus.serial_rtsptt == PTT_BOTH || progStatus.serial_rtsptt == PTT_SET) RigSerial->SetPTT(on);
else if (SepSerial->IsOpen() &&
(progStatus.sep_dtrptt == PTT_BOTH || progStatus.sep_dtrptt == PTT_SET)) SepSerial->SetPTT(on);
else if (SepSerial->IsOpen() &&
(progStatus.sep_rtsptt == PTT_BOTH || progStatus.sep_rtsptt == PTT_SET)) SepSerial->SetPTT(on);
else if (progStatus.gpio_ptt == PTT_BOTH || progStatus.gpio_ptt == PTT_SET) set_gpio(on);
else if (progStatus.cmedia_ptt == PTT_BOTH || progStatus.cmedia_ptt == PTT_SET) set_cmedia(on);
else
LOG_DEBUG("No PTT i/o connected");
}
extern bool xml_ptt_state();
bool ptt_state()
{
if (progStatus.xmlrpc_rig)
return xml_ptt_state();
if (progStatus.serial_catptt == PTT_BOTH || progStatus.serial_catptt == PTT_GET) return selrig->get_PTT();
else if (progStatus.serial_dtrptt == PTT_BOTH || progStatus.serial_dtrptt == PTT_GET) return selrig->get_PTT();
else if (progStatus.serial_rtsptt == PTT_BOTH || progStatus.serial_rtsptt == PTT_GET) return selrig->get_PTT();
else if (SepSerial->IsOpen() &&
(progStatus.sep_dtrptt == PTT_BOTH || progStatus.sep_dtrptt == PTT_GET)) return SepSerial->getPTT();
else if (SepSerial->IsOpen() &&
(progStatus.sep_rtsptt == PTT_BOTH || progStatus.sep_rtsptt == PTT_GET)) return SepSerial->getPTT();
else if (progStatus.gpio_ptt == PTT_BOTH || progStatus.gpio_ptt == PTT_GET) return get_gpio();
else if (progStatus.cmedia_ptt == PTT_BOTH || progStatus.cmedia_ptt == PTT_GET) return get_cmedia();
LOG_DEBUG("No PTT i/o connected");
return false;
}
flrig-2.0.04/src/support/init_rig.cxx 0000664 0001750 0001750 00000015422 14504050363 014462 0000000 0000000 // ----------------------------------------------------------------------------
// Copyright (C) 2014-2011
// David Freese, W1HKJ
//
// This file is part of flrig.
//
// flrig is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation; either version 3 of the License, or
// (at your option) any later version.
//
// flrig is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program. If not, see .
// ----------------------------------------------------------------------------
#include "support.h"
void TRACED(init_xcvr)
if (selrig->name_ == rig_TT550.name_) return;
if (xcvr_name == rig_FT817.name_ ||
xcvr_name == rig_FT818ND.name_ ||
xcvr_name == rig_FT857D.name_ ||
xcvr_name == rig_FT897D.name_ ) {
// transceiver should be on VFO A before starting flrig
selrig->selectB();
vfoB.freq = selrig->get_vfoB();
FreqDispB->value(vfoB.freq);
vfoB.imode = selrig->get_modeB();
selrig->selectA();
vfoA.freq = selrig->get_vfoA();
FreqDispA->value(vfoA.freq);
vfoA.imode = selrig->get_modeA();
updateBandwidthControl();
setModeControl((void *)0);
highlight_vfo(NULL);
return;
} // Yaesu FT817, FT817ND, FT818ND, FT857D, FT897D transceivers
if (xcvr_name == rig_FT817BB.name_) {
if (selrig->get_vfoAorB() == onA) {
selrig->selectB();
vfoB.freq = selrig->get_vfoB();
FreqDispB->value(vfoB.freq);
vfoB.imode = selrig->get_modeB();
selrig->selectA();
vfoA.freq = selrig->get_vfoA();
FreqDispA->value(vfoA.freq);
vfoA.imode = selrig->get_modeA();
updateBandwidthControl();
} else {
selrig->selectA();
vfoA.freq = selrig->get_vfoA();
FreqDispA->value(vfoA.freq);
vfoA.imode = selrig->get_modeA();
selrig->selectB();
vfoB.freq = selrig->get_vfoB();
FreqDispB->value(vfoB.freq);
vfoB.imode = selrig->get_modeB();
updateBandwidthControl();
}
setModeControl((void *)0);
highlight_vfo(NULL);
return;
} // FT817BB transceiver
if (!progStatus.use_rig_data) {
vfoB.freq = progStatus.freq_B;
vfoB.imode = progStatus.imode_B;
vfoB.iBW = progStatus.iBW_B;
if (vfoB.iBW == -1)
vfoB.iBW = selrig->def_bandwidth(vfoB.imode);
selrig->selectB();
selrig->set_modeB(vfoB.imode);
selrig->set_bwB(vfoB.iBW);
selrig->set_vfoB(vfoB.freq);
FreqDispB->value(vfoB.freq);
update_progress(progress->value() + 4);
trace(2, "init_xcvr() vfoB ", printXCVR_STATE(vfoB).c_str());
vfoA.freq = progStatus.freq_A;
vfoA.imode = progStatus.imode_A;
vfoA.iBW = progStatus.iBW_A;
if (vfoA.iBW == -1)
vfoA.iBW = selrig->def_bandwidth(vfoA.imode);
selrig->selectA();
selrig->set_modeA(vfoA.imode);
selrig->set_bwA(vfoA.iBW);
selrig->set_vfoA(vfoA.freq);
FreqDispA->value( vfoA.freq );
update_progress(progress->value() + 4);
vfo = &vfoA;
updateBandwidthControl();
highlight_vfo((void *)0);
trace(2, "init_xcvr() vfoA ", printXCVR_STATE(vfoA).c_str());
} else {
// Capture VFOA mode and bandwidth, since it will be lost in VFO switch
if (selrig->name_ == rig_FT891.name_) {
selrig->selectA();
vfoA.freq = selrig->get_vfoA();
update_progress(progress->value() + 4);
vfoA.imode = selrig->get_modeA();
update_progress(progress->value() + 4);
vfoA.iBW = selrig->get_bwA();
update_progress(progress->value() + 4);
FreqDispA->value(vfoA.freq);
trace(2, "A: ", printXCVR_STATE(vfoA).c_str());
selrig->selectB(); // third select call
vfoB.freq = selrig->get_vfoB();
update_progress(progress->value() + 4);
vfoB.imode = selrig->get_modeB();
update_progress(progress->value() + 4);
vfoB.iBW = selrig->get_bwB();
update_progress(progress->value() + 4);
FreqDispB->value(vfoB.freq);
trace(2, "B: ", printXCVR_STATE(vfoB).c_str());
// Restore radio VFOA mode, then freq and bandwidth
selrig->selectA(); // fourth select call
yaesu891UpdateA(&vfoA);
} else {
vfoB = xcvr_vfoB;
vfoA = xcvr_vfoA;
FreqDispB->value(vfoB.freq);
FreqDispA->value(vfoA.freq);
}
vfo = &vfoA;
selrig->set_modeA(vfo->imode);
selrig->set_bwA(vfo->iBW);
setModeControl((void *)0);
update_progress(progress->value() + 4);
updateBandwidthControl();
update_progress(progress->value() + 4);
highlight_vfo((void *)0);
}
selrig->set_split(0); // initialization set split call
}
void TRACED(init_generic_rig)
if (progStatus.CIV > 0)
selrig->adjustCIV(progStatus.CIV);
if (selrig->has_getvfoAorB) {
selrig->get_vfoAorB();
// int ret = selrig->get_vfoAorB();
// int retry = 10;
// while (ret == -1 && retry--) {
// MilliSleep(50);
// ret = selrig->get_vfoAorB();
// }
// if (ret == -1) ret = 0;
// selrig->inuse = ret;
rig_startup_data();
if (progStatus.use_rig_data) {
vfoA = xcvr_vfoA;
vfoB = xcvr_vfoB;
}
if (selrig->inuse == onB) {
// selrig->selectB();
vfo = &vfoB;
} else {
vfo = &vfoA;
}
}
else {
rig_startup_data();
if (progStatus.use_rig_data) {
vfoA = xcvr_vfoA;
vfoB = xcvr_vfoB;
}
}
init_xcvr();
progStatus.compON = xcvr_vfoA.compON;
progStatus.compression = xcvr_vfoA.compression;
if (selrig->has_compression)
update_compression(NULL);
// vfo = &vfoA;
rigmodes_.clear();
opMODE->clear();
if (selrig->has_mode_control) {
for (size_t i = 0; i < selrig->modes_.size(); i++) {
rigmodes_.push_back(selrig->modes_.at(i));
opMODE->add(selrig->modes_.at(i).c_str());
}
opMODE->activate();
opMODE->index(progStatus.imode_A);
} else {
opMODE->add(" ");
opMODE->index(0);
opMODE->deactivate();
}
if (xcvr_name == rig_KX3.name_ ||
xcvr_name == rig_K4.name_) {
opBW->hide();
opBW_A->show();
opBW_B->show();
if (progStatus.iBW_A < 1) progStatus.iBW_A = selrig->def_bandwidth(vfoA.imode);
if (progStatus.iBW_B < 1) progStatus.iBW_B = selrig->def_bandwidth(vfoB.imode);
opBW_A->index(selrig->bwA = vfoA.iBW = progStatus.iBW_A);
opBW_B->index(selrig->bwB = vfoB.iBW = progStatus.iBW_B);
opBW_A->redraw();
opBW_B->redraw();
}
else if (selrig->has_bandwidth_control) {
opBW->clear();
opBW->show();
try {
for (size_t i = 0; i < selrig->bandwidths_.size(); i++) {
opBW->add(selrig->bandwidths_.at(i).c_str());
}
} catch (const std::exception& e) {
LOG_ERROR("%s", e.what());
}
opBW->activate();
if (progStatus.iBW_A == -1) progStatus.iBW_A = selrig->def_bandwidth(vfoA.imode);
if (progStatus.iBW_B == -1) progStatus.iBW_B = selrig->def_bandwidth(vfoB.imode);
opBW->index(progStatus.iBW_A);
} else {
opBW->add(" ");
opBW->index(0);
opBW->deactivate();
}
}
flrig-2.0.04/src/support/gpio_ptt.cxx 0000664 0001750 0001750 00000010222 14504050363 014474 0000000 0000000 // ----------------------------------------------------------------------------
// Copyright (C) 2020
// David Freese, W1HKJ
//
// This file is part of flrig.
//
// flrig is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation; either version 3 of the License, or
// (at your option) any later version.
//
// flrig is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program. If not, see .
// ----------------------------------------------------------------------------
#include
#include "gpio_ptt.h"
#include "support.h"
//-------------------- gpio port PTT --------------------//
#ifndef __MINGW32__
void gpioEXEC(std::string execstr)
{
int pfd[2];
if (pipe(pfd) == -1) {
LOG_PERROR("pipe");
return;
}
int pid;
switch (pid = fork()) {
case -1:
LOG_PERROR("fork");
return;
case 0: // child
close(pfd[0]);
if (dup2(pfd[1], STDOUT_FILENO) != STDOUT_FILENO) {
LOG_PERROR("dup2");
exit(EXIT_FAILURE);
}
close(pfd[1]);
execl("/bin/sh", "sh", "-c", execstr.c_str(), (char *)NULL);
perror("execl");
exit(EXIT_FAILURE);
}
// parent
close(pfd[1]);
}
#else // !__MINGW32__
void gpioEXEC(std::string execstr)
{
char* cmd = strdup(execstr.c_str());
STARTUPINFO si;
PROCESS_INFORMATION pi;
memset(&si, 0, sizeof(si));
si.cb = sizeof(si);
memset(&pi, 0, sizeof(pi));
if (!CreateProcess(NULL, cmd, NULL, NULL, FALSE, CREATE_NO_WINDOW, NULL, NULL, &si, &pi))
LOG_ERROR("CreateProcess failed with error code %ld", GetLastError());
CloseHandle(pi.hProcess);
CloseHandle(pi.hThread);
free(cmd);
}
#endif // !__MINGW32__
static const char *gpio_name[] = {
"17", "18", "27", "22", "23",
"24", "25", "4", "5", "6",
"13", "19", "26", "12", "16",
"20", "21"};
void export_gpio(int bcm)
{
if (bcm < 0 || bcm > 16) return;
std::string exec_str = "gpio export ";
exec_str.append(gpio_name[bcm]).append(" out");
gpioEXEC(exec_str);
LOG_INFO("%s", exec_str.c_str());
}
void unexport_gpio(int bcm)
{
if (bcm < 0 || bcm > 16) return;
std::string exec_str = "gpio unexport ";
exec_str.append(gpio_name[bcm]);
gpioEXEC(exec_str);
LOG_INFO("%s", exec_str.c_str());
}
void open_gpio(void)
{
bool enabled = false;
for (int i = 0; i < 17; i++) {
enabled = (progStatus.enable_gpio >> i) & 0x01;
if (enabled) export_gpio(i);
}
}
void close_gpio(void)
{
bool enabled = false;
for (int i = 0; i < 17; i++) {
enabled = (progStatus.enable_gpio >> i) & 0x01;
if (enabled) unexport_gpio(i);
}
}
static int enabled = 0;
int get_gpio()
{
return enabled;
}
void set_gpio(bool ptt)
{
#define VALUE_MAX 30
static const char s_values_str[] = "01";
std::string portname = "/sys/class/gpio/gpio";
std::string ctrlport;
enabled = false;
int val = 0;
int fd;
for (int i = 0; i < 17; i++) {
enabled = (progStatus.enable_gpio >> i) & 0x01;
if (enabled) {
val = (progStatus.gpio_on >> i) & 0x01;
ctrlport = portname;
ctrlport.append(gpio_name[i]);
ctrlport.append("/value");
fd = fl_open(ctrlport.c_str(), O_WRONLY);
bool ok = false;
if (fd == -1) {
LOG_ERROR("Failed to open gpio (%s) for writing!", ctrlport.c_str());
} else {
if (progStatus.gpio_pulse_width == 0) {
if (ptt) { if (val == 1) val = 1; else val = 0;}
if (!ptt) { if (val == 1) val = 0; else val = 1;}
if (write(fd, &s_values_str[val], 1) == 1)
ok = true;
} else {
if (write(fd, &s_values_str[val], 1) == 1) {
MilliSleep(progStatus.gpio_pulse_width);
if (write(fd, &s_values_str[val == 0 ? 1 : 0], 1) == 1)
ok = true;
}
}
if (ok)
LOG_INFO("Set GPIO ptt on %s %s%s",
ctrlport.c_str(),
(progStatus.gpio_pulse_width > 0) ?
"pulsed " : "",
(val == 1 ? "HIGH" : "LOW")
);
else
LOG_ERROR("Failed to write value!");
close(fd);
}
}
}
}
flrig-2.0.04/src/flrig-rc.rc 0000664 0001750 0001750 00000000263 14475136651 012462 0000000 0000000 #include // include for version info constants
#include "flrigrc.h"
IDI_ICON ICON DISCARDABLE "flrig.ico"
//A ICON MOVEABLE PURE LOADONCALL DISCARDABLE "flrig.ico"
flrig-2.0.04/src/Makefile.am 0000664 0001750 0001750 00000030530 14502041135 012442 0000000 0000000 # Copyright (c) 2008 Dave Freese, W1HKJ (w1hkj AT w1hkj DOT com)
bin_PROGRAMS = flrig
MINGW32_SRC = \
flrig-rc.rc \
include/flrigrc.h \
support/mingw.c \
include/compat.h \
include/compat-mingw.h
# Build the xmlrpcpp source if libflxmlrpc is not found
XMLRPCPP_SRC = \
xmlrpcpp/XmlRpcBase64.h \
xmlrpcpp/XmlRpcClient.cpp \
xmlrpcpp/XmlRpcClient.h \
xmlrpcpp/XmlRpcDispatch.cpp \
xmlrpcpp/XmlRpcDispatch.h \
xmlrpcpp/XmlRpcException.h \
xmlrpcpp/XmlRpc.h \
xmlrpcpp/XmlRpcMutex.cpp \
xmlrpcpp/XmlRpcMutex.h \
xmlrpcpp/XmlRpcServerConnection.cpp \
xmlrpcpp/XmlRpcServerConnection.h \
xmlrpcpp/XmlRpcServer.cpp \
xmlrpcpp/XmlRpcServer.h \
xmlrpcpp/XmlRpcServerMethod.cpp \
xmlrpcpp/XmlRpcServerMethod.h \
xmlrpcpp/XmlRpcSocket.cpp \
xmlrpcpp/XmlRpcSocket.h \
xmlrpcpp/XmlRpcSource.cpp \
xmlrpcpp/XmlRpcSource.h \
xmlrpcpp/XmlRpcUtil.cpp \
xmlrpcpp/XmlRpcUtil.h \
xmlrpcpp/XmlRpcValue.cpp \
xmlrpcpp/XmlRpcValue.h
# We distribute these but do not always compile them
EXTRA_flrig_SOURCES = $(FLRIG_WIN32_RES_SRC) $(MINGW32_SRC) $(XMLRPCPP_SRC)
flrig_SOURCES =
if !ENABLE_FLXMLRPC
flrig_SOURCES += $(XMLRPCPP_SRC)
flrig_CPPFLAGS = @FLRIG_BUILD_CPPFLAGS@
flrig_CXXFLAGS = @FLRIG_BUILD_CXXFLAGS@
flrig_CFLAGS = $(flrig_CXXFLAGS)
flrig_LDFLAGS = @FLRIG_BUILD_LDFLAGS@
flrig_LDADD = @FLRIG_BUILD_LDADD@
else
flrig_CPPFLAGS = @FLRIG_BUILD_CPPFLAGS@ @FLXMLRPC_CFLAGS@
flrig_CXXFLAGS = @FLRIG_BUILD_CXXFLAGS@ @FLXMLRPC_CFLAGS@
flrig_CFLAGS = $(flrig_CXXFLAGS)
flrig_LDFLAGS = @FLRIG_BUILD_LDFLAGS@ @FLXMLRPC_LIBS@
flrig_LDADD = @FLRIG_BUILD_LDADD@
endif
if MINGW32
if HAVE_WINDRES
flrig_SOURCES += $(MINGW32_SRC)
endif
endif
########################################################################
FLRIG_VERSION_MAJOR = @FLRIG_VERSION_MAJOR@
FLRIG_VERSION_MINOR = @FLRIG_VERSION_MINOR@
FLRIG_VERSION_PATCH = @FLRIG_VERSION_PATCH@
FLRIG_VERSION = @FLRIG_VERSION@
.EXPORT_ALL_VARIABLES: nsisinst appbundle
# Sources that are generated,
BUILT_SOURCES =
# not distributed,
nodist_flrig_SOURCES = $(BUILT_SOURCES)
# and deleted by the clean targets
CLEANFILES = $(BUILT_SOURCES)
CLEAN_LOCAL =
if MINGW32
if HAVE_WINDRES
.rc.o:
$(WINDRES) -I$(srcdir)/include -I$(srcdir)/../data/win32 $< -O coff $@
endif
endif
install-data-local:
if test -f $(srcdir)/../data/flrig.xpm; then \
$(mkinstalldirs) $(DESTDIR)/$(datadir)/pixmaps; \
$(INSTALL_DATA) $(srcdir)/../data/flrig.xpm $(DESTDIR)/$(datadir)/pixmaps; \
fi
if test -f $(srcdir)/../data/flrig.desktop; then \
$(mkinstalldirs) $(DESTDIR)/$(datadir)/applications; \
$(INSTALL_DATA) $(srcdir)/../data/flrig.desktop $(DESTDIR)/$(datadir)/applications; \
fi
uninstall-local:
rm -f $(DESTDIR)/$(datadir)/pixmaps/flrig.xpm
rm -f $(DESTDIR)/$(datadir)/applications/flrig.desktop
INSTALLER_FILE = flrig-$(FLRIG_VERSION)_setup.exe
APPBUNDLE=flrig-$(FLRIG_VERSION)
APPBUNDLE_NOLIBS=$(APPBUNDLE)-nolibs
if HAVE_NSIS
nsisinst: $(bin_PROGRAMS)
sh $(srcdir)/../scripts/mknsisinst.sh "$(srcdir)/../data" .
CLEANFILES += $(INSTALLER_FILE)
endif
if DARWIN
appbundle: $(bin_PROGRAMS)
sh $(srcdir)/../scripts/mkappbundle.sh "$(srcdir)/../data" .
CLEAN_LOCAL += $(APPBUNDLE_NOLIBS) $(APPBUNDLE) $(APPBUNDLE)*.dmg
endif
clean-local:
-rm -rf $(CLEAN_LOCAL)
# Sources that we build. It is OK to have headers here.
flrig_SOURCES += \
rigs/rigbase.cxx \
rigs/rigs.cxx \
rigs/elad/FDMDUO.cxx \
rigs/elecraft/K2.cxx \
rigs/elecraft/K3.cxx \
rigs/elecraft/KX3.cxx \
rigs/elecraft/K4.cxx \
rigs/icom/ICbase.cxx \
rigs/icom/IC703.cxx \
rigs/icom/IC705.cxx \
rigs/icom/IC706MKIIG.cxx \
rigs/icom/IC718.cxx \
rigs/icom/IC728.cxx \
rigs/icom/IC735.cxx \
rigs/icom/IC746.cxx \
rigs/icom/IC751.cxx \
rigs/icom/IC756.cxx \
rigs/icom/IC756PRO2.cxx \
rigs/icom/IC756PRO3.cxx \
rigs/icom/IC910.cxx \
rigs/icom/IC7000.cxx \
rigs/icom/IC7100.cxx \
rigs/icom/IC7200.cxx \
rigs/icom/IC7300.cxx \
rigs/icom/IC7410.cxx \
rigs/icom/IC7600.cxx \
rigs/icom/IC7610.cxx \
rigs/icom/IC7800.cxx \
rigs/icom/IC7851.cxx \
rigs/icom/IC9100.cxx \
rigs/icom/IC9700.cxx \
rigs/icom/IC7700.cxx \
rigs/icom/ICF8101.cxx \
rigs/icom/ICR71.cxx \
rigs/kenwood/KENWOOD.cxx \
rigs/kenwood/TS140.cxx \
rigs/kenwood/TS440.cxx \
rigs/kenwood/TS450S.cxx \
rigs/kenwood/TS480HX.cxx \
rigs/kenwood/TS480SAT.cxx \
rigs/kenwood/TS570.cxx \
rigs/kenwood/TS590S.cxx \
rigs/kenwood/TS590SG.cxx \
rigs/kenwood/TS790.cxx \
rigs/kenwood/TS850.cxx \
rigs/kenwood/TS870S.cxx \
rigs/kenwood/TS890S.cxx \
rigs/kenwood/TS940S.cxx \
rigs/kenwood/TS950.cxx \
rigs/kenwood/TS990.cxx \
rigs/kenwood/TS2000.cxx \
rigs/lab599/TX500.cxx \
rigs/other/AOR5K.cxx \
rigs/other/FLEX1500.cxx \
rigs/other/PCR1000.cxx \
rigs/other/PowerSDR.cxx \
rigs/other/RAY152.cxx \
rigs/other/SmartSDR.cxx \
rigs/other/sunsdr2.cxx \
rigs/other/tcisdr.cxx \
rigs/other/trusdx.cxx \
rigs/other/TMD710.cxx \
rigs/qrp_labs/QCXplus.cxx \
rigs/qrp_labs/QDX.cxx \
rigs/qrp_labs/QMX.cxx \
rigs/tentec/TT516.cxx \
rigs/tentec/DELTA-II.cxx \
rigs/tentec/TT538.cxx \
rigs/tentec/TT550.cxx \
rigs/tentec/TT563.cxx \
rigs/tentec/TT566.cxx \
rigs/tentec/TT588.cxx \
rigs/tentec/TT599.cxx \
rigs/xiegu/Xiegu-5105.cxx \
rigs/xiegu/Xiegu-G90.cxx \
rigs/xiegu/X6100.cxx \
rigs/yaesu/FT100D.cxx \
rigs/yaesu/FT450.cxx \
rigs/yaesu/FT450D.cxx \
rigs/yaesu/FT710.cxx \
rigs/yaesu/FT736R.cxx \
rigs/yaesu/FT747.cxx \
rigs/yaesu/FT757GX2.cxx \
rigs/yaesu/FT767.cxx \
rigs/yaesu/FT817.cxx \
rigs/yaesu/FT817BB.cxx \
rigs/yaesu/FT818.cxx \
rigs/yaesu/FT847.cxx \
rigs/yaesu/FT857D.cxx \
rigs/yaesu/FT890.cxx \
rigs/yaesu/FT891.cxx \
rigs/yaesu/FT900.cxx \
rigs/yaesu/FT920.cxx \
rigs/yaesu/FT950.cxx \
rigs/yaesu/FT990.cxx \
rigs/yaesu/FT990a.cxx \
rigs/yaesu/FT991.cxx \
rigs/yaesu/FT991A.cxx \
rigs/yaesu/FT1000.cxx \
rigs/yaesu/FT1000MP.cxx \
rigs/yaesu/FT1000MP_A.cxx \
rigs/yaesu/FT2000.cxx \
rigs/yaesu/FTdx101D.cxx \
rigs/yaesu/FTdx10.cxx \
rigs/yaesu/FTdx1200.cxx \
rigs/yaesu/FTdx3000.cxx \
rigs/yaesu/FT5000.cxx \
rigs/yaesu/FTdx9000.cxx \
support/debug.cxx \
support/dialogs.cxx \
support/gpio_ptt.cxx \
support/ptt.cxx \
support/rig_io.cxx \
support/serial.cxx \
support/socket.cxx \
support/socket_io.cxx \
support/status.cxx \
support/support.cxx \
support/read_rig.cxx \
support/restore_rig.cxx \
support/init_rig.cxx \
support/TT550_support.cxx \
support/init_user_interface.cxx \
support/threads.cxx \
support/timeops.cxx \
support/trace.cxx \
support/util.cxx \
wc/tci_io.cxx \
wc/WSclient.cxx \
UI/K3_ui.cxx \
UI/KX3_ui.cxx \
UI/K4_ui.cxx \
UI/rigpanel.cxx \
UI/meters_dialog.cxx \
widgets/combo.cxx \
widgets/Fl_SigBar.cxx \
widgets/flbrowser2.cxx \
widgets/flinput2.cxx \
widgets/flslider2.cxx \
widgets/font_browser.cxx \
widgets/FreqControl.cxx \
widgets/pl_tones.cxx \
widgets/ValueSlider.cxx \
widgets/hspinner.cxx \
support/tod_clock.cxx \
server/xml_server.cxx \
server/xmlrpc_rig.cxx \
cwio/cwio.cxx \
cwio/morse.cxx \
cwio/cwioUI.cxx \
cwio/precise_time.cxx \
cmedia/cmedia.cxx \
cmedia/hid.cxx \
cmedia/tmate2.cxx \
fskio/fsk.cxx \
fskio/fskioUI.cxx \
log/cwlog.cxx \
log/fsklog.cxx \
graphics/pixmaps.cxx \
graphics/icons.cxx \
graphics/images.cxx \
main.cxx
# Additional source files that are distributed
EXTRA_DIST = \
config.h \
flrig_icon.cxx \
cmedia/hid_lin.cxx \
cmedia/hid_mac.cxx \
cmedia/hid_win.cxx \
UI/ui_bitmaps.cxx \
UI/gpio.cxx \
UI/ui_wide.cxx \
UI/ui_small.cxx \
UI/ui_touch.cxx \
UI/ui_setup.cxx \
UI/ui_memory.cxx \
UI/xcvr_setup.cxx \
UI/meters_setup.cxx \
UI/power_meter_setup.cxx \
include/cmedia.h \
include/hid_lin.h \
include/hid_mac.h \
include/hid_win.h \
include/hidapi.h \
include/tmate2.h \
include/cwio.h \
include/cwlog.h \
include/cwioUI.h \
include/fsk.h \
include/fskioUI.h \
include/fsklog.h \
include/gpio.h \
include/gpio_ptt.h \
include/morse.h \
include/debug.h \
include/dialogs.h \
include/flbrowser2.h \
include/flinput2.h \
include/flslider2.h \
include/fileselect.h \
include/font_browser.h \
include/flrigrc.h \
include/icons.h \
include/kenwood/KENWOOD.h \
include/pixmaps.h \
include/Fl_SigBar.h \
include/FreqControl.h \
include/hspinner.h \
include/other/AOR5K.h \
include/other/sunsdr2.h \
include/other/tcisdr.h \
include/other/trusdx.h \
include/generic.h \
include/gettext.h \
include/hidapi.h \
include/hid_mac.h \
include/hid_win.h \
include/xmlrpc_rig.h \
include/elad/FDMDUO.h \
include/icom/ICbase.h \
include/icom/IC703.h \
include/icom/IC705.h \
include/icom/IC706MKIIG.h \
include/icom/IC718.h \
include/icom/IC728.h \
include/icom/IC735.h \
include/icom/IC746.h \
include/icom/IC751.h \
include/icom/IC756.h \
include/icom/IC756PRO2.h \
include/icom/IC756PRO3.h \
include/icom/IC910.h \
include/icom/IC7000.h \
include/icom/IC7100.h \
include/icom/IC7410.h \
include/icom/IC7200.h \
include/icom/IC7300.h \
include/icom/IC7600.h \
include/icom/IC7610.h \
include/icom/IC7700.h \
include/icom/IC7800.h \
include/icom/IC7851.h \
include/icom/IC9100.h \
include/icom/IC9700.h \
include/icom/ICF8101.h \
include/icom/ICR71.h \
include/images.h \
include/elecraft/K2.h \
include/elecraft/K3.h \
include/elecraft/K4.h \
include/K3_ui.h \
include/elecraft/KX3.h \
include/KX3_ui.h \
include/K4_ui.h \
include/mingw.h \
include/other/FLEX1500.h \
include/other/PCR1000.h \
include/other/RAY152.h \
include/other/PowerSDR.h \
include/other/SmartSDR.h \
include/other/TMD710.h \
include/pl_tones.h \
include/ptt.h \
include/qrp_labs/QCXplus.h \
include/qrp_labs/QDX.h \
include/qrp_labs/QMX.h \
include/rig.h \
include/rigs.h \
include/rigbase.h \
include/rig_io.h \
include/rigpanel.h \
include/serial.h \
include/socket.h \
include/socket_io.h \
include/status.h \
include/support.h \
include/threads.h \
include/trace.h \
include/lab599/TX500.h \
include/kenwood/KENWOOD.h \
include/kenwood/TS140.h \
include/kenwood/TS440.h \
include/kenwood/TS450S.h \
include/kenwood/TS480HX.h \
include/kenwood/TS480SAT.h \
include/kenwood/TS570.h \
include/kenwood/TS590S.h \
include/kenwood/TS590SG.h \
include/kenwood/TS790.h \
include/kenwood/TS850.h \
include/kenwood/TS870S.h \
include/kenwood/TS890S.h \
include/kenwood/TS940S.h \
include/kenwood/TS950.h \
include/kenwood/TS990.h \
include/kenwood/TS2000.h \
include/tentec/DELTA-II.h \
include/tentec/TT516.h \
include/tentec/TT538.h \
include/tentec/TT550.h \
include/tentec/TT563.h \
include/tentec/TT566.h \
include/tentec/TT588.h \
include/tentec/TT599.h \
include/tci_io.h \
include/WSclient.h \
include/timeops.h \
include/tod_clock.h \
include/ui.h \
include/util.h \
include/ValueSlider.h \
include/xml_server.h \
include/xiegu/Xiegu-5105.h \
include/xiegu/Xiegu-G90.h \
include/xiegu/X6100.h \
include/yaesu/FT100D.h \
include/yaesu/FT450.h \
include/yaesu/FT450D.h \
include/yaesu/FT710.h \
include/yaesu/FT736R.h \
include/yaesu/FT747.h \
include/yaesu/FT757GX2.h \
include/yaesu/FT767.h \
include/yaesu/FT817.h \
include/yaesu/FT817BB.h \
include/yaesu/FT818.h \
include/yaesu/FT847.h \
include/yaesu/FT857D.h \
include/yaesu/FT920.h \
include/yaesu/FT890.h \
include/yaesu/FT891.h \
include/yaesu/FT900.h \
include/yaesu/FT950.h \
include/yaesu/FT990.h \
include/yaesu/FT990a.h \
include/yaesu/FT991.h \
include/yaesu/FT991A.h \
include/yaesu/FT1000.h \
include/yaesu/FT1000MP.h \
include/yaesu/FT1000MP_A.h \
include/yaesu/FT2000.h \
include/yaesu/FTdx10.h \
include/yaesu/FTdx101D.h \
include/yaesu/FTdx1200.h \
include/yaesu/FTdx3000.h \
include/yaesu/FT5000.h \
include/yaesu/FTdx9000.h \
include/combo.h \
images/alc.xbm \
images/alc40db.xbm \
images/P5.xbm \
images/P10.xbm \
images/P15.xbm \
images/P20.xbm \
images/P25.xbm \
images/P50.xbm \
images/P100.xbm \
images/P200.xbm \
images/P200log.xbm \
images/S60.xbm \
images/SWR.xbm \
images/volts.xbm \
images/volts13.xbm \
images/volts50.xbm \
images/idd25.xbm \
images/idd50.xbm \
cwio/cwioUI.fl \
fskio/fskioUI.fl
# Additional non-source files that are distributed
# Additional source files that support non-Linux cross compilation
EXTRA_DIST += \
$(srcdir)/../data/flrig.desktop \
$(srcdir)/../data/flrig.xpm \
$(srcdir)/../data/win32/fl_app.nsi \
$(srcdir)/../data/win32/flrig.ico \
$(srcdir)/../scripts/mknsisinst.sh \
$(srcdir)/../scripts/buildmxe.sh \
$(srcdir)/../scripts/builddist.sh \
$(srcdir)/../data/mac/Info.plist.in \
$(srcdir)/../data/mac/flrig.icns \
$(srcdir)/../scripts/mkappbundle.sh \
$(FLRIG_WIN32_SRC) \
$(FLRIG_FL_SRC)
flrig-2.0.04/src/images/ 0000775 0001750 0001750 00000000000 14511461606 011743 5 0000000 0000000 flrig-2.0.04/src/images/volts.xbm 0000664 0001750 0001750 00000005705 14475136651 013561 0000000 0000000 #define volts_width 205
#define volts_height 18
static unsigned char volts_bits[] = {
0xfc, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
0xff, 0x07, 0x54, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55,
0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55,
0x55, 0x55, 0x55, 0x05, 0x54, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55,
0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55,
0x55, 0x55, 0x55, 0x55, 0x55, 0x05, 0x04, 0x10, 0x40, 0x00, 0x01, 0x04,
0x10, 0x40, 0x00, 0x01, 0x04, 0x10, 0x40, 0x00, 0x01, 0x04, 0x10, 0x40,
0x00, 0x01, 0x04, 0x10, 0x40, 0x00, 0x01, 0x04, 0x04, 0x10, 0x40, 0x00,
0x01, 0x04, 0x10, 0x40, 0x00, 0x01, 0x04, 0x10, 0x40, 0x00, 0x01, 0x04,
0x10, 0x40, 0x00, 0x01, 0x04, 0x10, 0x40, 0x00, 0x01, 0x04, 0x04, 0x00,
0x40, 0x00, 0x00, 0x04, 0x00, 0x40, 0x00, 0x00, 0x04, 0x00, 0x40, 0x00,
0x00, 0x04, 0x00, 0x40, 0x00, 0x00, 0x04, 0x00, 0x40, 0x00, 0x00, 0x04,
0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x40, 0x00, 0x00, 0x04, 0x00,
0x40, 0x00, 0x00, 0x04, 0x00, 0x40, 0x00, 0x00, 0x04, 0x00, 0x40, 0x00,
0x00, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x44, 0x00, 0x00, 0x00, 0x00, 0x0f, 0x00, 0x00,
0x00, 0x80, 0x70, 0x00, 0x00, 0x00, 0x80, 0x38, 0x00, 0x00, 0x00, 0x00,
0x41, 0x00, 0x00, 0x00, 0x00, 0x00, 0x44, 0x46, 0x3e, 0x03, 0x80, 0x10,
0x00, 0x00, 0x00, 0xc0, 0x88, 0x00, 0x00, 0x00, 0xc0, 0x44, 0x00, 0x00,
0x00, 0x80, 0x61, 0x00, 0x00, 0x00, 0x00, 0x00, 0x44, 0x49, 0x88, 0x04,
0x80, 0x10, 0x00, 0x00, 0x00, 0x80, 0x88, 0x00, 0x00, 0x00, 0x80, 0x44,
0x00, 0x00, 0x00, 0x00, 0x51, 0x00, 0x00, 0x00, 0x00, 0x00, 0x28, 0x49,
0x88, 0x00, 0x00, 0x0f, 0x00, 0x00, 0x00, 0x80, 0x88, 0x00, 0x00, 0x00,
0x80, 0x40, 0x00, 0x00, 0x00, 0x00, 0x51, 0x00, 0x00, 0x00, 0x00, 0x00,
0x28, 0x49, 0x08, 0x01, 0x80, 0x10, 0x00, 0x00, 0x00, 0x80, 0x88, 0x00,
0x00, 0x00, 0x80, 0x30, 0x00, 0x00, 0x00, 0x00, 0x49, 0x00, 0x00, 0x00,
0x00, 0x00, 0x28, 0x49, 0x08, 0x02, 0x80, 0x10, 0x00, 0x00, 0x00, 0x80,
0x88, 0x00, 0x00, 0x00, 0x80, 0x18, 0x00, 0x00, 0x00, 0x00, 0x45, 0x00,
0x00, 0x00, 0x00, 0x00, 0x10, 0x49, 0x08, 0x04, 0x80, 0x10, 0x00, 0x00,
0x00, 0x80, 0x88, 0x00, 0x00, 0x00, 0x80, 0x08, 0x00, 0x00, 0x00, 0x00,
0x7d, 0x00, 0x00, 0x00, 0x00, 0x00, 0x10, 0x4d, 0x88, 0x04, 0x80, 0x10,
0x00, 0x00, 0x00, 0x80, 0x88, 0x00, 0x00, 0x00, 0x80, 0x04, 0x00, 0x00,
0x00, 0x00, 0x41, 0x00, 0x00, 0x00, 0x00, 0x00, 0x10, 0xc6, 0x09, 0x03,
0x00, 0x0f, 0x00, 0x00, 0x00, 0x80, 0x70, 0x00, 0x00, 0x00, 0x80, 0x7c,
0x00, 0x00, 0x00, 0x00, 0x41, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 };
flrig-2.0.04/src/images/P25.xbm 0000664 0001750 0001750 00000005677 14475136651 012770 0000000 0000000 #define P25_width 205
#define P25_height 18
static unsigned char P25_bits[] = {
0xfc, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
0xff, 0x07, 0x44, 0x44, 0x44, 0x44, 0x44, 0x44, 0x44, 0x44, 0x44, 0x44,
0x44, 0x44, 0x44, 0x44, 0x44, 0x44, 0x44, 0x44, 0x44, 0x44, 0x44, 0x44,
0x44, 0x44, 0x44, 0x04, 0x44, 0x44, 0x44, 0x44, 0x44, 0x44, 0x44, 0x44,
0x44, 0x44, 0x44, 0x44, 0x44, 0x44, 0x44, 0x44, 0x44, 0x44, 0x44, 0x44,
0x44, 0x44, 0x44, 0x44, 0x44, 0x04, 0x04, 0x00, 0x40, 0x00, 0x00, 0x04,
0x00, 0x40, 0x00, 0x00, 0x04, 0x00, 0x40, 0x00, 0x00, 0x04, 0x00, 0x40,
0x00, 0x00, 0x04, 0x00, 0x40, 0x00, 0x00, 0x04, 0x04, 0x00, 0x40, 0x00,
0x00, 0x04, 0x00, 0x40, 0x00, 0x00, 0x04, 0x00, 0x40, 0x00, 0x00, 0x04,
0x00, 0x40, 0x00, 0x00, 0x04, 0x00, 0x40, 0x00, 0x00, 0x04, 0x04, 0x00,
0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00,
0x00, 0x04, 0x00, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00, 0x04,
0x04, 0x00, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00, 0x04, 0x00,
0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00,
0x00, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x1f, 0x00, 0x00,
0x00, 0x80, 0x71, 0x00, 0x00, 0x00, 0x00, 0xf9, 0x00, 0x00, 0x00, 0xc0,
0x71, 0x00, 0x00, 0x00, 0x00, 0x00, 0xf0, 0x00, 0x00, 0x00, 0x00, 0x01,
0x00, 0x00, 0x00, 0xc0, 0x89, 0x00, 0x00, 0x00, 0xc0, 0x09, 0x00, 0x00,
0x00, 0x20, 0x8a, 0x00, 0x00, 0x00, 0x00, 0x00, 0x10, 0x01, 0x00, 0x00,
0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x89, 0x00, 0x00, 0x00, 0x00, 0x09,
0x00, 0x00, 0x00, 0x00, 0x8a, 0x00, 0x00, 0x00, 0x00, 0x00, 0x10, 0x01,
0x00, 0x00, 0x00, 0x0f, 0x00, 0x00, 0x00, 0x00, 0x89, 0x00, 0x00, 0x00,
0x00, 0x79, 0x00, 0x00, 0x00, 0x00, 0x8a, 0x00, 0x00, 0x00, 0x00, 0x00,
0x10, 0x01, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x00, 0x89, 0x00,
0x00, 0x00, 0x00, 0x81, 0x00, 0x00, 0x00, 0x00, 0x89, 0x00, 0x00, 0x00,
0x00, 0x00, 0xf0, 0x0c, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x00,
0x89, 0x00, 0x00, 0x00, 0x00, 0x81, 0x00, 0x00, 0x00, 0x80, 0x88, 0x00,
0x00, 0x00, 0x00, 0x00, 0x10, 0x12, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00,
0x00, 0x00, 0x89, 0x00, 0x00, 0x00, 0x00, 0x81, 0x00, 0x00, 0x00, 0x40,
0x88, 0x00, 0x00, 0x00, 0x00, 0x00, 0x10, 0x12, 0x00, 0x00, 0x00, 0x11,
0x00, 0x00, 0x00, 0x00, 0x89, 0x00, 0x00, 0x00, 0x00, 0x89, 0x00, 0x00,
0x00, 0x20, 0x88, 0x00, 0x00, 0x00, 0x00, 0x00, 0x10, 0x0c, 0x00, 0x00,
0x00, 0x0e, 0x00, 0x00, 0x00, 0x00, 0x71, 0x00, 0x00, 0x00, 0x00, 0x71,
0x00, 0x00, 0x00, 0xe0, 0x73, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 };
flrig-2.0.04/src/images/idd50.xbm 0000664 0001750 0001750 00000004674 14475136651 013323 0000000 0000000 #define idd50_width 205
#define idd50_height 18
static unsigned char idd50_bits[] = {
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x74,0x1c,0x00,0x00,
0x00,0x39,0x00,0x00,0x00,0xc0,0x71,0x00,0x00,0x00,0xc0,0x71,0x00,0x00,0x00,
0x00,0x72,0x00,0x00,0x00,0x00,0x00,0x94,0x24,0x00,0x00,0xc0,0x45,0x00,0x00,
0x00,0x20,0x8a,0x00,0x00,0x00,0x20,0x8a,0x00,0x00,0x00,0x00,0x8b,0x00,0x00,
0x00,0x00,0x00,0x14,0x45,0x00,0x00,0x00,0x45,0x00,0x00,0x00,0x00,0x8a,0x00,
0x00,0x00,0x00,0x8a,0x00,0x00,0x00,0x80,0x8a,0x00,0x00,0x00,0x00,0x00,0x14,
0x45,0x00,0x00,0x00,0x45,0x00,0x00,0x00,0x00,0x8a,0x00,0x00,0x00,0x00,0x8a,
0x00,0x00,0x00,0x80,0x8a,0x00,0x00,0x00,0x00,0x00,0x14,0x45,0x00,0x00,0x00,
0x45,0x00,0x00,0x00,0x00,0x89,0x00,0x00,0x00,0x80,0x89,0x00,0x00,0x00,0x40,
0x8a,0x00,0x00,0x00,0x00,0x00,0x14,0x45,0x00,0x00,0x00,0x45,0x00,0x00,0x00,
0x80,0x88,0x00,0x00,0x00,0x00,0x8a,0x00,0x00,0x00,0xc0,0x8b,0x00,0x00,0x00,
0x00,0x00,0x14,0x45,0x00,0x00,0x00,0x45,0x00,0x00,0x00,0x40,0x88,0x00,0x00,
0x00,0x00,0x8a,0x00,0x00,0x00,0x00,0x8a,0x00,0x00,0x00,0x00,0x00,0x94,0x24,
0x00,0x00,0x00,0x45,0x00,0x00,0x00,0x20,0x88,0x00,0x00,0x00,0x20,0x8a,0x00,
0x00,0x00,0x00,0x8a,0x00,0x00,0x00,0x00,0x00,0x74,0x1c,0x00,0x00,0x00,0x39,
0x00,0x00,0x00,0xe0,0x73,0x00,0x00,0x00,0xc0,0x71,0x00,0x00,0x00,0x00,0x72,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x04,0x00,0x00,0x00,0x00,0x04,0x00,0x00,0x00,0x00,0x04,0x00,0x00,0x00,
0x00,0x04,0x00,0x00,0x00,0x00,0x04,0x00,0x00,0x00,0x00,0x04,0x04,0x00,0x40,
0x00,0x00,0x04,0x00,0x40,0x00,0x00,0x04,0x00,0x40,0x00,0x00,0x04,0x00,0x40,
0x00,0x00,0x04,0x00,0x40,0x00,0x00,0x04,0x04,0x00,0x40,0x00,0x00,0x04,0x00,
0x40,0x00,0x00,0x04,0x00,0x40,0x00,0x00,0x04,0x00,0x40,0x00,0x00,0x04,0x00,
0x40,0x00,0x00,0x04,0x04,0x00,0x40,0x00,0x00,0x04,0x00,0x40,0x00,0x00,0x04,
0x00,0x40,0x00,0x00,0x04,0x00,0x40,0x00,0x00,0x04,0x00,0x40,0x00,0x00,0x04,
0x44,0x44,0x44,0x44,0x44,0x44,0x44,0x44,0x44,0x44,0x44,0x44,0x44,0x44,0x44,
0x44,0x44,0x44,0x44,0x44,0x44,0x44,0x44,0x44,0x44,0x04,0x44,0x44,0x44,0x44,
0x44,0x44,0x44,0x44,0x44,0x44,0x44,0x44,0x44,0x44,0x44,0x44,0x44,0x44,0x44,
0x44,0x44,0x44,0x44,0x44,0x44,0x04,0xfc,0xff,0xff,0xff,0xff,0xff,0xff,0xff,
0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,
0xff,0xff,0x07 };
flrig-2.0.04/src/images/SWR.xbm 0000664 0001750 0001750 00000005677 14475136651 013075 0000000 0000000 #define SWR_width 205
#define SWR_height 18
static unsigned char SWR_bits[] = {
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x80, 0xf0, 0x01, 0x00, 0x0e, 0x00, 0x00, 0x00,
0x00, 0x00, 0x0e, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x70, 0x00, 0xc0, 0x10, 0x00, 0x00, 0x11, 0x00,
0x00, 0x00, 0x00, 0x00, 0x11, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x88, 0x00, 0x80, 0x10, 0x00, 0x00,
0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x00, 0x80, 0xf0,
0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x70, 0xa2,
0x82, 0x00, 0x01, 0x00, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0c, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x80, 0xa2, 0x85, 0x00, 0x01, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00,
0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x80, 0xaa, 0x80, 0x00, 0x01, 0x00, 0x02, 0x00, 0x00, 0x00,
0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x88, 0xaa, 0x80, 0x10, 0x01, 0x00, 0x01, 0x00,
0x00, 0x00, 0x00, 0x00, 0x11, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x70, 0x94, 0x80, 0xe4, 0x00, 0x00,
0x1f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0e, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0xc0, 0x7b, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x20, 0x84, 0x00, 0x04, 0x00,
0x00, 0x04, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x04, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x20, 0x84, 0x00,
0x04, 0x00, 0x00, 0x04, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00,
0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xc0,
0x7b, 0x00, 0x04, 0x00, 0x00, 0x04, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00,
0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x24, 0x49, 0x92, 0x24, 0x49, 0x92, 0x04, 0x41,
0x10, 0x04, 0x41, 0x10, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x24, 0x49, 0x92, 0x24, 0x49, 0x92,
0x04, 0x41, 0x10, 0x04, 0x41, 0x10, 0x44, 0x44, 0x44, 0x44, 0x44, 0x44,
0x44, 0x44, 0x44, 0x44, 0x44, 0x44, 0x44, 0x04, 0x24, 0x49, 0x92, 0x24,
0x49, 0x92, 0x04, 0x41, 0x10, 0x04, 0x41, 0x10, 0x44, 0x44, 0x44, 0x44,
0x44, 0x44, 0x44, 0x44, 0x44, 0x44, 0x44, 0x44, 0x44, 0x04, 0xfc, 0xff,
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x07 };
flrig-2.0.04/src/images/P50.xbm 0000664 0001750 0001750 00000005677 14475136651 012766 0000000 0000000 #define P50_width 205
#define P50_height 18
static unsigned char P50_bits[] = {
0xfc, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
0xff, 0x07, 0x44, 0x44, 0x44, 0x44, 0x44, 0x44, 0x44, 0x44, 0x44, 0x44,
0x44, 0x44, 0x44, 0x44, 0x44, 0x44, 0x44, 0x44, 0x44, 0x44, 0x44, 0x44,
0x44, 0x44, 0x44, 0x04, 0x44, 0x44, 0x44, 0x44, 0x44, 0x44, 0x44, 0x44,
0x44, 0x44, 0x44, 0x44, 0x44, 0x44, 0x44, 0x44, 0x44, 0x44, 0x44, 0x44,
0x44, 0x44, 0x44, 0x44, 0x44, 0x04, 0x04, 0x00, 0x40, 0x00, 0x00, 0x04,
0x00, 0x40, 0x00, 0x00, 0x04, 0x00, 0x40, 0x00, 0x00, 0x04, 0x00, 0x40,
0x00, 0x00, 0x04, 0x00, 0x40, 0x00, 0x00, 0x04, 0x04, 0x00, 0x40, 0x00,
0x00, 0x04, 0x00, 0x40, 0x00, 0x00, 0x04, 0x00, 0x40, 0x00, 0x00, 0x04,
0x00, 0x40, 0x00, 0x00, 0x04, 0x00, 0x40, 0x00, 0x00, 0x04, 0x04, 0x00,
0x40, 0x00, 0x00, 0x04, 0x00, 0x40, 0x00, 0x00, 0x04, 0x00, 0x40, 0x00,
0x00, 0x04, 0x00, 0x40, 0x00, 0x00, 0x04, 0x00, 0x40, 0x00, 0x00, 0x04,
0x04, 0x00, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00, 0x04, 0x00,
0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00,
0x00, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x71, 0x00, 0x00,
0x00, 0xc0, 0x71, 0x00, 0x00, 0x00, 0xc0, 0x71, 0x00, 0x00, 0x00, 0x00,
0x71, 0x00, 0x00, 0x00, 0x00, 0x00, 0xf0, 0x00, 0x00, 0x00, 0xc0, 0x89,
0x00, 0x00, 0x00, 0x20, 0x8a, 0x00, 0x00, 0x00, 0x20, 0x8a, 0x00, 0x00,
0x00, 0x80, 0x89, 0x00, 0x00, 0x00, 0x00, 0x00, 0x10, 0x01, 0x00, 0x00,
0x00, 0x89, 0x00, 0x00, 0x00, 0x00, 0x8a, 0x00, 0x00, 0x00, 0x00, 0x8a,
0x00, 0x00, 0x00, 0x40, 0x89, 0x00, 0x00, 0x00, 0x00, 0x00, 0x10, 0x01,
0x00, 0x00, 0x00, 0x89, 0x00, 0x00, 0x00, 0x00, 0x8a, 0x00, 0x00, 0x00,
0x00, 0x8a, 0x00, 0x00, 0x00, 0x40, 0x89, 0x00, 0x00, 0x00, 0x00, 0x00,
0x10, 0x01, 0x00, 0x00, 0x00, 0x89, 0x00, 0x00, 0x00, 0x00, 0x89, 0x00,
0x00, 0x00, 0x80, 0x89, 0x00, 0x00, 0x00, 0x20, 0x89, 0x00, 0x00, 0x00,
0x00, 0x00, 0xf0, 0x0c, 0x00, 0x00, 0x00, 0x89, 0x00, 0x00, 0x00, 0x80,
0x88, 0x00, 0x00, 0x00, 0x00, 0x8a, 0x00, 0x00, 0x00, 0xe0, 0x8b, 0x00,
0x00, 0x00, 0x00, 0x00, 0x10, 0x12, 0x00, 0x00, 0x00, 0x89, 0x00, 0x00,
0x00, 0x40, 0x88, 0x00, 0x00, 0x00, 0x00, 0x8a, 0x00, 0x00, 0x00, 0x00,
0x89, 0x00, 0x00, 0x00, 0x00, 0x00, 0x10, 0x12, 0x00, 0x00, 0x00, 0x89,
0x00, 0x00, 0x00, 0x20, 0x88, 0x00, 0x00, 0x00, 0x20, 0x8a, 0x00, 0x00,
0x00, 0x00, 0x89, 0x00, 0x00, 0x00, 0x00, 0x00, 0x10, 0x0c, 0x00, 0x00,
0x00, 0x71, 0x00, 0x00, 0x00, 0xe0, 0x73, 0x00, 0x00, 0x00, 0xc0, 0x71,
0x00, 0x00, 0x00, 0x00, 0x71, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 };
flrig-2.0.04/src/images/P200log.xbm 0000664 0001750 0001750 00000005713 14475136651 013534 0000000 0000000 #define P200log_width 205
#define P200log_height 18
static unsigned char P200log_bits[] = {
0xfc, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
0xff, 0x07, 0x04, 0x00, 0x41, 0x44, 0x04, 0x82, 0x10, 0x22, 0x02, 0x82,
0x20, 0x08, 0x42, 0x00, 0x01, 0x01, 0x01, 0x81, 0x40, 0x20, 0x08, 0x82,
0x20, 0x84, 0x20, 0x04, 0x04, 0x00, 0x41, 0x44, 0x04, 0x82, 0x10, 0x22,
0x02, 0x82, 0x20, 0x08, 0x42, 0x00, 0x01, 0x01, 0x01, 0x81, 0x40, 0x20,
0x08, 0x82, 0x20, 0x84, 0x20, 0x04, 0x04, 0x00, 0x41, 0x44, 0x04, 0x82,
0x10, 0x22, 0x02, 0x82, 0x20, 0x08, 0x42, 0x00, 0x01, 0x01, 0x01, 0x81,
0x40, 0x20, 0x08, 0x82, 0x20, 0x84, 0x20, 0x04, 0x04, 0x00, 0x41, 0x44,
0x04, 0x80, 0x00, 0x02, 0x02, 0x80, 0x00, 0x08, 0x40, 0x00, 0x01, 0x01,
0x01, 0x81, 0x40, 0x20, 0x08, 0x82, 0x20, 0x84, 0x20, 0x04, 0x04, 0x00,
0x00, 0x00, 0x04, 0x80, 0x00, 0x02, 0x02, 0x80, 0x00, 0x08, 0x40, 0x00,
0x00, 0x00, 0x00, 0x80, 0x00, 0x00, 0x00, 0x80, 0x00, 0x00, 0x00, 0x04,
0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x40, 0x00, 0x00, 0x00, 0x00, 0x80, 0x00, 0x00, 0x00, 0x80, 0x00, 0x00,
0x00, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x1f, 0x00, 0x00, 0xe0,
0x38, 0x00, 0x00, 0x00, 0x3e, 0x07, 0x00, 0x00, 0x00, 0x71, 0x1c, 0x00,
0x00, 0xe4, 0x73, 0x00, 0x00, 0x00, 0xf0, 0x00, 0x00, 0x00, 0x01, 0x00,
0x00, 0x10, 0x45, 0x00, 0x00, 0x00, 0x82, 0x08, 0x00, 0x00, 0xc0, 0x89,
0x22, 0x00, 0x00, 0x27, 0x88, 0x00, 0x00, 0x00, 0x10, 0x01, 0x00, 0x00,
0x01, 0x00, 0x00, 0x00, 0x45, 0x00, 0x00, 0x00, 0x82, 0x08, 0x00, 0x00,
0x00, 0x89, 0x22, 0x00, 0x00, 0x24, 0x88, 0x00, 0x00, 0x00, 0x10, 0x01,
0x00, 0x00, 0x0e, 0x00, 0x00, 0x00, 0x45, 0x00, 0x00, 0x00, 0x9c, 0x08,
0x00, 0x00, 0x00, 0x89, 0x22, 0x00, 0x00, 0xc4, 0x89, 0x00, 0x00, 0x00,
0x10, 0x01, 0x00, 0x00, 0x10, 0x00, 0x00, 0x80, 0x44, 0x00, 0x00, 0x00,
0xa0, 0x08, 0x00, 0x00, 0x00, 0x89, 0x22, 0x00, 0x00, 0x04, 0x8a, 0x00,
0x00, 0x00, 0xf0, 0x0c, 0x00, 0x00, 0x10, 0x00, 0x00, 0x40, 0x44, 0x00,
0x00, 0x00, 0xa0, 0x08, 0x00, 0x00, 0x00, 0x89, 0x22, 0x00, 0x00, 0x04,
0x8a, 0x00, 0x00, 0x00, 0x10, 0x12, 0x00, 0x00, 0x10, 0x00, 0x00, 0x20,
0x44, 0x00, 0x00, 0x00, 0xa0, 0x08, 0x00, 0x00, 0x00, 0x89, 0x22, 0x00,
0x00, 0x04, 0x8a, 0x00, 0x00, 0x00, 0x10, 0x12, 0x00, 0x00, 0x11, 0x00,
0x00, 0x10, 0x44, 0x00, 0x00, 0x00, 0xa2, 0x08, 0x00, 0x00, 0x00, 0x89,
0x22, 0x00, 0x00, 0x24, 0x8a, 0x00, 0x00, 0x00, 0x10, 0x0c, 0x00, 0x00,
0x0e, 0x00, 0x00, 0xf0, 0x39, 0x00, 0x00, 0x00, 0x1c, 0x07, 0x00, 0x00,
0x00, 0x71, 0x1c, 0x00, 0x00, 0xc4, 0x71, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 };
flrig-2.0.04/src/images/P15.xbm 0000664 0001750 0001750 00000004666 14475136651 012764 0000000 0000000 #define P15_width 205
#define P15_height 18
static unsigned char P15_bits[] = {
0xfc,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,
0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0x07,0x44,0x44,0x44,0x44,
0x44,0x44,0x44,0x44,0x44,0x44,0x44,0x44,0x44,0x44,0x44,0x44,0x44,0x44,0x44,
0x44,0x44,0x44,0x44,0x44,0x44,0x04,0x44,0x44,0x44,0x44,0x44,0x44,0x44,0x44,
0x44,0x44,0x44,0x44,0x44,0x44,0x44,0x44,0x44,0x44,0x44,0x44,0x44,0x44,0x44,
0x44,0x44,0x04,0x04,0x40,0x00,0x04,0x40,0x00,0x04,0x40,0x00,0x04,0x40,0x00,
0x04,0x40,0x00,0x04,0x40,0x00,0x04,0x40,0x00,0x04,0x40,0x00,0x04,0x00,0x04,
0x40,0x00,0x04,0x40,0x00,0x04,0x40,0x00,0x04,0x40,0x00,0x04,0x40,0x00,0x04,
0x40,0x00,0x04,0x40,0x00,0x04,0x40,0x00,0x00,0x00,0x04,0x00,0x00,0x00,0x40,
0x00,0x00,0x00,0x00,0x04,0x00,0x00,0x00,0x40,0x00,0x00,0x00,0x00,0x04,0x00,
0x00,0x00,0x40,0x00,0x00,0x00,0x04,0x00,0x00,0x00,0x40,0x00,0x00,0x00,0x00,
0x04,0x00,0x00,0x00,0x40,0x00,0x00,0x00,0x00,0x04,0x00,0x00,0x00,0x40,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0xe0,0x00,0x00,0x00,0x00,0x0e,0x00,0x00,0x00,0xe0,0x00,0x00,0x00,
0x00,0x71,0x00,0x00,0x00,0x90,0x07,0x00,0x00,0xf0,0x00,0x00,0x00,0x10,0x01,
0x00,0x00,0x00,0x11,0x00,0x00,0x00,0x10,0x01,0x00,0x00,0xc0,0x89,0x00,0x00,
0x00,0x9c,0x08,0x00,0x00,0x10,0x01,0x00,0x00,0x00,0x01,0x00,0x00,0x00,0x01,
0x00,0x00,0x00,0x10,0x01,0x00,0x00,0x00,0x81,0x00,0x00,0x00,0x90,0x00,0x00,
0x00,0x10,0x01,0x00,0x00,0xc0,0x00,0x00,0x00,0x00,0x01,0x00,0x00,0x00,0x10,
0x01,0x00,0x00,0x00,0x81,0x00,0x00,0x00,0x90,0x06,0x00,0x00,0x10,0x01,0x00,
0x00,0x00,0x01,0x00,0x00,0x00,0x0f,0x00,0x00,0x00,0xe0,0x01,0x00,0x00,0x00,
0x41,0x00,0x00,0x00,0x90,0x09,0x00,0x00,0xf0,0x0c,0x00,0x00,0x00,0x01,0x00,
0x00,0x00,0x11,0x00,0x00,0x00,0x00,0x01,0x00,0x00,0x00,0x21,0x00,0x00,0x00,
0x10,0x08,0x00,0x00,0x10,0x12,0x00,0x00,0x00,0x01,0x00,0x00,0x00,0x11,0x00,
0x00,0x00,0x00,0x01,0x00,0x00,0x00,0x11,0x00,0x00,0x00,0x10,0x08,0x00,0x00,
0x10,0x12,0x00,0x00,0x10,0x01,0x00,0x00,0x00,0x11,0x00,0x00,0x00,0x10,0x01,
0x00,0x00,0x00,0x09,0x00,0x00,0x00,0x90,0x08,0x00,0x00,0x10,0x0c,0x00,0x00,
0xe0,0x00,0x00,0x00,0x00,0x0e,0x00,0x00,0x00,0xe0,0x00,0x00,0x00,0x00,0xf9,
0x00,0x00,0x00,0x10,0x07,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00 };
flrig-2.0.04/src/images/alc.xbm 0000664 0001750 0001750 00000005677 14475136651 013161 0000000 0000000 #define alc_width 205
#define alc_height 18
static unsigned char alc_bits[] = {
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00,
0x0e, 0x00, 0x00, 0x00, 0x00, 0x0e, 0x00, 0x00, 0x00, 0x00, 0x08, 0x00,
0x00, 0x00, 0x00, 0x00, 0x20, 0x02, 0x07, 0x00, 0x00, 0x07, 0x00, 0x00,
0x00, 0x00, 0x11, 0x00, 0x00, 0x00, 0x00, 0x11, 0x00, 0x00, 0x00, 0x00,
0x0c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x50, 0x82, 0x08, 0x00, 0x00, 0x04,
0x00, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00,
0x00, 0x00, 0x0a, 0x00, 0x00, 0x00, 0x00, 0x00, 0x50, 0x82, 0x00, 0x00,
0x00, 0x04, 0x00, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x00, 0x10,
0x00, 0x00, 0x00, 0x00, 0x0a, 0x00, 0x00, 0x00, 0x00, 0x00, 0x88, 0x82,
0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00,
0x00, 0x0c, 0x00, 0x00, 0x00, 0x00, 0x09, 0x00, 0x00, 0x00, 0x00, 0x00,
0xf8, 0x82, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00, 0x04, 0x00,
0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x00, 0x1f, 0x00, 0x00, 0x00,
0x00, 0x00, 0x88, 0x82, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00,
0x02, 0x00, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x00, 0x08, 0x00,
0x00, 0x00, 0x00, 0x00, 0x88, 0x82, 0x08, 0x00, 0x00, 0x04, 0x00, 0x00,
0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x11, 0x00, 0x00, 0x00, 0x00,
0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x88, 0x3e, 0x07, 0x00, 0x00, 0x04,
0x00, 0x00, 0x00, 0x00, 0x1f, 0x00, 0x00, 0x00, 0x00, 0x0e, 0x00, 0x00,
0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x04, 0x00,
0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00,
0x00, 0x04, 0x00, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00, 0x04,
0x04, 0x00, 0x40, 0x00, 0x00, 0x04, 0x00, 0x40, 0x00, 0x00, 0x04, 0x00,
0x40, 0x00, 0x00, 0x04, 0x00, 0x40, 0x00, 0x00, 0x04, 0x00, 0x40, 0x00,
0x00, 0x04, 0x04, 0x00, 0x40, 0x00, 0x00, 0x04, 0x00, 0x40, 0x00, 0x00,
0x04, 0x00, 0x40, 0x00, 0x00, 0x04, 0x00, 0x40, 0x00, 0x00, 0x04, 0x00,
0x40, 0x00, 0x00, 0x04, 0x04, 0x00, 0x40, 0x00, 0x00, 0x04, 0x00, 0x40,
0x00, 0x00, 0x04, 0x00, 0x40, 0x00, 0x00, 0x04, 0x00, 0x40, 0x00, 0x00,
0x04, 0x00, 0x40, 0x00, 0x00, 0x04, 0x44, 0x44, 0x44, 0x44, 0x44, 0x44,
0x44, 0x44, 0x44, 0x44, 0x44, 0x44, 0x44, 0x44, 0x44, 0x44, 0x44, 0x44,
0x44, 0x44, 0x44, 0x44, 0x44, 0x44, 0x44, 0x04, 0x44, 0x44, 0x44, 0x44,
0x44, 0x44, 0x44, 0x44, 0x44, 0x44, 0x44, 0x44, 0x44, 0x44, 0x44, 0x44,
0x44, 0x44, 0x44, 0x44, 0x44, 0x44, 0x44, 0x44, 0x44, 0x04, 0xfc, 0xff,
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x07 };
flrig-2.0.04/src/images/volts13.xbm 0000664 0001750 0001750 00000005705 14475136651 013725 0000000 0000000 #define volts_width 205
#define volts_height 18
static unsigned char volts_bits[] = {
0xfc, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
0xff, 0x07, 0x54, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55,
0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55,
0x55, 0x55, 0x55, 0x05, 0x54, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55,
0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55,
0x55, 0x55, 0x55, 0x55, 0x55, 0x05, 0x04, 0x10, 0x40, 0x00, 0x01, 0x04,
0x10, 0x40, 0x00, 0x01, 0x04, 0x10, 0x40, 0x00, 0x01, 0x04, 0x10, 0x40,
0x00, 0x01, 0x04, 0x10, 0x40, 0x00, 0x01, 0x04, 0x04, 0x10, 0x40, 0x00,
0x01, 0x04, 0x10, 0x40, 0x00, 0x01, 0x04, 0x10, 0x40, 0x00, 0x01, 0x04,
0x10, 0x40, 0x00, 0x01, 0x04, 0x10, 0x40, 0x00, 0x01, 0x04, 0x04, 0x00,
0x40, 0x00, 0x00, 0x04, 0x00, 0x40, 0x00, 0x00, 0x04, 0x00, 0x40, 0x00,
0x00, 0x04, 0x00, 0x40, 0x00, 0x00, 0x04, 0x00, 0x40, 0x00, 0x00, 0x04,
0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x40, 0x00, 0x00, 0x04, 0x00,
0x40, 0x00, 0x00, 0x04, 0x00, 0x40, 0x00, 0x00, 0x04, 0x00, 0x40, 0x00,
0x00, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x44, 0x00, 0x00, 0x00, 0x80, 0x70, 0x00, 0x00,
0x00, 0x00, 0x71, 0x00, 0x00, 0x00, 0x00, 0x41, 0x00, 0x00, 0x00, 0x00,
0x71, 0x00, 0x00, 0x00, 0x00, 0x00, 0x44, 0x46, 0x3e, 0x03, 0xc0, 0x88,
0x00, 0x00, 0x00, 0x80, 0x89, 0x00, 0x00, 0x00, 0x80, 0x61, 0x00, 0x00,
0x00, 0x80, 0x89, 0x00, 0x00, 0x00, 0x00, 0x00, 0x44, 0x49, 0x88, 0x04,
0x80, 0x88, 0x00, 0x00, 0x00, 0x00, 0x89, 0x00, 0x00, 0x00, 0x00, 0x51,
0x00, 0x00, 0x00, 0x00, 0x09, 0x00, 0x00, 0x00, 0x00, 0x00, 0x28, 0x49,
0x88, 0x00, 0x80, 0x88, 0x00, 0x00, 0x00, 0x00, 0x81, 0x00, 0x00, 0x00,
0x00, 0x51, 0x00, 0x00, 0x00, 0x00, 0x09, 0x00, 0x00, 0x00, 0x00, 0x00,
0x28, 0x49, 0x08, 0x01, 0x80, 0x88, 0x00, 0x00, 0x00, 0x00, 0x61, 0x00,
0x00, 0x00, 0x00, 0x49, 0x00, 0x00, 0x00, 0x00, 0x79, 0x00, 0x00, 0x00,
0x00, 0x00, 0x28, 0x49, 0x08, 0x02, 0x80, 0x88, 0x00, 0x00, 0x00, 0x00,
0x31, 0x00, 0x00, 0x00, 0x00, 0x45, 0x00, 0x00, 0x00, 0x00, 0x89, 0x00,
0x00, 0x00, 0x00, 0x00, 0x10, 0x49, 0x08, 0x04, 0x80, 0x88, 0x00, 0x00,
0x00, 0x00, 0x11, 0x00, 0x00, 0x00, 0x00, 0x7d, 0x00, 0x00, 0x00, 0x00,
0x89, 0x00, 0x00, 0x00, 0x00, 0x00, 0x10, 0x4d, 0x88, 0x04, 0x80, 0x88,
0x00, 0x00, 0x00, 0x00, 0x09, 0x00, 0x00, 0x00, 0x00, 0x41, 0x00, 0x00,
0x00, 0x00, 0x89, 0x00, 0x00, 0x00, 0x00, 0x00, 0x10, 0xc6, 0x09, 0x03,
0x80, 0x70, 0x00, 0x00, 0x00, 0x00, 0xf9, 0x00, 0x00, 0x00, 0x00, 0x41,
0x00, 0x00, 0x00, 0x00, 0x71, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 };
flrig-2.0.04/src/images/P5.xbm 0000664 0001750 0001750 00000005674 14475136651 012703 0000000 0000000 #define P5_width 205
#define P5_height 18
static unsigned char P5_bits[] = {
0xfc, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
0xff, 0x07, 0x44, 0x44, 0x44, 0x44, 0x44, 0x44, 0x44, 0x44, 0x44, 0x44,
0x44, 0x44, 0x44, 0x44, 0x44, 0x44, 0x44, 0x44, 0x44, 0x44, 0x44, 0x44,
0x44, 0x44, 0x44, 0x04, 0x44, 0x44, 0x44, 0x44, 0x44, 0x44, 0x44, 0x44,
0x44, 0x44, 0x44, 0x44, 0x44, 0x44, 0x44, 0x44, 0x44, 0x44, 0x44, 0x44,
0x44, 0x44, 0x44, 0x44, 0x44, 0x04, 0x04, 0x00, 0x40, 0x00, 0x00, 0x04,
0x00, 0x40, 0x00, 0x00, 0x04, 0x00, 0x40, 0x00, 0x00, 0x04, 0x00, 0x40,
0x00, 0x00, 0x04, 0x00, 0x40, 0x00, 0x00, 0x04, 0x04, 0x00, 0x40, 0x00,
0x00, 0x04, 0x00, 0x40, 0x00, 0x00, 0x04, 0x00, 0x40, 0x00, 0x00, 0x04,
0x00, 0x40, 0x00, 0x00, 0x04, 0x00, 0x40, 0x00, 0x00, 0x04, 0x04, 0x00,
0x40, 0x00, 0x00, 0x04, 0x00, 0x40, 0x00, 0x00, 0x04, 0x00, 0x40, 0x00,
0x00, 0x04, 0x00, 0x40, 0x00, 0x00, 0x04, 0x00, 0x40, 0x00, 0x00, 0x04,
0x04, 0x00, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00, 0x04, 0x00,
0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00,
0x00, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xf0, 0x00, 0x00, 0x00, 0x00, 0x06,
0x00, 0x00, 0x00, 0x00, 0x0e, 0x00, 0x00, 0x00, 0x00, 0x0e, 0x00, 0x00,
0x00, 0x00, 0x18, 0x00, 0x00, 0x00, 0x00, 0x00, 0x10, 0x01, 0x00, 0x00,
0x00, 0x07, 0x00, 0x00, 0x00, 0x00, 0x11, 0x00, 0x00, 0x00, 0x00, 0x11,
0x00, 0x00, 0x00, 0x00, 0x14, 0x00, 0x00, 0x00, 0x00, 0x00, 0x10, 0x01,
0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00,
0x00, 0x10, 0x00, 0x00, 0x00, 0x00, 0x12, 0x00, 0x00, 0x00, 0x00, 0x00,
0x10, 0x01, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00, 0x10, 0x00,
0x00, 0x00, 0x00, 0x0c, 0x00, 0x00, 0x00, 0x00, 0x11, 0x00, 0x00, 0x00,
0x00, 0x00, 0xf0, 0x0c, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00,
0x0c, 0x00, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x00, 0x1f, 0x00,
0x00, 0x00, 0x00, 0x00, 0x10, 0x12, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00,
0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x00,
0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x10, 0x12, 0x00, 0x00, 0x00, 0x04,
0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x11, 0x00, 0x00,
0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x10, 0x0c, 0x00, 0x00,
0x00, 0x04, 0x00, 0x00, 0x00, 0x00, 0x1f, 0x00, 0x00, 0x00, 0x00, 0x0e,
0x00, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 };
flrig-2.0.04/src/images/volts50.xbm 0000664 0001750 0001750 00000004702 14475136651 013722 0000000 0000000 #define volts50_width 205
#define volts50_height 18
static unsigned char volts50_bits[] = {
0xfc,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,
0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0x07,0x54,0x55,0x55,0x55,
0x55,0x55,0x55,0x55,0x55,0x55,0x55,0x55,0x55,0x55,0x55,0x55,0x55,0x55,0x55,
0x55,0x55,0x55,0x55,0x55,0x55,0x05,0x54,0x55,0x55,0x55,0x55,0x55,0x55,0x55,
0x55,0x55,0x55,0x55,0x55,0x55,0x55,0x55,0x55,0x55,0x55,0x55,0x55,0x55,0x55,
0x55,0x55,0x05,0x04,0x10,0x40,0x00,0x01,0x04,0x10,0x40,0x00,0x01,0x04,0x10,
0x40,0x00,0x01,0x04,0x10,0x40,0x00,0x01,0x04,0x10,0x40,0x00,0x01,0x04,0x04,
0x10,0x40,0x00,0x01,0x04,0x10,0x40,0x00,0x01,0x04,0x10,0x40,0x00,0x01,0x04,
0x10,0x40,0x00,0x01,0x04,0x10,0x40,0x00,0x01,0x04,0x04,0x00,0x40,0x00,0x00,
0x04,0x00,0x40,0x00,0x00,0x04,0x00,0x40,0x00,0x00,0x04,0x00,0x40,0x00,0x00,
0x04,0x00,0x40,0x00,0x00,0x04,0x04,0x00,0x00,0x00,0x00,0x00,0x00,0x40,0x00,
0x00,0x04,0x00,0x40,0x00,0x00,0x04,0x00,0x40,0x00,0x00,0x04,0x00,0x40,0x00,
0x00,0x04,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x44,0x00,
0x00,0x00,0x00,0xf1,0x00,0x00,0x00,0x80,0x70,0x00,0x00,0x00,0x80,0xe3,0x00,
0x00,0x00,0x80,0x43,0x00,0x00,0x00,0x00,0x00,0x44,0x46,0x3e,0x03,0x80,0x09,
0x01,0x00,0x00,0xc0,0x88,0x00,0x00,0x00,0x40,0x14,0x01,0x00,0x00,0x40,0x64,
0x00,0x00,0x00,0x00,0x00,0x44,0x49,0x88,0x04,0x40,0x09,0x01,0x00,0x00,0xa0,
0x08,0x01,0x00,0x00,0x40,0x10,0x01,0x00,0x00,0x40,0x40,0x00,0x00,0x00,0x00,
0x00,0x28,0x49,0x88,0x00,0x40,0xf1,0x00,0x00,0x00,0xa0,0x08,0x01,0x00,0x00,
0x40,0x10,0x01,0x00,0x00,0x40,0x40,0x00,0x00,0x00,0x00,0x00,0x28,0x49,0x08,
0x01,0x20,0x09,0x01,0x00,0x00,0x90,0x70,0x01,0x00,0x00,0x80,0x13,0x01,0x00,
0x00,0x80,0x43,0x00,0x00,0x00,0x00,0x00,0x28,0x49,0x08,0x02,0x10,0x09,0x01,
0x00,0x00,0x88,0x00,0x01,0x00,0x00,0x00,0x14,0x01,0x00,0x00,0x00,0x44,0x00,
0x00,0x00,0x00,0x00,0x10,0x49,0x08,0x04,0xf0,0x09,0x01,0x00,0x00,0xf8,0x00,
0x01,0x00,0x00,0x00,0x14,0x01,0x00,0x00,0x00,0x44,0x00,0x00,0x00,0x00,0x00,
0x10,0x4d,0x88,0x04,0x00,0x09,0x01,0x00,0x00,0x80,0x08,0x01,0x00,0x00,0x40,
0x14,0x01,0x00,0x00,0x40,0x44,0x00,0x00,0x00,0x00,0x00,0x10,0xc6,0x09,0x03,
0x00,0xf1,0x00,0x00,0x00,0x80,0xf0,0x00,0x00,0x00,0x80,0xe3,0x00,0x00,0x00,
0x80,0x43,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00 };
flrig-2.0.04/src/images/alc40db.xbm 0000664 0001750 0001750 00000004721 14502041135 013577 0000000 0000000 #define alc40db_width 205
#define alc40db_height 18
static unsigned char alc40db_bits[] = {
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0xe0,0x00,0x00,0x00,0x00,0x00,0x00,0xc8,0x00,0x00,0x00,
0x00,0x00,0x1c,0x03,0x00,0x00,0x00,0x00,0x70,0x0c,0x00,0x00,
0x00,0x00,0x80,0xec,0x20,0x02,0x07,0x00,0x00,0x00,0x2e,0x01,
0x00,0x00,0x00,0x00,0xa2,0x04,0x00,0x00,0x00,0x00,0x88,0x12,
0x00,0x00,0x00,0x00,0xc0,0xf2,0x50,0x82,0x08,0x00,0x00,0x00,
0x28,0x01,0x00,0x00,0x00,0x00,0xa0,0x04,0x00,0x00,0x00,0x00,
0x80,0x12,0x00,0x00,0x00,0x00,0xa0,0xf2,0x50,0x82,0x00,0x00,
0x00,0x00,0x28,0x01,0x00,0x00,0x00,0x00,0xa0,0x04,0x00,0x00,
0x00,0x00,0x80,0x12,0x00,0x00,0x00,0x00,0xa0,0xf2,0x88,0x82,
0x00,0x00,0x00,0x00,0x28,0x01,0x00,0x00,0x00,0x00,0xa0,0x04,
0x00,0x00,0x00,0x00,0xe0,0x12,0x00,0x00,0x00,0x00,0x90,0xf2,
0xf8,0x82,0x00,0x00,0x00,0x00,0x28,0x01,0x00,0x00,0x00,0x00,
0x90,0x04,0x00,0x00,0x00,0x00,0x80,0x12,0x00,0x00,0x00,0x00,
0xf0,0xf3,0x88,0x82,0x00,0x00,0x00,0x00,0x28,0x01,0x00,0x00,
0x00,0x00,0x88,0x04,0x00,0x00,0x00,0x00,0x80,0x12,0x00,0x00,
0x00,0x00,0x80,0xf2,0x88,0x82,0x08,0x00,0x00,0x00,0x28,0x01,
0x00,0x00,0x00,0x00,0x84,0x04,0x00,0x00,0x00,0x00,0x88,0x12,
0x00,0x00,0x00,0x00,0x80,0xf2,0x88,0x3e,0x07,0x00,0x00,0x00,
0xc8,0x00,0x00,0x00,0x00,0x00,0x3e,0x03,0x00,0x00,0x00,0x00,
0x70,0x0c,0x00,0x00,0x00,0x00,0x80,0xec,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xe0,0x04,0x00,
0x00,0x00,0x00,0x00,0x10,0x00,0x00,0x00,0x00,0x00,0x40,0x00,
0x00,0x00,0x00,0x00,0x00,0x01,0x00,0x00,0x00,0x00,0x00,0xe4,
0x04,0x00,0x00,0x08,0x00,0x00,0x10,0x00,0x00,0x20,0x00,0x00,
0x40,0x00,0x00,0x80,0x00,0x00,0x00,0x01,0x00,0x00,0x02,0x00,
0x00,0xe4,0x04,0x00,0x00,0x08,0x00,0x00,0x10,0x00,0x00,0x20,
0x00,0x00,0x40,0x00,0x00,0x80,0x00,0x00,0x00,0x01,0x00,0x00,
0x02,0x00,0x00,0xe4,0x04,0x00,0x00,0x08,0x00,0x00,0x10,0x00,
0x00,0x20,0x00,0x00,0x40,0x00,0x00,0x80,0x00,0x00,0x00,0x01,
0x00,0x00,0x02,0x00,0x00,0xe4,0x84,0x10,0x42,0x08,0x21,0x84,
0x10,0x42,0x08,0x21,0x84,0x10,0x42,0x08,0x21,0x84,0x10,0x42,
0x08,0x21,0x84,0x10,0x42,0x08,0x21,0xe4,0x84,0x10,0x42,0x08,
0x21,0x84,0x10,0x42,0x08,0x21,0x84,0x10,0x42,0x08,0x21,0x84,
0x10,0x42,0x08,0x21,0x84,0x10,0x42,0x08,0x21,0xe4,0xfc,0xff,
0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,
0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xe7};
flrig-2.0.04/src/images/idd25.xbm 0000664 0001750 0001750 00000004674 14475136651 013325 0000000 0000000 #define idd25_width 205
#define idd25_height 18
static unsigned char idd25_bits[] = {
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x74,0x1c,0x00,0x00,
0x00,0x1e,0x00,0x00,0x00,0x00,0x39,0x00,0x00,0x00,0x00,0x79,0x00,0x00,0x00,
0xc0,0x71,0x00,0x00,0x00,0x00,0x00,0x94,0x24,0x00,0x00,0x00,0x01,0x00,0x00,
0x00,0xc0,0x45,0x00,0x00,0x00,0xc0,0x05,0x00,0x00,0x00,0x20,0x8a,0x00,0x00,
0x00,0x00,0x00,0x14,0x45,0x00,0x00,0x00,0x01,0x00,0x00,0x00,0x00,0x45,0x00,
0x00,0x00,0x00,0x05,0x00,0x00,0x00,0x00,0x8a,0x00,0x00,0x00,0x00,0x00,0x14,
0x45,0x00,0x00,0x00,0x0f,0x00,0x00,0x00,0x00,0x45,0x00,0x00,0x00,0x00,0x3d,
0x00,0x00,0x00,0x00,0x8a,0x00,0x00,0x00,0x00,0x00,0x14,0x45,0x00,0x00,0x00,
0x11,0x00,0x00,0x00,0x00,0x45,0x00,0x00,0x00,0x00,0x45,0x00,0x00,0x00,0x00,
0x89,0x00,0x00,0x00,0x00,0x00,0x14,0x45,0x00,0x00,0x00,0x20,0x00,0x00,0x00,
0x00,0x45,0x00,0x00,0x00,0x00,0x81,0x00,0x00,0x00,0x80,0x88,0x00,0x00,0x00,
0x00,0x00,0x14,0x45,0x00,0x00,0x00,0x20,0x00,0x00,0x00,0x00,0x45,0x00,0x00,
0x00,0x00,0x81,0x00,0x00,0x00,0x40,0x88,0x00,0x00,0x00,0x00,0x00,0x94,0x24,
0x00,0x00,0x00,0x11,0x00,0x00,0x00,0x00,0x45,0x00,0x00,0x00,0x00,0x45,0x00,
0x00,0x00,0x20,0x88,0x00,0x00,0x00,0x00,0x00,0x74,0x1c,0x00,0x00,0x00,0x0e,
0x00,0x00,0x00,0x00,0x39,0x00,0x00,0x00,0x00,0x39,0x00,0x00,0x00,0xe0,0x73,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x04,0x00,0x00,0x00,0x00,0x04,0x00,0x00,0x00,0x00,0x04,0x00,0x00,0x00,
0x00,0x04,0x00,0x00,0x00,0x00,0x04,0x00,0x00,0x00,0x00,0x04,0x04,0x00,0x00,
0x00,0x00,0x04,0x00,0x00,0x00,0x00,0x04,0x00,0x00,0x00,0x00,0x04,0x00,0x00,
0x00,0x00,0x04,0x00,0x00,0x00,0x00,0x04,0x04,0x04,0x04,0x04,0x04,0x04,0x04,
0x04,0x04,0x04,0x04,0x04,0x04,0x04,0x04,0x04,0x04,0x04,0x04,0x04,0x04,0x04,
0x04,0x04,0x04,0x04,0x04,0x04,0x04,0x04,0x04,0x04,0x04,0x04,0x04,0x04,0x04,
0x04,0x04,0x04,0x04,0x04,0x04,0x04,0x04,0x04,0x04,0x04,0x04,0x04,0x04,0x04,
0x44,0x44,0x44,0x44,0x44,0x44,0x44,0x44,0x44,0x44,0x44,0x44,0x44,0x44,0x44,
0x44,0x44,0x44,0x44,0x44,0x44,0x44,0x44,0x44,0x44,0x04,0x44,0x44,0x44,0x44,
0x44,0x44,0x44,0x44,0x44,0x44,0x44,0x44,0x44,0x44,0x44,0x44,0x44,0x44,0x44,
0x44,0x44,0x44,0x44,0x44,0x44,0x04,0xfc,0xff,0xff,0xff,0xff,0xff,0xff,0xff,
0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,
0xff,0xff,0x07 };
flrig-2.0.04/src/images/S60.xbm 0000664 0001750 0001750 00000005677 14475136651 012772 0000000 0000000 #define S60_width 205
#define S60_height 18
static unsigned char S60_bits[] = {
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0xc3, 0x01, 0x00, 0x00, 0x1c, 0x0e,
0x00, 0x00, 0x0e, 0x07, 0x00, 0x00, 0x1c, 0x0e, 0x00, 0x00, 0x00, 0x71,
0x00, 0x00, 0x1c, 0x07, 0x00, 0x00, 0x00, 0x40, 0x24, 0x02, 0x00, 0x00,
0x22, 0x11, 0x00, 0x00, 0x91, 0x08, 0x00, 0x00, 0x22, 0x11, 0x00, 0x00,
0x80, 0x89, 0x00, 0x00, 0xa2, 0x08, 0x00, 0x00, 0x00, 0x40, 0x00, 0x02,
0x00, 0x00, 0x02, 0x01, 0x00, 0x00, 0x81, 0x08, 0x00, 0x00, 0x20, 0x11,
0x00, 0x00, 0x80, 0x89, 0x00, 0x20, 0x82, 0x08, 0x00, 0x00, 0x00, 0x40,
0x00, 0x02, 0x00, 0x00, 0x02, 0x01, 0x00, 0x00, 0x81, 0x08, 0x00, 0x40,
0x20, 0x11, 0x00, 0x00, 0x42, 0x89, 0x00, 0x20, 0x82, 0x08, 0x00, 0x00,
0x00, 0x80, 0x83, 0x01, 0x00, 0x00, 0x1c, 0x0f, 0x00, 0x00, 0x0e, 0x0f,
0x00, 0x40, 0x10, 0x11, 0x00, 0x00, 0x42, 0x89, 0x00, 0xf8, 0x9e, 0x08,
0x00, 0x00, 0x00, 0x00, 0x04, 0x02, 0x00, 0x00, 0x20, 0x11, 0x00, 0x00,
0x10, 0x08, 0x00, 0xf0, 0x09, 0x11, 0x00, 0x80, 0x2f, 0x89, 0x00, 0x20,
0xa2, 0x08, 0x00, 0x00, 0x00, 0x00, 0x04, 0x02, 0x00, 0x00, 0x20, 0x11,
0x00, 0x00, 0x10, 0x08, 0x00, 0x40, 0x04, 0x11, 0x00, 0x00, 0xe2, 0x8b,
0x00, 0x20, 0xa2, 0x08, 0x00, 0x00, 0x00, 0x40, 0x24, 0x02, 0x00, 0x00,
0x22, 0x11, 0x00, 0x00, 0x91, 0x08, 0x00, 0x40, 0x02, 0x11, 0x00, 0x00,
0x02, 0x89, 0x00, 0x00, 0xa2, 0x08, 0x00, 0x00, 0x00, 0x80, 0xc3, 0x01,
0x00, 0x00, 0x1c, 0x0e, 0x00, 0x00, 0x0e, 0x07, 0x00, 0x00, 0x3e, 0x0e,
0x00, 0x00, 0x00, 0x71, 0x00, 0x00, 0x1c, 0x07, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x04, 0x00,
0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x80, 0x00, 0x00, 0x00, 0x40, 0x00,
0x00, 0x00, 0x80, 0x00, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04,
0x04, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x80, 0x00, 0x00, 0x00,
0x40, 0x00, 0x00, 0x00, 0x80, 0x00, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00,
0x00, 0x04, 0x04, 0x20, 0x00, 0x02, 0x10, 0x00, 0x01, 0x08, 0x80, 0x00,
0x02, 0x08, 0x40, 0x00, 0x40, 0x00, 0x80, 0x00, 0x00, 0x01, 0x00, 0x04,
0x00, 0x08, 0x00, 0x04, 0x04, 0x20, 0x00, 0x02, 0x10, 0x00, 0x01, 0x08,
0x80, 0x00, 0x02, 0x08, 0x40, 0x00, 0x40, 0x00, 0x80, 0x00, 0x00, 0x01,
0x00, 0x04, 0x00, 0x08, 0x00, 0x04, 0x04, 0x20, 0x00, 0x02, 0x10, 0x00,
0x01, 0x08, 0x80, 0x00, 0x02, 0x08, 0x40, 0x00, 0x40, 0x00, 0x80, 0x00,
0x00, 0x01, 0x00, 0x04, 0x00, 0x08, 0x00, 0x04, 0x04, 0x20, 0x00, 0x02,
0x10, 0x00, 0x01, 0x08, 0x80, 0x00, 0x02, 0x08, 0x40, 0x00, 0x40, 0x00,
0x80, 0x00, 0x00, 0x01, 0x00, 0x04, 0x00, 0x08, 0x00, 0x04, 0xfc, 0xff,
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x07 };
flrig-2.0.04/src/images/P20.xbm 0000664 0001750 0001750 00000004666 14475136651 012760 0000000 0000000 #define P20_width 205
#define P20_height 18
static unsigned char P20_bits[] = {
0xfc,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,
0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0x07,0x54,0x55,0x55,0x55,
0x55,0x55,0x55,0x55,0x55,0x55,0x55,0x55,0x55,0x55,0x55,0x55,0x55,0x55,0x55,
0x55,0x55,0x55,0x55,0x55,0x55,0x05,0x54,0x55,0x55,0x55,0x55,0x55,0x55,0x55,
0x55,0x55,0x55,0x55,0x55,0x55,0x55,0x55,0x55,0x55,0x55,0x55,0x55,0x55,0x55,
0x55,0x55,0x05,0x04,0x10,0x40,0x00,0x01,0x04,0x10,0x40,0x00,0x01,0x04,0x10,
0x40,0x00,0x01,0x04,0x10,0x40,0x00,0x01,0x04,0x10,0x40,0x00,0x01,0x04,0x04,
0x10,0x40,0x00,0x01,0x04,0x10,0x40,0x00,0x01,0x04,0x10,0x40,0x00,0x01,0x04,
0x10,0x40,0x00,0x01,0x04,0x10,0x40,0x00,0x01,0x04,0x04,0x00,0x40,0x00,0x00,
0x04,0x00,0x40,0x00,0x00,0x04,0x00,0x40,0x00,0x00,0x04,0x00,0x40,0x00,0x00,
0x04,0x00,0x40,0x00,0x00,0x04,0x04,0x00,0x40,0x00,0x00,0x04,0x00,0x40,0x00,
0x00,0x04,0x00,0x40,0x00,0x00,0x04,0x00,0x40,0x00,0x00,0x04,0x00,0x40,0x00,
0x00,0x04,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0xe0,0x00,0x00,0x08,0x00,0xe0,0x00,0x00,0x0e,0x00,0x88,0x03,0x00,0x71,0x00,
0x10,0x04,0x00,0x71,0x00,0x10,0x07,0x00,0x00,0xf0,0x00,0x10,0x01,0x00,0x0c,
0x00,0x10,0x01,0x00,0x11,0x00,0x4e,0x04,0xc0,0x89,0x00,0x1c,0x06,0xc0,0x89,
0x00,0x9c,0x08,0x00,0x00,0x10,0x01,0x00,0x01,0x00,0x0c,0x00,0x10,0x00,0x00,
0x11,0x00,0x48,0x04,0x00,0x81,0x00,0x10,0x06,0x00,0x09,0x00,0x90,0x08,0x00,
0x00,0x10,0x01,0x00,0x01,0x00,0x0a,0x00,0x10,0x00,0x00,0x11,0x00,0x48,0x04,
0x00,0x81,0x00,0x10,0x05,0x00,0x09,0x00,0x90,0x08,0x00,0x00,0x10,0x01,0x80,
0x00,0x00,0x0a,0x00,0xf0,0x00,0x00,0x0e,0x00,0x48,0x04,0x00,0x41,0x00,0x10,
0x05,0x00,0x79,0x00,0x10,0x07,0x00,0x00,0xf0,0x0c,0x40,0x00,0x00,0x09,0x00,
0x10,0x01,0x00,0x11,0x00,0x48,0x04,0x00,0x21,0x00,0x90,0x04,0x00,0x89,0x00,
0x90,0x08,0x00,0x00,0x10,0x12,0x20,0x00,0x00,0x1f,0x00,0x10,0x01,0x00,0x11,
0x00,0x48,0x04,0x00,0x11,0x00,0x90,0x0f,0x00,0x89,0x00,0x90,0x08,0x00,0x00,
0x10,0x12,0x10,0x00,0x00,0x08,0x00,0x10,0x01,0x00,0x11,0x00,0x48,0x04,0x00,
0x09,0x00,0x10,0x04,0x00,0x89,0x00,0x90,0x08,0x00,0x00,0x10,0x0c,0xf0,0x01,
0x00,0x08,0x00,0xe0,0x00,0x00,0x0e,0x00,0x88,0x03,0x00,0xf9,0x00,0x10,0x04,
0x00,0x71,0x00,0x10,0x07,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00 };
flrig-2.0.04/src/images/P10.xbm 0000664 0001750 0001750 00000004666 14475136651 012757 0000000 0000000 #define P10_width 205
#define P10_height 18
static unsigned char P10_bits[] = {
0xfc,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,
0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0x07,0x54,0x55,0x55,0x55,
0x55,0x55,0x55,0x55,0x55,0x55,0x55,0x55,0x55,0x55,0x55,0x55,0x55,0x55,0x55,
0x55,0x55,0x55,0x55,0x55,0x55,0x05,0x54,0x55,0x55,0x55,0x55,0x55,0x55,0x55,
0x55,0x55,0x55,0x55,0x55,0x55,0x55,0x55,0x55,0x55,0x55,0x55,0x55,0x55,0x55,
0x55,0x55,0x05,0x04,0x10,0x40,0x00,0x01,0x04,0x10,0x40,0x00,0x01,0x04,0x10,
0x40,0x00,0x01,0x04,0x10,0x40,0x00,0x01,0x04,0x10,0x40,0x00,0x01,0x04,0x04,
0x10,0x40,0x00,0x01,0x04,0x10,0x40,0x00,0x01,0x04,0x10,0x40,0x00,0x01,0x04,
0x10,0x40,0x00,0x01,0x04,0x10,0x40,0x00,0x01,0x04,0x04,0x00,0x40,0x00,0x00,
0x04,0x00,0x40,0x00,0x00,0x04,0x00,0x40,0x00,0x00,0x04,0x00,0x40,0x00,0x00,
0x04,0x00,0x40,0x00,0x00,0x04,0x04,0x00,0x40,0x00,0x00,0x04,0x00,0x40,0x00,
0x00,0x04,0x00,0x40,0x00,0x00,0x04,0x00,0x40,0x00,0x00,0x04,0x00,0x40,0x00,
0x00,0x04,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x0e,0x00,0x00,0x00,0x00,0x04,0x00,0x00,0x00,0x00,0x0e,0x00,
0x00,0x00,0x00,0x0e,0x00,0x00,0x00,0x00,0x00,0xf0,0x00,0x00,0x00,0x00,0x11,
0x00,0x00,0x00,0x00,0x06,0x00,0x00,0x00,0x00,0x11,0x00,0x00,0x00,0x00,0x11,
0x00,0x00,0x00,0x00,0x00,0x10,0x01,0x00,0x00,0x00,0x10,0x00,0x00,0x00,0x00,
0x06,0x00,0x00,0x00,0x00,0x01,0x00,0x00,0x00,0x00,0x11,0x00,0x00,0x00,0x00,
0x00,0x10,0x01,0x00,0x00,0x00,0x10,0x00,0x00,0x00,0x00,0x05,0x00,0x00,0x00,
0x00,0x01,0x00,0x00,0x00,0x00,0x11,0x00,0x00,0x00,0x00,0x00,0x10,0x01,0x00,
0x00,0x00,0x08,0x00,0x00,0x00,0x00,0x05,0x00,0x00,0x00,0x00,0x1f,0x00,0x00,
0x00,0x00,0x0e,0x00,0x00,0x00,0x00,0x00,0xf0,0x0c,0x00,0x00,0x00,0x04,0x00,
0x00,0x00,0x80,0x04,0x00,0x00,0x00,0x00,0x11,0x00,0x00,0x00,0x00,0x11,0x00,
0x00,0x00,0x00,0x00,0x10,0x12,0x00,0x00,0x00,0x02,0x00,0x00,0x00,0x80,0x0f,
0x00,0x00,0x00,0x00,0x11,0x00,0x00,0x00,0x00,0x11,0x00,0x00,0x00,0x00,0x00,
0x10,0x12,0x00,0x00,0x00,0x01,0x00,0x00,0x00,0x00,0x04,0x00,0x00,0x00,0x00,
0x11,0x00,0x00,0x00,0x00,0x11,0x00,0x00,0x00,0x00,0x00,0x10,0x0c,0x00,0x00,
0x00,0x1f,0x00,0x00,0x00,0x00,0x04,0x00,0x00,0x00,0x00,0x0e,0x00,0x00,0x00,
0x00,0x0e,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00 };
flrig-2.0.04/src/images/P200.xbm 0000664 0001750 0001750 00000005702 14475136651 013030 0000000 0000000 #define P200_width 205
#define P200_height 18
static unsigned char P200_bits[] = {
0xfc, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
0xff, 0x07, 0x54, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55,
0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55,
0x55, 0x55, 0x55, 0x05, 0x54, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55,
0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55,
0x55, 0x55, 0x55, 0x55, 0x55, 0x05, 0x04, 0x10, 0x40, 0x00, 0x01, 0x04,
0x10, 0x40, 0x00, 0x01, 0x04, 0x10, 0x40, 0x00, 0x01, 0x04, 0x10, 0x40,
0x00, 0x01, 0x04, 0x10, 0x40, 0x00, 0x01, 0x04, 0x04, 0x10, 0x40, 0x00,
0x01, 0x04, 0x10, 0x40, 0x00, 0x01, 0x04, 0x10, 0x40, 0x00, 0x01, 0x04,
0x10, 0x40, 0x00, 0x01, 0x04, 0x10, 0x40, 0x00, 0x01, 0x04, 0x04, 0x00,
0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00, 0x04, 0x00, 0x40, 0x00,
0x00, 0x04, 0x00, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00, 0x04,
0x04, 0x00, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00, 0x04, 0x00,
0x40, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00,
0x00, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x71, 0x00, 0x00,
0x00, 0xc0, 0x71, 0x00, 0x00, 0x00, 0x20, 0x8e, 0x03, 0x00, 0x00, 0x20,
0x8e, 0x03, 0x00, 0x00, 0x00, 0x00, 0xf0, 0x00, 0x00, 0x00, 0x80, 0x89,
0x00, 0x00, 0x00, 0x20, 0x8a, 0x00, 0x00, 0x00, 0x38, 0x51, 0x04, 0x00,
0x00, 0x38, 0x51, 0x04, 0x00, 0x00, 0x00, 0x00, 0x10, 0x01, 0x00, 0x00,
0x80, 0x89, 0x00, 0x00, 0x00, 0x20, 0x8a, 0x00, 0x00, 0x00, 0x20, 0x50,
0x04, 0x00, 0x00, 0x20, 0x41, 0x04, 0x00, 0x00, 0x00, 0x00, 0x10, 0x01,
0x00, 0x00, 0x40, 0x89, 0x00, 0x00, 0x00, 0x20, 0x8a, 0x00, 0x00, 0x00,
0x20, 0x50, 0x04, 0x00, 0x00, 0x20, 0x41, 0x04, 0x00, 0x00, 0x00, 0x00,
0x10, 0x01, 0x00, 0x00, 0x40, 0x89, 0x00, 0x00, 0x00, 0xc0, 0x89, 0x00,
0x00, 0x00, 0x20, 0x48, 0x04, 0x00, 0x00, 0x20, 0x4f, 0x04, 0x00, 0x00,
0x00, 0x00, 0xf0, 0x0c, 0x00, 0x00, 0x20, 0x89, 0x00, 0x00, 0x00, 0x20,
0x8a, 0x00, 0x00, 0x00, 0x20, 0x44, 0x04, 0x00, 0x00, 0x20, 0x51, 0x04,
0x00, 0x00, 0x00, 0x00, 0x10, 0x12, 0x00, 0x00, 0xe0, 0x8b, 0x00, 0x00,
0x00, 0x20, 0x8a, 0x00, 0x00, 0x00, 0x20, 0x42, 0x04, 0x00, 0x00, 0x20,
0x51, 0x04, 0x00, 0x00, 0x00, 0x00, 0x10, 0x12, 0x00, 0x00, 0x00, 0x89,
0x00, 0x00, 0x00, 0x20, 0x8a, 0x00, 0x00, 0x00, 0x20, 0x41, 0x04, 0x00,
0x00, 0x20, 0x51, 0x04, 0x00, 0x00, 0x00, 0x00, 0x10, 0x0c, 0x00, 0x00,
0x00, 0x71, 0x00, 0x00, 0x00, 0xc0, 0x71, 0x00, 0x00, 0x00, 0x20, 0x9f,
0x03, 0x00, 0x00, 0x20, 0x8e, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 };
flrig-2.0.04/src/images/P100.xbm 0000664 0001750 0001750 00000005702 14475136651 013027 0000000 0000000 #define P100_width 205
#define P100_height 18
static unsigned char P100_bits[] = {
0xfc, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
0xff, 0x07, 0x54, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55,
0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55,
0x55, 0x55, 0x55, 0x05, 0x54, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55,
0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55,
0x55, 0x55, 0x55, 0x55, 0x55, 0x05, 0x04, 0x10, 0x40, 0x00, 0x01, 0x04,
0x10, 0x40, 0x00, 0x01, 0x04, 0x10, 0x40, 0x00, 0x01, 0x04, 0x10, 0x40,
0x00, 0x01, 0x04, 0x10, 0x40, 0x00, 0x01, 0x04, 0x04, 0x10, 0x40, 0x00,
0x01, 0x04, 0x10, 0x40, 0x00, 0x01, 0x04, 0x10, 0x40, 0x00, 0x01, 0x04,
0x10, 0x40, 0x00, 0x01, 0x04, 0x10, 0x40, 0x00, 0x01, 0x04, 0x04, 0x00,
0x40, 0x00, 0x00, 0x04, 0x00, 0x40, 0x00, 0x00, 0x04, 0x00, 0x40, 0x00,
0x00, 0x04, 0x00, 0x40, 0x00, 0x00, 0x04, 0x00, 0x40, 0x00, 0x00, 0x04,
0x04, 0x00, 0x40, 0x00, 0x00, 0x04, 0x00, 0x40, 0x00, 0x00, 0x04, 0x00,
0x40, 0x00, 0x00, 0x04, 0x00, 0x40, 0x00, 0x00, 0x04, 0x00, 0x40, 0x00,
0x00, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xc0, 0x71, 0x00, 0x00,
0x00, 0x00, 0x71, 0x00, 0x00, 0x00, 0xc0, 0x71, 0x00, 0x00, 0x00, 0xc0,
0x71, 0x00, 0x00, 0x00, 0x00, 0x00, 0xf0, 0x00, 0x00, 0x00, 0x20, 0x8a,
0x00, 0x00, 0x00, 0x80, 0x89, 0x00, 0x00, 0x00, 0x20, 0x8a, 0x00, 0x00,
0x00, 0x20, 0x8a, 0x00, 0x00, 0x00, 0x00, 0x00, 0x10, 0x01, 0x00, 0x00,
0x00, 0x8a, 0x00, 0x00, 0x00, 0x80, 0x89, 0x00, 0x00, 0x00, 0x20, 0x88,
0x00, 0x00, 0x00, 0x20, 0x8a, 0x00, 0x00, 0x00, 0x00, 0x00, 0x10, 0x01,
0x00, 0x00, 0x00, 0x8a, 0x00, 0x00, 0x00, 0x40, 0x89, 0x00, 0x00, 0x00,
0x20, 0x88, 0x00, 0x00, 0x00, 0x20, 0x8a, 0x00, 0x00, 0x00, 0x00, 0x00,
0x10, 0x01, 0x00, 0x00, 0x00, 0x89, 0x00, 0x00, 0x00, 0x40, 0x89, 0x00,
0x00, 0x00, 0xe0, 0x8b, 0x00, 0x00, 0x00, 0xc0, 0x89, 0x00, 0x00, 0x00,
0x00, 0x00, 0xf0, 0x0c, 0x00, 0x00, 0x80, 0x88, 0x00, 0x00, 0x00, 0x20,
0x89, 0x00, 0x00, 0x00, 0x20, 0x8a, 0x00, 0x00, 0x00, 0x20, 0x8a, 0x00,
0x00, 0x00, 0x00, 0x00, 0x10, 0x12, 0x00, 0x00, 0x40, 0x88, 0x00, 0x00,
0x00, 0xe0, 0x8b, 0x00, 0x00, 0x00, 0x20, 0x8a, 0x00, 0x00, 0x00, 0x20,
0x8a, 0x00, 0x00, 0x00, 0x00, 0x00, 0x10, 0x12, 0x00, 0x00, 0x20, 0x88,
0x00, 0x00, 0x00, 0x00, 0x89, 0x00, 0x00, 0x00, 0x20, 0x8a, 0x00, 0x00,
0x00, 0x20, 0x8a, 0x00, 0x00, 0x00, 0x00, 0x00, 0x10, 0x0c, 0x00, 0x00,
0xe0, 0x73, 0x00, 0x00, 0x00, 0x00, 0x71, 0x00, 0x00, 0x00, 0xc0, 0x71,
0x00, 0x00, 0x00, 0xc0, 0x71, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 };
flrig-2.0.04/src/UI/ 0000775 0001750 0001750 00000000000 14511461606 011013 5 0000000 0000000 flrig-2.0.04/src/UI/KX3_ui.cxx 0000664 0001750 0001750 00000005750 14504050407 012563 0000000 0000000 // ----------------------------------------------------------------------------
// Copyright (C) 2014
// David Freese, W1HKJ
//
// This file is part of flrig.
//
// flrig is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation; either version 3 of the License, or
// (at your option) any later version.
//
// flrig is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program. If not, see .
// ----------------------------------------------------------------------------
#include
#include
#include
#include
#include